Maximize Active Section with Trade I

Maximize Active Section with Trade I - Problem

String Enumeration Medium

You are given a binary string s of length n, where:

'1' represents an active section
'0' represents an inactive section

You can perform at most one trade to maximize the number of active sections in s.

In a trade, you:

Convert a contiguous block of '1's that is surrounded by '0's to all '0's
Afterward, convert a contiguous block of '0's that is surrounded by '1's to all '1's

Return the maximum number of active sections in s after making the optimal trade.

Note: Treat s as if it is augmented with a '1' at both ends, forming t = '1' + s + '1'. The augmented '1's do not contribute to the final count.

Input & Output

Example 1 — Basic Trade

$ Input: s = "10110"

› Output: 3

💡 Note: Original has 3 ones. No beneficial trade exists: trading any 1-block for 0-block results in net loss or no gain.

Example 2 — Beneficial Trade

$ Input: s = "1001"

› Output: 3

💡 Note: Original has 2 ones. Trade the middle 00 block for one of the 1 blocks: lose 1 one, gain 2 ones, net +1. Result: 2 + 1 = 3.

Example 3 — All Zeros

$ Input: s = "0000"

› Output: 0

💡 Note: No 1-blocks to trade away, so no trade is possible. Result remains 0.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

The key insight is to find blocks of contiguous 1s and 0s, then calculate the net gain for each possible trade. The optimal approach uses direct calculation instead of string simulation. Time: O(b²) where b is number of blocks, Space: O(b)

Common Approaches

✓ Binary Search Answer

⏱️ Time: N/A Space: N/A

Brute Force - Try All Trades

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

For each possible block of 1s to convert to 0s, and each possible block of 0s to convert to 1s, simulate the trade and count the resulting 1s. Keep track of the maximum.

Optimized Enumeration

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

Instead of simulating each trade, pre-compute all blocks and their sizes, then calculate the net gain (zeros gained - ones lost) for each valid trade pair without string manipulation.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int canDistribute(int* candies, int candiesSize, int k, int candyCount) {
    int totalChildren = 0;
    for (int i = 0; i < candiesSize; i++) {
        totalChildren += candies[i] / candyCount;
    }
    return totalChildren >= k;
}

int solution(int* candies, int candiesSize, int k) {
    if (candiesSize == 0 || k == 0) return 0;
    
    int left = 1, right = 0;
    for (int i = 0; i < candiesSize; i++) {
        if (candies[i] > right) {
            right = candies[i];
        }
    }
    
    int result = 0;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canDistribute(candies, candiesSize, k, mid)) {
            result = mid;
            right = mid - 1; // Try smaller values for larger answer
        } else {
            left = mid + 1; // Try larger values
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int candies[1000];
    int candiesSize = 0;
    
    if (strncmp(line, "[]", 2) != 0) {
        char* token = strtok(line + 1, ",]");
        while (token != NULL) {
            candies[candiesSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(candies, candiesSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

3.4K Views

Medium Frequency

~25 min Avg. Time

89 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