Minimum Moves to Get a Peaceful Board - Practice Coding Problems

Minimum Moves to Get a Peaceful Board - Problem

Minimum Moves to Get a Peaceful Board

You are given an n × n chessboard with n rooks placed on it. The positions of the rooks are given as a 2D array rooks where rooks[i] = [xi, yi] represents the position of the i-th rook.

Your goal is to rearrange the rooks so that the board becomes peaceful. A board is peaceful when there is exactly one rook in each row and exactly one rook in each column.

You can move rooks one cell at a time, either vertically or horizontally to adjacent cells. However, no two rooks can occupy the same cell at any point during the moves.

Return the minimum number of moves required to make the board peaceful.

Example: If you have 3 rooks on a 3×3 board at positions [[0,0], [1,0], [2,2]], you need to move them so each row and column has exactly one rook, like [[0,0], [1,1], [2,2]].

Input & Output

example_1.py — Simple Case

$ Input: rooks = [[0,0],[1,0],[2,2]]

› Output: 1

💡 Note: Move the rook from (1,0) to (1,1). Now we have rooks at (0,0), (1,1), (2,2) - each row and column has exactly one rook.

example_2.py — All Same Row

$ Input: rooks = [[0,0],[0,1],[0,2]]

› Output: 3

💡 Note: All rooks are in row 0. We need to move them to (0,0), (1,1), (2,2). Total moves: |0-1| + |1-1| + |2-2| + |0-0| + |1-1| + |2-2| = 1 + 0 + 0 + 0 + 0 + 0 = 3 moves (actually 0 + 3 = 3, where 3 comes from row moves)

example_3.py — Already Peaceful

$ Input: rooks = [[0,0],[1,1],[2,2]]

› Output: 0

💡 Note: The board is already peaceful - each row and column has exactly one rook, so no moves are needed.

Constraints

n == rooks.length
1 ≤ n ≤ 100
rooks[i].length == 2
0 ≤ xi, yi ≤ n - 1
All the values of rooks are unique
The input is guaranteed to have exactly n rooks on an n × n board

Visualization

Tap to expand

Understanding the Visualization

Identify Current State

List all current rook positions and see which rows/columns have conflicts

Define Target

The peaceful arrangement has exactly one rook per row and per column

Apply Greedy Matching

Sort current positions and target positions, then match them optimally

Key Takeaway

🎯 Key Insight: Row and column assignments can be optimized independently using greedy matching of sorted positions, leading to minimum total Manhattan distance.

Asked in

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

The optimal solution uses a greedy approach with O(n log n) time complexity. The key insight is that row moves and column moves are independent. We sort the current rook positions and match them with sorted target positions (0 to n-1 for both rows and columns), then sum up the Manhattan distances.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Permutations)	O(n! × n)	O(n)	Try all possible assignments of rooks to final positions
Greedy Assignment (Optimal)	O(n log n)	O(n)	Sort rooks by position and assign to sorted target positions greedily

Brute Force (Try All Permutations) — Algorithm Steps

Generate all possible target positions (one per row and column)
Try all n! permutations of assigning current rooks to target positions
For each assignment, calculate total Manhattan distance
Return the minimum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Target Positions

Create all valid peaceful arrangements

Try All Assignments

For each permutation, calculate total distance

Find Minimum

Keep track of the assignment with minimum moves

Code -

solution.c — C

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

int minMoves = INT_MAX;

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void permute(int rooks[][2], int targets[][2], int* indices, int n, int start) {
    if (start == n) {
        int totalMoves = 0;
        for (int i = 0; i < n; i++) {
            totalMoves += abs(rooks[i][0] - targets[indices[i]][0]) + 
                         abs(rooks[i][1] - targets[indices[i]][1]);
        }
        if (totalMoves < minMoves) {
            minMoves = totalMoves;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        swap(&indices[start], &indices[i]);
        permute(rooks, targets, indices, n, start + 1);
        swap(&indices[start], &indices[i]);
    }
}

int minimumMoves(int rooks[][2], int n) {
    int targets[n][2];
    for (int i = 0; i < n; i++) {
        targets[i][0] = i;
        targets[i][1] = i;
    }
    
    int indices[n];
    for (int i = 0; i < n; i++) {
        indices[i] = i;
    }
    
    minMoves = INT_MAX;
    permute(rooks, targets, indices, n, 0);
    return minMoves;
}

int main() {
    printf("Implementation needed\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations to try, each requiring O(n) time to calculate distances

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and target positions

⚡ Linearithmic Space

38.2K Views

Medium Frequency

~15 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 (Try All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler