547. 省份数量

547. 省份数量
为了正确计算省份的数量，我们需要使用一种方法来识别和合并连通分量。虽然题目要求只使用数组和 Set 或 Map，我们可以使用深度优先搜索（DFS）来实现这一点。

使用 DFS 来计算省份的数量：

DFS +合并连通分量

/**
 * 计算省份的数量
 * @param {number[][]} isConnected 表示省份之间是否直接相连的邻接矩阵
 * @return {number} 返回省份的总数
 */
var findCircleNum = function (isConnected) {
    const n = isConnected.length;
    const visited = new Set();
    let provinceCount = 0;

    // 深度优先搜索函数
    const dfs = (city) => {
        for (let i = 0; i < n; i++) {
            if (isConnected[city][i] === 1 && !visited.has(i)) {
                visited.add(i);
                dfs(i);
            }
        }
    };

    // 遍历每个城市
    for (let i = 0; i < n; i++) {
        if (!visited.has(i)) {
            dfs(i);
            provinceCount++;
        }
    }

    return provinceCount;
};

var isConnected = [
  [1, 1, 0],
  [1, 1, 0],
  [0, 0, 1],
];
console.log(findCircleNum(isConnected)); // 输出 2

代码解释

1. 初始化：

   • n 表示城市的数量。
   • visited 是一个 Set，用于记录已经访问过的城市。
   • provinceCount 用于记录省份的数量。

2. 深度优先搜索 (DFS)：

   • dfs 函数用于从某个城市开始，递归地访问所有直接或间接相连的城市，并将它们标记为已访问。

3. 遍历城市：

   • 对于每个城市，如果它没有被访问过，则从该城市开始进行 DFS，并增加省份计数 provinceCount。

4. 返回结果：

   • 最后返回省份的数量 provinceCount。

这种方法确保了我们能够正确地识别和计算所有的连通分量（省份）。
547. 省份数量

/**
 * 计算城市的数量
 * @param {number[][]} isConnected 表示城市的邻接矩阵
 * @return {number} 返回城市的总数
 */
var findCircleNum = function(isConnected) {
    const len=isConnected.length
    const uf=new UnionFind(len)
    for(let i=0;i<len;i++){
        for(let j=i+1;j<len;j++){
            if(isConnected[i][j]==1){
                uf.union(i,j)
            }
        }
    }
    return uf.count
};

// 定义并查集类
class UnionFind{
    // 构造函数初始化并查集
    constructor(n){
        this.parent = new Array(n).fill(0).map((item,index)=>index)
        this.rank = new Array(n).fill(1)
        this.count = n
    }
    // 查找元素的根节点
    find(x){
        if(this.parent[x] !== x){
            this.parent[x] = this.find(this.parent[x])
        }
        return this.parent[x]
    }
    // 合并两个集合
    union(x,y){
        let rootX = this.find(x)
        let rootY = this.find(y)
        if(rootX === rootY){
            return false
        }
        if(this.rank[rootX] < this.rank[rootY]){
            this.parent[rootX] = rootY
            this.rank[rootY] += this.rank[rootX]
        }else{
            this.parent[rootY] = rootX
            this.rank[rootX] += this.rank[rootY]
        }
        this.count--
    }
    // 判断两个元素是否属于同一个集合
    connected(x,y){
        return this.find(x) === this.find(y)
    }
    // 获取集合的数量
    getCount(){
        return this.count
    }
}

// 测试用例
var isConnected = [[1,1,0],[1,1,0],[0,0,1]]
console.log(findCircleNum(isConnected))