Count the Number of Houses at a Certain Distance II

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

Imagine you're a city planner analyzing the transportation network of a linear city! 🏘️

You have a city with n houses numbered from 1 to n, arranged in a straight line. Each house i is connected to house i+1 by a street, forming a linear chain. However, there's also a special shortcut street that directly connects house x to house y, potentially creating faster routes between certain houses.

Your task is to analyze the transportation efficiency: for each possible distance k (where 1 ≤ k ≤ n), count how many pairs of houses are exactly k streets apart when taking the shortest possible route.

Goal: Return an array where result[k] represents the number of house pairs that are exactly k streets apart via the shortest path.

Note: The shortcut street can be used in both directions, and houses x and y can be the same (creating a loop).

Input & Output

example_1.py — Basic Linear City

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

› Output: [6, 0, 0]

💡 Note: With houses 1-2-3 and shortcut 1↔3: distance 1 has pairs (1,2), (2,3), (1,3) via shortcut, (3,1) via shortcut, (2,1), (3,2) = 6 pairs. No pairs at distances 2 or 3.

example_2.py — Medium City

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

› Output: [10, 8, 2, 0, 0]

💡 Note: Houses 1-2-3-4-5 with shortcut 2↔4. Distance 1: adjacent pairs plus some using shortcut. Distance 2: pairs that are 2 apart via optimal path. Distance 3: only (1,4) and (4,1) via direct path.

example_3.py — Same House Shortcut

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

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

💡 Note: Shortcut creates a loop at house 2, but doesn't change distances between different houses. Standard linear arrangement applies.

Visualization

Tap to expand

Understanding the Visualization

Map the Network

Identify the linear chain and shortcut connection

Analyze Regions

Divide into regions: left of shortcut, shortcut span, right of shortcut

Count Base Pairs

Calculate pairs at each distance without using shortcut

Apply Shortcut Benefits

Adjust counts based on which pairs benefit from the shortcut

Key Takeaway

🎯 Key Insight: Rather than computing O(n²) shortest paths, we can mathematically analyze how the shortcut affects distance distribution, achieving optimal O(n) performance through regional analysis and formula-based counting.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through distances, each with constant time calculations

✓ Linear Growth

Space Complexity

O(n)

Only space needed for the result array

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
1 ≤ x, y ≤ n
x and y can be equal (creating a self-loop)
The result array should have exactly n elements

Asked in

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

This problem can be solved optimally using mathematical analysis in O(n) time. Instead of computing shortest paths for every pair of houses, we analyze how the shortcut affects the distance distribution. The key insight is that we can calculate pair counts directly using formulas that consider different regions relative to the shortcut endpoints.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Pairs Shortest Path)	O(n²)	O(n)	Calculate shortest distance for every pair of houses directly
Mathematical Formula (Optimal)	O(n)	O(n)	Use mathematical analysis to count pairs directly without calculating individual distances

Brute Force (All Pairs Shortest Path) — Algorithm Steps

Initialize result array of size n with zeros
For each pair of houses (i, j) where i < j:
Calculate direct distance: |i - j|
Calculate shortcut distance: min(|i - x| + 1 + |y - j|, |i - y| + 1 + |x - j|)
Take minimum of direct and shortcut distances
Increment result[minDistance]
Return result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Pair

Choose houses i and j to calculate distance

Direct Path

Calculate distance via linear chain: |i - j|

Shortcut Path

Calculate distance via shortcut: min(|i-x| + 1 + |j-y|, |i-y| + 1 + |j-x|)

Choose Minimum

Take the shorter of the two paths and increment counter

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int* countOfPairs(int n, int x, int y) {
    int* result = (int*)calloc(n, sizeof(int));
    
    // Make x <= y for consistency
    if (x > y) {
        int temp = x;
        x = y;
        y = temp;
    }
    
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            // Direct distance along the line
            int directDist = j - i;
            
            // Distance using shortcut x-y
            int shortcutDist1 = abs_val(i - x) + 1 + abs_val(j - y);
            int shortcutDist2 = abs_val(i - y) + 1 + abs_val(j - x);
            int shortcutDist = min(shortcutDist1, shortcutDist2);
            
            // Take minimum distance
            int minDist = min(directDist, shortcutDist);
            result[minDist - 1]++;
        }
    }
    
    return result;
}

int main() {
    int n, x, y;
    scanf("%d %d %d", &n, &x, &y);
    
    int* result = countOfPairs(n, x, y);
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("%d", result[i]);
        if (i < n - 1) printf(", ");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check every pair of houses, which is n*(n-1)/2 pairs

⚠ Quadratic Growth

Space Complexity

O(n)

Only need space for the result array

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
1 ≤ x, y ≤ n
x and y can be equal (creating a self-loop)
The result array should have exactly n elements

27.4K Views

Medium Frequency

~25 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

Brute Force (All Pairs Shortest Path) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler