feat: update solutions to lc problem: No.1632

yanglbme · yanglbme · commit ecc9aa7234d0 · 2023-01-25T22:05:38.000+08:00
No.1632.Rank Transform of a Matrix
diff --git a/solution/1600-1699/1632.Rank Transform of a Matrix/README.md b/solution/1600-1699/1632.Rank Transform of a Matrix/README.md
@@ -111,6 +111,10 @@ class UnionFind:
                 self.p[pa] = pb
                 self.size[pb] += self.size[pa]
 
+    def reset(self, x):
+        self.p[x] = x
+        self.size[x] = 1
+
 
 class Solution:
     def matrixRankTransform(self, matrix: List[List[int]]) -> List[List[int]]:
@@ -122,15 +126,18 @@ class Solution:
         row_max = [0] * m
         col_max = [0] * n
         ans = [[0] * n for _ in range(m)]
+        uf = UnionFind(m + n)
         for v in sorted(d):
-            uf = UnionFind(m + n)
             rank = defaultdict(int)
             for i, j in d[v]:
                 uf.union(i, j + m)
             for i, j in d[v]:
                 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[uf.find(i)]
+            for i, j in d[v]:
+                uf.reset(i)
+                uf.reset(j + m)
         return ans
 ```
 
@@ -171,6 +178,11 @@ class UnionFind {
             }
         }
     }
+
+    public void reset(int x) {
+        p[x] = x;
+        size[x] = 1;
+    }
 }
 
 
@@ -186,9 +198,9 @@ class Solution {
         int[] rowMax = new int[m];
         int[] colMax = new int[n];
         int[][] ans = new int[m][n];
+        UnionFind uf = new UnionFind(m + n);
+        int[] rank = new int[m + n];
         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);
             }
@@ -202,6 +214,10 @@ class Solution {
                 rowMax[i] = ans[i][j];
                 colMax[j] = ans[i][j];
             }
+            for (var p : ps) {
+                uf.reset(p[0]);
+                uf.reset(p[1] + m);
+            }
         }
         return ans;
     }
@@ -239,6 +255,11 @@ public:
         return p[x];
     }
 
+    void reset(int x) {
+        p[x] = x;
+        size[x] = 1;
+    }
+
 private:
     vector<int> p, size;
 };
@@ -256,9 +277,9 @@ public:
         vector<int> rowMax(m);
         vector<int> colMax(n);
         vector<vector<int>> ans(m, vector<int>(n));
+        UnionFind uf(m + n);
+        vector<int> rank(m + n);
         for (auto& [_, ps] : d) {
-            UnionFind uf(m + n);
-            vector<int> rank(m + n);
             for (auto& [i, j] : ps) {
                 uf.unite(i, j + m);
             }
@@ -268,6 +289,10 @@ public:
             for (auto& [i, j] : ps) {
                 ans[i][j] = rowMax[i] = colMax[j] = 1 + rank[uf.find(i)];
             }
+            for (auto& [i, j] : ps) {
+                uf.reset(i);
+                uf.reset(j + m);
+            }
         }
         return ans;
     }
@@ -311,6 +336,11 @@ func (uf *unionFind) union(a, b int) {
 	}
 }
 
+func (uf *unionFind) reset(x int) {
+	uf.p[x] = x
+	uf.size[x] = 1
+}
+
 func matrixRankTransform(matrix [][]int) [][]int {
 	m, n := len(matrix), len(matrix[0])
 	type pair struct{ i, j int }
@@ -331,10 +361,10 @@ func matrixRankTransform(matrix [][]int) [][]int {
 		vs = append(vs, v)
 	}
 	sort.Ints(vs)
+	uf := newUnionFind(m + n)
+	rank := make([]int, m+n)
 	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)
 		}
@@ -347,6 +377,10 @@ func matrixRankTransform(matrix [][]int) [][]int {
 			ans[i][j] = 1 + rank[uf.find(i)]
 			rowMax[i], colMax[j] = ans[i][j], ans[i][j]
 		}
+		for _, p := range ps {
+			uf.reset(p.i)
+			uf.reset(p.j + m)
+		}
 	}
 	return ans
 }
diff --git a/solution/1600-1699/1632.Rank Transform of a Matrix/README_EN.md b/solution/1600-1699/1632.Rank Transform of a Matrix/README_EN.md
@@ -86,6 +86,10 @@ class UnionFind:
                 self.p[pa] = pb
                 self.size[pb] += self.size[pa]
 
+    def reset(self, x):
+        self.p[x] = x
+        self.size[x] = 1
+
 
 class Solution:
     def matrixRankTransform(self, matrix: List[List[int]]) -> List[List[int]]:
@@ -97,15 +101,18 @@ class Solution:
         row_max = [0] * m
         col_max = [0] * n
         ans = [[0] * n for _ in range(m)]
+        uf = UnionFind(m + n)
         for v in sorted(d):
-            uf = UnionFind(m + n)
             rank = defaultdict(int)
             for i, j in d[v]:
                 uf.union(i, j + m)
             for i, j in d[v]:
                 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[uf.find(i)]
+            for i, j in d[v]:
+                uf.reset(i)
+                uf.reset(j + m)
         return ans
 ```
 
@@ -144,6 +151,11 @@ class UnionFind {
             }
         }
     }
+
+    public void reset(int x) {
+        p[x] = x;
+        size[x] = 1;
+    }
 }
 
 
@@ -159,9 +171,9 @@ class Solution {
         int[] rowMax = new int[m];
         int[] colMax = new int[n];
         int[][] ans = new int[m][n];
+        UnionFind uf = new UnionFind(m + n);
+        int[] rank = new int[m + n];
         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);
             }
@@ -175,6 +187,10 @@ class Solution {
                 rowMax[i] = ans[i][j];
                 colMax[j] = ans[i][j];
             }
+            for (var p : ps) {
+                uf.reset(p[0]);
+                uf.reset(p[1] + m);
+            }
         }
         return ans;
     }
@@ -212,6 +228,11 @@ public:
         return p[x];
     }
 
+    void reset(int x) {
+        p[x] = x;
+        size[x] = 1;
+    }
+
 private:
     vector<int> p, size;
 };
@@ -229,9 +250,9 @@ public:
         vector<int> rowMax(m);
         vector<int> colMax(n);
         vector<vector<int>> ans(m, vector<int>(n));
+        UnionFind uf(m + n);
+        vector<int> rank(m + n);
         for (auto& [_, ps] : d) {
-            UnionFind uf(m + n);
-            vector<int> rank(m + n);
             for (auto& [i, j] : ps) {
                 uf.unite(i, j + m);
             }
@@ -241,6 +262,10 @@ public:
             for (auto& [i, j] : ps) {
                 ans[i][j] = rowMax[i] = colMax[j] = 1 + rank[uf.find(i)];
             }
+            for (auto& [i, j] : ps) {
+                uf.reset(i);
+                uf.reset(j + m);
+            }
         }
         return ans;
     }
@@ -284,6 +309,11 @@ func (uf *unionFind) union(a, b int) {
 	}
 }
 
+func (uf *unionFind) reset(x int) {
+	uf.p[x] = x
+	uf.size[x] = 1
+}
+
 func matrixRankTransform(matrix [][]int) [][]int {
 	m, n := len(matrix), len(matrix[0])
 	type pair struct{ i, j int }
@@ -304,10 +334,10 @@ func matrixRankTransform(matrix [][]int) [][]int {
 		vs = append(vs, v)
 	}
 	sort.Ints(vs)
+	uf := newUnionFind(m + n)
+	rank := make([]int, m+n)
 	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)
 		}
@@ -320,6 +350,10 @@ func matrixRankTransform(matrix [][]int) [][]int {
 			ans[i][j] = 1 + rank[uf.find(i)]
 			rowMax[i], colMax[j] = ans[i][j], ans[i][j]
 		}
+		for _, p := range ps {
+			uf.reset(p.i)
+			uf.reset(p.j + m)
+		}
 	}
 	return ans
 }
diff --git a/solution/1600-1699/1632.Rank Transform of a Matrix/Solution.cpp b/solution/1600-1699/1632.Rank Transform of a Matrix/Solution.cpp
@@ -26,6 +26,11 @@ class UnionFind {
         return p[x];
     }
 
+    void reset(int x) {
+        p[x] = x;
+        size[x] = 1;
+    }
+
 private:
     vector<int> p, size;
 };
@@ -43,9 +48,9 @@ class Solution {
         vector<int> rowMax(m);
         vector<int> colMax(n);
         vector<vector<int>> ans(m, vector<int>(n));
+        UnionFind uf(m + n);
+        vector<int> rank(m + n);
         for (auto& [_, ps] : d) {
-            UnionFind uf(m + n);
-            vector<int> rank(m + n);
             for (auto& [i, j] : ps) {
                 uf.unite(i, j + m);
             }
@@ -55,6 +60,10 @@ class Solution {
             for (auto& [i, j] : ps) {
                 ans[i][j] = rowMax[i] = colMax[j] = 1 + rank[uf.find(i)];
             }
+            for (auto& [i, j] : ps) {
+                uf.reset(i);
+                uf.reset(j + m);
+            }
         }
         return ans;
     }
diff --git a/solution/1600-1699/1632.Rank Transform of a Matrix/Solution.go b/solution/1600-1699/1632.Rank Transform of a Matrix/Solution.go
@@ -32,6 +32,11 @@ func (uf *unionFind) union(a, b int) {
 	}
 }
 
+func (uf *unionFind) reset(x int) {
+	uf.p[x] = x
+	uf.size[x] = 1
+}
+
 func matrixRankTransform(matrix [][]int) [][]int {
 	m, n := len(matrix), len(matrix[0])
 	type pair struct{ i, j int }
@@ -52,10 +57,10 @@ func matrixRankTransform(matrix [][]int) [][]int {
 		vs = append(vs, v)
 	}
 	sort.Ints(vs)
+	uf := newUnionFind(m + n)
+	rank := make([]int, m+n)
 	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)
 		}
