leetcode-正则表达式和通配符匹配的dp解法

正则表达式匹配

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。’.’ 匹配任意单个字符，’*’ 匹配零个或多个前面的那一个元素。 所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

示例：输入: s = “aab”，p = “c*a*b”
输出: true
解释: 因为 ‘*’ 表示零个或多个，这里 ‘c’ 为 0 个, ‘a’ 被重复一次。因此可以匹配字符串 “aab”。

分析：

初始解： 初始解一般是对第一个变量等于0的情况，含义即源字符串为空的时候怎么与模式串P进行匹配。
首先想到两个都是空的时候，是匹配的，为true。如果模式串不为空，也要分情况讨论：

1. 对p[j] != ‘*’，一定是不匹配的
2. 如果p[j] == ‘*’，那么就存在p[j-1]p[j]这两个模式串使用0次，也可以匹配
   因此初始解dp[0][j]可以定义为:
   2.1 对p[j] != ‘*’，一定是不匹配的，等于false
   2.2 如果p[j] == ‘*’，那么就存在p[j-1]p[j]这两个模式串使用0次，也可以匹配,等于 dp[0][j-2]

主流程：

1. 如果 p.(j) == s.(i) ，则 dp[i][j] = dp[i-1][j-1]；
2. 如果 p.(j) == ‘.’ ，则dp[i][j] = dp[i-1][j-1]；
3. 如果 p.(j) == ‘*’：
   3.1 如果 p.(j-1) != s.(i) : dp[i][j] = dp[i][j-2] // in this case, a* only counts as empty
   3.2 如果 p.(j-1) == s.(i) || p.(j-1) == ‘.’ , 则
   dp[i][j] = dp[i-1][j] // * 匹配多个字符
   || dp[i][j-1] // * 匹配单个字符（由 p.(j-1) == s.(i) || p.(j-1) == '.'知dp[i][j-1] =dp[i-1][j-2], 而这个可由匹配多个字符再匹配空字符推导而来，所以这个条件可省略）
   || dp[i][j-2] // * 匹配空字符

解法1：dp解法

class Solution {
public:
	   	bool isMatch(string s, string p) {
		int ns = s.length();
		int np = p.length();
		if (p.empty()) return s.empty();
		vector<vector<bool>> dp(ns + 1, vector<bool>(np + 1, false));
		dp[0][0] = true;
		for (int i = 1; i <= np; i++) {
			if (i - 2 >= 0 && p[i - 1] == '*' && p[i - 2]) {
				dp[0][i] = dp[0][i - 2];
			}
		}

		for (int i = 1; i <= ns; i++) {
			for (int j = 1; j <= np; j++) {
				if (p[j - 1] == s[i - 1] || p[j - 1] == '.')
					dp[i][j] = dp[i - 1][j - 1];
				if (p[j - 1] == '*') {
					bool zero, one;
					if (j - 2 >= 0) {
						zero = dp[i][j - 2];
						one = (p[j - 2] == s[i - 1] || p[j - 2] == '.') && dp[i - 1][j];
						dp[i][j] = zero || one;
					}
				}
			}
		}
		return dp[ns][np];
	}
};

解法2：回溯法（递归求解）

class Solution {
public:
    bool match(char* str, char* pattern)
    {
        // 指针为空，返回false
        if(str == NULL || pattern == NULL){
            return false;
        }
        return matchCore(str, pattern);
    }
private:
    bool matchCore(char* str, char* pattern){
        // 字符串和模式串都运行到了结尾，返回true
        if(*str == '\0' && *pattern == '\0'){
            return true;
        }
        // 字符串没有到结尾，模式串到了，则返回false
        // 模式串没有到结尾，字符串到了，则根据后续判断进行，需要对'*'做处理
        if((*str != '\0' && *pattern == '\0')){
            return false;
        }
        // 如果模式串的下一个字符是'*'，则进入状态机的匹配
        if(*(pattern + 1) == '*'){
            // 如果字符串和模式串相等，或者模式串是'.'，并且字符串没有到结尾，则继续匹配
            if(*str == *pattern || (*pattern == '.' && *str != '\0')){
                // 进入下一个状态，就是匹配到了一个
                return matchCore(str + 1, pattern + 2) ||
                    // 保持当前状态，就是继续那这个'*'去匹配
                    matchCore(str + 1, pattern) ||
                    // 跳过这个'*'
                    matchCore(str, pattern + 2);
            }
            // 如果字符串和模式串不相等，则跳过当前模式串的字符和'*'，进入新一轮的匹配
            else{
                // 跳过这个'*'
                return matchCore(str, pattern + 2);
            }
        }
        // 如果字符串和模式串相等，或者模式串是'.'，并且字符串没有到结尾，则继续匹配
        if(*str == *pattern || (*pattern == '.' && *str != '\0')){
            return matchCore(str + 1, pattern + 1);
        }
        return false;
    }
};

---

通配符匹配

给定一个字符串 (s) 和一个字符模式 ( p ) ，实现一个支持 ‘?’ 和 ‘*’ 的通配符匹配。’?’ 可以匹配任何单个字符。’*’ 可以匹配任意字符串（包括空字符串）。 两个字符串完全匹配才算匹配成功。说明: s 可能为空，且只包含从 a-z 的小写字母。p 可能为空，且只包含从 a-z 的小写字母，以及字符 ? 和 *。

示例1：输入:s = “cb”，p = “?a”
输出: false。
解释: ‘?’ 可以匹配 ‘c’, 但第二个 ‘a’ 无法匹配 ‘b’。

示例2：输入: s = “acdcb”，p = “a*c?b”
输入: false

分析：
状态定义: dp[i][j]：表示 s 的前i个字符是否与 p的前j个字符是否匹配
状态方程:

1. 当 s[i] == p[j] 或者p[j] == ‘?’ 时,dp[i][j] = dp[i-1][j-1]
2. 当 s[i] != p[j] && p[j] == ‘*’ 时, dp[i][j] = dp[i-1][j] || dp[i][j-1]
   dp[i-1][j]：匹配任意非空字符，例如abkk,ab*
   dp[i][j-1]：匹配空字符相当于0个，例如ab，ab*

初始化:
dp[0][0]：两个空字符串，为true.
dp[0][j]：当s为空，p为*号时，为true.
p[j-1] == ‘*’ && dp[0][j] = dp[0][j-1]

class Solution {
	public:
		bool isMatch(string s, string p) {
			vector<vector<int>>dp(s.size() + 1, vector<int>(p.size() + 1, 0));
			dp[0][0] = 1;
			//初始化
			for (int j = 1; j <= p.size(); j++) {
				if (p[j - 1] == '*')
					dp[0][j] = dp[0][j - 1];
			}
			//主流程		
			for (int i = 1; i <= s.size(); i++) {
				for (int j = 1; j <= p.size(); j++) {
					if (s[i - 1] == p[j - 1] || p[j - 1] == '?') {
						dp[i][j] = dp[i - 1][j - 1];
					}
					else if (p[j - 1] == '*') {
						dp[i][j] = dp[i][j - 1] || dp[i - 1][j];
					}
				}
			}
			return dp[s.size()][p.size()];
		}
	};

---