LeetCode 0547. Number of Provinces Solution in Java, C++, Python & More | Explanation + Code

Description

There are n cities. Some of them are connected, while some are not. If city a is connected directly with city b, and city b is connected directly with city c, then city a is connected indirectly with city c.

A province is a group of directly or indirectly connected cities and no other cities outside of the group.

You are given an n x n matrix isConnected where isConnected[i][j] = 1 if the ith city and the jth city are directly connected, and isConnected[i][j] = 0 otherwise.

Return the total number of provinces.

 

Example 1:

Input: isConnected = [[1,1,0],[1,1,0],[0,0,1]]
Output: 2

Example 2:

Input: isConnected = [[1,0,0],[0,1,0],[0,0,1]]
Output: 3

 

Constraints:

• 1 <= n <= 200
• n == isConnected.length
• n == isConnected[i].length
• isConnected[i][j] is 1 or 0.
• isConnected[i][i] == 1
• isConnected[i][j] == isConnected[j][i]

Solutions

Solution 1: DFS

We create an array vis to record whether each city has been visited.

Next, we traverse each city i. If the city has not been visited, we start a depth-first search from that city. Using the matrix isConnected, we find the cities directly connected to this city. These cities and the current city belong to the same province. We continue the depth-first search for these cities until all cities in the same province have been visited. This counts as one province, so we increment the answer ans by 1. Then, we move to the next unvisited city and repeat the process until all cities have been traversed.

Finally, return the answer.

The time complexity is O(n^2), and the space complexity is O(n). Here, n is the number of cities.

PythonJavaC++GoTypeScriptRust

class Solution: def findCircleNum(self, isConnected: List[List[int]]) -> int: def dfs(i: int): vis[i] = True for j, x in enumerate(isConnected[i]): if not vis[j] and x: dfs(j) n = len(isConnected) vis = [False] * n ans = 0 for i in range(n): if not vis[i]: dfs(i) ans += 1 return ans(code-box)

class Solution { private int[][] g; private boolean[] vis; public int findCircleNum(int[][] isConnected) { g = isConnected; int n = g.length; vis = new boolean[n]; int ans = 0; for (int i = 0; i < n; ++i) { if (!vis[i]) { dfs(i); ++ans; } } return ans; } private void dfs(int i) { vis[i] = true; for (int j = 0; j < g.length; ++j) { if (!vis[j] && g[i][j] == 1) { dfs(j); } } } }(code-box)

class Solution { public: int findCircleNum(vector<vector<int>>& isConnected) { int n = isConnected.size(); int ans = 0; bool vis[n]; memset(vis, false, sizeof(vis)); auto dfs = [&](this auto&& dfs, int i) -> void { vis[i] = true; for (int j = 0; j < n; ++j) { if (!vis[j] && isConnected[i][j]) { dfs(j); } } }; for (int i = 0; i < n; ++i) { if (!vis[i]) { dfs(i); ++ans; } } return ans; } };(code-box)

func findCircleNum(isConnected [][]int) (ans int) { n := len(isConnected) vis := make([]bool, n) var dfs func(int) dfs = func(i int) { vis[i] = true for j, x := range isConnected[i] { if !vis[j] && x == 1 { dfs(j) } } } for i, v := range vis { if !v { ans++ dfs(i) } } return }(code-box)

function findCircleNum(isConnected: number[][]): number { const n = isConnected.length; const vis: boolean[] = new Array(n).fill(false); const dfs = (i: number) => { vis[i] = true; for (let j = 0; j < n; ++j) { if (!vis[j] && isConnected[i][j]) { dfs(j); } } }; let ans = 0; for (let i = 0; i < n; ++i) { if (!vis[i]) { dfs(i); ++ans; } } return ans; }(code-box)

impl Solution { fn dfs(is_connected: &mut Vec<Vec<i32>>, vis: &mut Vec<bool>, i: usize) { vis[i] = true; for j in 0..is_connected.len() { if vis[j] || is_connected[i][j] == 0 { continue; } Self::dfs(is_connected, vis, j); } } pub fn find_circle_num(mut is_connected: Vec<Vec<i32>>) -> i32 { let n = is_connected.len(); let mut vis = vec![false; n]; let mut res = 0; for i in 0..n { if vis[i] { continue; } res += 1; Self::dfs(&mut is_connected, &mut vis, i); } res } }(code-box)

Solution 2: Union-Find

We can also use the union-find data structure to maintain each connected component. Initially, each city belongs to a different connected component, so the number of provinces is n.

Next, we traverse the matrix isConnected. If there is a connection between two cities (i, j) and they belong to two different connected components, they will be merged into one connected component, and the number of provinces is decremented by 1.

Finally, return the number of provinces.

The time complexity is O(n^2 × log n), and the space complexity is O(n). Here, n is the number of cities, and log n is the time complexity of path compression in the union-find data structure.

PythonJavaC++GoTypeScript

class Solution: def findCircleNum(self, isConnected: List[List[int]]) -> int: def find(x: int) -> int: if p[x] != x: p[x] = find(p[x]) return p[x] n = len(isConnected) p = list(range(n)) ans = n for i in range(n): for j in range(i + 1, n): if isConnected[i][j]: pa, pb = find(i), find(j) if pa != pb: p[pa] = pb ans -= 1 return ans(code-box)

class Solution { private int[] p; public int findCircleNum(int[][] isConnected) { int n = isConnected.length; p = new int[n]; for (int i = 0; i < n; ++i) { p[i] = i; } int ans = n; for (int i = 0; i < n; ++i) { for (int j = i + 1; j < n; ++j) { if (isConnected[i][j] == 1) { int pa = find(i), pb = find(j); if (pa != pb) { p[pa] = pb; --ans; } } } } return ans; } private int find(int x) { if (p[x] != x) { p[x] = find(p[x]); } return p[x]; } }(code-box)

class Solution { public: int findCircleNum(vector<vector<int>>& isConnected) { int n = isConnected.size(); int p[n]; iota(p, p + n, 0); auto find = [&](this auto&& find, int x) -> int { if (p[x] != x) { p[x] = find(p[x]); } return p[x]; }; int ans = n; for (int i = 0; i < n; ++i) { for (int j = i + 1; j < n; ++j) { if (isConnected[i][j]) { int pa = find(i), pb = find(j); if (pa != pb) { p[pa] = pb; --ans; } } } } return ans; } };(code-box)

func findCircleNum(isConnected [][]int) (ans int) { n := len(isConnected) p := make([]int, n) for i := range p { p[i] = i } var find func(x int) int find = func(x int) int { if p[x] != x { p[x] = find(p[x]) } return p[x] } ans = n for i := 0; i < n; i++ { for j := 0; j < n; j++ { if isConnected[i][j] == 1 { pa, pb := find(i), find(j) if pa != pb { p[pa] = pb ans-- } } } } return }(code-box)

function findCircleNum(isConnected: number[][]): number { const n = isConnected.length; const p: number[] = Array.from({ length: n }, (_, i) => i); const find = (x: number): number => { if (p[x] !== x) { p[x] = find(p[x]); } return p[x]; }; let ans = n; for (let i = 0; i < n; ++i) { for (let j = i + 1; j < n; ++j) { if (isConnected[i][j]) { const pa = find(i); const pb = find(j); if (pa !== pb) { p[pa] = pb; --ans; } } } } return ans; }(code-box)