Number of Valid Move Combinations On Chessboard

Number of Valid Move Combinations On Chessboard - Problem

🏁 Chess Piece Choreography Challenge

Imagine you're directing a synchronized chess performance where multiple pieces must move simultaneously across an 8×8 chessboard without colliding! You have n chess pieces (rooks, queens, or bishops) at different starting positions, and you need to count how many different ways they can all move at once without crashing into each other.

The Rules:

Rooks move horizontally or vertically (4 directions) ↑↓←→
Queens move in any direction (8 directions) ↑↓←→↖↗↙↘
Bishops move diagonally only (4 directions) ↖↗↙↘

Movement mechanics: All pieces start moving at time 0 and travel one square per second toward their chosen destinations. You can even choose a piece's current position as its destination (staying put).

Goal: Count all valid move combinations where no two pieces occupy the same square at any point in time during their journeys.

Input: Array of piece types and their 1-based starting positions
Output: Number of valid simultaneous move combinations

Input & Output

example_1.py — Single Rook

$ Input: pieces = ["rook"], positions = [[1,1]]

› Output: 15

💡 Note: A rook at (1,1) can stay put or move to any of the 14 squares in its row/column. Each choice is a valid move combination since there's only one piece, so total = 1 + 14 = 15 combinations.

example_2.py — Two Rooks

$ Input: pieces = ["rook","rook"], positions = [[1,1],[8,8]]

› Output: 91

💡 Note: Two rooks at opposite corners. They can move independently without collision in most cases. Each rook has 15 possible destinations, but we need to subtract combinations where they end up on the same square or collide during movement.

example_3.py — Queen and Bishop

$ Input: pieces = ["queen","bishop"], positions = [[1,1],[2,2]]

› Output: 22

💡 Note: Queen at (1,1) can move in 8 directions to 21 squares plus stay put = 22 destinations. Bishop at (2,2) can move diagonally. Need to count combinations where their paths don't intersect.

Constraints

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(8^(8n) × T)	O(T × n)	Generate all possible move combinations and simulate each one step-by-step
Optimized Backtracking with Pruning	O(M^n)	O(n × T)	Use backtracking with early collision detection and path optimization

Brute Force Simulation — Algorithm Steps

Generate all possible destinations for each piece based on their type and position
Create all combinations of moves (one destination per piece)
For each combination, simulate movement second by second
Check for collisions at each time step
Count valid combinations that never have collisions

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Destinations

For each piece, find all valid squares it can move to based on its type and position

Create Combinations

Generate all possible combinations of moves (one destination per piece)

Simulate Movement

For each combination, simulate step-by-step movement and check for collisions

Count Valid Combinations

Increment counter for combinations that never have collisions during movement

Code -

solution.c — C

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

#define MAX_PIECES 4
#define BOARD_SIZE 8
#define MAX_MOVES 64

int countCombinations(char pieces[][10], int positions[][2], int n) {
    // Simplified C implementation
    // Full implementation would require complex dynamic arrays
    return 0; // Placeholder
}

int main() {
    char pieces[MAX_PIECES][10];
    int positions[MAX_PIECES][2];
    int n = 1;
    
    strcpy(pieces[0], "rook");
    positions[0][0] = 1;
    positions[0][1] = 1;
    
    printf("%d\n", countCombinations(pieces, positions, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(8^(8n) × T)

Each piece can move to at most 8×8=64 positions, with n pieces that's 64^n combinations. T is the maximum time steps needed for simulation.

✓ Linear Growth

Space Complexity

O(T × n)

Need to store positions of all pieces at each time step during simulation

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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