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

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

@@ -694,6 +694,44 @@ object Solution {
 }
 ```
 
+### Ruby
+```ruby
+def letter_combinations(digits)
+  letter_map = {
+    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']
+  }
+  
+  result = []
+  path = []
+
+  return result if digits.size == 0
+
+  backtracking(result, letter_map, digits.split(''), path, 0)
+  result
+end
+
+def backtracking(result, letter_map, digits, path, index) 
+  if path.size == digits.size
+    result << path.join('')
+    return
+  end
+
+  hash[digits[index].to_i].each do |chr|
+    path << chr
+    #index + 1代表处理下一个数字
+    backtracking(result, letter_map, digits, path, index + 1)
+    #回溯，撤销处理过的数字
+    path.pop
+  end
+end
+```
 
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">

problems/0077.组合.md

@@ -764,6 +764,35 @@ object Solution {
 }
 ```
 
+### Ruby
+
+```ruby
+
+def combine(n, k)
+  result = []
+  path = []
+  backtracking(result, path, n, 1, k)
+  return result
+end
+
+#剪枝优化
+def backtracking(result, path, n, j, k)
+  if path.size == k
+    result << path.map {|item| item}
+    return
+  end
+
+  for i in j..(n-(k - path.size)) + 1
+    #处理节点
+    path << i
+    backtracking(result, path, n, i + 1, k)
+    #回溯，撤销处理过的节点
+    path.pop
+  end
+end
+
+```
+
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>

problems/0151.翻转字符串里的单词.md

@@ -311,7 +311,7 @@ class Solution {
 ```
 
 ```java
-//解法三：双反转+移位，在原始数组上进行反转。空间复杂度O(1)
+//解法三：双反转+移位，String 的 toCharArray() 方法底层会 new 一个和原字符串相同大小的 char 数组，空间复杂度：O(n)
 class Solution {
     /**
      * 思路：

problems/0200.岛屿数量.广搜版.md

@@ -239,6 +239,42 @@ class Solution:
                 visited[next_i][next_j] = True
 
 ```
+### JavaScript
+```javascript
+var numIslands = function (grid) {
+    let dir = [[0, 1], [1, 0], [-1, 0], [0, -1]]; // 四个方向
+    let bfs = (grid, visited, x, y) => {
+        let queue = [];
+        queue.push([x, y]);
+        visited[x][y] = true;
+        while (queue.length) {
+            let top = queue.shift();//取出队列头部元素
+            console.log(top)
+            for (let i = 0; i < 4; i++) {
+                let nextX = top[0] + dir[i][0]
+                let nextY = top[1] + dir[i][1]
+                if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length)
+                    continue;
+                if (!visited[nextX][nextY] && grid[nextX][nextY] === "1") {
+                    queue.push([nextX, nextY])
+                    visited[nextX][nextY] = true
+                }
+            }
+        }
+    }
+    let visited = new Array(grid.length).fill().map(() => Array(grid[0].length).fill(false))
+    let res = 0
+    for (let i = 0; i < grid.length; i++) {
+        for (let j = 0; j < grid[i].length; j++) {
+            if (!visited[i][j] && grid[i][j] === "1") {
+                ++res;
+                bfs(grid, visited, i, j);
+            }
+        }
+    }
+    return res
+};
+```
 
 ### Rust
 

problems/0200.岛屿数量.深搜版.md

@@ -219,7 +219,7 @@ class Solution {
 }
 ```
 
-Python:
+### Python:
 
 ```python
 # 版本一
@@ -278,8 +278,91 @@ class Solution:
 
         return result
 ```
+### JavaScript
 
-Rust:
+```javascript
+var numIslands = function (grid) {
+    let dir = [[0, 1], [1, 0], [-1, 0], [0, -1]]; // 四个方向
+
+    let dfs = (grid, visited, x, y) => {
+        for (let i = 0; i < 4; i++) {
+            let nextX = x + dir[i][0]
+            let nextY = y + dir[i][1]
+            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length)
+                continue;
+            if (!visited[nextX][nextY] && grid[nextX][nextY] === "1") {
+                visited[nextX][nextY] = true
+                dfs(grid,visited,nextX,nextY)
+            }
+        }
+    }
+    let visited = new Array(grid.length).fill().map(() => Array(grid[0].length).fill(false))
+
+    let res = 0
+    for (let i = 0; i < grid.length; i++) {
+        for (let j = 0; j < grid[i].length; j++) {
+            if (!visited[i][j] && grid[i][j] === "1") {
+                ++res;
+                visited[i][j] = true;
+                dfs(grid, visited, i, j);
+            }
+        }
+    }
+    return res
+};
+```
+
+### Go
+
+```go
+func numIslands(grid [][]byte) int {
+    // 用1标记已访问
+    visited := make([][]int, len(grid))
+    for i := 0; i < len(visited); i++{
+        visited[i] = make([]int, len(grid[0]))
+    }
+
+    var bfs func(x, y int)
+    bfs = func(x, y int){
+        stack := make([][]int, 0)
+        stack = append(stack, []int{x, y})
+        moveX := []int{1, -1, 0, 0}
+        moveY := []int{0, 0, 1, -1} 
+
+        for len(stack) != 0{
+            node := stack[len(stack) - 1]
+            stack = stack[:len(stack) - 1]
+
+            for i := 0; i < 4; i++{
+                dx := moveX[i] + node[0]
+                dy := moveY[i] + node[1]
+                if dx < 0 || dx >= len(grid) || dy < 0 || dy >= len(grid[0]) || visited[dx][dy] == 1{
+                    continue
+                }
+                visited[dx][dy] = 1
+                if grid[dx][dy] == '1'{
+                    stack = append(stack, []int{dx,dy})
+                }
+            }
+        }
+    }
+
+    result := 0
+    for i := 0; i < len(grid); i++{
+        for j := 0; j < len(grid[0]); j++{
+            if visited[i][j] == 0 && grid[i][j] == '1'{
+                bfs(i, j)
+                visited[i][j] = 1
+                result++
+            }
+        }
+    }
+
+    return result
+}
+```
+
+### Rust:
 
 
 ```rust

problems/0225.用队列实现栈.md

@@ -454,13 +454,34 @@ class MyStack:
 
     def top(self) -> int:
         """
+        写法一：
         1. 首先确认不空
-        2. 我们仅有in会存放数据，所以返回第一个即可
+        2. 我们仅有in会存放数据，所以返回第一个即可（这里实际上用到了栈）
+        写法二：
+        1. 首先确认不空
+        2. 因为队列的特殊性，FIFO，所以我们只有在pop()的时候才会使用queue_out
+        3. 先把queue_in中的所有元素（除了最后一个），依次出列放进queue_out
+        4. 交换in和out，此时out里只有一个元素
+        5. 把out中的pop出来，即是原队列的最后一个，并使用temp变量暂存
+        6. 把temp追加到queue_in的末尾
         """
+        # 写法一：
+        # if self.empty():
+        #     return None
+        
+        # return self.queue_in[-1]    # 这里实际上用到了栈，因为直接获取了queue_in的末尾元素
+
+        # 写法二：
         if self.empty():
             return None
+
+        for i in range(len(self.queue_in) - 1):
+            self.queue_out.append(self.queue_in.popleft())
         
-        return self.queue_in[-1]
+        self.queue_in, self.queue_out = self.queue_out, self.queue_in 
+        temp = self.queue_out.popleft()   
+        self.queue_in.append(temp)
+        return temp
 
 
     def empty(self) -> bool:
@@ -488,9 +509,19 @@ class MyStack:
         return self.que.popleft()
 
     def top(self) -> int:
+        # 写法一：
+        # if self.empty():
+        #     return None
+        # return self.que[-1]
+
+        # 写法二：
         if self.empty():
             return None
-        return self.que[-1]
+        for i in range(len(self.que)-1):
+            self.que.append(self.que.popleft())
+        temp = self.que.popleft()
+        self.que.append(temp)
+        return temp
 
     def empty(self) -> bool:
         return not self.que

problems/0695.岛屿的最大面积.md

@@ -391,6 +391,44 @@ class Solution:
                 self.dfs(grid, visited, new_x, new_y)
 ```
 
+### JavaScript
+```javascript
+var maxAreaOfIsland = function (grid) {
+    let dir = [[0, 1], [1, 0], [-1, 0], [0, -1]]; // 四个方向
+    
+    let visited = new Array(grid.length).fill().map(() => Array(grid[0].length).fill(false))
+    
+    let dfs = (grid, visited, x, y, m) => {
+        for (let i = 0; i < 4; i++) {
+            let nextX = x + dir[i][0]
+            let nextY = y + dir[i][1]
+            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length)
+                continue;
+            if (!visited[nextX][nextY] && grid[nextX][nextY] === 1) {
+                visited[nextX][nextY] = true
+                m = dfs(grid, visited, nextX, nextY,m+1)
+            }
+        }
+        return m
+    }
+
+    let  max = 0
+
+    for (let i = 0; i < grid.length; i++) {
+        for (let j = 0; j < grid[i].length; j++) {
+            if (!visited[i][j] && grid[i][j] === 1) {
+                // 深度优先
+                visited[i][j] = true;
+                let m = dfs(grid, visited, i, j, 1);
+                if (m > max) max = m;
+            }
+        }
+    }
+    return max
+};
+```
+
+
 ### Rust
 
 dfs: 版本一
@@ -530,7 +568,6 @@ impl Solution {
     }
 }
 ```
-
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>

problems/0797.所有可能的路径.md

@@ -217,8 +217,61 @@ class Solution:
             self.path.pop() # 回溯
 ```
 
+
+### JavaScript
+```javascript
+var allPathsSourceTarget = function(graph) {
+    let res=[],path=[]
+
+    function dfs(graph,start){
+        if(start===graph.length-1){
+            res.push([...path])
+            return;
+        }
+        for(let i=0;i<graph[start].length;i++){
+            path.push(graph[start][i])
+            dfs(graph,graph[start][i])
+            path.pop()
+        }
+    }
+    path.push(0)
+    dfs(graph,0)
+    return res
+};
+```
+
+
+### Go
+
+```go
+func allPathsSourceTarget(graph [][]int) [][]int {
+    result := make([][]int, 0)
+
+    var dfs func(path []int, step int)
+    dfs = func(path []int, step int){
+        // 从0遍历到length-1
+        if step == len(graph) - 1{
+            tmp := make([]int, len(path))
+            copy(tmp, path)
+            result = append(result, tmp)
+            return 
+        }
+
+        for i := 0; i < len(graph[step]); i++{
+            next := append(path, graph[step][i])
+            dfs(next, graph[step][i])
+        }
+    }
+    // 从0开始，开始push 0进去
+    dfs([]int{0}, 0)
+    return result 
+}
+
+```
+
 ### Rust
 
+
 ```rust
 impl Solution {
     pub fn all_paths_source_target(graph: Vec<Vec<i32>>) -> Vec<Vec<i32>> {

problems/剑指Offer58-II.左旋转字符串.md

@@ -120,8 +120,9 @@ class Solution {
 ```
 
 ```java
-//解法二：空间复杂度：O(1)。用原始数组来进行反转操作
-//思路为：先整个字符串反转，再反转前面的，最后反转后面 n 个
+// 解法二
+// 空间复杂度：O(n)。String 的 toCharArray() 方法底层会 new 一个和原字符串相同大小的 char 数组
+// 思路为：先整个字符串反转，再反转前面的，最后反转后面 n 个
 class Solution {
     public String reverseLeftWords(String s, int n) {
         char[] chars = s.toCharArray();