ChinaAIIT
diff --git a/‎.DS_Store‎
0 Bytes b/‎.DS_Store‎
0 Bytes
diff --git a/‎Java/.DS_Store‎
0 Bytes b/‎Java/.DS_Store‎
0 Bytes
diff --git a/‎Java/alg/.DS_Store‎
0 Bytes b/‎Java/alg/.DS_Store‎
0 Bytes
diff --git a/‎Java/alg/README.md‎
Lines changed: 2 additions & 0 deletions b/‎Java/alg/README.md‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎Java/alg/lc/62.不同路径.md‎
Lines changed: 81 additions & 0 deletions b/‎Java/alg/lc/62.不同路径.md‎
Lines changed: 81 additions & 0 deletions
diff --git a/‎Java/alg/lc/63.不同路径2.md‎
Lines changed: 101 additions & 0 deletions b/‎Java/alg/lc/63.不同路径2.md‎
Lines changed: 101 additions & 0 deletions
@@ -119,6 +119,8 @@
 - [47.全排列2](lc/47.全排列2.md)
 - [55.跳跃游戏](lc/55.跳跃游戏.md)
 - [56.合并区间](lc/56.合并区间.md)
+- [62.不同路径](lc/62.不同路径.md)
+- [63.不同路径2](lc/63.不同路径2.md)
 
 ## 笔试
 
 
@@ -0,0 +1,81 @@
+# 62. 不同路径
+
+[url](https://leetcode-cn.com/problems/unique-paths/)
+
+## 题目
+
+一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
+
+机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
+
+问总共有多少条不同的路径？
+
+![](https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png)
+
+```
+输入：m = 3, n = 7
+输出：28
+输入：m = 3, n = 2
+输出：3
+解释：
+从左上角开始，总共有 3 条路径可以到达右下角。
+1. 向右 -> 向下 -> 向下
+2. 向下 -> 向下 -> 向右
+3. 向下 -> 向右 -> 向下
+输入：m = 7, n = 3
+输出：28
+```
+
+## 方法
+
+## code
+
+### js
+
+```js
+let uniquePaths = (m, n) => {
+    let dp = Array(n).fill(1);
+    for (let i = 1; i < m; i++) {
+        for (let j = 1; j < n; j++) {
+            dp[j] += dp[j - 1];
+        }
+    }
+    return dp[n - 1];
+}
+```
+
+### go
+
+```go
+func uniquePaths(m, n int) int {
+	dp := make([]int, n)
+	for i := 0; i < n; i++ {
+		dp[i] = 1
+	}
+	for i := 1; i < m; i++ {
+		for j := 1; j < n; j++ {
+			dp[j] += dp[j - 1]
+		}
+	}
+	return dp[n-1]
+}
+```
+
+
+### java
+
+```java
+class Solution {
+    public int uniquePaths(int m, int n) {
+        int[] dp = new int[n];
+        Arrays.fill(dp, 1);
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                dp[j] += dp[j - 1];
+            }
+        }
+        return dp[n - 1];
+    }
+}
+```
+
@@ -0,0 +1,101 @@
+# 63. 不同路径 II
+
+
+[url](https://leetcode-cn.com/problems/unique-paths-ii/)
+
+## 题目
+
+一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
+
+机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
+
+现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
+
+
+![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/10/22/robot_maze.png)
+
+
+![](https://assets.leetcode.com/uploads/2020/11/04/robot1.jpg)
+```
+输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
+输出：2
+解释：
+3x3 网格的正中间有一个障碍物。
+从左上角到右下角一共有 2 条不同的路径：
+1. 向右 -> 向右 -> 向下 -> 向下
+2. 向下 -> 向下 -> 向右 -> 向右
+```
+![](https://assets.leetcode.com/uploads/2020/11/04/robot2.jpg)
+```
+输入：obstacleGrid = [[0,1],[0,0]]
+输出：1
+```
+
+## 方法
+
+## code
+
+### js
+
+```js
+let uniquePathsWithObstacles = obstacleGrid => {
+    let m = obstacleGrid.length, n = obstacleGrid[0].length;
+    let dp = Array(n + 1).fill(0);
+    dp[1] = 1;
+    for (let i = 1; i <= m; i ++) {
+        for (let j = 1; j <= n; j++) {
+            if (obstacleGrid[i - 1][j - 1] === 1) {
+                dp[j] = 0;
+            } else {
+                dp[j] += dp[j - 1];
+            }
+        }
+    }
+    return dp[n];
+}
+```
+
+### go
+
+```go
+func uniquePathsWithObstacles(obstacleGrid [][]int) int {
+	m, n := len(obstacleGrid), len(obstacleGrid[0])
+	dp := make([]int, n + 1)
+	dp[1] = 1
+	for i := 1; i <= m; i++ {
+		for j := 1; j <= n; j++ {
+			if obstacleGrid[i-1][j-1] == 1 {
+				dp[j] = 0
+			} else {
+				dp[j] += dp[j - 1]
+			}
+		}
+	}
+	return dp[n]
+}
+```
+
+
+### java
+
+```java
+class Solution {
+    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+        int m = obstacleGrid.length;
+        int n = obstacleGrid[0].length;
+        int[] dp = new int[n + 1];
+        dp[1] = 1;
+        for (int i = 1; i <= m; i++){
+            for (int j = 1; j <= n; j++) {
+                if (obstacleGrid[i - 1][j - 1] == 1) {
+                    dp[j] = 0;
+                } else {
+                    dp[j] += dp[j - 1];
+                }
+            }
+        }
+        return dp[n];
+    }
+}
+```
+