Maximize Active Section with Trade II

Maximize Active Section with Trade II - Problem

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

Additionally, you are 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 in s after making the optimal trade on the substring s[l_i...r_i].

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

Note: For each query, treat s[l_i...r_i] as if it is augmented with a '1' at both ends, forming t = '1' + s[l_i...r_i] + '1'. The augmented '1's do not contribute to the final count. The queries are independent of each other.

Input & Output

Example 1 — Basic Trade

$ Input: s = "10110", queries = [[1,3]]

› Output: [3]

💡 Note: Query [1,3] gives substring "011". Augmented: "1011". We can trade the '1' block (position 0) with '00' block (positions 1-2) to get "100" → 3 ones total in original string.

Example 2 — Multiple Queries

$ Input: s = "1100", queries = [[0,1],[2,3]]

› Output: [2,2]

💡 Note: Query [0,1]: "11" → augmented "111", no beneficial trade. Query [2,3]: "00" → augmented "100", can convert to "111" for 2 total ones.

Example 3 — No Trade Needed

$ Input: s = "111", queries = [[0,2]]

› Output: [3]

💡 Note: All positions are already '1', no trade can improve the count.

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
1 ≤ queries.length ≤ 10⁵
0 ≤ l_i ≤ r_i < s.length

Visualization

Tap to expand

Asked in

G Google 35 f Meta 28 a Amazon 22 M Microsoft 18

This problem requires analyzing binary string trades within query ranges. The key insight is that we need to find the optimal swap between a '1' block and a '0' block after augmenting the substring. The optimized approach uses prefix sums for O(1) counting and efficient block identification. Time: O(Q × N), Space: O(N).

Common Approaches

✓ Bfs

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

Brute Force - Try All Possible Trades

⏱️ Time: O(Q × N³) Space: O(N)

Extract the substring for each query, identify all contiguous blocks of '1's and '0's, then try every combination of swapping one '1' block with one '0' block to find the maximum count.

Optimized with Preprocessing

⏱️ Time: O(N log N + Q log N) Space: O(N)

Build segments for each possible query range once, then use prefix sums and efficient lookups to quickly calculate the optimal trade for each query without recalculating blocks.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_BOXES 1000
#define MAX_LINE 10000

int parseIntArray(char* line, int* arr) {
    int count = 0;
    char* token;
    char* copy = malloc(strlen(line) + 1);
    strcpy(copy, line);
    
    // Remove brackets
    if (copy[0] == '[') copy++;
    if (copy[strlen(copy)-1] == ']') copy[strlen(copy)-1] = '\0';
    
    if (strlen(copy) == 0) {
        free(copy - 1);
        return 0;
    }
    
    token = strtok(copy, ",");
    while (token != NULL && count < MAX_BOXES) {
        arr[count++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    free(copy - 1);
    return count;
}

int parse2DArray(char* line, int arr[][MAX_BOXES], int sizes[]) {
    int count = 0;
    int i = 0;
    int depth = 0;
    char current[MAX_LINE] = "";
    int currentPos = 0;
    
    while (i < strlen(line)) {
        char c = line[i];
        if (c == '[') {
            depth++;
            if (depth == 2) {
                currentPos = 0;
                memset(current, 0, sizeof(current));
            }
        } else if (c == ']') {
            depth--;
            if (depth == 1) {
                current[currentPos] = '\0';
                sizes[count] = 0;
                if (strlen(current) > 0) {
                    char* token = strtok(current, ",");
                    while (token != NULL && sizes[count] < MAX_BOXES) {
                        arr[count][sizes[count]++] = atoi(token);
                        token = strtok(NULL, ",");
                    }
                }
                count++;
            }
        } else if (depth == 2 && c != ',' && c != ' ') {
            current[currentPos++] = c;
        } else if (depth == 2 && c == ',') {
            current[currentPos++] = c;
        }
        i++;
    }
    
    return count;
}

int solution(int status[], int candies[], int keys[][MAX_BOXES], int keySizes[], int containedBoxes[][MAX_BOXES], int boxSizes[], int initialBoxes[], int initialSize, int n) {
    int totalCandies = 0;
    int availableBoxes[MAX_BOXES] = {0};
    int hasKeys[MAX_BOXES] = {0};
    int opened[MAX_BOXES] = {0};
    
    // Initialize available boxes
    for (int i = 0; i < initialSize; i++) {
        availableBoxes[initialBoxes[i]] = 1;
    }
    
    int changed = 1;
    while (changed) {
        changed = 0;
        int openableBoxes[MAX_BOXES];
        int openableCount = 0;
        
        // Check available boxes that can be opened
        for (int i = 0; i < n; i++) {
            if (availableBoxes[i] && !opened[i] && (status[i] == 1 || hasKeys[i])) {
                openableBoxes[openableCount++] = i;
                changed = 1;
            }
        }
        
        // Check all boxes to see if any can be opened with current keys
        for (int i = 0; i < n; i++) {
            if (!opened[i] && !availableBoxes[i] && hasKeys[i]) {
                openableBoxes[openableCount++] = i;
                changed = 1;
            }
        }
        
        // Open all openable boxes
        for (int i = 0; i < openableCount; i++) {
            int box = openableBoxes[i];
            if (!opened[box]) {
                opened[box] = 1;
                totalCandies += candies[box];
                
                // Add keys
                for (int j = 0; j < keySizes[box]; j++) {
                    hasKeys[keys[box][j]] = 1;
                }
                
                // Add contained boxes
                for (int j = 0; j < boxSizes[box]; j++) {
                    availableBoxes[containedBoxes[box][j]] = 1;
                }
                
                availableBoxes[box] = 0;
            }
        }
    }
    
    return totalCandies;
}

int main() {
    char line[MAX_LINE];
    int status[MAX_BOXES], candies[MAX_BOXES], initialBoxes[MAX_BOXES];
    int keys[MAX_BOXES][MAX_BOXES], containedBoxes[MAX_BOXES][MAX_BOXES];
    int keySizes[MAX_BOXES], boxSizes[MAX_BOXES];
    
    fgets(line, sizeof(line), stdin);
    int n = parseIntArray(line, status);
    
    fgets(line, sizeof(line), stdin);
    parseIntArray(line, candies);
    
    fgets(line, sizeof(line), stdin);
    parse2DArray(line, keys, keySizes);
    
    fgets(line, sizeof(line), stdin);
    parse2DArray(line, containedBoxes, boxSizes);
    
    fgets(line, sizeof(line), stdin);
    int initialSize = parseIntArray(line, initialBoxes);
    
    printf("%d\n", solution(status, candies, keys, keySizes, containedBoxes, boxSizes, initialBoxes, initialSize, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.2K Views

Medium Frequency

~35 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