【算法挨揍日记】day39——10. 正则表达式匹配、97. 交错字符串

 10. 正则表达式匹配

10. 正则表达式匹配

题目解析：

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。

• '.' 匹配任意单个字符
• '*' 匹配零个或多个前面的那一个元素

所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

 

解题思路：

算法思路：

1. 状态表⽰：

对于两个字符串之间的 dp 问题，我们⼀般的思考⽅式如下：

i. 选取第⼀个字符串的 [0, i] 区间以及第⼆个字符串的 [0, j] 区间当成研究对象，结

合题⽬的要求来定义「状态表⽰」；

ii. 然后根据两个区间上「最后⼀个位置的字符」，来进⾏「分类讨论」，从⽽确定「状态转移

⽅程」。

我们可以根据上⾯的策略，解决⼤部分关于两个字符串之间的 dp 问题。

因此我们定义状态表⽰：

dp[i][j] 表⽰：字符串 p 的 [0, j] 区间和字符串 s 的 [0, i] 区间是否可以匹配。

2. 状态转移⽅程：

⽼规矩，根据最后⼀个位置的元素，结合题⽬要求，分情况讨论：

a. 当 s[i] == p[j] 或 p[j] == '.' 的时候，此时两个字符串匹配上了当前的⼀个字符，

只能从 dp[i - 1][j - 1] 中看当前字符前⾯的两个⼦串是否匹配。只能继承上个状态中

的匹配结果， dp[i][j] = dp[i - 1][j - 1] ；

b. 当 p[j] == '*' 的时候，和上道题稍有不同的是，上道题 "*" 本⾝便可匹配 0 ~ n 个

字符，但此题是要带着 p[j - 1] 的字符⼀起，匹配 0 ~ n 个和 p[j - 1] 相同的字

符。此时，匹配策略有两种选择：

▪ ⼀种选择是： p[j - 1]* 匹配空字符串，此时相当于这两个字符都匹配了⼀个寂寞，直

接继承状态 dp[i][j - 2] ，此时 dp[i][j] = dp[i][j - 2] ；

▪ 另⼀种选择是： p[j - 1]* 向前匹配 1 ~ n 个字符，直⾄匹配上整个 s1 串。此时

相当于从 dp[k][j - 2] (0 < k <= i) 中所有匹配情况中，选择性继承可以成功的

情况。此时 dp[i][j] = dp[k][j - 2] (0 < k <= i 且 s[k]~s[i] = p[j

- 1]) ；

c. 当 p[j] 不是特殊字符，且不与 s[i] 相等时，⽆法匹配。

三种情况加起来，就是所有可能的匹配结果。

综上所述，状态转移⽅程为：

▪ 当 s[i] == p[j] 或 p[j] == '.' 时： dp[i][j] = dp[i][j - 1] ；

▪ 当 p[j] == '*' 时，有多种情况需要讨论： dp[i][j] = dp[i][j - 2] ；

dp[i][j] = dp[k][j - 1] (0 <= k <= i) 。

优化：当我们发现，计算⼀个状态的时候，需要⼀个循环才能搞定的时候，我们要想到去优化。优

化的⽅向就是⽤⼀个或者两个状态来表⽰这⼀堆的状态。通常就是把它写下来，然后⽤数学的⽅式

做⼀下等价替换：

当 p[j] == '*' 时，状态转移⽅程为：

dp[i][j] = dp[i][j - 2] || dp[i - 1][j - 2] || dp[i - 2][j - 2]

......

我们发现 i 是有规律的减⼩的，因此我们去看看 dp[i - 1][j] ：

dp[i - 1][j] = dp[i - 1][j - 2] || dp[i - 2][j - 2] || dp[i - 3]

[j - 2] ......

我们惊奇的发现， dp[i][j] 的状态转移⽅程⾥⾯除了第⼀项以外，其余的都可以⽤ dp[i -

1][j] 替代。因此，我们优化我们的状态转移⽅程为： dp[i][j] = dp[i][j - 2] ||

dp[i - 1][j] 。

3. 初始化：

由于 dp 数组的值设置为是否匹配，为了不与答案值混淆，我们需要将整个数组初始化为

false 。

由于需要⽤到前⼀⾏和前⼀列的状态，我们初始化第⼀⾏、第⼀列即可。

dp[0][0] 表⽰两个空串能否匹配，答案是显然的， 初始化为 true 。

第⼀⾏表⽰ s 是⼀个空串， p 串和空串只有⼀种匹配可能，即 p 串全部字符表⽰为 "任⼀字符

+ *"，此时也相当于空串匹配上空串。所以，我们可以遍历 p 串，把所有前导为 "任⼀字符 + *"

的 p ⼦串和空串的 dp 值设为 true 。

第⼀列表⽰ p 是⼀个空串，不可能匹配上 s 串，跟随数组初始化即可。

4. 填表顺序：

从上往下填每⼀⾏，每⼀⾏从左往右。

5. 返回值：

根据状态表⽰，返回 dp[m][n] 的值。

解题代码：

class Solution {
public:
    bool isMatch(string s, string p) {
        int m=s.size();
        int n=p.size();
        vector<vector<bool>>dp(m+1,vector<bool>(n+1));
        dp[0][0]=true;
        s=' '+s;
        p=' '+p;
        for(int j = 2; j <= n; j += 2)
            if(p[j] == '*') dp[0][j] = true;
            else break;
        for(int i=1;i<=m;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(s[i]==p[j]||p[j]=='.')
                    dp[i][j]=dp[i-1][j-1];
                if(p[j]=='*')
                    dp[i][j]=dp[i][j-2]||(p[j - 1] == '.' || p[j - 1] == s[i])&&dp[i-1][j];

            }
        }
        return dp[m][n];
    }
};

 97. 交错字符串
97. 交错字符串

题目描述：

给定三个字符串 s1、s2、s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错 组成的。

两个字符串 s 和 t 交错 的定义与过程如下，其中每个字符串都会被分割成若干 非空 子字符串：

• s = s1 + s2 + ... + sn
• t = t1 + t2 + ... + tm
• |n - m| <= 1
• 交错 是 s1 + t1 + s2 + t2 + s3 + t3 + ... 或者 t1 + s1 + t2 + s2 + t3 + s3 + ...

注意：a + b 意味着字符串 a 和 b 连接。

 解题思路：

算法思路：

对于两个字符串之间的 dp 问题，我们⼀般的思考⽅式如下：

i. 选取第⼀个字符串的 [0, i] 区间以及第⼆个字符串的 [0, j] 区间当成研究对象，结

合题⽬的要求来定义「状态表⽰」；

ii. 然后根据两个区间上「最后⼀个位置的字符」，来进⾏「分类讨论」，从⽽确定「状态转移

⽅程」。

我们可以根据上⾯的策略，解决⼤部分关于两个字符串之间的 dp 问题。

这道题⾥⾯空串是有研究意义的，因此我们先预处理⼀下原始字符串，前⾯统⼀加上⼀个占位符：

s1 = " " + s1, s2 = " " + s2, s3 = " " + s3 。

1. 状态表⽰：

dp[i][j] 表⽰字符串 s1 中 [1, i] 区间内的字符串以及 s2 中 [1, j] 区间内的字符

串，能否拼接成 s3 中 [1, i + j] 区间内的字符串。

2. 状态转移⽅程：

先分析⼀下题⽬，题⽬中交错后的字符串为 s1 + t1 + s2 + t2 + s3 + t3...... ，看

似⼀个 s ⼀个 t 。实际上 s1 能够拆分成更⼩的⼀个字符，进⽽可以细化成 s1 + s2 +

s3 + t1 + t2 + s4...... 。

也就是说，并不是前⼀个⽤了 s 的⼦串，后⼀个必须要⽤ t 的⼦串。这⼀点理解，对我们的状

态转移很重要。

继续根据两个区间上「最后⼀个位置的字符」，结合题⽬的要求，来进⾏「分类讨论」：

i. 当 s3[i + j] = s1[i] 的时候，说明交错后的字符串的最后⼀个字符和 s1 的最后⼀

个字符匹配了。那么整个字符串能否交错组成，变成：

s1 中 [1, i - 1] 区间上的字符串以及 s2 中 [1, j] 区间上的字符串，能够交

错形成 s3 中 [1, i + j - 1] 区间上的字符串，也就是 dp[i - 1][j] ；

此时 dp[i][j] = dp[i - 1][j]

ii. 当 s3[i + j] = s2[j] 的时候，说明交错后的字符串的最后⼀个字符和 s2 的最后

⼀个字符匹配了。那么整个字符串能否交错组成，变成：

s1 中 [1, i] 区间上的字符串以及 s2 中 [1, j - 1] 区间上的字符串，能够交

错形成 s3 中 [1, i + j - 1] 区间上的字符串，也就是 dp[i][j - 1] ；

iii. 当两者的末尾都不等于 s3 最后⼀个位置的字符时，说明不可能是两者的交错字符串。

上述三种情况下，只要有⼀个情况下能够交错组成⽬标串，就可以返回 true 。因此，我们可以

定义状态转移为：

dp[i][j] = (s1[i - 1] == s3[i + j - 1] && dp[i - 1][j])

|| (s2[j - 1] == s3[i + j - 1] && dp[i][j - 1])

只要有⼀个成⽴，结果就是 true 。

3. 初始化：

由于⽤到 i - 1 , j - 1 位置的值，因此需要初始化「第⼀个位置」以及「第⼀⾏」和「第⼀

列」。

◦ 第⼀个位置：

dp[0][0] = true ，因为空串 + 空串能够构成⼀个空串。

◦ 第⼀⾏：

第⼀⾏表⽰ s1 是⼀个空串，我们只⽤考虑 s2 即可。因此状态转移之和 s2 有关：

dp[0][j] = s2[j - 1] == s3[j - 1] && dp[0][j - 1] ， j 从 1 到 n

（ n 为 s2 的⻓度）

◦ 第⼀列：

第⼀列表⽰ s2 是⼀个空串，我们只⽤考虑 s1 即可。因此状态转移之和 s1 有关：

dp[i][0] = s1[i - 1] == s3[i - 1] && dp[i - 1][0] ， i 从 1 到 m

（ m 为 s1 的⻓度）

4. 填表顺序：

根据「状态转移」，我们需要「从上往下」填每⼀⾏，每⼀⾏「从左往右」。

5. 返回值：

根据「状态表⽰」，我们需要返回 dp[m][n] 的值。

解题代码：

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int m=s1.size();
        int n=s2.size();
        vector<vector<bool>>dp(m+1,vector<bool>(n+1));
        if(m+n!=s3.size())return false;
        dp[0][0]=true;
        s1=' '+s1;s2=' '+s2;s3=' '+s3;
        for(int i=1;i<=n;i++)
            if(dp[0][i-1]==true&&s2[i]==s3[i]) dp[0][i]=true;
            else dp[0][i]=false;
        for(int j=1;j<=m;j++)
            if(dp[j-1][0]==true&&s1[j]==s3[j])dp[j][0]=true;
            else dp[j][0]=false;
        for(int i=1;i<=m;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(s3[i+j]==s1[i]&&dp[i-1][j]==true)
                    dp[i][j]=true;
                if(s3[i+j]==s2[j]&&dp[i][j-1]==true)
                    dp[i][j]=true;
            }
        }
        return dp[m][n];
    }
};