Minimum Time to Make Rope Colorful

Minimum Time to Make Rope Colorful - Problem

Alice has n balloons arranged on a rope. You are given a 0-indexed string colors where colors[i] is the color of the i^th balloon.

Alice wants the rope to be colorful. She does not want two consecutive balloons to be of the same color, so she asks Bob for help. Bob can remove some balloons from the rope to make it colorful.

You are given a 0-indexed integer array neededTime where neededTime[i] is the time (in seconds) that Bob needs to remove the i^th balloon from the rope.

Return the minimum time Bob needs to make the rope colorful.

Input & Output

Example 1 — Basic Group Removal

$ Input: colors = "aabaa", neededTime = [1,3,2,5,4]

› Output: 5

💡 Note: First group 'aa' at positions 0-1: keep balloon with cost 3, remove balloon with cost 1. Last group 'aa' at positions 3-4: keep balloon with cost 5, remove balloon with cost 4. Total removal cost: 1 + 4 = 5.

Example 2 — Multiple Consecutive Groups

$ Input: colors = "aaabbbaaab", neededTime = [1,3,2,5,4,9,8,1,3,6]

› Output: 21

💡 Note: Group 'aaa': keep cost 3, remove costs 1+2=3. Group 'bbb': keep cost 9, remove costs 5+4=9. Group 'aaa': keep cost 3, remove costs 8+1=9. Single 'b': keep cost 6. Total: 3+9+9=21 removal cost.

Example 3 — No Consecutive Same Colors

$ Input: colors = "abaca", neededTime = [1,2,3,4,5]

› Output: 0

💡 Note: All balloons have different colors from their neighbors, so no removals needed.

Constraints

n == colors.length == neededTime.length
1 ≤ n ≤ 10⁵
1 ≤ neededTime[i] ≤ 10⁴
colors contains only lowercase English letters

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8 f Facebook 6

The key insight is that for any group of consecutive same-colored balloons, we should keep only the one with maximum removal time and remove all others. The optimal approach uses a greedy single-pass algorithm that processes each group independently. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2^n) Space: O(n)

For each balloon, we have two choices: keep it or remove it. We try all 2^n combinations, check if the result has no consecutive same colors, and track the minimum removal cost among valid arrangements.

Greedy - Single Pass with Group Processing

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

We iterate through the rope and whenever we find consecutive balloons of the same color, we keep track of the group and remove all balloons except the one with maximum removal time. This ensures minimum cost while maintaining the colorful property.

Two Pointers - Adjacent Comparison

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

We use two pointers starting at adjacent positions. When colors match, we remove the balloon with smaller removal time and update pointers accordingly. This approach processes the string in a single pass while handling consecutive duplicates efficiently.

Brute Force - Try All Combinations — Algorithm Steps

Generate all 2^n possible subsets of balloons to remove
For each subset, check if remaining balloons form a valid colorful rope
Track the minimum cost among all valid arrangements

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n possible removal combinations

Validate Each

Check if remaining balloons form valid colorful rope

Find Minimum

Track the lowest cost among valid arrangements

Code -

solution.c — C

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

int isValid(char* colors, int* remaining, int remainingSize) {
    for (int i = 1; i < remainingSize; i++) {
        if (colors[remaining[i]] == colors[remaining[i-1]]) {
            return 0;
        }
    }
    return 1;
}

int minCostGlobal = INT_MAX;

void backtrack(char* colors, int* neededTime, int n, int index, int* removed, int cost) {
    if (index == n) {
        int remaining[1000];
        int remainingSize = 0;
        for (int i = 0; i < n; i++) {
            if (!removed[i]) {
                remaining[remainingSize++] = i;
            }
        }
        if (isValid(colors, remaining, remainingSize)) {
            if (cost < minCostGlobal) {
                minCostGlobal = cost;
            }
        }
        return;
    }
    
    backtrack(colors, neededTime, n, index + 1, removed, cost);
    
    removed[index] = 1;
    backtrack(colors, neededTime, n, index + 1, removed, cost + neededTime[index]);
    removed[index] = 0;
}

int solution(char* colors, int* neededTime, int n) {
    minCostGlobal = INT_MAX;
    int removed[1000] = {0};
    backtrack(colors, neededTime, n, 0, removed, 0);
    return minCostGlobal == INT_MAX ? 0 : minCostGlobal;
}

int main() {
    char colors[1001];
    fgets(colors, sizeof(colors), stdin);
    colors[strcspn(colors, "\n")] = 0;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int neededTime[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        neededTime[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(colors, neededTime, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate 2^n subsets and validate each one

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth for generating subsets

⚡ Linearithmic Space

89.5K Views

Medium Frequency

~15 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler