Merge branch 'dev' of github.com:resyon/leetcode-master into dev

Author: resyon

problems/0015.三数之和.md

@@ -336,6 +336,23 @@ var threeSum = function(nums) {
 ```
 
 
+ruby:
+```ruby
+def is_valid(strs)
+    symbol_map = {')' => '(', '}' => '{', ']' => '['}
+    stack = []
+    strs.size.times {|i|
+        c = strs[i]
+        if symbol_map.has_key?(c)
+            top_e = stack.shift
+            return false if symbol_map[c] != top_e
+        else
+            stack.unshift(c)
+        end
+    }
+    stack.empty?
+end
+```
 
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)

problems/0019.删除链表的倒数第N个节点.md

@@ -112,6 +112,30 @@ class Solution {
     }
 }
 ```
+
+Python:
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
+        head_dummy = ListNode()
+        head_dummy.next = head
+
+        slow, fast = head_dummy, head_dummy
+        while(n!=0): #fast先往前走n步
+            fast = fast.next
+            n -= 1
+        while(fast.next!=None):
+            slow = slow.next
+            fast = fast.next
+        #fast 走到结尾后，slow的下一个节点为倒数第N个节点
+        slow.next = slow.next.next #删除
+        return head_dummy.next
+```
 Go:
 ```Go
 /**

problems/0027.移除元素.md

@@ -186,6 +186,20 @@ var removeElement = (nums, val) => {
 };
 ```
 
+Ruby:
+```ruby
+def remove_element(nums, val)
+    i = 0
+    nums.each_index do |j| 
+        if nums[j] != val
+            nums[i] = nums[j]
+            i+=1
+        end
+    end
+    i
+end
+```
+
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)

problems/0039.组合总和.md

@@ -237,34 +237,28 @@ public:
 
 Java：
 ```Java
+// 剪枝优化
 class Solution {
-    List<List<Integer>> lists = new ArrayList<>();
-    Deque<Integer> deque = new LinkedList<>();
-
-    public List<List<Integer>> combinationSum3(int k, int n) {
-        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
-        backTracking(arr, n, k, 0);
-        return lists;
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> res = new ArrayList<>();
+        Arrays.sort(candidates); // 先进行排序
+        backtracking(res, new ArrayList<>(), candidates, target, 0, 0);
+        return res;
     }
 
-    public void backTracking(int[] arr, int n, int k, int startIndex) {
-        //如果 n 小于0，没必要继续本次递归，已经不符合要求了
-        if (n < 0) {
-            return;
-        }
-        if (deque.size() == k) {
-            if (n == 0) {
-                lists.add(new ArrayList(deque));
-            }
+    public void backtracking(List<List<Integer>> res, List<Integer> path, int[] candidates, int target, int sum, int idx) {
+        // 找到了数字和为 target 的组合
+        if (sum == target) {
+            res.add(new ArrayList<>(path));
             return;
         }
-        for (int i = startIndex; i < arr.length - (k - deque.size()) + 1; i++) {
-            deque.push(arr[i]);
-            //减去当前元素
-            n -= arr[i];
-            backTracking(arr, n, k, i + 1);
-            //恢复n
-            n += deque.pop();
+
+        for (int i = idx; i < candidates.length; i++) {
+            // 如果 sum + candidates[i] > target 就终止遍历
+            if (sum + candidates[i] > target) break;
+            path.add(candidates[i]);
+            backtracking(res, path, candidates, target, sum + candidates[i], i);
+            path.remove(path.size() - 1); // 回溯，移除路径 path 最后一个元素
         }
     }
 }

problems/0046.全排列.md

@@ -182,7 +182,45 @@ class Solution {
 ```
 
 Python：
+```python3
+class Solution:
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        res = []  #存放符合条件结果的集合
+        path = []  #用来存放符合条件的结果
+        used = []  #用来存放已经用过的数字
+        def backtrack(nums,used):
+            if len(path) == len(nums):
+                return res.append(path[:])  #此时说明找到了一组
+            for i in range(0,len(nums)):
+                if nums[i] in used:
+                    continue  #used里已经收录的元素，直接跳过
+                path.append(nums[i])
+                used.append(nums[i])
+                backtrack(nums,used)
+                used.pop()
+                path.pop()
+        backtrack(nums,used)
+        return res
+```
 
+Python（优化，不用used数组）：
+```python3
+class Solution:
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        res = []  #存放符合条件结果的集合
+        path = []  #用来存放符合条件的结果
+        def backtrack(nums):
+            if len(path) == len(nums):
+                return res.append(path[:])  #此时说明找到了一组
+            for i in range(0,len(nums)):
+                if nums[i] in path:  #path里已经收录的元素，直接跳过
+                    continue
+                path.append(nums[i])
+                backtrack(nums)  #递归
+                path.pop()  #回溯
+        backtrack(nums)
+        return res
+```
 
 Go：
 ```Go

problems/0055.跳跃游戏.md

@@ -141,7 +141,20 @@ func canJUmp(nums []int) bool {
 }
 ```
 
-
+Javascript:
+```Javascript
+var canJump = function(nums) {
+    if(nums.length === 1) return true
+    let cover = 0
+    for(let i = 0; i <= cover; i++) {
+        cover = Math.max(cover, i + nums[i])
+        if(cover >= nums.length - 1) {
+            return true
+        }
+    }
+    return false
+};
+```
 
 
 -----------------------

problems/0078.子集.md

@@ -205,7 +205,20 @@ class Solution {
 ```
 
 Python：
-
+```python3
+class Solution:
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+        res = []  
+        path = []  
+        def backtrack(nums,startIndex):
+            res.append(path[:])  #收集子集，要放在终止添加的上面，否则会漏掉自己
+            for i in range(startIndex,len(nums)):  #当startIndex已经大于数组的长度了，就终止了，for循环本来也结束了，所以不需要终止条件
+                path.append(nums[i])
+                backtrack(nums,i+1)  #递归
+                path.pop()  #回溯
+        backtrack(nums,0)
+        return res
+```
 
 Go：
 ```Go

problems/0090.子集II.md

@@ -208,7 +208,23 @@ class Solution {
 ```
 
 Python：
-
+```python3
+class Solution:
+    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
+        res = []  #存放符合条件结果的集合
+        path = []  #用来存放符合条件结果
+        def backtrack(nums,startIndex):
+            res.append(path[:])
+            for i in range(startIndex,len(nums)):
+                if i > startIndex and nums[i] == nums[i - 1]:  #我们要对同一树层使用过的元素进行跳过
+                    continue
+                path.append(nums[i])
+                backtrack(nums,i+1)  #递归
+                path.pop()  #回溯
+        nums = sorted(nums)  #去重需要排序
+        backtrack(nums,0)
+        return res
+```
 
 Go：
 ```Go

problems/0096.不同的二叉搜索树.md

@@ -186,7 +186,16 @@ class Solution {
 ```
 
 Python：
-
+```python
+class Solution:
+    def numTrees(self, n: int) -> int:
+        dp = [0] * (n + 1)
+        dp[0], dp[1] = 1, 1
+        for i in range(2, n + 1):
+            for j in range(1, i + 1):
+                dp[i] += dp[j - 1] * dp[i - j]
+        return dp[-1]
+```
 
 Go：
 ```Go