[pull] master from youngyangyang04:master

problems/0001.两数之和.md

@@ -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/0018.四数之和.md

@@ -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;
             }

problems/0046.全排列.md

@@ -456,6 +456,36 @@ func permute(_ nums: [Int]) -> [[Int]] {
 }
 ```
 
+### Scala
+
+```scala
+object Solution {
+  import scala.collection.mutable
+  def permute(nums: Array[Int]): List[List[Int]] = {
+    var result = mutable.ListBuffer[List[Int]]()
+    var path = mutable.ListBuffer[Int]()
+
+    def backtracking(used: Array[Boolean]): Unit = {
+      if (path.size == nums.size) {
+        // 如果path的长度和nums相等，那么可以添加到结果集
+        result.append(path.toList)
+        return
+      }
+      // 添加循环守卫，只有当当前数字没有用过的情况下才进入回溯
+      for (i <- nums.indices if used(i) == false) {
+        used(i) = true
+        path.append(nums(i))
+        backtracking(used) // 回溯
+        path.remove(path.size - 1)
+        used(i) = false
+      }
+    }
+
+    backtracking(new Array[Boolean](nums.size)) // 调用方法
+    result.toList // 最终返回结果集的List形式
+  }
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0047.全排列II.md

@@ -422,5 +422,43 @@ int** permuteUnique(int* nums, int numsSize, int* returnSize, int** returnColumn
 }
 ```
 
+### Scala
+
+```scala
+object Solution {
+  import scala.collection.mutable
+  def permuteUnique(nums: Array[Int]): List[List[Int]] = {
+    var result = mutable.ListBuffer[List[Int]]()
+    var path = mutable.ListBuffer[Int]()
+    var num = nums.sorted // 首先对数据进行排序
+
+    def backtracking(used: Array[Boolean]): Unit = {
+      if (path.size == num.size) {
+        // 如果path的size等于num了，那么可以添加到结果集
+        result.append(path.toList)
+        return
+      }
+      // 循环守卫，当前元素没被使用过就进入循环体
+      for (i <- num.indices if used(i) == false) {
+        // 当前索引为0，不存在和前一个数字相等可以进入回溯
+        // 当前索引值和上一个索引不相等，可以回溯
+        // 前一个索引对应的值没有被选，可以回溯
+        // 因为Scala没有continue，只能将逻辑反过来写 
+        if (i == 0 || (i > 0 && num(i) != num(i - 1)) || used(i-1) == false) {
+          used(i) = true
+          path.append(num(i))
+          backtracking(used)
+          path.remove(path.size - 1)
+          used(i) = false
+        }
+      }
+    }
+
+    backtracking(new Array[Boolean](nums.length))
+    result.toList
+  }
+}
+```
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0051.N皇后.md

@@ -455,7 +455,7 @@ var solveNQueens = function(n) {
 };
 ```
 
-## TypeScript
+### TypeScript
 
 ```typescript
 function solveNQueens(n: number): string[][] {
@@ -683,5 +683,77 @@ char *** solveNQueens(int n, int* returnSize, int** returnColumnSizes){
 }
 ```
 
+### Scala
+
+```scala
+object Solution {
+  import scala.collection.mutable
+  def solveNQueens(n: Int): List[List[String]] = {
+    var result = mutable.ListBuffer[List[String]]()
+
+    def judge(x: Int, y: Int, maze: Array[Array[Boolean]]): Boolean = {
+      // 正上方
+      var xx = x
+      while (xx >= 0) {
+        if (maze(xx)(y)) return false
+        xx -= 1
+      }
+      // 左边
+      var yy = y
+      while (yy >= 0) {
+        if (maze(x)(yy)) return false
+        yy -= 1
+      }
+      // 左上方
+      xx = x
+      yy = y
+      while (xx >= 0 && yy >= 0) {
+        if (maze(xx)(yy)) return false
+        xx -= 1
+        yy -= 1
+      }
+      xx = x
+      yy = y
+      // 右上方
+      while (xx >= 0 && yy < n) {
+        if (maze(xx)(yy)) return false
+        xx -= 1
+        yy += 1
+      }
+      true
+    }
+
+    def backtracking(row: Int, maze: Array[Array[Boolean]]): Unit = {
+      if (row == n) {
+        // 将结果转换为题目所需要的形式
+        var path = mutable.ListBuffer[String]()
+        for (x <- maze) {
+          var tmp = mutable.ListBuffer[String]()
+          for (y <- x) {
+            if (y == true) tmp.append("Q")
+            else tmp.append(".")
+          }
+          path.append(tmp.mkString)
+        }
+        result.append(path.toList)
+        return
+      }
+
+      for (j <- 0 until n) {
+        // 判断这个位置是否可以放置皇后
+        if (judge(row, j, maze)) {
+          maze(row)(j) = true
+          backtracking(row + 1, maze)
+          maze(row)(j) = false
+        }
+      }
+    }
+
+    backtracking(0, Array.ofDim[Boolean](n, n))
+    result.toList
+  }
+}
+```
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0056.合并区间.md

@@ -136,24 +136,38 @@ public:
 
 ### Java 
 ```java
+
+/**
+时间复杂度 ： O(NlogN) 排序需要O(NlogN)
+空间复杂度 ： O(logN)  java 的内置排序是快速排序 需要 O(logN)空间
+
+*/
 class Solution {
     public int[][] merge(int[][] intervals) {
         List<int[]> res = new LinkedList<>();
-        Arrays.sort(intervals, (o1, o2) -> Integer.compare(o1[0], o2[0]));
-
+        //按照左边界排序
+        Arrays.sort(intervals, (x, y) -> Integer.compare(x[0], y[0]));
+        //initial start 是最小左边界
         int start = intervals[0][0];
+        int rightmostRightBound = intervals[0][1];
         for (int i = 1; i < intervals.length; i++) {
-            if (intervals[i][0] > intervals[i - 1][1]) {
-                res.add(new int[]{start, intervals[i - 1][1]});
+            //如果左边界大于最大右边界
+            if (intervals[i][0] > rightmostRightBound) {
+                //加入区间 并且更新start
+                res.add(new int[]{start, rightmostRightBound});
                 start = intervals[i][0];
+                rightmostRightBound = intervals[i][1];
             } else {
-                intervals[i][1] = Math.max(intervals[i][1], intervals[i - 1][1]);
+                //更新最大右边界
+                rightmostRightBound = Math.max(rightmostRightBound, intervals[i][1]);
             }
         }
-        res.add(new int[]{start, intervals[intervals.length - 1][1]});
+        res.add(new int[]{start, rightmostRightBound});
         return res.toArray(new int[res.size()][]);
     }
 }
+
+}
 ```
 ```java
 // 版本2

problems/0104.二叉树的最大深度.md

@@ -294,14 +294,13 @@ class solution {
     /**
      * 递归法
      */
-    public int maxdepth(treenode root) {
+    public int maxDepth(TreeNode root) {
         if (root == null) {
             return 0;
         }
-        int leftdepth = maxdepth(root.left);
-        int rightdepth = maxdepth(root.right);
-        return math.max(leftdepth, rightdepth) + 1;
-
+        int leftDepth = maxDepth(root.left);
+        int rightDepth = maxDepth(root.right);
+        return Math.max(leftDepth, rightDepth) + 1;
     }
 }
 ```
@@ -311,23 +310,23 @@ class solution {
     /**
      * 迭代法，使用层序遍历
      */
-    public int maxdepth(treenode root) {
+    public int maxDepth(TreeNode root) {
         if(root == null) {
             return 0;
         }
-        deque<treenode> deque = new linkedlist<>();
+        Deque<TreeNode> deque = new LinkedList<>();
         deque.offer(root);
         int depth = 0;
-        while (!deque.isempty()) {
+        while (!deque.isEmpty()) {
             int size = deque.size();
             depth++;
             for (int i = 0; i < size; i++) {
-                treenode poll = deque.poll();
-                if (poll.left != null) {
-                    deque.offer(poll.left);
+                TreeNode node = deque.poll();
+                if (node.left != null) {
+                    deque.offer(node.left);
                 }
-                if (poll.right != null) {
-                    deque.offer(poll.right);
+                if (node.right != null) {
+                    deque.offer(node.right);
                 }
             }
         }

problems/0129.求根到叶子节点数字之和.md

@@ -3,6 +3,9 @@
   <img src="https://code-thinking-1253855093.file.myqcloud.com/pics/20210924105952.png" width="1000"/>
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
+
+
+
 # 129. 求根节点到叶节点数字之和
 
 [力扣题目链接](https://leetcode.cn/problems/sum-root-to-leaf-numbers/)
@@ -245,6 +248,29 @@ class Solution:
 ```
 Go：
 
+```go
+func sumNumbers(root *TreeNode) int {
+	sum = 0
+	travel(root, root.Val)
+	return sum
+}
+
+func travel(root *TreeNode, tmpSum int) {
+	if root.Left == nil && root.Right == nil {
+		sum += tmpSum
+	} else {
+		if root.Left != nil {
+			travel(root.Left, tmpSum*10+root.Left.Val)
+		}
+		if root.Right != nil {
+			travel(root.Right, tmpSum*10+root.Right.Val)
+		}
+	}
+}
+```
+
+
+
 JavaScript：
 ```javascript
 var sumNumbers = function(root) {