leetcode Ch2-Dynamic Programming I

一、

1. Edit Distance

class Solution
{
public:
    int minDistance(string t1,string t2)
    {
        int len1=t1.size(),len2=t2.size();
        vector<vector<int>> dp(len1+1,vector<int>(len2+1,0));
        for(int i=0;i<=len1;i++) dp[i][0]=i;
        for(int i=0;i<=len2;i++) dp[0][i]=i;
        for(int i=1;i<=len1;i++)
        {
            for(int j=1;j<=len2;j++)
            {
                dp[i][j]=min(min(dp[i-1][j]+1,dp[i][j-1]+1),dp[i-1][j-1]+(t1[i-1]==t2[j-1]?0:1));
            }
        }
        return dp[len1][len2];
    }
};

需要注意的细节是dp里的下标和字符串t中的下标不是一致的（Line14），是差了1的。即dp[i][j]所对应的是t1中的第i-1位和t2中的第j-1
位，即t1[i-1],t2[j-1]。因为dp中的下标代表的是对应字符串的长度。

#2: 又漏了种情况。当word1和word2末尾元素不相等时，有3种可能的操作：除dp[i-1][j]+1,dp[i][j]+1之外，还有 dp[i-1][j-1]+1。 

2. Distinct Subsequences

class Solution
{
public:
    int numDistinct(string s,string t)
    {
        int sLen=s.size(),tLen=t.size();
        vector<vector<int>> dp(sLen+1,vector<int>(tLen+1,0));
        for(int i=0;i<=sLen;i++) dp[i][0]=1;
        for(int i=1;i<=sLen;i++)
        {
            for(int j=1;j<=tLen;j++)
            {
                dp[i][j]=dp[i-1][j]+(s[i-1]==t[j-1]? dp[i-1][j-1]:0 );        
            }
        }
        return dp[sLen][tLen];
    }
};

递推式不难，关键是正确理解题意和初始化。

题目说的是T是S任意删掉若干字符得到的结果。那么当T为空时，从S中只有一种删法能够得到T（那就是删光）。所以dp[i][0]都是1. 这一步初始化很重要。

 dp[i][j]是S长度为i（从下标0开始），T长度为j（从下标0开始）所对应的删法的个数。

易出错。

#2: 忘记递推关系了; 初始化的时候是=1；

3. Scramble String

用vector，不用数组 (推荐)

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

用数组（不推荐）

class Solution
{
public:
    bool isScramble(string s1,string s2)
    {
        const int N=s1.size();
        if(N!=s2.size()) return false;
        bool f[N+1][N][N];
        fill_n(&f[0][0][0],(N+1)*N*N,false);
        for(int i=0;i<N;i++)
            for(int j=0;j<N;j++)
                f[1][i][j]=(s1[i]==s2[j]);
        for(int n=2;n<=N;n++)
        {
            for(int i=0;i<=N-n;i++)
            {
                for(int j=0;j<=N-n;j++)
                {
                    for(int k=1;k<n;k++)
                    {
                        if((f[k][i][j]&&f[n-k][i+k][j+k])||(f[k][i][j+n-k]&&f[n-k][i+k][j]))
                        {
                            f[n][i][j]=true;
                            break;
                        }
                    }
                }
            }
        }
        return f[N][0][0];
    }
};

简单的说，就是s1和s2是scramble的话，那么必然存在一个在s1上的长度l1，将s1分成s11和s12两段，同样有s21和s22。

那么要么s11和s21是scramble的并且s12和s22是scramble的；要么s11和s22是scramble的并且s12和s21是scramble的。

springfor的总结不错。

这道题很多细节容易出错，要谨慎。

注意：这个代码在VS下通不过，虽然能过OJ。

#2: 忘记对 f[1][i][j] 的初始化了。而且写的巨慢。

注意：k是从1到n-1的，不能从0开始，那会导致越界。

二、最长递增子序列 LIS

见此整理，三。'

#2： 老是重复犯一个错误！！！每次应用binarySearch的时候都用到了nums上，应该是用到存储当前位置最小元素的数组B上！！！

三、矩阵链乘

