Wildcard Matching

Implement wildcard pattern matching with support for '?' and '*'.

'?' Matches any single character.
'*' Matches any sequence of characters (including the empty sequence).

The matching should cover the entire input string (not partial).

The function prototype should be:
bool isMatch(const char *s, const char *p)

Some examples:
isMatch("aa","a") → false
isMatch("aa","aa") → true
isMatch("aaa","aa") → false
isMatch("aa", "*") → true
isMatch("aa", "a*") → true
isMatch("ab", "?*") → true
isMatch("aab", "c*a*b") → false

首先想到的是递归，但是超时，然后递归转非递归，在大数据测试用例时还是超时，这里贴一下非递归的代码

 

public boolean isMatch(String s, String p) {
        Stack<String> source = new Stack<String>();
        Stack<String> regex = new Stack<String>();
        if (s.equals("")) {
            if (p.equals("") || p.equals("*")) {
                return true;
            } else {
                return false;
            }
        }
        char temp[] = p.toCharArray();
        p = "";
        for (char a : temp) {
            if (p.length() > 0 && p.charAt(p.length() - 1) == '*' && a == '*') {
                continue;
            }
            p += a;
        }
        boolean result = false;
        source.push(s);
        regex.push(p);
        while (!result && !source.empty()) {
            s = source.pop();
            p = regex.pop();
            int i = 0;
            int j = 0;
            for (; i < s.length() && j < p.length();) {
                if (p.charAt(j) != '*') {
                    if (p.charAt(0) == '?' || p.charAt(0) == s.charAt(0)) {
                        i++;
                        j++;
                    } else {
                        break;
                    }
                } else {
                    j++;
                    if (j == p.length()) {
                        i = s.length();
                    } else {
                        for (int k = i; k < s.length(); k++) {
                            if (s.charAt(k) == p.charAt(j)) {
                                source.push(s.substring(k));
                                regex.push(p.substring(j));
                            }
                        }
                        continue;
                    }
                }
            }
            if (i == s.length() && j == p.length()) {
                result = true;
            }
        }
        return result;
    }

优化后还是超时，就想着应该有别的思路。

借鉴一下网上的，转载自 http://blog.csdn.net/pickless/article/details/9787227

看着有点像求字符串的最长公共子串那个问题的解法

用矩阵表示匹配结果，横坐标为p串，纵坐标为s串，假设S="ababa"，P="a*?"，则有下图：

S\P	a	*	?
a	T	T	F
b	F	T	T
a	F	T	T
b	F	T	T

如何计算这个表格呢？规则如下：

1. p[j] == '*'，则   f[i][j] = f[i-1][j]

2. p[j] == '?' || p[j] == s[i] 则 f[i][j] = f[i-1][j-1]

3. 其余情况   f[i][j] = false

上述情况不包含，第0行和第0列，需要单独计算

经过上面分析，第i行只与第i-1行有关，所以，可以将矩阵简化成一维的。代码如下：

public boolean isMatch(String s, String p) {
        boolean f[] = new boolean[p.length()];
        if (s == null || p == null || (p.equals("") && !s.equals(""))) {
            return false;
        }
        if (s.equals("")) {
            if (p.equals("") || p.equals("*")) {
                return true;
            } else {
                return false;
            }
        }
        boolean isTrue = false;
        for (int i = 0; i < p.length(); i++) {
            if (p.charAt(i) == '*') {
                f[i] = (i == 0) || f[i - 1];
            } else if (p.charAt(i) == '?' || p.charAt(i) == s.charAt(0)) {
                if (isTrue) {
                    break;
                }
                f[i] = (i == 0) || ((!isTrue) && f[i - 1]);
                isTrue = true;
            } else {
                break;
            }
        }
        for (int i = 1; i < s.length(); i++) {
            boolean temp[] = new boolean[f.length];
            for (int j = 0; j < f.length; j++) {
                if (p.charAt(j) == '*') {
                    temp[j] = f[j];
                } else if (p.charAt(j) == '?' || p.charAt(j) == s.charAt(i)) {
                    temp[j] = (j == 0 && p.charAt(0) == '*' && f[j])
                            || (j > 0 && f[j - 1]);
                } else {
                    temp[j] = false;
                }
            }
            f = temp;
        }
        return f[f.length - 1];
    }

但是依旧超时，再根据网上的解法，使用贪心算法

http://blog.unieagle.net/2012/11/07/leetcode题目：wildcard-matching/

先用*号把string p切割，然后把每段不含星号的子串放到s中匹配，匹配上了将base前移，继续匹配下一个。这里要注意的是，当p的一头或者一尾没有星号时，第一个和最后一个子串要严格匹配给s的头和尾

成功过大数据

public boolean isMatch(String s, String p) {
        int ls = s.length();
        int lp = p.length();
        if(ls == 0 && lp == 0) return true;
        else if(ls != 0 && lp == 0) return false;
        
        String[] strarr = p.split("[\\*]+",0);
        if(strarr.length == 0) return true;
        boolean firstneedmatch = !p.startsWith("*");
        boolean lastneedmatch = !p.endsWith("*");
        if(!firstneedmatch) strarr = Arrays.copyOfRange(strarr, 1, strarr.length);
        if(strarr.length == 0) return true;
        
        int base = 0;
        for(int i=0;i<strarr.length;i++){
            if(base > ls-strarr[i].length()) return false;
            if(i==0 && firstneedmatch) base = -1;
            else if(i==strarr.length-1 && lastneedmatch) base = -2;
            base = getMatchedIdx(s,strarr[i],base);
            if(base == -1) return false;
            if(i == strarr.length-1 && lastneedmatch && base != ls) return false;
        }
        return true;
    }
    
    public int getMatchedIdx(String s, String pat,int base){
        char[] sch = s.toCharArray();
        char[] pch = pat.toCharArray();
        int ls = sch.length;
        int lp = pch.length;
        if(base == -1){
            for(int i=0;i<lp;i++){
                if(pch[i] != '?' && pch[i] != sch[i]) return -1;
            }
            return lp;
        }
        else if(base == -2){
            base = ls-lp;
            for(int i=0;i<lp;i++){
                if(pch[i] !='?' && pch[i] != sch[base+i]) return -1;
            }
            return ls;
        }
        else{
            int limit = ls-lp;
            for(;base<=limit;base++){
                for(int i=0;i<lp;i++){
                    if(pch[i] !='?' && pch[i] != sch[base+i]) break;
                    if(i == lp-1) return base+lp;
                }
            }
            return -1;
        }
    }