Merge branch 'master' into greedy02

Author: youngyangyang04

problems/0001.两数之和.md

@@ -7,7 +7,7 @@
 
 ## 1. 两数之和
 
-[力扣题目链接](https://leetcode-cn.com/problems/two-sum/)
+[力扣题目链接](https://leetcode.cn/problems/two-sum/)
 
 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
 
@@ -317,6 +317,20 @@ public class Solution {
 }
 ```
 
+Dart:
+```dart
+List<int> twoSum(List<int> nums, int target) {  
+    var tmp = [];
+    for (var i = 0; i < nums.length; i++) {
+        var rest = target - nums[i];
+        if(tmp.contains(rest)){
+            return [tmp.indexOf(rest), i];
+        }
+        tmp.add(nums[i]);
+    }
+    return [0 , 0];
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0005.最长回文子串.md

@@ -8,7 +8,7 @@
 
 # 5.最长回文子串
 
-[力扣题目链接](https://leetcode-cn.com/problems/longest-palindromic-substring/)
+[力扣题目链接](https://leetcode.cn/problems/longest-palindromic-substring/)
 
 给你一个字符串 s，找到 s 中最长的回文子串。
 

problems/0015.三数之和.md

@@ -10,7 +10,7 @@
 
 # 第15题. 三数之和
 
-[力扣题目链接](https://leetcode-cn.com/problems/3sum/)
+[力扣题目链接](https://leetcode.cn/problems/3sum/)
 
 给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
 
@@ -95,7 +95,7 @@ public:
 
 拿这个nums数组来举例，首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。
 
-依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于  a = nums[i] b = nums[left]  c = nums[right]。
+依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于  a = nums[i]，b = nums[left]，c = nums[right]。
 
 接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right] > 0  就说明 此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。
 
@@ -345,6 +345,76 @@ var threeSum = function(nums) {
     return res
 };
 ```
+
+解法二：nSum通用解法。递归
+
+```js
+/**
+ *  nsum通用解法，支持2sum，3sum，4sum...等等
+ *  时间复杂度分析：
+ *  1. n = 2时，时间复杂度O(NlogN)，排序所消耗的时间。、
+ *  2. n > 2时，时间复杂度为O(N^n-1)，即N的n-1次方，至少是2次方，此时可省略排序所消耗的时间。举例：3sum为O(n^2)，4sum为O(n^3)
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+    // nsum通用解法核心方法
+    function nSumTarget(nums, n, start, target) {
+        // 前提：nums要先排序好
+        let res = [];
+        if (n === 2) {
+            res = towSumTarget(nums, start, target);
+        } else {
+            for (let i = start; i < nums.length; i++) {
+                // 递归求(n - 1)sum
+                let subRes = nSumTarget(
+                    nums,
+                    n - 1,
+                    i + 1,
+                    target - nums[i]
+                );
+                for (let j = 0; j < subRes.length; j++) {
+                    res.push([nums[i], ...subRes[j]]);
+                }
+                // 跳过相同元素
+                while (nums[i] === nums[i + 1]) i++;
+            }
+        }
+        return res;
+    }
+
+    function towSumTarget(nums, start, target) {
+        // 前提：nums要先排序好
+        let res = [];
+        let len = nums.length;
+        let left = start;
+        let right = len - 1;
+        while (left < right) {
+            let sum = nums[left] + nums[right];
+            if (sum < target) {
+                while (nums[left] === nums[left + 1]) left++;
+                left++;
+            } else if (sum > target) {
+                while (nums[right] === nums[right - 1]) right--;
+                right--;
+            } else {
+                // 相等
+                res.push([nums[left], nums[right]]);
+                // 跳过相同元素
+                while (nums[left] === nums[left + 1]) left++;
+                while (nums[right] === nums[right - 1]) right--;
+                left++;
+                right--;
+            }
+        }
+        return res;
+    }
+    nums.sort((a, b) => a - b);
+    // n = 3，此时求3sum之和
+    return nSumTarget(nums, 3, 0, 0);
+};
+```
+
 TypeScript:
 
 ```typescript
@@ -484,6 +554,71 @@ func threeSum(_ nums: [Int]) -> [[Int]] {
 }
 ```
 
+Rust:
+```Rust
+// 哈希解法
+use std::collections::HashSet;
+impl Solution {
+    pub fn three_sum(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut result: Vec<Vec<i32>> = Vec::new();
+        let mut nums = nums;
+        nums.sort();
+        let len = nums.len();
+        for i in 0..len {
+            if nums[i] > 0 { break; }
+            if i > 0 && nums[i] == nums[i - 1] { continue; }
+            let mut set = HashSet::new();
+            for j in (i + 1)..len {
+                if j > i + 2 && nums[j] == nums[j - 1] && nums[j] == nums[j - 2] { continue; }
+                let c = 0 - (nums[i] + nums[j]);
+                if set.contains(&c) {
+                    result.push(vec![nums[i], nums[j], c]);
+                    set.remove(&c);
+                } else { set.insert(nums[j]); }
+            }
+        }
+        result
+    }
+}
+```
+
+```Rust
+// 双指针法
+use std::collections::HashSet;
+impl Solution {
+    pub fn three_sum(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut result: Vec<Vec<i32>> = Vec::new();
+        let mut nums = nums;
+        nums.sort();
+        let len = nums.len();
+        for i in 0..len {
+            if nums[i] > 0 { return result; }
+            if i > 0 && nums[i] == nums[i - 1] { continue; }
+            let (mut left, mut right) = (i + 1, len - 1);
+            while left < right {
+                if nums[i] + nums[left] + nums[right] > 0 {
+                    right -= 1;
+                    // 去重
+                    while left < right && nums[right] == nums[right + 1] { right -= 1; }
+                } else if nums[i] + nums[left] + nums[right] < 0 {
+                    left += 1;
+                    // 去重
+                    while left < right && nums[left] == nums[left - 1] { left += 1; }
+                } else {
+                    result.push(vec![nums[i], nums[left], nums[right]]);
+                    // 去重
+                    right -= 1;
+                    left += 1;
+                    while left < right && nums[right] == nums[right + 1] { right -= 1; }
+                    while left < right && nums[left] == nums[left - 1] { left += 1; }
+                }
+            }
+        }
+        result
+    }
+}
+```
+
 C:
 ```C
 //qsort辅助cmp函数

problems/0017.电话号码的字母组合.md

@@ -7,7 +7,7 @@
 
 # 17.电话号码的字母组合
 
-[力扣题目链接](https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/)
+[力扣题目链接](https://leetcode.cn/problems/letter-combinations-of-a-phone-number/)
 
 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。
 
@@ -454,6 +454,49 @@ function letterCombinations(digits: string): string[] {
 };
 ```
 
+## Rust
+
+```Rust
+impl Solution {
+    fn backtracking(result: &mut Vec<String>, s: &mut String, map: &[&str; 10], digits: &String, index: usize)  {
+        let len = digits.len();
+        if len == index {
+            result.push(s.to_string());
+            return;
+        }
+        // 在保证不会越界的情况下使用unwrap()将Some()中的值提取出来
+        let digit= digits.chars().nth(index).unwrap().to_digit(10).unwrap() as usize;
+        let letters = map[digit];
+        for i in letters.chars() {
+            s.push(i);
+            Self::backtracking(result, s, &map, &digits, index+1);
+            s.pop();
+        }
+    }
+    pub fn letter_combinations(digits: String) -> Vec<String> {
+        if digits.len() == 0 {
+            return vec![];
+        }
+        const MAP: [&str; 10] = [
+        "",
+        "",
+        "abc",
+        "def",
+        "ghi",
+        "jkl",
+        "mno",
+        "pqrs",
+        "tuv",
+        "wxyz"
+        ];
+        let mut result: Vec<String> = Vec::new();
+        let mut s: String = String::new();
+        Self::backtracking(&mut result, &mut s, &MAP, &digits, 0);
+        result
+    }
+}
+```
+
 ## C
 
 ```c
@@ -557,6 +600,37 @@ func letterCombinations(_ digits: String) -> [String] {
 }
 ```
 
+## Scala:
+
+```scala
+object Solution {
+  import scala.collection.mutable
+  def letterCombinations(digits: String): List[String] = {
+    var result = mutable.ListBuffer[String]()
+    if(digits == "") return result.toList // 如果参数为空，返回空结果集的List形式
+    var path = mutable.ListBuffer[Char]()
+    // 数字和字符的映射关系
+    val map = Array[String]("", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz")
+
+    def backtracking(index: Int): Unit = {
+      if (index == digits.size) {
+        result.append(path.mkString)  // mkString语法：将数组类型直接转换为字符串
+        return
+      }
+      var digit = digits(index) - '0' // 这里使用toInt会报错！必须 -'0'
+      for (i <- 0 until map(digit).size) {
+        path.append(map(digit)(i))
+        backtracking(index + 1)
+        path = path.take(path.size - 1)
+      }
+    }
+    
+    backtracking(0)
+    result.toList
+  }
+}
+```
+
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0018.四数之和.md

@@ -10,7 +10,7 @@
 
 # 第18题. 四数之和
 
-[力扣题目链接](https://leetcode-cn.com/problems/4sum/)
+[力扣题目链接](https://leetcode.cn/problems/4sum/)
 
 题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
 
@@ -140,6 +140,11 @@ class Solution {
 
         for (int i = 0; i < nums.length; i++) {
 
+            // nums[i] > target 直接返回, 剪枝操作
+            if (nums[i] > 0 && nums[i] > target) {
+                return result;
+            }
+
             if (i > 0 && nums[i - 1] == nums[i]) {
                 continue;
             }
@@ -153,7 +158,7 @@ class Solution {
                 int left = j + 1;
                 int right = nums.length - 1;
                 while (right > left) {
-                    int sum = nums[i] + nums[j] + nums[left] + nums[right];
+                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                     if (sum > target) {
                         right--;
                     } else if (sum < target) {
@@ -522,6 +527,51 @@ public class Solution
     }
 }
 ```
+
+Rust:
+```Rust
+impl Solution {
+    pub fn four_sum(nums: Vec<i32>, target: i32) -> Vec<Vec<i32>> {
+        let mut result: Vec<Vec<i32>> = Vec::new();
+        let mut nums = nums;
+        nums.sort();
+        let len = nums.len();
+        for k in 0..len {
+            // 剪枝
+            if nums[k] > target && (nums[k] > 0 || target > 0) { break; }
+            // 去重
+            if k > 0 && nums[k] == nums[k - 1] { continue; }
+            for i in (k + 1)..len {
+                // 剪枝
+                if nums[k] + nums[i] > target && (nums[k] + nums[i] >= 0 || target >= 0) { break; }
+                // 去重
+                if i > k + 1 && nums[i] == nums[i - 1] { continue; }
+                let (mut left, mut right) = (i + 1, len - 1);
+                while left < right {
+                    if nums[k] + nums[i] > target - (nums[left] + nums[right]) {
+                        right -= 1;
+                        // 去重
+                        while left < right && nums[right] == nums[right + 1] { right -= 1; }
+                    } else if nums[k] + nums[i] < target - (nums[left] + nums[right]) {
+                        left += 1;
+                        // 去重
+                        while left < right && nums[left] == nums[left - 1] { left += 1; }
+                    } else {
+                        result.push(vec![nums[k], nums[i], nums[left], nums[right]]);
+                        // 去重
+                        while left < right && nums[right] == nums[right - 1] { right -= 1; }
+                        while left < right && nums[left] == nums[left + 1] { left += 1; }
+                        left += 1;
+                        right -= 1;
+                    }
+                }
+            }
+        }
+        result
+    }
+}
+```
+
 Scala:
 ```scala
 object Solution {