动态规划（dp）题目练习

题目链接：https://leetcode.cn/problems/maximum-subarray/
题目描述：

dp[i] 定义为 以nums[i]结尾的最大字段和 。 如果dp[i-1]<0,那么dp[i]肯定是单独成段，所以dp[i]就等于nums[i],相反当dp[i-1]>0,那么nums[i]+dp[i-1]肯定是大于nums[i]单独成段的。

class Solution {
public:
    int maxSubArray(vector& nums) {
        int dp[100005]={0};
        dp[0]=nums[0];
        for(int i=1;i
            if(dp[i-1]<0){
                dp[i]=nums[i];
            }else{
                dp[i]+=nums[i]+dp[i-1];
            }
        }
        int maxn=dp[0];
        for(int i=0;i
            //cout<maxn){
                maxn=dp[i];
            }
        }
        return maxn;
    }
};

题目链接：https://leetcode.cn/problems/longest-increasing-subsequence/
题目描述：

class Solution {
public:
    int lengthOfLIS(vector& nums) {
        int i,j,dp[2505];
        fill(dp,dp+2505,1);//初始化 数组为1
        for(i=1;i
            for(j=i-1;j>=0;j--){
                if(nums[j]
                    dp[i]=max(dp[j]+1,dp[i]);
                }
            }
        }
        int maxn=dp[0];
        for(i=0;i
            //cout<maxn){
                maxn=dp[i];
            }
        }
        return maxn;
    }
};

题目链接：https://leetcode.cn/problems/minimum-path-sum/
题目描述：

观察示例可知，右下角的位置能从他上面或者左边到达，我们只需要保证左边和上面是最优，就能得到终点是最优的。
dp[i][i]定义为到达i，j的最少和。需要特殊处理的是边界条件，第一行和第一列都要特殊处理。
所以状态转移为 dp[i][j] = min( dp[i-1][j] , dp[i][j-1] ) + grid[i][j];

class Solution {
public:
    int minPathSum(vector>& grid) {
        int dp[205][205];
        int i,j;
        for(i=0;i
            for(j=0;j
                if(i==0&&j==0){
                    dp[0][0]=grid[0][0];
                }else if(i-1<0){//特殊处理第一行
                    dp[i][j]=dp[i][j-1]+grid[i][j];
                }else if(j-1<0){//特殊处理第一列
                    dp[i][j]=dp[i-1][j]+grid[i][j];
                }else
                dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }
        return dp[i-1][j-1];
    }
};

题目链接：https://leetcode.cn/problems/unique-paths-ii/
题目描述：

观察示例可以看出，因为机器人只能向右或者向下移动，所以到达终点的方案数等于它上面的位置方案数加左边的位置方案数。
dp[i][j]定义为到达[i][j]的最大方案数。边界特殊处理，第一行上面没有，第一列左边没有。
那么状态转移为 dp[i][j]=dp[i-1][j]+dp[i][j-1];

class Solution {
public:
    int uniquePathsWithObstacles(vector>& obstacleGrid) {
        int dp[205][205];
        int i,j;
        for(i=0;i
            for(j=0;j
                if(obstacleGrid[i][j]) {
                    dp[i][j]=0;//障碍走不了为0
                }else if(i==0&&j==0){
                    dp[0][0]=1;
                }else if(i-1<0){
                    dp[i][j]=dp[i][j-1];
                }else if(j-1<0){
                    dp[i][j]=dp[i-1][j];
                }else
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[i-1][j-1];
    }
};