对于dp的一点理解

动态规划

在这周，我稍微做了几题dp题目，并根据自己的做题总结出了一些做题规律
DP解题基本步骤

1，首先要确定需要求的目标值

比方说，一个m*n的二维数组，我们需要求从出发点到右下方结束点的最小步数，那么结束点dp[m-1][n-1]就是我们的目标值

2，要找出目标值的构成，我个人认为有些类似于递归的思路，从头一步步递归到目标点

沿用上面的例子，目标点的构成就是dp[m-2][n-1]+1或者是dp[m-1][n-2]+1,因为目标点是由前一个点进行向下移动或者向右移动得到的。

3，最后一步我们就要确认初始值以及范围

继续沿用上面的例子，初始值就是dp[0][0]这个点，因为它每次都会向右或者向下移动一个点，所以范围就是[0 ~ m][0 ~ n]了

那么以上就是我对于一些简单的DP题目的总结
接下来我们举几个例子具体分析
首先就是这道leetcode62题

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
问总共有多少条不同的路径？

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m+1][n+1];
        //我们需要的结果
        //dp[m-1][n-1];
        //找前一步的point
        //dp[m-1][n-1]=dp[m-1][n-2]+dp[m-2][n-1];
        //初始化
        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];
    }
}

让我们再来看一题
leetcode64

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。

class Solution {
    public int minPathSum(int[][] grid) {
    
        int w = grid[0].length;
        int h = grid.length;
        int [][] dp= new int[h][w];
        dp[0][0]=grid[0][0];
        //目标值
        //dp[w-1][h-1]
        //找出dp的构成
        //dp[w-1][h-1]=Math.max(dp[w-2][h-1]+grid[w-1][h-1],dp[w-1][h-2]+grid[w-1][h-1]);
        for(int i=1;i<h;i++){
        dp[i][0] = dp[i-1][0]+grid[i][0];
        }
        for(int j=1;j<w;j++){
            dp[0][j] = dp[0][j-1]+grid[0][j];
        }
        for(int i=1;i<h;i++){
            for(int j=1;j<w;j++){
                dp[i][j]=Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }
        return dp[h-1][w-1];
    }
}

这里不难看出两道题的思想都是一样的，最为关键的就是初始化这一步，因为dp[0][0]是无法减1的，所以我们应对其进行初始化。

那么根据这两题，应该对动态规划解题的思路有了一定的理解了。

那么我们来看看这道打家劫舍的经典题目

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

class Solution {
    public int rob(int[] nums) {
        int dp[] = new int[nums.length];
        if (nums == null || nums.length == 0) {
            return 0;
        }
        if (nums.length == 1) {
            return nums[0];
        }
        dp[1] = Math.max(nums[0],nums[1]);
        dp[0] = nums[0];
            for(int i=2;i<nums.length;i++){
                //dp[i]=Math.max(nums[i-2]+dp[i],nums[i-1]);
                dp[i]=Math.max(dp[i-2]+nums[i],dp[i-1]);
            }
        return dp[nums.length-1];
    }
}

以上就是我对dp的一些总结和理解。