Sort Array by Moving Items to Empty Space

Sort Array by Moving Items to Empty Space - Problem

Imagine you have a sliding puzzle where you need to arrange numbered tiles in order! You're given an integer array nums of size n containing each element from 0 to n-1 (inclusive).

Think of it this way:

Elements 1 to n-1 represent numbered tiles
Element 0 represents the empty space
In one operation, you can slide any tile into the empty space

Your goal is to sort the array so that:

All numbered tiles are in ascending order
The empty space is either at the beginning or end

Valid sorted arrangements:

[0,1,2,3] - empty space at start
[1,2,3,0] - empty space at end

Return the minimum number of operations needed to sort the array.

Input & Output

example_1.py — Basic case with one cycle

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

› Output: 2

💡 Note: We can sort to [1,2,3,0] with 2 operations: Move 2 to empty space (pos 3): [0,1,3,2], then move 3 to pos 2: [0,1,2,3]. Wait, let me recalculate... Actually, we need to move 0 to position of 2, then 2 to position of 1, creating a cycle that requires 2 swaps total.

example_2.py — Already sorted case

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

› Output: 0

💡 Note: The array is already sorted with empty space at the beginning, so no operations are needed.

example_3.py — Reverse order case

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

› Output: 3

💡 Note: This creates cycles: 3→0→3 (length 2, needs 1 op) and 2→1→2 (length 2, needs 1 op), but we need to consider the optimal target configuration which gives us 3 operations total.

Constraints

2 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] < nums.length
All the values of nums are unique
nums contains exactly one occurrence of each integer from 0 to n-1

Visualization

Tap to expand

Understanding the Visualization

Identify Valid Targets

There are only two valid sorted arrangements: empty space at start [0,1,2,3] or at end [1,2,3,0]

Find Misplaced Tiles

Compare current arrangement with each target to see which tiles are out of place

Detect Cycles

Misplaced tiles form cycles - each tile needs to move to where another tile currently is

Count Operations

Each cycle of k tiles needs k-1 swap operations to resolve completely

Key Takeaway

🎯 Key Insight: The optimal solution recognizes that this is a permutation cycle problem. Elements in their correct position stay put, while misplaced elements form cycles that can be resolved with k-1 swaps for a cycle of length k.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 31

The optimal solution uses cycle detection to identify groups of misplaced elements. The key insight is that elements already in their correct position don't need to move. For misplaced elements forming cycles, a cycle of length k requires exactly k-1 swap operations to resolve. We try both valid target configurations ([0,1,2,...,n-1] and [1,2,...,n-1,0]) and return the minimum operations needed.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (BFS State Exploration)	O(n! × n)	O(n! × n)	Explore all possible states using BFS until we reach a sorted state
Cycle Detection (Optimal)	O(n)	O(n)	Identify cycles of misplaced elements and count operations needed

Brute Force (BFS State Exploration) — Algorithm Steps

Start from the initial array configuration
Use BFS to explore all possible states by swapping 0 with other elements
For each state, generate all possible next states
Track visited states to avoid cycles
Return the minimum steps when we reach a target sorted state

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with the given array configuration

Generate Neighbors

For each state, generate all possible moves by swapping 0 with other elements

Explore Level by Level

BFS ensures we find the minimum number of operations

Target Found

Return steps when we reach a sorted configuration

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_N 10
#define MAX_STATES 3628800 // 10!

typedef struct {
    int arr[MAX_N];
    int steps;
} State;

int n;
State queue[MAX_STATES];
int visited[MAX_STATES][MAX_N];
int front = 0, rear = 0;
int visitedCount = 0;

int arrayToHash(int* arr, int size) {
    int hash = 0;
    for (int i = 0; i < size; i++) {
        hash = hash * 10 + arr[i];
    }
    return hash % MAX_STATES;
}

int isVisited(int* arr, int size) {
    int hash = arrayToHash(arr, size);
    for (int i = 0; i < visitedCount; i++) {
        if (memcmp(visited[i], arr, size * sizeof(int)) == 0) {
            return 1;
        }
    }
    return 0;
}

void addVisited(int* arr, int size) {
    memcpy(visited[visitedCount], arr, size * sizeof(int));
    visitedCount++;
}

int isTarget(int* arr, int size) {
    // Check target1: [0,1,2,...,n-1]
    int isTarget1 = 1;
    for (int i = 0; i < size; i++) {
        if (arr[i] != i) {
            isTarget1 = 0;
            break;
        }
    }
    
    // Check target2: [1,2,...,n-1,0]
    int isTarget2 = 1;
    for (int i = 0; i < size - 1; i++) {
        if (arr[i] != i + 1) {
            isTarget2 = 0;
            break;
        }
    }
    if (arr[size - 1] != 0) isTarget2 = 0;
    
    return isTarget1 || isTarget2;
}

int minimumOperations(int* nums, int size) {
    n = size;
    front = rear = visitedCount = 0;
    
    if (isTarget(nums, size)) return 0;
    
    memcpy(queue[rear].arr, nums, size * sizeof(int));
    queue[rear].steps = 0;
    rear++;
    addVisited(nums, size);
    
    while (front < rear) {
        State current = queue[front++];
        
        int zeroIdx = -1;
        for (int i = 0; i < size; i++) {
            if (current.arr[i] == 0) {
                zeroIdx = i;
                break;
            }
        }
        
        for (int i = 0; i < size; i++) {
            if (i != zeroIdx) {
                int newState[MAX_N];
                memcpy(newState, current.arr, size * sizeof(int));
                
                // Swap
                int temp = newState[zeroIdx];
                newState[zeroIdx] = newState[i];
                newState[i] = temp;
                
                if (isTarget(newState, size)) {
                    return current.steps + 1;
                }
                
                if (!isVisited(newState, size) && rear < MAX_STATES) {
                    addVisited(newState, size);
                    memcpy(queue[rear].arr, newState, size * sizeof(int));
                    queue[rear].steps = current.steps + 1;
                    rear++;
                }
            }
        }
    }
    
    return -1;
}

int main() {
    int nums[MAX_N];
    int n = 0;
    int x;
    while (scanf("%d", &x) == 1) {
        nums[n++] = x;
    }
    
    printf("%d\n", minimumOperations(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

There are n! possible permutations, and for each state we need O(n) time to generate next states

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Need to store all possible states in the queue and visited set, each state takes O(n) space

⚠ Quadratic Space

41.3K Views

Medium Frequency

~25 min Avg. Time

1.5K 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 (BFS State Exploration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler