Number of Provinces - Practice Coding Problems

Number of Provinces - Problem

Finding Connected Components in a City Network

Imagine you're a data analyst for a transportation company studying city connectivity patterns. You have n cities, and some pairs of cities are directly connected by roads. However, cities can also be indirectly connected through other cities - if city A connects to city B, and city B connects to city C, then A and C are indirectly connected.

A province is defined as a group of cities that are all connected to each other (either directly or indirectly), with no connections to cities outside the group. Your task is to determine how many such provinces exist.

You're given an n × n adjacency matrix isConnected where:
• isConnected[i][j] = 1 means cities i and j are directly connected
• isConnected[i][j] = 0 means no direct connection
• The matrix is symmetric: isConnected[i][j] = isConnected[j][i]
• Each city is connected to itself: isConnected[i][i] = 1

Goal: Return the total number of provinces (connected components) in the network.

Input & Output

example_1.py — Three Cities, Two Provinces

$ Input: isConnected = [[1,1,0],[1,1,0],[0,0,1]]

› Output: 2

💡 Note: Cities 0 and 1 are directly connected, forming one province. City 2 is isolated, forming a second province.

example_2.py — Three Cities, Three Provinces

$ Input: isConnected = [[1,0,0],[0,1,0],[0,0,1]]

› Output: 3

💡 Note: No cities are connected to each other, so each city forms its own province.

example_3.py — Four Cities, One Province

$ Input: isConnected = [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]]

› Output: 1

💡 Note: All cities are connected to each other either directly or indirectly, forming one large province.

Visualization

Tap to expand

Understanding the Visualization

Map the connections

The adjacency matrix shows direct relationships between cities

Explore each group

Starting from an unvisited city, explore all cities reachable through connections

Mark visited cities

Once a city is part of a province, mark it to avoid counting again

Count provinces

Each DFS or Union-Find component represents one province

Key Takeaway

🎯 Key Insight: This problem is fundamentally about finding connected components in an undirected graph. Whether using DFS or Union-Find, we're grouping cities that can reach each other through any path of direct connections.

Time & Space Complexity

Time Complexity

⏱️

O(n² × α(n))

We check n² matrix entries, each union/find operation takes nearly O(1) with path compression

⚠ Quadratic Growth

Space Complexity

O(n)

Parent and rank arrays each take O(n) space

⚡ Linearithmic Space

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]

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

This is a classic connected components problem that can be solved efficiently using either DFS traversal or Union-Find data structure. The key insight is that each province represents a connected component in the graph represented by the adjacency matrix. Both approaches achieve O(n²) time complexity, but Union-Find provides better performance for dynamic connectivity queries and is the preferred solution for graph connectivity problems.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Disjoint Set Union)	O(n² × α(n))	O(n)	Use Union-Find data structure to efficiently group connected cities

Union-Find (Disjoint Set Union) — Algorithm Steps

Initialize Union-Find structure with each city as its own parent
Implement find() with path compression for efficiency
Implement union() to merge two components
Iterate through upper triangle of adjacency matrix
For each connection isConnected[i][j] = 1, union cities i and j
Count distinct root parents to get number of provinces

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Each city starts as its own parent (separate province)

Union connections

For each edge in matrix, union the two cities

Path compression

Find operations compress paths for efficiency

Count roots

Number of distinct root parents = number of provinces

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int* parent;
    int* rank;
    int size;
} UnionFind;

UnionFind* createUnionFind(int n) {
    UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(n * sizeof(int));
    uf->rank = (int*)calloc(n, sizeof(int));
    uf->size = n;
    
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
    }
    return uf;
}

int find(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]); // Path compression
    }
    return uf->parent[x];
}

void unite(UnionFind* uf, int x, int y) {
    int px = find(uf, x);
    int py = find(uf, y);
    if (px == py) return;
    
    // Union by rank
    if (uf->rank[px] < uf->rank[py]) {
        uf->parent[px] = py;
    } else if (uf->rank[px] > uf->rank[py]) {
        uf->parent[py] = px;
    } else {
        uf->parent[py] = px;
        uf->rank[px]++;
    }
}

int findCircleNum(int** isConnected, int n) {
    UnionFind* uf = createUnionFind(n);
    
    // Union connected cities
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (isConnected[i][j] == 1) {
                unite(uf, i, j);
            }
        }
    }
    
    // Count distinct components
    int* visited = (int*)calloc(n, sizeof(int));
    int count = 0;
    for (int i = 0; i < n; i++) {
        int root = find(uf, i);
        if (!visited[root]) {
            visited[root] = 1;
            count++;
        }
    }
    
    free(uf->parent);
    free(uf->rank);
    free(uf);
    free(visited);
    return count;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int** isConnected = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        isConnected[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            scanf("%d", &isConnected[i][j]);
        }
    }
    
    printf("%d\n", findCircleNum(isConnected, n));
    
    for (int i = 0; i < n; i++) {
        free(isConnected[i]);
    }
    free(isConnected);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × α(n))

We check n² matrix entries, each union/find operation takes nearly O(1) with path compression

⚠ Quadratic Growth

Space Complexity

O(n)

Parent and rank arrays each take O(n) space

⚡ Linearithmic Space

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]

25.7K Views

High Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Union-Find (Disjoint Set Union) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler