Merge branch 'master' of https://github.com/cychiu8/Leetcode

Author: cychiu8

0017 Letter Combinations of a Phone Number/0017 Letter Combinations of a Phone Number.md

@@ -0,0 +1,60 @@
+# 0017. Letter Combinations of a Phone Number
+
+* Difficulty: medium
+* Link: https://leetcode.com/problems/letter-combinations-of-a-phone-number/
+* Topics: Backtracking
+
+# Clarification
+
+1. Check the inputs and outputs
+    - INPUT: string
+    - OUTPUT: List[String]
+
+# Naive Solution
+
+### Thought Process
+
+- 建立數字對應的 map
+- Backtracking
+    - 停止條件
+        - len(substring) == len(inputstring)
+    - 非停止條件
+        - forloop
+            - 對每個letter backtrack
+- Implement
+    
+    ```python
+    class Solution:
+        def letterCombinations(self, digits: str) -> List[str]:
+            digit_map = {
+                "2" : "abc",
+                "3":"def",
+                "4":"ghi",
+                "5":"jkl",
+                "6":"mno",
+                "7":"pqrs",
+                "8":"tuv",
+                "9":"wxyz"
+            }
+            if len(digits) == 0:
+                return []
+            chars = list(digits)
+            result = []
+            def backtrack(substr, res):
+                if len(substr) == len(digits):
+                    return result.append(substr)
+                for i in range(len(res)):
+                    letters = list(digit_map.get(res[i]))
+                    for letter in letters:
+                        backtrack(substr+letter, res[i+1:])
+            
+            backtrack("", chars)
+            return result
+    ```
+    
+
+### Complexity
+
+- Time complexity:
+- Space complexity: $O(N)$
+    - N: len(digits)

0131 Palindrome Partitioning/0131 Palindrome Partitioning.md

@@ -0,0 +1,119 @@
+# 0131. Palindrome Partitioning
+
+* Difficulty: medium
+* Link: https://leetcode.com/problems/palindrome-partitioning/
+* Topics: Backtracking
+
+# Clarification
+
+1. Check the inputs and outputs
+    - INPUT: String
+    - OUTPUT: List[List[String]]
+
+# Naive Solution
+
+### Thought Process
+
+- 停止條件
+    - len(res) == 0
+- 非停止條件
+    - substr = res[:i+1]
+    - if substr is palindrome
+        - backtrack
+            - subset = subset + substr
+            - res = res[i+1:]
+    
+    ![Untitled](./Untitled.png)
+    
+    ![Untitled](./Untitled%201.png)
+    
+- Implement
+    
+    ```python
+    class Solution:
+        def partition(self, s: str) -> List[List[str]]:
+            result = []
+            chars = list(s)
+            def isPalindrome(substr):
+                if len(substr) == 1:
+                    return True
+                forward_idx = 0
+                backward_idx = len(substr) - 1
+                while forward_idx < backward_idx:
+                    if substr[forward_idx] != substr[backward_idx]:
+                        return False
+                    forward_idx += 1
+                    backward_idx -=1
+                return True
+                        
+            def backtrack(subset, res):
+                if len(res) == 0:
+                    return result.append(subset)
+                for idx in range(len(res)):
+                    substr = "".join(res[:idx+1])
+                    if isPalindrome(substr):
+                        backtrack(subset + [substr], res[idx+1:])
+                
+            backtrack([],chars)
+            return result
+    ```
+    
+    - 額外需準備的空間：string 長度的空間
+
+### Complexity
+
+- Time complexity: $O(N^N)$ ?!!!
+    
+    ![Untitled](./Untitled%202.png)
+    
+    - 每個 backtrack 需要呼叫 len(res) 次 的 backtrack
+    - N * (res - 1 次 backtrack)
+        
+        ![Untitled](./Untitled%203.png)
+        
+        ```python
+        len of input string = 3
+        call backtrack = 6
+        loop time = 7
+        
+        ==== backtrack ==== 1
+        []
+        ['a', 'a', 'b']
+        ---- forloop -- 1 -- idx:0 ---- a
+        ==== backtrack ==== 2
+        ['a']
+        ['a', 'b']
+        ---- forloop -- 2 -- idx:0 ---- a
+        ==== backtrack ==== 3
+        ['a', 'a']
+        ['b']
+        ---- forloop -- 3 -- idx:0 ---- b
+        ==== backtrack ==== 4
+        ['a', 'a', 'b']
+        []
+        ---- forloop -- 4 -- idx:1 ---- ab
+        ---- forloop -- 5 -- idx:1 ---- aa
+        ==== backtrack ==== 5
+        ['aa']
+        ['b']
+        ---- forloop -- 6 -- idx:0 ---- b
+        ==== backtrack ==== 6
+        ['aa', 'b']
+        []
+        ---- forloop -- 7 -- idx:2 ---- aab
+        ```
+        
+- Space complexity: $O(N)$
+    - N : len(input string)
+
+### Problems & Improvement
+
+- isPalindrome 的 function
+    - [::-1] 順序相反操作
+        - substr[::-1] 把整個 string 反過來
+        
+        ```python
+        
+        def isPalindrome(substr):
+                    return substr == substr[::-1]
+        ```

0131 Palindrome Partitioning/Untitled 1.png

@@ -0,0 +1,53 @@
+# 0704. Binary Search
+
+* Difficulty: easy
+* Link: https://leetcode.com/problems/binary-search/
+* Topics: Binary-Search
+
+# Clarification
+
+1. Check the inputs and outputs
+    - INPUT: List[int]
+    - OUTPUT: index of list
+2. Check the main goal
+    - the list is sorted
+    - time complexity in O(log n)
+
+# Naive Solution
+
+### Thought Process
+
+- 建立兩個指標
+    - left pointer: 陣列開頭的位置、值的下限)
+    - right pointer: 陣列結束的位置、值的上限
+1. 找中間指標對應的值
+    - = target ⇒ return
+    - < target ⇒ 調高下限 left pointer ++
+    - > target ⇒ 調低上限 right pointer - -
+- Implement
+    
+    ```python
+    class Solution:
+        def search(self, nums: List[int], target: int) -> int:
+            left = 0
+            right = len(nums) - 1
+            while left <= right:
+                mid = int((left + right) / 2)
+                if nums[mid] == target:
+                    return mid
+                if nums[mid] < target:
+                    left += 1
+                elif nums[mid] > target:
+                    right -= 1
+            return -1
+    ```
+    
+
+### Complexity
+
+- Time complexity: O(log n)
+- Space complexity: O(1)
+
+# Reference
+
+- ****[初學者學演算法｜從時間複雜度認識常見演算法](https://medium.com/appworks-school/%E5%88%9D%E5%AD%B8%E8%80%85%E5%AD%B8%E6%BC%94%E7%AE%97%E6%B3%95-%E5%BE%9E%E6%99%82%E9%96%93%E8%A4%87%E9%9B%9C%E5%BA%A6%E8%AA%8D%E8%AD%98%E5%B8%B8%E8%A6%8B%E6%BC%94%E7%AE%97%E6%B3%95-%E4%B8%80-b46fece65ba5)****