LeetCode-Day96(C++) 547. 省份数量

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]
输出：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]

可以把 n 一个城市和它们之间的关系被视为图片，城市是图片中的节点，连接是图片中的边缘，给定的矩阵 isConnected 即图中的邻接矩阵，省份为图中的连接重量。

计算省总数，等同于计算图中的连接分量，可通过深度优先搜索或广度优先搜索或收集实现。

方法1：深度优先搜索
深度优先搜索的思路非常直观。遍历所有城市，对于每个城市，如果这个城市还没有被访问，通过矩阵从这个城市开始深入搜索 isConnected 与城市直接相连的城市是什么？这些城市和城市属于相同的连接重量，然后继续深入搜索这些城市，直到所有相同连接重量的城市都被访问，你可以得到一个省。遍历所有城市后，可获得连通重量总数，即省份总数。

class Solution { 
        public:     void dfs(vector<vector<int>>& isConnected, vector<int>& visited, int provinces, int i) { 
                for (int j = 0; j < provinces; j ) { 
                    if (isConnected[i][j] == 1 && !visited[j]) { 
                        visited[j] = 1;                 dfs(isConnected, visited, provinces, j);             }         }     }      int findCircleNum(vector<vector<int>>& isConnected) { 
                int provinces = isConnected.();
        vector<int> visited(provinces);
        int circles = 0;
        for (int i = 0; i < provinces; i++) { 
       
            if (!visited[i]) { 
       
                dfs(isConnected, visited, provinces, i);
                circles++;
            }
        }
        return circles;
    }
};

复杂度分析

时间复杂度：O(n^2)，其中 n 是城市的数量。需要遍历矩阵 n 中的每个元素。

空间复杂度：O(n)，其中 n 是城市的数量。需要使用数组 visited 记录每个城市是否被访问过，数组长度是 n，递归调用栈的深度不会超过 n。

方法二：广度优先搜索
也可以通过广度优先搜索的方法得到省份的总数。对于每个城市，如果该城市尚未被访问过，则从该城市开始广度优先搜索，直到同一个连通分量中的所有城市都被访问到，即可得到一个省份。

class Solution { 
       
public:
    int findCircleNum(vector<vector<int>>& isConnected) { 
       
        int provinces = isConnected.size();
        vector<int> visited(provinces);
        int circles = 0;
        queue<int> Q;
        for (int i = 0; i < provinces; i++) { 
       
            if (!visited[i]) { 
       
                Q.push(i);
                while (!Q.empty()) { 
       
                    int j = Q.front(); Q.pop();
                    visited[j] = 1;
                    for (int k = 0; k < provinces; k++) { 
       
                        if (isConnected[j][k] == 1 && !visited[k]) { 
       
                            Q.push(k);
                        }
                    }
                }
                circles++;
            }
        }
        return circles;
    }
};

复杂度分析

时间复杂度：O(n^2)，其中 n 是城市的数量。需要遍历矩阵 isConnected 中的每个元素。

空间复杂度：O(n)，其中 n 是城市的数量。需要使用数组 visited 记录每个城市是否被访问过，数组长度是 n，广度优先搜索使用的队列的元素个数不会超过 n。

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/number-of-provinces/solution/sheng-fen-shu-liang-by-leetcode-solution-eyk0/