LeetCode 5 longest-palindromic-substring题解

LeetCode longest-palindromic-substring题解

题目链接

飞鱼决定开始每天保底五题（except Hard)

粗爆动态规划 （fast than 25%)

思路

主要就是挖掘前提条件：

1、单个字符必然回文
2、两个字符当且仅当他们相同时回文

其次是关联：

如果区间[i, j]是回文，当且仅当[ i+1, j-1]是回文 and s[i] == s[j]

然后再次遍历结果数组，找出最大的回文输出

Talking is no use, show your my codes

public String longestPalindrome(String s) {
        boolean[][] b = new boolean[s.length()][s.length()];
        
        for(int i = 0; i <s.length(); i++) {
        	b[i][i] = true;
        }
        for(int i = 0; i<s.length()-1;i++) {
        	b[i][i+1] = s.charAt(i) == s.charAt(i+1);
        }
        
        for(int i = 0; i <s.length()-2;i++) {
        	for(int j = 1; j <s.length()-i-1; j++) {
        		b[j-1][j+i+1] = b[j][j+i] && s.charAt(j-1) == s.charAt(j+i+1);
        	}
        }
        String ans = new String();
        for(int i = 0; i<s.length();i++) {
        	for(int j = s.length()-1; j>=0;j--) {
        		if(b[i][j] && ans.length()<j-i+1) {
        			ans =  s.substring(i, j+1);
        		}
        	}
        }
        return ans;
    }

稍微改进的动态规划 (fast than 55%)

改进思路，我们可以从一个中心出发，两边扩充直至最大，这就是以这个点中心的最大回文子串，比较所有中心的最大，即可得到结果。
注意中心有以i为中心，和（i,i+1）的中间位置，故遍历每个i,有两种情况，我们利用while循环，
while(start2>=0 && end2<s.length() && s.charAt(start2) == s.charAt(end2)) { start2--; end2++; }
找出回文开区间，
为什么是开区间？
因为 这样我们如果初始化start = end，那么第一次循环必然成立，如果初始化start = i， end = i+1 ,那么，第一次不一定成立，此时却有赋值start和end，如果不是开区间，这意味着我们默认了长度为二的字符串为回文，这是荒谬的。

开区间长度为 end - start - 1;
***扩展一丢丢，

闭区间：end -start +1
左开右闭： end - start

---

Talking is no use, show your my codes

class Solution {
   	public String longestPalindrome(String s) {
		String ans = new String();
		if(s==null || s.length()<=1) {return s;}
		int len = 0;
		int start=0,end=0;
		for(int i = 0; i<s.length(); i++) {
			int start1 = i;
			int end1 = i;
			while(start1>=0 && end1 <s.length() && s.charAt(start1) == s.charAt(end1)) {
				start1--;
				end1++;
			}
			int len1 = end1 - start1 -1;
			int start2 = i;
			int end2 = i+1;
			while(start2>=0 && end2<s.length() && s.charAt(start2) == s.charAt(end2)) {
				start2--;
				end2++;
			}
			int len2 = end2 - start2-1;
			len = Math.max(len1,len2);
			if(len> end - start + 1) {
				end = i + len/2;
				start = i - (len-1)/2;
			}
		}
		ans = s.substring(start, end+1);
		return ans;
    }
}

Manacher’s Algorithm （线性时间复杂度，fast than 94.37%）

思路解析

Talking is no use, show your my codes

class Solution {
  public String longestPalindrome(String s) {
		//  Manacher's Algorithm
		if(s==null || s.length()<=1) {return s;}
		char[] tp = new char[s.length()*2+1];
		tp[0] = '#';
		for(int i = 0; i < s.length(); i++) {
			tp[2*i+1] = s.charAt(i);
			tp[2*(i+1)] = '#';
		}
		int[] p = new int[tp.length];
		p[1] = 1;
		int center = 1; 
		int right = 2;
		int pt = 0;
		for(int i = 2; i<tp.length; i++) {
			int mirror = 2 * center - i;
			if(right > i && right - i > p[mirror]) {
				p[i] = p[mirror];
			}else if(right < i) {
				int k = 1;
				while(i-k>=0 && i+k<tp.length && tp[i-k] == tp[i+k]) {
					k++;
				}
				p[i] = k-1;
				center = i;
				right = p[i] + center;
			}else {
				int k = 1;
				int left = 2*i -right;
				while(left-k>=0 && right+k<tp.length && tp[right+k] == tp[left-k]) {
					k++;
				}
				p[i] = k-1 + right - i;
                center = i;
				right = p[i] + center;
			}
			if(p[i]>p[pt]) {
				pt = i;
			}
		}
		int start = pt/2 - p[pt]/2;
		int end = pt/2 + (p[pt]-1)/2;
		return s.substring(start, end+1);
    }
}