【LeetCode】Sama的个人记录_22

 

 

【Q44】(hd) 通配符匹配
 
给定一个字符串 (s) 和一个字符模式 § ，实现一个支持 ‘?’ 和 ‘*’ 的通配符匹配。
 
‘?’ 可以匹配任何单个字符。 ‘*’ 可以匹配任意字符串（包括空字符串）。 两个字符串完全匹配才算匹配成功。
 
说明:
   s 可能为空，且只包含从 a-z 的小写字母。 p 可能为空，且只包含从 a-z 的小写字母，以及字符 ? 和 *。
 
示例 :
   输入: s = “aa” p = “a”       输出: false
   输入: s = “aa” p = “*”         输出: true
   输入: s = “cb” p = “?a”      输出: false
   输入: s = “adceb” p = “*a*b”     输出: true
   输入: s = “acdcb” p = “a*c?b”    输出: false

class Solution {
	/*
	 * 【动态规划】
	 */
    public boolean isMatch(String s, String p) {
  
    	// 【dp[i][j]的含义是前i的p正则串 是否能匹配 前j的s原串】
    	// p称为正则串，下标对应i，竖着的； s称为原串，下标对用j，横着的
    	// dp在二维的长度都为 length + 1；dp[i][j]时(也就是前i个和前j个)时，比较的是p的第i个和s的第j个字符，下标为i-1和j-1
    	boolean[][] dp = new boolean[p.length() + 1][s.length() + 1];
    	
    	// 初始化
    	dp[0][0] = true;			// 其含义是，前0个，也就是两个空的串能否匹配(是可以的)
    	for(int i = 1; i <= p.length(); i++) {		// 当j为0，也就是原串为空时，如果正则串为多个'*'，也是可以匹配的(true)
    		if(p.charAt(i - 1) == '*') {
    			dp[i][0] = dp[i - 1][0];
    		}
    	}
    	for(int j = 1; j <= s.length(); j++) {		// 当i为0，也就是正则串为空，只要原串不是空(dp[0][0])，其他情况下必然是不可匹配(false)
    		dp[0][j] = false;						// 这句可以不写，为了理解初始化的含义，还是写上
    	}
    	
    	// 打表
    	// 状态转移方程不只是找规律，更要理解！
    	// 当第i个和第j个字符相同  或者 正则串的第i个字符是'?'(相当于相同)时：
    	// 		dp[i][j] = dp[i][j] = dp[i - 1][j - 1]
    	// 		即 继承了正则串前i-1个和原串前j-1个匹配的结果
    	// 当正则串第i个字符为'*'时：
    	//		dp[i][j] = dp[i - 1][j] || dp[i][j - 1]
    	//		这个逻辑极其精髓
    	// 		如果正则串的前i-1个可以和原串的前j个匹配，那么这个'*'就是空，前i个和前j个仍然匹配
    	//		如果正则串的前i个可以和串的前j-1个匹配配，那么这个'*'可以多代表原串一个任意字符，前i个和前j个仍然匹配
    	// 如果不相同且不是'*':
    	//		置false
    	for(int i = 1; i <= p.length(); i++) {
    		for(int j = 1; j <= s.length(); j++) {
    			if(p.charAt(i - 1) == s.charAt(j - 1) || p.charAt(i - 1) == '?') {
    				dp[i][j] = dp[i - 1][j - 1];
    			}else if(p.charAt(i - 1) == '*') {
    				dp[i][j] = dp[i - 1][j] || dp[i][j - 1];
    			}else {
    				dp[i][j] = false;		// 这句可以不写，写上便于理解
    			}
    		}
    	}
    	return dp[p.length()][s.length()];
    }
}

// 去掉注释和不必要代码
class Solution {
    public boolean isMatch(String s, String p) {
    	boolean[][] dp = new boolean[p.length() + 1][s.length() + 1];
    	dp[0][0] = true;
    	for(int i = 1; i <= p.length(); i++) {
    		if(p.charAt(i - 1) == '*') {
    			dp[i][0] = dp[i - 1][0];
    		}
    	}
    	for(int i = 1; i <= p.length(); i++) {
    		for(int j = 1; j <= s.length(); j++) {
    			if(p.charAt(i - 1) == s.charAt(j - 1) || p.charAt(i - 1) == '?') {
    				dp[i][j] = dp[i - 1][j - 1];
    			}else if(p.charAt(i - 1) == '*') {
    				dp[i][j] = dp[i - 1][j] || dp[i][j - 1];
    			}
    		}
    	}
    	return dp[p.length()][s.length()];
    }
}

 

 

【Q10】(hd) 正则表达式匹配
 
给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘’ 的正则表达式匹配。
 
‘.’ 匹配任意单个字符
'’ 匹配零个或多个前面的那一个元素
 
说明:
s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

