Skip to content

Commit 96438b4

Browse files
committed
feat: add solutions to lc problem: No.3267
No.3267.Count Almost Equal Pairs II
1 parent 3013bb6 commit 96438b4

File tree

10 files changed

+510
-9
lines changed

10 files changed

+510
-9
lines changed

solution/0600-0699/0690.Employee Importance/README.md

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -172,6 +172,8 @@ public:
172172
};
173173
```
174174
175+
#### Go
176+
175177
```go
176178
/**
177179
* Definition for Employee.

solution/0600-0699/0690.Employee Importance/README_EN.md

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -165,6 +165,8 @@ public:
165165
};
166166
```
167167
168+
#### Go
169+
168170
```go
169171
/**
170172
* Definition for Employee.

solution/3200-3299/3265.Count Almost Equal Pairs I/README.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -86,7 +86,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3265.Co
8686

8787
### 方法一:排序 + 枚举
8888

89-
我们可以枚举每一个数,然后对于每一个数,我们可以枚举每一对不同的数位,然后交换这两个数位,得到一个新的数,记录到一个哈希表 $s$ 中,表示这个数至多进行一次交换后的所有可能的数。然后计算前面枚举过的数中有多少个数在哈希表 $s$ 中,累加到答案中。接下来,我们将当前枚举的数加入到哈希表 $\textit{cnt}$ 中,表示当前枚举的数的个数。
89+
我们可以枚举每一个数,然后对于每一个数,我们可以枚举每一对不同的数位,然后交换这两个数位,得到一个新的数,记录到一个哈希表 $\textit{vis}$ 中,表示这个数至多进行一次交换后的所有可能的数。然后计算前面枚举过的数中有多少个数在哈希表 $\textit{vis}$ 中,累加到答案中。接下来,我们将当前枚举的数加入到哈希表 $\textit{cnt}$ 中,表示当前枚举的数的个数。
9090

9191
这样枚举,会少统计一些数对,比如 $[100, 1]$,因为 $100$ 交换后的数是 $1$,而此前枚举过数不包含 $1$,因此会少统计一些数对。我们只需要在枚举之前,将数组排序,即可解决这个问题。
9292

solution/3200-3299/3267.Count Almost Equal Pairs II/README.md

Lines changed: 172 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -82,32 +82,200 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3200-3299/3267.Co
8282

8383
<!-- solution:start -->
8484

85-
### 方法一
85+
### 方法一:排序 + 枚举
86+
87+
我们可以枚举每一个数,然后对于每一个数,我们可以枚举每一对不同的数位,然后交换这两个数位,得到一个新的数,记录到一个哈希表 $\textit{vis}$ 中,表示这个数至多进行一次交换后的所有可能的数,然后继续枚举每一对不同的数位,交换这两个数位,得到一个新的数,记录到哈希表 $\textit{vis}$ 中,表示这个数至多进行两次交换后的所有可能的数。
88+
89+
这样枚举,会少统计一些数对,比如 $[100, 1]$,因为 $100$ 交换后的数是 $1$,而此前枚举过数不包含 $1$,因此会少统计一些数对。我们只需要在枚举之前,将数组排序,即可解决这个问题。
90+
91+
时间复杂度 $O(n \times (\log n + \log^5 M))$,空间复杂度 $O(n + \log^4 M)$。其中 $n$ 是数组 $\textit{nums}$ 的长度,而 $M$ 是数组 $\textit{nums}$ 中的最大值。
8692

8793
<!-- tabs:start -->
8894

8995
#### Python3
9096

9197
```python
92-
98+
class Solution:
99+
def countPairs(self, nums: List[int]) -> int:
100+
nums.sort()
101+
ans = 0
102+
cnt = defaultdict(int)
103+
for x in nums:
104+
vis = {x}
105+
s = list(str(x))
106+
m = len(s)
107+
for j in range(m):
108+
for i in range(j):
109+
s[i], s[j] = s[j], s[i]
110+
vis.add(int("".join(s)))
111+
for q in range(i + 1, m):
112+
for p in range(i + 1, q):
113+
s[p], s[q] = s[q], s[p]
114+
vis.add(int("".join(s)))
115+
s[p], s[q] = s[q], s[p]
116+
s[i], s[j] = s[j], s[i]
117+
ans += sum(cnt[x] for x in vis)
118+
cnt[x] += 1
119+
return ans
93120
```
94121

95122
#### Java
96123

97124
```java
98-
125+
class Solution {
126+
public int countPairs(int[] nums) {
127+
Arrays.sort(nums);
128+
int ans = 0;
129+
Map<Integer, Integer> cnt = new HashMap<>();
130+
for (int x : nums) {
131+
Set<Integer> vis = new HashSet<>();
132+
vis.add(x);
133+
char[] s = String.valueOf(x).toCharArray();
134+
for (int j = 0; j < s.length; ++j) {
135+
for (int i = 0; i < j; ++i) {
136+
swap(s, i, j);
137+
vis.add(Integer.parseInt(String.valueOf(s)));
138+
for (int q = i; q < s.length; ++q) {
139+
for (int p = i; p < q; ++p) {
140+
swap(s, p, q);
141+
vis.add(Integer.parseInt(String.valueOf(s)));
142+
swap(s, p, q);
143+
}
144+
}
145+
swap(s, i, j);
146+
}
147+
}
148+
for (int y : vis) {
149+
ans += cnt.getOrDefault(y, 0);
150+
}
151+
cnt.merge(x, 1, Integer::sum);
152+
}
153+
return ans;
154+
}
155+
156+
private void swap(char[] s, int i, int j) {
157+
char t = s[i];
158+
s[i] = s[j];
159+
s[j] = t;
160+
}
161+
}
99162
```
100163

101164
#### C++
102165

103166
```cpp
104-
167+
class Solution {
168+
public:
169+
int countPairs(vector<int>& nums) {
170+
sort(nums.begin(), nums.end());
171+
int ans = 0;
172+
unordered_map<int, int> cnt;
173+
174+
for (int x : nums) {
175+
unordered_set<int> vis = {x};
176+
string s = to_string(x);
177+
178+
for (int j = 0; j < s.length(); ++j) {
179+
for (int i = 0; i < j; ++i) {
180+
swap(s[i], s[j]);
181+
vis.insert(stoi(s));
182+
for (int q = i + 1; q < s.length(); ++q) {
183+
for (int p = i + 1; p < q; ++p) {
184+
swap(s[p], s[q]);
185+
vis.insert(stoi(s));
186+
swap(s[p], s[q]);
187+
}
188+
}
189+
swap(s[i], s[j]);
190+
}
191+
}
192+
193+
for (int y : vis) {
194+
ans += cnt[y];
195+
}
196+
cnt[x]++;
197+
}
198+
199+
return ans;
200+
}
201+
};
105202
```
106203
107204
#### Go
108205
109206
```go
207+
func countPairs(nums []int) (ans int) {
208+
sort.Ints(nums)
209+
cnt := make(map[int]int)
210+
211+
for _, x := range nums {
212+
vis := make(map[int]struct{})
213+
vis[x] = struct{}{}
214+
s := []rune(strconv.Itoa(x))
215+
216+
for j := 0; j < len(s); j++ {
217+
for i := 0; i < j; i++ {
218+
s[i], s[j] = s[j], s[i]
219+
y, _ := strconv.Atoi(string(s))
220+
vis[y] = struct{}{}
221+
for q := i + 1; q < len(s); q++ {
222+
for p := i + 1; p < q; p++ {
223+
s[p], s[q] = s[q], s[p]
224+
z, _ := strconv.Atoi(string(s))
225+
vis[z] = struct{}{}
226+
s[p], s[q] = s[q], s[p]
227+
}
228+
}
229+
s[i], s[j] = s[j], s[i]
230+
}
231+
}
232+
233+
for y := range vis {
234+
ans += cnt[y]
235+
}
236+
cnt[x]++
237+
}
238+
239+
return
240+
}
241+
```
110242

243+
#### TypeScript
244+
245+
```ts
246+
function countPairs(nums: number[]): number {
247+
nums.sort((a, b) => a - b);
248+
let ans = 0;
249+
const cnt = new Map<number, number>();
250+
251+
for (const x of nums) {
252+
const vis = new Set<number>();
253+
vis.add(x);
254+
const s = x.toString().split('');
255+
256+
for (let j = 0; j < s.length; j++) {
257+
for (let i = 0; i < j; i++) {
258+
[s[i], s[j]] = [s[j], s[i]];
259+
vis.add(+s.join(''));
260+
for (let q = i + 1; q < s.length; ++q) {
261+
for (let p = i + 1; p < q; ++p) {
262+
[s[p], s[q]] = [s[q], s[p]];
263+
vis.add(+s.join(''));
264+
[s[p], s[q]] = [s[q], s[p]];
265+
}
266+
}
267+
[s[i], s[j]] = [s[j], s[i]];
268+
}
269+
}
270+
271+
for (const y of vis) {
272+
ans += cnt.get(y) || 0;
273+
}
274+
cnt.set(x, (cnt.get(x) || 0) + 1);
275+
}
276+
277+
return ans;
278+
}
111279
```
112280

113281
<!-- tabs:end -->

0 commit comments

Comments
 (0)