feat: add solutions to lc problem: No.0765

No.0765.Couples Holding Hands

Author: yanglbme

solution/0700-0799/0765.Couples Holding Hands/README.md

@@ -46,73 +46,17 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-坐错位置的情况与最少需要交换次数：
+**方法一：并查集**
 
--   1 对情侣、2 个座位，不需要交换。
--   2 对情侣、4 个座位，交换 1 次。
--   3 对情侣、6 个座位。首先交换 1 次使得其中 1 对情侣坐在一起，剩下 2 对情侣、4 个座位。即需要交换 2 次。
+我们可以给每一对情侣编号，编号 $0$ 和 $1$ 的人对应情侣 $0$，编号 $2$ 和 $3$ 的人对应情侣 $1$...即编号为 $row[i]$ 对应的情侣编号为 $\lfloor \frac{row[i]}{2} \rfloor$。
 
-以此类推，得到 `f(n)=n-1`。即：n 对情侣相互坐错位置，最少需要交换 `n-1` 次。
+如果有 $k$ 对情侣相互之间坐错了位置，也即是说，有 $k$ 对情侣处于一个置换环中，那么他们之间需要经过 $k-1$ 次交换才能都坐到正确的位置上。
 
-把相互坐错位置的情侣放在一组（同个集合），组内有 n 对情侣就需要 `n-1` 次交换。将 n 对情侣分为 K 组：N1,N2...Nk，有 N1+N2+...+Nk=n。需要交换的次数分别为：N1-1、N2-1、...、Nk-1，则总的最少交换次数为 N1-1+N2-1+...+Nk-1=N1+N2+...+Nk-k=n-k。问题转换为：n 对情侣，根据相互坐错位置的条件分组，共有多少个分组。并查集实现。
+为什么？不妨这样考虑，我们先调整一对情侣的位置，使其坐到正确的位置上，那么问题就从 $k$ 对情侣的问题，转换成了 $k-1$ 对情侣的问题。依此类推，最终 $k=1$ 时，交换次数为 $0$。所以，如果 $k$ 对情侣相互之间坐错了位置，那么需要 $k-1$ 次交换。
 
-模板 1——朴素并查集：
+因此，我们只需要遍历一遍数组，利用并查集找出有多少个置换环，假设有 $x$ 个，每个环的大小（情侣的对数）为 $y_1, y_2, \cdots, y_x$，那么需要交换的次数为 $y_1-1 + y_2-1 + \cdots + y_x-1 = y_1 + y_2 + \cdots + y_x - x = n - x$。
 
-```python
-# 初始化，p存储每个点的父节点
-p = list(range(n))
-
-# 返回x的祖宗节点
-def find(x):
-    if p[x] != x:
-        # 路径压缩
-        p[x] = find(p[x])
-    return p[x]
-
-
-# 合并a和b所在的两个集合
-p[find(a)] = find(b)
-```
-
-模板 2——维护 size 的并查集：
-
-```python
-# 初始化，p存储每个点的父节点，size只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
-p = list(range(n))
-size = [1] * n
-
-# 返回x的祖宗节点
-def find(x):
-    if p[x] != x:
-        # 路径压缩
-        p[x] = find(p[x])
-    return p[x]
-
-# 合并a和b所在的两个集合
-if find(a) != find(b):
-    size[find(b)] += size[find(a)]
-    p[find(a)] = find(b)
-```
-
-模板 3——维护到祖宗节点距离的并查集：
-
-```python
-# 初始化，p存储每个点的父节点，d[x]存储x到p[x]的距离
-p = list(range(n))
-d = [0] * n
-
-# 返回x的祖宗节点
-def find(x):
-    if p[x] != x:
-        t = find(p[x])
-        d[x] += d[p[x]]
-        p[x] = t
-    return p[x]
-
-# 合并a和b所在的两个集合
-p[find(a)] = find(b)
-d[find(a)] = distance
-```
+时间复杂度 $O(n \times \alpha(n))$，空间复杂度 $O(n)$。其中 $\alpha(n)$ 为阿克曼函数的反函数，可以认为是一个很小的常数。
 
 <!-- tabs:start -->
 
@@ -123,7 +67,7 @@ d[find(a)] = distance
 ```python
 class Solution:
     def minSwapsCouples(self, row: List[int]) -> int:
-        def find(x):
+        def find(x: int) -> int:
             if p[x] != x:
                 p[x] = find(p[x])
             return p[x]
@@ -150,17 +94,17 @@ class Solution {
         for (int i = 0; i < n; ++i) {
             p[i] = i;
         }
-        for (int i = 0; i < row.length; i += 2) {
+        for (int i = 0; i < n << 1; i += 2) {
             int a = row[i] >> 1, b = row[i + 1] >> 1;
             p[find(a)] = find(b);
         }
-        int cnt = 0;
+        int ans = n;
         for (int i = 0; i < n; ++i) {
             if (i == find(i)) {
-                ++cnt;
+                --ans;
             }
         }
-        return n - cnt;
+        return ans;
     }
 
     private int find(int x) {
@@ -177,64 +121,120 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    vector<int> p;
-
     int minSwapsCouples(vector<int>& row) {
-        int n = row.size() >> 1;
-        p.resize(n);
-        for (int i = 0; i < n; ++i) {
-            p[i] = i;
-        }
-        for (int i = 0; i < row.size(); i += 2) {
+        int n = row.size() / 2;
+        int p[n];
+        iota(p, p + n, 0);
+        function<int(int)> find = [&](int x) -> int {
+            if (p[x] != x) {
+                p[x] = find(p[x]);
+            }
+            return p[x];
+        };
+        for (int i = 0; i < n << 1; i += 2) {
             int a = row[i] >> 1, b = row[i + 1] >> 1;
             p[find(a)] = find(b);
         }
-        int cnt = 0;
+        int ans = n;
         for (int i = 0; i < n; ++i) {
-            if (i == find(i))
-                ++cnt;
+            ans -= i == find(i);
         }
-        return n - cnt;
-    }
-
-    int find(int x) {
-        if (p[x] != x) {
-            p[x] = find(p[x]);
-        }
-        return p[x];
+        return ans;
     }
 };
 ```
 
 ### **Go**
 
 ```go
-var p []int
-
 func minSwapsCouples(row []int) int {
 	n := len(row) >> 1
-	p = make([]int, n)
-	for i := 0; i < n; i++ {
+	p := make([]int, n)
+	for i := range p {
 		p[i] = i
 	}
-	for i := 0; i < len(row); i += 2 {
+	var find func(int) int
+	find = func(x int) int {
+		if p[x] != x {
+			p[x] = find(p[x])
+		}
+		return p[x]
+	}
+	for i := 0; i < n<<1; i += 2 {
 		a, b := row[i]>>1, row[i+1]>>1
 		p[find(a)] = find(b)
 	}
-	cnt := 0
-	for i := 0; i < n; i++ {
-		if i == find(i) {
-			cnt++
+	ans := n
+	for i := range p {
+		if find(i) == i {
+			ans--
 		}
 	}
-	return n - cnt
+	return ans
 }
+```
 
-func find(x int) int {
-	if p[x] != x {
-		p[x] = find(p[x])
-	}
-	return p[x]
+### **TypeScript**
+
+```ts
+function minSwapsCouples(row: number[]): number {
+    const n = row.length >> 1;
+    const p: number[] = Array(n)
+        .fill(0)
+        .map((_, i) => i);
+    const find = (x: number): number => {
+        if (p[x] !== x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    };
+    for (let i = 0; i < n << 1; i += 2) {
+        const a = row[i] >> 1;
+        const b = row[i + 1] >> 1;
+        p[find(a)] = find(b);
+    }
+    let ans = n;
+    for (let i = 0; i < n; ++i) {
+        if (i === find(i)) {
+            --ans;
+        }
+    }
+    return ans;
+}
+```
+
+### **C#**
+
+```cs
+public class Solution {
+    private int[] p;
+
+    public int MinSwapsCouples(int[] row) {
+        int n = row.Length >> 1;
+        p = new int[n];
+        for (int i = 0; i < n; ++i) {
+            p[i] = i;
+        }
+        for (int i = 0; i < n << 1; i += 2) {
+            int a = row[i] >> 1;
+            int b = row[i + 1] >> 1;
+            p[find(a)] = find(b);
+        }
+        int ans = n;
+        for (int i = 0; i < n; ++i) {
+            if (p[i] == i) {
+                --ans;
+            }
+        }
+        return ans;
+    }
+
+    private int find(int x) {
+        if (p[x] != x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
 }
 ```