Shortest Distance to Target Color

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.

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

Visualization

Tap to expand

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

✓ Brute Force (Linear Search for Each Query)

⏱️ Time: O(q × n) Space: O(1)

The most straightforward approach is to handle each query independently. For each query (i, c), we start from index i and expand outward in both directions until we find the target color c. We check positions i-1, i+1, i-2, i+2, etc., until we find the first occurrence of color c.

Dynamic Programming (Optimal)

⏱️ Time: O(n + q) Space: O(n)

The most efficient approach is to precompute the answer for every possible query. We use dynamic programming to calculate, for each position and each color, the distance to the nearest occurrence of that color. This eliminates the need for any searching during query time.

Preprocessing with Index Lists

⏱️ Time: O(n + q log n) Space: O(n)

Instead of searching from scratch for each query, we can preprocess the array to store all indices where each color appears. Then for each query, we use binary search on the appropriate color's index list to find the closest position.

Brute Force (Linear Search for Each Query) — Algorithm Steps

For each query (i, c), start from index i
Check if colors[i] == c, if yes return 0
Expand search radius: check i±1, then i±2, then i±3, etc.
Return the distance when target color is found
If we've searched the entire array without finding c, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at query index

Begin search at the given index i

Check current position

If colors[i] matches target, return 0

Expand search radius

Check positions at distance 1, then 2, then 3...

First match wins

Return distance when target color is first found

Code -

solution.c — C

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

int abs(int x) {
    if (x < 0) {
        return -x;
    }
    return x;
}

int findShortestDistance(int* colors, int colorsSize, int index, int targetColor) {
    int minDistance = -1;
    
    for (int i = 0; i < colorsSize; i++) {
        if (colors[i] == targetColor) {
            int distance = abs(index - i);
            if (minDistance == -1 || distance < minDistance) {
                minDistance = distance;
            }
        }
    }
    
    return minDistance;
}

int* solution(int* colors, int colorsSize, int** queries, int queriesSize, int* returnSize) {
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int index = queries[i][0];
        int targetColor = queries[i][1];
        
        result[i] = findShortestDistance(colors, colorsSize, index, targetColor);
    }
    
    return result;
}

int main() {
    char line1[100000];
    char line2[100000];
    
    if (fgets(line1, sizeof(line1), stdin) == NULL) return 1;
    if (fgets(line2, sizeof(line2), stdin) == NULL) return 1;
    
    int len = strlen(line1);
    if (len > 0 && line1[len - 1] == '\n') {
        line1[len - 1] = '\0';
    }
    
    len = strlen(line2);
    if (len > 0 && line2[len - 1] == '\n') {
        line2[len - 1] = '\0';
    }
    
    int* colors = (int*)malloc(50000 * sizeof(int));
    int colorsSize = 0;
    
    char* ptr = line1;
    int num = 0;
    int inNumber = 0;
    
    while (*ptr) {
        if (*ptr >= '0' && *ptr <= '9') {
            num = num * 10 + (*ptr - '0');
            inNumber = 1;
        } else if (inNumber) {
            colors[colorsSize++] = num;
            num = 0;
            inNumber = 0;
        }
        ptr++;
    }
    if (inNumber) {
        colors[colorsSize++] = num;
    }
    
    int** queries = (int**)malloc(50000 * sizeof(int*));
    for (int i = 0; i < 50000; i++) {
        queries[i] = (int*)malloc(2 * sizeof(int));
    }
    int queriesSize = 0;
    
    ptr = line2;
    int bracketDepth = 0;
    int queryIdx = 0;
    num = 0;
    inNumber = 0;
    
    while (*ptr) {
        if (*ptr == '[') {
            bracketDepth++;
            if (bracketDepth == 2) {
                queryIdx = 0;
            }
        } else if (*ptr == ']') {
            if (inNumber && bracketDepth == 2) {
                queries[queriesSize][queryIdx++] = num;
                num = 0;
                inNumber = 0;
            }
            if (bracketDepth == 2) {
                queriesSize++;
            }
            bracketDepth--;
        } else if (*ptr >= '0' && *ptr <= '9') {
            num = num * 10 + (*ptr - '0');
            inNumber = 1;
        } else if ((*ptr == ',' || *ptr == ' ') && inNumber && bracketDepth == 2) {
            queries[queriesSize][queryIdx++] = num;
            num = 0;
            inNumber = 0;
        }
        ptr++;
    }
    
    int returnSize;
    int* result = solution(colors, colorsSize, queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) {
            printf(",");
        }
    }
    printf("]\n");
    
    free(colors);
    for (int i = 0; i < 50000; i++) {
        free(queries[i]);
    }
    free(queries);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × n)

For each of q queries, we might need to search the entire array of length n

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for the current search

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Linear Search for Each Query) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler