Share 8 queens problem c#

[organicsnake981]

## 8 vấn đề của nữ hoàng trong C#

Vấn đề 8 Queens là một vấn đề kinh điển trong khoa học máy tính.Mục tiêu là đặt tám nữ hoàng lên bàn cờ để không có hai nữ hoàng nào có thể tấn công nhau.Điều này có nghĩa là không có nữ hoàng nào có thể ở cùng một hàng, cột hoặc đường chéo như một nữ hoàng khác.

Vấn đề 8 Nữ hoàng là một vấn đề đầy thách thức để giải quyết, và có nhiều giải pháp khác nhau.Một giải pháp khả thi là sử dụng thuật toán quay lại.Một thuật toán quay lại bắt đầu bằng một giải pháp không nhất thiết phải chính xác, và sau đó nó thực hiện các thay đổi cho giải pháp cho đến khi nó tìm thấy một giải pháp là chính xác.

Mã sau đây hiển thị thuật toán quay lại để giải quyết vấn đề 8 nữ hoàng trong C#.

`` `C#
// Xác định bàn cờ.
int [,] board = new int [8, 8];

// Hàm đệ quy để giải quyết vấn đề 8 Nữ hoàng.
Void giải quyết (int hàng)
{
// Nếu chúng tôi đã đạt đến hàng cuối cùng, chúng tôi đã tìm ra một giải pháp.
if (hàng == 8)
{
// In giải pháp.
for (int i = 0; i <8; i ++)
{
for (int j = 0; j <8; j ++)
{
Console.Write (board [i, j] == 1? "Q": "_");
}
Console.WriteLine ();
}
}

// Cố gắng đặt một nữ hoàng trong mỗi cột của hàng hiện tại.
for (int cột = 0; cột <8; cột ++)
{
// Kiểm tra xem nữ hoàng có thể được đặt trong cột hiện tại không.
if (iSSAFE (hàng, cột)))
{
// Đặt nữ hoàng vào cột hiện tại.
Bảng [hàng, cột] = 1;

// Gọi giải quyết () ở hàng tiếp theo.
Giải quyết (hàng + 1);

// Loại bỏ nữ hoàng khỏi cột hiện tại.
Bảng [hàng, cột] = 0;
}
}
}

// Kiểm tra xem một nữ hoàng có thể được đặt trong hàng và cột đã cho.
Bool Issafe (Int Row, Int Cột)
{
// Kiểm tra xem có nữ hoàng trong cùng một hàng không.
for (int i = 0; i <cột; i ++)
{
if (board [hàng, i] == 1)
{
trả lại sai;
}
}

// Kiểm tra xem có nữ hoàng trong cùng một cột không.
for (int i = 0; i <row; i ++)
{
if (board [i, cột] == 1)
{
trả lại sai;
}
}

// Kiểm tra xem có nữ hoàng trong các đường chéo không.
for (int i = row-1, j = cột-1; i> = 0 && j> = 0; i--, j--)
{
if (board [i, j] == 1)
{
trả lại sai;
}
}

for (int i = row+1, j = cột+1; i <8 && j <8; i ++, j ++)
{
if (board [i, j] == 1)
{
trả lại sai;
}
}

for (int i = row-1, j = cột+1; i> = 0 && j <8; i--, j ++)
{
if (board [i, j] == 1)
{
trả lại sai;
}
}

for (int i = hàng+1, j = cột-1; i <8 && j> = 0; i ++, j--)
{
if (board [i, j
=======================================
## 8 Queens Problem in C#

The 8 queens problem is a classic problem in computer science. The goal is to place eight queens on a chessboard so that no two queens can attack each other. This means that no queen can be in the same row, column, or diagonal as another queen.

The 8 queens problem is a challenging problem to solve, and there are many different solutions. One possible solution is to use a backtracking algorithm. A backtracking algorithm starts with a solution that is not necessarily correct, and then it makes changes to the solution until it finds a solution that is correct.

The following code shows a backtracking algorithm for solving the 8 queens problem in C#.

```c#
// Define the chessboard.
int[,] board = new int[8, 8];

// Recursive function to solve the 8 queens problem.
void Solve(int row)
{
// If we have reached the last row, we have found a solution.
if (row == 8)
{
// Print the solution.
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
Console.Write(board[i, j] == 1 ? "Q" : "_");
}
Console.WriteLine();
}
}

// Try to place a queen in each column of the current row.
for (int column = 0; column < 8; column++)
{
// Check if the queen can be placed in the current column.
if (IsSafe(row, column))
{
// Place the queen in the current column.
board[row, column] = 1;

// Recursively call Solve() on the next row.
Solve(row + 1);

// Remove the queen from the current column.
board[row, column] = 0;
}
}
}

// Check if a queen can be placed in the given row and column.
bool IsSafe(int row, int column)
{
// Check if there is a queen in the same row.
for (int i = 0; i < column; i++)
{
if (board[row, i] == 1)
{
return false;
}
}

// Check if there is a queen in the same column.
for (int i = 0; i < row; i++)
{
if (board[i, column] == 1)
{
return false;
}
}

// Check if there is a queen in the diagonals.
for (int i = row - 1, j = column - 1; i >= 0 && j >= 0; i--, j--)
{
if (board[i, j] == 1)
{
return false;
}
}

for (int i = row + 1, j = column + 1; i < 8 && j < 8; i++, j++)
{
if (board[i, j] == 1)
{
return false;
}
}

for (int i = row - 1, j = column + 1; i >= 0 && j < 8; i--, j++)
{
if (board[i, j] == 1)
{
return false;
}
}

for (int i = row + 1, j = column - 1; i < 8 && j >= 0; i++, j--)
{
if (board[i, j