regular leetcode

Author: KrisYu

017._letter_combinations_of_a_phone_number.md

@@ -0,0 +1,49 @@
+###17. Letter Combinations of a Phone Number
+
+题目:
+
+<https://leetcode.com/problems/letter-combinations-of-a-phone-number/>
+
+
+难度:
+
+Medium
+
+
+
+
+```
+class Solution(object):
+    def letterCombinations(self, digits):
+        """
+        :type digits: str
+        :rtype: List[str]
+        """
+        if digits == "":
+            return []
+            
+        self.res = []
+        self.singleResult('',digits)
+        return self.res
+
+    def singleResult(self, s, digits):
+        if len(digits) == 0:
+            self.res.append(s)
+        else:
+            mapx = {'2':['a','b','c'],
+            '3':['d','e','f'],
+            '4':['g','h','i'],
+            '5':['j','k','l'],
+            '6':['m','n','o'],
+            '7':['p','q','r','s'],
+            '8':['t','u','v'],
+            '9':['w','x','y','z']}
+        
+            curDigit = digits[0]
+            for alpha in mapx[curDigit]:
+                self.singleResult(s + alpha, digits[1:])
+            
+                
+```
+
+

022._generate_parentheses.md

@@ -0,0 +1,88 @@
+###22. Generate Parentheses
+
+题目:
+<https://leetcode.com/problems/generate-parentheses/>
+
+
+难度:
+
+Medium
+
+
+
+
+
+```
+class Solution(object):
+    def generateParenthesis(self,n):
+        """
+        :type n: int
+        :rtype: List[str]
+        """
+        self.res = []
+        self.singleStr('', 0, 0, n)
+        return self.res
+        
+    def singleStr(self, s, left, right, n):
+        if left == n and right == n:
+            self.res.append(s)
+        if left < n:
+            self.singleStr(s + '(',left + 1, right,n)
+        if right < left:
+            self.singleStr(s + ')',left, right + 1, n)
+                
+```
+
+
+非常牛逼的讲解，需要这样的人来给我们讲算法
+
+####以Generate Parentheses为例，backtrack的题到底该怎么去思考？
+
+
+所谓Backtracking都是这样的思路：在当前局面下，你有若干种选择。那么尝试每一种选择。如果已经发现某种选择肯定不行（因为违反了某些限定条件），就返回；如果某种选择试到最后发现是正确解，就将其加入解集
+
+所以你思考递归题时，只要明确三点就行：选择 (Options)，限制 (Restraints)，结束条件 (Termination)。即“ORT原则”（这个是我自己编的）
+
+
+
+
+对于这道题，在任何时刻，你都有两种选择：
+1. 加左括号。
+2. 加右括号。
+
+同时有以下限制：
+1. 如果左括号已经用完了，则不能再加左括号了。
+2. 如果已经出现的右括号和左括号一样多，则不能再加右括号了。因为那样的话新加入的右括号一定无法匹配。
+
+结束条件是：
+左右括号都已经用完。
+
+结束后的正确性：
+左右括号用完以后，一定是正确解。因为1. 左右括号一样多，2. 每个右括号都一定有与之配对的左括号。因此一旦结束就可以加入解集（有时也可能出现结束以后不一定是正确解的情况，这时要多一步判断）。
+
+递归函数传入参数：
+限制和结束条件中有“用完”和“一样多”字样，因此你需要知道左右括号的数目。
+当然你还需要知道当前局面sublist和解集res。
+
+因此，把上面的思路拼起来就是代码：
+
+	if (左右括号都已用完) {
+	  加入解集，返回
+	}
+	//否则开始试各种选择
+	if (还有左括号可以用) {
+	  加一个左括号，继续递归
+	}
+	if (右括号小于左括号) {
+	  加一个右括号，继续递归
+	}
+	
+	
+	
+你帖的那段代码逻辑中加了一条限制：“3. 是否还有右括号剩余。如有才加右括号”。这是合理的。不过对于这道题，如果满足限制1、2时，3一定自动满足，所以可以不判断3。
+
+这题其实是最好的backtracking初学练习之一，因为ORT三者都非常简单明显。你不妨按上述思路再梳理一遍，还有问题的话再说。
+
+
+
+以上文字来自 1point3arces的牛人解答

039._combination_sum.md

@@ -0,0 +1,66 @@
+###39. Combination Sum
+
+题目:
+
+<https://leetcode.com/problems/combination-sum/>
+
+
+难度:
+
+Medium
+
+
+最初的思路：
+
+
+```
+res = []    
+def combSum(candidates, target, valueList):
+    if target == 0:
+        res.append(valueList)
+    for candidate in candidates:
+        if candidate > target:
+            return
+        combSum(candidates, target - candidate, valueList + [candidate] )
+                
+```
+
+
+问题在于，有重复：
+
+```
+combSum([2,3,6,7],7,[])
+
+res
+Out[9]: [[2, 2, 3], [2, 3, 2], [3, 2, 2], [7]]
+```
+
+然后看了hint，除[2, 2, 3] 和 [2, 3, 2]这种重复的方式是， 把candidates先sort，然后用index的方式来处理。
+
+
+所以最终的除重大法如下，根据hint做出：
+
+```
+class Solution(object):
+    def combinationSum(self, candidates, target):
+        """
+        :type candidates: List[int]
+        :type target: int
+        :rtype: List[List[int]]
+        """
+        candidates = list(set(candidates))
+        candidates.sort()
+        self.res = []
+        self.combSum(candidates, target, 0, [])
+        return self.res
+        
+    
+    def combSum(self, candidates, target, start, valueList):
+        length = len(candidates)
+        if target == 0:
+            self.res.append(valueList)
+        for i in range(start, length):
+            if target < candidates[i]:
+                return
+            self.combSum(candidates, target - candidates[i], i, valueList + [candidates[i]])
+```

040._combination_sum_ii.md

@@ -0,0 +1,40 @@
+###40. Combination Sum II
+
+题目:
+
+<https://leetcode.com/problems/combination-sum-ii/>
+
+
+难度:
+
+Medium
+
+
+Combination Sum 已经AC，做了minor change.
+
+```
+class Solution(object):
+    def combinationSum2(self, candidates, target):
+        """
+        :type candidates: List[int]
+        :type target: int
+        :rtype: List[List[int]]
+        """
+        candidates.sort()
+        self.res = []
+        self.combSum(candidates, target, 0, [])
+        return self.res
+        
+    def combSum(self, candidates, target, start, valueList):
+        length = len(candidates)
+        if target == 0:
+            if valueList not in self.res:
+                self.res.append(valueList)
+        if length == 0:
+            return 
+        for i in range(start, length):
+            if target < candidates[i]:
+                return
+            self.combSum(candidates[:i] + candidates[i+1:], target - candidates[i], i, valueList + [candidates[i]])
+        
+```

118._pascal's_triangle.md

@@ -0,0 +1,36 @@
+###118. Pascal's Triangle
+
+题目:
+
+<https://leetcode.com/problems/pascals-triangle/>
+
+
+难度:
+
+Easy
+
+
+高中数学知识，把行数理理清楚就ok
+
+
+```
+class Solution(object):
+    def generate(self, numRows):
+        """
+        :type numRows: int
+        :rtype: List[List[int]]
+        """
+        res = [[1],[1,1]]
+        if numRows < 3:
+            return res[:numRows]
+        for i in range(3, numRows+1):
+            tmp = [1] * i
+            for j in range(1,i-1):
+                tmp[j] = res[i-2][j-1] + res[i-2][j]
+            res.append(tmp)
+        return res
+
+                
+```
+
+

216._combination_sum_iii.md

@@ -0,0 +1,40 @@
+###216. Combination Sum III
+
+题目:
+
+<https://leetcode.com/problems/combination-sum-iii/>
+
+
+难度:
+
+Medium
+
+继续Combination Sum 系列
+
+
+```
+class Solution(object):
+    def combinationSum3(self, k, n):
+        """
+        :type k: int
+        :type n: int
+        :rtype: List[List[int]]
+        """
+        candidates = [1,2,3,4,5,6,7,8,9]
+        self.res = []
+        self.combSum(candidates, n, [], k)
+        return self.res
+        
+        
+    def combSum(self,candidates, target, valueList, k):
+        if target == 0 and k == 0:
+            self.res.append(valueList)
+        length = len(candidates)
+        if length == 0 or k < 0 :
+            return 
+        for i in range(length):
+            if candidates[i] > target:
+                return
+            self.combSum(candidates[i+1:], target - candidates[i], valueList + [candidates[i]], k-1)
+            
+```

backtracking思路.md

@@ -0,0 +1,50 @@
+##以Generate Parentheses为例，backtrack的题到底该怎么去思考？
+
+
+所谓Backtracking都是这样的思路：在当前局面下，你有若干种选择。那么尝试每一种选择。如果已经发现某种选择肯定不行（因为违反了某些限定条件），就返回；如果某种选择试到最后发现是正确解，就将其加入解集
+
+所以你思考递归题时，只要明确三点就行：选择 (Options)，限制 (Restraints)，结束条件 (Termination)。即“ORT原则”（这个是我自己编的）
+
+
+
+
+对于这道题，在任何时刻，你都有两种选择：
+1. 加左括号。
+2. 加右括号。
+
+同时有以下限制：
+1. 如果左括号已经用完了，则不能再加左括号了。
+2. 如果已经出现的右括号和左括号一样多，则不能再加右括号了。因为那样的话新加入的右括号一定无法匹配。
+
+结束条件是：
+左右括号都已经用完。
+
+结束后的正确性：
+左右括号用完以后，一定是正确解。因为1. 左右括号一样多，2. 每个右括号都一定有与之配对的左括号。因此一旦结束就可以加入解集（有时也可能出现结束以后不一定是正确解的情况，这时要多一步判断）。
+
+递归函数传入参数：
+限制和结束条件中有“用完”和“一样多”字样，因此你需要知道左右括号的数目。
+当然你还需要知道当前局面sublist和解集res。
+
+因此，把上面的思路拼起来就是代码：
+
+	if (左右括号都已用完) {
+	  加入解集，返回
+	}
+	//否则开始试各种选择
+	if (还有左括号可以用) {
+	  加一个左括号，继续递归
+	}
+	if (右括号小于左括号) {
+	  加一个右括号，继续递归
+	}
+	
+	
+	
+你帖的那段代码逻辑中加了一条限制：“3. 是否还有右括号剩余。如有才加右括号”。这是合理的。不过对于这道题，如果满足限制1、2时，3一定自动满足，所以可以不判断3。
+
+这题其实是最好的backtracking初学练习之一，因为ORT三者都非常简单明显。你不妨按上述思路再梳理一遍，还有问题的话再说。
+
+
+
+以上文字来自 1point3arces的牛人解答