【LeetCode】Sama的个人记录_1

 

 

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

示例 1：

  输入: “babad”
  输出: “bab”
  注意: “aba” 也是一个有效答案。
示例 2：

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

class Solution {
    public String longestPalindrome(String s) {
    	/*
    	* 首先想到的依然是暴力法
    	* 先写一个用于判断是否为回文的方法， 然后切割出所有可能的字符串进行判断
    	*/
    	String result = new String();
    	String ss = new String();
    	int max = 0;
    	int len = s.length();
    	for(int i = 0; i < len ; i++) {
    		for(int j = i+1 ; j < len+1 ; j++) {
    			ss = s.substring(i, j);
    			if(ss.length() > max && judge(ss)) {
    				max = ss.length();
    				result = new String(ss);
    			}
    		}
    	}
    	return result;
    }
    
    // 用于判断是否为回文
    public Boolean judge(String s){
    	String ss = new StringBuffer(s).reverse().toString();	
    	if(ss.equals(s)) {
    		return true;
    	}else {
    		return false;
    	}
    }
    
    // 这段代码因为超时而WA掉；重新审视发现new出了大量的对象
    // 对所有出现new的地方进行优化，尤其是StringBuffer对象
}

 

class Solution {
    public String longestPalindrome(String s) {
		/*
		* 这是对上面的暴力法的改进
		*/
    	String result = "";
    	int max = 0;
    	int len = s.length();
    	for(int i = 0; i < len ; i++) {
    		for(int j = i+1 ; j < len+1 ; j++) {
    			String ss = s.substring(i, j);
    			if(ss.length() > max && judge(ss)) {
    				max = ss.length();
    				result = ss;
    			}
    		}
    	}
    	return result;
    }
    
    public Boolean judge(String s){
    	for(int i = 0 ; i < s.length() / 2 ; i++) {
    		if(s.charAt(i) != s.charAt(s.length()-i-1)) {
    			return false;
    		}
    	}
    	return true;
    }
}

 

class Solution {
    public String longestPalindrome(String s) {
    	/*
    	* 中心扩散法
    	* 暴力法截出所有的子串并进行回文判断，其中有许多是无意义的
    	* 回文必定是从中心(中心也可能是一段相同的字母)开始对称
    	* 因而我们用O(n)的时间复杂度对所有的中心进行一次判断，即向外扩散，再判断扩散是否中止
    	* 一个难点是：我们得到中心后，不能急于想"两边"扩散；应该先尝试与中心比较，进行"单边扩散"：
    	* 这是为了解决诸如"aa","bbb","dddd"为中心的特殊情况
    	*/
    	String result = "";
    	int center = 0;
    	int left = 0;
    	int right = 0;
    	int len = 1;
    	int max = 0;
    	
    	for(int i = 0 ; i < s.length() ; i++) {
    		center = i;
    		left = i - 1;
    		right = i + 1;
    		len = 1;
    		// 先尝试单边扩散
    		while(left >= 0 && s.charAt(left) == s.charAt(center)) {
    			left--;
    			len++;
    		}
    		while(right < s.length() && s.charAt(right) == s.charAt(center)) {
    			right++;
    			len++;
    		}
    		// 再双边扩散
    		while(left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
    			left--;
    			right++;
    			len += 2;
    		}
    		if(len > max) {
    			max = len;
    			result = s.substring(left+1, right);
    		}
    	}
    	return result;
    }
    
}

至于动态规划，liweiwei dalao讲得特别好：click here

class Solution_5_5 {
    public String longestPalindrome(String s) {
    	/*
    	* 算法：【动态规划（Dynamic Programming）】
    	* 填dp表；
    	*/
    	if(s.length() < 2)	return s;
    
    	int len = s.length();
    	int start = 0;
    	int maxlen = 0;
    	boolean[][] dp = new boolean[len][len];
    	for(int i = 0 ; i < len ; i++) {
    		dp[i][i] = true;
    	}
    	for(int r = 1 ; r < len ; r++) {
    		for(int l = 0 ; l < len ; l++) {
    			if(s.charAt(r) == s.charAt(l)) {
    				if((r - l) < 3) {
    					dp[l][r] = true;
    				}else {
    					dp[l][r] = dp[l + 1][r - 1];
    				}
    			}else {
    				dp[l][r] = false;
    			}
    			
    			if(dp[l][r]) {
    				if((r - l) > maxlen) {
    					maxlen = r - l;
    					start = l;
    				}
    			}
    		}
    	}
    	return s.substring(start, start + maxlen + 1);
    }
    // 动态规划本质还是暴力法(时间复杂度O(n²))，速度慢很正常
}

 

 
 
 

