Number of Provinces

Number of Provinces - Problem

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 i^th city and the j^th city are directly connected, and isConnected[i][j] = 0 otherwise.

Return the total number of provinces.

Input & Output

Example 1 — Two Separate Provinces

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

› Output: 2

💡 Note: Cities 0 and 1 are connected (province 1). City 2 is isolated (province 2). Total: 2 provinces.

Example 2 — All Connected

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

› Output: 3

💡 Note: No connections between cities. Each city is its own province: 0, 1, 2. Total: 3 provinces.

Example 3 — Chain Connection

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

› Output: 1

💡 Note: City 0↔1, City 1↔2, so all cities are in one connected province. Total: 1 province.

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]

Visualization

Tap to expand

Asked in

A Amazon 45 f Facebook 32 G Google 28 M Microsoft 22

The key insight is that provinces are connected components in an undirected graph. Each unvisited city starts a new DFS traversal, representing a new province. Best approach uses DFS for simplicity or Union-Find for efficiency. Time: O(n²), Space: O(n)

Common Approaches

✓ Breadth-First Search

⏱️ Time: O(n²) Space: O(n)

Similar to DFS but uses a queue to explore cities level by level. For each unvisited city, start BFS to mark all connected cities in the same province.

Brute Force DFS

⏱️ Time: O(n²) Space: O(n)

Iterate through each city. If not visited, start a DFS to mark all cities in the same province. Count how many times we start a new DFS.

Union-Find (Disjoint Set)

⏱️ Time: O(n² α(n)) Space: O(n)

Initialize each city as its own parent. For each connection, union the cities. Count the number of unique root parents to get province count.

Breadth-First Search — Algorithm Steps

Iterate through each city
If city not visited, start BFS with queue
Process all cities in current province level by level
Count each BFS traversal as one province

Visualization

Tap to expand

Step-by-Step Walkthrough

Queue Start

Add unvisited city to queue

Process Level

Process all cities at current level

Add Neighbors

Add connected unvisited cities to queue

Code -

solution.c — C

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

typedef struct {
    int* data;
    int front, rear, size, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (int*)malloc(capacity * sizeof(int));
    q->front = q->rear = q->size = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, int val) {
    q->data[q->rear] = val;
    q->rear = (q->rear + 1) % q->capacity;
    q->size++;
}

int dequeue(Queue* q) {
    int val = q->data[q->front];
    q->front = (q->front + 1) % q->capacity;
    q->size--;
    return val;
}

int solution(int** isConnected, int n) {
    bool* visited = (bool*)calloc(n, sizeof(bool));
    int provinces = 0;
    Queue* queue = createQueue(n);
    
    for (int city = 0; city < n; city++) {
        if (!visited[city]) {
            provinces++;
            enqueue(queue, city);
            visited[city] = true;
            
            while (queue->size > 0) {
                int current = dequeue(queue);
                for (int neighbor = 0; neighbor < n; neighbor++) {
                    if (isConnected[current][neighbor] == 1 && !visited[neighbor]) {
                        visited[neighbor] = true;
                        enqueue(queue, neighbor);
                    }
                }
            }
        }
    }
    
    free(visited);
    free(queue->data);
    free(queue);
    return provinces;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int n = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && line[i+1] != '[') n++;
    }
    
    int** isConnected = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        isConnected[i] = (int*)malloc(n * sizeof(int));
    }
    
    int row = 0, col = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] >= '0' && line[i] <= '9') {
            isConnected[row][col] = line[i] - '0';
            col++;
            if (col == n) {
                col = 0;
                row++;
            }
        }
    }
    
    int result = solution(isConnected, n);
    printf("%d\n", result);
    
    for (int i = 0; i < n; i++) {
        free(isConnected[i]);
    }
    free(isConnected);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

BFS visits each city once and checks all n connections

⚠ Quadratic Growth

Space Complexity

O(n)

Visited array plus queue can hold up to n cities

⚡ Linearithmic Space

67.0K Views

High Frequency

~15 min Avg. Time

1.9K 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

Constraints

Visualization

Related Problems

Common Approaches

Breadth-First Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler