动态规划之基础题目总结

一、斐波那契、爬楼梯

很简单,dp[i]为dp[i-1]与dp[i-2]两种情况的和，注释略

int fib(int n){
    if(n<2) return n;
    int dp[n+1];
    dp[0]=0;dp[1]=1;
    for(int i=2;i<=n;i++)
        dp[i]=dp[i-2]+dp[i-1];
    return dp[n];
}

二、使用最小花费爬楼梯

这里注意结果是在dp[costSize-2]和dp[costSize-1]中取最小值

int minCostClimbingStairs(int* cost, int costSize){
    //1.dp[i]表示到达i位置处时的最小花费(包括i处的花费)
    //2.递推式:
    //对于dp[i]:
    //      若从i-1过来，dp[i]=dp[i-1]+cost[i];
    //      若从i-2过来，dp[i]=dp[i-2]+cost[i];
    //综上，递推式为:dp[i]=fmin(dp[i-1]+cost[i],dp[i-2]+cost[i]);
    //3.dp数组初始化:
    //dp[0]=cost[0];dp[1]=cost[1];
    int dp[costSize];
    dp[0]=cost[0];dp[1]=cost[1];
    for(int i=2;i<costSize;i++)
        dp[i]=fmin(dp[i-1]+cost[i],dp[i-2]+cost[i]);
    return fmin(dp[costSize-2],dp[costSize-1]);
}

三、不同路径、不同路径II

无障碍版本很简单，两种情况直接相加即可

int uniquePaths(int m, int n){
    //1.dp[i][j]表示到达(i,j)位置时，最大的路径数
    //2.递推式:
    //对于dp[i][j]:
    //      若从(i-1,j)过来，dp[i][j]=dp[i-1][j];
    //      若从(i,j-1)过来，dp[i][j]=dp[i][j-1];
    //两种情况取并集，故递推公式为:dp[i][j]=dp[i-1][j]+dp[i][j-1];
    //3.dp数组初始化:
    //dp[0][j]=dp[i][0]=1;
    //4.遍历顺序:
    //从上到下、从左到右
    int dp[m][n];
    for(int i=0;i<m;i++) dp[i][0]=1;
    for(int j=0;j<n;j++) dp[0][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];
    }
    return dp[m-1][n-1];
}

有障碍版本难点在于第三步：dp数组的初始化；还有就是不可达就是路径条数为0，即dp[i][j]=0

int uniquePathsWithObstacles(int** obstacleGrid, int obstacleGridSize, int* obstacleGridColSize){
    //1.dp[i][j]表示到达(i,j)位置时，最大的路径数
    //2.递推式:
    //对于dp[i][j]:
    //    若obstacleGrid[i][j]!=1:
    //      递推公式为:dp[i][j]=dp[i-1][j]+dp[i][j-1];
    //    否则:
    //      该处不可达(用dp[i][j]=0表示)
    //3.dp数组初始化:
    //dp[i][j]=0，所有位置先初始化为不可达
    //对于dp的第一行和第一列的初始化，在遇到障碍后，障碍后面的都不可达:
    //    for(int i=0;i<m&&obstacleGrid[i][0]!=1;i++) obstacleGrid[i][0]=1;
    //    for(int j=0;j<n&&obstacleGrid[0][j]!=1;j++) obstacleGrid[0][j]=1;
    //4.遍历顺序:
    //从上到下、从左到右
    int m=obstacleGridSize,n=obstacleGridColSize[0];
    int dp[m][n];
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++)
            dp[i][j]=0;
    }
    for(int i=0;i<m&&obstacleGrid[i][0]!=1;i++) dp[i][0]=1;
    for(int j=0;j<n&&obstacleGrid[0][j]!=1;j++) dp[0][j]=1;
    for(int i=1;i<m;i++){
        for(int j=1;j<n;j++){
            if(obstacleGrid[i][j]!=1)
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
        }
    }
    return dp[m-1][n-1];
}

四、整数拆分

这题没见过确实不好想，建议背下来

一些易错点也要注意：

1. dp[i]=max(dp[i],j*(i-j),j*dp[i-j]);注意每次比较最大值时也要与上一轮的dp[i]比较，最终取最大值

2. dp数组要全部初始化为0（dp[2]除外），因为dp[i]要参与比较最大值

int integerBreak(int n){
    //1.dp[i]表示正整数i拆分后的最大乘积
    //2.递推式:
    //不管i分解出来多少数，这些数一定小于i
    //本题的关键就是:找到一个小于i的数j，以该数为因子时能得到最大乘积
    //dp[i]=max(dp[i],j*(i-j),j*dp[i-j]);
    //3.初始化:
    //dp[i]=0,dp[2]=1;
    int dp[n+1];
    for(int i=0;i<=n;i++) dp[i]=0;
    dp[2]=1;
    for(int i=3;i<=n;i++){
        for(int j=1;j<i-1;j++){
            if(dp[i]<j*dp[i-j])
                dp[i]=j*dp[i-j];
            if(dp[i]<j*(i-j))
                dp[i]=j*(i-j);
        }
    }
    return dp[n];
}

五、不同的二叉搜索树

这种题只能背，记不住拉倒

int numTrees(int n){
    //1.dp[i]表示i个节点的二叉搜索树个数
    //2.递推式:
    //dp[i]+=dp[i-j]*dp[j-1];
    //3.dp数组初始化:
    //dp[i]=0;dp[0]=1;
    int dp[n+1];
    for(int i=1;i<=n;i++) dp[i]=0;
    dp[0]=1;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=i;j++){
            dp[i]+=dp[j-1]*dp[i-j];
        }
    }
    return dp[n];
}