添加题64，62，63

Author: ligecarryme

基础算法篇/动态规划.md

@@ -56,8 +56,8 @@ console.log(minimumTotal(tringle)); //11
 
 动态规划和 DFS 区别
 
-- 二叉树 子问题是没有交集，所以大部分二叉树都用递归或者分治法，即 DFS，就可以解决
-- 像 triangle 这种是有重复走的情况，**子问题是有交集**，所以可以用动态规划来解决
+- 二叉树子问题是没有交集，所以大部分二叉树都用递归或者分治法，即DFS，就可以解决。
+- 像 triangle 这种是有重复走的情况，**子问题是有交集**，所以可以用动态规划来解决。
 
 **动态规划三个特性**：
 
@@ -73,7 +73,11 @@ console.log(minimumTotal(tringle)); //11
 
   如果用一句话概括一下，那就是，不同的决策序列，到达某个相同的阶段时，可能会产生重复的状态。所以才会用一个数组记录中间结果，避免重复计算。
 
-动态规划，自底向上 这里变成一位数组，因为层号实际上可以不用记录，每次记录上一层的值，到当前层就把以前的覆盖到，动态规划运用场景其中一条就是最优子结构，往下走不用回头一定是最优的
+动态规划，自底向上 
+
+这里变成一位数组，因为层号实际上可以不用记录，每次记录上一层的值，到当前层就把以前的覆盖到，动态规划运用场景其中一条就是最优子结构，往下走不用回头一定是最优的。
+
+`f(i,j)=min(f(i+1,j),f(i+1,j+1))+triangle[i][j]`
 
 ```js
 var minimumTotal = function(tringle){
@@ -100,7 +104,7 @@ Function(x) {
 }
 ```
 
-动态规划：是一种解决问 题的思想，大规模问题的结果，是由小规模问 题的结果运算得来的。动态规划可用递归来实现(Memorization Search)
+动态规划：是一种解决问题的思想，大规模问题的结果，是由小规模问 题的结果运算得来的。动态规划可用递归来实现(Memorization Search)
 
 ## 使用场景
 
@@ -136,4 +140,90 @@ Function(x) {
 
 > 注意点
 >
-> - 贪心算法大多题目靠背答案，所以如果能用动态规划就尽量用动规，不用贪心算法
+> - 贪心算法大多题目靠背答案，所以如果能用动态规划就尽量用动规，不用贪心算法
+
+## 1、矩阵类型（10%）
+
+##### [64. 最小路径和](https://leetcode-cn.com/problems/minimum-path-sum/)
+
+给定一个包含非负整数的 `*m* x *n*` 网格 `grid` ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。**说明：**每次只能向下或者向右移动一步。
+
+```js
+var minPathSum = function (grid) {
+    let m = grid.length
+    let n = grid[0].length
+    for (let i = 1; i < m; i++) {
+        grid[i][0] += grid[i - 1][0]
+    }
+    for (let i = 1; i < n; i++) {
+        grid[0][i] += grid[0][i - 1]
+    }
+    for (let i = 1; i < m; i++) {
+        for (let j = 1; j < n; j++) {
+            grid[i][j] = Math.min(grid[i - 1][j], grid[i][j - 1]) + grid[i][j]
+        }
+    }
+    return grid[m - 1][n - 1]
+};
+```
+
+##### [62. 不同路径](https://leetcode-cn.com/problems/unique-paths/)
+
+一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。问总共有多少条不同的路径？
+
+```js
+var uniquePaths = function (m, n) {
+    let dp = new Array(m).fill(new Array(n).fill(1)) //第一行和第一列都是1
+    for (let i = 1; i < m; i++) {
+        for (let j = 1; j < n; j++) {
+            dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+        }
+    }
+    return dp[m - 1][n - 1]
+};
+```
+
+##### [63. 不同路径 II](https://leetcode-cn.com/problems/unique-paths-ii/)
+
+同上，不过增加了障碍物。
+
+> 思路：第一行（列）遇到障碍物之前置为1，之后置为0（包括障碍物）
+
+```js
+var uniquePathsWithObstacles = function (obstacleGrid) {
+    let m = obstacleGrid.length
+    let n = obstacleGrid[0].length
+    if (obstacleGrid[0][0] === 1) {
+        return 0
+    }
+    for (let i = 0; i < m; i++) {
+        if (obstacleGrid[i][0] === 1) {
+            for (let j = i; j < m; j++) {
+                obstacleGrid[j][0] = 0
+            }
+            break
+        }
+        obstacleGrid[i][0] = 1
+    }
+    for (let i = 1; i < n; i++) {
+        if (obstacleGrid[0][i] === 1) {
+            for (let j = i; j < n; j++) {
+                obstacleGrid[0][j] = 0
+            }
+            break
+        }
+        obstacleGrid[0][i] = 1
+    }
+    for (let i = 1; i < m; i++) {
+        for (let j = 1; j < n; j++) {
+            if (obstacleGrid[i][j] === 1) {
+                obstacleGrid[i][j] = 0
+            } else {
+                obstacleGrid[i][j] = obstacleGrid[i - 1][j] + obstacleGrid[i][j - 1]
+            }
+        }
+    }
+    return obstacleGrid[m - 1][n - 1]
+};
+```
+