Minimum Swaps To Make Sequences Increasing

Minimum Swaps To Make Sequences Increasing - Problem

You're given two integer arrays of the same length, nums1 and nums2. Your mission is to make both arrays strictly increasing using the minimum number of swap operations.

In one operation, you can swap nums1[i] with nums2[i] at any position i. For example:

If nums1 = [1,2,3,8] and nums2 = [5,6,7,4]
Swapping at index 3 gives us nums1 = [1,2,3,4] and nums2 = [5,6,7,8]

Goal: Return the minimum number of swaps needed to make both arrays strictly increasing.

Note: An array is strictly increasing if each element is greater than the previous one: arr[0] < arr[1] < arr[2] < ...

✅ Guaranteed: The input always has a valid solution!

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Swap nums1[3] and nums2[3] to get nums1=[1,3,5,7] and nums2=[1,2,3,4]. Both arrays are now strictly increasing with just 1 swap.

example_2.py — No Swaps Needed

$ Input: nums1 = [0,3,5,8,9], nums2 = [2,1,4,6,9]

› Output: 1

💡 Note: After 1 swap at position 1: nums1=[0,1,5,8,9], nums2=[2,3,4,6,9]. Both sequences become strictly increasing.

example_3.py — Multiple Swaps

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

› Output: 1

💡 Note: Only need to swap at position 3 to make both arrays strictly increasing: nums1=[1,3,5,7], nums2=[1,2,3,4].

Constraints

2 ≤ nums1.length ≤ 10⁵
nums2.length == nums1.length
0 ≤ nums1[i], nums2[i] ≤ 2 × 10⁵
The test cases are generated so that the given input always makes it possible

Visualization

Tap to expand

Understanding the Visualization

Set Initial States

Position 0: keep=0 swaps, swap=1 swap

Check Valid Transitions

For each position, see which previous states allow increasing order

Update Optimally

Choose the path with minimum swaps that maintains the increasing constraint

Return Best Final State

The answer is the minimum of keep and swap at the last position

Key Takeaway

🎯 Key Insight: Dynamic Programming tracks optimal states at each position, making locally optimal decisions that lead to the globally optimal solution with O(n) efficiency.

Asked in

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

The optimal solution uses Dynamic Programming with O(n) time complexity. We track two states at each position: the minimum swaps needed if we keep the current arrangement vs if we swap at this position. The key insight is that at each position, we only need to consider the previous position's state to make the optimal decision while maintaining strictly increasing sequences.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Track swap/no-swap states at each position to find minimum swaps

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP states: keep[i] = min swaps to reach position i without swapping, swap[i] = min swaps with swapping at i
For each position, check which transitions are valid (maintain increasing order)
Update states based on valid transitions: keep[i] = min valid previous states, swap[i] = min valid previous states + 1
Return minimum of final states: min(keep[n-1], swap[n-1])

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize States

keep=0 (no swap), swap=1 (swap at position 0)

Check Transitions

For each position, check which previous states allow valid increasing sequences

Update States

Calculate new keep/swap values based on valid transitions

Return Minimum

Final answer is min(keep, swap) at the last position

Code -

solution.c — C

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

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

int minSwap(int* nums1, int* nums2, int n) {
    int keep = 0, swap = 1;
    
    for (int i = 1; i < n; i++) {
        int newKeep = INT_MAX;
        int newSwap = INT_MAX;
        
        // Case 1: Natural increasing order
        if (nums1[i] > nums1[i-1] && nums2[i] > nums2[i-1]) {
            newKeep = min(newKeep, keep);
            newSwap = min(newSwap, swap + 1);
        }
        
        // Case 2: Cross increasing order
        if (nums1[i] > nums2[i-1] && nums2[i] > nums1[i-1]) {
            newKeep = min(newKeep, swap);
            newSwap = min(newSwap, keep + 1);
        }
        
        keep = newKeep;
        swap = newSwap;
    }
    
    return min(keep, swap);
}

int main() {
    printf("DP solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the arrays, constant work per position

✓ Linear Growth

Space Complexity

O(1)

Only storing two state variables (keep, swap) at any time

✓ Linear Space

89.1K Views

Medium Frequency

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler