Skip to content

Commit b43d94e

Browse files
yanglbmeyanglbme
committedAug 24, 2021
feat: add solutions to lc problem: No.1061.Lexicographically Smallest
Equivalent String
1 parent 9dafaa5 commit b43d94e

File tree

6 files changed

+420
-3
lines changed

6 files changed

+420
-3
lines changed
 

‎solution/1000-1099/1061.Lexicographically Smallest Equivalent String/README.md

+179-2
Original file line numberDiff line numberDiff line change
@@ -53,27 +53,204 @@
5353
<li>字符串&nbsp;<code>A</code>&nbsp;和&nbsp;<code>B</code>&nbsp;长度相同。</li>
5454
</ol>
5555

56-
5756
## 解法
5857

5958
<!-- 这里可写通用的实现逻辑 -->
6059

60+
并查集。
61+
62+
模板 1——朴素并查集：
63+
64+
```python
65+
# 初始化，p存储每个点的祖宗节点
66+
p = [i for i in range(n)]
67+
# 返回x的祖宗节点
68+
def find(x):
69+
if p[x] != x:
70+
# 路径压缩
71+
p[x] = find(p[x])
72+
return p[x]
73+
# 合并a和b所在的两个集合
74+
p[find(a)] = find(b)
75+
```
76+
77+
模板 2——维护 size 的并查集：
78+
79+
```python
80+
# 初始化，p存储每个点的祖宗节点，size只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
81+
p = [i for i in range(n)]
82+
size = [1] * n
83+
# 返回x的祖宗节点
84+
def find(x):
85+
if p[x] != x:
86+
# 路径压缩
87+
p[x] = find(p[x])
88+
return p[x]
89+
# 合并a和b所在的两个集合
90+
size[find(b)] += size[find(a)]
91+
p[find(a)] = find(b)
92+
```
93+
94+
模板 3——维护到祖宗节点距离的并查集：
95+
96+
```python
97+
# 初始化，p存储每个点的祖宗节点，d[x]存储x到p[x]的距离
98+
p = [i for i in range(n)]
99+
d = [0] * n
100+
# 返回x的祖宗节点
101+
def find(x):
102+
if p[x] != x:
103+
t = find(p[x])
104+
d[x] += d[p[x]]
105+
p[x] = t
106+
return p[x]
107+
# 合并a和b所在的两个集合
108+
p[find(a)] = find(b)
109+
d[find(a)] = dinstance
110+
```
111+
112+
对于本题，套用并查集模板时，将数值较大的祖宗节点指向数值较小的祖宗节点，这样可以保证祖宗节点存放的是本集合的最小值。
113+
61114
<!-- tabs:start -->
62115

63116
### **Python3**
64117

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

67120
```python
68-
121+
class Solution:
122+
def smallestEquivalentString(self, s1: str, s2: str, baseStr: str) -> str:
123+
p = list(range(26))
124+
125+
def find(x):
126+
if p[x] != x:
127+
p[x] = find(p[x])
128+
return p[x]
129+
130+
for i in range(len(s1)):
131+
a, b = ord(s1[i]) - ord('a'), ord(s2[i]) - ord('a')
132+
pa, pb = find(a), find(b)
133+
if pa < pb:
134+
p[pb] = pa
135+
else:
136+
p[pa] = pb
137+
138+
res = []
139+
for a in baseStr:
140+
a = ord(a) - ord('a')
141+
res.append(chr(find(a) + ord('a')))
142+
return ''.join(res)
69143
```
70144

71145
### **Java**
72146

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

75149
```java
150+
class Solution {
151+
private int[] p;
152+
153+
public String smallestEquivalentString(String s1, String s2, String baseStr) {
154+
p = new int[26];
155+
for (int i = 0; i < 26; ++i) {
156+
p[i] = i;
157+
}
158+
for (int i = 0; i < s1.length(); ++i) {
159+
int a = s1.charAt(i) - 'a', b = s2.charAt(i) - 'a';
160+
int pa = find(a), pb = find(b);
161+
if (pa < pb) {
162+
p[pb] = pa;
163+
} else {
164+
p[pa] = pb;
165+
}
166+
}
167+
StringBuilder sb = new StringBuilder();
168+
for (char a : baseStr.toCharArray()) {
169+
char b = (char) (find(a - 'a') + 'a');
170+
sb.append(b);
171+
}
172+
return sb.toString();
173+
}
174+
175+
private int find(int x) {
176+
if (p[x] != x) {
177+
p[x] = find(p[x]);
178+
}
179+
return p[x];
180+
}
181+
}
182+
```
183+
184+
### **C++**
185+
186+
```cpp
187+
class Solution {
188+
public:
189+
vector<int> p;
190+
191+
string smallestEquivalentString(string s1, string s2, string baseStr) {
192+
p.resize(26);
193+
for (int i = 0; i < 26; ++i)
194+
p[i] = i;
195+
for (int i = 0; i < s1.size(); ++i)
196+
{
197+
int a = s1[i] - 'a', b = s2[i] - 'a';
198+
int pa = find(a), pb = find(b);
199+
if (pa < pb)
200+
p[pb] = pa;
201+
else
202+
p[pa] = pb;
203+
}
204+
string res = "";
205+
for (char a : baseStr)
206+
{
207+
char b = (char)(find(a - 'a') + 'a');
208+
res += b;
209+
}
210+
return res;
211+
}
212+
213+
int find(int x) {
214+
if (p[x] != x)
215+
p[x] = find(p[x]);
216+
return p[x];
217+
}
218+
};
219+
```
76220

221+
### **Go**
222+
223+
```go
224+
var p []int
225+
226+
func smallestEquivalentString(s1 string, s2 string, baseStr string) string {
227+
p = make([]int, 26)
228+
for i := 0; i < 26; i++ {
229+
p[i] = i
230+
}
231+
for i := 0; i < len(s1); i++ {
232+
a, b := int(s1[i]-'a'), int(s2[i]-'a')
233+
pa, pb := find(a), find(b)
234+
if pa < pb {
235+
p[pb] = pa
236+
} else {
237+
p[pa] = pb
238+
}
239+
}
240+
var res []byte
241+
for _, a := range baseStr {
242+
b := byte(find(int(a-'a'))) + 'a'
243+
res = append(res, b)
244+
}
245+
return string(res)
246+
}
247+
248+
func find(x int) int {
249+
if p[x] != x {
250+
p[x] = find(p[x])
251+
}
252+
return p[x]
253+
}
77254
```
78255

79256
### **...**

‎solution/1000-1099/1061.Lexicographically Smallest Equivalent String/README_EN.md

+125-1
Original file line numberDiff line numberDiff line change
@@ -101,13 +101,137 @@
101101
### **Python3**
102102

103103
```python
104-
104+
class Solution:
105+
def smallestEquivalentString(self, s1: str, s2: str, baseStr: str) -> str:
106+
p = list(range(26))
107+
108+
def find(x):
109+
if p[x] != x:
110+
p[x] = find(p[x])
111+
return p[x]
112+
113+
for i in range(len(s1)):
114+
a, b = ord(s1[i]) - ord('a'), ord(s2[i]) - ord('a')
115+
pa, pb = find(a), find(b)
116+
if pa < pb:
117+
p[pb] = pa
118+
else:
119+
p[pa] = pb
120+
121+
res = []
122+
for a in baseStr:
123+
a = ord(a) - ord('a')
124+
res.append(chr(find(a) + ord('a')))
125+
return ''.join(res)
105126
```
106127

107128
### **Java**
108129

