Skip to content

Commit f881942

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1101.The Earliest Moment When
Everyone Become Friends
1 parent b2f4942 commit f881942

File tree

6 files changed

+409
-4
lines changed

6 files changed

+409
-4
lines changed

‎solution/1100-1199/1101.The Earliest Moment When Everyone Become Friends/README.md

Lines changed: 180 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -45,27 +45,205 @@
4545
<li><code>logs[i][1] != logs[i][2]</code></li>
4646
</ol>
4747

48-
4948
## 解法
5049

5150
<!-- 这里可写通用的实现逻辑 -->
5251

52+
并查集模板题。
53+
54+
模板 1——朴素并查集：
55+
56+
```python
57+
# 初始化，p存储每个点的父节点
58+
p = list(range(n))
59+
60+
# 返回x的祖宗节点
61+
def find(x):
62+
if p[x] != x:
63+
# 路径压缩
64+
p[x] = find(p[x])
65+
return p[x]
66+
67+
# 合并a和b所在的两个集合
68+
p[find(a)] = find(b)
69+
```
70+
71+
模板 2——维护 size 的并查集：
72+
73+
```python
74+
# 初始化，p存储每个点的父节点，size只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
75+
p = list(range(n))
76+
size = [1] * n
77+
78+
# 返回x的祖宗节点
79+
def find(x):
80+
if p[x] != x:
81+
# 路径压缩
82+
p[x] = find(p[x])
83+
return p[x]
84+
85+
# 合并a和b所在的两个集合
86+
if find(a) != find(b):
87+
size[find(b)] += size[find(a)]
88+
p[find(a)] = find(b)
89+
```
90+
91+
模板 3——维护到祖宗节点距离的并查集：
92+
93+
```python
94+
# 初始化，p存储每个点的父节点，d[x]存储x到p[x]的距离
95+
p = list(range(n))
96+
d = [0] * n
97+
98+
# 返回x的祖宗节点
99+
def find(x):
100+
if p[x] != x:
101+
t = find(p[x])
102+
d[x] += d[p[x]]
103+
p[x] = t
104+
return p[x]
105+
106+
# 合并a和b所在的两个集合
107+
p[find(a)] = find(b)
108+
d[find(a)] = distance
109+
```
110+
111+
对于本题，先对日志列表按照时间升序排列。然后遍历日志列表，每条日志对应的两个人合并为同一个连通分量。当连通分量个数减为 1 时，说明圈子里所有人之间都熟识了，返回当前遍历到的时间。否则遍历结束返回 -1。
112+
53113
<!-- tabs:start -->
54114

55115
### **Python3**
56116

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

59119
```python
60-
120+
class Solution:
121+
def earliestAcq(self, logs: List[List[int]], n: int) -> int:
122+
p = list(range(n))
123+
logs.sort(key=lambda x: x[0])
124+
125+
def find(x):
126+
if p[x] != x:
127+
p[x] = find(p[x])
128+
return p[x]
129+
130+
for t, a, b in logs:
131+
pa, pb = find(a), find(b)
132+
if pa == pb:
133+
continue
134+
p[pa] = pb
135+
n -= 1
136+
if n == 1:
137+
return t
138+
return -1
61139
```
62140

63141
### **Java**
64142

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

67145
```java
146+
class Solution {
147+
private int[] p;
148+
149+
public int earliestAcq(int[][] logs, int n) {
150+
p = new int[n];
151+
for (int i = 0; i < n; ++i) {
152+
p[i] = i;
153+
}
154+
Arrays.sort(logs, Comparator.comparingInt(a -> a[0]));
155+
for (int[] log : logs) {
156+
int t = log[0];
157+
int a = log[1], b = log[2];
158+
int pa = find(a), pb = find(b);
159+
if (pa == pb) {
160+
continue;
161+
}
162+
p[pa] = pb;
163+
--n;
164+
if (n == 1) {
165+
return t;
166+
}
167+
}
168+
return -1;
169+
}
170+
171+
private int find(int x) {
172+
if (p[x] != x) {
173+
p[x] = find(p[x]);
174+
}
175+
return p[x];
176+
}
177+
}
178+
```
179+
180+
### **C++**
181+
182+
```cpp
183+
class Solution {
184+
public:
185+
vector<int> p;
186+
187+
int earliestAcq(vector<vector<int>>& logs, int n) {
188+
for (int i = 0; i < n; ++i)
189+
p.push_back(i);
190+
sort(logs.begin(), logs.end());
191+
for (auto log : logs)
192+
{
193+
int a = log[1], b = log[2];
194+
int pa = find(a), pb = find(b);
195+
if (pa == pb)
196+
continue;
197+
p[pa] = pb;
198+
--n;
199+
if (n == 1)
200+
return log[0];
201+
}
202+
return -1;
203+
}
204+
205+
int find(int x) {
206+
if (p[x] != x)
207+
p[x] = find(p[x]);
208+
return p[x];
209+
}
210+
};
211+
```
68212
213+
### **Go**
214+
215+
```go
216+
var p []int
217+
218+
func earliestAcq(logs [][]int, n int) int {
219+
p = make([]int, n)
220+
for i := 0; i < n; i++ {
221+
p[i] = i
222+
}
223+
sort.Slice(logs, func(i, j int) bool {
224+
return logs[i][0] < logs[j][0]
225+
})
226+
for _, log := range logs {
227+
a, b := log[1], log[2]
228+
pa, pb := find(a), find(b)
229+
if pa == pb {
230+
continue
231+
}
232+
p[pa] = pb
233+
n--
234+
if n == 1 {
235+
return log[0]
236+
}
237+
}
238+
return -1
239+
}
240+
241+
func find(x int) int {
242+
if p[x] != x {
243+
p[x] = find(p[x])
244+
}
245+
return p[x]
246+
}
69247
```
70248

71249
### **...**

‎solution/1100-1199/1101.The Earliest Moment When Everyone Become Friends/README_EN.md

Lines changed: 119 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -44,21 +44,138 @@ The sixth event occurs at timestamp = 20190301 and after 0 and 3 become friends
4444
<li><code>logs[i][1] != logs[i][2]</code></li>
4545
</ol>
4646

47-
4847
## Solutions
4948

5049
<!-- tabs:start -->
5150

5251
### **Python3**
5352

5453
```python
55-
54+
class Solution:
55+
def earliestAcq(self, logs: List[List[int]], n: int) -> int:
56+
p = list(range(n))
57+
logs.sort(key=lambda x: x[0])
58+
59+
def find(x):
60+
if p[x] != x:
61+
p[x] = find(p[x])
62+
return p[x]
63+
64+
for t, a, b in logs:
65+
pa, pb = find(a), find(b)
66+
if pa == pb:
67+
continue
68+
p[pa] = pb
69+
n -= 1
70+
if n == 1:
71+
return t
72+
return -1
5673
```
5774

5875
### **Java**
5976

6077
```java
78+
class Solution {
79+
private int[] p;
80+
81+
public int earliestAcq(int[][] logs, int n) {
82+
p = new int[n];
83+
for (int i = 0; i < n; ++i) {
84+
p[i] = i;
85+
}
86+
Arrays.sort(logs, Comparator.comparingInt(a -> a[0]));
87+
for (int[] log : logs) {
88+
int t = log[0];
89+
int a = log[1], b = log[2];
90+
int pa = find(a), pb = find(b);
91+
if (pa == pb) {
92+
continue;
93+
}
94+
p[pa] = pb;
95+
--n;
96+
if (n == 1) {
97+
return t;
98+
}
99+
}
100+
return -1;
101+
}
102+
103+
private int find(int x) {
104+
if (p[x] != x) {
105+
p[x] = find(p[x]);
106+
}
107+
return p[x];
108+
}
109+
}
110+
```
111+
112+
### **C++**
113+
114+
```cpp
115+
class Solution {
116+
public:
117+
vector<int> p;
118+
119+
int earliestAcq(vector<vector<int>>& logs, int n) {
120+
for (int i = 0; i < n; ++i)
121+
p.push_back(i);
122+
sort(logs.begin(), logs.end());
123+
for (auto log : logs)
124+
{
125+
int a = log[1], b = log[2];
126+
int pa = find(a), pb = find(b);
127+
if (pa == pb)
128+
continue;
129+
p[pa] = pb;
130+
--n;
131+
if (n == 1)
132+
return log[0];
133+
}
134+
return -1;
135+
}
136+
137+
int find(int x) {
138+
if (p[x] != x)
139+
p[x] = find(p[x]);
140+
return p[x];
141+
}
142+
};
143+
```
61144
145+
### **Go**
146+
147+
```go
148+
var p []int
149+
150+
func earliestAcq(logs [][]int, n int) int {
151+
p = make([]int, n)
152+
for i := 0; i < n; i++ {
153+
p[i] = i
154+
}
155+
sort.Slice(logs, func(i, j int) bool {
156+
return logs[i][0] < logs[j][0]
157+
})
158+
for _, log := range logs {
159+
a, b := log[1], log[2]
160+
pa, pb := find(a), find(b)
161+
if pa == pb {
162+
continue
163+
}
164+
p[pa] = pb
165+
n--
166+
if n == 1 {
167+
return log[0]
168+
}
169+
}
170+
return -1
171+
}
172+
173+
func find(x int) int {
174+
if p[x] != x {
175+
p[x] = find(p[x])
176+
}
177+
return p[x]
178+
}
62179
```
63180

64181
### **...**

‎solution/1100-1199/1101.The Earliest Moment When Everyone Become Friends/Solution.cpp

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
public:
3+
vector<int> p;
4+
5+
int earliestAcq(vector<vector<int>>& logs, int n) {
6+
for (int i = 0; i < n; ++i)
7+
p.push_back(i);
8+
sort(logs.begin(), logs.end());
9+
for (auto log : logs)
10+
{
11+
int a = log[1], b = log[2];
12+
int pa = find(a), pb = find(b);
13+
if (pa == pb)
14+
continue;
15+
p[pa] = pb;
16+
--n;
17+
if (n == 1)
18+
return log[0];
19+
}
20+
return -1;
21+
}
22+
23+
int find(int x) {
24+
if (p[x] != x)
25+
p[x] = find(p[x]);
26+
return p[x];
27+
}
28+
};

0 commit comments

Comments
 (0)