动态规划类题目的解决之道

首先明确无法用动态规划的情况有哪些？

第一种，无法提前知道拓扑排序，也就是无法知道填充顺序。

第二种，没有重复计算，dependencygraph里node的入度都是1，没必要用dp。

第三种，依赖关系构成环。

知道拓扑关系，就知道填充数组或者矩阵的顺序是什么样的，到底是从上到下还是从右向左还是斜着对角线。

动态规划的解决步骤：

definition: dp[i] 表示是f(i) 是多少 => 存的是value
induction rule: dp[i] = dp[i - 1] + dp[i - 2] => cose: O(1)
base case: dp[0]  dp[1]
filling order: 从左往右
result: max(dp[i])
optimized on space or time:

下面节选几个leetcode上的动态规划题目：

（1）97题：给定s1,s2，求s3是否是由s1和s2形成的，组合交错形成也是可以的。

思路是，二维动态规划，dp[i][j]表示s1取前i位，s2取前j位，是否能构成s3的前i+j位。

递推公式如下：

 if(i==0 && j==0) dp[i][j]=true;
                else if(i>0 && s1[i-1]==s3[i+j-1] && dp[i-1][j])
                    dp[i][j]=true;
                else if(j>0 && s2[j-1]==s3[i+j-1] && dp[i][j-1])
                    dp[i][j]=true;

（2）72题：编辑距离：给定两个单词w1和w2，求最少需要操作多少次，才能将w1变成w2。操作方式包括插入，删除，替换。也是二维动态规划解决的问题，递推公式是

如果w1[i-1]==w2[j-1]: dp[i][j]=dp[i-1][j-1]；
如果w1[i-1]!=w2[j-1]：dp[i][j]= min(dp[i-1][j-1]+1,min(dp[i-1][j]+1,dp[i][j-1]+1));
分别对应的是，替换，删除和插入。

（3）120题：三角形，给定一个三角形，找出路径和的最小值，从顶到底部，每一步只能找与它相邻位置的路径。这个题从底部到顶走比较好，最后一行的最短路径等于它所在位置本身。递推公式是dp[i][j]=min(dp[i+1][j+1],dp[i+1][j])+t[i][j];  返回的是dp[0][0];

 int minimumTotal(vector<vector<int>>& t) 
    {
        int n=t.size();
        vector<vector<int>> dp(n,vector<int>(n,0));
        dp[n-1]=t[n-1];//最后一行的最短路径等于它所在位置本身。
        for(int i=n-2;i>=0;i--)
        {
            for(int j=0;j<t[i].size();j++)
            {
                dp[i][j]=min(dp[i+1][j+1],dp[i+1][j])+t[i][j];
            }
        }
        return dp[0][0];       
}

（4） Maximum Product Subarray

这个题的解法：需要维护的当前最大值和当前最小值，都是在dp_min[i-1] * A[i]，dp_max[i] * A[i]，和A[i]这三者里面取一即可。状态的跳转是需要前一个位置的最大值，最小值和当前位置的值。

class Solution 
{
public:
    int maxProduct(vector<int>& nums)
    {
       int pMax=1,nMax=1,m=INT_MIN;
       int n=nums.size();
       for(int i=0;i<n;i++)
       {
           if(nums[i]<0) swap(pMax,nMax);
           pMax=max(pMax*nums[i],nums[i]);
           nMax=min(nMax*nums[i],nums[i]);
           m=max(m,pMax);
       }
        return m;
    }
};