• 正则表达式及通配符匹配问题（建议收藏）

    目录

    一.通配符匹配问题⭐⭐⭐⭐

    二.正则表达式匹配⭐⭐⭐⭐⭐

    一.通配符匹配问题⭐⭐⭐⭐

    1.对应letecode链接：

    44. 通配符匹配 - 力扣（LeetCode）

    2.题目描述：

    3.解题思路：

    本题的题意是实现支持'?' 和 '*' 的通配符匹配的字符串匹配，像这种字符串匹配的题目大概率是这个样本对应模型：在这里我们可以进行尝试，定义这个递归函数进行尝试：

    bool process(const string&s,int si,const string&p,int pi);

    这个递归函数的含义是字符串s从si位置一直到结尾能和字符串p从pi位置开始一直到字符串的结尾。返回值：如果能够匹配上则返回true否则返回false.

    下面我们来分析可能性：

    1.当前si位置上的字符和pi位置的字符相等：此时能否匹配成功决定于后面的字符能否匹配成功

     2.情况二:si位置上的字符不等于pi位置上的字符但是pi位置上的字符为 ?那么此时字符串能否匹配成功也是决定与后面的字符能否匹配成功这是因为.可以匹配任意单个字符

     

    情况三:也是最复杂的一种情况：si位置上的字符和 pi位置的字符不相等并且pi位置的字符为*

    此时这个*可以匹配s字符串当中的0个字符，1个字符，2个字符，3个字符，4字符，一直匹配到字符串的结尾，在这个过程当中只要有一次匹配成功了那么就匹配成功了。情况四非常的简单就是si位置的字符和pi位置的字符不相等并且pi位置的字符不是*也不是.此时直接返回false即可

     4.对应代码：

    1. class Solution {
    2.   public:
    3.     bool isMatch(string s, string p) {
    4.         return process(s, 0, p, 0);
    5.  
    6.     }
    7.     //字符串s从0位置开始一直到结尾能否匹配字符串p从pi位置开始一直到结尾
    8.     bool process( string& s, int si, string& p, int pi) {
    9.         //两个字符串都到了字符串的结尾空串和空串一定匹配
    10.         if (si == s.size() && pi == p.size()) {
    11.             return true;
    12.         }
    13.         //s还没结束但是p已经结束了
    14.         if (pi == p.size()) {
    15.             return false;
    16.         }
    17.  
    18.         if (si == s.size()) {
    19.             //*可以匹配空串
    20.             return  (p[pi] == '*') && process(s, si, p, pi + 1);
    21.         }
    22.         //情况一和情况二合并
    23.         if (s[si] == p[pi] || p[pi] == '?') {
    24.             return process(s, si + 1, p, pi + 1);
    25.         }
    26.         //情况三
    27.         else if (p[pi] == '*') {
    28.             //开始进行产生
    29.             for (int i = 0; i <= s.size() - si; i++) {
    30.                 //开始进行尝试匹配
    31.                 if (process(s, si + i, p, pi + 1)) {
    32.                     return true;
    33.                 }
    34.             }
    35.         }
    36.         //情况四：
    37.  
    38.         return false;
    39.  
    40.     }
    41. };

    对应记忆化搜索：

    1. class Solution {
    2.   public:
    3.     vectorint>>dp;
    4.     bool isMatch(string s, string p) {
    5.         dp.resize(s.size() + 1, vector<int>(p.size() + 1, -1));
    6.         return process(s, 0, p, 0);
    7.     }
    8.     bool process(const string& s, int si, const string& p, int pi) {
    9.         if (si == s.size() && pi == p.size()) {
    10.             return true;
    11.         }
    12.         if (si == s.size()) {
    13.             return p[pi] == '*' && process(s, si, p, pi + 1);
    14.         }
    15.         if (pi == p.size()) {
    16.             return false;
    17.         }
    18.         if (dp[si][pi] != -1) {
    19.             return dp[si][pi];
    20.         }
    21.         bool ans = false;
    22.         if (s[si] == p[pi] || p[pi] == '?') {
    23.             ans = process(s, si + 1, p, pi + 1);
    24.         }
    25.  
    26.         else if (p[pi] == '*') {
    27.             for (int i = 0; i <= s.size() - si; i++) {
    28.                 if (process(s, si + i, p, pi + 1)) {
    29.                     ans = true;
    30.                 }
    31.             }
    32.         }
    33.         dp[si][pi] = ans;
    34.         return ans;
    35.  
    36.     }
    37.  
    38. };

    斜率优化我们可以观察一下当p[pi]=='*时的对应关系：

    dp[i][j]=dp[i][j+1] | dp[i+1][j+1] | dp[i+2][j+1] | dp[i+3][j+1]............................

    我们来看一下dp[i+1][j]=dp[i+2][j+1] | dp[i+3][j+1] | dp[i+4][j+1]...........................

    通过观察可以发现dp[i+1][j]可以优化dp[i][j]

    对应代码：

    1. class Solution {
    2. public:
    3.     bool isMatch(string s, string p) {
    4.         vectorbool>>dp(s.size()+1,vector<bool>(p.size()+1));
    5.         int N=s.size()+1;
    6.         int M=p.size()+1;
    7.         dp[N-1][M-1]=true;
    8.          for(int i=p.size()-1;i>=0;i--)//根据暴力递归得到
    9.          {
    10.              dp[s.size()][i]=p[i]=='*'&&dp[s.size()][i+1];
    11.          }
    12.         for(int i=s.size()-1;i>=0;i--)
    13.         {
    14.             for(int j=p.size();j>=0;j--)
    15.             {
    16.                 if(s[i]==p[j])//全部根据暴力递归得到的状态转移方程
    17.                 {
    18.                     dp[i][j]=dp[i+1][j+1];
    19.                 }
    20.                 else
    21.                 {
    22.                     if(p[j]=='?')
    23.                     {
    24.                         dp[i][j]=dp[i+1][j+1];
    25.                     }
    26.                     else if(p[j]=='*')
    27.                     {
    28.                        dp[i][j]=dp[i][j+1]|dp[i+1][j];
    29.                     }
    30.                     else
    31.                     {
    32.                         dp[i][j]=false;
    33.                     }
    34.                 }
    35.             }
    36.         }
    37.         return dp[0][0];
    38.     }
    39.     //递归含义str1从[0.......i],str2[0......j]能否匹配
    40.     bool process(const string&str1,const string&str2,int i,int j)
    41.     {
    42.         //str2可能有*和？
    43.         if(i==str1.size()&&j==str2.size())
    44.         {
    45.             return true;
    46.         }
    47.         if(i==str1.size())
    48.         {
    49.             
    50.             return str2[j]=='*'&&process(str1,str2,i,j+1);
    51.         }
    52.  
    53.         if(j==str2.size())//str2为空串必定为false;
    54.         {
    55.             return false;
    56.         }
    57.         //来到普遍位置
    58.         if(str1[i]==str2[j])
    59.         {
    60.             
    61.             return process(str1,str2,i+1,j+1);
    62.         }
    63.  
    64.         //说明不相等
    65.         if(str2[j]=='?')
    66.         {
    67.             return process(str1,str2,i+1,j+1);
    68.         }
    69.  
    70.         if(str2[j]=='*')
    71.         {
    72.            /*for(int k=0;k<=str1.size()-i;k++)//可以匹配一个也可以匹配很多个
    73.            {
    74.                if(process(str1,str2,i+k,j+1))
    75.                {
    76.                    return true;
    77.                }
    78.            }
    79.            */
    80.            return process(str1,str2,i,j+1)|process(str1,str2,i+1,j);
    81.         }
    82.         //说明是普通字符并且不相等
    83.         return false;
    84.  
    85.     }
    86. };

    二.正则表达式匹配⭐⭐⭐⭐⭐

    1.对应letecode链接：

    10. 正则表达式匹配 - 力扣（LeetCode）

    2.题目描述：

     3.解题思路：

    本题相比上一题而言难度比较大.同样的这种字符串匹配的题一般是这个样本对应模型而样本对应模型的如何考虑都是有套路的：

    我们一般可以考虑字符串结尾位置的字符如何如何。在这里我们可以进行尝试，下面给出递归函数的定义：

    1.  //递归含义str取前si个字符能否匹配上pattern取前pi个字符。
    2.      //能够匹配返回true不能够匹配返回false
    3.     bool process(const string&str,int si,const string&pattern,int pi)

    下面我们来分析可能性：

    情况一：s[i-1]与p[j-1]是匹配的最右端的字符是匹配的，那么，大问题的答案 = 剩余子串是否匹配。

    情况二：s[i-1]与p[j-1]是匹配的最右端的字符是匹配的但是pattern[j-1]位置上面的字符是*，此时又有两种情况了：

    • s[i-1]位置的字符和p[j-2]位置上面的字符能够匹配上
    • s[i-1]位置的字符和p[j-2]位置上的字符不能匹配上

    p[j-1]是星号，并且 s[i-1]和p[j−2] 匹配，要考虑三种情况：，p[j−1] 星号可以让p[j−2] 在 p 串中消失、出现 1 次、出现 >=2 次。

    小情况二很简单了：既然不能匹配上那不好意思我只能拉着你一起变成空串了

    情况三：真的匹配不是此时直接返回false即可 

    4.对应代码：

    1. class Solution {
    2.   public:
    3.     bool isMatch(string s, string p) {
    4.         return process(s, s.size(), p, p.size());
    5.     }
    6.     //递归含义str取前si个字符能否匹配上pattern取前pi个字符。
    7.     //能够匹配返回true不能够匹配返回false
    8.     bool process(const string& str, int si, const string& pattern, int pi) {
    9.         //两个同时是这个空串了一定匹配
    10.         if (si == 0 && pi == 0) {
    11.             return true;
    12.         }
    13.         //字符串str是空串了但是pattern不是空串
    14.         if (si == 0) {
    15.             //此时pattern[si-1]=='*只能将他前面的那个字符给消除掉
    16.             return pattern[pi - 1] == '*' && process(str, si, pattern, pi - 2);
    17.  
    18.         }
    19.         //字符串pattern是空串了但是str串还不是空串
    20.         if (pi == 0) {
    21.             return false;
    22.         }
    23.         //字符串si-1位置的字符和pi-1位置的字符能够匹配
    24.         if (str[si - 1] == pattern[pi - 1] || pattern[pi - 1] == '.') {
    25.             return  process(str, si - 1, pattern, pi - 1);
    26.         }
    27.         //当前位置可能是*而导致的不能够匹配
    28.         else if (pattern[pi - 1] == '*') {
    29.             //当前位置是*分为两种情况：
    30.             //1.pi-2位置的字符能够匹配上si-1位置上的字符
    31.             //2.pi-2位置的字符和si-1位置上的字符匹配不了不好意思此时只能用pi-1位置上的*和pi-2位置上
    32.             //的字符一起变成空
    33.             //情况一:
    34.             if (pattern[pi - 2] == str[si - 1] || pattern[pi - 2] == '.') {
    35.                 //此时能够匹配上但是要匹配几个了？
    36.                 //匹配0个，匹配1个，匹配>=2个
    37.                 return process(str, si, pattern, pi - 2) ||
    38.                        process(str, si - 1, pattern, pi - 2) ||
    39.                        process(str, si - 1, pattern, pi);
    40.  
    41.             } else {
    42.                 //情况二:
    43.                 return process(str, si, pattern, pi - 2);
    44.             }
    45.         }
    46.  
    47.         return false;//当前si-1位置的字符和pi-1位置的字符真的不匹配
    48.  
    49.  
    50.     }
    51. };

    对应严格位置的动态规划：

    1. class Solution {
    2.   public:
    3.     bool isMatch(string s, string p) {
    4.         int M = s.size();
    5.         int N = p.size();
    6.         vectorbool>>dp(M + 1, vector<bool>(N + 1));
    7.         //默认初始化为false
    8.         dp[0][0] = true;
    9.         for (int i = 1; i <= N; i++) {
    10.             if (p[i - 1] == '*') {
    11.                 dp[0][i] = dp[0][i - 2];
    12.             }
    13.         }
    14.         //来到普遍位置
    15.         for (int i = 1; i <= M; i++) {
    16.             for (int j = 1; j <= N; j++) {
    17.                 if (s[i - 1] == p[j - 1] || p[j - 1] == '.') {
    18.                     dp[i][j] = dp[i - 1][j - 1];
    19.                 } else if (p[j - 1] == '*') {
    20.                     if (p[j - 2] == s[i - 1] || p[j - 2] == '.') {
    21.                         dp[i][j] = dp[i][j - 2] || dp[i - 1][j - 2] || dp[i - 1][j];
    22.                     } else {
    23.                         dp[i][j] = dp[i][j - 2];
    24.                     }
    25.                 } else { //可以省略
    26.                     dp[i][j] = false;
    27.                 }
    28.             }
    29.         }
    30.         return dp[M][N];
    31.  
    32.     }
    33.     //递归含义str取前si个字符能否匹配上pattern取前pi个字符。
    34.     //能够匹配返回true不能够匹配返回false
    35.     bool process(const string& str, int si, const string& pattern, int pi) {
    36.         //两个同时是这个空串了一定匹配
    37.         if (si == 0 && pi == 0) {
    38.             return true;
    39.         }
    40.         //字符串str是空串了但是pattern不是空串
    41.         if (si == 0) {
    42.             //此时pattern[si-1]=='*只能将他前面的那个字符给消除掉
    43.             return pattern[pi - 1] == '*' && process(str, si, pattern, pi - 2);
    44.  
    45.         }
    46.         //字符串pattern是空串了但是str串还不是空串
    47.         if (pi == 0) {
    48.             return false;
    49.         }
    50.         //字符串si-1位置的字符和pi-1位置的字符能够匹配
    51.         if (str[si - 1] == pattern[pi - 1] || pattern[pi - 1] == '.') {
    52.             return  process(str, si - 1, pattern, pi - 1);
    53.         }
    54.         //当前位置可能是*而导致的不能够匹配
    55.         else if (pattern[pi - 1] == '*') {
    56.             //当前位置是*分为两种情况：
    57.             //1.pi-2位置的字符能够匹配上si-1位置上的字符
    58.             //2.pi-2位置的字符和si-1位置上的字符匹配不了不好意思此时只能用pi-1位置上的*和pi-2位置上
    59.             //的字符一起变成空
    60.             //情况一:
    61.             if (pattern[pi - 2] == str[si - 1] || pattern[pi - 2] == '.') {
    62.                 //此时能够匹配上但是要匹配几个了？
    63.                 //匹配0个，匹配1个，匹配>=2个
    64.                 return process(str, si, pattern, pi - 2) ||
    65.                        process(str, si - 1, pattern, pi - 2) ||
    66.                        process(str, si - 1, pattern, pi);
    67.  
    68.             } else {
    69.                 //情况二:
    70.                 return process(str, si, pattern, pi - 2);
    71.             }
    72.         }
    73.  
    74.         return false;//当前si-1位置的字符和pi-1位置的字符真的不匹配
    75.  
    76.  
    77.     }
    78. };

    总结：

    类似于两个字符串的这种问题一般是样本对应模型即一个做行一个做列，通常我们思考的点是每个位置结尾如何如何。

  • 相关阅读:
    电脑入门： 路由器初学者完全教程
    nginx初识
    java101-arraylist的遍历和增加
    Linux 下进程管理 API 之创建、查询、退出和收回详解
    python 生成随机字符串（大小写英文字母、数字组成）、生成随机的无重复字符的字符串
    Docker Desktop -WSL kernel version too low
    python之if else语句介绍
    【c++】——类和对象(中)——默认成员函数(上)
    【RPG Maker MV 仿新仙剑 战斗场景UI （三）】
    Metabase学习教程：模型-1
  • 原文地址：https://blog.csdn.net/qq_56999918/article/details/126473865