leetcode-947. 移除最多的同行或同列石头之DFS与并查集

题目

这个月是图论月啊，各种并查集和图论算法。。。
各个石头处于同列同行的性质其实就是石头之间的连接关系！要是删除了一个石头，那么由它所发出的边都要删除。而对于一个联通分量来说，是一定最多能删到只剩一个顶点的！因此这题其实就是要求是是有多少个联通分量！
因此需要先根据stones列表来维护各个石头的联通关系，在同一列和同一行的石头都需要建立两两相连的边！然后通过DFS来求分量个数。

class Solution {
public:
    int removeStones(vector<vector<int>>& stones) {
        vector<vector<int>> graph(stones.size(),vector<int>(0,0));
        unordered_map<int,vector<int>> row;
        unordered_map<int,vector<int>> col;
        // 记录了每一行和每一列上有哪些石头
        for(int i=0;i<stones.size();i++){
            row[stones[i][0]].push_back(i);
            col[stones[i][1]].push_back(i);
        } 
		// 维护石头们的连接关系，存放在graph中
        for(auto iter=row.begin();iter!=row.end();iter++){
            for(int i=1;i<iter->second.size();i++){
                graph[iter->second[i]].push_back(iter->second[i-1]);
                graph[iter->second[i-1]].push_back(iter->second[i]);
            }
        }

        for(auto iter=col.begin();iter!=col.end();iter++){
            for(int i=1;i<iter->second.size();i++){
                graph[iter->second[i]].push_back(iter->second[i-1]);
                graph[iter->second[i-1]].push_back(iter->second[i]);
            }
        }

        vector<int> visited(stones.size(), 0);
        int count = 0;
        for(int i=0;i<stones.size();i++){
            if(visited[i] == 0){
                DFS(graph,visited,i);
                count ++;
            }
        }

        return stones.size()-count;
    }

    void DFS(vector<vector<int>>& graph, vector<int>& visited, int taregt){
        if(visited[taregt] == 1)
            return;
        visited[taregt] = 1;
        for(int i=0;i<graph[taregt].size();i++){
            DFS(graph, visited, graph[taregt][i]);
        }
    }
};

而这里使用并查集还是比较难想到的，因为并查集需要维护的是石头的xy坐标的连接关系！比如：
（1，2）和（1，3），这两个石头在同一行1上，那么他们的parent关系需要构造为：1 —> 2 —> 3，这两个石头是联通的
（2，1）和（3，1） ，这两个石头在同一列1上，那么他们的parent关系需要构造为：2 —> 1，3 —> 1，这两个石头也是联通的，因为parent相同！
因此若本题采用并查集的话，判断联通分量个数的方法就是要检查每个石头x坐标的parent的个数！

class Solution {
public:
    int Find(unordered_map<int,int> &parent,int x){
        int x_root = x;
        while(parent.count(x_root) != 0)
            x_root = parent[x_root];
        return x_root;
    }

    void Union(unordered_map<int,int>&parent, int x, int y){
        int x_root = Find(parent,x);
        int y_root = Find(parent,y);
        if(x_root == y_root)
            return;
        else{
            parent[x_root] = y_root;
        }
    }
    int removeStones(vector<vector<int>>& stones) {
        unordered_map<int,int> parent;
        for(int i=0;i<stones.size();i++){
            Union(parent, stones[i][0], stones[i][1]+100000);
        }
        unordered_map<int,int> count;
        for(int i=0;i<stones.size();i++){
            count[Find(parent,stones[i][0])]++;
        }
        return stones.size()-count.size();

    }
};