[LeetCode#5]Longest Palindromic Substring

The problem: (The code of dynamic programming is very concise and elegant. You must learn it!)

Given a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.

My analysis:

The problem could be perfectly solved by using dynamic programming. 

The state transformaion equation is clear, and could be divided into following kinds :

assume: p[i][j] indicate whether the string from position i to position j is a palindromic. 

we could have following state transistion fuction:

1. p[i][j] == true; iff i = j
2. p[i][j] = s[i] == s[j]; iff j = i+1
3. p[i][j] = s[i][j] && p[i+1][j-1]; iff j > i + 1

My solution: 

 

/*
The state trasition at here:
p[i][j] == true; iff i = j
p[i][j] = s[i] == s[j]; iff j = i+1 
p[i][j] = s[i][j] && p[i+1][j-1]; iff j > i + 1  
*/

public class Solution {
    public String longestPalindrome(String s) {
        if (s.length() == 0 || s.length() == 1)
            return s;

        char[] s_Array = s.toCharArray(); 
        int len = s.length();
        int max_len = 0;
        int max_front = 0;
        int max_end = 0;
        boolean[][] pa_matrix = new boolean[len][len]; //the initial value of boolean type is false
        
        for (int i = 0; i < len; i++) {  //note: i is the index for end, j is the index for front 
            for (int j = 0; j <= i; j++) { //compute and memorize the pa_matrix from the bottom to up
                    if (i == j)
                        pa_matrix[i][j] = true;
                    if ((i == j + 1) && (s_Array[i] == s_Array[j]))
                        pa_matrix[i][j] = true;
                    if ((i > j + 1) && pa_matrix[i - 1][j + 1] && (s_Array[i] == s_Array[j])) //don't miss condition
                        pa_matrix[i][j] = true;
                        
                    if ((pa_matrix[i][j] == true) && (i - j + 1 > max_len)) {
                        max_len = i - j + 1;
                        max_front = j;
                        max_end = i;
                    }
            }           
        }
        return s.substring(max_front, max_end + 1); //take care of the usage of String.subString ... index 
    }
}