————2020.1.17————

 1 public static boolean isMatch(String s, String t) {
 2     return match(s, t, 0, 0);
 3     }
 4 public static boolean match(String s, String t, int i, int j) {
 5     if (j == t.length()) return i == s.length();
 6     if(j+1 == t.length() || t.charAt(j+1) != ‘*‘) {
 7         return i != s.length() && (t.charAt(j) == s.charAt(i) || t.charAt(j) == ‘.‘) 
 8                 && match(s, t, i+1, j+1);
 9     }
10     while(i != s.length() && (t.charAt(j) == s.charAt(i) || t.charAt(j) ==‘.‘)) {
11         if(match(s, t, i, j+2)) return true;
12         i++;
13     }
14     return match(s, t, i, j+2);
15 }

 1 public static boolean dpmatch(String s, String t) {
 2     int m = s.length(), n = t.length();
 3     if(m == 0 && n ==0) return true;
 4     else if (m != 0 && n == 0) return false;
 5     boolean [][] dp = new boolean[m+1][n+1];
 6     dp[m][n] = true;
 7     for (int j = n-2;j>=0;j = j-2) {
 8         if(t.charAt(j+1) == ‘*‘ && t.charAt(j) != ‘*‘) dp[m][j] = true;
 9         else break;
10     }
11     if(m == 0) return dp[0][0];
12     if(t.charAt(n-1) == ‘.‘ || t.charAt(n-1) == s.charAt(m-1)) dp[m-1][n-1] = true;
13     for(int i = m-1; i>=0; i--) {
14         for(int j = n-2; j>=0; j--) {
15             if(t.charAt(j+1) != ‘*‘) {
16                 dp[i][j] = (t.charAt(j) == s.charAt(i) || t.charAt(j) == ‘.‘)
17                         &&dp[i+1][j+1];
18             } else {
19             int p = i;
20             while (p != s.length() && (t.charAt(j) == s.charAt(p) || t.charAt(j) ==‘.‘)) {
21                 if(dp[p][j+2]) {
22                     dp[p][j] = true;
23                     break;
24                 }
25                 p++;
26             }
27             if(dp[i][j] != true)
28             dp[i][j] = dp[p][j+2];
29             }
30         }
31     }
32     return dp[0][0];
33 }

  1 import java.util.Arrays;
  2 import java.util.HashMap;
  3 import java.util.HashSet;
  4 import java.util.LinkedList;
  5 import java.util.List;
  6 import java.util.Map;
  7 import java.util.Set;
  8 
  9 public class Solutions {
 10     class Solution {
 11         public boolean isMatch(String s, String p) {
 12             State dfa = buildStateChain(p);
 13             Set<State> dfaSet = new HashSet<>();
 14             dfaSet.add(dfa);
 15             int index = -1;
 16             while(++index < s.length()){
 17                 char ch = s.charAt(index);
 18                 String input = String.valueOf(ch);
 19                 Set<State> newStateSet = new HashSet<>();
 20                 for(State state : dfaSet){
 21                     List<State> newList = state.changeState(input);
 22                     if(newList != null){
 23                         newStateSet.addAll(newList);
 24                     }
 25                 }
 26                 dfaSet  = newStateSet;
 27                 if(dfaSet.size() <= 0){
 28                     break;
 29                 }
 30             }
 31 
 32             boolean isMatch = false;
 33             for(State state : dfaSet){
 34                 if(state.isEnd()){
 35                     isMatch = true;
 36                     break;
 37                 }
 38             }
 39 
 40             return isMatch;
 41         }
 42 
 43           public State buildStateChain(String p){
 44             State start = new State();
 45             start.setStart(true);
 46 
 47             List<State> currentLevelStateList = Arrays.asList(start);
 48             for(int i = 0; i < p.length(); i++){
 49                 char current = p.charAt(i);
 50                 if(current == ‘*‘){
 51                     continue;
 52                 }
 53                 Character next = null;
 54                 if(i < p.length() - 1){
 55                     next = p.charAt(i + 1);
 56                 }
 57 
 58                 List<State> nextLevelStateList = new LinkedList<>();
 59                 State nextState = new State();
 60                 nextLevelStateList.add(nextState);
 61                 String currentStr = String.valueOf(current);
 62                 for(State currentState : currentLevelStateList) {
 63                     currentState.addNextState(currentStr, nextState);
 64 
 65                     // 如果是x* 这种形式的话，状态有个自循环，并且当前状态需要建立一个和下下个状态的关系
 66                     if (next != null && next.equals(‘*‘)) {
 67                         nextLevelStateList.add(currentState);
 68                         nextState.addNextState(currentStr, nextState);
 69                     }
 70                 }
 71 
 72                 currentLevelStateList = nextLevelStateList;
 73             }
 74 
 75             for(State currentState : currentLevelStateList) {
 76                 currentState.setEnd(true);
 77             }
 78 
 79             return start;
 80         }
 81 
 82         class State{
 83             private boolean start;
 84             private boolean end;
 85 
 86             // 状态转移mapping
 87             private Map<String, List<State>> nextMap = new HashMap<>();
 88 
 89             public List<State> changeState(String input){
 90                 List<State> result = new LinkedList<>();
 91                 List<State> nextList = nextMap.get(input);
 92                 if(nextList != null){
 93                     result.addAll(nextList);
 94                 }
 95                 nextList = nextMap.get(".");
 96                 if(nextList != null){
 97                     result.addAll(nextList);
 98                 }
 99 
100 //                List<State> forEmptyList = nextMap.get("");
101 //                if(forEmptyList != null){
102 //                    result.addAll(forEmptyList);
103 //                }
104 
105                 return result;
106             }
107 
108             public boolean isStart() {
109                 return start;
110             }
111 
112             public void setStart(boolean start) {
113                 this.start = start;
114             }
115 
116             public boolean isEnd() {
117                 return end;
118             }
119 
120             public void setEnd(boolean end) {
121                 this.end = end;
122             }
123 
124             public void addNextState(String input, State next){
125                 List<State> nextList = nextMap.get(input);
126                 if(nextList == null){
127                     nextList = new LinkedList<>();
128                     nextMap.put(input, nextList);
129                 }
130                 nextList.add(next);
131             }
132 
133         }
134     }