Leetcode 5. 最长回文子串

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

示例 1：

输入: “babad”
输出: “bab”

注意: “aba” 也是一个有效答案。
示例 2：

输入: “cbbd”
输出: “bb”

方法一：时间超限，自己思路（行不通）：

1. 将字符串赋给map集合，字符为键，下标为值，值为集合，集合中存储的都是每个字符重复的下标
2. 根据每个entry的值，获取每个字符对应的集合。
3. 遍历集合，每次从集合中拿出两个值，一个作为起始 一个作为终点，两个值截取的字符串判断是否为回文子串，若是则判断是否最大，若是则保存，继续遍历。

class Solution {
    public String longestPalindrome(String s) {
        if(s.equals("")){
			return "";
		}
		//使用map作为字符数组，z存放所有的字符，并将每个字符添加对应的序号
		Map<Character,ArrayList<Integer>> map = new HashMap<>();
		for(int i = 0;i<s.length();i++){
			ArrayList<Integer> list = null;
			if(map.get(s.charAt(i)) != null){
				list = map.get(s.charAt(i));
			}else{
				list = new ArrayList<>();
			}
			list.add(i);
			map.put(s.charAt(i), list);
		}
		
		//记录最长回文子串的起始点
		int start = 0,end = 0,max = 0;//start 和 end为-1说明未开始遍历，max为最大回文子串的长度
		
		for (Character key : map.keySet()) {
			ArrayList<Integer> list = map.get(key);
			for (int i = 0;i<list.size();i++) {
				for(int j = list.size()-1;i<j;j--){
					if(isPalindrome(s, list.get(i), list.get(j))&&max <= list.get(j)-list.get(i)+1){//若是回文且回文子串长度大于当前最长的长度，则记录该回文子串的起始值和长度
						start = list.get(i);
						end = list.get(j);
						max = end-start+1;
					}
				}
			}
		}
		return s.substring(start, end+1);
    }
	public boolean isPalindrome(String s,int start ,int end){
		char[] cs = s.substring(start, end+1).toCharArray();
		for(int i = 0,j = cs.length-1;i<j;i++,j--){
			if(cs[i] != cs[j]){
				return false;
			}
		}
		return true;
	}
}

简写上边的方法：

public static String longestPalindrome(String s) {
		if(s.equals("")){
			return "";
		}
		//两个for循环遍历字符数组，找到两个相同的字符就截取，并判断是否为回文子串
		char[] cs = s.toCharArray();
		
		int start = 0,end = 0,max = 0;
		
		for(int i = 0;i<cs.length;i++){
			for(int j = i;j<cs.length;j++){//最长子串的长度要小于剩下的字符长度
				if(cs[i] == cs[j]){
					if(isPalindrome(s,i,j)&&max<j-i+1){//若是回文子串且大于最大的回文子串，则保存
						start = i;
						end = j;
						max = j-i+1;
					}
				}
			}
		}
		return s.substring(start, end+1);
    }

但还是超时。
还有一种暴力解法：从最长的字符串即本身开始判断是否为回文子串，每次判断子串的长度减一，直到为0。

public String longestPalindrome(String s) {
		if(s.equals("")){
			return "";
		}
		//两个for循环遍历字符数组，找到两个相同的字符就截取，并判断是否为回文子串
		char[] cs = s.toCharArray();
		
		int start = 0,end = 0,max = 0;
		int len = cs.length;
		for(;len>0;len--){//len为字符串的长度
			start = 0;
			for(;start+len<=cs.length;start++){
				if(isPalindrome(s,start,start+len-1)){//若是回文子串且大于最大的回文子串，则保存
					return s.substring(start, start+len);
				}
			}
		}
		return s.substring(start, end+1);
    }

依然超时。。。。
最终妥协，使用中心扩散：
方法二：中心扩散法：

class Solution {
    public String longestPalindrome(String s) {
		if(s.equals("")){
			return "";
		}
		//中心扩散法
		int max = 0;
		String str = s.substring(0,1);
		for(int i = 0;i<s.length();i++){
			String oddStr = centerSpread(s,i,i);//获取每个字符中心扩散的最大回文子串（中间值为一个）
			String evenStr = centerSpread(s,i,i+1);//获取每个字符中心扩散的最大回文子串（中间值为两个）
			String maxLenStr  = oddStr.length()>evenStr.length() ? oddStr :evenStr;//判断这两个字符串那个长，长的一方赋值给真正的回文子串
			if(maxLenStr.length()>max){
				max = maxLenStr.length();
				str = maxLenStr;
			}
		}
		return str;
	}

	public String centerSpread(String s, int left,int right) {//设置两个参数的原因是因为会有两种情况，第一种为中心值是单个（aba），第二种为中心值为双数(abba)
		//中心扩散找到最大回文子串
		int i = left,j = right;//i向左扩散（i--），j向右扩散（j++）
		
		while(i>=0&&j<s.length()){
			if(s.charAt(i) == s.charAt(j)){
				i--;
				j++;
			}else {
				break;
			}
			
		}
		return s.substring(i+1,j);//因为在跳出循环时多余扩散了一次，因此要i+1，j为同理
	}
}

还有一种方法为动态规划，慢慢再看吧。。。。