小黑科二通过，开启第二学期的上班，带着呆呆完整跑下了南二环，申请出京十分恐惧，去大黑驴屋子里吃大黑驴做的饭感慨厨艺高超，买了前往大兴机场高铁的leetcode之旅:44. 通配符匹配

最新推荐文章于 2024-10-18 10:39:20 发布

爱喝喜茶爱吃烤冷面的小黑黑

最新推荐文章于 2024-10-18 10:39:20 发布

阅读量619

点赞数 8

分类专栏：小黑的日常leetcode之旅文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/qq_37418807/article/details/138348475

版权

小黑的日常leetcode之旅专栏收录该内容

225 篇文章 1 订阅

订阅专栏

小黑独立做出一道困难题，继续开启力扣之旅，干就完了

小黑代码

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        # 字符串和模式串长度
        len_s = len(s)
        len_p = len(p)
        # 初始化动态规划数组
        dp = [[False]*(len(s)+1) for _ in range(len_p+1)]
        dp[0][0] = True
        # 开始动态规划操作
        for i in range(1, len_p+1):
            for j in range(len_s+1):
                # 末端字符匹配的情况下(保证j>0)
                if j and (p[i-1] == s[j-1] or p[i-1] == '?'):
                    dp[i][j] = dp[i-1][j-1]
                # 模式串带*
                elif p[i-1] == '*':
                    # 考虑p: (xx*) 与s: (xx)的情况
                    dp[i][j] = dp[i-1][j]
                    # j>0需考虑比较p: (xx)*与s: (xx)a的括号里的内容
                    if j:
                        dp[i][j] = dp[i-1][j-1] or dp[i][j-1] or dp[i][j]

        return dp[len_p][len_s]

在这里插入图片描述

动态规划

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        # 模式串与字符串长度
        len_s = len(s)
        len_p = len(p)
        # 初始化动态规划数组
        dp = [[False] * (len_s+1) for _ in range(len_p+1)] 
        # 初始值
        dp[0][0] = True
        # 模式串以一个或者多个“*”为开头，可以匹配空字符(数组对应为True)
        for t in range(len_p):
            if p[t] != '*':
                break
            dp[t+1][0] = True
        # 开始动态规划
        for i in range(1, len_p+1):
            for j in range(1, len_s+1):
                # 模式串的末端字符为*
                if p[i-1] == '*':
                    dp[i][j] = dp[i-1][j] or dp[i][j-1] or dp[i-1][j-1]
                # 相等或者模式串末端为'?'
                elif p[i-1] == s[j-1] or p[i-1] == '?':
                    dp[i][j] = dp[i-1][j-1]
        return dp[len_p][len_s]

在这里插入图片描述

贪心匹配

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        # 字符匹配函数
        def match(s_c, p_c):
            if s_c == p_c or p_c == '?':
                return True
            return False
        # 匹配结尾，直到碰到p中为*
        sRight = len(s)
        pRight = len(p)
        # 将p变成xxxx*xxx*xx*的情况
        while pRight > 0 and p[pRight-1] != '*':
            # 不匹配的情况，或者是s已经匹配到头而p还有
            if sRight == 0 or (not match(s[sRight-1], p[pRight-1])):
                return False
            sRight -= 1
            pRight -= 1
        # p已经变成xxxx*xxx*xx*的形式
        pRecord = -1
        sRecord = -1
        pIndex = 0
        sIndex = 0
        while pIndex < pRight and sIndex < sRight:
            # p碰到了*，开始在s中匹配下一个子序列
            if p[pIndex] == '*':
                pIndex += 1
                pRecord = pIndex
                sRecord = sIndex
            # 匹配的情况，指针同时往前走
            elif match(s[sIndex], p[pIndex]):
                pIndex += 1
                sIndex += 1
            # 如果不匹配，重新匹配p中的当前子序列
            elif pRecord!=-1 and sRecord+1 < sRight:
                sRecord += 1
                sIndex = sRecord
                pIndex = pRecord
            else:
                return False
        # p已经匹配完，而s没有匹配完
        if pRight==0 and sRight!=0:
            return False
        # s匹配完，p没匹配完，判断是否只剩下*
        
        for i in range(pIndex, pRight):
            if p[i] != '*':
                return False
        return True