|
2 | 2 |
|
3 | 3 | public class Problem_0010_RegularExpressionMatching {
|
4 | 4 |
|
5 |
| - public static boolean isMatch(String str, String exp) { |
| 5 | + public static boolean isMatch1(String s, String p) { |
| 6 | + if (s == null || p == null) { |
| 7 | + return false; |
| 8 | + } |
| 9 | + char[] str = s.toCharArray(); |
| 10 | + char[] pattern = p.toCharArray(); |
| 11 | + return isValid(str, pattern) && process(str, pattern, 0, 0); |
| 12 | + } |
| 13 | + |
| 14 | + public static boolean isValid(char[] str, char[] pattern) { |
| 15 | + for (char cha : str) { |
| 16 | + if (cha == '.' || cha == '*') { |
| 17 | + return false; |
| 18 | + } |
| 19 | + } |
| 20 | + for (int i = 0; i < pattern.length; i++) { |
| 21 | + if (pattern[i] == '*' && (i == 0 || pattern[i - 1] == '*')) { |
| 22 | + return false; |
| 23 | + } |
| 24 | + } |
| 25 | + return true; |
| 26 | + } |
| 27 | + |
| 28 | + // str[si.....] 能否被 pattern[pi...] 变出来 |
| 29 | + // 潜台词:pi位置,pattern[pi] != '*' |
| 30 | + public static boolean process(char[] str, char[] pattern, int si, int pi) { |
| 31 | + if (si == str.length) { // si越界了 |
| 32 | + if (pi == pattern.length) { |
| 33 | + return true; |
| 34 | + } |
| 35 | + if (pi + 1 < pattern.length && pattern[pi + 1] == '*') { |
| 36 | + return process(str, pattern, si, pi + 2); |
| 37 | + } |
| 38 | + return false; |
| 39 | + } |
| 40 | + // si 没越界 |
| 41 | + if (pi == pattern.length) { |
| 42 | + return si == str.length; |
| 43 | + } |
| 44 | + // si 没越界 pi 没越界 |
| 45 | + if (pi + 1 >= pattern.length || pattern[pi + 1] != '*') { |
| 46 | + return ((str[si] == pattern[pi]) || (pattern[pi] == '.')) && process(str, pattern, si + 1, pi + 1); |
| 47 | + } |
| 48 | + // si 没越界 pi 没越界 pi+1 * |
| 49 | + if (pattern[pi] != '.' && str[si] != pattern[pi]) { |
| 50 | + return process(str, pattern, si, pi + 2); |
| 51 | + } |
| 52 | + if (process(str, pattern, si, pi + 2)) { |
| 53 | + return true; |
| 54 | + } |
| 55 | + while (si < str.length && (str[si] == pattern[pi] || pattern[pi] == '.')) { |
| 56 | + if (process(str, pattern, si + 1, pi + 2)) { |
| 57 | + return true; |
| 58 | + } |
| 59 | + si++; |
| 60 | + } |
| 61 | + return false; |
| 62 | + } |
| 63 | + |
| 64 | + public static boolean isMatch2(String s, String p) { |
| 65 | + if (s == null || p == null) { |
| 66 | + return false; |
| 67 | + } |
| 68 | + char[] str = s.toCharArray(); |
| 69 | + char[] pattern = p.toCharArray(); |
| 70 | + int[][] dp = new int[str.length + 1][pattern.length + 1]; |
| 71 | + for (int si = 0; si <= str.length; si++) { |
| 72 | + for (int pi = 0; pi <= pattern.length; pi++) { |
| 73 | + dp[si][pi] = -1; |
| 74 | + } |
| 75 | + } |
| 76 | + // dp[si][pi] == -1 |
| 77 | + // dp[si][pi] == 0 si pi false |
| 78 | + // dp[si][pi] == 1 si pi true |
| 79 | + return isValid(str, pattern) && process2(str, pattern, 0, 0, dp); |
| 80 | + } |
| 81 | + |
| 82 | + // str[si.....] 能否被 pattern[pi...] 变出来 |
| 83 | + // 潜台词:pi位置,pattern[pi] != '*' |
| 84 | + public static boolean process2(char[] str, char[] pattern, int si, int pi, int[][] dp) { |
| 85 | + if (dp[si][pi] != -1) { |
| 86 | + return dp[si][pi] == 1; |
| 87 | + } |
| 88 | + // si pi 这个参数组合第一次算 |
| 89 | + |
| 90 | + if (si == str.length) { // si越界了 |
| 91 | + if (pi == pattern.length) { |
| 92 | + dp[si][pi] = 1; |
| 93 | + return true; |
| 94 | + } |
| 95 | + // (pi pi+1) pi+2 .... |
| 96 | + if (pi + 1 < pattern.length && pattern[pi + 1] == '*') { |
| 97 | + boolean ans = process2(str, pattern, si, pi + 2, dp); |
| 98 | + dp[si][pi] = ans ? 1 : 0; |
| 99 | + return ans; |
| 100 | + } |
| 101 | + dp[si][pi] = 0; |
| 102 | + return false; |
| 103 | + } |
| 104 | + // si 没越界 |
| 105 | + if (pi == pattern.length) { |
| 106 | + boolean ans = si == str.length; |
| 107 | + dp[si][pi] = ans ? 1 : 0; |
| 108 | + return ans; |
| 109 | + } |
| 110 | + // si 没越界 pi 没越界 |
| 111 | + if (pi + 1 >= pattern.length || pattern[pi + 1] != '*') { |
| 112 | + boolean ans = ((str[si] == pattern[pi]) || (pattern[pi] == '.')) |
| 113 | + && process2(str, pattern, si + 1, pi + 1, dp); |
| 114 | + dp[si][pi] = ans ? 1 : 0; |
| 115 | + return ans; |
| 116 | + } |
| 117 | + // si 没越界 pi 没越界 pi+1 * |
| 118 | + if (pattern[pi] != '.' && str[si] != pattern[pi]) { |
| 119 | + boolean ans = process2(str, pattern, si, pi + 2, dp); |
| 120 | + dp[si][pi] = ans ? 1 : 0; |
| 121 | + return ans; |
| 122 | + } |
| 123 | + if (process2(str, pattern, si, pi + 2, dp)) { |
| 124 | + dp[si][pi] = 1; |
| 125 | + return true; |
| 126 | + } |
| 127 | + while (si < str.length && (str[si] == pattern[pi] || pattern[pi] == '.')) { |
| 128 | + if (process2(str, pattern, si + 1, pi + 2, dp)) { |
| 129 | + dp[si][pi] = 1; |
| 130 | + return true; |
| 131 | + } |
| 132 | + si++; |
| 133 | + } |
| 134 | + dp[si][pi] = 0; |
| 135 | + return false; |
| 136 | + } |
| 137 | + |
| 138 | + public static boolean isMatch3(String str, String exp) { |
6 | 139 | if (str == null || exp == null) {
|
7 | 140 | return false;
|
8 | 141 | }
|
@@ -34,20 +167,6 @@ public static boolean isMatch(String str, String exp) {
|
34 | 167 | return dp[0][0];
|
35 | 168 | }
|
36 | 169 |
|
37 |
| - public static boolean isValid(char[] s, char[] e) { |
38 |
| - for (int i = 0; i < s.length; i++) { |
39 |
| - if (s[i] == '*' || s[i] == '.') { |
40 |
| - return false; |
41 |
| - } |
42 |
| - } |
43 |
| - for (int i = 0; i < e.length; i++) { |
44 |
| - if (e[i] == '*' && (i == 0 || e[i - 1] == '*')) { |
45 |
| - return false; |
46 |
| - } |
47 |
| - } |
48 |
| - return true; |
49 |
| - } |
50 |
| - |
51 | 170 | public static boolean[][] initDPMap(char[] s, char[] e) {
|
52 | 171 | int slen = s.length;
|
53 | 172 | int elen = e.length;
|
|
0 commit comments