1632. 矩阵转换后的秩
给你一个 m x n 的矩阵 matrix ，请你返回一个新的矩阵 answer ，其中 answer[row][col] 是 matrix[row][col] 的秩。
每个元素的 秩 是一个整数，表示这个元素相对于其他元素的大小关系，它按照如下规则计算：
- 秩是从 1 开始的一个整数。
- 如果两个元素
p 和q 在同一行或者同一列，那么：
- 如果
p < q ，那么rank(p) < rank(q) - 如果
p == q ，那么rank(p) == rank(q) - 如果
p > q ，那么rank(p) > rank(q)
- 秩需要越小越好。
题目保证按照上面规则 answer 数组是唯一的。
示例 1：
输入：matrix = [[1,2],[3,4]] 输出：[[1,2],[2,3]] 解释： matrix[0][0] 的秩为 1 ，因为它是所在行和列的最小整数。 matrix[0][1] 的秩为 2 ，因为 matrix[0][1] > matrix[0][0] 且 matrix[0][0] 的秩为 1 。 matrix[1][0] 的秩为 2 ，因为 matrix[1][0] > matrix[0][0] 且 matrix[0][0] 的秩为 1 。 matrix[1][1] 的秩为 3 ，因为 matrix[1][1] > matrix[0][1]， matrix[1][1] > matrix[1][0] 且 matrix[0][1] 和 matrix[1][0] 的秩都为 2 。
示例 2：
输入：matrix = [[7,7],[7,7]] 输出：[[1,1],[1,1]]
示例 3：
输入：matrix = [[20,-21,14],[-19,4,19],[22,-47,24],[-19,4,19]] 输出：[[4,2,3],[1,3,4],[5,1,6],[1,3,4]]
示例 4：
输入：matrix = [[7,3,6],[1,4,5],[9,8,2]] 输出：[[5,1,4],[1,2,3],[6,3,1]]
提示：
-
m == matrix.length -
n == matrix[i].length -
1 <= m, n <= 500 -
-1e9 <= matrix[row][col] <= 1e9
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/rank-transform-of-a-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
做题结果
成功，不过写了好久，好几个小时。开始的做法是 图+拓扑，发现有问题，会不满足同行同列一起变化的条件。更换了思路，变成并查集+排序最终通过
方法：并查集+排序
1. 并查集并在哪里？这题用并查集是藏的很好的。它的并在于相同数字的行列值相同，这意味着，他们需要一起改变。数组中完全有可能有多个转角，从而达成间接关系，而一起改变。如图，多个3可以一起改变，但是并不是值相同一定一起改变。红色的3和其他3的行列都不相同，因此，不和其他3一起改变。因此我们需要根据值和位置进行分组，于是就用到了并查集。
class Solution {
int[] parent;
int[] sizes;
public int[][] matrixRankTransform(int[][] matrix) {
int m = matrix.length;
int n = matrix[0].length;
int[][] ans = new int[m][n];
parent = new int[m*n];
sizes = new int[m*n];
for(int i = 0; i < m*n; i++){
parent[i] = i;
sizes[i] = 1;
}
//并查集
for(int i = 0; i < m; i++){
Map<Integer,Integer> map = new HashMap<>();
for(int j = 0; j < n; j++){
if(map.containsKey(matrix[i][j])) connect(map.get(matrix[i][j]),i*n+j);
else map.put(matrix[i][j],i*n+j);
}
}
for(int j = 0; j < n; j++){
Map<Integer,Integer> map = new HashMap<>();
for(int i = 0; i < m; i++){
if(map.containsKey(matrix[i][j])) connect(map.get(matrix[i][j]),i*n+j);
else map.put(matrix[i][j],i*n+j);
}
}
Set<Integer>[] cnt = new HashSet[m*n];
Arrays.setAll(cnt,o->new HashSet<>());
for(int i = 0; i < m*n; i++){
int p = root(i);
cnt[p].add(i);
}
List<Integer> list = new ArrayList<>();
for(int i = 0; i < m*n; i++) list.add(i);
list.sort((a,b)->matrix[a/n][a%n]-matrix[b/n][b%n]);
int[] mlines = new int[m];
int[] mcols = new int[n];
for(int i = 0; i < m*n; i++){
int id = list.get(i);
int x = id/n;
int y = id%n;
//System.out.println(matrix[x][y]);
int rid = root(id);
sizes[rid]--;
if(sizes[rid]==0){
int value = 0;
for(Integer item:cnt[rid]){
value = Math.max(Math.max(mlines[item/n]+1,mcols[item%n]+1),value);
}
for(Integer item:cnt[rid]){
ans[item/n][item%n]=value;
mlines[item/n]=value;
mcols[item%n]=value;
}
}
}
return ans;
}
private void connect(int a, int b){
int ra = root(a);
int rb = root(b);
if(ra==rb) return;
if(sizes[ra]>=sizes[rb]){
parent[rb] = ra;
sizes[ra] += sizes[rb];
}else{
parent[ra] = rb;
sizes[rb] += sizes[ra];
}
}
private int root(int a){
while(parent[a]!=a){
parent[a] = parent[parent[a]];
a = parent[a];
}
return a;
}
}
2. 分组后的处理。小的数字一定要分配更小的值，大的数字一定分配更大的值，因此，我们完全可以把所有元素的行列索引，按照从小到大排序，依次放入。
3. 相同值是需要一起放入的。所以当一个值完成放置后，需要处理对应并查集位置-1，当所有并查集元素都完成放入操作后，即可填写这一组并查集元素的值。
4. 每次填好id后，更新对应行列的最大id。后续放入的值是并查集的所有元素，行列填入的最大值+1。原因是这些元素必须要填写相同的值，又要保证不同元素值不同。
