leetcode刷题记录-正则表达式匹配

leetcode刷题记录

题目 正则表达式匹配

题目描述

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。 示例 1： 输入：nums1 = [1,3], nums2 = [2] 输出：2.00000 解释：合并数组 = [1,2,3] ，中位数 2 示例 2： 输入：nums1 = [1,2], nums2 = [3,4] 输出：2.50000 解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5 示例 3： 输入：nums1 = [0,0], nums2 = [0,0] 输出：0.00000 示例 4： 输入：nums1 = [], nums2 = [1] 输出：1.00000 示例 5： 输入：nums1 = [2], nums2 = [] 输出：2.00000
提示：
nums1.length == m
nums2.length == n
0 <= m <= 1000 0 <= n <= 1000
1 <= m + n <= 2000 -10^6 <= nums1[i], nums2[i] <= 10^6
链接: leetcode地址

思路

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘’ 的正则表达式匹配。 ‘.’ 匹配任意单个字符 ‘’ 匹配零个或多个前面的那一个元素 所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。 示例 1： 输入：s = “aa” p = “a” 输出：false 解释：“a” 无法匹配 “aa” 整个字符串。 示例 2: 输入：s = “aa” p = “a*” 输出：true 解释：因为 ‘’ 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 ‘a’。因此，字符串 “aa” 可被视为 ‘a’ 重复了一次。 示例 3： 输入：s = “ab” p = ". " 输出：true 解释：".* " 表示可匹配零个或多个（’‘）任意字符（’.'）。 示例 4： 输入：s = “aab” p = “c * a * b” 输出：true 解释：因为 '’ 表示零个或多个，这里 ‘c’ 为 0 个, ‘a’ 被重复一次。因此可以匹配字符串 “aab”。 示例 5： 输入：s = “mississippi” p = “misisp*.” 输出：false 提示： 0 <= s.length <= 20 0 <= p.length <= 30 s 可能为空，且只包含从 a-z 的小写字母。 p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 。 保证每次出现字符 * 时，前面都匹配到有效的字符
题意
str一定不含有.
表达式串能不能搞成str

题解
样本对应模型
定义二维表
dp【i】:
str从i出发到后面的所有，能不能被表达式串从j出发到后面的所有配出来，
它俩之前的死去根本就不管

大过滤
str不能有. 和 *
exp 开头不能是, 两个不能挨着

	public static boolean isValid(char[] s, char[] e) {
		// s中不能有'.' or '*'
		for (int i = 0; i < s.length; i++) {
			if (s[i] == '*' || s[i] == '.') {
				return false;
			}
		}
		// 开头的e[0]不能是'*'，没有相邻的'*'
		for (int i = 0; i < e.length; i++) {
			if (e[i] == '*' && (i == 0 || e[i - 1] == '*')) {
				return false;
			}
		}
		return true;
	}

递归含义:
str从si出发及其后面的所有, 能不能被 exp从ei出发及其后面的所有配出来
能配出来返回true, 否则false
逻辑划分: ei下一个位置是不是*

1. ei下一个位置不是*
   如果ei+1不是，就说明我ei没有操作空间了。它不能指望后面的把它变没, 代表此时si必须能和ei对上
   

只能是 [ei]字符等于[si]字符
要么 [ei]字符是 . , 它能够变成一切

2. ei+1是*
   

ei跟si不相等, 只能让ei+1*把ei字符变成0个

相等的时候
0) 变零个
让a* 变0个a, 后面去匹配

1. 变1个a
   

2. 变两个a

3. 3个a

4. 4个a
   

所以每一种分支全都走，但有一个走通，直接返回true，所有分支都走不通，返回false，
代码
ei + 1位置是*
ei是c, 不进while

ei是a, 进while
变0个

变1个
…

最后一步跳出while, 尝试4个a的时候

	public static boolean isValid(char[] s, char[] e) {
		// s中不能有'.' or '*'
		for (int i = 0; i < s.length; i++) {
			if (s[i] == '*' || s[i] == '.') {
				return false;
			}
		}
		// 开头的e[0]不能是'*'，没有相邻的'*'
		for (int i = 0; i < e.length; i++) {
			if (e[i] == '*' && (i == 0 || e[i - 1] == '*')) {
				return false;
			}
		}
		return true;
	}

	// 初始尝试版本，不包含斜率优化
	public static boolean isMatch1(String str, String exp) {
		if (str == null || exp == null) {
			return false;
		}
		char[] s = str.toCharArray();
		char[] e = exp.toCharArray();
		return isValid(s, e) && process(s, e, 0, 0);
	}

	// str[si.....] 能不能被 exp[ei.....]配出来！ true false
	public static boolean process(char[] s, char[] e, int si, int ei) {
		if (ei == e.length) { // exp 没了 str？
			return si == s.length;
		}
		// exp[ei]还有字符
		// ei + 1位置的字符，不是*
		if (ei + 1 == e.length || e[ei + 1] != '*') {
			// ei + 1 不是*
			// str[si] 必须和 exp[ei] 能配上！
			return si != s.length && (e[ei] == s[si] || e[ei] == '.') && process(s, e, si + 1, ei + 1);
		}
		// exp[ei]还有字符
		// ei + 1位置的字符，是*!
		while (si != s.length && (e[ei] == s[si] || e[ei] == '.')) {
			if (process(s, e, si, ei + 2)) {
				return true;
			}
			si++;
		}
		return process(s, e, si, ei + 2);
	}

记忆化搜索

// 改记忆化搜索+斜率优化
	public static boolean isMatch2(String str, String exp) {
		if (str == null || exp == null) {
			return false;
		}
		char[] s = str.toCharArray();
		char[] e = exp.toCharArray();
		if (!isValid(s, e)) {
			return false;
		}
		int[][] dp = new int[s.length + 1][e.length + 1];
		// dp[i][j] = 0, 没算过！
		// dp[i][j] = -1 算过，返回值是false
		// dp[i][j] = 1 算过，返回值是true
		return isValid(s, e) && process2(s, e, 0, 0, dp);
	}

	public static boolean process2(char[] s, char[] e, int si, int ei, int[][] dp) {
		if (dp[si][ei] != 0) {
			return dp[si][ei] == 1;
		}
		boolean ans = false;
		if (ei == e.length) {
			ans = si == s.length;
		} else {
			if (ei + 1 == e.length || e[ei + 1] != '*') {
				ans = si != s.length && (e[ei] == s[si] || e[ei] == '.') && process2(s, e, si + 1, ei + 1, dp);
			} else {
				if (si == s.length) { // ei ei+1 *
					ans = process2(s, e, si, ei + 2, dp);
				} else { // si没结束
					if (s[si] != e[ei] && e[ei] != '.') {
						ans = process2(s, e, si, ei + 2, dp);
					} else { // s[si] 可以和 e[ei]配上
						ans = process2(s, e, si, ei + 2, dp) || process2(s, e, si + 1, ei, dp);
					}
				}
			}
		}
		dp[si][ei] = ans ? 1 : -1;
		return ans;
	}

优化
斜率优化, 省掉while
f(13, 29)的依赖

f(12, 29)的依赖

在str中i位置字符和str中i+1位置字符它一样的时候就存在这个优化

例子

14开始的状态没有13开始的大

代码

当我一个格子有枚举行为的时候，我就观察他已经算过的格子，能不能把枚举行为替代掉，
从而得到一个使用有限若干个位置的方式来得到这一个格子的值

斜率优化时, 不能配上通项公式也是一样的

代码

// 动态规划版本 + 斜率优化
	public static boolean isMatch3(String str, String pattern) {
		if (str == null || pattern == null) {
			return false;
		}
		char[] s = str.toCharArray();
		char[] p = pattern.toCharArray();
		if (!isValid(s, p)) {
			return false;
		}
		int N = s.length;
		int M = p.length;
		boolean[][] dp = new boolean[N + 1][M + 1];
		dp[N][M] = true;
		for (int j = M - 1; j >= 0; j--) {
			dp[N][j] = (j + 1 < M && p[j + 1] == '*') && dp[N][j + 2];
		}
		// dp[0..N-2][M-1]都等于false，只有dp[N-1][M-1]需要讨论
		if (N > 0 && M > 0) {
			dp[N - 1][M - 1] = (s[N - 1] == p[M - 1] || p[M - 1] == '.');
		}
		for (int i = N - 1; i >= 0; i--) {
			for (int j = M - 2; j >= 0; j--) {
				if (p[j + 1] != '*') {
					dp[i][j] = ((s[i] == p[j]) || (p[j] == '.')) && dp[i + 1][j + 1];
				} else {
					if ((s[i] == p[j] || p[j] == '.') && dp[i + 1][j]) {
						dp[i][j] = true;
					} else {
						dp[i][j] = dp[i][j + 2];
					}
				}
			}
		}
		return dp[0][0];
	}

一般 将 尝试改成记忆化搜索就可以过了