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

Author: youngyangyang04

problems/0031.下一个排列.md

@@ -178,10 +178,10 @@ class Solution:
 >另一种思路
 ```python
 class Solution:
-  '''
-  抛砖引玉：因题目要求“必须原地修改，只允许使用额外常数空间”，python内置sorted函数以及数组切片+sort()无法使用。  
-  故选择另一种算法暂且提供一种python思路
-  '''
+    '''
+    抛砖引玉：因题目要求“必须原地修改，只允许使用额外常数空间”，python内置sorted函数以及数组切片+sort()无法使用。  
+    故选择另一种算法暂且提供一种python思路
+    '''
     def nextPermutation(self, nums: List[int]) -> None:
         """
         Do not return anything, modify nums in-place instead.
@@ -195,9 +195,9 @@ class Solution:
                         break
                 self.reverse(nums, i, length-1)
                 break
-        else:
-            # 若正常结束循环，则对原数组直接翻转
-            self.reverse(nums, 0, length-1)
+            if n == 1:
+                # 若正常结束循环，则对原数组直接翻转
+                self.reverse(nums, 0, length-1)
 
     def reverse(self, nums: List[int], low: int, high: int) -> None:
         while low < high:

problems/0037.解数独.md

@@ -488,6 +488,52 @@ function solveSudoku(board: string[][]): void {
 };
 ```
 
+### Rust
+
+```Rust
+impl Solution {
+    fn is_valid(row: usize, col: usize, val: char, board: &mut Vec<Vec<char>>) -> bool{
+        for i in 0..9 {
+            if board[row][i] == val { return false; }
+        }
+        for j in 0..9 {
+            if board[j][col] == val {
+                return false;
+            }
+        }
+        let  start_row = (row / 3) * 3;
+        let  start_col = (col / 3) * 3;
+        for i in start_row..(start_row + 3) {
+            for j in start_col..(start_col + 3) {
+                if board[i][j] == val { return false; }
+            }
+        }
+        return true;
+    }
+
+    fn backtracking(board: &mut Vec<Vec<char>>) -> bool{
+        for i in 0..board.len() {
+            for j in 0..board[0].len() {
+                if board[i][j] != '.' { continue; }
+                for k in '1'..='9' {
+                    if Self::is_valid(i, j, k, board) {
+                        board[i][j] = k;
+                        if Self::backtracking(board) { return true; }
+                        board[i][j] = '.';
+                    }
+                }
+                return false;
+            }
+        }
+        return true;
+    }
+
+    pub fn solve_sudoku(board: &mut Vec<Vec<char>>) {
+        Self::backtracking(board);
+    }
+}
+```
+
 ### C 
 
 ```C

problems/0045.跳跃游戏II.md

@@ -305,6 +305,56 @@ object Solution {
 }
 ```
 
+### Rust
+
+```Rust
+//版本一
+impl Solution {
+    fn max(a: i32, b:i32) -> i32 {
+        if a > b { a } else { b }
+    }
+    pub fn jump(nums: Vec<i32>) -> i32 {
+        if nums.len() == 0 { return 0; }
+        let mut cur_distance: i32 = 0;
+        let mut ans: i32 = 0;
+        let mut next_distance: i32 = 0;
+        for i in 0..nums.len() {
+            next_distance = Self::max(nums[i] + i as i32, next_distance);
+            if i as i32 == cur_distance {
+                if cur_distance != (nums.len() - 1) as i32 {
+                    ans += 1;
+                    cur_distance = next_distance;
+                    if next_distance == (nums.len() - 1) as i32 { break; }
+                }
+                else { break; }
+            }
+        }
+        ans
+    }
+}
+```
+
+```Rust
+//版本二
+impl Solution {
+    fn max(a: i32, b:i32) -> i32 {
+        if a > b { a } else { b }
+    }
+    pub fn jump(nums: Vec<i32>) -> i32 {
+        let mut cur_distance: i32 = 0;
+        let mut ans: i32 = 0;
+        let mut next_distance: i32 = 0;
+        for i in 0..nums.len() - 1 {
+            next_distance = Self::max(nums[i] + i as i32, next_distance);
+            if i as i32 == cur_distance {
+                cur_distance = next_distance;
+                ans += 1;
+            }
+        }
+        ans
+    }
+}
+```
 
 
 -----------------------

problems/0047.全排列II.md

@@ -351,6 +351,40 @@ func permuteUnique(_ nums: [Int]) -> [[Int]] {
 }
 ```
 
+### Rust
+
+```Rust
+impl Solution {
+    fn backtracking(result: &mut Vec<Vec<i32>>, path: &mut Vec<i32>, nums: &Vec<i32>, used: &mut Vec<bool>) {
+        let len = nums.len();
+        if path.len() == len {
+            result.push(path.clone());
+            return;
+        }
+        for i in 0..len {
+            if i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false { continue; }
+            if used[i] == false {
+                used[i] = true;
+                path.push(nums[i]);
+                Self::backtracking(result, path, nums, used);
+                path.pop();
+                used[i] = false;
+            }
+        }
+    }
+
+    pub fn permute_unique(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut result: Vec<Vec<i32>> = Vec::new();
+        let mut path: Vec<i32> = Vec::new();
+        let mut used = vec![false; nums.len()];
+        let mut nums= nums;
+        nums.sort();
+        Self::backtracking(&mut result, &mut path, &nums, &mut used);
+        result
+    }
+}
+```
+
 ### C
 ```c
 //临时数组

problems/0051.N皇后.md

@@ -558,6 +558,56 @@ func solveNQueens(_ n: Int) -> [[String]] {
 }
 ```
 
+### Rust
+
+```Rust
+impl Solution {
+    fn is_valid(row: usize, col: usize, chessboard: &mut Vec<Vec<char>>, n: usize) -> bool {
+        let mut i = 0 as usize;
+        while i < row { 
+            if chessboard[i][col] == 'Q' { return false; }
+            i += 1;
+        }
+        let (mut i, mut j) = (row as i32 - 1, col as i32 - 1);
+        while i >= 0 && j >= 0 {
+            if chessboard[i as usize][j as usize] == 'Q' { return false; }
+            i -= 1;
+            j -= 1;
+        }
+        let (mut i, mut j) = (row as i32 - 1, col as i32 + 1);
+        while i >= 0 && j < n as i32 {
+            if chessboard[i as usize][j as usize] == 'Q' { return false; }
+            i -= 1;
+            j += 1;
+        }
+        return true;
+    }
+    fn backtracking(result: &mut Vec<Vec<String>>, n: usize, row: usize, chessboard: &mut Vec<Vec<char>>) {
+        if row == n {
+            let mut chessboard_clone: Vec<String> = Vec::new();
+            for i in chessboard {
+                chessboard_clone.push(i.iter().collect::<String>());
+            }
+            result.push(chessboard_clone);
+            return;
+        }
+        for col in 0..n {
+            if Self::is_valid(row, col, chessboard, n) {
+                chessboard[row][col] = 'Q';
+                Self::backtracking(result, n, row + 1, chessboard);
+                chessboard[row][col] = '.';
+            }
+        }
+    }
+    pub fn solve_n_queens(n: i32) -> Vec<Vec<String>> {
+        let mut result: Vec<Vec<String>> = Vec::new();
+        let mut chessboard: Vec<Vec<char>> = vec![vec!['.'; n as usize]; n as usize];
+        Self::backtracking(&mut result, n as usize, 0, &mut chessboard);
+        result
+    }
+}
+```
+
 ### C
 ```c
 char ***ans;

problems/0055.跳跃游戏.md

@@ -154,6 +154,26 @@ var canJump = function(nums) {
 };
 ```
 
+### Rust
+
+```Rust
+impl Solution {
+    fn max(a: usize, b: usize) -> usize {
+        if a > b { a } else { b }
+    }
+    pub fn can_jump(nums: Vec<i32>) -> bool {
+        let mut cover = 0;
+        if (nums.len() == 1) { return true; }
+        let mut i = 0;
+        while i <= cover {
+            cover = Self::max(i + nums[i] as usize, cover);
+            if cover >= nums.len() - 1 { return true; }
+            i += 1;
+        }
+        false
+    }
+}
+```
 
 ### C
 ```c

problems/0078.子集.md

@@ -292,6 +292,30 @@ 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) {
+        result.push(path.clone());
+        let len = nums.len();
+        // if start_index >= len { return; }
+        for i in start_index..len {
+            path.push(nums[i]);
+            Self::backtracking(result, path, nums, i + 1);
+            path.pop();
+        }
+    }
+
+    pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut result: Vec<Vec<i32>> = Vec::new();
+        let mut path: Vec<i32> = Vec::new();
+        Self::backtracking(&mut result, &mut path, &nums, 0);
+        result
+    }
+}
+```
+
 ## C
 
 ```c

problems/0090.子集II.md

@@ -367,6 +367,36 @@ function subsetsWithDup(nums: number[]): number[][] {
 };
 ```
 
+### Rust
+
+```Rust
+impl Solution {
+    fn backtracking(result: &mut Vec<Vec<i32>>, path: &mut Vec<i32>, nums: &Vec<i32>, start_index: usize, used: &mut Vec<bool>) {
+        result.push(path.clone());
+        let len = nums.len();
+        // if start_index >= len { return; }
+        for i in start_index..len {
+            if i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false { continue; }
+            path.push(nums[i]);
+            used[i] = true;
+            Self::backtracking(result, path, nums, i + 1, used);
+            used[i] = false;
+            path.pop();
+        }
+    }
+
+    pub fn subsets_with_dup(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut result: Vec<Vec<i32>> = Vec::new();
+        let mut path: Vec<i32> = Vec::new();
+        let mut used = vec![false; nums.len()];
+        let mut nums = nums;
+        nums.sort();
+        Self::backtracking(&mut result, &mut path, &nums, 0, &mut used);
+        result
+    }
+}
+```
+
 ### C 
 
 ```c

problems/0093.复原IP地址.md

@@ -536,6 +536,53 @@ func isNormalIp(s string,startIndex,end int)bool{
 
 ```
 
+## Rust
+
+```Rust
+impl Solution {
+    fn is_valid(s: &Vec<char>, start: usize, end: usize) -> bool {
+        if start > end { return false; }
+        if s[start] == '0' && start != end { return false; }
+        let mut num = 0;
+        for i in start..=end {
+            if s[i] > '9' || s[i] < '0' { return false; }
+            if let Some(digit) = s[i].to_digit(10) { num = num * 10 + digit; }
+            if num > 255 { return false; }
+        }
+        true
+    }
+
+    fn backtracking(result: &mut Vec<String>, s: &mut Vec<char>, start_index: usize, mut point_num: usize) {
+        let len = s.len();
+        if point_num == 3 {
+            if Self::is_valid(s, start_index, len - 1) {
+                result.push(s.iter().collect::<String>());
+            }
+            return;
+        }
+        for i in start_index..len {
+            if Self::is_valid(s, start_index, i) {
+                point_num += 1;
+                s.insert(i + 1, '.');
+                Self::backtracking(result, s, i + 2, point_num);
+                point_num -= 1;
+                s.remove(i + 1);
+            }   else { break; }
+        }
+    }
+
+    pub fn restore_ip_addresses(s: String) -> Vec<String> {
+        let mut result: Vec<String> = Vec::new();
+        let len = s.len();
+        if len < 4 || len > 12 { return result; }
+        let mut s = s.chars().collect::<Vec<char>>();
+        Self::backtracking(&mut result, &mut s, 0, 0);
+        result
+    }
+
+}
+```
+
 ## C 
 ```c
 //记录结果