int matrixChain(vector<pair<int,int>> &vp)
{
    int len = vp.size();
    vector<vector<int>> dp(SIZE, vector<int>(SIZE, INT_MAX));
    for (int i = 0; i<len; i++) dp[i][i] = 0;
    for (int L = 2; L <= len; L++)
    {
        for (int i = 0; i <= len - L; i++)
        {
            int j = i + L - 1;
            int minV = INT_MAX;
            for (int k = i; k < j; k++)
            {
                if (dp[i][k] + dp[k + 1][j] + vp[i].first*vp[k].second*vp[j].second<minV)
                    minV = dp[i][k] + dp[k + 1][j] + vp[i].first*vp[k].second*vp[j].second;
            }
            dp[i][j] = minV;
        }
    }
    return dp[0][len - 1];
}

需要注意的是Line12，k<j，不能是k<=j. 因为我们的划分是划分成[i...k][k+1...j],所以对于后半段需要满足k+1<=j，即k必须小于j。

完整代码：

不能首尾相连版：

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

#define SIZE 1000
void init(vector<pair<int, int>> &vp)
{
    int n;
    cin >> n;
    while (n--)
    {
        int x, y;
        cin >> x >> y;
        vp.push_back(make_pair(x, y));
    }
}

int matrixChain(vector<pair<int,int>> &vp)
{
    int len = vp.size();
    vector<vector<int>> dp(SIZE, vector<int>(SIZE, INT_MAX));
    for (int i = 0; i<len; i++) dp[i][i] = 0;
    for (int L = 2; L <= len; L++)
    {
        for (int i = 0; i <= len - L; i++)
        {
            int j = i + L - 1;
            int minV = INT_MAX;
            for (int k = i; k < j; k++)
            {
                if (dp[i][k] + dp[k + 1][j] + vp[i].first*vp[k].second*vp[j].second<minV)
                    minV = dp[i][k] + dp[k + 1][j] + vp[i].first*vp[k].second*vp[j].second;
            }
            dp[i][j] = minV;
        }
    }
    return dp[0][len - 1];
}

int main()
{
    vector<pair<int, int>> vp;
    init(vp);
    cout << matrixChain(vp) << endl;
}

可以首尾相连版：

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

struct mat {
    int rowNum;
    int colNum;
};

void init(vector<mat> &v) {
    int n;
    cin >> n;
    while (n--) {
        mat tmp;
        cin >> tmp.rowNum >> tmp.colNum;
        v.push_back(tmp);
    }
}

int matMultiply(vector<mat> &v) {
    int len = v.size();
    if (len == 0) {
        return 0;
    }
    vector<vector<int> > dp(2 * len, vector<int>(2 * len, INT_MAX));
    for (int i = 0; i < 2 * len; i++) {
        dp[i][i] = 0;
    }
    int minV = INT_MAX;
    for (int L = 2; L <= len; L++) {
        for (int i = 0; i <= 2 * len - L; i++) {
            int j = i + L - 1;
            for (int k = i; k < j; k++) {
                int tmp = dp[i][k] + dp[k + 1][j] + v[i % len].rowNum * v[k % len].colNum * v[j % len].colNum;
                dp[i][j] = min(dp[i][j], tmp);
            }
            if (L == len) {
                minV = min(minV, dp[i][j]);
            }
        }
    }
    return minV;
}

int main() {
    vector<mat> v;
    init(v);
    cout << matMultiply(v) << endl;
    return 0;
}

 reference

#2: 犯的错误：if(L == len) 放错位置，放在了i循环外面。

四、最长公共子序列 LCS

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int lcs(string t1, string t2, vector<vector<int>> &trace)
{
    int len1 = t1.size(), len2 = t2.size();
    vector<vector<int>> dp(t1.size() + 1, vector<int>(t2.size() + 1, 0));
    for (int i = 1; i <= len1; i++)
    {
        for (int j = 1; j <= len2; j++)
        {
            if (t1[i - 1] == t2[j - 1])
            {
                dp[i][j] = dp[i - 1][j - 1] + 1;
                trace[i][j] = 0;
            }
            else
            {
                if (dp[i - 1][j]>dp[i][j - 1])
                {
                    dp[i][j] = dp[i - 1][j];
                    trace[i][j] = 1;
                }
                else
                {
                    dp[i][j] = dp[i][j - 1];
                    trace[i][j] = 2;
                }
            }
        }
    }
    return dp[len1][len2];
}