@@ -68,6 +73,10 @@ func matrixRankTransform(matrix [][]int) [][]int {
 			ans[i][j] = 1 + rank[uf.find(i)]
 			rowMax[i], colMax[j] = ans[i][j], ans[i][j]
 		}
+		for _, p := range ps {
+			uf.reset(p.i)
+			uf.reset(p.j + m)
+		}
 	}
 	return ans
 }
diff --git a/solution/1600-1699/1632.Rank Transform of a Matrix/Solution.java b/solution/1600-1699/1632.Rank Transform of a Matrix/Solution.java
@@ -30,6 +30,11 @@ public void union(int a, int b) {
             }
         }
     }
+
+    public void reset(int x) {
+        p[x] = x;
+        size[x] = 1;
+    }
 }
 
 
@@ -45,9 +50,9 @@ public int[][] matrixRankTransform(int[][] matrix) {
         int[] rowMax = new int[m];
         int[] colMax = new int[n];
         int[][] ans = new int[m][n];
+        UnionFind uf = new UnionFind(m + n);
+        int[] rank = new int[m + n];
         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);
             }
@@ -61,6 +66,10 @@ public int[][] matrixRankTransform(int[][] matrix) {
                 rowMax[i] = ans[i][j];
                 colMax[j] = ans[i][j];
             }
+            for (var p : ps) {
+                uf.reset(p[0]);
+                uf.reset(p[1] + m);
+            }
         }
         return ans;
     }
diff --git a/solution/1600-1699/1632.Rank Transform of a Matrix/Solution.py b/solution/1600-1699/1632.Rank Transform of a Matrix/Solution.py

Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,11 @@ func (uf *unionFind) union(a, b int) {`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
	`35`	`+func (uf *unionFind) reset(x int) {`
	`36`	`+ uf.p[x] = x`
	`37`	`+ uf.size[x] = 1`
	`38`	`+}`
	`39`	`+`
`35`	`40`	`func matrixRankTransform(matrix [][]int) [][]int {`
`36`	`41`	`m, n := len(matrix), len(matrix[0])`
`37`	`42`	`type pair struct{ i, j int }`
`@@ -52,10 +57,10 @@ func matrixRankTransform(matrix [][]int) [][]int {`
`52`	`57`	`vs = append(vs, v)`
`53`	`58`	`}`
`54`	`59`	`sort.Ints(vs)`
	`60`	`+ uf := newUnionFind(m + n)`
	`61`	`+ rank := make([]int, m+n)`
`55`	`62`	`for _, v := range vs {`
`56`	`63`	`ps := d[v]`
`57`		`- uf := newUnionFind(m + n)`
`58`		`- rank := make([]int, m+n)`
`59`	`64`	`for _, p := range ps {`
`60`	`65`	`uf.union(p.i, p.j+m)`
`61`	`66`	`}`
`@@ -68,6 +73,10 @@ func matrixRankTransform(matrix [][]int) [][]int {`
`68`	`73`	`ans[i][j] = 1 + rank[uf.find(i)]`
`69`	`74`	`rowMax[i], colMax[j] = ans[i][j], ans[i][j]`
`70`	`75`	`}`
	`76`	`+ for _, p := range ps {`
	`77`	`+ uf.reset(p.i)`
	`78`	`+ uf.reset(p.j + m)`
	`79`	`+ }`
`71`	`80`	`}`
`72`	`81`	`return ans`
`73`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,11 @@ public void union(int a, int b) {`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`}`
	`33`	`+`
	`34`	`+ public void reset(int x) {`
	`35`	`+ p[x] = x;`
	`36`	`+ size[x] = 1;`
	`37`	`+ }`
`33`	`38`	`}`
`34`	`39`
`35`	`40`
`@@ -45,9 +50,9 @@ public int[][] matrixRankTransform(int[][] matrix) {`
`45`	`50`	`int[] rowMax = new int[m];`
`46`	`51`	`int[] colMax = new int[n];`
`47`	`52`	`int[][] ans = new int[m][n];`
	`53`	`+ UnionFind uf = new UnionFind(m + n);`
	`54`	`+ int[] rank = new int[m + n];`
`48`	`55`	`for (var ps : d.values()) {`
`49`		`- UnionFind uf = new UnionFind(m + n);`
`50`		`- int[] rank = new int[m + n];`
`51`	`56`	`for (var p : ps) {`
`52`	`57`	`uf.union(p[0], p[1] + m);`
`53`	`58`	`}`
`@@ -61,6 +66,10 @@ public int[][] matrixRankTransform(int[][] matrix) {`
`61`	`66`	`rowMax[i] = ans[i][j];`
`62`	`67`	`colMax[j] = ans[i][j];`
`63`	`68`	`}`
	`69`	`+ for (var p : ps) {`
	`70`	`+ uf.reset(p[0]);`
	`71`	`+ uf.reset(p[1] + m);`
	`72`	`+ }`
`64`	`73`	`}`
`65`	`74`	`return ans;`
`66`	`75`	`}`