▊【Q6】(md) Z字型变换
 
将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。
 
比如输入字符串为 “LEETCODEISHIRING” 行数为 3 时，排列如下：
 
L     C   I  R
E T O E S I I G
E     D    H  N
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“LCIRETOESIIGEDHN”。
 
请你实现这个将字符串进行指定行数变换的函数：
 
string convert(string s, int numRows);
 
示例 1:
   输入: s = “LEETCODEISHIRING”, numRows = 3
   输出: “LCIRETOESIIGEDHN”
 
示例 2:

   输入: s = “LEETCODEISHIRING”, numRows = 4
   输出: “LDREOEIIECIHNTSG”
解释:
 
L     D    R
E   O E    I  I
E C    I H   N
T    S    G

class Solution {
    public String convert(String s, int numRows) {
    	/*
    	* 二维数组法
    	* 思路 ： 把Z型循环分割成一个个Part，每个Part是由一个“竖线”和一个“斜线组成的”
    	* 竖线和斜线的表达式都不算难找，只是注意每个Part的横轴都要加上一个Part的宽度
    	* 最后遍历输出数组中不是默认值的所有元素即可
    	*/
    	
    	// Z型变换在行数为0和1时是特殊情况
    	if(numRows < 2) {
    		return s;
    	}
    	
//    	int len = ( ((s.length() / ((numRows - 1) * 2)) - 1) + 1 ) * (numRows);  
    	int len = s.length();
    	char[][] arr = new char[numRows][len];
    	
    	int partNum = 0;
    	int index = 0;
    	while(index < s.length()) {	
    		for(int i = 0 ; i < numRows ; i++) {
    			if(index < s.length()) {
    				arr[i][partNum] = s.charAt(index++);					//竖线
    			}
    		}
    		for(int j = 0 ; j < numRows - 2 ; j++) {
    			if(index < s.length()) {
    				arr[numRows-2-j][j+1+partNum] = s.charAt(index++);		//斜线
    			}
    		}
    		partNum += (numRows - 1);										//在横向上有个增量
    		
    	}
    	
    	StringBuilder result = new StringBuilder();							//字符串连接时，StringBuilder对象可以使用append方法，是字符串连接中效率最高的
    	for(int i = 0 ; i < numRows ; i++) {
    		for(int j = 0 ; j < len ; j++) {
    			if(arr[i][j] != '\0') {										//字符(char)数组默认值为'\0'!!!
    				result.append(String.valueOf(arr[i][j]));				//字符不允许强制转换成字符串(Character和char都不行)，需要使用String.valueOf方法
    			}
    		}
    	}
    	
    	return result.toString();											
    }
    // 总结 ：
	// 二维数组中有大量被浪费的空间
}

 

class Solution {
    public String convert(String s, int numRows) {
    	/*
    	* 【巧妙的方法】
    	* 总而言之，二维数组的方法是静态的，而此方法的思想是动态的
    	* 与其说是“Z”，倒不如说是“V”
    	* 思路是用numRows个集合，动态地捕捉每一个字符 : (索引)向下-掉头-向上-掉头-....
    	*/
    	if(numRows < 2)	return s;
    	
    	List<StringBuilder> rows = new ArrayList<StringBuilder>();
    	for(int i = 0 ; i < numRows ; i++) {
    		rows.add(new StringBuilder());
    	}
    	int index = 0;
    	int flag = -1;
    	for(char c : s.toCharArray()) {
    		rows.get(index).append(c);
    		if(index == 0 || index == numRows - 1) {		//到达边界就掉头
    			flag = -flag;
    		}
    		index += flag;									//向下-掉头-向上-掉头-....
    	}
    	StringBuilder result = new StringBuilder();
    	for(StringBuilder row : rows) {
    		result.append(row);
    	}
    	
    	return result.toString();
    }
    // 总结 ：
    // 除了解题思想，还有一点是巧妙的：
    // 用 List<StringBuilder>泛型集合和 StringBuilder字符串类，代替了二维数组；而且在后边字符串合并的时候也极其方便
}

 
 
 

 

 

 

 

 

 

 

 

 
Qs from https://leetcode-cn.com
♥ loli saikou
♦ end