LeetCode10-Regular Expression Matching(动态规划、递归和Java库函数matches)

题目链接：https://leetcode.com/problems/regular-expression-matching/description/
题意：
输入：待匹配的字符串S和正则表达式P，正则表达式P中的‘.’可以匹配任何字符，‘*’可以匹配任何前面的字符n（n>=0）次。特别提醒：‘.*’ 可以匹配n个‘.’并且这n个‘.’可以表示各自任何不同的字符（如：‘.*’可以和‘abc’匹配）。
输出：false或者true（代表S与P匹配的结果）。

解题方式1–动态规划:

思路分析：由于S和P相匹配，表示S和P中的相应子串也是匹配的（最优化原理：一个问题的最优解包含的子问题也具有最优解），则S与P的匹配问题可以转化为子问题来化解。这样思路自然就被引到了动态规划的思路上。
动态规划：
参考博客 hattp://blog.csdn.net/u014265088/article/details/52574639

求解过程：
供下文举例用的输入样例：
S：abcgfg
P：a.*g
1、划分阶段：只有一个阶段。
2、确定状态和状态变量：dp[i+1][j+1]表示S[i]与P[j]是否匹配，值为boolean型；
3、确定决策并写出转移方程：
        a、P[j] ! = ‘*’，
        则

if(p.charAt(j) == s.charAt(i) || p.charAt(j) == '.') { //p[j]不为'*'时的状态转移；
                    dp[i+1][j+1] = dp[i][j];

                }

        b、p[j] == ‘*’,
                若’*’匹配0个p[j-1]时，比如：S子串：a与 P子串：a.*匹配。：dp[i+1][j+1] = dp[i+1][j-1] ;
                若‘*’匹配1个p[j-1]时,比如：S子串: ab与P：a.*匹配 ：dp[i+1][j+1] = dp[i][j-1] && (&& (s[i] == p[j-1] || p[j-1] == ‘.’);
                若‘*’匹配n个p[j-1]时，比如S子串1：abc与a.*；S子串2:abcgfg与a.*g
：dp[i+1][j+1] = dp[i][j+1] && (s[i] == p[j-1] || p[j-1] == ‘.’)。
4、寻找边界：
        a、p[0][0] = true //表示字符串为S与P均为空字符串时，则S与P肯定是匹配的。
        b、若：p[j] == ‘’ 则 p[o][j+1] = p[0][j-1] //预处理P为.*.*.*化（即：P为n个.组成，其中n >= 2 ）和c*a*b*这类的初始：即P串的开头字符只能（.*）匹配0个的情况，需要通过该初始化来把状态转移下去。
输入样例：
aab
b.*
aab
c*a*b*
abcgfg
a.*g
abcgfg
a.*g.*
aaa
ab*a*c*a
代码：

import java.util.Scanner;
/**
 * dp[i][j] 表示s[i-1]和p[j-1]是否匹配,进行初始化；
 * p[j-1] == '*'时，状态转移方程如下：
 * '*'匹配0个p[j-2]，dp[i][j] = dp[][]
 * '*'匹配1个p[j-2]
 * '*'匹配n个p[j-2]
 */

public class _10_Regular_Expression_Matching {
    public static boolean isMatch(String s, String p) {
        int lenS = s.length();
        int lenP = p.length();
        boolean[][] dp = new boolean[lenS+1][lenP+1];
        for(int i = 0; i<lenS; i++) {// 首先dp二维数组初始化为false
            for(int j = 0;j< lenP; j++) {
                dp[i][j] = false;
            }
        }
        dp[0][0] = true;// 表示S和P字符串均为空时当然相等，则dp[0][0] = true;
        for(int j = 0;j< lenP; j++) {//预处理P为.*.*.*化（即：P为n个.*组成，其中n >= 2 ）和c*a*b*这类的初始：即P串的开头字符只能（.*）匹配0个的情况，需要通过该初始化来把状态转移下去。
            if(p.charAt(j) == '*' && j > 0)
                dp[0][j+1] = dp[0][j-1];
            System.out.println("dp[0][" + (j+1) +"]" + dp[0][j+1]);
        }
        for(int i = 0; i < lenS; i++) {
            for(int j = 0; j < lenP; j++) {
                if(p.charAt(j) == s.charAt(i) || p.charAt(j) == '.') { //p[j]不为'*'时的状态转移；
                    dp[i+1][j+1] = dp[i][j];

                } else if(p.charAt(j) == '*') { //p[j]为'*'时的状态转移；
                    dp[i+1][j+1] = ((dp[i][j-1] && (s.charAt(i) == p.charAt(j-1) || p.charAt(j-1) == '.'))
                            || dp[i+1][j-1] || (dp[i][j+1] && ((s.charAt(i) == p.charAt(j-1)) || p.charAt(j-1) == '.')));
                }
//                System.out.println("i + 1 = " + (i+1) + " j + 1= "+ (j+1) + " "+dp[i+1][j+1]);
            }
        }
        return dp[lenS][lenP];
    }
    public static void main(String[] args) {
        while(true) {
            Scanner scanner  = new Scanner(System.in);
            String s = scanner.next();
            String p = scanner.next();
            System.out.println(s);
            System.out.println(p);
            System.out.println("isMatch : "+isMatch(s, p));

        }
    }
}

解题方式2

Java自带的用于字符串正则匹配的库函数matches。

    public static boolean isMatch1(String s,String p) {
        return s.matches(p);
    }

解题方式3–递归算法，采用回溯的方法

如果“”不好判断，可以使用暴力的算法，把“”的所有情况都便利一遍，看是否有满足即可。用i，j指向S和P的当前位置。
采用从后往前匹配，因为从后往前匹配，遇到p[j] == ‘*’，则前面必然有一个字符。
可参考：http://blog.csdn.net/hk2291976/article/details/51165010

递归出口
        如果j == -1，说明p已经匹配完了，同时i == -1,即S匹配完了，返回true；i != -1,则表明S与P没有匹配；
        如果i == -1，但是j != -1可能还有‘*’存在，继续把p剩下的部分匹配下去。
搜索规则
如果p[j] == ‘*’ ;
        a、首先’*’匹配n(n > 0)个p[j-1]的情况：即尝试用p[j-1]匹配掉s[i]，并且用s[0,1…I-1]与p[0,1…j]进行匹配，如果匹配得上则返回true；
        b、‘*’匹配0个p[j-1]的情况：即跳过p[j-1]和p[j]，并且用s[0,1…I]与p[0,1,…j-2]进行匹配。

        if(p.charAt(j) == '*') {
            if(i > FIRST && (( p.charAt(j-1) == s.charAt(i))|| p.charAt(j-1) == '.' )) {
                if(isMatch2(s, i-1, p, j)) {
                    return true;
                }
            }
            return isMatch2(s, i, p, j-2);
        }

如果p[j] != ‘*’;
直接比较s[i]与p[j]是否相匹配。

if(i > FIRST && (p.charAt(j) == s.charAt(i) || p.charAt(j) == '.')) {
            return isMatch2(s, i-1, p, j-1);
        }

代码

public static boolean isMatch2(String s, int i, String p, int j) {
        final int FIRST = -1;
        if(j == FIRST) { //表示P已经被匹配完了，此时如果S还没匹配完，则说明S与P不匹配；
            if(i == FIRST) {
                return true;
            } else {
                return false;
            }
            // 如果S已经匹配完了，但是P还没匹配，则可能有.*这种串还没匹配完。
        }
        if(p.charAt(j) == '*') {
            if(i > FIRST && (( p.charAt(j-1) == s.charAt(i))|| p.charAt(j-1) == '.' )) {
                if(isMatch2(s, i-1, p, j)) {
                    return true;
                }
            }
            return isMatch2(s, i, p, j-2);
        }
        if(i > FIRST && (p.charAt(j) == s.charAt(i) || p.charAt(j) == '.')) {
            return isMatch2(s, i-1, p, j-1);
        }
        return false;
    }