Count the Number of Houses at a Certain Distance I

Count the Number of Houses at a Certain Distance I - Problem

You are given a city with n houses numbered from 1 to n, connected by streets forming a linear chain. Each house i is connected to house i+1. Additionally, there's a special shortcut street connecting house x to house y.

Your task is to count how many pairs of houses have each possible shortest distance from 1 to n streets. For each distance k, find the number of house pairs (house1, house2) where the minimum streets needed to travel from house1 to house2 is exactly k.

Goal: Return an array where result[k] represents the total number of house pairs with shortest distance k.

Example: With houses 1-2-3 and shortcut 1↔3, the shortest path from house 1 to 3 is 1 street (using shortcut) instead of 2 streets (via house 2).

Input & Output

example_1.py — Basic Linear Chain with Shortcut

$ Input: n = 3, x = 1, y = 3

› Output: [4, 2, 0]

💡 Note: Houses: 1-2-3 with shortcut 1↔3. Distance 1: (1,2), (2,1), (1,3), (3,1) = 4 pairs. Distance 2: (2,3), (3,2) = 2 pairs. Distance 3: none = 0 pairs.

example_2.py — No Shortcut Effect

$ Input: n = 5, x = 2, y = 4

› Output: [8, 6, 4, 2]

💡 Note: Houses: 1-2-3-4-5 with shortcut 2↔4. The shortcut creates new shortest paths, changing the distance distribution compared to a simple linear arrangement.

example_3.py — Self-Loop Edge Case

$ Input: n = 4, x = 2, y = 2

› Output: [6, 4, 2]

💡 Note: When x equals y, the shortcut has no effect. This becomes a simple linear chain: 1-2-3-4. Distance counts follow the standard linear pattern.

Visualization

Tap to expand

Understanding the Visualization

Linear City Setup

Houses 1-2-3-4-5 connected in a chain with shortcut 2↔4

Without Shortcut

Distance from 2 to 4 would be 2 steps (2→3→4)

With Shortcut

Distance from 2 to 4 becomes 1 step (2→4 directly)

Count All Pairs

BFS from each house reveals all shortest distances for counting

Key Takeaway

🎯 Key Insight: BFS efficiently finds shortest paths in unweighted graphs, and running it from each house gives us the complete distance distribution needed to solve this counting problem.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We run BFS from each of the n houses, and each BFS takes O(n) time to visit all houses

⚠ Quadratic Growth

Space Complexity

O(n)

We need space for the adjacency list and BFS queue, plus the result array

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 100
1 ≤ x, y ≤ n
x and y can be equal (shortcut has no effect)
Return array is 1-indexed where result[k] = count of pairs with distance k

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

This problem requires finding shortest distances between all pairs of houses in a modified linear graph. The optimal approach uses BFS from each house to compute shortest paths efficiently, accounting for the additional shortcut edge that can create alternative routes. The key insight is that BFS naturally finds shortest paths in unweighted graphs, making it perfect for this distance-counting problem.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (BFS from every house)	O(n²)	O(n)	Run BFS from each house to find distances to all other houses

Brute Force (BFS from every house) — Algorithm Steps

For each house i from 1 to n:
Run BFS from house i to find shortest distances to all other houses
For each distance found, increment the corresponding counter
Build adjacency list including the shortcut edge
Return the result array with counts for each distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Start BFS from house 1

Initialize queue with house 1 at distance 0

Explore neighbors

Add adjacent houses to queue with distance + 1

Count distances

Record distance for each house pair found

Repeat for all houses

Perform same BFS from every house as starting point

Code -

solution.c — C

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

int* countOfPairs(int n, int x, int y, int* returnSize) {
    *returnSize = n;
    int* result = (int*)calloc(n, sizeof(int));
    
    // Build adjacency matrix
    int** graph = (int**)malloc(sizeof(int*) * (n + 1));
    for (int i = 0; i <= n; i++) {
        graph[i] = (int*)calloc(n + 1, sizeof(int));
    }
    
    // Add linear connections
    for (int i = 1; i < n; i++) {
        graph[i][i + 1] = 1;
        graph[i + 1][i] = 1;
    }
    
    // Add shortcut if x != y
    if (x != y) {
        graph[x][y] = 1;
        graph[y][x] = 1;
    }
    
    // BFS from each house
    for (int start = 1; start <= n; start++) {
        int* visited = (int*)calloc(n + 1, sizeof(int));
        int* queue = (int*)malloc(sizeof(int) * n * 2);
        int* dist_queue = (int*)malloc(sizeof(int) * n * 2);
        int front = 0, rear = 0;
        
        queue[rear] = start;
        dist_queue[rear] = 0;
        rear++;
        visited[start] = 1;
        
        while (front < rear) {
            int house = queue[front];
            int dist = dist_queue[front];
            front++;
            
            // Count this distance (excluding distance 0 to self)
            if (dist > 0) {
                result[dist - 1]++;
            }
            
            // Explore neighbors
            for (int neighbor = 1; neighbor <= n; neighbor++) {
                if (graph[house][neighbor] && !visited[neighbor]) {
                    visited[neighbor] = 1;
                    queue[rear] = neighbor;
                    dist_queue[rear] = dist + 1;
                    rear++;
                }
            }
        }
        
        free(visited);
        free(queue);
        free(dist_queue);
    }
    
    // Free graph
    for (int i = 0; i <= n; i++) {
        free(graph[i]);
    }
    free(graph);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We run BFS from each of the n houses, and each BFS takes O(n) time to visit all houses

⚠ Quadratic Growth

Space Complexity

O(n)

We need space for the adjacency list and BFS queue, plus the result array

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 100
1 ≤ x, y ≤ n
x and y can be equal (shortcut has no effect)
Return array is 1-indexed where result[k] = count of pairs with distance k

38.2K Views

Medium Frequency

~25 min Avg. Time

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

Brute Force (BFS from every house) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler