LeetCode_5---Longest Palindromic Substring (求最长回文子串)

/**
 * 
 */

/**
 * @author MohnSnow
 * @time 2015年5月29日 下午2:24:31
 * 
 */
public class LeetCode5 {

	/**
	 * @param argsmengdx
	 *            -fnst
	 */
	/*
	 * 方法1两侧比较法,其实就是暴力方法
	 */
	public static String longestPalindrome1(String s) {
		int maxLength = 0;
		int sLength = s.length();
		String maxPali = "";
		for (int i = 0; i < sLength; i++) {
			for (int j = i + 1; j < sLength; j++) {
				if (isPali(s.substring(i, j + 1))) {// substring参数的定义需要熟悉一下，bigin开始，end结束，不包括end
					System.out.println(s.substring(i, j + 1));
					if (s.substring(i, j + 1).length() > maxLength) {
						maxLength = s.substring(i, j + 1).length();
						maxPali = s.substring(i, j + 1);
					}
				}
			}
		}
		return "Test1:  " + maxPali;
	}

	/**
	 * @param string
	 * @returnmengdx-fnst
	 */
	private static boolean isPali(String str) {
		int len = str.length() - 1;
		for (int i = 0; i < len - i; i++) {
			if (str.charAt(i) != str.charAt(len - i)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * @param s
	 * @returnmengdx-fnst
	 */
	/*
	 * 动态规划法假设dp[ i ][ j ]的值为true，表示字符串s中下标从 i 到 j 的字符组成的子串是回文串。那么可以推出： dp[ i
	 * ][j ] = dp[ i + 1][ j - 1] && s[ i ] == s[ j ]。 这是一般的情况，由于需要依靠i+1,
	 * j-1，所以有可能 i + 1 = j -1, i +1 = (j - 1) -1， 因此需要求出基准情况才能套用以上的公式： a. i + 1
	 * = j -1， 即回文长度为1时， dp[ i ][ i ] = true; b. i +1 = (j - 1) -1， 即回文长度为2时，dp[
	 * i ][ i + 1] = （s[ i ] == s[ i + 1]）。
	 * 有了以上分析就可以写出代码了。需要注意的是动态规划需要额外的O(n2)的空间。
	 * 但是此方法在提交的时候提示超时，输入很多行：ddddddddddddddddddddddddddddddddddddd的时候
	 */
	private static String longestPalindrome2(String s) {
		if (s == null) {
			return null;
		}
		if (s.length() <= 1) {
			return s;
		}
		int maxLen = 0;
		String longestStr = null;
		int length = s.length();
		boolean[][] table = new boolean[length][length];
		table[0][0] = true;
		for (int i = length - 1; i > 0; i--) {// 字符串长度等于2的时候在此判断了，并完成了基础赋值
			table[i][i] = true;
			if (s.charAt(i) == s.charAt(i - 1)) {
				table[i - 1][i] = true;
				longestStr = s.substring(i - 1, i + 1);// 这个方法包前不包后，字符串长度等于2的时候在此判断了
			}
		}
		// printTable(table);
		for (int l = 3; l <= length; l++) {// 从长度为3的子串开始判断
			for (int i = 0; i <= length - l; i++) {// i<=length- l 决定了不会出现数组溢出
				int j = i + l - 1;
				if (s.charAt(i) == s.charAt(j)) {
					table[i][j] = table[i + 1][j - 1];
					if (table[i][j] == true && l > maxLen)
						longestStr = s.substring(i, j + 1);

				} else {
					table[i][j] = false;
				}
				// printTable(table);
			}
		}
		return longestStr;
	}

	/* 打印数组 */
	public static void printTable(int[][] x) {
		for (int[] y : x) {
			for (int z : y) {
				System.out.print(z + " ");
			}
			System.out.println();
		}
		System.out.println("----------");
	}

	/*
	 * 因为回文字符串是以中心轴对称的，所以如果我们从下标 i 出发，用2个指针向 i 的两边扩展判断是否相等，那么只需要对0到
	 * n-1的下标都做此操作，就可以求出最长的回文子串。但需要注意的是，回文字符串有奇偶对称之分，即"abcba"与"abba"2种类型，
	 * 因此需要在代码编写时都做判断。 设函数int Palindromic ( string &s, int i ,int j) 是求由下标 i 和 j
	 * 向两边扩展的回文串的长度，那么对0至n-1的下标，调用2次此函数： int lenOdd = Palindromic( str, i, i ) 和
	 * int lenEven = Palindromic (str , i , j )，即可求得以i 下标为奇回文和偶回文的子串长度。
	 * 接下来以lenOdd和lenEven中的最大值与当前最大值max比较即可。 这个方法有一个好处是时间复杂度为O(n2)，且不需要使用额外的空间。
	 * 
	 * 
	 */
	private static String longestPalindrome3(String s) {
		if (s.isEmpty()) {
			return null;
		}
		if (s.length() == 1) {
			return s;
		}
		String longest = s.substring(0, 1);
		for (int i = 0; i < s.length(); i++) {
			String tmp = helper(s, i, i);
			if (tmp.length() > longest.length()) {
				longest = tmp;
			}
			tmp = helper(s, i, i + 1);
			if (tmp.length() > longest.length()) {
				longest = tmp;
			}
		}
		return longest;
	}

	public static String helper(String s, int begin, int end) {
		while (begin >= 0 && end <= s.length() - 1 && s.charAt(begin) == s.charAt(end)) {
			begin--;
			end++;
		}
		String subS = s.substring(begin + 1, end);
		return subS;
	}

	public static void main(String[] args) {
		String s = "dddddd";
		System.out.println(s);
		// System.out.println(isPali("dddddddddddddddddddddddddddd"));
		// System.out.println(longestPalindrome1(s));
		// System.out.println(longestPalindrome2(s));
		System.out.println(longestPalindrome3(s));
	}

}

综述：第一种方法采用的是暴力方法,容易理解，但是时间复杂度太高O(n3).

    第二种方法采用的是动态规划法，但是Java版的提示超时，C++版的就没有问题,并且时间复杂度为O(n2),空间复杂度为O(n2).

    第三种方法采取中间向两边移动的方法，非常好，复杂度低，容易理解，并且时间复杂度为O(n2),空间复杂度为O(1).

参考博客：

http://blog.csdn.net/feliciafay/article/details/16984031