Minimum Unlocked Indices to Sort Nums - Practice Coding Problems

Minimum Unlocked Indices to Sort Nums - Problem

Imagine you have a special array of security codes (integers 1, 2, or 3) that needs to be sorted using adjacent swaps. However, some positions are locked and cannot participate in swaps!

You're given:

nums: An array of integers between 1 and 3
locked: A binary array where locked[i] = 1 means position i is locked

Swapping Rules:

You can swap nums[i] and nums[i+1] only if:
• nums[i] - nums[i+1] == 1 (decreasing by exactly 1)
• locked[i] == 0 (position i is unlocked)

Goal: Find the minimum number of positions you need to unlock to make the array sortable. Return -1 if impossible.

Example: nums = [3,1,2], locked = [1,0,1]
We need to unlock position 0 to enable swaps, so answer is 1.

Input & Output

example_1.py — Basic Case

$ Input: nums = [3,1,2], locked = [1,0,1]

› Output: 1

💡 Note: We need to unlock position 2 to enable the swap between positions 1 and 2 (since 2-1=1). After unlocking position 2, we can perform swaps to sort the array: [3,1,2] → [3,2,1] → [2,3,1] → [2,1,3] → [1,2,3].

example_2.py — Already Sorted

$ Input: nums = [1,2,3], locked = [1,1,1]

› Output: 0

💡 Note: The array is already sorted, so no unlocks are needed. Even though all positions are locked, no swaps are required.

example_3.py — Impossible Case

$ Input: nums = [3,2,1], locked = [1,1,1]

› Output: -1

💡 Note: All positions are locked and the array is reverse sorted. Since we can only swap adjacent elements with difference exactly 1, and no swaps are possible with all positions locked, it's impossible to sort this array.

Constraints

1 ≤ nums.length ≤ 20
1 ≤ nums[i] ≤ 3
locked.length == nums.length
locked[i] is either 0 or 1
Only adjacent swaps allowed when nums[i] - nums[i+1] = 1 and locked[i] = 0

Visualization

Tap to expand

Understanding the Visualization

Initial State

Cards [3,1,2] with positions [🔒,🔓,🔒]. Only position 1 can initiate swaps.

Analysis

Need 3→1→2 to become 1→2→3. Check which swaps are possible with current locks.

Strategic Unlock

Unlock position 2 to enable swap between 1 and 2 (since 2-1=1).

Sorting Process

Perform allowed swaps: [3,1,2]→[3,2,1]→[2,3,1]→[2,1,3]→[1,2,3]

Key Takeaway

🎯 Key Insight: This problem combines graph theory with optimization. Elements can only bubble sort within connected components, so we need to strategically unlock positions to bridge components that must exchange elements for proper sorting.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

This problem requires graph analysis to identify connected components of positions that can participate in swaps. The key insight is that elements can only move within their connected components, and we need to find the minimum number of positions to unlock to enable required swaps. The optimal approach uses Union-Find to group positions and analyzes movement requirements within each component.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * n^2)	O(n)	Try all possible combinations of unlocking positions
Connected Components Analysis	O(n²)	O(n)	Find connected components, then determine minimum bridges needed

Brute Force (Try All Combinations) — Algorithm Steps

Generate all 2^n subsets of positions that could be unlocked
For each subset, simulate the bubble sort process with swap constraints
Check if array becomes sorted after all possible swaps
Return minimum subset size that makes array sortable

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all possible combinations of positions to unlock

Test Each Subset

For each combination, simulate the sorting process

Find Minimum

Track the smallest number of unlocks that enables sorting

Code -

solution.c — C

int minimumOperations(int* nums, int numsSize, int* locked, int lockedSize) {
    int minUnlocks = INT_MAX;
    
    for (int mask = 0; mask < (1 << numsSize); mask++) {
        int tempNums[numsSize], tempLocked[numsSize];
        
        for (int i = 0; i < numsSize; i++) {
            tempNums[i] = nums[i];
            tempLocked[i] = locked[i];
            if (mask & (1 << i)) {
                tempLocked[i] = 0;
            }
        }
        
        int changed = 1;
        while (changed) {
            changed = 0;
            for (int i = 0; i < numsSize - 1; i++) {
                if (tempNums[i] - tempNums[i + 1] == 1 && tempLocked[i] == 0) {
                    int temp = tempNums[i];
                    tempNums[i] = tempNums[i + 1];
                    tempNums[i + 1] = temp;
                    changed = 1;
                }
            }
        }
        
        int sorted = 1;
        for (int i = 0; i < numsSize - 1; i++) {
            if (tempNums[i] > tempNums[i + 1]) {
                sorted = 0;
                break;
            }
        }
        
        if (sorted) {
            int unlocks = __builtin_popcount(mask);
            if (unlocks < minUnlocks) {
                minUnlocks = unlocks;
            }
        }
    }
    
    return minUnlocks == INT_MAX ? -1 : minUnlocks;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n^2)

2^n subsets to try, each taking O(n^2) to simulate sorting

⚠ Quadratic Growth

Space Complexity

O(n)

Space for tracking current unlock state and array copy

⚡ Linearithmic Space

23.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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler