Skip to content

Commit 4b6b486

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1202
No.1202.Smallest String With Swaps
1 parent b504d1f commit 4b6b486

File tree

6 files changed

+217
-38
lines changed

6 files changed

+217
-38
lines changed

‎solution/1200-1299/1202.Smallest String With Swaps/README.md

Lines changed: 79 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,11 @@
5757

5858
<!-- 这里可写通用的实现逻辑 -->
5959

60-
并查集。
60+
并查集。对于本题，索引对具备传递性。即如果索引对是 `[0,2]`, `[0, 3]`，那么索引 0、2、3 可以进行任意交换。我们可以利用并查集，遍历每个索引对，将其中的两个索引进行合并，得到并查集，连在一起的索引对应的字符按照字典序排列，这里可以利用优先级队列实现（也可以先用列表存储，再排序）。
61+
62+
最后遍历字符串，找到每个字符的根元素，并替换为字典序中对应的字符。
63+
64+
以下是并查集的几个常用模板。
6165

6266
模板 1——朴素并查集：
6367

@@ -116,10 +120,6 @@ p[find(a)] = find(b)
116120
d[find(a)] = distance
117121
```
118122

119-
对于本题，索引对具备传递性。即如果索引对是 `[0,2]`, `[0, 3]`，那么索引 0、2、3 可以进行任意交换。我们可以利用并查集，遍历每个索引对，将其中的两个索引进行合并，得到并查集，连在一起的索引对应的字符按照字典序排列，这里可以利用优先级队列实现。
120-
121-
最后遍历字符串，找到每个字符的根元素，并替换为字典序中对应的字符。
122-
123123
<!-- tabs:start -->
124124

125125
### **Python3**
@@ -129,24 +129,19 @@ d[find(a)] = distance
129129
```python
130130
class Solution:
131131
def smallestStringWithSwaps(self, s: str, pairs: List[List[int]]) -> str:
132-
n = len(s)
133-
p = list(range(n))
134-
135132
def find(x):
136133
if p[x] != x:
137134
p[x] = find(p[x])
138135
return p[x]
139136

137+
n = len(s)
138+
p = list(range(n))
140139
for a, b in pairs:
141140
p[find(a)] = find(b)
142-
143141
mp = defaultdict(list)
144-
for i in range(n):
145-
heapq.heappush(mp[find(i)], s[i])
146-
chars = list(s)
147-
for i in range(n):
148-
chars[i] = heapq.heappop(mp[find(i)])
149-
return ''.join(chars)
142+
for i, c in enumerate(s):
143+
heapq.heappush(mp[find(i)], c)
144+
return ''.join(heapq.heappop(mp[find(i)]) for i in range(n))
150145
```
151146

152147
### **Java**
@@ -169,7 +164,7 @@ class Solution {
169164
Map<Integer, PriorityQueue<Character>> mp = new HashMap<>();
170165
char[] chars = s.toCharArray();
171166
for (int i = 0; i < n; ++i) {
172-
mp.computeIfAbsent(find(i), key -> new PriorityQueue<>()).offer(chars[i]);
167+
mp.computeIfAbsent(find(i), k -> new PriorityQueue<>()).offer(chars[i]);
173168
}
174169
for (int i = 0; i < n; ++i) {
175170
chars[i] = mp.get(find(i)).poll();
@@ -186,6 +181,74 @@ class Solution {
186181
}
187182
```
188183

184+
### **C++**
185+
186+
```cpp
187+
class Solution {
188+
public:
189+
vector<int> p;
190+
191+
string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
192+
int n = s.length();
193+
p.resize(n);
194+
for (int i = 0; i < n; ++i) p[i] = i;
195+
for (auto& pair : pairs) p[find(pair[0])] = find(pair[1]);
196+
unordered_map<int, vector<char>> mp;
197+
for (int i = 0; i < n; ++i) mp[find(i)].push_back(s[i]);
198+
for (auto& [k, v] : mp) sort(v.rbegin(), v.rend());
199+
string ans;
200+
for (int i = 0; i < n; ++i)
201+
{
202+
ans.push_back(mp[find(i)].back());
203+
mp[find(i)].pop_back();
204+
}
205+
return ans;
206+
}
207+
208+
int find(int x) {
209+
if (p[x] != x) p[x] = find(p[x]);
210+
return p[x];
211+
}
212+
};
213+
```
214+
215+
### **Go**
216+
217+
```go
218+
func smallestStringWithSwaps(s string, pairs [][]int) string {
219+
n := len(s)
220+
p := make([]int, n)
221+
for i := range p {
222+
p[i] = i
223+
}
224+
var find func(x int) int
225+
find = func(x int) int {
226+
if p[x] != x {
227+
p[x] = find(p[x])
228+
}
229+
return p[x]
230+
}
231+
for _, pair := range pairs {
232+
p[find(pair[0])] = find(pair[1])
233+
}
234+
mp := make(map[int][]rune)
235+
for i, c := range s {
236+
mp[find(i)] = append(mp[find(i)], c)
237+
}
238+
for _, v := range mp {
239+
sort.Slice(v, func(i, j int) bool {
240+
return v[i] < v[j]
241+
})
242+
}
243+
var ans []rune
244+
for i := 0; i < n; i++ {
245+
ans = append(ans, mp[find(i)][0])
246+
mp[find(i)] = mp[find(i)][1:]
247+
}
248+
return string(ans)
249+
}
250+
```
251+
189252
### **...**
190253

191254
```

‎solution/1200-1299/1202.Smallest String With Swaps/README_EN.md

Lines changed: 74 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -61,24 +61,19 @@ Swap s[0] and s[1], s = &quot;abc&quot;
6161
```python
6262
class Solution:
6363
def smallestStringWithSwaps(self, s: str, pairs: List[List[int]]) -> str:
64-
n = len(s)
65-
p = list(range(n))
66-
6764
def find(x):
6865
if p[x] != x:
6966
p[x] = find(p[x])
7067
return p[x]
7168

69+
n = len(s)
70+
p = list(range(n))
7271
for a, b in pairs:
7372
p[find(a)] = find(b)
74-
7573
mp = defaultdict(list)
76-
for i in range(n):
77-
heapq.heappush(mp[find(i)], s[i])
78-
chars = list(s)
79-
for i in range(n):
80-
chars[i] = heapq.heappop(mp[find(i)])
81-
return ''.join(chars)
74+
for i, c in enumerate(s):
75+
heapq.heappush(mp[find(i)], c)
76+
return ''.join(heapq.heappop(mp[find(i)]) for i in range(n))
8277
```
8378

8479
### **Java**
@@ -99,7 +94,7 @@ class Solution {
9994
Map<Integer, PriorityQueue<Character>> mp = new HashMap<>();
10095
char[] chars = s.toCharArray();
10196
for (int i = 0; i < n; ++i) {
102-
mp.computeIfAbsent(find(i), key -> new PriorityQueue<>()).offer(chars[i]);
97+
mp.computeIfAbsent(find(i), k -> new PriorityQueue<>()).offer(chars[i]);
10398
}
10499
for (int i = 0; i < n; ++i) {
105100
chars[i] = mp.get(find(i)).poll();
@@ -116,6 +111,74 @@ class Solution {
116111
}
117112
```
118113

114+
### **C++**
115+
116+
```cpp
117+
class Solution {
118+
public:
119+
vector<int> p;
120+
121+
string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
122+
int n = s.length();
123+
p.resize(n);
124+
for (int i = 0; i < n; ++i) p[i] = i;
125+
for (auto& pair : pairs) p[find(pair[0])] = find(pair[1]);
126+
unordered_map<int, vector<char>> mp;
127+
for (int i = 0; i < n; ++i) mp[find(i)].push_back(s[i]);
128+
for (auto& [k, v] : mp) sort(v.rbegin(), v.rend());
129+
string ans;
130+
for (int i = 0; i < n; ++i)
131+
{
132+
ans.push_back(mp[find(i)].back());
133+
mp[find(i)].pop_back();
134+
}
135+
return ans;
136+
}
137+
138+
int find(int x) {
139+
if (p[x] != x) p[x] = find(p[x]);
140+
return p[x];
141+
}
142+
};
143+
```
144+
145+
### **Go**
146+
147+
```go
148+
func smallestStringWithSwaps(s string, pairs [][]int) string {
149+
n := len(s)
150+
p := make([]int, n)
151+
for i := range p {
152+
p[i] = i
153+
}
154+
var find func(x int) int
155+
find = func(x int) int {
156+
if p[x] != x {
157+
p[x] = find(p[x])
158+
}
159+
return p[x]
160+
}
161+
for _, pair := range pairs {
162+
p[find(pair[0])] = find(pair[1])
163+
}
164+
mp := make(map[int][]rune)
165+
for i, c := range s {
166+
mp[find(i)] = append(mp[find(i)], c)
167+
}
168+
for _, v := range mp {
169+
sort.Slice(v, func(i, j int) bool {
170+
return v[i] < v[j]
171+
})
172+
}
173+
var ans []rune
174+
for i := 0; i < n; i++ {
175+
ans = append(ans, mp[find(i)][0])
176+
mp[find(i)] = mp[find(i)][1:]
177+
}
178+
return string(ans)
179+
}
180+
```
181+
119182
### **...**
120183

121184
```

‎solution/1200-1299/1202.Smallest String With Swaps/Solution.cpp

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public:
3+
vector<int> p;
4+
5+
string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
6+
int n = s.length();
7+
p.resize(n);
8+
for (int i = 0; i < n; ++i) p[i] = i;
9+
for (auto& pair : pairs) p[find(pair[0])] = find(pair[1]);
10+
unordered_map<int, vector<char>> mp;
11+
for (int i = 0; i < n; ++i) mp[find(i)].push_back(s[i]);
12+
for (auto& [k, v] : mp) sort(v.rbegin(), v.rend());
13+
string ans;
14+
for (int i = 0; i < n; ++i)
15+
{
16+
ans.push_back(mp[find(i)].back());
17+
mp[find(i)].pop_back();
18+
}
19+
return ans;
20+
}
21+
22+
int find(int x) {
23+
if (p[x] != x) p[x] = find(p[x]);
24+
return p[x];
25+
}
26+
};

‎solution/1200-1299/1202.Smallest String With Swaps/Solution.go

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
func smallestStringWithSwaps(s string, pairs [][]int) string {
2+
n := len(s)
3+
p := make([]int, n)
4+
for i := range p {
5+
p[i] = i
6+
}
7+
var find func(x int) int
8+
find = func(x int) int {
9+
if p[x] != x {
10+
p[x] = find(p[x])
11+
}
12+
return p[x]
13+
}
14+
for _, pair := range pairs {
15+
p[find(pair[0])] = find(pair[1])
16+
}
17+
mp := make(map[int][]rune)
18+
for i, c := range s {
19+
mp[find(i)] = append(mp[find(i)], c)
20+
}
21+
for _, v := range mp {
22+
sort.Slice(v, func(i, j int) bool {
23+
return v[i] < v[j]
24+
})
25+
}
26+
var ans []rune
27+
for i := 0; i < n; i++ {
28+
ans = append(ans, mp[find(i)][0])
29+
mp[find(i)] = mp[find(i)][1:]
30+
}
31+
return string(ans)
32+
}

‎solution/1200-1299/1202.Smallest String With Swaps/Solution.java

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ public String smallestStringWithSwaps(String s, List<List<Integer>> pairs) {
1313
Map<Integer, PriorityQueue<Character>> mp = new HashMap<>();
1414
char[] chars = s.toCharArray();
1515
for (int i = 0; i < n; ++i) {
16-
mp.computeIfAbsent(find(i), key -> new PriorityQueue<>()).offer(chars[i]);
16+
mp.computeIfAbsent(find(i), k -> new PriorityQueue<>()).offer(chars[i]);
1717
}
1818
for (int i = 0; i < n; ++i) {
1919
chars[i] = mp.get(find(i)).poll();

‎solution/1200-1299/1202.Smallest String With Swaps/Solution.py

Lines changed: 5 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,15 @@
11
class Solution:
22
def smallestStringWithSwaps(self, s: str, pairs: List[List[int]]) -> str:
3-
n = len(s)
4-
p = list(range(n))
5-
63
def find(x):
74
if p[x] != x:
85
p[x] = find(p[x])
96
return p[x]
107

8+
n = len(s)
9+
p = list(range(n))
1110
for a, b in pairs:
1211
p[find(a)] = find(b)
13-
1412
mp = defaultdict(list)
15-
for i in range(n):
16-
heapq.heappush(mp[find(i)], s[i])
17-
chars = list(s)
18-
for i in range(n):
19-
chars[i] = heapq.heappop(mp[find(i)])
20-
return ''.join(chars)
13+
for i, c in enumerate(s):
14+
heapq.heappush(mp[find(i)], c)
15+
return ''.join(heapq.heappop(mp[find(i)]) for i in range(n))

0 commit comments

Comments
 (0)