java reids 通配符查询 java通配符匹配字符串

题目及测试

package pid044;
/*通配符匹配

给定一个字符串 (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


*/


public class main {
	
	public static void main(String[] args) {
		String [] testTable = {"aa","aa","cb","adceb","acdcb","a","acdcb"};
		String [] testTable2 = {"a","*","?a","*a*b","a*c?b","a**","a*c?b"};
		for (int i=0;i<7;i++) {
			test(testTable[i],testTable2[i]);
		}
	}
		 
	private static void test(String ito,String ito2) {
		Solution solution = new Solution();
		boolean rtn;
		long begin = System.currentTimeMillis();
		System.out.println(ito);
		System.out.println(ito2);
		//开始时打印数组
		
		rtn= solution.isMatch(ito,ito2);//执行程序
		long end = System.currentTimeMillis();	
		
		System.out.println("rtn" );
		System.out.print(rtn);
		System.out.println();
		System.out.println("耗时：" + (end - begin) + "ms");
		System.out.println("-------------------");
	}

}

解法1（成功，147ms，极慢）

匹配从第i个开始与第j个开始

public class Solution {
	
	int[][] dp;
	
	public boolean isMatch(String s, String p) {
		if(s.equals("")){
			for(int i=0;i<p.length();i++){
				if(p.charAt(i)!='*'){
					return false;
				}
			}
			return true;
		}
		if(p.equals("")) {
			return false;
		}
		dp = new int[s.length() + 1][p.length() + 1];
		return match(s, 0, p, 0) == 1;
    }
	
	private int match(String s,int indexS,String p,int indexP){
		if(dp[indexS][indexP] != 0){
			// 如果已经匹配过了，则不匹配了
			return dp[indexS][indexP]; 
		}
		if(indexS==s.length()&&indexP<p.length()){
			// 如果s到底了，p剩余的都是*，成功
			for(int i=indexP;i<p.length();i++){
				if(p.charAt(i)!='*'){
					dp[indexS][indexP] = 2;
					return dp[indexS][indexP];
				}
			}
			dp[indexS][indexP] = 1;
			return dp[indexS][indexP];
		}
		if(indexS == s.length() && indexP ==p.length()){
			dp[indexS][indexP] = 1;
			return dp[indexS][indexP];
		}
		if(indexS == s.length() || indexP ==p.length()){
			return 2;
		}
		
		char nowS=s.charAt(indexS);
		char nowP=p.charAt(indexP);
		if(nowP!='?'&&nowP!='*'){
			// 当前匹配字符为a-z
			if(nowP!=nowS){
				// 匹配不成功，直接返回
				dp[indexS][indexP] = 2;
				return dp[indexS][indexP];
			}else{
				// 匹配成功
				dp[indexS][indexP] = match(s, indexS+1, p, indexP+1);
				return dp[indexS][indexP];
			}			
		}
		if(nowP=='?'){
			// 当前匹配字符为?，一定匹配成功
			dp[indexS][indexP] = match(s, indexS+1, p, indexP+1);
			return dp[indexS][indexP];
		}
		if(nowP=='*'){
			// 当前匹配字符为*，一定匹配成功
			for(int i=0;i<=s.length()-indexS;i++){
				if(dp[indexS][indexP] == 2 || dp[indexS][indexP] == 0) {
					dp[indexS][indexP] = match(s, indexS+i, p, indexP+1);
				}else {
					match(s, indexS+i, p, indexP+1);
				}
			}
			return dp[indexS][indexP];
		}
		return 2;
	}
}

解法2（别人的）

动态规划

（一）状态

    f[i][j]表示s1的前i个字符，和s2的前j个字符，能否匹配

（二）转移方程

    如果s1的第 i 个字符和s2的第 j 个字符相同，或者s2的第 j 个字符为 “?”
    f[i][j] = f[i - 1][j - 1]

    如果s2的第 j 个字符为 *
        若s2的第 j 个字符匹配空串, f[i][j] = f[i][j - 1]
        若s2的第 j 个字符匹配s1的第 i 个字符, f[i][j] = f[i - 1][j]
        这里注意不是 f[i - 1][j - 1]， 举个例子就明白了 (abc, a*) f[3][2] = f[2][2]

（三）初始化

    f[0][i] = f[0][i - 1] && s2[i] == *
    即s1的前0个字符和s2的前i个字符能否匹配（是否s2的前i个字符都是*）

（四）结果

    f[m][n]

class Solution {
    public boolean isMatch(String s, String p) {
        int m = s.length(), n = p.length();
        boolean[][] f = new boolean[m + 1][n + 1];
        
        f[0][0] = true;
        for(int i = 1; i <= n; i++){
            f[0][i] = f[0][i - 1] && p.charAt(i - 1) == '*';
        }
        
        for(int i = 1; i <= m; i++){
            for(int j = 1; j <= n; j++){
                if(s.charAt(i - 1) == p.charAt(j - 1) || p.charAt(j - 1) == '?'){
                    f[i][j] = f[i - 1][j - 1];
                }
                if(p.charAt(j - 1) == '*'){
                    f[i][j] = f[i][j - 1] || f[i - 1][j];
                }
            }
        }
        return f[m][n];
    }
}

解法3（别人的）

双指针

class Solution {
    public boolean isMatch(String s, String p) {
        int sn = s.length();
        int pn = p.length();
        int i = 0;
        int j = 0;
        int start = -1;
        int match = 0;
        while (i < sn) {
            if (j < pn && (s.charAt(i) == p.charAt(j) || p.charAt(j) == '?')) {
                i++;
                j++;
            } else if (j < pn && p.charAt(j) == '*') {
                start = j;
                match = i;
                j++;
            } else if (start != -1) {
                j = start + 1;
                match++;
                i = match;
            } else {
                return false;
            }
        }
        while (j < pn) {
            if (p.charAt(j) != '*') return false;
            j++;
        }
        return true;
        
    }
}

或者

boolean isMatch(String str, String pattern) {
    int s = 0, p = 0, match = 0, starIdx = -1;     
    //遍历整个字符串
    while (s < str.length()){
        // 一对一匹配，两指针同时后移。
        if (p < pattern.length()  && (pattern.charAt(p) == '?' || str.charAt(s) == pattern.charAt(p))){
            s++;
            p++;
        }
        // 碰到 *，假设它匹配空串，并且用 startIdx 记录 * 的位置，记录当前字符串的位置，p 后移
        else if (p < pattern.length() && pattern.charAt(p) == '*'){
            starIdx = p;
            match = s;
            p++;
        }
        // 当前字符不匹配，并且也没有 *，回退
        // p 回到 * 的下一个位置
        // match 更新到下一个位置
        // s 回到更新后的 match 
        // 这步代表用 * 匹配了一个字符
        else if (starIdx != -1){
            p = starIdx + 1;
            match++;
            s = match;
        }
        //字符不匹配，也没有 *，返回 false
        else return false;
    }
 
    //将末尾多余的 * 直接匹配空串 例如 text = ab, pattern = a*******
    while (p < pattern.length() && pattern.charAt(p) == '*')
        p++;

    return p == pattern.length();
}