Maximize Active Section with Trade I - Practice Coding Problems

Maximize Active Section with Trade I - Problem

String Enumeration Medium

Maximize Active Section with Trade I

You are managing a system with active and inactive sections represented by a binary string s of length n:

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

You can perform at most one trade to maximize the number of active sections. A trade consists of two operations:

1. Deactivate: Convert a contiguous block of '1's surrounded by '0's to all '0's
2. Activate: Convert a contiguous block of '0's surrounded by '1's to all '1's

The string is treated as if it has virtual '1's at both ends: t = '1' + s + '1'. These virtual sections don't count toward the final result.

Goal: Return the maximum number of active sections possible after making the optimal trade.

Input & Output

example_1.py — Basic Trade

$ Input: s = "01100"

› Output: 3

💡 Note: Original string has 2 ones. We can deactivate the "11" (surrounded by 0s) and activate the "00" (surrounded by 1s after augmentation). Net gain = 2 - 2 = 0. No beneficial trade exists, so return original count of 2... Wait, let me recalculate. Original: "01100" has 2 ones. After augmentation: "1011001". The "11" at positions 2-3 can be deactivated, and "00" at positions 4-5 can be activated. But this gives no net gain. Actually, return 2.

example_2.py — Beneficial Trade

$ Input: s = "0110"

› Output: 3

💡 Note: Original: "0110" has 2 ones. Augmented: "101101". The "11" at positions 2-3 is surrounded by 0s, so can be deactivated (lose 2). The "0" at position 1 is surrounded by 1s, so can be activated (gain 1). Net = 1-2 = -1, not beneficial. The "0" at position 4 is surrounded by 1s, so can be activated (gain 1). Net = 1-2 = -1. No beneficial single trade. Wait... let me reconsider the segments.

example_3.py — No Trade Possible

$ Input: s = "1111"

› Output: 4

💡 Note: All sections are already active. Augmented: "111111". No segments are surrounded by different characters, so no trades are possible. Return original count of 4.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with constant time operations per character

✓ Linear Growth

Space Complexity

O(k)

Where k is number of tradeable segments, typically much smaller than n

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
s consists only of characters '0' and '1'
At most one trade can be performed

Asked in

The optimal solution uses a single-pass approach to identify tradeable segments and calculate maximum gain in O(n) time. By parsing the augmented string once and storing only the lengths of segments that can be deactivated or activated, we avoid redundant string manipulations and achieve the best possible time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Optimal Solution	O(n)	O(k)	Parse segments and calculate optimal trade in one efficient pass
Two-Pass Segment Analysis	O(n²)	O(n)	First pass identifies segments, second pass finds optimal trade
Brute Force (Try All Combinations)	O(n³)	O(n)	Try every possible deactivation and activation combination

Single Pass Optimal Solution — Algorithm Steps

Parse augmented string while tracking segment starts and types
When completing a segment, check if it can be part of a trade
Maintain running lists of segment lengths for deactivation and activation
Calculate maximum gain incrementally without storing full segment details
Return original count plus maximum gain in O(n) time

Visualization

Tap to expand

Step-by-Step Walkthrough

Stream Processing

Parse augmented string character by character, identifying segment boundaries

Immediate Analysis

As each segment completes, immediately check if it's tradeable based on neighbors

Length Collection

Store only the lengths of tradeable segments, not full segment details

Optimal Calculation

Calculate maximum gain from collected lengths without redundant operations

Code -

solution.c — C

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

int maximizeActiveSection(char* s) {
    int n = strlen(s);
    if (n == 0) return 0;
    
    // Count original 1s
    int originalCount = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] == '1') originalCount++;
    }
    
    // Create augmented string
    char* augmented = malloc(n + 3);
    sprintf(augmented, "1%s1", s);
    int augLen = n + 2;
    
    // Arrays to store tradeable segment lengths
    int* deactivateLengths = malloc(augLen * sizeof(int));
    int* activateLengths = malloc(augLen * sizeof(int));
    int deactCount = 0, actCount = 0;
    
    int i = 0;
    while (i < augLen) {
        int j = i;
        while (j < augLen && augmented[j] == augmented[i]) {
            j++;
        }
        
        char currChar = augmented[i];
        
        if (i > 0 && j < augLen) {
            char prevChar = augmented[i - 1];
            char nextChar = augmented[j];
            
            if (currChar == '1' && prevChar == '0' && nextChar == '0') {
                int actualStart = (i - 1 > 0) ? i - 1 : 0;
                int actualEnd = (j - 2 < n - 1) ? j - 2 : n - 1;
                if (actualStart <= actualEnd) {
                    deactivateLengths[deactCount++] = actualEnd - actualStart + 1;
                }
            } else if (currChar == '0' && prevChar == '1' && nextChar == '1') {
                int actualStart = (i - 1 > 0) ? i - 1 : 0;
                int actualEnd = (j - 2 < n - 1) ? j - 2 : n - 1;
                if (actualStart <= actualEnd) {
                    activateLengths[actCount++] = actualEnd - actualStart + 1;
                }
            }
        }
        
        i = j;
    }
    
    // Find maximum gain
    int maxGain = 0;
    for (int i = 0; i < deactCount; i++) {
        for (int j = 0; j < actCount; j++) {
            int gain = activateLengths[j] - deactivateLengths[i];
            if (gain > maxGain) {
                maxGain = gain;
            }
        }
    }
    
    free(augmented);
    free(deactivateLengths);
    free(activateLengths);
    
    return originalCount + maxGain;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with constant time operations per character

✓ Linear Growth

Space Complexity

O(k)

Where k is number of tradeable segments, typically much smaller than n

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
s consists only of characters '0' and '1'
At most one trade can be performed

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Single Pass Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler