Leetcode 5. Longest Palindromic Substring

我的解法是以每个字符为中心进行两侧试探，或者以每两个相邻字符为中心进行两侧试探

public class Solution {
    public String longestPalindrome(String s) {
       int maxI = -1;
        int maxLengthI = 0;
        int maxJ = -1;
        int maxLengthJ = 0;
        for (int i = 0; i < s.length(); i++) {
            int p = i;
            int q = i;
            while (p >=0 && q < s.length()) {
                if (s.charAt(p) == s.charAt(q)) {
                    p--;
                    q++;
                } else {
                    break;
                }
            }
            if ((q-p-1) > maxLengthI) {
                maxLengthI = q-p-1;
                maxI = i;
            }
        }

        for (int j = 0; j< s.length()-1; j++) {
            int p = j;
            int q = j+1;
            while (p >=0 && q < s.length()) {
                if (s.charAt(p) == s.charAt(q)) {
                    p--;
                    q++;
                } else {
                    break;
                }
            }
            if ((q-p-1) > maxLengthJ) {
                maxLengthJ = q-p-1;
                maxJ = j;
            }
        }
        if (maxLengthI > maxLengthJ) {
            return s.substring(maxI - maxLengthI/2, maxI+maxLengthI/2+1);
        } else {
            return s.substring(maxJ - maxLengthJ/2+1, maxJ+maxLengthJ/2+1);
        }
    }
    
}

正统的方法还有动态规划，动态规划，类似于lcs的解法，数组flagi记录s从i到j是不是回文

首先初始化，i>=j时，flagi=true，这是因为si是单字符的回文，当i>j时，为true，是因为有可能出现flag2这种情况，比如bcaa，当计算s从2到3的时候，s[2]==s[3]，这时就要计算s[2+1] ?= s[3-1]，总的来说，当i>j时置为true，就是为了考虑j=i+1这种情况。

接着比较s[i] ?= s[j]，如果成立，那么flagi = flagi+1，否则直接flagi=false

class Solution {
public:
    string longestPalindrome(string s) {
        int len = s.length(), max = 1, ss = 0, tt = 0;
        bool flag[len][len];
        for (int i = 0; i < len; i++)
            for (int j = 0; j < len; j++)
                if (i >= j)
                    flag[i][j] = true;
                else flag[i][j] = false;
        for (int j = 1; j < len; j++)
            for (int i = 0; i < j; i++)
            {
                if (s[i] == s[j])
                {
                    flag[i][j] = flag[i+1][j-1];
                    if (flag[i][j] == true && j - i + 1 > max)
                    {
                        max = j - i + 1;
                        ss = i;
                        tt = j;
                    }
                }
                else flag[i][j] = false;
            }
        return s.substr(ss, max);
    }
};