void print(vector<vector<int>> &trace, int i, int j, string t1)
{
    if (i == 0 || j == 0) return;
    if (trace[i][j] == 0)
    {
        print(trace, i - 1, j - 1,t1);
        cout << t1[i-1];
    }
    else if (trace[i][j] == 1)
        print(trace, i - 1, j, t1);
    else if(trace[i][j]==2)
        print(trace, i, j - 1, t1);
}

int main()
{
    string t1;
    string t2;
    cin >> t1 >> t2;
    vector<vector<int>> trace(t1.size()+1, vector<int>(t2.size()+1, -1));
    lcs(t1, t2, trace);
    print(trace, t1.size(), t2.size(), t1);
    //cout << endl;
}

这里仍然是需要注意下标问题。dp[i][j]里的下标仍然代表的是长度，即对应t1[i-1],t2[j-1]. 不过trace的下标和dp一样，也是长度。这里构造出LCS序列时，可以如代码中那样利用递归，也可以while(dp[i][j]) if(dp[i][j]==dp[i-1][j]) i--; ........... 用while循环来做。（refer to bnuzhanyu in 51nod）

reference and 算法概论，算法导论

#2: 忘记了怎么递归地output。

五、

1. 最长重复子串 Longest Repeat Substring (LRS)

最长重复子串是单字符串问题。本题中默认为允许重叠。

直观做法 O(n^3)

#include <string>
#include <vector>
#include <iostream>
using namespace std;

int comp(string str, int i, int j)
{
    int len = 0;
    while (i<str.size() && j<str.size() && str[i] == str[j])
    {
        len++;
        i++; j++;
    }
    return len;
}
int lrs(string str,int &maxIndex)
{
    int maxV = 0;
    for (int i = 0; i<str.size(); i++)
    {
        for (int j = i + 1; j<str.size(); j++)
        {
            int len = comp(str, i, j);
            if (len>maxV) {
                maxV = len;
                maxIndex = i;
            }
        }
    }
    return maxV;
}

void output(string str, int maxIndex,int len)
{
    while (len--)
    {
        cout << str[maxIndex++];
    }
}

int main()
{
    string str("banana");
    int maxIndex = 0;
    int len= lrs(str,maxIndex);
    output(str,maxIndex,len);
    return 0;
}

refer1

refer2

后缀数组做法：

最长公共子序列|最长公共子串|最长重复子串|最长不重复子串|最长回文子串|最长递增子序列|最大子数组和

2. Longest Substring Without Repeating Characters [最长不重复子串]

class Solution {
public:
    int lengthOfLongestSubstring(string str) {
        vector<bool> exist(256, false);
        int n = str.size();
        int i = 0, j = 0;
        int maxlen = 0;
        while (j < n) {
            if (exist[str[j]]) {
                maxlen = max(maxlen, j - i);
                while (str[i] != str[j]) {
                    exist[str[i]] = false;
                    i++;    
                }
                i++;
                j++;
            } else {
                exist[str[j]] = true;
                j++;
            }
        }
        maxlen = max(maxlen, n - i);
        return maxlen;
    }
};

ref

六、

1. Unique Binary Search Trees

class Solution
{
public:
    int numTrees(int n)
    {
        vector<int> g(n+1,0);
        g[0]=g[1]=1;
        for(int i=2;i<=n;i++)
        {
            for(int j=0;j<i;j++)
            {
                g[i]+=g[j]*g[i-1-j];
            }
        }
        return g[n];
    }
};

g[n]表示对于长为n的序列能有多少个UniqueBST。循环里的 i 表示序列长度，依次从短向长计算，直到计算出最终结果g[n].

g[n]=g[0]*g[n-1]+g[1]*g[n-2]+...+g[n-1]*g[0]

ref 解释的非常清楚。

2. Unique Binary Search Trees II

class Solution
{
public:
    vector<TreeNode*> generateTrees(int n)
    {
        return dfs(1,n);
    }
    vector<TreeNode*> dfs(int min,int max)
    {
        vector<TreeNode*> res;
        if(min>max) 
        {
            res.push_back(NULL);//表示空树，不可缺少。否则会影响下面对leftSub,rightSub的循环。
            return res;
        }
        for(int i=min;i<=max;i++)
        {
            vector<TreeNode*> leftSub=dfs(min,i-1);
            vector<TreeNode*> rightSub=dfs(i+1,max);
            for(int j=0;j<leftSub.size();j++)
            {
                for(int k=0;k<rightSub.size();k++)
                {
                    TreeNode* root=new TreeNode(i);
                    root->left=leftSub[j];
                    root->right=rightSub[k];
                    res.push_back(root);
                }
            }
        }
        return res;
    }
};

