最长公共子串

是那题我很喜欢的动态规划的升级版！！
法一：二维dp
法二：状压dp，从后往前，不用记录，因为不会改变左上的
法三：状压dp，从前往后，要记录左上的。
状压dp最重要的就是如果不相等记得将dp[j]设为0

class Solution {
public:
    /**
     * longest common substring
     * @param str1 string字符串 the string
     * @param str2 string字符串 the string
     * @return string字符串
     */
    string LCS(string str1, string str2) {
        // write code here
        //可以用二维dp做，dp[i][j]表示的是1的前i位和2的前j位能形成的最大公共子串长度
        //状态转移方程就是如果两者相等，就等于dp[i-1][j-1]+1，如果不相等，就等于dp[i-1][j]和[i][j-1]
        //中较大的那个
        //basecase就是dp[0][j]和dp[i][0]为0
        
        //这样可以防止取i-1和j-1的时候越界，不用特判很方便
        /*vector<vector<int>> dp(str1.length()+1,vector<int>(str2.length()+1));
        int maxn = 0, index = 0;
        for(int i = 1; i <= str1.length(); ++i){
            for(int j = 1; j <= str2.length(); ++j){
                //我们只考虑相等，如果不相等就为0就ok了，因为我们不需要dp[1.length][2.length]
                //不需要一直继承下去
                if(str1[i-1] == str2[j-1]) dp[i][j] = dp[i-1][j-1]+1;
                if(dp[i][j] > maxn){
                    maxn = dp[i][j];
                    //此时的i是子串结尾的下标！！我们不应该从index开始截取
                    index = i-1;
                }
            }
        }
        return str1.substr(index-maxn+1,maxn);*/
        
        //只需要考虑左上的，从后往前，防止dp[i][j-1]把dp[i-1][j-1]给覆盖了
        //或者从前往后，但是更新当前的时候要把当前的值给记录下来
        vector<int> dp(str2.length()+1);
        int index = 0, maxn = 0;
        int tmp = 0;
        //还是从后往前把
        for(int i = 1; i <= str1.length(); ++i){
            int zuoshang = 0;
            /*for(int j = str2.length(); j >= 1; --j){
                
                if(str1[i-1] == str2[j-1]) dp[j] = dp[j-1]+1;
                else dp[j] = 0;
                if(dp[j] > maxn){
                    index = j-1;
                    maxn = dp[j];
                }
            }*/
            
            for(int j = 1; j <= str2.length(); ++j){
                tmp = dp[j];
                if(str1[i-1] == str2[j-1]) dp[j] = zuoshang + 1;
                else dp[j] = 0;
                zuoshang  = tmp;
                if(dp[j] > maxn){
                    index = j-1;
                    maxn = dp[j];
                }
            }
        }
        return str2.substr(index-maxn+1,maxn);
    }
};