leetcode200题之动态规划（三）

1. 最长重复子数组

（1）dp[i][j]定义： 表示 A[i:] 和 B[j:] 的最长公共前缀，那么答案即为所有 dp[i][j] 中的最大值

（2）状态转移：如果 A[i] == B[j]，那么 dp[i][j] = dp[i + 1][j + 1] + 1，否则 dp[i][j] = 0。

 考虑到这里 dp[i][j] 的值从 dp[i + 1][j + 1] 转移得到，所以我们需要倒过来，首先计算 dp[len(A) - 1][len(B) - 1]，最后计算 dp[0][0]

class Solution {
public:
    int findLength(vector<int>& A, vector<int>& B) {
        int size_A=A.size();
        int size_B=B.size();
        vector<vector<int>> dp(size_A+1,vector<int>(size_B+1));
        int ans=0;
        for(int i=size_A-1; i>=0; i--){
            for(int j=size_B-1; j>=0; j--){
                if(A[i]==B[j]){
                    dp[i][j]=dp[i+1][j+1]+1;
                }
                else dp[i][j]=0;
                if(ans<dp[i][j]){
                    ans=dp[i][j];
                }
            }
        }
        return ans;
    }
};

2. 最大子序和

（1）dp[i]含义：以第 i 个数结尾的连续子数组的最大和

（2）状态转移：dp[i] = max(dp[i-1]+nums[i], nums[i])  

解释：我们如何求 dp[i] 呢？可以考虑 nums[i] 单独成为一段还是加入 dp[i-1] 对应的那一段，这取决于 nums[i] 和 dp[i-1]+nums[i]  的大小，我们希望获得一个比较大的

（3）base case： dp[0]=nums[0]

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n=nums.size();
        vector<int> dp(n);
        dp[0]=nums[0];
        int res=nums[0];
        for(int i=1; i<n; i++){
            dp[i]=max(dp[i-1]+nums[i], nums[i]);
            if(dp[i]>res){
                res=dp[i];
            }
        }
        return res;
    }
};

3. 乘积最大子数组

（1） dp[i][j]含义：以 nums[i] 结尾的子数组的乘积最值，

• 当 j = 0 的时候，表示计算的是最小值；
• 当 j = 1 的时候，表示计算的是最大值。

（2）状态转移：

典型错误想法：dp[i] = max(dp[i-1]*nums[i], nums[i]) ，因为存在负负得正。

如果当前位置是一个负数的话，那么我们希望以它前一个位置结尾的某个段的积也是个负数，这样就可以负负得正，并且我们希望这个积尽可能负得更多，即尽可能小。

如果当前位置是一个正数的话，我们更希望以它前一个位置结尾的某个段的积也是个正数，并且希望它尽可能地大。

因此需要维护两个最值。

（3）base case:   dp[0][0] = nums[0]       dp[0][1] = nums[0]

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int n=nums.size();
        if(n<1)  return 0;
        vector<vector<int>> dp(n, vector<int>(2));
        dp[0][0]=nums[0];
        dp[0][1]=nums[0];
        int res=dp[0][1];
        for(int i=1; i<n; i++){
            if(nums[i]>=0){
                dp[i][1]=max(dp[i-1][1]*nums[i],nums[i]);
                dp[i][0]=min(dp[i-1][0]*nums[i],nums[i]);
               
            }
            else{
                dp[i][0]=min(dp[i-1][1]*nums[i],nums[i]);
                dp[i][1]=max(dp[i-1][0]*nums[i],nums[i]);
            }
            res = max(res, dp[i][1]);
        }   
        return res;
    }
};

4. 最小路径和

（1）dp[i][j]含义：运动到（i,j) 位置时的最小路径

（2）状态转移：注意到只能右移和下移，所以dp[i][j]与dp[i-1][j]、dp[i][j-1]有关

                                                              dp[i][j]=min(dp[i-1][j], dp[i][j-1])+grid[i][j]

（3）边界条件：

                      上边界：dp[0][j] = dp[0][j-1] + grid[0][j];

                      左边界：dp[i][0] = dp[i-1][0]+grid[i][0];

（4）初始值：dp[0][0]=grid[0][0]

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int row=grid.size();
        int col=grid[0].size();
        vector<vector<int>> dp(row, vector<int> (col));
        dp[0][0]= grid[0][0];
        for(int i=1; i<row; i++){
            dp[i][0] = dp[i-1][0]+grid[i][0];
        }
        for(int j=1; j<col; j++){
            dp[0][j] = dp[0][j-1] + grid[0][j];
        }

        for(int i=1;  i<row; i++){
            for(int j=1; j<col; j++){
                dp[i][j]=min(dp[i-1][j], dp[i][j-1])+grid[i][j];
            }
        }
        return dp[row-1][col-1];
    }
};

 5. 回文子串

（1）dp[i][j]定义：表示字符串 s 的第 i 到 j 个字母组成的串是否是回文子串

（2）状态转移：若s[i]==s[j]  , 那么dp[i][j]=dp[i+1][j-1];

（3）边界条件：上述前提子串长度>2;   

考虑子串的长度为 1 或 2。对于长度为 1 的子串，它显然是个回文串；对于长度为 2 的子串，只要它的两个字母相同，它就是一个回文串。表达式 [i + 1, j - 1] 不构成区间，即长度严格小于 2，即 j - 1 - (i + 1) + 1 < 2 ，整理得 j - i < 3。因此，在 s[i] == s[j] 成立和 j - i < 3 的前提下，直接可以下结论，dp[i][j] = true，否则才执行状态转移。

（4）初始化：单个字符一定是回文串，因此把对角线先初始化为 true，即 dp[i][i] = true 。

class Solution {
public:
    int countSubstrings(string s) {
        int n=s.size();
        int res=s.size();
        vector<vector<bool>> dp(n, vector<bool>(n));
        for(int i=0; i<n; i++){
            dp[i][i]=true;
        }
        for(int j=1; j <n; j++){
            for(int i=0; i<j; i++){
                if(s[i]!=s[j]){
                    dp[i][j]=false;
                }
                else{
                    if((j-1)-(i+1)+1 < 2)  dp[i][j]=true;
                    else  dp[i][j]=dp[i+1][j-1];
                }
                if(dp[i][j]){
                    res++;
                }
            }
        }
        return res;
    }
};