leetcode Ch2-Dynamic Programming II

一、 Longest Valid Parentheses

方法一、一维DP

class Solution
{
public:
    int longestValidParentheses(string s)
    {
        vector<int> dp(s.size(),0);
        int res=0;
        for(int i=s.size()-2;i>=0;i--)
        {
            if(s[i]==')')
                dp[i]=0;
            else
            {
                int j=i+dp[i+1]+1;
                if(j<s.size()&&s[j]==')')
                {
                    dp[i]+=dp[i+1]+2;
                    if(j+1<s.size())
                        dp[i]+=dp[j+1];
                }
            }
            res=max(res,dp[i]);
        }
        return res;
    }
};

像这种连续的子串，类似于最大连续子串和，在dp时往往是以某位置为结尾/起点。

dp[i]表示以s[i]为起点的最长连续括号数。下标j表示跨越了以s[i+1]为起点的一连串括号后到达的位置。如果该位置s[j]为'(' ,那说明以该'('为起点的有效括号数必然是0（否则就应该被包含进以s[i+1]为起点的有效括号串里了）；而如果该位置s[j]为')'，那正好和s[i]的'('匹配起来，因此s[i]可基于s[i+1]的基础上再加2，而且，除此之外还要再加上s[j+1] 。

ref1: Lexi's

#2: 忘的太快。很多细节： 判断 j < n 和 j + 1 < n。

方法二、栈

二、 Regular Expression Matching

DP解法：

ref1   ref2

 三、 Interleaving String

class Solution
{
public:
    bool isInterleave(string s1,string s2,string s3)
    {    
        int m=s1.size(),n=s2.size();
        if(m+n!=s3.size()) return false;    
        vector<vector<int>> f(m+1,vector<int>(n+1,0));
        f[0][0]=true;
        for(int i=1;i<=m;i++)
            f[i][0]=f[i-1][0]&&(s1[i-1]==s3[i-1]);
        for(int i=1;i<=n;i++)
            f[0][i]=f[0][i-1]&&(s2[i-1]==s3[i-1]);
        for(int i=1;i<=m;i++)
            for(int j=1;j<=n;j++)
                f[i][j]=(s1[i-1]==s3[i+j-1] && f[i-1][j])||(s2[j-1]==s3[i+j-1] && f[i][j-1]);
        return f[m][n];
    }
};

f[i][j]表示s1从下标0开始长度为i的子串，与s2从下标0开始长度为j的子串，它们与s3从0开始长度为i+j的子串是否是interleave string。

注意这里的i,j都是长度。所以转换为下标时别忘了减1.

另外，在line8初始化时如果是以0为初始值，那就别忘了专门把f[0][0]赋值为1。

细节很多，易出错。

#2: good.

四、 Maximal Square

class Solution
{
public:
    int maximalSquare(vector<vector<char>> &matrix)
    {
        if(matrix.empty()) return 0;
        int m=matrix.size(),n=matrix[0].size();
        vector<vector<int>> f(m,vector<int>(n,0));
        int res=0;
        for(int i=0;i<m;i++)
        {
            f[i][0]=matrix[i][0]-'0';
            res=max(res,f[i][0]);
        }
        for(int i=0;i<n;i++)
        {    
            f[0][i]=matrix[0][i]-'0';
            res=max(res,f[0][i]);
        }
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                if(matrix[i][j]=='1')
                {
                    f[i][j]=min(min(f[i-1][j],f[i][j-1]),f[i-1][j-1])+1;
                    res=max(res,f[i][j]);
                }
                else f[i][j]=0;
            }
        }
        return res*res;
    }
};

dp[i][j]表示以(i,j)为右下角的最大正方形的边长。那么，可得递推公式：dp[i][j]= min( dp[i-1][j] , dp[i][j-1] , dp[i-1][j-1] ) + 1;

该递推式可以先直观感受一下：

若该点周围3个点最小的dp值为0（即至少有一个点是‘0’），那最大正方形边长必然是1（即该点本身）；

若该点周围3个点最小的dp值为1，那么至少这3个点都是‘1’，所以已经可以构成一个边长为2的正方形；

...

ref

#2: 一堆细节易出错。题目要求的是面积，不是边长，所以最后返回的是res * res; 第一行和第一列要特殊处理，同时把它们的值都要跟res比一下并更新res。

五、 Palindrome Partitioning II

class Solution
{
public:
    int minCut(string s)
    {
        int n=s.size();
        vector<int> f(n+1,0);
        vector<vector<int>> p(n,vector<int>(n,0));
        for(int i=0;i<=n;i++)
            f[i]=n-1-i;
        for(int i=n-1;i>=0;i--)
        {
            for(int j=i;j<n;j++)
            {
                if(s[i]==s[j]&&(j-i<2||p[i+1][j-1]))
                {
                    p[i][j]=1;
                    f[i]=min(f[i],f[j+1]+1);
                }
            }
        }
        return f[0];
    }
};

设len=s.size(),  f[i]表示从s[i]开始一直到s[len-1]这段子串的minCut数（显然，最大值即为这段子串包含的字符数减1）。

这里之所以有除了f[0]~f[len-1]之外还有个f[len]= -1，是因为后面会用到。

p[i][j]表示s[i...j]这段子串是否是回文串。判断依据就是 if ( s[i]==s[j]  &&  (j-i<2 || p[i+1][j-1]) ) ，这个如果成立则说明s[i...j]是个回文串，那么就可以尝试更新一下  f[i]=min(f[i] , f[j+1]+1) ，即如果在j和j+1之间cut一下，那么s[i...len-1]即分成了s[i...j]和s[j+1...len-1]，此时的cut数等于f[j+1]+1.

ref: soul, spring 

#2: 太容易忘。

六、 Maximum Product Subarray

 O(n) space: 【非最优】

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

O(1) space 【最优】

class Solution
{
public:
    int maxProduct(vector<int> &nums)
    {
        int n=nums.size();    
        int maxsofar,minsofar,maxpre,minpre;
        int res=maxsofar=minsofar=maxpre=minpre=nums[0];
        for(int i=1;i<n;i++)
        {
            maxsofar=max(nums[i],max(maxpre*nums[i],minpre*nums[i]));
            minsofar=min(nums[i],min(maxpre*nums[i],minpre*nums[i]));    
            res=max(res,maxsofar);
            maxpre=maxsofar;
            minpre=minsofar;
        }
        return res;
    }
};

#2: 细节容易出错。

七、 Decode Ways

class Solution
{
public:
    int numDecodings(string s)    
    {
        int n=s.size();
        if(n==0) return 0;
        vector<int> dp(n+1,0);
        dp[0]=1;
        if(s[0]!='0') dp[1]=1;
        for(int i=2;i<=n;i++)
        {
            if(s[i-1]!='0')
                dp[i]+=dp[i-1];
            if(s[i-2]=='1'||(s[i-2]=='2' && s[i-1]<='6'))
                dp[i]+=dp[i-2];
        }
        return dp[n];
    }
};

dp[i]里的i表示长度，即从下标0开始的长度为i的子串的decode ways数。

要特别注意，dp[0]值为1。这是为了递推后面的值的需要。

与climb stairs是类似的。  可以用滚动数组优化空间复杂度。

ref

Backpack

Backpack II

k Sum

k Sum II

Minimum Adjustment Cost