Merge branch 'master' of github.com:youngyangyang04/leetcode-master

Author: youngyangyang04

.DS_Store

@@ -152,6 +152,24 @@ public int[] twoSum(int[] nums, int target) {
     return res;
 }
 ```
+
+```java
+//使用哈希表方法2
+public int[] twoSum(int[] nums, int target) {
+    Map<Integer, Integer> indexMap = new HashMap<>();
+    
+    for(int i = 0; i < nums.length; i++){
+        int balance = target - nums[i];  // 记录当前的目标值的余数
+        if(indexMap.containsKey(balance)){  // 查找当前的map中是否有满足要求的值
+            return new int []{i, indexMap.get(balance)}; //  如果有，返回目标值
+        } else{
+            indexMap.put(nums[i], i); //  如果没有，把访问过的元素和下标加入map中
+        }
+    }
+    return null;
+}
+```
+
 ```java
 //使用双指针
 public int[] twoSum(int[] nums, int target) {

problems/0001.两数之和.md

@@ -262,6 +262,11 @@ class Solution {
             
             for (int j = i + 1; j < nums.length; j++) {
 
+		// nums[i]+nums[j] > target 直接返回, 剪枝操作
+		            if (nums[i]+nums[j] > 0 && nums[i]+nums[j] > target) {
+		                return result;
+		            }
+
                 if (j > i + 1 && nums[j - 1] == nums[j]) {  // 对nums[j]去重
                     continue;
                 }

problems/0018.四数之和.md

@@ -287,6 +287,7 @@ function subsets(nums: number[]): number[][] {
 
 ### Rust
 
+思路一：使用本题的标准解法，递归回溯。
 ```Rust
 impl Solution {
     fn backtracking(result: &mut Vec<Vec<i32>>, path: &mut Vec<i32>, nums: &Vec<i32>, start_index: usize) {
@@ -308,6 +309,30 @@ impl Solution {
     }
 }
 ```
+思路二：使用二进制枚举，n个元素的子集问题一共是$2^n$种情况。如果我们使用一个二进制数字，每一位根据0和1来决定是选取该元素与否，那么一共也是$2^n$的情况，正好可以一一对应，所以我们可以不使用递归，直接利用循环枚举完成子集问题。
+这种方法的优点在于效率高，不需要递归调用，并且代码容易编写。缺点则是过滤某些非法情况时会比递归方法难写一点，不过在子集问题中不存在这个问题。
+```Rust
+impl Solution {
+    pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let n = nums.len();
+        // 预分配2^n空间
+        let mut result = Vec::with_capacity(1 << n);
+        // 二进制枚举，2^n种情况
+        for i in 0..(1 << n) {
+            let mut subset = Vec::new();
+            for j in 0..n {
+                // 枚举该二进制数字的每一位
+                // 如果该位是1，对应位置上的元素加入子集，否则跳过
+                if i & (1 << j) != 0 {
+                    subset.push(nums[j]);
+                }
+            }
+            result.push(subset);
+        }
+        result
+    }
+}
+```
 
 ### C