DP之钢管切割，最长回文字符串，最长公共子串

在做LeetCode第3题的时候，用到了DP，但是自己对DP还是不了解，所以翻开算法导论，开始看动态规划喽，学好动态规划，走遍天下都不怕。

• 钢管切割
  对于一根长n米的钢管，每个长度的价格不一样，对于长i米的钢管，价格为p[i],价格表如下所示：
  
  现在问题是，给你一根长为n的钢管，你怎么切割，使得最后总价格最高。
  比如：长度为4米的钢管，我们有8种方案，也就是对应着中间3段切不切的排列组合，所以有2^3=8种方案。（4），（1，3），（1，1，2），（1，1，1，1），（2，1，1），（2，2），（3，1），（1，2，1）。
  然后比较得出总价最高的方案。
  动态规划，意味着解决n的问题，需要解决n-1的问题，获取最优解，需要最优子方方案，也就是最优子结构：问题的最优解由相关子问题的最优解组合而成，而这些子问题可以独立求解。
  所以我们可以得到公式：r[n] = max(p[i] + r[n-i]) ，i=1 to n。
  所以自底向上的DP算法：

int dp(int a[], int n) {
    int *r = new int[n];
    r[0] = 0;
    int q = 0;
    for (int i = 1; i < n; i++) {
        q = 0;
        for (int j = i; j > 0; j--) {
            q = max(q,a[j] + r[i-j]);
        }
        r[i] = q;
    }
    return r[n-1];
}

3.10 最长回文子字符串
问题：给字符串s，输出最长的回文子字符串。比如‘abcdcbw’,最长回文子字符串‘bcdcb’。
思路：最好的方法是马拉车算法，但是这里希望都用DP。设dp[i][j]为Si-Sj是否回文，则dp[i][j] = (Si==Sj && dp[i+1][j-1]),dp[i][i] = true;

string longestPalindrome(string s) {
    int len = s.size();
    bool dp[len][len];
    dp[len][len] = {false};
    int longest = 0;
    int left = 0;
    for (int i = 0; i < len; i++) {
        for (int j = 0; j < i; j++) {
            dp[j][i] = (s[i] == s[j] && (dp[j + 1][i - 1] || i - j < 2));
            if (dp[j][i] && longest < i - j + 1) {
                longest = i - j + 1;
                left = j;
            }
        }
        dp[i][i] = true;
    }
    return s.substr(left,longest);

}

3.27最长公共子串
思路1：BF暴力搜索。两个字符串s1,s2,比较s1[i]和s2[j]，如果相等，则比较s[i+1],s[j+1],循环下去，记录开始位置和长度，最后返回。

string longestCommonSubstring(string s1,string s2) {
    int start;
    int end;
    int longestNum;
    int m = s1.size();
    int n = s2.size();
    if (m == 0 || n == 0) {
        return "";
    }
    for (int i = 0; i < m; i++) {
        int k = i;
        int count = 0;
        for (int j = 0; j < n; j++) {
            if (s1[k] == s2[j]) {
                count++;
                k++;
            }
            else {
                if (count > longestNum) {
                    longestNum = count;
                    start = i;
                    end = j - 1;
                }
                break;
            }
        }
    }
    return s1.substr(start,longestNum);
}

思路2：DP动态规划。dp[i][j] 为bool型数组，表示以s1[i]和s2[j]为最后元素的子串，是否公共。dp[i][j] = (s[i] == s[j] ? dp[i-1][j-1]+1 : 0)

string longestCommonSubstring1(string s1,string s2) {
    int m = s1.size();
    int n = s2.size();
    vector<vector<int>> dp(m,vector<int>(n,0));
    int longest = 0;
    int end = 0;
    for (int i = 0; i < m; i++) {
        if (s1[i] == s2[0]) dp[i][0] = 1;
    }
    for (int j = 0; j < n; j++) {
        if (s2[j] == s1[0]) dp[0][j] = 1;
    }

    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[i][j] = (s1[i] == s2[j] ? dp[i-1][j-1]+1 : 0);
            if (dp[i][j] > longest) {
                longest = dp[i][j];
                end = i;
            }
        }
    }
    return s1.substr(end - longest + 1,longest);

}