547. Friend Circles

▶ 将一群人的关系网络划分为几个连通子图，且子图之间两两不连通，求这种连通子图的数量

● 代码，22 ms，深度优先遍历

class Solution
{
public:
    void dfs(int root, vector<vector<int>>& M, vector<bool>& noVisited)
    {
        noVisited[root] = false;
        for (int i = 0; i < noVisited.size(); i++)
        {
            if (root != i && M[root][i] && noVisited[i])
                dfs(i, M, noVisited);
        }
    }
    int findCircleNum(vector<vector<int>>& M)
    {
        const int n = M.size();
        if (!n)
            return 0;
        int i, group;
        vector<bool> noVisited(n, true);
        for (i = group = 0; i < n; i++)
            group += noVisited[i] ? (dfs(i, M, noVisited), 1) : 0;
        return group;
    }
};

● 代码，21 ms，建立森林，并且定义了专用于这类合并问题的类 UnionFind，本问题中可以完全去掉节点等级变量 rank

class UnionFind
{
private:
    int cnt;
    vector<int> parent, rank;
public:
    UnionFind(int n)
    {
        cnt = n;
        parent = vector<int>(n, 0);
        rank = vector<int>(n,0);
        for (int i = 0; i < n; i++)
            parent[i] = i;            
    }
    int find(int p)
    {
        for (; p != parent[p]; parent[p] = parent[parent[p]], p = parent[p]);                
        return p;
    }
    void unionOperate(int p, int q)
    {
        int rootP = find(p), rootQ = find(q);// 找到 p 和 q 的源
        if (rootP == rootQ)                  // 同源，相当于已经合并完成
            return;
        if (rank[rootQ] > rank[rootP])       // rootQ 的级数比较高，把 rootP 挂到 rootQ 上
            parent[rootP] = rootQ;
        else
        {
            parent[rootQ] = rootP;           // rootQ 挂到 rootP 上
            if (rank[rootP] == rank[rootQ])  // 同层合并，把其中一个升一级
                rank[rootP]++;
        }
        cnt--;
    }
    int count() { return cnt; }
};

class Solution
{
public:    
    int findCircleNum(vector<vector<int>> M)
    {
        int n = M.size();
        UnionFind uf(n);
        for (int i = 0; i < n - 1; i++)
        {
            for (int j = i + 1; j < n; j++)
                if (M[i][j] == 1) uf.unionOperate(i, j);
        }
        return uf.count();
    }
};

● 广度优先遍历，24 ms

class Solution
{
public:
    int findCircleNum(vector<vector<int>>& M)
    {
        int i, count;
        for (i = count = 0; i < M.size(); i++)
            count += (M[i][i] == 1) ? (BFS(i, M), 1) : 0;
        return count;
    }
    void BFS(int root, vector<vector<int>>& M)
    {
        queue<int> qq;
        int i, j, k;
        for(qq.push(root);qq.size() > 0;)
        {
            for (i = 0; i < qq.size(); i++)
            {
                j = qq.front(), qq.pop();                             
                for (M[j][j] = 2, k = 0; k < M[0].size(); k++)  // M[j][j] = 2 标记为已遍历
                {
                    if (M[j][k] == 1 && M[k][k] == 1)
                        qq.push(k);
                }
            }
        }
    }
};

● 收录两个 python 的算法，分别为 201 ms 和 240 ms，已经是内置函数了

import scipy.sparse
class Solution(object) :
    def findCircleNum(self, M) :
        return scipy.sparse.csgraph.connected_components(M)[0]

import numpy as np
class Solution(object) :
    def findCircleNum(self, M) :
        return len(set(map(tuple, (np.matrix(M, dtype = 'bool')**len(M)).A)))