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

}