252 lines
6.9 KiB
Markdown
252 lines
6.9 KiB
Markdown
# N-Queens Problem - Simple Explanation 👑
|
||
|
||
## What is the N-Queens Problem? 🤔
|
||
|
||
Imagine you have a chessboard and some queens (the most powerful pieces in chess). The N-Queens problem is like a puzzle where you need to place N queens on an N×N chessboard so that **none of them can attack each other**.
|
||
|
||
### What's a Queen in Chess? ♛
|
||
|
||
A queen is the strongest piece in chess. She can move:
|
||
- **Horizontally** (left and right) ←→
|
||
- **Vertically** (up and down) ↕️
|
||
- **Diagonally** (in any diagonal direction) ↗️↖️↙️↘️
|
||
|
||
She can move as many squares as she wants in these directions!
|
||
|
||
## The Challenge 🎯
|
||
|
||
Let's say we want to solve the **4-Queens problem** (N=4):
|
||
- We have a 4×4 chessboard (16 squares total)
|
||
- We need to place 4 queens
|
||
- **NO queen can attack any other queen**
|
||
|
||
### Example: What Does "Attack" Mean?
|
||
|
||
If we put a queen at position (0,0) - that's the top-left corner - she can attack:
|
||
|
||
```
|
||
Q . . . ← Queen here attacks all positions marked with X
|
||
X . . .
|
||
X . . .
|
||
X . . .
|
||
```
|
||
|
||
```
|
||
Q X X X ← Queen attacks horizontally
|
||
. . . .
|
||
. . . .
|
||
. . . .
|
||
```
|
||
|
||
```
|
||
Q . . . ← Queen attacks diagonally
|
||
. X . .
|
||
. . X .
|
||
. . . X
|
||
```
|
||
|
||
So we can't put any other queen in any of those X positions!
|
||
|
||
## How Our Program Works 🖥️
|
||
|
||
### Step 1: Understanding the Input
|
||
When you run our program like this:
|
||
```bash
|
||
./n_queens 4
|
||
```
|
||
|
||
The number `4` means "solve the 4-Queens problem" (4×4 board with 4 queens).
|
||
|
||
### Step 2: How We Represent the Solution
|
||
|
||
Instead of drawing the whole board, we use a clever trick! Since we know:
|
||
- There must be exactly ONE queen in each row
|
||
- There must be exactly ONE queen in each column
|
||
|
||
We can represent a solution as a list of numbers:
|
||
```
|
||
1 3 0 2
|
||
```
|
||
|
||
This means:
|
||
- **Row 0**: Queen is in column 1
|
||
- **Row 1**: Queen is in column 3
|
||
- **Row 2**: Queen is in column 0
|
||
- **Row 3**: Queen is in column 2
|
||
|
||
### Step 3: Visualizing the Solution
|
||
|
||
If we draw this on a 4×4 board:
|
||
|
||
```
|
||
. Q . . ← Row 0, Column 1
|
||
. . . Q ← Row 1, Column 3
|
||
Q . . . ← Row 2, Column 0
|
||
. . Q . ← Row 3, Column 2
|
||
```
|
||
|
||
Let's check: Can any queen attack another?
|
||
- Queen at (0,1): Can't attack any other queen ✅
|
||
- Queen at (1,3): Can't attack any other queen ✅
|
||
- Queen at (2,0): Can't attack any other queen ✅
|
||
- Queen at (3,2): Can't attack any other queen ✅
|
||
|
||
Perfect! This is a valid solution!
|
||
|
||
## How Our Code Works 🔧
|
||
|
||
### The Main Function (`main`)
|
||
|
||
```c
|
||
int main(int argc, char **argv)
|
||
{
|
||
int n;
|
||
int *queens;
|
||
|
||
if (argc != 2) // Check if user gave us exactly one number
|
||
return (1);
|
||
n = atoi(argv[1]); // Convert the text "4" to number 4
|
||
if (n <= 0) // Make sure the number is positive
|
||
return (1);
|
||
queens = (int *)malloc(sizeof(int) * n); // Create space to store queen positions
|
||
if (!queens) // Check if we got the memory
|
||
return (1);
|
||
solve_nqueens(queens, 0, n); // Start solving from row 0
|
||
free(queens); // Clean up memory
|
||
return (0);
|
||
}
|
||
```
|
||
|
||
**What this does in simple terms:**
|
||
1. "Did the user give me a number?"
|
||
2. "Is it a good number (positive)?"
|
||
3. "Let me create space to remember where I put the queens"
|
||
4. "Now let me solve the puzzle!"
|
||
5. "Clean up when I'm done"
|
||
|
||
### The Solver Function (`solve_nqueens`)
|
||
|
||
This is the "brain" of our program. It uses a technique called **backtracking**:
|
||
|
||
```c
|
||
void solve_nqueens(int *queens, int row, int n)
|
||
{
|
||
int col;
|
||
|
||
if (row == n) // Did I place all queens?
|
||
{
|
||
print_solution(queens, n); // Yes! Print this solution
|
||
return ;
|
||
}
|
||
col = 0;
|
||
while (col < n) // Try each column in this row
|
||
{
|
||
if (is_safe(queens, row, col, n)) // Can I put a queen here?
|
||
{
|
||
queens[row] = col; // Yes! Put the queen here
|
||
solve_nqueens(queens, row + 1, n); // Try the next row
|
||
}
|
||
col++;
|
||
}
|
||
}
|
||
```
|
||
|
||
**Think of it like this:**
|
||
1. "Am I done placing all queens?" → If yes, print the solution!
|
||
2. "If not, let me try putting a queen in each column of this row"
|
||
3. "For each column, ask: Is it safe to put a queen here?"
|
||
4. "If safe, put the queen there and try to solve the next row"
|
||
|
||
### The Safety Check (`is_safe`)
|
||
|
||
This function checks if a queen position is safe:
|
||
|
||
```c
|
||
int is_safe(int *queens, int row, int col, int n)
|
||
{
|
||
int i;
|
||
|
||
i = 0;
|
||
while (i < row) // Check all previously placed queens
|
||
{
|
||
if (queens[i] == col) // Same column?
|
||
return (0); // Not safe!
|
||
if (queens[i] - i == col - row) // Same diagonal (\)?
|
||
return (0); // Not safe!
|
||
if (queens[i] + i == col + row) // Same diagonal (/)?
|
||
return (0); // Not safe!
|
||
i++;
|
||
}
|
||
return (1); // Safe to place queen here!
|
||
}
|
||
```
|
||
|
||
**The three checks:**
|
||
|
||
1. **Same column**: `queens[i] == col`
|
||
- "Is there already a queen in this column?"
|
||
|
||
2. **Diagonal 1**: `queens[i] - i == col - row`
|
||
- "Is there a queen on the same diagonal going from top-left to bottom-right?"
|
||
|
||
3. **Diagonal 2**: `queens[i] + i == col + row`
|
||
- "Is there a queen on the same diagonal going from top-right to bottom-left?"
|
||
|
||
## Example Run 🏃♂️
|
||
|
||
Let's trace through what happens when we run `./n_queens 4`:
|
||
|
||
1. **Start with row 0**: Try putting a queen in each column
|
||
- Column 0: Check safety → Safe! Put queen at (0,0)
|
||
- Move to row 1
|
||
|
||
2. **Row 1**: Try each column
|
||
- Column 0: Not safe (same column as row 0)
|
||
- Column 1: Not safe (same column... wait, no queen there yet)
|
||
- Column 2: Check safety → Safe! Put queen at (1,2)
|
||
- Move to row 2
|
||
|
||
3. **Row 2**: Try each column
|
||
- Column 0: Not safe (diagonal conflict)
|
||
- Column 1: Not safe (diagonal conflict)
|
||
- Column 2: Not safe (same column as row 1)
|
||
- Column 3: Not safe (diagonal conflict)
|
||
- **No solution found!** Go back to row 1
|
||
|
||
4. **Back to row 1**: Try next column
|
||
- Column 3: Check safety → Safe! Put queen at (1,3)
|
||
- Move to row 2
|
||
|
||
5. Continue this process...
|
||
|
||
Eventually, we find: `1 3 0 2` and `2 0 3 1`
|
||
|
||
## Results for Different N Values 📊
|
||
|
||
- **N=1**: `0` (1 solution - just put the queen anywhere)
|
||
- **N=2**: No output (impossible to solve)
|
||
- **N=3**: No output (impossible to solve)
|
||
- **N=4**: `1 3 0 2` and `2 0 3 1` (2 solutions)
|
||
- **N=8**: 92 solutions!
|
||
|
||
## Fun Facts! 🎉
|
||
|
||
1. **Why no solution for N=2 and N=3?**
|
||
- For N=2: You need 2 queens on a 2×2 board, but they'll always attack each other!
|
||
- For N=3: Same problem - not enough space!
|
||
|
||
2. **The 8-Queens problem** (standard chessboard) has exactly **92 solutions**!
|
||
|
||
3. **This is a classic computer science problem** that teaches us about:
|
||
- **Recursion** (functions calling themselves)
|
||
- **Backtracking** (trying something, and if it doesn't work, going back and trying something else)
|
||
- **Problem solving** (breaking a big problem into smaller pieces)
|
||
|
||
## How to Use the Program 💻
|
||
|
||
1. **Compile**: `make`
|
||
2. **Run**: `./n_queens 4`
|
||
3. **Test different values**: `make test`
|
||
4. **Clean up**: `make clean`
|
||
|
||
Try it with different numbers and see what happens! 🚀 |