feat: add solutions to lc problem: No.1632

No.1632.Rank Transform of a Matrix

Author: yanglbme

solution/1600-1699/1632.Rank Transform of a Matrix/README.md

@@ -82,23 +82,38 @@ matrix[1][1] 的秩为 3 ，因为 matrix[1][1] > matrix[0][1]， matrix[1][1] >
 
 这种联动容易想到并查集，于是用并查集将相同元素分为几个连通块，对于每个连通块，里面所有元素对应的行或列的最大秩加 $1$，即为该连通块内所有元素的秩。
 
+时间复杂度 $O(m \times n \times \log(m \times n))$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为矩阵的行数和列数。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-class Solution:
-    def matrixRankTransform(self, matrix: List[List[int]]) -> List[List[int]]:
-        def find(x):
-            if p.setdefault(x, x) != x:
-                p[x] = find(p[x])
-            return p[x]
+class UnionFind:
+    def __init__(self, n):
+        self.p = list(range(n))
+        self.size = [1] * n
+
+    def find(self, x):
+        if self.p[x] != x:
+            self.p[x] = self.find(self.p[x])
+        return self.p[x]
+
+    def union(self, a, b):
+        pa, pb = self.find(a), self.find(b)
+        if pa != pb:
+            if self.size[pa] > self.size[pb]:
+                self.p[pb] = pa
+                self.size[pa] += self.size[pb]
+            else:
+                self.p[pa] = pb
+                self.size[pb] += self.size[pa]
 
-        def union(a, b):
-            p[find(a)] = find(b)
 
+class Solution:
+    def matrixRankTransform(self, matrix: List[List[int]]) -> List[List[int]]:
         m, n = len(matrix), len(matrix[0])
         d = defaultdict(list)
         for i, row in enumerate(matrix):
@@ -108,13 +123,14 @@ class Solution:
         col_max = [0] * n
         ans = [[0] * n for _ in range(m)]
         for v in sorted(d):
-            p, rank = {}, defaultdict(int)
+            uf = UnionFind(m + n)
+            rank = defaultdict(int)
             for i, j in d[v]:
-                union(i, j + 500)
+                uf.union(i, j + m)
             for i, j in d[v]:
-                rank[find(i)] = max(rank[find(i)], row_max[i], col_max[j])
+                rank[uf.find(i)] = max(rank[uf.find(i)], row_max[i], col_max[j])
             for i, j in d[v]:
-                ans[i][j] = row_max[i] = col_max[j] = 1 + rank[find(i)]
+                ans[i][j] = row_max[i] = col_max[j] = 1 + rank[uf.find(i)]
         return ans
 ```
 
@@ -123,10 +139,42 @@ class Solution:
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-class Solution {
-    private Map<Integer, Integer> p = new HashMap<>();
-    private Map<Integer, Integer> rank = new HashMap<>();
+class UnionFind {
+    private int[] p;
+    private int[] size;
+
+    public UnionFind(int n) {
+        p = new int[n];
+        size = new int[n];
+        for (int i = 0; i < n; ++i) {
+            p[i] = i;
+            size[i] = 1;
+        }
+    }
+
+    public int find(int x) {
+        if (p[x] != x) {
+            p[x] = find(p[x]);
+        }
+        return p[x];
+    }
+
+    public void union(int a, int b) {
+        int pa = find(a), pb = find(b);
+        if (pa != pb) {
+            if (size[pa] > size[pb]) {
+                p[pb] = pa;
+                size[pa] += size[pb];
+            } else {
+                p[pa] = pb;
+                size[pb] += size[pa];
+            }
+        }
+    }
+}
 
+
+class Solution {
     public int[][] matrixRankTransform(int[][] matrix) {
         int m = matrix.length, n = matrix[0].length;
         TreeMap<Integer, List<int[]>> d = new TreeMap<>();
@@ -138,46 +186,63 @@ class Solution {
         int[] rowMax = new int[m];
         int[] colMax = new int[n];
         int[][] ans = new int[m][n];
-        for (var e : d.entrySet()) {
-            int v = e.getKey();
-            var g = e.getValue();
-            p.clear();
-            rank.clear();
-            for (int[] x : g) {
-                union(x[0], x[1] + 500);
+        for (var ps : d.values()) {
+            UnionFind uf = new UnionFind(m + n);
+            int[] rank = new int[m + n];
+            for (var p : ps) {
+                uf.union(p[0], p[1] + m);
             }
-            for (int[] x : g) {
-                int i = x[0], j = x[1];
-                rank.put(find(i),
-                    Math.max(rank.getOrDefault(find(i), 0), Math.max(rowMax[i], colMax[j])));
+            for (var p : ps) {
+                int i = p[0], j = p[1];
+                rank[uf.find(i)] = Math.max(rank[uf.find(i)], Math.max(rowMax[i], colMax[j]));
             }
-            for (int[] x : g) {
-                int i = x[0], j = x[1];
-                ans[i][j] = 1 + rank.getOrDefault(find(i), 0);
+            for (var p : ps) {
+                int i = p[0], j = p[1];
+                ans[i][j] = 1 + rank[uf.find(i)];
                 rowMax[i] = ans[i][j];
                 colMax[j] = ans[i][j];
             }
         }
         return ans;
     }
+}
+```
+
+### **C++**
+
+```cpp
+class UnionFind {
+public:
+    UnionFind(int n) {
+        p = vector<int>(n);
+        size = vector<int>(n, 1);
+        iota(p.begin(), p.end(), 0);
+    }
 
-    private void union(int a, int b) {
-        p.put(find(a), find(b));
+    void unite(int a, int b) {
+        int pa = find(a), pb = find(b);
+        if (pa != pb) {
+            if (size[pa] > size[pb]) {
+                p[pb] = pa;
+                size[pa] += size[pb];
+            } else {
+                p[pa] = pb;
+                size[pb] += size[pa];
+            }
+        }
     }
 
-    private int find(int x) {
-        p.putIfAbsent(x, x);
-        if (p.get(x) != x) {
-            p.put(x, find(p.get(x)));
+    int find(int x) {
+        if (p[x] != x) {
+            p[x] = find(p[x]);
         }
-        return p.get(x);
+        return p[x];
     }
-}
-```
 