109130
```java
131+
class Solution {
132+
private int[] p;
133+
134+
public String smallestEquivalentString(String s1, String s2, String baseStr) {
135+
p = new int[26];
136+
for (int i = 0; i < 26; ++i) {
137+
p[i] = i;
138+
}
139+
for (int i = 0; i < s1.length(); ++i) {
140+
int a = s1.charAt(i) - 'a', b = s2.charAt(i) - 'a';
141+
int pa = find(a), pb = find(b);
142+
if (pa < pb) {
143+
p[pb] = pa;
144+
} else {
145+
p[pa] = pb;
146+
}
147+
}
148+
StringBuilder sb = new StringBuilder();
149+
for (char a : baseStr.toCharArray()) {
150+
char b = (char) (find(a - 'a') + 'a');
151+
sb.append(b);
152+
}
153+
return sb.toString();
154+
}
155+
156+
private int find(int x) {
157+
if (p[x] != x) {
158+
p[x] = find(p[x]);
159+
}
160+
return p[x];
161+
}
162+
}
163+
```
164+
165+
### **C++**
166+
167+
```cpp
168+
class Solution {
169+
public:
170+
vector<int> p;
171+
172+
string smallestEquivalentString(string s1, string s2, string baseStr) {
173+
p.resize(26);
174+
for (int i = 0; i < 26; ++i)
175+
p[i] = i;
176+
for (int i = 0; i < s1.size(); ++i)
177+
{
178+
int a = s1[i] - 'a', b = s2[i] - 'a';
179+
int pa = find(a), pb = find(b);
180+
if (pa < pb)
181+
p[pb] = pa;
182+
else
183+
p[pa] = pb;
184+
}
185+
string res = "";
186+
for (char a : baseStr)
187+
{
188+
char b = (char)(find(a - 'a') + 'a');
189+
res += b;
190+
}
191+
return res;
192+
}
193+
194+
int find(int x) {
195+
if (p[x] != x)
196+
p[x] = find(p[x]);
197+
return p[x];
198+
}
199+
};
200+
```
110201

202+
### **Go**
203+
204+
```go
205+
var p []int
206+
207+
func smallestEquivalentString(s1 string, s2 string, baseStr string) string {
208+
p = make([]int, 26)
209+
for i := 0; i < 26; i++ {
210+
p[i] = i
211+
}
212+
for i := 0; i < len(s1); i++ {
213+
a, b := int(s1[i]-'a'), int(s2[i]-'a')
214+
pa, pb := find(a), find(b)
215+
if pa < pb {
216+
p[pb] = pa
217+
} else {
218+
p[pa] = pb
219+
}
220+
}
221+
var res []byte
222+
for _, a := range baseStr {
223+
b := byte(find(int(a-'a'))) + 'a'
224+
res = append(res, b)
225+
}
226+
return string(res)
227+
}
228+
229+
func find(x int) int {
230+
if p[x] != x {
231+
p[x] = find(p[x])
232+
}
233+
return p[x]
234+
}
111235
```
112236

113237
### **...**

‎solution/1000-1099/1061.Lexicographically Smallest Equivalent String/Solution.cpp

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
class Solution {
2+
public:
3+
vector<int> p;
4+
5+
string smallestEquivalentString(string s1, string s2, string baseStr) {
6+
p.resize(26);
7+
for (int i = 0; i < 26; ++i)
8+
p[i] = i;
9+
for (int i = 0; i < s1.size(); ++i)
10+
{
11+
int a = s1[i] - 'a', b = s2[i] - 'a';
12+
int pa = find(a), pb = find(b);
13+
if (pa < pb)
14+
p[pb] = pa;
15+
else
16+
p[pa] = pb;
17+
}
18+
string res = "";
19+
for (char a : baseStr)
20+
{
21+
char b = (char)(find(a - 'a') + 'a');
22+
res += b;
23+
}
24+
return res;
25+
}
26+
27+
int find(int x) {
28+
if (p[x] != x)
29+
p[x] = find(p[x]);
30+
return p[x];
31+
}
32+
};

0 commit comments

Comments
 (0)