Constructing Two Increasing Arrays - Practice Coding Problems

Constructing Two Increasing Arrays - Problem

You're tasked with a fascinating array transformation challenge! Given two binary arrays nums1 and nums2 (containing only 0s and 1s), you need to replace each element with positive integers following these rules:

Replace every 0 with an even positive integer
Replace every 1 with an odd positive integer
Both arrays must remain strictly increasing after replacement
Each integer can be used at most once across both arrays

Your goal is to minimize the largest number that appears in either array after the transformation.

Example: If nums1 = [0,1] and nums2 = [1,0], you could transform them to [2,3] and [1,4] respectively. The largest number is 4, but can you do better?

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [0,1], nums2 = [1,0]

› Output: 4

💡 Note: We can replace nums1 with [2,3] and nums2 with [1,4]. Both arrays are increasing, all numbers are unique, and the maximum is 4.

example_2.py — Longer Arrays

$ Input: nums1 = [0,1,1], nums2 = [1,0,1]

› Output: 6

💡 Note: Optimal assignment: nums1 = [2,3,5] and nums2 = [1,4,6]. Maximum value is 6.

example_3.py — Single Elements

$ Input: nums1 = [1], nums2 = [0]

› Output: 2

💡 Note: nums1 = [1], nums2 = [2]. The maximum is 2.

Constraints

1 ≤ nums1.length, nums2.length ≤ 100
nums1[i], nums2[i] ∈ {0, 1}
Each positive integer can be used at most once
Both resulting arrays must be strictly increasing

Visualization

Tap to expand

Understanding the Visualization

Count Requirements

Count how many even seats (aisle) and odd seats (center) each group needs

Merge by Position

Combine requirements from both groups, sorted by seating position

Binary Search Maximum

Find the minimum highest seat number needed

Greedy Assignment

For each requirement, assign the smallest available seat of correct type

Key Takeaway

🎯 Key Insight: Binary search on the maximum value combined with greedy assignment of the smallest available numbers ensures optimal solution while maintaining all constraints.

Asked in

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

The optimal solution uses binary search on the answer combined with greedy assignment. We binary search on the maximum possible value, and for each candidate maximum, we greedily assign the smallest available numbers of the correct parity (even/odd) while maintaining the increasing constraint. This achieves O(n log(max_answer)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Combinations)	O(k^n)	O(n)	Try all possible valid assignments and find the minimum largest number
Binary Search on Answer	O(n log(max_answer))	O(n)	Binary search on the maximum value, then greedily assign numbers

Brute Force (Generate All Combinations) — Algorithm Steps

Calculate total numbers needed (sum of both array lengths)
Generate all possible assignments of even/odd numbers
For each assignment, check if both arrays are strictly increasing
Verify no number is used more than once
Track the minimum largest number across all valid assignments

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty assignments for both arrays

Branch

For each position, try all valid even/odd numbers

Validate

Check if assignment creates increasing arrays with no duplicates

Track Minimum

Keep track of the minimum largest number found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>

bool isValidAssignment(int* arr1, int size1, int* arr2, int size2) {
    // Simple validation - check for duplicates and increasing order
    for (int i = 0; i < size1; i++) {
        for (int j = 0; j < size2; j++) {
            if (arr1[i] == arr2[j]) return false;
        }
    }
    for (int i = 1; i < size1; i++) {
        if (arr1[i] <= arr1[i-1]) return false;
    }
    for (int i = 1; i < size2; i++) {
        if (arr2[i] <= arr2[i-1]) return false;
    }
    return true;
}

int backtrack(int idx1, int idx2, int* assignment1, int size1, 
             int* assignment2, int size2, int nextNum,
             int* nums1, int len1, int* nums2, int len2) {
    if (idx1 == len1 && idx2 == len2) {
        if (isValidAssignment(assignment1, size1, assignment2, size2)) {
            int max1 = 0, max2 = 0;
            for (int i = 0; i < size1; i++) {
                if (assignment1[i] > max1) max1 = assignment1[i];
            }
            for (int i = 0; i < size2; i++) {
                if (assignment2[i] > max2) max2 = assignment2[i];
            }
            return max1 > max2 ? max1 : max2;
        }
        return INT_MAX;
    }
    
    int minMax = INT_MAX;
    
    if (idx1 < len1) {
        int neededParity = nums1[idx1] % 2;
        for (int num = nextNum; num < nextNum + 50; num++) {
            if (num % 2 == neededParity) {
                assignment1[size1] = num;
                int result = backtrack(idx1 + 1, idx2, assignment1, size1 + 1,
                                     assignment2, size2, num + 1, nums1, len1, nums2, len2);
                if (result < minMax) minMax = result;
                break;
            }
        }
    }
    
    return minMax;
}

int constructTwoArrays(int* nums1, int len1, int* nums2, int len2) {
    int assignment1[100], assignment2[100];
    return backtrack(0, 0, assignment1, 0, assignment2, 0, 1, nums1, len1, nums2, len2);
}

int main() {
    int nums1[] = {0, 1};
    int nums2[] = {1, 0};
    printf("%d\n", constructTwoArrays(nums1, 2, nums2, 2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Where k is the range of numbers we need to try and n is total elements. We try all combinations.

✓ Linear Growth

Space Complexity

O(n)

Space for storing current assignment and tracking used numbers

⚡ Linearithmic Space

24.4K Views

Medium Frequency

~25 min Avg. Time

847 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 (Generate All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler