从小白开始刷算法 并查集篇 leetcode.547

序言

虽然算法很难，但不应该就放弃。这是一个学习笔记，希望你们喜欢~

先自己尝试写，大概十几分钟仍然写不出来
看思路，再尝试跟着思路写
仍然写不出来，再看视频
b站up视频推荐：爱学习的饲养员

leetcode其他文章：

数组篇：
从小白开始刷算法 数组篇 leetcode.485
从小白开始刷算法 数组篇 leetcode.283
从小白开始刷算法 数组篇 leetcode.27

链表篇：
从小白开始刷算法 ListNode 链表篇 leetcode.203
从小白开始刷算法 ListNode 链表篇 leetcode.206

队列篇
从小白开始刷算法 ListNode 链表篇 leetcode.933

栈篇
从小白开始刷算法 Stack 栈篇 leetcode.20
从小白开始刷算法 Stack 栈篇 leetcode.496

哈希篇
从小白开始刷算法 Hash 哈希篇 leetcode.217
从小白开始刷算法 Hash 哈希篇 leetcode.705

树篇
从小白开始刷算法 Tree 树篇 先序遍历 leetcode.144
从小白开始刷算法 Tree 树篇 中序遍历 leetcode.94
从小白开始刷算法 Tree 树篇 后序遍历 leetcode.94

堆篇
从小白开始刷算法 Heap 堆篇 最大堆排序 leetcode.215
小白开始刷算法 Heap 堆篇 最小堆排序 leetcode.692

双指针篇
从小白开始刷算法 对撞双指针 leetcode.881
从小白开始刷算法 快慢双指针篇 leetcode.141

二分法篇
从小白开始刷算法 二分法篇 leetcode.704
从小白开始刷算法 二分法篇 leetcode.35
从小白开始刷算法 二分法篇 leetcode.162
从小白开始刷算法 二分法篇 leetcode.74

滑动窗口篇
从小白开始刷算法 滑动窗口篇 leetcode.209
从小白开始刷算法 滑动窗口篇 leetcode.1456

递归篇
从小白开始刷算法 递归篇 leetcode.509
从小白开始刷算法 递归篇 leetcode.206

分治法篇
从小白开始刷算法 分治法篇 leetcode.169
从小白开始刷算法 分治法篇 leetcode.53

回溯法篇
从小白开始刷算法 回溯法篇 leetcode.22
从小白开始刷算法 回溯法篇 leetcode.78

dfs篇
从小白开始刷算法 dfs篇 leetcode.938
从小白开始刷算法 dfs篇 leetcode.200

bfs篇
从小白开始刷算法 bfs篇 leetcode.102

并查集篇
从小白开始刷算法 并查集篇 leetcode.200

并查集篇

难度：中等

题目：

547. 省份数量

有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。

省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。

给你一个 n x n 的矩阵 isConnected ，其中isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。

返回矩阵中 省份 的数量。

示例 1：

输入：isConnected = [[1,1,0],[1,1,0],[0,0,1]]
输出：2
示例 2：

输入：isConnected = [[1,0,0],[0,1,0],[0,0,1]]
输出：3

题目来源：力扣（LeetCode）

并查集思路

能否写出：能写出，小参考了思路。

时间：半个小时起步

思路：

大体与从小白开始刷算法 并查集篇 leetcode.200一样

首先，我们可以将每个城市看作并查集中的一个节点。初始时，每个城市都是一个独立的集合。然后，遍历矩阵 isConnected，如果两个城市之间有直接连接（即 isConnected[i][j] = 1），则将它们合并到同一个集合中。最后，统计并查集中的根节点数量，即为省份的数量。

具体的步骤如下：

1. 初始化并查集，将每个城市都初始化为一个独立的集合。
2. 遍历矩阵 isConnected，对于每个连接的城市对 (i, j)，将它们所在的集合进行合并，即调用并查集的 union 方法。
3. 统计并查集中的根节点数量，即为省份的数量。

// 仅是我的思路代码，leetcode上大神更厉害
class Solution {
    public static int findCircleNum(int[][] isConnected) {
        int n = isConnected.length;
        UnionFind union = new UnionFind(isConnected.length);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (isConnected[i][j] == 1) {
                    union.union(i, j);
                }
            }
        }
        return union.getCount();
    }
}

class UnionFind {
    int[] parent;
    int count;

    public UnionFind(int size) {
        parent = new int[size];
        count = size;
        for (int i = 0; i < size; i++) {
            parent[i] = i;
        }
    }

    public int find(int x) {
        if (parent[x] == x) {
            return x;
        }
        return parent[x] = find(parent[x]);
    }

    public void union(int x, int y) {
        int parentX = find(x);
        int parentY = find(y);
        if (parentX != parentY) {
            parent[parentX] = parentY;
            count--;
        }
    }

    public int getCount() {
        return count;
    }
}

时间复杂度：O(N^2)

• 对于给定的n个城市，使用两层循环遍历所有城市对，时间复杂度为O(n^2)。
• 在并查集中，每次查找和合并操作的时间复杂度都可以近似看作O(1)，因此总体时间复杂度为O(n^2)。

空间复杂度：O(N)

• 使用了一个大小为n的数组来存储每个城市的父节点，因此空间复杂度为O(n)。