基础算法（Leetcode）刻意练习第十八天——字符串

引言

由 “LSGO软件技术团队” 组织的 “基础算法刻意练习” 采用分类别练习的模式，即选择了五个知识点（数组、链表、字符串、树、贪心算法），每个知识点选择了 三个简单、两个中等、一个困难 等级的题目，共计三十道题，利用三十天的时间完成这组刻意练习。以下是我的每日打卡记录：

---

Task18.正则表达式匹配

• Leetcode第10题

• 难度：困难

• 题目概述：

    给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 
    的正则表达式匹配。
    
    '.' 匹配任意单个字符
    '*' 匹配零个或多个前面的那一个元素
    所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。
    
    说明:
    s 可能为空，且只包含从 a-z 的小写字母。
    p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *
    
    示例 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 = "mis*is*p*."
    输出: false
  

---

题解思路

---

• 1.回溯法（参考题解）

对于任意的 p，其实只有出现 * 的时候才会感到很复杂。但是当我们细细梳理一遍以后，会发现 * 号只有三种情况：
1.* 号代表前面的非 . 字符出现 0 次
2.* 号代表前面的非 . 字符出现大于0次
3.“ .* ”组合
那么对应的三种解决办法也就顺势而出：
1.将 s 从 * 号后一位开始比较
2.一步步后移，直到遇到与 * 号代表字符不同的字符
3.一步一步试探 * 号后方的 p 是否能与剩下的 s 匹配，不能就增加 * 代表的位数
最后记得设置递归基。

时间复杂度：O( (T+P)2^T+P/2 ) ，T为 s 的长度，P为 p 的长度

class Solution {
    public boolean isMatch(String s, String p) {
        if(p.isEmpty())
            return s.isEmpty();
        boolean first=( !s.isEmpty() && (s.charAt(0)==p.charAt(0) || p.charAt(0)=='.') );
        if(p.length()>=2 && p.charAt(1)=='*') //如果下一个字符是 *
        			//此处判断*号之后的字符串是否与first之后的字符串匹配
            return first && isMatch(s.substring(1),p) || 
                   isMatch(s,p.substring(2)); 
        else
            return first && isMatch(s.substring(1),p.substring(1));
    }
}

提交记录

---

• 2.动态规划（参考题解）

同回溯的思路，不过我们将每个状态记录下来，用 dp[ i ] [ j ] 表示 s 的前 i 个是否能被 p 的前 j 个匹配，那么遍历所有的 i，j 就可以得到最终的答案。
最后当 p.charAt(j) == ‘*’ 时，对应思路1回溯可得：

dp[ i ] [ j+1 ] ：对应情况 " a* " 大于一次
dp[ i+1 ] [ j ] ： 对应情况 " a* " 等于一次
dp[ i+1 ] [ j-1 ] ： 对应情况 " a* " 为零次

时间复杂度：O(TP) ，T为 s 的长度，P为 p 的长度

class Solution {
    public boolean isMatch(String s,String p){
        if(p.isEmpty())
            return s.isEmpty();
        int len1=s.length(),len2=p.length();;
        boolean[][] dp = new boolean[len1 + 1][len2 + 1];
        dp[0][0] = true;//dp[i][j] 
        for (int i = 1; i < len2; i+=2)  //避免 s="" p="a*a*a*" 的情况
            if (p.charAt(i) == '*' && dp[0][i - 1]) 
                dp[0][i + 1] = true; 
        for (int i = 0; i < len1; i++) 
            for (int j = 0; j < len2; j++) {
                if (p.charAt(j) == '.' || p.charAt(j) == s.charAt(i)) 
                //如果是任意元素 或者是对于元素匹配
                    dp[i + 1][j + 1] = dp[i][j];
                if (p.charAt(j) == '*') 
                    //如果前一个元素不匹配 且不为任意元素
                    if (p.charAt(j - 1) != s.charAt(i) && p.charAt(j - 1) != '.') 
                        dp[i + 1][j + 1] = dp[i + 1][j - 1];
                    else 
                        dp[i + 1][j + 1] = (dp[i][j + 1] || dp[i + 1][j] || dp[i + 1][j - 1]);
            }
        return dp[len1][len2];
    }
}

提交记录

---

• 3.开玩笑之——正则表达式

虽然题目要求自己实现正则表达式匹配，但是，毕竟正则表达式本身就是一种实现方式，所以，还可以做个弊 [狗头保命]。

import java.util.regex.Matcher;
import java.util.regex.Pattern;
class Solution {
    public boolean isMatch(String s, String p) {
		return Pattern.compile(p).matcher(s).matches();
    }
}

提交记录

---