对于Line11-15，当min>max时表示空树。空树必须要加进去一个NULL来表示出来，否则，对于下面分别从leftSub和rightSub取出一个元素组成两个子树时，如果一边(假设为leftSub)为空且没有表示出空树来的话，这一层for循环就不能执行了，那对于有n-1个节点的rightSub的各种形态都没法执行循环列出来了。整个双层for循环都没法用了。

ref

#2: 想不出怎么实现的了。而且Line24如果放在两层循环的外面是会WA的，还没明白为什么。

七、

1. Maximum Subarray 最大子数组和

code1: [美观]

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

code2:[不够美观]

class Solution
{
public:
    int maxSubArray(vector<int> &nums)
    {
        int sum=0;
        int maxV=INT_MIN;
        for(int i=0;i<nums.size();i++)
        {
            if(sum<0) sum=0;
            sum+=nums[i];
            if(sum>maxV) maxV=sum;
        }
        return maxV;
    }
};

采用dp来做的话，dp[n]代表从arr[0]到arr[n]的最大子数组和。它的子问题dp[n-1]是从arr[0]到arr[n-1]的最大子数组和。注意，起点始终是arr[0].

看一下july列出的扩展问题。以及勇幸的整理。

1. 如果数组是二维数组，同样要你求最大子数组的和列?
2. 如果是要你求子数组的最大乘积列?
3. 如果同时要求输出子段的开始和结束列?

另外，关于如何用divide and conquer来解此问题，详见此贴。

2. 环形最大连续数组和

int maxConsSum(const vector<int> &arr)
{
    int dp=0,res=0;
    for(int i=0;i<arr.size();i++)
    {
        dp=max(arr[i],dp+arr[i]);
        res=max(res,dp);
    }
    return res;
}

int minConsSum(const vector<int> &arr)
{
    int dp=0,res=0;
    for(int i=0;i<arr.size();i++)
    {
        dp=min(arr[i],dp+arr[i]);
        res=min(dp,res);
    }
    return res;
}


int maxConsSum2(const vector<int> &arr) {
    int sum=0;
    for(int i=0;i<arr.size();i++)
        sum+=arr[i];
    int m1=maxConsSum(arr);
    int m2=minConsSum(arr);
    int res=max(m1,sum-m2);
    return res;
}

ref1   ref2

一开始的思路和ref2里刚开始说的那样，想着首尾拼接起来成一个长数组。但是貌似需要O(n*n)才行（难道是列举出长度为arr.size()的这n个数组，分别对其执行最大子段和MaxSubArray的O(n)算法？还没进行实现。）后来参考了ref2和ref1的代码，如果跨越了末尾就用（数组元素之和-最小子段和），如果没跨越就用（最大子段和）。对其取max即可。

注意一个与上题不同的细节。这题里说可以允许有空段，而上题里要求是至少含有一个元素。因此res的初值一个为INT_MIN，一个为0.

另外，再看一下ref3提到的几个拓展问题。

可以理解为：若环形最大子段和需要跨越首尾，那么最小子段和必然不需要跨越。举个极端的例子就是，首尾元素都是正数，其余元素都是负数。

八、Climbing Stairs

空间复杂度O(n):【非最优】

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

若不能开辟数组的话。

空间复杂度O(1):

class Solution
{
public:
    int climbStairs(int n)
    {
        int prev=0,curr=1;
        int tmp=0;
        for(int i=1;i<=n;i++)
        {
            tmp=curr;
            curr+=prev;
            prev=tmp;        
        }
        return curr;
    }
};

使用3个变量即可。和Fibonacci一样。

九、

1. Unique Paths

空间复杂度O(mn) 【非最优】

class Solution
{
public:
    int uniquePaths(int m,int n)
    {
        vector<vector<int>> dp(m,vector<int>(n,0));
        for(int i=0;i<m;i++)
            dp[i][0]=1;
        for(int i=0;i<n;i++)
            dp[0][i]=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];
    }
};

空间复杂度O(n) 【非最优】

class Solution
{
public:
    int uniquePaths(int m,int n)
    {
        vector<int> dp(n,1);
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                dp[j]=dp[j]+dp[j-1];
            }
        }
        return dp[n-1];
    }
};

等式左边的dp[j]代表dp[i][j],等式右边的dp[j]代表dp[i-1][j]. 而dp[j-1]代表dp[i][j-1].

可参考 ref1  ref2 学习一下滚动数组。

 利用公式 【最优】

class Solution
{
public:
    int uniquePaths(int m,int n)
    {
        int N=m+n-2;
        int k=min(n-1,m-1);
        double res=1.0;
        for(int i=1;i<=k;i++)
            res*=(double)(N-i+1)/i;
        return round(res);                    
    }
};

注意：Line10必须加double，否则等号右边精度就丢失了；Line11不能用(int)，要用round,这样得到的结果还能四舍五入到准确值，否则用int的话有可能就和准确结果差了1

ps: round实现如下：

double round(double number)
{
    return number < 0.0 ? ceil(number - 0.5) : floor(number + 0.5);
}

ref      绝对严格的准确解参考soulmach。

2. Unique Paths II

class Solution
{
public:
    int uniquePathsWithObstacles(vector<vector<int>> &obstacleGrid)
    {
        if(obstacleGrid.empty()) return 0;
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        vector<vector<int>> dp(m,vector<int>(n,0));
        for(int i=0;i<m;i++)
        {
            if(obstacleGrid[i][0]==1)
                break;
            dp[i][0]=1;
        }
        for(int i=0;i<n;i++)
        {
            if(obstacleGrid[0][i]==1)
                break;
            dp[0][i]=1;
        }
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                if(obstacleGrid[i][j]==1)
                    dp[i][j]=0;
                else
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

注意Line22,24，一定要从1开始。从0开始就错了，因为后面需要递推i-1,j-1。

用滚动数组法节省空间：

3. Minimum Path Sum

class Solution
{
public:
    int minPathSum(vector<vector<int>> &grid)
    {
        if(grid.empty()) return 0;
        int m=grid.size(),n=grid[0].size();
        vector<vector<int>> dp(m,vector<int>(n,0));
        dp[0][0]=grid[0][0];
        for(int i=1;i<m;i++)
            dp[i][0]=dp[i-1][0]+grid[i][0];
        for(int i=1;i<n;i++)
            dp[0][i]=dp[0][i-1]+grid[0][i];
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }
        return dp[m-1][n-1];
    }
};

4. Dungeon Game

class Solution
{
public:
    int calculateMinimumHP(vector<vector<int>> &dungeon)
    {
        if(dungeon.empty()) return 1;
        int m=dungeon.size(),n=dungeon[0].size();
        vector<vector<int>> dp(m,vector<int>(n,0));
        dp[m-1][n-1]=max(1,1-dungeon[m-1][n-1]);
        for(int i=m-2;i>=0;i--)
            dp[i][n-1]=max(1,dp[i+1][n-1]-dungeon[i][n-1]);
        for(int i=n-2;i>=0;i--)
            dp[m-1][i]=max(1,dp[m-1][i+1]-dungeon[m-1][i]);
        for(int i=m-2;i>=0;i--)
            for(int j=n-2;j>=0;j--)
                dp[i][j]=max(1,min(dp[i+1][j],dp[i][j+1])-dungeon[i][j]);
        return dp[0][0];
    }
};

dp[i][j]: 在走进dungeon[i][j]之前至少应有的hp值。

一开始自己写的太罗嗦了，一堆判断语句，结果其实就用一句max(1,dp[][]-dungeon[][])就行了。

