D-动态规划比递归快-LeetCode44-通配符匹配

题目

给定一个字符串 (s) 和一个字符模式 (p) ，实现一个支持 '?' 和 '*' 的通配符匹配。

'?' 可以匹配任何单个字符。
'*' 可以匹配任意字符串（包括空字符串）。
两个字符串完全匹配才算匹配成功。

说明:

s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 ? 和 *。
示例 1:

输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
示例 2:

输入:
s = "aa"
p = "*"
输出: true
解释: '*' 可以匹配任意字符串。
示例 3:

输入:
s = "cb"
p = "?a"
输出: false
解释: '?' 可以匹配 'c', 但第二个 'a' 无法匹配 'b'。
示例 4:

输入:
s = "adceb"
p = "*a*b"
输出: true
解释: 第一个 '*' 可以匹配空字符串, 第二个 '*' 可以匹配字符串 "dce".
示例 5:

输入:
s = "acdcb"
p = "a*c?b"
输入: false

思路1

以s、p首部缩减的方式，递归。类似https://blog.youkuaiyun.com/qq_36025975/article/details/83026821。超时。

代码1

class Solution {
    public boolean isMatch(String s, String p) {
        if(p.length()==0){
            return s.length()==0?true:false ;
        }
        
        if(p.charAt(0)=='*'){
            if(s.length()==0){
                return isMatch(s,p.substring(1));
            }
            
            return isMatch(s,p.substring(1)) || isMatch(s.substring(1),p); 
        }else{
            if(s.length()==0){
                return false;
            }
            
            if(s.charAt(0)==p.charAt(0) || p.charAt(0)=='?'){
                return isMatch(s.substring(1),p.substring(1));
            }
        }
        
        return false;
    }
}

思路2

动态规划。初始化矩阵 boolean[p.length()+1][s.length()+1]。boolean[i][j]代表p的i-1之前的字符串与s的j-1之前的字符串是否匹配。boolean[p.length()][s.length()]即为所求。

1. 初始化m[0][0]=true。

2. 初始化m[i][0]。如果遇到 '*' 则等于m[i-1][0]。如果遇到非 '*' 则false。

3. 初始化m[0][j]。全为false。

4. 之后按行初始化m[i][j]。

    4.1 遇到 '*' ： m[i][j]=m[i-1][j] || m[i][j-1];

         ('*' 代表0 ：m[i-1][j]             '*' 代表1或多个 ：m[i][j-1] ) 

    4.2 遇到 'a' 或 '?' ：如果相等，m[i][j]=m[i-1][j-1]; 否则false。

代码2

class Solution {
    public boolean isMatch(String s, String p) {
        boolean[][] m=new boolean[p.length()+1][s.length()+1];
        m[0][0]=true;
        // 初始化m[i][0]
        for(int i=1;i<m.length;i++){
            if(p.charAt(i-1)=='*'){
                m[i][0]=m[i-1][0];
            }else{
                m[i][0]=false;
            }
        }
        // 初始化m[0][j]
        for(int i=1;i<m[0].length;i++){
            m[0][i]=false;
        }
        // 按行填充m[][]
        for(int i=1;i<m.length;i++){
            for(int j=1;j<m[0].length;j++){
                if(p.charAt(i-1)=='*'){
                    m[i][j]=m[i-1][j] || m[i][j-1];
                }else{
                    if(p.charAt(i-1)==s.charAt(j-1) || p.charAt(i-1)=='?'){
                        m[i][j]=m[i-1][j-1];
                    }else{
                        m[i][j]=false;
                    }
                }
            }
        }
        
        return m[p.length()][s.length()];
    }
}

总结

动态规划比递归快。