Minimum Operations to Maximize Last Elements in Arrays

Minimum Operations to Maximize Last Elements in Arrays - Problem

Array Enumeration Medium

You're given two integer arrays nums1 and nums2, both with the same length n. Your goal is to make the last element of each array the maximum element in that array using the minimum number of swap operations.

In one operation, you can select any index i and swap nums1[i] with nums2[i]. This means you're swapping elements at the same position between the two arrays.

Victory Conditions:

nums1[n-1] must be the maximum value in nums1
nums2[n-1] must be the maximum value in nums2

Return the minimum number of operations needed to achieve both conditions, or -1 if it's impossible.

Example: If nums1 = [1,2,7] and nums2 = [4,5,3], we can swap at index 0 to get nums1 = [4,2,7] and nums2 = [1,5,3]. Now 7 is max in nums1 and 5 is max in nums2!

Input & Output

example_1.py — Basic Swap

$ Input: nums1 = [1,2,7], nums2 = [4,5,3]

› Output: 1

💡 Note: We need 7 to be max in nums1 and 5 to be max in nums2. By swapping at index 0: nums1 becomes [4,2,7] and nums2 becomes [1,5,3]. Now 7 is the maximum in nums1 and 5 is the maximum in nums2. Total operations: 1.

example_2.py — No Swaps Needed

$ Input: nums1 = [2,3,4], nums2 = [1,2,3]

› Output: 0

💡 Note: nums1[2] = 4 is already the maximum in nums1, and nums2[2] = 3 is already the maximum in nums2. No swaps needed.

example_3.py — Impossible Case

$ Input: nums1 = [1,5,4], nums2 = [2,5,3]

› Output: -1

💡 Note: Both arrays have 5 at index 1, but we need the last elements (4 and 3) to be maximums. Since 5 > 4 and 5 > 3, it's impossible to make the last elements the maximums regardless of any swaps.

Constraints

n == nums1.length == nums2.length
1 ≤ n ≤ 1000
1 ≤ nums1[i], nums2[i] ≤ 1000
Both arrays have the same length
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Identify the Heirs

The last elements of each array are the potential rulers who must become the strongest in their kingdoms.

Scenario Planning

There are only two possible successful outcomes: keep original heirs or swap them between kingdoms.

Calculate Costs

For each scenario, count how many people need to switch kingdoms to ensure the chosen heirs are strongest.

Choose Wisely

Select the scenario that requires the fewest kingdom transfers, ensuring both rulers are legitimately the strongest.

Key Takeaway

🎯 Key Insight: By recognizing that only two final configurations are possible, we reduce an exponential problem to a linear one, checking just two scenarios instead of 2ⁿ combinations!

Asked in

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

The optimal solution recognizes that there are only two possible scenarios for the final state: either keep the original last elements as maximums or swap them. For each scenario, we calculate the minimum swaps needed in O(n) time and return the better option. This avoids the exponential brute force approach and provides an elegant linear time solution.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Scenario Analysis (Optimal)	O(n)	O(1)	Consider only two scenarios: keep last elements or swap them
Brute Force (Try All Combinations)	O(2^n × n)	O(n)	Try every possible combination of swaps and check if conditions are met

Two-Scenario Analysis (Optimal) — Algorithm Steps

Identify the two possible target maximums for each array
Scenario 1: max1 = nums1[n-1], max2 = nums2[n-1]
Scenario 2: max1 = nums2[n-1], max2 = nums1[n-1]
For each scenario, count required swaps to satisfy conditions
Return minimum of both scenarios, or -1 if both impossible

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Scenarios

Only two final states possible: keep last elements or swap them

Scenario 1

Calculate swaps needed if we keep original last elements as maximums

Scenario 2

Calculate swaps needed if we swap the last elements

Choose Minimum

Return the scenario requiring fewer operations

Code -

solution.c — C

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

int calculateOps(int* nums1, int* nums2, int n, int targetMax1, int targetMax2) {
    int ops = 0;
    
    for (int i = 0; i < n; i++) {
        int canKeep = (nums1[i] <= targetMax1 && nums2[i] <= targetMax2);
        int canSwap = (nums2[i] <= targetMax1 && nums1[i] <= targetMax2);
        
        if (!canKeep && !canSwap) {
            return INT_MAX; // Impossible
        }
        
        if (i == n - 1) {
            // Last element must match target exactly
            if (nums1[i] == targetMax1 && canKeep) {
                // Keep as is
            } else if (nums2[i] == targetMax1 && canSwap) {
                ops++; // Swap needed
            } else {
                return INT_MAX; // Impossible
            }
        } else {
            // For other positions, prefer keeping if valid
            if (!canKeep && canSwap) {
                ops++; // Must swap
            }
        }
    }
    
    return ops;
}

int minimumOperations(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    int n = nums1Size;
    
    int scenario1 = calculateOps(nums1, nums2, n, nums1[n-1], nums2[n-1]);
    int scenario2 = calculateOps(nums1, nums2, n, nums2[n-1], nums1[n-1]);
    
    int result = (scenario1 < scenario2) ? scenario1 : scenario2;
    return (result == INT_MAX) ? -1 : result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through arrays for each of the two scenarios

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

43.7K Views

Medium-High Frequency

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

Two-Scenario Analysis (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler