Arrange a binary string to get maximum value within a range of indices C/C++?

In this problem, we have a binary string consisting of only 0's and 1's, along with M non-intersecting ranges [A1, B1], [A2, B2], ..., [AM, BM]. We need to rearrange the string to maximize the sum within the given ranges while ensuring the result is lexicographically maximum.

Syntax

char* arrangeString(char* binaryStr, int ranges[][2], int m);

Algorithm

The approach involves two main steps −

• First, fill all the given ranges with 1's to maximize the sum
• Then, place remaining 1's from left to right to achieve lexicographical maximum

Example 1: Basic Range Filling

Let's implement the solution for arranging a binary string −

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

void arrangeString(char* str, int ranges[][2], int m, int n) {
    int ones = 0;
    int i, j;
    
    /* Count total number of 1's in original string */
    for(i = 0; i < n; i++) {
        if(str[i] == '1') ones++;
    }
    
    /* Initialize result string with all 0's */
    for(i = 0; i < n; i++) {
        str[i] = '0';
    }
    
    /* Fill 1's in given ranges first */
    for(i = 0; i < m && ones > 0; i++) {
        for(j = ranges[i][0]; j <= ranges[i][1] && ones > 0; j++) {
            str[j] = '1';
            ones--;
        }
    }
    
    /* Place remaining 1's from left to maximize lexicographical order */
    for(i = 0; i < n && ones > 0; i++) {
        if(str[i] == '0') {
            str[i] = '1';
            ones--;
        }
    }
}

int main() {
    char str[] = "11100";
    int ranges[][2] = {{2, 3}, {4, 4}};  /* 0-indexed ranges */
    int m = 2;
    int n = strlen(str);
    
    printf("Original string: %s\n", str);
    arrangeString(str, ranges, m, n);
    printf("Rearranged string: %s\n", str);
    
    return 0;
}

Original string: 11100
Rearranged string: 00111

Example 2: Lexicographical Maximization

Here's an example showing lexicographical maximization with overlapping possibilities −

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

void arrangeStringAdvanced(char* str, int ranges[][2], int m, int n) {
    int ones = 0;
    int i, j;
    
    /* Count total 1's */
    for(i = 0; i < n; i++) {
        if(str[i] == '1') ones++;
    }
    
    /* Reset string to all 0's */
    for(i = 0; i < n; i++) {
        str[i] = '0';
    }
    
    /* Fill ranges with 1's */
    for(i = 0; i < m && ones > 0; i++) {
        for(j = ranges[i][0]; j <= ranges[i][1] && ones > 0; j++) {
            str[j] = '1';
            ones--;
        }
    }
    
    /* Place remaining 1's from leftmost position */
    for(i = 0; i < n && ones > 0; i++) {
        if(str[i] == '0') {
            str[i] = '1';
            ones--;
        }
    }
}

int main() {
    char str[] = "0000111";
    int ranges[][2] = {{0, 0}, {0, 1}};  /* 0-indexed: positions 1,1 and 1,2 become 0,0 and 0,1 */
    int m = 2;
    int n = strlen(str);
    
    printf("Original string: %s\n", str);
    arrangeStringAdvanced(str, ranges, m, n);
    printf("Rearranged string: %s\n", str);
    
    return 0;
}

Original string: 0000111
Rearranged string: 1110000

Key Points

• First priority is to maximize sum in given ranges by placing 1's there
• Second priority is lexicographical maximization by placing remaining 1's from left
• The algorithm ensures optimal solution in O(n + m*k) time complexity where k is average range size

Conclusion

This greedy approach ensures both maximum sum within ranges and lexicographical maximum arrangement. The key insight is prioritizing range filling first, then lexicographical optimization with remaining 1's.