LeetCode[947]移除最多的同行或同列石头

news2024/11/28 20:51:45

难度：中等

题目：

n 块石头放置在二维平面中的一些整数坐标点上。每个坐标点上最多只能有一块石头。
如果一块石头的同行或者同列上有其他石头存在，那么就可以移除这块石头。
给你一个长度为 n 的数组 stones ，其中 stones[i] = [xi, yi] 表示第 i 块石头的位置，返回可以移除的石子的最大数量。

示例 1：

输入：stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]

输出：5

解释：一种移除 5 块石头的方法如下所示：

1. 移除石头 [2,2] ，因为它和 [2,1] 同行。

2. 移除石头 [2,1] ，因为它和 [0,1] 同列。

3. 移除石头 [1,2] ，因为它和 [1,0] 同行。

4. 移除石头 [1,0] ，因为它和 [0,0] 同列。

5. 移除石头 [0,1] ，因为它和 [0,0] 同行。

石头 [0,0] 不能移除，因为它没有与另一块石头同行/列。

示例 2：

输入：stones = [[0,0],[0,2],[1,1],[2,0],[2,2]]

输出：3

解释：一种移除 3 块石头的方法如下所示：

1. 移除石头 [2,2] ，因为它和 [2,0] 同行。

2. 移除石头 [2,0] ，因为它和 [0,0] 同列。

3. 移除石头 [0,2] ，因为它和 [0,0] 同行。

石头 [0,0] 和 [1,1] 不能移除，因为它们没有与另一块石头同行/列。

示例 3：

输入：stones = [[0,0]]

输出：0

解释：[0,0] 是平面上唯一一块石头，所以不可以移除它。

提示：

1 <= stones.length <= 1000

0 <= xi, yi <= 104

不会有两块石头放在同一个坐标点上

重点！！！解题思路

第一步：

明确解题手段
此种连通性问题我们均可使用并查集来解决

第二步：

使用最暴力最简单的方法就能解决问题
遍历二维数组的每一组石头，如果横纵坐标有一个相同的就使用并查集将他们连接起来
最后石头总数-并查集中的连通分量数=操作次数

源码：

class UnionFind {
    //记录每个节点的根节点
    int[] parent;
    //记录每个子集的节点数
    int[] rank;
    //记录并查集中的联通分量数量
    int count;

    public UnionFind(int n){
        count=n;
        parent=new int[n];
        for (int i=0;i<n;i++){
            parent[i]=i;
        }
        rank=new int[n];
        Arrays.fill(rank,1);
    }

    //路径压缩
    public int find(int ind){
        if (parent[ind]!=ind){
            parent[ind]=find(parent[ind]);
        }
        return parent[ind];
    }

    //按秩合并
    public void unite(int ind1,int ind2){
        int root1=find(ind1),root2=find(ind2);
        if (root1!=root2){
            if (rank[root1]<rank[root2]){
                int temp=root2;
                root2=root1;
                root1=temp;
            }
            parent[root2]=root1;
            rank[root1]+=rank[root2];
            count--;
        }
    }

    public int getCount(){
        return count;
    }
    public boolean connected(int ind1,int ind2){
        return find(ind1)==find(ind2);
    }
}
class Solution {
    public int removeStones(int[][] stones) {
        int sum=stones.length;
        UnionFind uf = new UnionFind(sum);
        for (int i = 0; i < sum; i++) {
            for (int j = i+1; j < sum; j++) {
                int x1=stones[i][0];
                int y1=stones[i][1];
                int x2=stones[j][0];
                int y2=stones[j][1];
                if (x1==x2 || y1==y2){
                    uf.unite(i,j);
                }
            }
        }
        return sum- uf.getCount();
    }
}

运行结果：