[日记]LeetCode算法·十六——动态规划①

1 动态规划

动态规划的核心在于利用同一类型的任务结果进行递推。
动规具有明显套路，具体分为5步走：
1 确定dp数组（dp table）以及下标的含义
2 确定递推公式
3 dp数组如何初始化
4 确定遍历顺序
5 举例推导dp数组

2 斐波那契数

LeetCode:斐波那契数
无论是递归还是动规，这道题都是经典中的经典。

class Solution {
public:
    int fib(int n) {
        //0和1
        if(n<=1)return n;
        vector<int> dp(n+1);
        dp[0]=0;
        dp[1]=1;
        for(int i=2;i<=n;i++)
        {
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
};

3 爬楼梯

LeetCode:爬楼梯
本质上依然是斐波那契数列，这里对于0的初始化可以完全不用在意其现实意义，而是注重其对于递推的合理性。

class Solution {
public:
    int climbStairs(int n) {
        //dp[i]=dp[i-1]+dp[i-2]
        //dp[1]=1,dp[2]=2,dp[3]=3
        vector<int> dp(n+1);
        dp[0]=1;
        dp[1]=1;
        for(int i=2;i<=n;++i)
        {
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
};

4 使用最小花费爬楼梯

LeetCode:使用最小花费爬楼梯
使用最小值min进行状态转移。

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) 
    {
        //dp[i]=min(cost[i-1]+dp[i-1],cost[i-2]+dp[i-2])
        //dp[0]=0,dp[1]=0
        vector<int> dp(cost.size()+1);
        dp[0]=0;
        dp[1]=0;
        for(int i=2;i<=cost.size();++i)
        {
            dp[i]=min(cost[i-1]+dp[i-1],cost[i-2]+dp[i-2]);
        }
        return dp[cost.size()];
    }
};

5 不同路径

LeetCode:不同路径
如果使用排列组合，可以使用组合数进行选择，如果是动态规划，则是对第一行和第一列初始化后，直接dp[i][j]=dp[i-1][j]+dp[i][j-1]。

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp( m, vector<int>(n,1));
        //第一行和第一列全部都应该初始化为1
        //因为没法回头，只能一直右或一直左完成
        //对于第二列和第二行开始，dp[i][j]=dp[i-1][j]+dp[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];
            }
        }
        return dp[m-1][n-1];
    }
};

6 不同路径II

LeetCode:不同路径II
对第一行和第一列的初始化与上一题有所不同，一旦遇到障碍物，其与其后续的位置都置零。

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = (obstacleGrid[0]).size();
        vector<vector<int>> dp(m,vector(n,1));
        int i,j;
        bool jam=false;
        //初始化第一列
        for(i=0;i<m;i++)
        {
            if(jam==true)
                dp[i][0]=0;
            if(jam==false && obstacleGrid[i][0]!=1)
                dp[i][0]=1;
            if(jam==false && obstacleGrid[i][0]==1)
            {
                dp[i][0]=0;
                jam=true;
            }
        }
        //初始化第一行
        jam=false;
        for(i=0;i<n;i++)
        {
            if(jam==true)
                dp[0][i]=0;
            if(jam==false && obstacleGrid[0][i]!=1)
                dp[0][i]=1;
            if(jam==false && obstacleGrid[0][i]==1)
            {
                dp[0][i]=0;
                jam=true;
            }
        }
        //动态规划
        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];
                else
                    dp[i][j]=0;
            }
        }
        return dp[m-1][n-1];
    }
};

7 整数拆分

LeetCode:整数拆分
拆分问题摆明了是动态规划，唯一需要注意的是，对于当前小的拆分法方案还有[自身]一种方法。

class Solution {
public:
    int integerBreak(int n) {
        //dp[n]为n的最大成绩
        vector<int> dp(n+1,0);
        //初始化
        dp[1]=1;
        dp[2]=1;
        //记录最大乘积
        int max_val,i,j;
        for(i=3;i<=n;i++)
        {
            max_val=0;
            for(j=1;j<i;j++)
            {
                //状态转移方程，拆成n=n-k+k，其乘积为k*(n-k)
                //其中n-k的结果为max(n-k,dp[n-k])
                max_val=max(max_val, (i-j) * (max(j,dp[j])));
            }
            dp[i]=max_val;
        }
        return dp[n];
    }
};

8 不同的二叉搜索树

LeetCode:不同的二叉搜索树
二叉搜索树的左右子树也是二叉搜索树，因此可以利用左右子树的节点个数进行状态转移方程。

class Solution {
public:
    int numTrees(int n) {
        //根据左右两边各有多少个节点进行归类
        //因为二叉搜索树的左右子树也是二叉搜索树，所以可以递归
        vector<int> dp(n+1,0);

        dp[0]=1;
        dp[1]=1;

        for(int i=2;i<=n;i++)
        {
            for(int j=0;j<i;j++)
            {
                //左边j个，右边i-1-j个，根节点1个
                dp[i]+=dp[j]*dp[i-1-j];
            }
        }

        return dp[n];
    }
};

9 总结

开始动态规划喽，第一天的题目还是比较简单的，新学期开始老师也开始布置作业了，烦死了。
——2023.3.1