Get free ebooK with 50 must do coding Question for Product Based Companies solved
Fill the details & get ebook over email
Thank You!
We have sent the Ebook on 50 Must Do Coding Questions for Product Based Companies Solved over your email. All the best!

# 4 Queen Problem

Last Updated on June 27, 2023 by Mayank Dham

The 4-Queens Problem is a well-known puzzle that involves placing N queens on an N×N chessboard in such a way that no two queens threaten each other. In this article, we will focus on the 4-Queen problem, where we aim to place four queens on a 4×4 chessboard.

## How to Solve the 4 Queen Problem?

To solve this problem, we will use a backtracking algorithm. Backtracking is a technique where we explore all possible solutions by incrementally building the solution and backtracking whenever we find that the current solution is invalid.

## Approach to solve the 4 Queen Problem

1. In the 4-Queen problem, we aim to position four queens (Q1, Q2, Q3, Q4) on a 4×4 chessboard so that no two queens threaten each other.

2. Let’s consider the placement of the first queen, Q1, at position (1, 1) on the chessboard. However, this restricts the options for placing the second queen, Q2, since it cannot be placed in the same row as Q1.

3. After considering the available rows, we decided to place Q2 at (2, 3). However, this choice limits the possibilities for placing the third queen, Q3, as there are no available positions in row

4. In this situation, we need to backtrack to the previous step and reconsider the placement of Q2. We move Q2 to position (2, 4), and now we find a suitable position for Q3 at (3, 2). However, this placement leaves no options for placing the fourth queen, Q4.

5. Once again, we backtrack to the placement of Q1 and modify it to (1, 2) instead of (1, 1). By making this adjustment, we can safely place Q2 at (2, 4), Q3 at (3, 1), and Q4 at (4, 3).

6. Hence, we obtain the solution (2, 4, 1, 3), which represents the positions of the four queens on the chessboard. It is one possible solution for the 4-Queen problem. To find alternative solutions, we would need to backtrack and explore all possible partial solutions.

Another possible solution for the 4-Queen problem is (3, 1, 4, 2).

## Solution to solve 4 queen problem using space tree

To construct the state space tree, we can utilize the backtracking technique, which allows us to explore all possible solutions. By applying this approach, we not only find solutions for the 4-Queen problem but can also extend it to solve the N-Queen problem, where N represents any desired number of queens.

Here is the step-by-step logic for generating the state space tree:

1. Begin by considering each position (column) in the current row.
2. Check all the previous rows to determine if there is already a queen placed in any of the columns.
3. Additionally, check the previous diagonal columns to verify if there is a queen placed in any of those positions.
4. If either of these conditions is true, indicating that two queens would be attacking each other, backtrack to the previous row and move the previous queen one step forward.
5. If none of the previous positions conflict, place the current queen in the current position and move to the next row.

By following this procedure, we can systematically explore the state space, branching out with each decision and backtracking whenever necessary. This enables us to uncover all possible solutions for the N-Queen problem, not just the 4-Queen problem. The state space tree provides a visual representation of the decision-making process and the exploration of different paths to reach valid solutions. Each node in the tree represents a specific configuration of queens on the chessboard, while the edges represent the decisions made to reach that configuration. Through this method, we can exhaustively search the state space to find all the valid solutions to the N-queen problem, where N can be any desired number of queens.

## C++ Implementation of 4 Queen problem

### 4 Queen Problem

```#include
using namespace std;
int a[30], cnt;
int place(int pos)
{
int i;
for (i = 1; i < pos; i++) {
if ((a[i] == a[pos])
|| ((abs(a[i] - a[pos]) == abs(i - pos))))
return 0;
}
return 1;
}
void print_sol(int N)
{
int i, j;
cnt++;
cout << "\n\nSolution " << cnt << ":\n";
for (i = 1; i <= N; i++) {
for (j = 1; j <= N; j++) {
if (a[i] == j)
cout << "Q\t";
else
cout << "*\t";
}
cout << endl;
}
}
void queen(int n)
{
cnt = 0;
int k = 1;
a[k] = 0;
while (k != 0) {
a[k] = a[k] + 1;
while ((a[k] <= n) && !place(k))
a[k]++;
if (a[k] <= n) {
if (k == n)
print_sol(n);
else {
k++;
a[k] = 0;
}
}
else
k--;
}
}
int main()
{
int N = 4;
queen(N);
cout << "\nTotal solutions=" << cnt;
return 0;
}```

Conclusion
In conclusion, the 4-Queen Problem involves placing four queens on a 4×4 chessboard without them threatening each other. By using backtracking, we can systematically explore all possible solutions. This approach can be extended to solve the N-Queen problem. By understanding the concepts and implementing the provided code, we can efficiently find valid queen placements. The 4-Queen problem serves as a stepping stone to tackling larger instances and exploring combinatorial optimization.

Q1. What is the 4-Queen problem?
The 4-Queen problem involves placing four queens on a 4×4 chessboard in such a way that no two queens threaten each other.

Q2. How can I approach the 4-Queen problem?
One approach is to use a backtracking algorithm. Start by placing the first queen and then recursively explore all possible positions for the remaining queens, backtracking whenever conflicts arise.

Q3. Can the 4-Queen problem be solved using a different board size?
Yes, the size of the chessboard can be adjusted to solve the N-Queen problem. For example, for N=8, an 8×8 chessboard would be used.

Q4. Are there multiple solutions to the 4-Queen problem?
Yes, the 4-Queen problem can have multiple valid solutions. Backtracking helps to explore different paths and find alternative queen placements.

Q5. Is the backtracking algorithm the most efficient way to solve the 4-Queen problem?
The backtracking algorithm is suitable for small problem sizes. However, for larger N-Queen problems, more optimized techniques like pruning or additional constraints may be necessary to improve efficiency.