Minimum Moves to Spread Stones Over Grid - Practice Coding Problems

Minimum Moves to Spread Stones Over Grid - Problem

You are given a 3×3 grid containing exactly 9 stones distributed across the cells. Some cells may have multiple stones, while others might be empty.

Your goal is to redistribute the stones so that each cell contains exactly one stone. In each move, you can transfer a single stone from one cell to an adjacent cell (sharing a side - no diagonal moves allowed).

Find the minimum number of moves required to achieve this balanced distribution.

Example:

Grid: [[1,1,0],
       [1,1,1],
       [1,2,1]]

Target: [[1,1,1],
         [1,1,1],
         [1,1,1]]

The challenge is to find the most efficient way to move stones from cells with excess stones to empty cells.

Input & Output

example_1.py — Basic Grid

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

› Output: 3

💡 Note: We need to move 1 stone from position (2,1) which has 2 stones to position (0,2) which has 0 stones. The Manhattan distance is |2-0| + |1-2| = 3 moves.

example_2.py — Multiple Redistributions

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

› Output: 4

💡 Note: We have excess stones at (0,1) and (0,2), and empty cells at (1,2) and (2,0). Optimal assignment: (0,1)→(1,2) costs 2 moves, (0,2)→(2,0) costs 4 moves. Total: 6 moves. Wait, let me recalculate: (0,1)→(2,0) costs 3, (0,2)→(1,2) costs 1. Total: 4 moves.

example_3.py — Already Balanced

$ Input: grid = [[1,1,1],[1,1,1],[1,1,1]]

› Output: 0

💡 Note: The grid is already perfectly balanced with exactly one stone in each cell, so no moves are needed.

Constraints

grid.length == 3
grid[i].length == 3
0 ≤ grid[i][j] ≤ 9
The total number of stones is exactly 9
Stones can only be moved to adjacent cells (sharing a side)

Visualization

Tap to expand

Understanding the Visualization

Survey the Warehouse

Identify overcrowded storage areas and empty spots that need filling

Plan Optimal Routes

Calculate Manhattan distances between sources and destinations

Execute Redistribution

Move items along the shortest paths to minimize total effort

Achieve Balance

Every storage location now has exactly one item

Key Takeaway

🎯 Key Insight: This is a minimum cost bipartite matching problem solved by trying all possible assignments between excess stones and empty cells, calculating Manhattan distances for each assignment.

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

This problem is a minimum cost assignment problem where we need to optimally match excess stones with empty cells. The key insight is to find all positions with more than 1 stone and all empty positions, then calculate the minimum total Manhattan distance for all possible assignments. Since we have at most 8 stones to move in a 3×3 grid, trying all permutations is feasible with O(8!) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Permutations)	O(k!)	O(k)	Try all possible ways to assign excess stones to empty cells

Brute Force (All Permutations) — Algorithm Steps

Identify cells with more than 1 stone (sources) and cells with 0 stones (destinations)
Create lists of excess stone positions and empty cell positions
Generate all possible assignments (permutations) between sources and destinations
For each assignment, calculate total Manhattan distance
Return the minimum total distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Sources & Destinations

Find cells with excess stones (>1) and empty cells (=0)

Generate Assignments

Try all possible ways to assign excess stones to empty cells

Calculate Distances

For each assignment, sum up Manhattan distances

Find Minimum

Return the assignment with minimum total distance

Code -

solution.c — C

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

struct Point {
    int x, y;
};

int abs_val(int x) {
    return x < 0 ? -x : x;
}

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

void permute(struct Point* destinations, int start, int end, struct Point* sources, int* minMoves) {
    if (start == end) {
        int totalMoves = 0;
        for (int i = 0; i <= end; i++) {
            totalMoves += abs_val(sources[i].x - destinations[i].x) + 
                         abs_val(sources[i].y - destinations[i].y);
        }
        if (totalMoves < *minMoves) {
            *minMoves = totalMoves;
        }
        return;
    }
    
    for (int i = start; i <= end; i++) {
        swap(&destinations[start], &destinations[i]);
        permute(destinations, start + 1, end, sources, minMoves);
        swap(&destinations[start], &destinations[i]);
    }
}

int minimumMoves(int grid[3][3]) {
    struct Point sources[8], destinations[8];
    int srcCount = 0, destCount = 0;
    
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (grid[i][j] > 1) {
                for (int k = 0; k < grid[i][j] - 1; k++) {
                    sources[srcCount++] = (struct Point){i, j};
                }
            } else if (grid[i][j] == 0) {
                destinations[destCount++] = (struct Point){i, j};
            }
        }
    }
    
    int minMoves = INT_MAX;
    permute(destinations, 0, destCount - 1, sources, &minMoves);
    return minMoves;
}

int main() {
    int grid[3][3] = {{1,1,0},{1,1,1},{1,2,1}};
    printf("%d\n", minimumMoves(grid));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k!)

Where k is the number of stones to move (at most 8). We try all k! permutations of assignments.

✓ Linear Growth

Space Complexity

O(k)

Space for storing source and destination positions, plus recursion stack for permutations.

✓ Linear Space

28.6K Views

Medium Frequency

~15 min Avg. Time

1.2K 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 (All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler