Skip to content

Commit 9dafaa5

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0737.Sentence Similarity II
1 parent cf88375 commit 9dafaa5

File tree

6 files changed

+440
-3
lines changed

6 files changed

+440
-3
lines changed

‎solution/0700-0799/0737.Sentence Similarity II/README.md

+173-2
Original file line numberDiff line numberDiff line change
@@ -27,27 +27,198 @@
2727
<li>每个&nbsp;<code>words[i]</code>&nbsp;和&nbsp;<code>pairs[i][j]</code>&nbsp;的长度范围为&nbsp;<code>[1, 20]</code>。</li>
2828
</ul>
2929

30-
3130
## 解法
3231

3332
<!-- 这里可写通用的实现逻辑 -->
3433

34+
并查集。
35+
36+
模板 1——朴素并查集：
37+
38+
```python
39+
# 初始化，p存储每个点的祖宗节点
40+
p = [i for i in range(n)]
41+
# 返回x的祖宗节点
42+
def find(x):
43+
if p[x] != x:
44+
# 路径压缩
45+
p[x] = find(p[x])
46+
return p[x]
47+
# 合并a和b所在的两个集合
48+
p[find(a)] = find(b)
49+
```
50+
51+
模板 2——维护 size 的并查集：
52+
53+
```python
54+
# 初始化，p存储每个点的祖宗节点，size只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
55+
p = [i for i in range(n)]
56+
size = [1] * n
57+
# 返回x的祖宗节点
58+
def find(x):
59+
if p[x] != x:
60+
# 路径压缩
61+
p[x] = find(p[x])
62+
return p[x]
63+
# 合并a和b所在的两个集合
64+
size[find(b)] += size[find(a)]
65+
p[find(a)] = find(b)
66+
```
67+
68+
模板 3——维护到祖宗节点距离的并查集：
69+
70+
```python
71+
# 初始化，p存储每个点的祖宗节点，d[x]存储x到p[x]的距离
72+
p = [i for i in range(n)]
73+
d = [0] * n
74+
# 返回x的祖宗节点
75+
def find(x):
76+
if p[x] != x:
77+
t = find(p[x])
78+
d[x] += d[p[x]]
79+
p[x] = t
80+
return p[x]
81+
# 合并a和b所在的两个集合
82+
p[find(a)] = find(b)
83+
d[find(a)] = dinstance
84+
```
85+
86+
对于本题，将相似对的所有单词转换为下标，然后套用并查集模板，将相似对合并。
87+
88+
接着遍历 `sentence1`, `sentence2`，若对应的单词相同，直接 continue；若对应的单词不在相似对单词中，或者两单词不在同一个集合中，直接返回 false。否则遍历结束返回 true。
89+
3590
<!-- tabs:start -->
3691

3792
### **Python3**
3893

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

4196
```python
42-
97+
class Solution:
98+
def areSentencesSimilarTwo(self, sentence1: List[str], sentence2: List[str], similarPairs: List[List[str]]) -> bool:
99+
if len(sentence1) != len(sentence2):
100+
return False
101+
n = len(similarPairs)
102+
p = list(range(n << 1))
103+
104+
def find(x):
105+
if p[x] != x:
106+
p[x] = find(p[x])
107+
return p[x]
108+
109+
words = {}
110+
idx = 0
111+
for a, b in similarPairs:
112+
if a not in words:
113+
words[a] = idx
114+
idx += 1
115+
if b not in words:
116+
words[b] = idx
117+
idx += 1
118+
p[find(words[a])] = find(words[b])
119+
120+
for i in range(len(sentence1)):
121+
if sentence1[i] == sentence2[i]:
122+
continue
123+
if sentence1[i] not in words or sentence2[i] not in words or find(words[sentence1[i]]) != find(words[sentence2[i]]):
124+
return False
125+
return True
43126
```
44127

45128
### **Java**
46129

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

49132
```java
133+
class Solution {
134+
private int[] p;
135+
136+
public boolean areSentencesSimilarTwo(String[] sentence1, String[] sentence2, List<List<String>> similarPairs) {
137+
if (sentence1.length != sentence2.length) {
138+
return false;
139+
}
140+
int n = similarPairs.size();
141+
p = new int[n << 1];
142+
for (int i = 0; i < p.length; ++i) {
143+
p[i] = i;
144+
}
145+
Map<String, Integer> words = new HashMap<>();
146+
int idx = 0;
147+
for (List<String> e : similarPairs) {
148+
String a = e.get(0), b = e.get(1);
149+
if (!words.containsKey(a)) {
150+
words.put(a, idx++);
151+
}
152+
if (!words.containsKey(b)) {
153+
words.put(b, idx++);
154+
}
155+
p[find(words.get(a))] = find(words.get(b));
156+
}
157+
for (int i = 0; i < sentence1.length; ++i) {
158+
if (Objects.equals(sentence1[i], sentence2[i])) {
159+
continue;
160+
}
161+
if (!words.containsKey(sentence1[i]) || !words.containsKey(sentence2[i]) || find(words.get(sentence1[i])) != find(words.get(sentence2[i]))) {
162+
return false;
163+
}
164+
}
165+
return true;
166+
}
167+
168+
private int find(int x) {
169+
if (p[x] != x) {
170+
p[x] = find(p[x]);
171+
}
172+
return p[x];
173+
}
174+
}
175+
```
50176

177+
### **Go**
178+
179+
```go
180+
var p []int
181+
182+
func areSentencesSimilarTwo(sentence1 []string, sentence2 []string, similarPairs [][]string) bool {
183+
if len(sentence1) != len(sentence2) {
184+
return false
185+
}
186+
n := len(similarPairs)
187+
p = make([]int, (n<<1)+10)
188+
for i := 0; i < len(p); i++ {
189+
p[i] = i
190+
}
191+
words := make(map[string]int)
192+
idx := 1
193+
for _, e := range similarPairs {
194+
a, b := e[0], e[1]
195+
if words[a] == 0 {
196+
words[a] = idx
197+
idx++
198+
}
199+
if words[b] == 0 {
200+
words[b] = idx
201+
idx++
202+
}
203+
p[find(words[a])] = find(words[b])
204+
}
205+
for i := 0; i < len(sentence1); i++ {
206+
if sentence1[i] == sentence2[i] {
207+
continue
208+
}
209+
if words[sentence1[i]] == 0 || words[sentence2[i]] == 0 || find(words[sentence1[i]]) != find(words[sentence2[i]]) {
210+
return false
211+
}
212+
}
213+
return true
214+
}
215+
216+
func find(x int) int {
217+
if p[x] != x {
218+
p[x] = find(p[x])
219+
}
220+
return p[x]
221+
}
51222
```
52223

53224
### **...**

‎solution/0700-0799/0737.Sentence Similarity II/README_EN.md

+117-1
Original file line numberDiff line numberDiff line change
@@ -52,13 +52,129 @@
5252
### **Python3**
5353

5454
```python
55-
55+
class Solution:
56+
def areSentencesSimilarTwo(self, sentence1: List[str], sentence2: List[str], similarPairs: List[List[str]]) -> bool:
57+
if len(sentence1) != len(sentence2):
58+
return False
59+
n = len(similarPairs)
60+
p = list(range(n << 1))
61+
62+
def find(x):
63+
if p[x] != x:
64+
p[x] = find(p[x])
65+
return p[x]
66+
67+
words = {}
68+
idx = 0
69+
for a, b in similarPairs:
70+
if a not in words:
71+
words[a] = idx
72+
idx += 1
73+
if b not in words:
74+
words[b] = idx
75+
idx += 1
76+
p[find(words[a])] = find(words[b])
77+
78+
for i in range(len(sentence1)):
79+
if sentence1[i] == sentence2[i]:
80+
continue
81+
if sentence1[i] not in words or sentence2[i] not in words or find(words[sentence1[i]]) != find(words[sentence2[i]]):
82+
return False
83+
return True
5684
```
5785

5886
### **Java**
5987

6088
```java
89+
class Solution {
90+
private int[] p;
91+
92+
public boolean areSentencesSimilarTwo(String[] sentence1, String[] sentence2, List<List<String>> similarPairs) {
93+
if (sentence1.length != sentence2.length) {
94+
return false;
95+
}
96+
int n = similarPairs.size();
97+
p = new int[n << 1];
98+
for (int i = 0; i < p.length; ++i) {
99+
p[i] = i;
100+
}
101+
Map<String, Integer> words = new HashMap<>();
102+
int idx = 0;
103+
for (List<String> e : similarPairs) {
104+
String a = e.get(0), b = e.get(1);
105+
if (!words.containsKey(a)) {
106+
words.put(a, idx++);
107+
}
108+
if (!words.containsKey(b)) {
109+
words.put(b, idx++);
110+
}
111+
p[find(words.get(a))] = find(words.get(b));
112+
}
113+
for (int i = 0; i < sentence1.length; ++i) {
114+
if (Objects.equals(sentence1[i], sentence2[i])) {
115+
continue;
116+
}
117+
if (!words.containsKey(sentence1[i]) || !words.containsKey(sentence2[i]) || find(words.get(sentence1[i])) != find(words.get(sentence2[i]))) {
118+
return false;
119+
}
120+
}
121+
return true;
122+
}
123+
124+
private int find(int x) {
125+
if (p[x] != x) {
126+
p[x] = find(p[x]);
127+
}
128+
return p[x];
129+
}
130+
}
131+
```
61132

133+
### **Go**
134+
135+
```go
136+
var p []int
137+
138+
func areSentencesSimilarTwo(sentence1 []string, sentence2 []string, similarPairs [][]string) bool {
139+
if len(sentence1) != len(sentence2) {
140+
return false
141+
}
142+
n := len(similarPairs)
143+
p = make([]int, (n<<1)+10)
144+
for i := 0; i < len(p); i++ {
145+
p[i] = i
146+
}
147+
words := make(map[string]int)
148+
idx := 1
149+
for _, e := range similarPairs {
150+
a, b := e[0], e[1]
151+
if words[a] == 0 {
152+
words[a] = idx
153+
idx++
154+
}
155+
if words[b] == 0 {
156+
words[b] = idx
157+
idx++
158+
}
159+
p[find(words[a])] = find(words[b])
160+
}
161+
for i := 0; i < len(sentence1); i++ {
162+
if sentence1[i] == sentence2[i] {
163+
continue
164+
}
165+
if words[sentence1[i]] == 0 || words[sentence2[i]] == 0 || find(words[sentence1[i]]) != find(words[sentence2[i]]) {
166+
return false
167+
}
168+
}
169+
return true
170+
}
171+
172+
func find(x int) int {
173+
if p[x] != x {
174+
p[x] = find(p[x])
175+
}
176+
return p[x]
177+
}
62178
```
63179

64180
### **...**

‎solution/0700-0799/0737.Sentence Similarity II/Solution.cpp

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
class Solution {
2+
public:
3+
vector<int> p;
4+
bool areSentencesSimilarTwo(vector<string> &sentence1, vector<string> &sentence2, vector<vector<string>> &similarPairs) {
5+
if (sentence1.size() != sentence2.size())
6+
return false;
7+
int n = similarPairs.size();
8+
p.resize(n << 1);
9+
for (int i = 0; i < p.size(); ++i)
10+
p[i] = i;
11+
unordered_map<string, int> words;
12+
int idx = 0;
13+
for (auto e : similarPairs)
14+
{
15+
string a = e[0], b = e[1];
16+
if (!words.count(a))
17+
words[a] = idx++;
18+
if (!words.count(b))
19+
words[b] = idx++;
20+
p[find(words[a])] = find(words[b]);
21+
}
22+
for (int i = 0; i < sentence1.size(); ++i)
23+
{
24+
if (sentence1[i] == sentence2[i])
25+
continue;
26+
if (!words.count(sentence1[i]) || !words.count(sentence2[i]) || find(words[sentence1[i]]) != find(words[sentence2[i]]))
27+
return false;
28+
}
29+
return true;
30+
}
31+
32+
int find(int x) {
33+
if (p[x] != x)
34+
p[x] = find(p[x]);
35+
return p[x];
36+
}
37+
};

0 commit comments

Comments
 (0)