描述
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] 是平面上唯一一块石头，所以不可以移除它。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/most-stones-removed-with-same-row-or-column/
求解
// 使用散列表实现一个动态增加的并查集
class VarUnionFind {
private:
unordered_map<int, int> parent;
unordered_map<int, int> rank;
public:
int find(int p) {
if (parent.count(p) == 0) {
// 如果p在散列表中不存在，则添加进去
parent[p] = p;
return p;
}
while (p != parent[p]) {
parent[p] = parent[parent[p]];
p = parent[p];
}
return p;
}
void unionElements(int p, int q) {
int pRoot = find(p);
int qRoot = find(q);
if (pRoot == qRoot) {
return;
}
if (rank[pRoot] < rank[qRoot]) {
parent[pRoot] = qRoot;
return;
}
if (rank[pRoot] > rank[qRoot]) {
parent[qRoot] = pRoot;
return;
}
// rank[pRoot] == rank[qRoot]
parent[pRoot] = qRoot;
++rank[qRoot];
}
// 返回并查集的连通分量
int getConnectedComponent() {
int count = 0;
for (auto &[p, root] : parent) {
if (p == root) {
++count;
}
}
return count;
}
};
class Solution {
public:
// 方法一，使用并查集，求取连通分量，通过分析可知，每个连通分量通过不停的粉碎可以只剩下一块石头
// 则结果为n - 连通分量个数
int removeStones_useUnionFind(vector<vector<int>> &stones) {
const int OFFSET = 100001; // 纵坐标的偏移量，为了不跟横坐标重合的冲突
VarUnionFind uf;
for (auto &vec : stones) {
uf.unionElements(vec[0], vec[1] + OFFSET);
}
// 石头数量减去并查集的连通分量即为可以粉碎的最大数量石头
return stones.size() - uf.getConnectedComponent();
}
// 方法二，深度遍历图得到连通分量，这里将每块石头看做图的一个结点，通过观察是否在同行或者同列来确定是否有边相连，
// 最后通过深度遍历计算连通分量，则结果为n - 连通分量个数
int removeStones_useDFS1e(vector<vector<int>> &stones) {
const int n = stones.size();
vector<vector<int>> edges(n, vector<int>()); // 邻接表存储图
// 构造图
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; j++) {
if (stones[i][0] == stones[j][0] || stones[i][1] == stones[j][1]) {
edges[i].push_back(j);
edges[j].push_back(i); // 构造一个无向图
}
}
}
// 深度遍历，求取连通分量
int count = 0; // 连通分量初始化为0
visited.assign(n, false); // 结点访问标记初始化
for (int i = 0; i < n; ++i) {
if (!visited[i]) {
++count;
dfs(edges, i);
}
}
return n - count;
}
// 方法三，方法二建图部分时间复杂度为O(N*N)，进行优化，将同行或者同列的石头放一起，再进行建图
int removeStones(vector<vector<int>> &stones) {
const int n = stones.size();
const int OFFSET = 100001; // 纵坐标的偏移量，为了不跟横坐标重合的冲突
unordered_map<int, vector<int>> record;
// 计算每个行或者列上有哪些石头（图节点）
for (int i = 0; i < n; ++i) {
record[stones[i][0]].emplace_back(i); // 在横坐标stones[i][0]上有石头i（即图节点i ）
record[stones[i][1] + OFFSET].emplace_back(i); // 在横坐标stones[i][1] + OFFSET上有石头i（即图节点i ）
}
// 构造图
vector<vector<int>> edges(n, vector<int>()); // 邻接表构造图
for (auto &[_, vec] : record) {
int k = vec.size();
for (int i = 1; i < k; ++i) {
// 在同行或者同列的节点肯定相连，注意无向图的处理
edges[vec[i - 1]].emplace_back(vec[i]);
edges[vec[i]].emplace_back(vec[i - 1]);
}
}
// 深度遍历，求取连通分量
int count = 0; // 连通分量初始化为0
visited.assign(n, false); // 结点访问标记初始化
for (int i = 0; i < n; ++i) {
if (!visited[i]) {
++count;
dfs(edges, i);
}
}
return n - count;
}
private:
// 图的深度遍历
void dfs(const vector<vector<int>> &edges, int v) {
visited[v] = true;
const auto &adjPoints = edges[v];
for (auto w : adjPoints) {
if (!visited[w]) {
dfs(edges, w);
}
}
}
// 图结点是否访问标志，用于辅助遍历
vector<bool> visited;
};