动态规划解题思路总结归纳(一)

一、动态规划的三大步骤

定义：动态规划，无非就是利用历史记录，来避免我们的重复计算。而这些历史记录，我们得需要一些变量来保存，一般是用一维数组或者二维数组来保存

步骤一：定义数组元素含义，例如定义一个二维数组，dp[ ][ ]，dp[ i ][ j ] 表示的具体含义；

步骤二：找出数组元素之间的关系式，例如 dp[ i ][ j ] = dp[ i-1 ][ j ] + dp[ i ][ j -1] ，也就是可以利用历史数据来推出新的元素值，这个就是他们的关系式了。而这一步，也是最难的一步突破口。

步骤三：寻找初始值，例如 dp[ i ][ j ] = dp[ i-1 ][ j ] + dp[ i ][ j -1] ，这样一直递推下去
dp[ 1 ][1j ] = dp[ 0 ][ 1 ] + dp[ 1 ][ 0 ] ， dp[ 0 ][ 1 ] 和 dp[ 1 ][ 0 ] 不能再分解了，所以要必须能够获得他们的具体值，就是所谓的初始值。

接下来直接上几道LeetCode的真题来实践下！

二、案例详解 —— 70. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/climbing-stairs

步骤一：定义数组元素含义

定义数组元素含义，dp[i] 为青蛙跳上i级楼梯总共有多少种跳法；dp[n]就我我们求解的答案。

步骤二：找出数组元素间的关系式

青蛙一次可以跳1级，也可以跳2级，所以青蛙到达第n级楼梯有2种方式，一种是从n-1级跳上来，另一种是从 n-2 级跳上来，所以可以推到出公式：dp[n] = dp[n-1] + dp[n-2]。

步骤三：找出初始条件

当 n = 1 时，dp[1] =1，当 n = 2 时，dp[2] = 2

代码：

class Solution {
    public int climbStairs(int n) {
        if (n==1) return 1;
        int[] dp = new int[n+1];
        dp[1] = 1;
        dp[2] = 2;
        for(int i = 3;i<dp.length;i++) {
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }
}

三、案例详解 —— 62. 不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths

步骤一：定义数组元素含义

由于我们的目的是从左上角到右下角一共有多少种路径，那我们就定义 dp[i] [j]的含义为：当机器人从左上角走到(i, j) 这个位置时，一共有 dp[i] [j] 种路径。那么，dp[m-1] [n-1] 就是我们要的答案了。

注意，这个网格相当于一个二维数组，数组是从下标为 0 开始算起的，所以 右下角的位置是 (m-1, n - 1)，所以 dp[m-1] [n-1] 就是我们要找的答案。

步骤二：找出数组元素间的关系式

想象以下，机器人要怎么样才能到达 (i, j) 这个位置？由于机器人可以向下走或者向右走，所以有两种方式到达。

方式1：从 (i-1,j) 的位置向右走一步到达；
方式2：从 (i,j-1) 的位置向下走一步到达。

因为要计算所有的可能到达 (i, j) 这个位置的路径，所以dp[i] [j] = dp[i-1] [j] + dp[i] [j-1]

步骤三：找出初始值

初始值是计算出所有的 dp[0] [0….n-1] 和所有的 dp[0….m-1] [0]，这个还是非常容易计算的，相当于计算机图中的最上面一行和左边一列。因此初始值如下。

dp[0] [0….n-1] = 1; // 相当于最上面一行，机器人只能一直往右走
dp[0…m-1] [0] = 1; // 相当于最左面一列，机器人只能一直往下走

代码：

class Solution {
    public int uniquePaths(int m, int n) {
        // 定义二维数组
        int[][] dp = new int[m][n];

        // 初始化值
        for (int i = 0;i<m;i++) {
            dp[i][0] = 1;
        }
        for (int i = 0;i<n;i++) {
            dp[0][i] = 1;
        }

        // 用关系式开始计算
        for (int i = 1;i<m;i++) {
            for (int j = 1;j<n;j++) {
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }

        return dp[m-1][n-1];
    }
}

四、案例详解 —— 62. 不同路径 Ⅱ

提示：
m == obstacleGrid.length
n == obstacleGrid[i].length
1 <= m, n <= 100
obstacleGrid[i][j] 为 0 或 1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths-ii

此题的解题思路与上题类似，只是在初始化的时候和用关系式计算的时候，要考虑到障碍物的情况！

代码：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        // 定义二维数组
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] dp = new int[m][n]; // 数组元素默认是0

        // 初始化值
        for (int i = 0;i<m;i++) {
            if(obstacleGrid[i][0] == 1) {
                break;// 右边的无法到达了
            } else {
                dp[i][0] = 1;
            }
            
        }
        for (int i = 0;i<n;i++) {
            if (obstacleGrid[0][i] == 1) {
                break;// 下边的无法到达了
            } else {
                dp[0][i] = 1;
            }
        }

        // 用关系式开始计算
        for (int i = 1;i<m;i++) {
            for (int j = 1;j<n;j++) {
                if (obstacleGrid[i][j] == 1) {
                    continue;// 障碍物无法到达
                } else {
                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
                }
            }
        }
        return dp[m-1][n-1];
    }
}