动态规划

一、基本描述
1、适合场景：能用公式来描述结果。当前值依赖它之前计算的值。
2、如何使用：
（1）创建一个二维数组来记录过程值。
（2）解题步骤：
1）根据条件，能直接初始化一些值。
2）循环遍历行和列，根据之前已知的值（初始化值）来计算当前的值。关键点是能找出依赖关系得出公式或者结论

  for (int i = 1; i < 行数; i++) {
            for (int j = 1; j < 列数; j++) {
                //根据根据公式和已经的值来计算当前值
            }
  }

二、实战
1、不同路径
1.1 题目描述（来源LeetCode）
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
问总共有多少条不同的路径？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths
1.2 解法

 public static int uniquePaths(int m, int n) {
        if (m <= 0 || n <= 0) {
            return 0;
        }
        int[][] dp = new int[m][n];
        if (m >= 1) {
            for (int j = 0; j < n; j++) {
                dp[0][j] = 1;
            }
        }
        if (n >= 1) {
            for (int j = 0; j < m; j++) {
                dp[j][0] = 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];
    }

2、不同路径2
2.1 题目描述
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths-ii

2.2 解法

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int rowLength =obstacleGrid.length;
        int colLength =obstacleGrid[0].length;
        if(obstacleGrid[0][0]==1){
            return  0;
        }
        if(obstacleGrid[rowLength-1][colLength-1]==1){
            return  0;
        }
        int[][] dp=new int[rowLength][colLength];
        dp[0][0]=1;
        int end=0;
        //第一列
        for(int j=1;j<rowLength;j++){
            if(obstacleGrid[j][0]==1){
                dp[j][0]=0;
                end=j;
                for(int i=end+1;i<rowLength;i++){
                    dp[i][0]=0;
                }
                break;
            }else{
                dp[j][0]=1;
            }
        }


        //第一行
        for(int j=1;j<colLength;j++){
            if(obstacleGrid[0][j]==1){
                dp[0][j]=0;
                end=j;
                for(int i=end+1;i<colLength;i++){
                    dp[0][i]=0;
                }
                break;
            }else{
                dp[0][j]=1;
            }
        }

        for(int i=1;i<rowLength;i++){
            for(int j=1;j<colLength;j++){
                if(obstacleGrid[i-1][j]==1 &&obstacleGrid[i][j-1]==1){
                    dp[i][j]=0;
                }else  if(obstacleGrid[i-1][j]==1){
                    dp[i][j]=dp[i][j-1];
                }else if(obstacleGrid[i][j-1]==1){
                    dp[i][j]=dp[i-1][j];
                }else{
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
                }

            }
        }
        return dp[rowLength-1][colLength-1];

    }

3 最小路径求和
3.1 题目描述
给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-path-sum/
3.2 解法

public static int minPathSum(int[][] grid) {
        //行数
        int rowLength = grid.length;
        //列数
        int colLength = grid[0].length;
        //创建一个二维数组来记录过程值
        int[][] dp = new int[rowLength][colLength];
        dp[0][0] = grid[0][0];
        //初始化二维数组
        for (int i = 1; i < rowLength; i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }
        for (int i = 1; i < colLength; i++) {
            dp[0][i] += dp[0][i - 1] + grid[0][i];
        }
        //
        for (int i = 1; i < rowLength; i++) {
            for (int j = 1; j < colLength; j++) {
                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }
        return dp[rowLength - 1][colLength - 1];
    }

备注：代码思想有参考网络，因之前忘记备注来源，如有侵权请联系我，谢谢