Skip to content

Commit 11be672

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0291
No.0291.Word Pattern II
1 parent db3bc32 commit 11be672

File tree

8 files changed

+432
-3
lines changed

8 files changed

+432
-3
lines changed

‎README.md

+1
Original file line numberDiff line numberDiff line change
@@ -60,6 +60,7 @@
6060
- [满足不等式的最大值](/solution/1400-1499/1499.Max%20Value%20of%20Equation/README.md) - `单调队列`
6161
- [和至少为 K 的最短子数组](/solution/0800-0899/0862.Shortest%20Subarray%20with%20Sum%20at%20Least%20K/README.md) - `单调队列`
6262
- [带限制的子序列和](/solution/1400-1499/1425.Constrained%20Subsequence%20Sum/README.md) - `动态规划`、`单调队列优化`
63+
- [单词规律 II](/solution/0200-0299/0291.Word%20Pattern%20II/README.md) - `哈希表`、`回溯`
6364

6465
### 3. 搜索
6566

‎README_EN.md

+2-1
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,8 @@ Complete solutions to [LeetCode](https://leetcode.com/problemset/all/), [LCOF](h
5757
- [Sliding Window Maximum](/solution/0200-0299/0239.Sliding%20Window%20Maximum/README_EN.md) - `Monotonic Queue`
5858
- [Max Value of Equation](/solution/1400-1499/1499.Max%20Value%20of%20Equation/README_EN.md) - `Monotonic Queue`
5959
- [Shortest Subarray with Sum at Least K](/solution/0800-0899/0862.Shortest%20Subarray%20with%20Sum%20at%20Least%20K/README_EN.md) - `Monotonic Queue`
60-
- [带限制的子序列和](/solution/1400-1499/1425.Constrained%20Subsequence%20Sum/README.md) - `Dynamic Programming`, `Monotonic Queue`
60+
- [Constrained Subsequence Sum](/solution/1400-1499/1425.Constrained%20Subsequence%20Sum/README_EN.md) - `Dynamic Programming`, `Monotonic Queue`
61+
- [Word Pattern II](/solution/0200-0299/0291.Word%20Pattern%20II/README_EN.md) - `Hash Table`、`Backtracking`
6162

6263
### 3. Search
6364

‎solution/0200-0299/0291.Word Pattern II/README.md

+146-1
Original file line numberDiff line numberDiff line change
@@ -57,15 +57,160 @@
5757
<!-- 这里可写当前语言的特殊实现逻辑 -->
5858

5959
```python
60-
60+
class Solution:
61+
def wordPatternMatch(self, pattern: str, s: str) -> bool:
62+
def dfs(i, j):
63+
if i == m and j == n:
64+
return True
65+
if i == m or j == n or n - j < m - i:
66+
return False
67+
for k in range(j, n):
68+
t = s[j: k + 1]
69+
if d.get(pattern[i]) == t:
70+
if dfs(i + 1, k + 1):
71+
return True
72+
if pattern[i] not in d and t not in vis:
73+
d[pattern[i]] = t
74+
vis.add(t)
75+
if dfs(i + 1, k + 1):
76+
return True
77+
d.pop(pattern[i])
78+
vis.remove(t)
79+
return False
80+
81+
m, n = len(pattern), len(s)
82+
d = {}
83+
vis = set()
84+
return dfs(0, 0)
6185
```
6286

6387
### **Java**
6488

6589
<!-- 这里可写当前语言的特殊实现逻辑 -->
6690

6791
```java
92+
class Solution {
93+
private Set<String> vis;
94+
private Map<Character, String> d;
95+
private String p;
96+
private String s;
97+
private int m;
98+
private int n;
99+
100+
public boolean wordPatternMatch(String pattern, String s) {
101+
vis = new HashSet<>();
102+
d = new HashMap<>();
103+
this.p = pattern;
104+
this.s = s;
105+
m = p.length();
106+
n = s.length();
107+
return dfs(0, 0);
108+
}
109+
110+
private boolean dfs(int i, int j) {
111+
if (i == m && j == n) {
112+
return true;
113+
}
114+
if (i == m || j == n || m - i > n - j) {
115+
return false;
116+
}
117+
char c = p.charAt(i);
118+
for (int k = j + 1; k <= n; ++k) {
119+
String t = s.substring(j, k);
120+
if (d.getOrDefault(c, "").equals(t)) {
121+
if (dfs(i + 1, k)) {
122+
return true;
123+
}
124+
}
125+
if (!d.containsKey(c) && !vis.contains(t)) {
126+
d.put(c, t);
127+
vis.add(t);
128+
if (dfs(i + 1, k)) {
129+
return true;
130+
}
131+
vis.remove(t);
132+
d.remove(c);
133+
}
134+
}
135+
return false;
136+
}
137+
}
138+
```
139+
140+
### **C++**
141+
142+
```cpp
143+
class Solution {
144+
public:
145+
bool wordPatternMatch(string pattern, string s) {
146+
unordered_set<string> vis;
147+
unordered_map<char, string> d;
148+
return dfs(0, 0, pattern, s, vis, d);
149+
}
150+
151+
bool dfs(int i, int j, string& p, string& s, unordered_set<string>& vis, unordered_map<char, string>& d) {
152+
int m = p.size(), n = s.size();
153+
if (i == m && j == n) return true;
154+
if (i == m || j == n || m - i > n - j) return false;
155+
char c = p[i];
156+
for (int k = j + 1; k <= n; ++k)
157+
{
158+
string t = s.substr(j, k - j);
159+
if (d.count(c) && d[c] == t)
160+
{
161+
if (dfs(i + 1, k, p, s, vis, d)) return true;
162+
}
163+
if (!d.count(c) && !vis.count(t))
164+
{
165+
d[c] = t;
166+
vis.insert(t);
167+
if (dfs(i + 1, k, p, s, vis, d)) return true;
168+
vis.erase(t);
169+
d.erase(c);
170+
}
171+
}
172+
return false;
173+
}
174+
};
175+
```
68176

177+
### **Go**
178+
179+
```go
180+
func wordPatternMatch(pattern string, s string) bool {
181+
m, n := len(pattern), len(s)
182+
vis := map[string]bool{}
183+
d := map[byte]string{}
184+
var dfs func(i, j int) bool
185+
dfs = func(i, j int) bool {
186+
if i == m && j == n {
187+
return true
188+
}
189+
if i == m || j == n || m-i > n-j {
190+
return false
191+
}
192+
c := pattern[i]
193+
for k := j + 1; k <= n; k++ {
194+
t := s[j:k]
195+
if v, ok := d[c]; ok && v == t {
196+
if dfs(i+1, k) {
197+
return true
198+
}
199+
}
200+
if _, ok := d[c]; !ok && !vis[t] {
201+
d[c] = t
202+
vis[t] = true
203+
if dfs(i+1, k) {
204+
return true
205+
}
206+
delete(d, c)
207+
vis[t] = false
208+
}
209+
}
210+
return false
211+
}
212+
return dfs(0, 0)
213+
}
69214
```
70215

71216
### **...**

‎solution/0200-0299/0291.Word Pattern II/README_EN.md

+146-1
Original file line numberDiff line numberDiff line change
@@ -49,13 +49,158 @@
4949
### **Python3**
5050

5151
```python
52-
52+
class Solution:
53+
def wordPatternMatch(self, pattern: str, s: str) -> bool:
54+
def dfs(i, j):
55+
if i == m and j == n:
56+
return True
57+
if i == m or j == n or n - j < m - i:
58+
return False
59+
for k in range(j, n):
60+
t = s[j: k + 1]
61+
if d.get(pattern[i]) == t:
62+
if dfs(i + 1, k + 1):
63+
return True
64+
if pattern[i] not in d and t not in vis:
65+
d[pattern[i]] = t
66+
vis.add(t)
67+
if dfs(i + 1, k + 1):
68+
return True
69+
d.pop(pattern[i])
70+
vis.remove(t)
71+
return False
72+
73+
m, n = len(pattern), len(s)
74+
d = {}
75+
vis = set()
76+
return dfs(0, 0)
5377
```
5478

5579
### **Java**
5680

5781
```java
82+
class Solution {
83+
private Set<String> vis;
84+
private Map<Character, String> d;
85+
private String p;
86+
private String s;
87+
private int m;
88+
private int n;
89+
90+
public boolean wordPatternMatch(String pattern, String s) {
91+
vis = new HashSet<>();
92+
d = new HashMap<>();
93+
this.p = pattern;
94+
this.s = s;
95+
m = p.length();
96+
n = s.length();
97+
return dfs(0, 0);
98+
}
99+
100+
private boolean dfs(int i, int j) {
101+
if (i == m && j == n) {
102+
return true;
103+
}
104+
if (i == m || j == n || m - i > n - j) {
105+
return false;
106+
}
107+
char c = p.charAt(i);
108+
for (int k = j + 1; k <= n; ++k) {
109+
String t = s.substring(j, k);
110+
if (d.getOrDefault(c, "").equals(t)) {
111+
if (dfs(i + 1, k)) {
112+
return true;
113+
}
114+
}
115+
if (!d.containsKey(c) && !vis.contains(t)) {
116+
d.put(c, t);
117+
vis.add(t);
118+
if (dfs(i + 1, k)) {
119+
return true;
120+
}
121+
vis.remove(t);
122+
d.remove(c);
123+
}
124+
}
125+
return false;
126+
}
127+
}
128+
```
129+
130+
### **C++**
131+
132+
```cpp
133+
class Solution {
134+
public:
135+
bool wordPatternMatch(string pattern, string s) {
136+
unordered_set<string> vis;
137+
unordered_map<char, string> d;
138+
return dfs(0, 0, pattern, s, vis, d);
139+
}
140+
141+
bool dfs(int i, int j, string& p, string& s, unordered_set<string>& vis, unordered_map<char, string>& d) {
142+
int m = p.size(), n = s.size();
143+
if (i == m && j == n) return true;
144+
if (i == m || j == n || m - i > n - j) return false;
145+
char c = p[i];
146+
for (int k = j + 1; k <= n; ++k)
147+
{
148+
string t = s.substr(j, k - j);
149+
if (d.count(c) && d[c] == t)
150+
{
151+
if (dfs(i + 1, k, p, s, vis, d)) return true;
152+
}
153+
if (!d.count(c) && !vis.count(t))
154+
{
155+
d[c] = t;
156+
vis.insert(t);
157+
if (dfs(i + 1, k, p, s, vis, d)) return true;
158+
vis.erase(t);
159+
d.erase(c);
160+
}
161+
}
162+
return false;
163+
}
164+
};
165+
```
58166

167+
### **Go**
168+
169+
```go
170+
func wordPatternMatch(pattern string, s string) bool {
171+
m, n := len(pattern), len(s)
172+
vis := map[string]bool{}
173+
d := map[byte]string{}
174+
var dfs func(i, j int) bool
175+
dfs = func(i, j int) bool {
176+
if i == m && j == n {
177+
return true
178+
}
179+
if i == m || j == n || m-i > n-j {
180+
return false
181+
}
182+
c := pattern[i]
183+
for k := j + 1; k <= n; k++ {
184+
t := s[j:k]
185+
if v, ok := d[c]; ok && v == t {
186+
if dfs(i+1, k) {
187+
return true
188+
}
189+
}
190+
if _, ok := d[c]; !ok && !vis[t] {
191+
d[c] = t
192+
vis[t] = true
193+
if dfs(i+1, k) {
194+
return true
195+
}
196+
delete(d, c)
197+
vis[t] = false
198+
}
199+
}
200+
return false
201+
}
202+
return dfs(0, 0)
203+
}
59204
```
60205

61206
### **...**

‎solution/0200-0299/0291.Word Pattern II/Solution.cpp

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
class Solution {
2+
public:
3+
bool wordPatternMatch(string pattern, string s) {
4+
unordered_set<string> vis;
5+
unordered_map<char, string> d;
6+
return dfs(0, 0, pattern, s, vis, d);
7+
}
8+
9+
bool dfs(int i, int j, string& p, string& s, unordered_set<string>& vis, unordered_map<char, string>& d) {
10+
int m = p.size(), n = s.size();
11+
if (i == m && j == n) return true;
12+
if (i == m || j == n || m - i > n - j) return false;
13+
char c = p[i];
14+
for (int k = j + 1; k <= n; ++k)
15+
{
16+
string t = s.substr(j, k - j);
17+
if (d.count(c) && d[c] == t)
18+
{
19+
if (dfs(i + 1, k, p, s, vis, d)) return true;
20+
}
21+
if (!d.count(c) && !vis.count(t))
22+
{
23+
d[c] = t;
24+
vis.insert(t);
25+
if (dfs(i + 1, k, p, s, vis, d)) return true;
26+
vis.erase(t);
27+
d.erase(c);
28+
}
29+
}
30+
return false;
31+
}
32+
};

0 commit comments

Comments
 (0)