class Solution {
	/*
	 *【动态规划】
	 * 
	 * 同样，s称为原串(对应j)，p称为正则串(对应i)
	 * dp[i][j]的意义为：正则串的前i个字符能否匹配原串的前j个字符
	 * 
	 * 关键点依旧有二：初始化；状态转移方程
	 * 先说状态转移方程：
	 * 		(设当前位置的字符分别为ss和pp)
	 * 		当 ss == pp，直接继承，也很好理解：
	 * 				dp[i][j] = dp[i - 1][j - 1]
	 * 		当  pp != '*'时(隐含pp!=ss)：
	 * 				直接置false，这句没必要写直接用默认值
	 * 		当  pp == '*'时(隐含pp!=ss)：
	 * 				当 p.charAt(i - 2) == p.charAt(i - 1)：
	 * 					dp[i][j] = dp[i][j - 1]，这样理解：反正*可以代表任意多个前一个字符，这个前一个字符又和原串s的j个字符相同，可以直接忽略这个第j个字符
	 * 												比如 ab* 去匹配 abbb，后者等价于abb，再等价ab，再等价到a (也就是不断的缩减等价)
	 * 					dp[i][j] = dp[i - 2][j]，这样理解：'*'取0个前一个字符，这两个字符直接相当于没有。
	 * 												比如上面的 ab* 去匹配abbb，等价到a后，'b*'直接相当于没有，a和a匹配成功
	 * 				当 p.charAt(i - 2) ！= p.charAt(i - 1)：
	 * 					dp[i][j] = dp[i - 2][j]，这样理解：和上面相比，"直接两个字符相当于没有"这种情况依旧存在，但少了不断缩减等价s串的情况
	 * 
	 * 再说初始化：
	 * 		首先dp[0][0]是true
	 * 		除了dp[0][0]，当正则串为空时，一定无法匹配：即dp[0][j]全是false
	 * 		当原串为空时，正则串有可能与其匹配(当正则串出现*时，继承dp[i - 2][0])。比如"a*b*"，是可以匹配空串的
	 * 
	 * 一点细节：
	 * 		1.给dp[i][j]填值的时候，取字符串的下标是i-1和j-1
	 * 		2.题意可知，【正则串的第一个字符不能为'*'】，比如"*ab"这种情况。也就是说我们不需要再进行if(i>=2)的判断，可以放心的填表
	 * 		3.上面一直没说p.charAt(i - 1)为'.'的情况———这很简单，每次写等于号时，或上一个p.charAt(i - 1) == '.'就行
	 */
    public boolean isMatch(String s, String p) {
    	boolean[][] dp = new boolean[p.length() + 1][s.length() + 1];
    	dp[0][0] = true;
    	for(int i = 1; i <= p.length(); i++) {
    		if(p.charAt(i - 1) == '*') {
    			dp[i][0] = dp[i - 2][0];
    		}
    	}
    	for(int i = 1; i <= p.length(); i++) {
    		for(int j = 1; j <= s.length(); j++) {
    			char pp = p.charAt(i - 1);
    			char ss = s.charAt(j - 1);
    			if(ss == pp || ss == '.' || pp == '.') {
    				dp[i][j] = dp[i - 1][j - 1];
    			}
    			if(pp == '*') {
    				if(p.charAt(i - 2) == ss || p.charAt(i - 2) == '.') {
						dp[i][j] = dp[i][j - 1] || dp[i - 2][j];
					}else {
						dp[i][j] = dp[i - 2][j];
					}
    			}
    		}
    	}
    	return dp[p.length()][s.length()];
    }
}

 

 

【Q44】(hd) 通配符匹配
 
给定一个 n × n 的二维矩阵表示一个图像。
 
将图像顺时针旋转 90 度。
 
说明：你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。
 
示例 :

给定 matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9] ],
 
原地旋转输入矩阵，使其变为: [
[7, 4, 1],
[8, 5, 2],
[9, 6, 3] ]

class Solution {
	/*
	 * 首先，因为是[原地]，所以思想必然是[交换]
	 *
	 * 【两层for循环】
	 * i 是对角线出的下标，每个i一个圈
	 * 通过此时的i和j，可以旋转一整个圈
	 * 
	 * 有两个关键点：
	 * 		一是两个for循环嵌套
	 * 		二是通过四个位置下标表示：matrix[i][j], matrix[len - 1 - j][i], matrix[len - 1 - i][len - 1 - j], matrix[j][len - 1 - i]：
	 * 
	 */
    public void rotate(int[][] matrix) {
    	int len = matrix.length;
    	for(int i = 0; i < (len / 2); i++) {
    		for(int j = i; j < len - 1 - i; j++) {
    			int temp = matrix[i][j];
    			matrix[i][j] = matrix[len - 1 - j][i];
    			matrix[len - 1 - j][i] = matrix[len - 1 - i][len - 1 - j];
    			matrix[len - 1 - i][len - 1 - j] = matrix[j][len - 1 - i];
    			matrix[j][len - 1 - i] = temp;
    		}  		
    	}
    }
}

 
 

 

 

 

 

 

 

 

 

 
 

 

 

Qs from https://leetcode-cn.com
♣ loli suki
♠ end