Leetcode547

题目描述

有 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

提示：

• 1 <= n <= 200
• n == isConnected.length
• n == isConnected[i].length
• isConnected[i][j] 为 1 或 0
• isConnected[i][i] == 1
• isConnected[i][j] == isConnected[j][i]

算法

1.深度优先遍历

时间复杂度$O(n^2)$其中n为矩阵宽度.这道题实际上求的是连通块中点的数量,我们只需要建图,然后遍历即可.需要注意为无向图,建两次即可

这道题实际上是邻接表转图,写一个二维遍历即可,再用一个vis数组判重即可

class Solution {
public:
    vector<bool> vis;
    vector<vector<int>> g;
    int findCircleNum(vector<vector<int>>& isConnected) {
        int n = isConnected.size();
        g.resize(n, vector<int>());
        vis.resize(n, false);
        for(int i = 0; i < n; i ++) {
            for(int j = 0; j < n; j ++) {
                if(isConnected[i][j])
                    g[i].push_back(j);
            }
        }
        
        int cnt = 0;
        for(int i = 0; i < n; i ++) {
            if(!vis[i]) {
                cnt ++;
                dfs(i);
            }
        }
        return cnt;
    }
    
    void dfs(int u) {
        vis[u] = true;
        for(int i = 0; i < g[u].size(); i ++) {
            int v = g[u][i];
            if(!vis[v])
                dfs(v);
        }
    }
};

2.宽度优先遍历

遍历图也可以使用宽度优先算法,时间复杂度也是$O(n^2)$,具体代码如下

class Solution {
public:
    vector<bool> vis;
    vector<vector<int>> g;
    int findCircleNum(vector<vector<int>>& isConnected) {
        int n = isConnected.size();
        g.resize(n, vector<int>());
        vis.resize(n, false);
        for(int i = 0; i < n; i ++) {
            for(int j = 0; j < n; j ++) {
                if(isConnected[i][j])
                    g[i].push_back(j);
            }
        }
        
        int cnt = 0;
        for(int i = 0; i < n; i ++) {
            if(!vis[i]) {
                cnt ++;
                bfs(i);
            }
        }
        return cnt;
    }
    
    void bfs(int u) {
        queue<int> q;
        q.push(u);
        vis[u] = true;
        while(!q.empty()) {
            int cur = q.front();
            q.pop();
            for(int i = 0; i < g[cur].size(); i ++) {
                int v = g[cur][i];
                if(!vis[v]) {
                    q.push(v);
                    vis[v] = true;
                }
            }
        }
    }
};

3.并查集

我们可以把所有有关系的点,连到一起,形成集合.记录合并的数量,用总数减去合并的数量就是答案,时间复杂度$O(n^2)$

class Solution {
public:
    vector<int> p;
    int find(int x)
    {
        if(p[x] != x)   p[x] = find(p[x]);
        return p[x];
    }
    int findCircleNum(vector<vector<int>>& isConnected) {
        int cnt = isConnected.size();
        int n = isConnected.size();
        for(int i = 0; i < n; i ++)
            p.push_back(i);
        for(int i = 0; i < n; i ++)
        {
            for(int j = 0; j < n; j ++)
            {
                if(isConnected[i][j] && find(i) != find(j))
                {
                    cnt --;
                    p[find(i)] = find(j);
                }
            }
        }
        return cnt;
    }
};