动态规划入门v0.2

• leetcode 746

  确定dp[i]的含义为：爬到第i个台阶的最小花费。随后的问题，比如确定递推公式等问题就可以轻松解决。

  class Solution {
      public int minCostClimbingStairs(int[] cost) {
          //dp[i] 为 爬到第i个台阶的花费。——>爬到第i个台阶的最小花费。
          //爬两个或者一个台阶怎么表示？——> 更改定义，取每次的最小值。
          int dp []= new int [cost.length + 1];
  
          //dp数组如何初始化？ dp[0] = 0 ,dp[1] = 0。
          dp[0]  = 0;
          dp[1] = 0;
          //遍历顺序？ 从第二个台阶一直到最后一个台阶 + 1。
          for(int i = 2 ; i<cost.length + 1 ; i++){
              //递推公式
              dp[i] = Math.min(dp[i - 1] + cost[i - 1] , dp[i - 2] + cost[i - 2]);
          }
          return dp[cost.length];
      }
  }
  

• leetcode 62

  class Solution {
      public int uniquePaths(int m, int n) {
          //dp[i][j]数组定义为：走到（i，j） 的位置时，一共有dp[i][j]条不同的路径。
          //第三个状态由上方路径和左方路径共同决定。
          
          int [][] dp = new int [m][n];
          //初始化dp[0][0] = 1，为起点。初始化左右两个边，都是1种路径。
          dp[0][0] = 1;
          for(int i = 1;i < m ;i ++){
              dp[i][0] = 1;
          }
          for(int j = 1;j<n;j ++){
              dp[0][j] = 1;
          }
          //遍历顺序，i,j都从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]。
                  dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
              }
          }
          return dp[m - 1][n - 1];
      }
  }
  

• leetcode 63

  class Solution {
      public int uniquePathsWithObstacles(int[][] obstacleGrid) {
          //技巧：只要将dp[i][j]为障碍的地方记为0即可。
          //其他思路与不同路径I一致，需要注意，在初始化时，如果一行有一个障碍，那么后面都要记为0.
          int m = obstacleGrid.length;
          int n = obstacleGrid[0].length;
          int [] []dp  = new int [m][n];
          if(obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1){
              return 0;
          }
          dp[0][0] = 1;
          for(int i = 1;i < m && obstacleGrid[i][0] == 0;i++){
              dp[i][0] = 1;
          }
          for(int j = 1;j < n && obstacleGrid[0][j] == 0 ;j ++){
              dp[0][j] = 1;
          }
          for(int i = 1 ;i < m;i++){
              for(int j = 1; j < n;j ++){
                  //这里注意，遍历到了障碍要跳过。
                  if(obstacleGrid[i][j] == 1) continue;
                  dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
              }
          }
          return dp[m - 1][n - 1];
      }
  }