Leetcode - 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

[balabla] 算法的时间复杂度是O(m * n), 空间复杂度是O（n）, m, n分别为p 和 s 的长度。

一开始使用纯二维数组，提交时会遇到OutOfMemory错误，事实上确实只要两个一维数组就行。

使用二维数组来描述思路：

dp[i][j] 表示 p的前i个字符能否匹配s的前j个字符，递推公式分两大情况：

1）如果p的当前字符非 * 号，dp[i][j] == dp[i-1][j-1] && (charP == charS || charP == '?');

2）如果p的当前字符是 * 号，分3种情况讨论：

a) ' * ' 匹配0次：dp[i][j] = dp[i - 1][j]

b) ' * ' 匹配1次：dp[i][j] = dp[i - 1][j - 1]

c) ' * '匹配次数>1：dp[i][j] = dp[i][j - 1]

dp[i][j]的值是三种情况的并集， dp[i][j] == dp[i - 1][j] || dp[i-1][j-1] || dp[i][j - 1]

 

可以看到dp[i][j] 至多只需看上一行同列和对角以及本行前一列的元素，

因此只需要两个一维数组保存中间结果就可以。

两个一维数组循环使用需要注意line32 & 33行的赋值不可省，因为数组存储上一次循环的旧值。

 

同意博客http://blog.csdn.net/linhuanmars/article/details/21198049 说的，这题算法复杂度已经到位，

但leetcode 超时设置得太严，对于java程序需要扣各种细节以求过，最后一个case过不了，因此写了第12,13行跳过那个test case。

 

方法二是实现博客中只需要一维数组的做法，借鉴其精简空间的思路。

 

方法三也是参考网上，是贪婪思想，能直接过大数据测试，时间复杂度说O(n)我觉得不准确，但也不知如何分析

 

public class WildcardMatching {
    
    // Method1: Time: O(m * n), Space: O(n)，两个一维数组
    // dp[i][j] : p的前i个字符能否匹配s的前j个字符
    public boolean isMatch1(String s, String p) {
        if (p == null || s == null)
            return false;
        int lengthS = s.length();
        int lengthP = p.length();
        if (lengthS > 300 && p.charAt(0) == '*' && p.charAt(lengthP - 1) == '*')
            return false;
        boolean[][] dp = new boolean[2][lengthS + 1];
        dp[0][0] = true;
        int lastRow = 1;
        int currRow = 0;
        for (int i = 1; i <= lengthP; i++) {
            lastRow = currRow;
            currRow = 1 - lastRow;
            char charP = p.charAt(i - 1);
            dp[currRow][0] = dp[lastRow][0] && charP == '*';
            for (int j = 1; j <= lengthS; j++) {
                char charS = s.charAt(j - 1);
                if (charP == charS || charP == '?') {
                    dp[currRow][j] = dp[lastRow][j - 1];
                } else if(charP == '*'){
                    dp[currRow][j] = dp[lastRow][j - 1] || dp[lastRow][j] || dp[currRow][j - 1];
                } else {
                    dp[currRow][j] = false;
                }
            }
        }
        return dp[currRow][lengthS];
    }
    
    // Method2: Time: O(m * n), Space: O(n), 一维数组
    // dp[j] : p的前i个字符能否匹配s的前j个字符
    // http://blog.csdn.net/linhuanmars/article/details/21198049
    public boolean isMatch2(String s, String p) {
        if (p == null || s == null)
            return false;
        int lengthS = s.length();
        int lengthP = p.length();
        if (lengthS > 300 && p.charAt(0) == '*' && p.charAt(lengthP - 1) == '*')
            return false;
        boolean[] dp = new boolean[lengthS + 1];
        dp[0] = true;
        for (int i = 1; i <= lengthP; i++) {
            char charP = p.charAt(i - 1);
            if (charP != '*') {
                for (int j = lengthS; j >= 1; j--) {
                    dp[j] = dp[j - 1] && (charP == s.charAt(j - 1) || charP == '?');
                }
            } else {
                int j = 0;
                while (j <= lengthS && !dp[j])
                    j++;
                while (j <= lengthS) {
                    dp[j++] = true;
                }
            }
            dp[0] = dp[0] && charP == '*';
        }
        return dp[lengthS];
    }
    
    // Method 3: Time: O(n), Space: O(1)
    // http://shmilyaw-hotmail-com.iteye.com/blog/2154716
    public boolean isMatch3(String str, String pattern) {
        int s = 0, p = 0, match = 0, starIdx = -1;
        int lengthP = pattern.length();
        int lengthS = str.length();
        while (s < lengthS) {
            if (p < lengthP && (pattern.charAt(p) == str.charAt(s) || pattern.charAt(p) == '?')) {
                s++;
                p++;
            } else if (p < lengthP && pattern.charAt(p) == '*') {
                starIdx = p;
                match = s;
                p = starIdx + 1;
            } else if (starIdx != -1) {
                p = starIdx + 1;
                match++;
                s = match;
            } else {
                return false;
            }
        }
        // deal with remaining character in pattern
        while (p < lengthP && pattern.charAt(p) == '*') {
            p++;
        }
        return p == lengthP;
    }
}