C++算法之动态规划一

深入浅出动态规划

解释：动态规划（Dynamic Programming,DP）在查找很多重叠子问题的最优解时有效，他将问题重新组合成子问题，为了避免多次解决这些子问题，他们的结果都逐渐被计算并保存，从简答的问题直到整个问题都被解决。
动态规划和其他遍历算法（广度搜索）都是将原问题拆成多个子问题然后求解，本质区别是：动态规划保存子问题的解，避免重复计算。解决动态规划的关键是找到转移方程，这样我们可以通过计算和存储子问题的解来求解最终问题。

1.基本动态规划：一维

题目一：给定 n 节台阶，每次可以走一步或走两步，求一共有多少种方式可以走完这些台阶。
例如：输入是一个数字，表示台阶数量；输出是爬台阶的总方式。

这是十分经典的斐波那契数列题。定义一个数组 dp，dp[i] 表示走到第 i 阶的方法数。因为
我们每次可以走一步或者两步，所以第 i 阶可以从第 i-1 或 i-2 阶到达。换句话说，走到第 i 阶的
方法数即为走到第 i-1 阶的方法数加上走到第 i-2 阶的方法数。这样我们就得到了状态转移方程
dp[i] = dp[i-1] + dp[i-2]。注意边界条件的处理。

int climbStairs(int n)
{
    if(n<=2) return n;
    vector<int>dp(n+1,1);
    for(int i=2;i<=n;++i)
    {
        dp[i]=dp[i-1]+dp[i-1];
    }
    return dpp[n];
}

进一步的，我们可以对动态规划进行空间压缩。因为 dp[i] 只与 dp[i-1] 和 dp[i-2] 有关，因此
可以只用两个变量来存储 dp[i-1] 和 dp[i-2]，使得原来的 O(n) 空间复杂度优化为 O(1) 复杂度。

int climbStairs(int n)
{
    if(n<=2) return n;
    int pre2=1,pre1=2,cur;
    for(int i=2;i<n;++i)
    {
        cur=pre1+pre2;
        pre2=pre1;
        pre1=cur;
    }
    return cur;
}

题目二：

int rob(vector<int>&nums)
{
    if(nums.empty()) return 0;
    int n=nums.size();
    if(n==1) return nums[0];
    int pre2=0,pre1=0,curr;
    for(int i=0;i<n;i++)
    {
        cur=max(pre2+nums[i],pre1);
        pre2=pre1;
        pre1=cur;
    }
    return cur;
}

题目三：

int numberOfAirthmeticSlices(vector<int>&nums)
{
    int n=nums.size();
    if(n<3) return 0;
    vector<int>dp(n,0);
    for(int i=2;i<n;++i)
    {
        if(nums[i]-nums[i-1]==nums[i-1]-nums[n-2])
        {
            dp[i]=dp[i-1]+1;
        }
    }
    return accumulate(dp.begin(),dp.end(),0);
}

2.基本动态规划：二维

题目一：给定一个 m × n 大小的非负整数矩阵，求从左上角开始到右下角结束的、经过的数字的和最
小的路径。每次只能向右或者向下移动。

我们可以定义一个同样是二维的 dp 数组，其中 dp[i][j] 表示从左上角开始到 (i, j) 位置的最
优路径的数字和。因为每次只能向下或者向右移动，我们可以很容易得到状态转移方程
dp[i][j] =min(dp[i-1][j], dp[i][j-1]) + grid[i][j]，其中 grid 表示原数组。

int minPathSum(vector<vector<int>>&grid)
{
    int m=grid.size();
    int n=grid[0].size();
    vector<vector<int>>dp(m,vector<int>(n,0));
    for(int i=0;i<m;++i)
    {
        for(int j=0;j<n;++j)
        {
            if(i==0&&j==0){
                dp[i][j]=grid[i][j];
            }
            else if(i==0)
            {
                dp[i][j]=dp[i][j-1]+grid[i][j];
            }
            else if(j==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[m-1][n-1];
}

题目二：

我们从左上到右下进行一次动态搜索，再从右下到左上进行一次动态搜索。两次动态搜索即可完成四个方向上的查找。

vector<vector<int>>updateMatrix(vector<vector<int>>&matrix)
{
    if(matrix.empty()) return{};
    int n=matrix.size(),m=matix[0].size();
    vector<vector<int>>dp(n,vector<int>(m,INT_MAX-1));
    for(int i=0;i<n;++i)
    {
        for(int j=0;j<m;++j)
        {
            if(matrix[i][j]==0)
            {
                dp[i][j]=0;
            }
            else
            {
                if(j>0){
                    dp[i][j]=min(dp[i][j],dp[i][j-1]+1);
                }
                if(i>0){
                    dp[i][j]=min(dp[i][j],dp[i-1][j]]+1);
                }
            }
        }
    }
    for(int i=n-1;i>=0;--i)
    {
        for(int j=m-1;j>=0;--j)
        {
            if(matrix[i][j]!=0)
            {
                if(j<m-1)
                {
                    dp[i][j]=min(dp[i][j],dp[i][j]+1);
                }
                if(i<n-1)
                {
                    dp[i][j]=min(dp[i][j],dp[i+1][j]+1);
                }
            }
        }
    }
    return dp;
}

题目三：


对于在矩阵内搜索正方形或长方形的题型，一种常见的做法是定义一个二维 dp 数组，其中
dp[i][j] 表示满足题目条件的、以 (i, j) 为右下角的正方形或者长方形的属性。对于本题，则表示
以 (i, j) 为右下角的全由 1 构成的最大正方形面积。如果当前位置是 0，那么 dp[i][j] 即为 0；如果
当前位置是 1，我们假设 dp[i][j] = k^2，其充分条件为 dp[i-1][j-1]、dp[i][j-1] 和 dp[i-1][j] 的值必须
都不小于 (k − 1)^2，否则 (i, j) 位置不可以构成一个边长为 k 的正方形。同理，如果这三个值中的
的最小值为 k − 1，则 (i, j) 位置一定且最大可以构成一个边长为 k 的正方形。

int maximalSquare(vector<vector<char>>&matrix)
{
    if(matrix.empty()||matrix[0].empty())
    {
        return 0;
    }
    int m=matrix.size(),n=matrix[0].size(),max_side=0;
    vector<vector<int>>dp(m+1,vector<int>(n+1,0);
    for(int i=1;i<=m;++i)
    {
        for(int j=1;j<=n;++j)
        {
            if(matrix[i-1][j-1]=='1')
                dp[i][j]=min(dp[i-1][j-1],min(dp[i][j-1],dp[i-1][j]))+1;
            }
            max_side=max(max_side,dp[i][j]);
        }
    }
    return max_side*max_side;
}