Maximize Active Section with Trade II - Practice Coding Problems

Maximize Active Section with Trade II - Problem

Maximize Active Section with Trade II

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. A trade involves:
1. Converting a contiguous block of '1's surrounded by '0's to all '0's
2. Afterward, converting a contiguous block of '0's surrounded by '1's to all '1's

You are also given a 2D array queries, where queries[i] = [l_i, r_i] represents a substring s[l_i...r_i]. For each query, determine the maximum possible number of active sections after making the optimal trade on that substring.

Important: For each query, the substring s[l_i...r_i] is treated as if it's augmented with a '1' at both ends: t = '1' + s[l_i...r_i] + '1'. These augmented '1's don't contribute to the final count.

Return an array answer where answer[i] is the result for queries[i].

Input & Output

example_1.py — Basic Trade

$ Input: s = "10111001011", queries = [[0, 10]]

› Output: [9]

💡 Note: For the entire string with padding '1|10111001011|1', we can trade the isolated '1' at position 1 (lose 1) to gain the '0' block at positions 6-7 (gain 2), resulting in net +1. But better: trade the '1' at position 1 for the '010' block at positions 6-8 (net +2). Total: 7 original + 2 = 9.

example_2.py — Multiple Queries

$ Input: s = "1100101", queries = [[0, 6], [2, 5]]

› Output: [5, 4]

💡 Note: Query 1: Full string '1|1100101|1' → can trade '1' block (size 1) for '0' block (size 2), net +1, total 4+1=5. Query 2: Substring '1|0101|1' → can trade nothing beneficial, stays 2. Wait, let me recalculate: substring has 2 ones, no beneficial trades, result is 2.

example_3.py — No Beneficial Trade

$ Input: s = "111000", queries = [[0, 5]]

› Output: [3]

💡 Note: With padding '1|111000|1', there are no isolated blocks to trade (the '111' is not surrounded by '0's on both sides, nor is '000' surrounded by '1's on both sides). Original count of 3 remains unchanged.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
0 ≤ l_i ≤ r_i < n
s consists only of '0' and '1'
Each query is independent

Visualization

Tap to expand

Understanding the Visualization

Identify Islands & Valleys

Scan the grid to find isolated powered islands ('1' blocks surrounded by '0's) and unpowered valleys ('0' blocks surrounded by '1's)

Find Optimal Trade

Choose the smallest powered island to shut down and the largest unpowered valley to activate

Calculate Net Benefit

If (valley size - island size) > 0, make the trade for a net gain

Apply Strategy

Add the net benefit to the original power count

Key Takeaway

🎯 Key Insight: The optimal strategy always involves the smallest sacrifice for the largest gain, making this a classic greedy optimization problem.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses dynamic programming insight: the best trade always involves giving up the smallest isolated '1' block to gain the largest isolated '0' block. This reduces the problem from O(n³) brute force to O(n) per query by scanning once to find the optimal trade pair.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Trades)	O(q × n³)	O(n)	Try every possible trade combination and pick the best result
Dynamic Programming (Optimal)	O(q × n)	O(n)	Use dynamic programming to track optimal trades in a single pass

Brute Force (Try All Trades) — Algorithm Steps

For each query, extract the substring and add '1' padding
Find all contiguous blocks of '1's surrounded by '0's
Find all contiguous blocks of '0's surrounded by '1's
Try every combination of converting one '1' block and one '0' block
Calculate the net change (gained '1's - lost '1's) for each combination
Return the maximum possible count after the best trade

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Blocks

Find all '1' blocks surrounded by '0's and '0' blocks surrounded by '1's

Try Combinations

For each '1' block, try trading it with each '0' block

Calculate Net Gain

Compute the change: gained '1's - lost '1's

Track Maximum

Keep track of the best trade result

Code -

solution.c — C

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

int max(int a, int b) { return a > b ? a : b; }

int solveQuery(char* s, int l, int r) {
    int len = r - l + 1;
    char* substr = malloc(len + 3);
    substr[0] = '1';
    strncpy(substr + 1, s + l, len);
    substr[len + 1] = '1';
    substr[len + 2] = '\0';
    
    int n = len + 2;
    int onesBlocks[1000][2], zerosBlocks[1000][2];
    int onesCount = 0, zerosCount = 0;
    
    // Find blocks of 1's surrounded by 0's
    for (int i = 1; i < n - 1; i++) {
        if (substr[i] == '1' && substr[i-1] == '0') {
            int start = i;
            while (i < n - 1 && substr[i] == '1') i++;
            if (i < n && substr[i] == '0') {
                onesBlocks[onesCount][0] = start;
                onesBlocks[onesCount][1] = i - 1;
                onesCount++;
            }
        }
    }
    
    // Find blocks of 0's surrounded by 1's
    for (int i = 1; i < n - 1; i++) {
        if (substr[i] == '0' && substr[i-1] == '1') {
            int start = i;
            while (i < n - 1 && substr[i] == '0') i++;
            if (i < n && substr[i] == '1') {
                zerosBlocks[zerosCount][0] = start;
                zerosBlocks[zerosCount][1] = i - 1;
                zerosCount++;
            }
        }
    }
    
    // Count original 1's
    int originalCount = 0;
    for (int i = 1; i < n - 1; i++) {
        if (substr[i] == '1') originalCount++;
    }
    
    int maxCount = originalCount;
    
    // Try all trades
    for (int i = 0; i < onesCount; i++) {
        int onesLost = onesBlocks[i][1] - onesBlocks[i][0] + 1;
        for (int j = 0; j < zerosCount; j++) {
            int zerosGained = zerosBlocks[j][1] - zerosBlocks[j][0] + 1;
            int newCount = originalCount - onesLost + zerosGained;
            maxCount = max(maxCount, newCount);
        }
    }
    
    free(substr);
    return maxCount;
}

int* maximizeActiveSection(char* s, int** queries, int queriesSize, int* returnSize) {
    *returnSize = queriesSize;
    int* result = malloc(queriesSize * sizeof(int));
    
    for (int i = 0; i < queriesSize; i++) {
        result[i] = solveQuery(s, queries[i][0], queries[i][1]);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × n³)

For each of q queries, we try O(n²) combinations of blocks, each taking O(n) time to evaluate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the augmented substring and block information

⚡ Linearithmic Space

52.4K Views

High Frequency

~25 min Avg. Time

1.8K 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 Trades) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler