Minimum Time to Visit All Houses - Practice Coding Problems

Minimum Time to Visit All Houses - Problem

Imagine you're planning an efficient route through a circular neighborhood where houses are connected by roads of varying lengths. You start at house 0 and need to visit a sequence of houses as quickly as possible.

The neighborhood has a unique road system:

Forward roads: Each house i connects to house (i+1) % n with distance forward[i] meters
Backward roads: Each house i connects to house (i-1+n) % n with distance backward[i] meters

You walk at 1 meter per second and need to visit houses in the exact order specified by the queries array. Your goal is to find the minimum total time to complete this journey.

Key insight: For each step in your journey, you can choose to go clockwise (forward) or counterclockwise (backward) around the circle to reach your destination faster!

Input & Output

example_1.py — Basic Circle Navigation

$ Input: forward = [5, 7, 3], backward = [3, 5, 2], queries = [1, 2, 0]

› Output: 13

💡 Note: Start at house 0. Go to house 1: min(5, 3+5+2) = min(5, 10) = 5. Go to house 2: min(7, 5) = 5. Go to house 0: min(3, 7+5) = min(3, 12) = 3. Total: 5+5+3 = 13

example_2.py — Same House Query

$ Input: forward = [4, 6], backward = [2, 3], queries = [0, 1, 0]

› Output: 6

💡 Note: Start at house 0. Stay at house 0: 0 time. Go to house 1: min(4, 2) = 2. Go to house 0: min(6, 3) = 3. Total: 0+2+4 = 6 (Note: 2+4=6, there was an error in explanation)

example_3.py — Large Circle

$ Input: forward = [1, 1, 1, 1], backward = [1, 1, 1, 1], queries = [2]

› Output: 2

💡 Note: Start at house 0, need to go to house 2. Both clockwise (1+1=2) and counterclockwise (1+1=2) take same time. Choose either: 2

Constraints

1 ≤ n ≤ 10⁵
1 ≤ forward[i], backward[i] ≤ 10⁴
1 ≤ queries.length ≤ 10⁵
0 ≤ queries[i] < n
All distances are positive integers

Visualization

Tap to expand

Understanding the Visualization

Preprocess

Calculate cumulative distances for both directions around the circle

Query

For each destination, instantly compute both clockwise and counterclockwise distances

Optimize

Always choose the shorter path to minimize travel time

Accumulate

Add the chosen distance to total time and move to next query

Key Takeaway

🎯 Key Insight: Pre-computing prefix sums transforms expensive O(n) distance calculations into instant O(1) lookups, making the solution efficient even for large inputs!

Asked in

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

The optimal solution uses prefix sums to preprocess cumulative distances in both directions. For each query, we can calculate clockwise and counterclockwise distances in O(1) time using the precomputed prefix arrays, then choose the minimum. This reduces the overall complexity from O(q×n) to O(n + q).

Common Approaches

Approach	Time	Space	Notes
✓ Optimized with Prefix Sums	O(n + q)	O(n)	Pre-compute cumulative distances for instant range queries

Optimized with Prefix Sums — Algorithm Steps

Pre-compute prefix sums for forward and backward arrays
For each query, calculate both clockwise and counterclockwise distances using prefix sums
Handle circular array wraparound using modular arithmetic
Choose minimum distance and add to total time
Update current position

Visualization

Tap to expand

Step-by-Step Walkthrough

Precompute Prefix Sums

Calculate cumulative distances for both directions

Query Processing

Use prefix sums to get distances in O(1) time

Range Calculation

Distance = prefix[target] - prefix[current]

Choose Optimal

Select minimum between clockwise and counterclockwise

Code -

solution.c — C

int minimumTimeToVisitAllHouses(int* forward, int forwardSize, int* backward, int backwardSize, int* queries, int queriesSize) {
    int n = forwardSize;
    
    // Pre-compute prefix sums
    int* forwardPrefix = (int*)calloc(2 * n, sizeof(int));
    int* backwardPrefix = (int*)calloc(2 * n, sizeof(int));
    
    for (int i = 0; i < 2 * n - 1; i++) {
        forwardPrefix[i + 1] = forwardPrefix[i] + forward[i % n];
        backwardPrefix[i + 1] = backwardPrefix[i] + backward[i % n];
    }
    
    int totalTime = 0;
    int current = 0;
    
    for (int i = 0; i < queriesSize; i++) {
        int target = queries[i];
        if (current == target) continue;
        
        // Calculate clockwise distance
        int clockwise;
        if (target > current) {
            clockwise = forwardPrefix[target] - forwardPrefix[current];
        } else {
            clockwise = forwardPrefix[n] - forwardPrefix[current] + forwardPrefix[target];
        }
        
        // Calculate counterclockwise distance
        int counterclockwise;
        if (target < current) {
            counterclockwise = backwardPrefix[current] - backwardPrefix[target];
        } else {
            counterclockwise = backwardPrefix[current + n] - backwardPrefix[target + n];
        }
        
        int minTime = clockwise < counterclockwise ? clockwise : counterclockwise;
        totalTime += minTime;
        current = target;
    }
    
    free(forwardPrefix);
    free(backwardPrefix);
    return totalTime;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + q)

O(n) for preprocessing prefix sums, then O(1) per query for q queries

✓ Linear Growth

Space Complexity

O(n)

Extra space needed to store prefix sum arrays for forward and backward directions

⚡ Linearithmic Space

24.0K Views

Medium Frequency

~18 min Avg. Time

890 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

Optimized with Prefix Sums — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler