Shortest Distance to Target Color - Practice Coding Problems

Shortest Distance to Target Color - Problem

You're working with a colorful array where each position contains one of three colors: 1 (red), 2 (green), or 3 (blue). Your task is to efficiently answer multiple queries about finding the shortest distance from any given position to the nearest occurrence of a specific target color.

For each query (i, c), you need to find the minimum number of steps required to reach color c from index i. If the target color doesn't exist in the array, return -1.

Example: Given colors = [1,1,2,1,3,2,2,3,3], if you're at index 3 (color 1) and looking for color 2, you can go left to index 2 (distance = 1) or right to index 5 (distance = 2), so the answer is 1.

Input & Output

example_1.py — Basic Case

$ Input: colors = [1,1,2,1,3,2,2,3,3], queries = [[1,3],[2,2],[6,1]]

› Output: [3, 0, 3]

💡 Note: Query [1,3]: At index 1 (color 1), nearest color 3 is at index 4, distance = |4-1| = 3. Query [2,2]: At index 2 (color 2), we're already at color 2, distance = 0. Query [6,1]: At index 6 (color 2), nearest color 1 is at index 3, distance = |6-3| = 3.

example_2.py — Color Not Found

$ Input: colors = [1,2], queries = [[0,3]]

› Output: [-1]

💡 Note: Query [0,3]: At index 0, we're looking for color 3, but color 3 doesn't exist in the array, so we return -1.

example_3.py — Multiple Queries Same Position

$ Input: colors = [1,2,3,1,2], queries = [[2,1],[2,2],[2,3]]

› Output: [1, 1, 0]

💡 Note: All queries start at index 2 (color 3). For color 1: nearest is at index 3, distance = 1. For color 2: nearest is at index 1, distance = 1. For color 3: we're already at color 3, distance = 0.

Visualization

Tap to expand

Understanding the Visualization

Build Distance Map

Create a map showing distances to each color from every position

Forward Propagation

Scan left-to-right, updating distances based on colors seen so far

Backward Propagation

Scan right-to-left, finding closer colors from the other direction

Instant Queries

Answer any query in O(1) by looking up the precomputed distance

Key Takeaway

🎯 Key Insight: Instead of searching for each query, precompute all possible answers using dynamic programming. This transforms an O(n) search per query into O(1) lookup time!

Time & Space Complexity

Time Complexity

⏱️

O(n + q)

O(n) for preprocessing with DP, then O(1) per query

✓ Linear Growth

Space Complexity

O(n)

DP table storing distances for each position and color

⚡ Linearithmic Space

Constraints

1 ≤ colors.length ≤ 5 × 10⁴
1 ≤ colors[i] ≤ 3
1 ≤ queries.length ≤ 5 × 10⁴
0 ≤ queries[i][0] < colors.length
1 ≤ queries[i][1] ≤ 3

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 21

The optimal solution uses dynamic programming to precompute distances from each position to each color in O(n) time. A two-pass approach (forward and backward) ensures we find the minimum distance in each direction. This allows answering each query in O(1) time, making it perfect for handling many queries efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n + q)	O(n)	Precompute shortest distances for all positions and colors using DP
Preprocessing with Index Lists	O(n + q log n)	O(n)	Store all indices of each color, then use binary search to find nearest
Brute Force (Linear Search for Each Query)	O(q × n)	O(1)	For each query, search linearly in both directions from the given index

Dynamic Programming (Optimal) — Algorithm Steps

Create a 2D DP array: dp[i][c] = distance from position i to nearest color c
Forward pass: For each position, update distances based on current color
Backward pass: Update distances by checking from the right side
For each query (i, c), return dp[i][c-1] in O(1) time

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP table

Create table with infinite distances

Forward pass

Propagate distances from left to right

Backward pass

Propagate distances from right to left

Answer queries

Look up precomputed answers in O(1)

Code -

solution.c — C

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

int* shortestDistanceColor(int* colors, int colorsSize, int** queries, int queriesSize, int* queryColSize, int* returnSize) {
    int n = colorsSize;
    int** dp = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dp[i] = (int*)malloc(3 * sizeof(int));
        for (int j = 0; j < 3; j++) {
            dp[i][j] = INT_MAX;
        }
    }
    
    // Forward pass
    for (int i = 0; i < n; i++) {
        dp[i][colors[i] - 1] = 0;
        
        if (i > 0) {
            for (int c = 0; c < 3; c++) {
                if (dp[i-1][c] != INT_MAX) {
                    int newDist = dp[i-1][c] + 1;
                    if (newDist < dp[i][c]) {
                        dp[i][c] = newDist;
                    }
                }
            }
        }
    }
    
    // Backward pass
    for (int i = n-2; i >= 0; i--) {
        for (int c = 0; c < 3; c++) {
            if (dp[i+1][c] != INT_MAX) {
                int newDist = dp[i+1][c] + 1;
                if (newDist < dp[i][c]) {
                    dp[i][c] = newDist;
                }
            }
        }
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int index = queries[i][0];
        int color = queries[i][1];
        int dist = dp[index][color-1];
        result[i] = (dist == INT_MAX) ? -1 : dist;
    }
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + q)

O(n) for preprocessing with DP, then O(1) per query

✓ Linear Growth

Space Complexity

O(n)

DP table storing distances for each position and color

⚡ Linearithmic Space

Constraints

1 ≤ colors.length ≤ 5 × 10⁴
1 ≤ colors[i] ≤ 3
1 ≤ queries.length ≤ 5 × 10⁴
0 ≤ queries[i][0] < colors.length
1 ≤ queries[i][1] ≤ 3

38.2K Views

Medium Frequency

~18 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler