LeetCode 5 最长回文子串

题目

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

思路

一眼看上去就是动态规划，当然还有更快的方法，详见Manacher算法。

动态规划步骤

1. 确定状态空间
2. 确定状态转移函数，子状态的关系
3. 遍历状态空间，填状态标注
4. 得到结果
5. 状态压缩，优化算法

本题思路

1. 确定状态空间

string s中的最长回文子串即确定s[i:j]是否是回文子串和回文串的长度。故可以用一个二维数组来记录状态dp[i][j]表示s[i:j]是否是回文子串和回文串的长度。

2. 确定状态转移函数

状态转移要划分出子状态。s[i:j]是否是回文子串 充要条件是 s[i+1:j-1]是回文且s[i] == s[j]。
映射到状态空间就是 dp[i+1][j-1]是字串 && s[i]==s[j]
状态转移函数是：

if (dp[i+1][j-1]==true && s[i]==s[j]){
	dp[i][j] = true
} else {
	dp[i][j] = false
}

3. 遍历状态空间，填状态标注

明确了状态转移函数就可以遍历状态空间来求解了。
如图沿对角线往右上角遍历解空间，依次填写dp[][]。

4. 得到结果

遍历完dp[][]就可以得到结果了。

5. 状态压缩，优化算法

遍历过程中有些情况是可以剪枝的，太麻烦了，不想改了。

代码

func longestPalindrome(s string) string {
    sLen := len(s)
    var dp [1001][1001]int

    sublen := 1
    subi:=0
    subj:=0

    if (s==""){
        return ""
    }

    i,j,k:= 0,0,0
    

    for i=0;i<sLen;i++ {
        dp[i][i] = 1
        if (i+1 < sLen) {
            if ( s[i] == s[i+1] ) {
                dp[i][i+1] = 1
                sublen = 2
                subi = i
                subj = i+1
            } else {
                dp[i][i+1] = 0
            }

        }
    }

    
    for i=1;i<sLen;i++ {
        j=i-1
        k= i+1 
        for ;(j >=0 && k < sLen); j,k = j-1, k+1 {
            if ( dp[j+1][k-1] == 1 ) && (s[j] == s[k]) {
                dp[j][k] = 1
                if( k-j+1 > sublen ) {
                    sublen = k-j+1       
                    subi = j
                    subj = k
                } 
            } else {
                dp[j][k] = 0
            }
        }
        j=i-1
        k= i+2
        for  ;j >=0 && k< sLen;j,k = j-1,k+1 {
            if ( dp[j+1][k-1] == 1 ) && (s[j] == s[k]) {
                dp[j][k] = 1
                if( k-j+1 > sublen ) {
                    sublen = k-j+1       
                    subi = j
                    subj = k
                } 
            } else {
                dp[j][k] = 0
            }
        } 
    }

    returnstr := s[subi:subj+1]

    return returnstr

}