 ref    ref2

#2: 特殊处理的行和列分别是 m-1行和 n-1列， 不是0！

此外，递推出错。最重要的递推公式是max(1, min(.....)), 别想当然。

十、

1. Best Time to Buy and Sell Stock

code1:

class Solution
{
public:
    int maxProfit(vector<int>& prices)
    {
        if(prices.size()<2) return 0;
        int dp=0,minV=prices[0];
        for(int i=1;i<prices.size();i++)
        {    
            dp=max(dp,prices[i]-minV);
            minV=min(minV,prices[i]);
        }
        return dp;
    }
}; 

code2:

class Solution
{
public:
    int maxProfit(vector<int> &prices)
    {
        if(prices.size()==0) return 0;
        int min=prices[0];
        int res=0;
        for(int i=1;i<prices.size();i++)
        {
            if(prices[i]<min) min=prices[i];
            if(prices[i]-min>res) res=prices[i]-min;
        }
        return res;
    }
};

和最大连续子数组和类似。子问题都是以当前位置作为结尾（卖出点）时的最优解。取这N个最优解中的最大值。但是MaxSubArray里是一定包括当前位置的，本题里不一定包括当前位置，只是指定一个范围。

2. Best Time to Buy and Sell Stock III

class Solution
{
public:
    int maxProfit(vector<int> &prices)
    {
        if(prices.size()<2) return 0;
        const int n=prices.size();
        vector<int> f(n,0);
        vector<int> g(n,0);
        int minV=prices[0],maxV=prices[n-1];
        for(int i=1;i<n;i++)
        {
            f[i]=max(f[i-1],prices[i]-minV);
            minV=min(minV,prices[i]);
        }
        for(int i=n-2;i>=0;i--)
        {
            g[i]=max(g[i+1],maxV-prices[i]);
            maxV=max(maxV,prices[i]);
        }
        int res=0;
        for(int i=0;i<n;i++)
        {
            res=max(f[i]+g[i],res);
        }
        return res;
    }
};

f[i]是记录[0..i]中的最大收益，是从前向后算的；g[i]是记录[i..n-1]中的最大收益，是从后向前算的。

【注意】不要忘了第一句prices为空时的操作！细节很重要！pay attention to corner case !

ref:soulMach.

本题是最多允许两次交易。看看扩展到最多k次交易的一般情况。reference    【最大M子段和】

3.  Best Time to Buy and Sell Stock IV

ref1      ref2       ref3       ref4  

十一、 

1. House Robber

方法一：O(n) space

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

递推公式：dp[i] = max(dp[i-1], dp[i-2]+nums[i-1])

其中这里的i指的是从下标0开始的长为i的序列能rob到的最大值。注意长度为i的序列对应的末尾元素应是nums[i-1],别忘了减1.

之前感觉递推公式不太对，因为毕竟这里的dp[i]是表示的从0到下标i这个区间范围内所能取到的最大值，不一定包含末尾元素。这样的话dp[i-2]就有可能不包含nums[i - 3],而是以nums[i - 4]结尾，因此在它的基础上可以加上nums[i - 2]，并在这种方案下取到最大值。但是后来想明白了，其实这种情况是已经包含在dp[i-1]这种情况里了。dp[i-1]所不能涵盖的就是dp[i-2]+nums[i-1]这种情况。因此最终在dp[i-1]和dp[i-2]+nums[i-1]之间取个较大值即可。

总结起来就是，dp[i]的大多数情况都能被dp[i-1]所代替。dp[i-1]唯一代替不了的方案是以nums[i-1]为结尾元素的方案，即dp[i-2] + nums[i-1]. 将这两大方案取个较大值即可。

ref

#2: dp[i]里的i是表示的长度。所以开辟的vector是n+1大小的。但是在line11处却用的是i < n. 应该是 i <= n.

方法二：O(1) space

class Solution
{
public:
    int rob(vector<int> &nums)
    {
        if(nums.size()==0) return 0;
        int odd=0,even=0;
        for(int i=0;i<nums.size();i++)
        {
            if(i%2==0)
                even=max(odd,even+nums[i]);
            else
                odd=max(even,odd+nums[i]);
        }
        return even>odd?even:odd;
    }
};

odd是之前在奇数位达到的最大值，even是之前在偶数位达到的最大值。

follow up: 如果首尾相连呢？

2. House Robber II

code 1:

class Solution
{
public:
    int rob(vector<int> &nums)
    {
        if(nums.size()==0) return 0;
        if(nums.size()==1) return nums[0];
        int odd=0,even=0;
        for(int i=0;i<nums.size()-1;i++)
        {        
            if(i%2==0)
                even=max(odd,even+nums[i]);
            else
                odd=max(even,odd+nums[i]);
        }
        int res1=max(even,odd);
        even=odd=0;
        for(int i=1;i<nums.size();i++)
        {        
            if(i%2==0)
                even=max(odd,even+nums[i]);
            else
                odd=max(even,odd+nums[i]);
        }
        int res2=max(even,odd);
        return max(res1,res2);
    }
};

code 2:

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

如果首尾相连，其实就意味着首和尾最多只能有1个（也可能都没有，反正不能同时出现）。所以就对上一题的算法跑两遍，一遍去掉头，一遍去掉尾。取这两次结果的较大值即可。

十二、 Triangle

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

 从下向上计算确实比从上向下要简单很多，没有额外的边界条件需要考虑。

滚动数组版： 

十三、

1. Word Break

先来个dfs版的。一阵子不练dfs就生疏了。

class Solution
{
public:
    bool wordBreak(string s, unordered_set<string> &wordDict)
    {
        return dfs(s, wordDict, 0);
    }
    bool dfs(string s, unordered_set<string> &wordDict, int start)
    {
        if (start == s.size())
            return true;
        for (int i = start; i<s.size(); i++)
        {
            if (wordDict.count(s.substr(start, i - start + 1))>0)
            {
                if (dfs(s, wordDict, i + 1))
                    return true;
            }
        }
        return false;
    }
};

DP:

class Solution
{
public:
    bool wordBreak(string s, unordered_set<string> &wordDict)
    {
        vector<bool> dp(s.size()+1,0);
        dp[0]=1;
        for(int i=1;i<=s.size();i++)
        {
            for(int j=0;j<i;j++)    
            {
                if(dp[j]&&wordDict.count(s.substr(j,i-j))>0)
                {
                    dp[i]=true;
                    break;
                }
            }
        }
        return dp[s.size()];
    }
};

i表示当前子串的长度（从下标0开始），j表示此时把子串分割成的左半段的长度。dp[i]就表示从0开始长度为i的子串是不是满足wordBreak的。

ref     自底向上，由小到大的构造出来。

2. Word Break II

常规dfs版：【TLE】

class Solution
{
public:
    vector<string> wordBreak(string s,unordered_set<string> &wordDict)
    {
        dfs(s,wordDict,0);
        return result;
    }
    vector<string> result;
    string path;
    void dfs(string s,unordered_set<string> &wordDict,int start)
    {
        if(start==s.size())    
        {
            result.push_back(path);
            return;
        }
        for(int i=start;i<s.size();i++)
        {
            if(wordDict.count(s.substr(start,i-start+1))>0)
            {
                if(!path.empty()) path+=" ";
                path+=s.substr(start,i-start+1);
                dfs(s,wordDict,i+1);
                path.resize(path.size()-(i-start+1));
                if(!path.empty()) path.resize(path.size()-1);
            }
        }
    }
};

改进版dfs--dp剪枝版：（除了利用word break里的函数外，只比上面的 [常规dfs版] 多了line6这一句话）

class Solution
{
public:
    vector<string> wordBreak(string s,unordered_set<string> &wordDict)
    {
        if(!isWordBreak(s,wordDict)) return result;
        dfs(s,wordDict,0);
        return result;
    }
private:
    vector<string> result;
    string path;
    void dfs(string s,unordered_set<string> &wordDict,int start)
    {
        if(start==s.size())    
        {
            result.push_back(path);
            return;
        }
        for(int i=start;i<s.size();i++)
        {
            if(wordDict.count(s.substr(start,i-start+1))>0)
            {
                if(!path.empty()) path+=" ";
                path+=s.substr(start,i-start+1);
                dfs(s,wordDict,i+1);
                path.resize(path.size()-(i-start+1));
                if(!path.empty()) path.resize(path.size()-1);
            }
        }
    }
    
    bool isWordBreak(string s, unordered_set<string> &wordDict)
    {
        vector<bool> dp(s.size()+1,0);
        dp[0]=1;
        for(int i=1;i<=s.size();i++)
        {
            for(int j=0;j<i;j++)    
            {
                if(dp[j]&&wordDict.count(s.substr(j,i-j))>0)
                {
                    dp[i]=true;
                    break;
                }
            }
        }
        return dp[s.size()];
    }
};

参考该博客，dp的作用只有1行，line6处。

纯dp版:

refer to discuss

十四、

1. Largest Rectangle in Histogram

class Solution
{
public:
    int largestRectangleArea(vector<int> &height)
    {
        stack<int> s;
        height.push_back(0);
        int i=0,res=0;
        while(i<height.size())
        {
            if(s.empty()||height[i]>=height[s.top()])
                s.push(i++);
            else
            {
                int tmp=s.top();
                s.pop();
                res=max(res,height[tmp]*(s.empty()?i:i-s.top()-1));
            }
        }
        return res;
    }
};

 关键是对于一个特定的柱体，如何最大限度的向左右扩展。

首先看向右扩展。假设当前需要出栈的柱体的下标是x，那么当它要出栈时，说明当前遍历到的下标i对应的柱体高度h[i]小于h[x].（其实也说明了下标i之前的柱体高度都是大于h[x]的） 所以当前柱体向右扩展最多能扩展到i的前一个，即下标i-1对应的柱体。

下面看向左扩展。从当前要出栈的柱体x开始向左依次找，第一个高度小于h[x]的柱体即为向左扩展的左边界（不包含）。而第一个高度小于h[x]的柱体恰恰是栈中紧挨着它的那个，即把柱体x出栈之后的栈顶元素s.top()（不包含）。特例：若此时栈已经空了，那么左边界就是下标0（包含）。

所以，当栈非空时，柱体x向左扩展的边界是s.top()+1(包含)，向右扩展的边界是i-1(包含)，介于这两个之间共有 i-s.top()-1 个柱体。

　　   当栈为空时，向左扩展的边界是0（包含），右边界不变，共有 i 个柱体。

ref

#2: Line11 忘了加上 if(s.empty()) 这个判断。这会导致RE. Line17也忘了考虑s.empty();

2. Maximal Rectangle

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

    int largestRectangleArea(vector<int> &height)
    {
        stack<int> s;
        height.push_back(0);
        int i=0,res=0;
        while(i<height.size())
        {
            if(s.empty()||height[i]>=height[s.top()])
                s.push(i++);
            else
            {
                int tmp=s.top();
                s.pop();
                res=max(res,height[tmp]*(s.empty()?i:i-s.top()-1));
            }
        }
        return res;
    }
};

先预处理再做，是一个很好的技巧。

学以致用。预处理出高度来，再利用上一题的代码。

ref

3. Trapping Rain Water

class Solution
{
public:
    int trap(vector<int> &height)
    {
        int n=height.size();
        if(n==0) return 0;
        vector<int> leftMost(n,0);
        vector<int> rightMost(n,0);
        int maxV=0,res=0;
        for(int i=0;i<n;i++)
        {
            leftMost[i]=maxV;
            maxV=max(maxV,height[i]);    
        }
        maxV=height[n-1];
        for(int i=n-1;i>=0;i--)
        {
            rightMost[i]=maxV;
            maxV=max(maxV,height[i]);
        }
        for(int i=0;i<n;i++)
        {
            if(min(leftMost[i],rightMost[i])>height[i])
                res+=min(leftMost[i],rightMost[i])-height[i];
        }
        return res;        
    }
};

规律：对每个小柱子X而言，它头顶上会不会有水取决于它左边所有柱子里最高的那个柱子A以及它右边所有柱子里最高的那个柱子B。A和B较矮的那个如果高过当前这个柱子X，那么这个小柱子X头顶上就能有 min(height[A],height[B]) - height[X] 这么高的水。

时间O(n)，空间O(n)。

注意对n==0的边界条件的判断。【corner case !】

ref1     ref2

学习下空间复杂度为O(1)的解法。   ref1     ref2      ref3

4. Container With Most Water

class Solution
{
public:
    int maxArea(vector<int> &height)
    {
        if(height.empty()) return 0;
        int p1=0,p2=height.size()-1;
        int res=0;
        while(p1<=p2)
        {
            if(height[p1]<height[p2])
            {
                res=max(res,height[p1]*(p2-p1));
                p1++;
            }
            else
            {
                res=max(res,height[p2]*(p2-p1));
                p2--;
            }
        }
        return res;
    }
};

比较左右两板，对于较短的板而言，无论另一块板（较长的板）如何向中间移动，都不可能取的比现在更大的面积。因此记录下此时的面积，将短板向中间移动。