Minimize the Maximum of Two Arrays

Minimize the Maximum of Two Arrays - Problem

We have two arrays arr1 and arr2 which are initially empty. You need to add positive integers to them such that they satisfy all the following conditions:

arr1 contains uniqueCnt1 distinct positive integers, each of which is not divisible by divisor1.
arr2 contains uniqueCnt2 distinct positive integers, each of which is not divisible by divisor2.
No integer is present in both arr1 and arr2.

Given divisor1, divisor2, uniqueCnt1, and uniqueCnt2, return the minimum possible maximum integer that can be present in either array.

Input & Output

Example 1 — Basic Case

$ Input: divisor1 = 2, divisor2 = 3, uniqueCnt1 = 1, uniqueCnt2 = 1

› Output: 2

💡 Note: We can put 1 in arr1 (not divisible by 2) and 2 in arr2 (not divisible by 3). The maximum element is 2.

Example 2 — Larger Requirements

$ Input: divisor1 = 3, divisor2 = 5, uniqueCnt1 = 2, uniqueCnt2 = 1

› Output: 3

💡 Note: For maxVal=3: Numbers not divisible by 3: {1,2}. Numbers not divisible by 5: {1,2,3}. arr1 needs 2 elements, takes {1,2}. arr2 needs 1 element from remaining {3}. Maximum element is 3.

Example 3 — Same Divisors

$ Input: divisor1 = 2, divisor2 = 2, uniqueCnt1 = 1, uniqueCnt2 = 1

› Output: 2

💡 Note: Both arrays need elements not divisible by 2. Available: {1,3,5,...}. For maxVal=2, only {1} is available, but we need 2 elements total. For maxVal=3, available: {1,3}. arr1 takes 1, arr2 takes 3. But since we're minimizing maximum and both need elements from same set, minimum maximum is 2 if we can use {1} for one array, but we need 2 distinct elements, so minimum maximum is actually 3.

Constraints

2 ≤ divisor1, divisor2 ≤ 10⁵
1 ≤ uniqueCnt1, uniqueCnt2 ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is to use binary search on the answer space combined with inclusion-exclusion principle to count valid numbers. We search for the minimum possible maximum value where both arrays can be filled with required counts. Best approach is Binary Search on Answer with Time: O(log n), Space: O(1).

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(log n) Space: O(1)

Instead of checking every value linearly, use binary search on the answer space. For each candidate maximum, check if it's possible to fill both arrays.

Brute Force Linear Search

⏱️ Time: O(n) Space: O(1)

For each potential maximum value, count how many valid numbers each array can use. Check if we can satisfy both array requirements without overlap.

Binary Search on Answer — Algorithm Steps

Set search range: left = 1, right = large value
For middle value, check if arrays can be filled
If feasible, search left half; otherwise search right half
Return the minimum feasible maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize bounds

Set left=1, right=upper_bound

Check middle

Test if mid value is feasible

Update bounds

Move left or right based on feasibility

Code -

solution.c — C

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

long long gcd(long long a, long long b) {
    while (b != 0) {
        long long temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

long long lcm(long long a, long long b) {
    return a * b / gcd(a, b);
}

long long min(long long a, long long b) {
    return a < b ? a : b;
}

bool canFill(int maxVal, int divisor1, int divisor2, int uniqueCnt1, int uniqueCnt2) {
    long long lcmVal = lcm(divisor1, divisor2);
    long long only1 = maxVal / divisor2 - maxVal / lcmVal;
    long long only2 = maxVal / divisor1 - maxVal / lcmVal;
    long long both = maxVal - maxVal / divisor1 - maxVal / divisor2 + maxVal / lcmVal;
    
    long long need1 = uniqueCnt1;
    long long used1Only = min(need1, only1);
    need1 -= used1Only;
    
    long long used1Both = min(need1, both);
    need1 -= used1Both;
    long long remainingBoth = both - used1Both;
    
    if (need1 > 0) {
        return false;
    }
    
    long long need2 = uniqueCnt2;
    long long used2Only = min(need2, only2);
    need2 -= used2Only;
    
    long long used2Both = min(need2, remainingBoth);
    need2 -= used2Both;
    
    return need2 <= 0;
}

int solution(int divisor1, int divisor2, int uniqueCnt1, int uniqueCnt2) {
    int left = 1, right = 2 * (uniqueCnt1 + uniqueCnt2);
    int result = right;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canFill(mid, divisor1, divisor2, uniqueCnt1, uniqueCnt2)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

int main() {
    int divisor1, divisor2, uniqueCnt1, uniqueCnt2;
    scanf("%d\n%d\n%d\n%d", &divisor1, &divisor2, &uniqueCnt1, &uniqueCnt2);
    printf("%d\n", solution(divisor1, divisor2, uniqueCnt1, uniqueCnt2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Binary search on answer space, where n is the final answer value

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra variables for binary search bounds

✓ Linear Space

12.5K Views

Medium Frequency

~25 min Avg. Time

450 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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler