leetcode 5: Longest Palindromic Substring

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.

求出最大回文子串，最长子串存在并且唯一。

方法一，动态规划，dp[i][j]记录的是下标i到j是否是最大回文子串，如果从下标逐渐增大开始遍历，不一定能访问到所有的状态，所以根据子串长度由小到大开始遍历。复杂度为n^2。结果在leetcode中超时了。

	public String longestPalindrome(String s) {
		if(s.length()==0) return null;
		int in_i=0,in_j=0;
        int len=s.length();
        int[][] dp=new int[len][len];//dp记录的是从下标i到j是否是回文子串
        for(int i=0;i<len-1;i++){//初始化边界条件
        	dp[i][i]=1;
        	if(s.charAt(i)==s.charAt(i+1)){
        		dp[i][i+1]=1;
        		in_i=i;
        		in_j=i+1;
        	}
        }
        dp[len-1][len-1]=1;
        for(int L=3;L<=len;L++){//由长度从小到大开始遍历
        	for(int i=0;i<=len-L;i++){
        		int j=i+L-1;
        		if(s.charAt(i)==s.charAt(j)&&dp[i+1][j-1]==1){//状态转移方程
        			dp[i][j]=1;
        			in_i=i;
            		in_j=j;
        		}
        	}
        }
        return s.substring(in_i, in_j+1);
	}

方法二，遍历每个字符，把它当作回文串的尾巴，currentlen记录的是当前尾巴的最大回文串长度，当下标加1时，根据currentlen记录的前一个字符作为尾巴的最大回文串长度，所以这次的回文串长度只能是cuurentlen+1或者currentlen+2。

	private boolean isPalindrome(String s,int start,int end){
		if(start<0) return false;
		while(start<end){
			if(s.charAt(start++)!=s.charAt(end--)) return false;
		}
		return true;
	}
	public String longestPalindrome(String s) {
		String res="";
		if(s.length()<2) return s;
		int currentlen=0;
		for(int i=0;i<s.length();i++){
			if(isPalindrome(s, i-currentlen-1, i)){
				res=s.substring(i-currentlen-1, i+1);
				currentlen=currentlen+2;
			}
			if(isPalindrome(s, i-currentlen, i)){
				res=s.substring(i-currentlen, i+1);
				currentlen=currentlen+1;
			}
		
	}
		return res;
}

方法三，从左到右扫描字符串，每次扫描，都把该字符当作最大回文子串的中心，向两边展开扫描，看是否能找到更大的最大回文子串。

注意：奇数和偶数回文子串的处理，若为偶数的最大回文子串，则中间的两个字符是相等的，所以直接跳过就行。

while(end<s.length()-1&&s.charAt(end)==s.charAt(end+1)) end++;
			i=end+1;

最好不要用string记录中间产生的最大回文子串，如果要记录中间最大回文子串，最好使用stringbuilder。

因为：

 简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。

或者用整型变量记录最大回文子串的开始和结束下标。

	public String longestPalindrome(String s) {
		if(s.length()<2) return s;
		int maxstart=0;
		int maxend=s.length();
		int max=0;
		for(int i=0;i<s.length();){
			if(s.length()-i<=max/2) break;
			int start=i,end=i;
			while(end<s.length()-1&&s.charAt(end)==s.charAt(end+1)) end++;
			i=end+1;
			while(end<s.length()&&start>=0&&s.charAt(end)==s.charAt(start)){
				++end;
				--start;
			}
			int len=end-start+1;
			if(len>max){
				max=len;
				maxstart=start+1;
				maxend=end;
			}
		}
		return s.substring(maxstart, maxend);
	}