-### **C++**
+private:
+    vector<int> p, size;
+};
 
-```cpp
 class Solution {
 public:
     vector<vector<int>> matrixRankTransform(vector<vector<int>>& matrix) {
@@ -191,32 +256,107 @@ public:
         vector<int> rowMax(m);
         vector<int> colMax(n);
         vector<vector<int>> ans(m, vector<int>(n));
-        for (auto& [v, g] : d) {
-            unordered_map<int, int> p;
-            unordered_map<int, int> rank;
-            for (auto [i, j] : g) {
-                unite(i, j + 500, p);
+        for (auto& [_, ps] : d) {
+            UnionFind uf(m + n);
+            vector<int> rank(m + n);
+            for (auto& [i, j] : ps) {
+                uf.unite(i, j + m);
             }
-            for (auto [i, j] : g) {
-                rank[find(i, p)] = max(rank[find(i, p)], max(rowMax[i], colMax[j]));
+            for (auto& [i, j] : ps) {
+                rank[uf.find(i)] = max({rank[uf.find(i)], rowMax[i], colMax[j]});
             }
-            for (auto [i, j] : g) {
-                ans[i][j] = rowMax[i] = colMax[j] = 1 + rank[find(i, p)];
+            for (auto& [i, j] : ps) {
+                ans[i][j] = rowMax[i] = colMax[j] = 1 + rank[uf.find(i)];
             }
         }
         return ans;
     }
+};
+```
 
-    void unite(int a, int b, unordered_map<int, int>& p) {
-        p[find(a, p)] = find(b, p);
-    }
+### **Go**
 
-    int find(int x, unordered_map<int, int>& p) {
-        if (!p.count(x)) p[x] = x;
-        if (p[x] != x) p[x] = find(p[x], p);
-        return p[x];
-    }
-};
+```go
+type unionFind struct {
+	p, size []int
+}
+
+func newUnionFind(n int) *unionFind {
+	p := make([]int, n)
+	size := make([]int, n)
+	for i := range p {
+		p[i] = i
+		size[i] = 1
+	}
+	return &unionFind{p, size}
+}
+
+func (uf *unionFind) find(x int) int {
+	if uf.p[x] != x {
+		uf.p[x] = uf.find(uf.p[x])
+	}
+	return uf.p[x]
+}
+
+func (uf *unionFind) union(a, b int) {
+	pa, pb := uf.find(a), uf.find(b)
+	if pa != pb {
+		if uf.size[pa] > uf.size[pb] {
+			uf.p[pb] = pa
+			uf.size[pa] += uf.size[pb]
+		} else {
+			uf.p[pa] = pb
+			uf.size[pb] += uf.size[pa]
+		}
+	}
+}
+
+func matrixRankTransform(matrix [][]int) [][]int {
+	m, n := len(matrix), len(matrix[0])
+	type pair struct{ i, j int }
+	d := map[int][]pair{}
+	for i, row := range matrix {
+		for j, v := range row {
+			d[v] = append(d[v], pair{i, j})
+		}
+	}
+	rowMax := make([]int, m)
+	colMax := make([]int, n)
+	ans := make([][]int, m)
+	for i := range ans {
+		ans[i] = make([]int, n)
+	}
+	vs := []int{}
+	for v := range d {
+		vs = append(vs, v)
+	}
+	sort.Ints(vs)
+	for _, v := range vs {
+		ps := d[v]
+		uf := newUnionFind(m + n)
+		rank := make([]int, m+n)
+		for _, p := range ps {
+			uf.union(p.i, p.j+m)
+		}
+		for _, p := range ps {
+			i, j := p.i, p.j
+			rank[uf.find(i)] = max(rank[uf.find(i)], max(rowMax[i], colMax[j]))
+		}
+		for _, p := range ps {
+			i, j := p.i, p.j
+			ans[i][j] = 1 + rank[uf.find(i)]
+			rowMax[i], colMax[j] = ans[i][j], ans[i][j]
+		}
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**