Minimum Time to Remove All Cars Containing Illegal Goods - Problem

You are given a 0-indexed binary string s which represents a sequence of train cars. s[i] = '0' denotes that the ith car does not contain illegal goods and s[i] = '1' denotes that the ith car does contain illegal goods.

As the train conductor, you would like to get rid of all the cars containing illegal goods. You can do any of the following three operations any number of times:

Remove a train car from the left end (i.e., remove s[0]) which takes 1 unit of time.
Remove a train car from the right end (i.e., remove s[s.length - 1]) which takes 1 unit of time.
Remove a train car from anywhere in the sequence which takes 2 units of time.

Return the minimum time to remove all the cars containing illegal goods.

Note: An empty sequence of cars is considered to have no cars containing illegal goods.

Input & Output

Example 1 — Basic Mixed Case

$ Input: s = "1100101"

› Output: 5

💡 Note: Remove the first 2 cars from left (2 units), remove the middle '1' at index 4 individually (2 units), and remove the last car from right (1 unit). Total: 2 + 2 + 1 = 5.

Example 2 — All Illegal

$ Input: s = "11111"

› Output: 5

💡 Note: Remove all 5 cars from either left or right end, each taking 1 unit of time. Total: 5 units.

Example 3 — No Illegal Cars

$ Input: s = "0000"

› Output: 0

💡 Note: No cars contain illegal goods, so no removal is needed. Total: 0 units.

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'

Visualization

Tap to expand

Asked in

G Google 12 f Meta 8 a Amazon 6 M Microsoft 4

The key insight is that removing cars from the ends costs 1 unit each, while removing from middle costs 2 units. We can use dynamic programming to find the optimal combination of left-end removal, individual middle removal, and right-end removal. Time: O(n), Space: O(n)

Common Approaches

✓ Dynamic Programming

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

Build a DP array where dp[i] represents the minimum cost to remove all '1's in s[0..i-1]. For each position, we can either remove individual '1's (cost 2) or remove from left end (cost i+1). This gives us the optimal solution in linear time.

Prefix Sum Optimization

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

Instead of counting '1's in the middle segment repeatedly, precompute prefix sums to get the count in O(1) time. This reduces the time complexity while still trying all possible partitions.

Try All Partitions

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

For each possible partition point, calculate the cost of removing all cars from the left, removing middle '1' cars individually (2 units each), and removing all cars from the right. This explores all possible combinations but is inefficient.

Dynamic Programming — Algorithm Steps

Initialize dp array
For each position i
If s[i] is '0', dp[i+1] = dp[i]
If s[i] is '1', choose min of: dp[i] + 2 (remove individually) or i+1 (remove from left)
Return minimum cost considering right-end removal

Visualization

Tap to expand

Step-by-Step Walkthrough

Build DP

For each position, choose min cost to clear all '1's so far

Two Options

Remove current '1' individually (cost 2) or remove from left (cost i+1)

Consider Right

Try removing suffixes from right end to find global minimum

Code -

solution.c — C

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

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

int solution(char* s) {
    int n = strlen(s);
    if (n == 0) {
        return 0;
    }
    
    // dp[i] = min cost to remove all '1's in s[0:i]
    int* dp = (int*)calloc(n + 1, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        if (s[i] == '0') {
            dp[i + 1] = dp[i];
        } else {  // s[i] == '1'
            // Option 1: remove this '1' individually (cost 2)
            // Option 2: remove everything from left (cost i+1)
            dp[i + 1] = min(dp[i] + 2, i + 1);
        }
    }
    
    // Consider removing from right end
    int min_cost = dp[n];  // Remove all individually or from left
    
    // Try removing suffix of length j from right
    for (int j = 1; j <= n; j++) {
        // Cost = dp[n-j] + j (remove first n-j optimally + remove last j)
        min_cost = min(min_cost, dp[n - j] + j);
    }
    
    int result = min_cost;
    free(dp);
    return result;
}

int main() {
    char s[100001];
    if (fgets(s, sizeof(s), stdin) != NULL) {
        // Remove trailing newline if present
        int len = strlen(s);
        if (len > 0 && s[len-1] == '\n') {
            s[len-1] = '\0';
        }
    }
    
    int result = solution(s);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string with constant work per position

⚠ Quadratic Growth

Space Complexity

O(n)

DP array stores minimum cost for each prefix

✓ Linear Space

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

Minimum Time to Remove All Cars Containing Illegal Goods - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler