lekhathu.nga
New member
#8queens, #C ++, #Chess, #Programming, #Proballsolving ## 8 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.Đó là một vấn đề hoàn thành NP, có nghĩa là không có thuật toán thời gian đa thức được biết đến để giải quyết nó.Tuy nhiên, có một số thuật toán hiệu quả có thể được sử dụng để tìm giải pháp cho vấn đề.
Trong bài viết này, chúng tôi sẽ chỉ ra cách giải quyết vấn đề 8 nữ hoàng trong C ++.Chúng tôi sẽ sử dụng thuật toán quay lại, là một thuật toán đệ quy cố gắng tìm giải pháp bằng cách khám phá tất cả các kết hợp có thể xảy ra của Nữ hoàng.
Bước đầu tiên là xác định cấu trúc dữ liệu để thể hiện trạng thái của bảng.Chúng tôi sẽ sử dụng một loạt các bools 2D, trong đó mỗi phần tử trong mảng đại diện cho việc một nữ hoàng được đặt trong hàng hoặc cột đó hay không.
`` `C ++
Bool Board [8] [8];
`` `
Bước tiếp theo là xác định chức năng quay lại.Hàm này sẽ lấy trạng thái hiện tại của bảng làm đầu vào và cố gắng tìm giải pháp bằng cách đặt nữ hoàng lên bảng.Hàm sẽ trả về true nếu nó tìm thấy một giải pháp và sai.
`` `C ++
Bool BackTrack (int Row) {
// 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) {
trả lại đúng;
}
// Cố gắng đặt một nữ hoàng trong mỗi cột của hàng hiện tại.
for (int col = 0; col <8; col ++) {
// Kiểm tra xem nữ hoàng có thể được đặt trong cột hiện tại không.
if (is_safe (hàng, col)) {
// Đặt nữ hoàng lên bảng.
Bảng [hàng] [col] = true;
// gọi đệ trình chức năng quay lại ở hàng tiếp theo.
if (backtrack (hàng + 1)) {
trả lại đúng;
}
// Nữ hoàng không thể được đặt trong cột hiện tại, vì vậy hãy xóa nó khỏi bảng.
bảng [hàng] [col] = false;
}
}
// Chúng tôi đã thử tất cả các cột có thể trong hàng hiện tại, vì vậy không có giải pháp.
trả lại sai;
}
`` `
Chức năng IS_SAFE kiểm tra xem nữ hoàng có thể được đặt trong một hàng và cột nhất định.Chức năng kiểm tra xem có nữ hoàng trong cùng một hàng, cột hoặc đường chéo khi nữ hoàng được đặt.
`` `C ++
bool is_safe (int row, int col) {
// Kiểm tra xem có nữ hoàng trong cùng một hàng không.
for (int i = 0; i <row; i ++) {
if (board [col]) {
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 <8; i ++) {
if (board [hàng] ) {
trả lại sai;
}
}
// Kiểm tra xem có nữ hoàng trong cùng một đường chéo không.
for (int i = row-1, j = col-1; i> = 0 && j> = 0; i--, j--) {
if (board [j]) {
trả lại sai;
}
}
// Kiểm tra xem có nữ hoàng trong cùng một đường chéo không.
for (int i = row+1, j = col+1; i <8 && j <8; i ++, j ++) {
if (board [j]) {
trả lại sai;
}
}
// Không có nữ hoàng trong cùng một hàng, cột hoặc đường chéo, vì vậy nữ hoàng có thể được đặt.
trả lại đúng;
}
`` `
Chức năng chính chỉ đơn giản gọi chức năng quay lại trên hàng đầu tiên của bảng.Nếu hàm trả về đúng, thì một giải pháp đã được tìm thấy.
`` `C ++
int main () {
// Khởi tạo bảng.
for (int i
=======================================
#8queens, #C++, #Chess, #Programming, #problemsolving ## 8 Queens in C++
The 8 queens problem is a classic problem in computer science. It is an NP-complete problem, meaning that there is no known polynomial-time algorithm to solve it. However, there are a number of efficient algorithms that can be used to find a solution to the problem.
In this article, we will show how to solve the 8 queens problem in C++. We will use a backtracking algorithm, which is a recursive algorithm that tries to find a solution by exploring all possible combinations of queens.
The first step is to define a data structure to represent the state of the board. We will use a 2D array of bools, where each element in the array represents whether or not a queen is placed in that row or column.
```c++
bool board[8][8];
```
The next step is to define the backtracking function. This function will take the current state of the board as input and try to find a solution by placing queens on the board. The function will return true if it finds a solution, and false otherwise.
```c++
bool backtrack(int row) {
// If we have reached the last row, we have found a solution.
if (row == 8) {
return true;
}
// Try to place a queen in each column of the current row.
for (int col = 0; col < 8; col++) {
// Check if the queen can be placed in the current column.
if (is_safe(row, col)) {
// Place the queen on the board.
board[row][col] = true;
// Recursively call the backtracking function on the next row.
if (backtrack(row + 1)) {
return true;
}
// The queen cannot be placed in the current column, so remove it from the board.
board[row][col] = false;
}
}
// We have tried all possible columns in the current row, so there is no solution.
return false;
}
```
The is_safe function checks if a queen can be placed in a given row and column. The function checks if there is a queen in the same row, column, or diagonal as the queen being placed.
```c++
bool is_safe(int row, int col) {
// Check if there is a queen in the same row.
for (int i = 0; i < row; i++) {
if (board[col]) {
return false;
}
}
// Check if there is a queen in the same column.
for (int i = 0; i < 8; i++) {
if (board[row]) {
return false;
}
}
// Check if there is a queen in the same diagonal.
for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
if (board[j]) {
return false;
}
}
// Check if there is a queen in the same anti-diagonal.
for (int i = row + 1, j = col + 1; i < 8 && j < 8; i++, j++) {
if (board[j]) {
return false;
}
}
// There is no queen in the same row, column, or diagonal, so the queen can be placed.
return true;
}
```
The main function simply calls the backtracking function on the first row of the board. If the function returns true, then a solution has been found.
```c++
int main() {
// Initialize the board.
for (int i
Vấn đề 8 Queens là một vấn đề kinh điển trong khoa học máy tính.Đó là một vấn đề hoàn thành NP, có nghĩa là không có thuật toán thời gian đa thức được biết đến để giải quyết nó.Tuy nhiên, có một số thuật toán hiệu quả có thể được sử dụng để tìm giải pháp cho vấn đề.
Trong bài viết này, chúng tôi sẽ chỉ ra cách giải quyết vấn đề 8 nữ hoàng trong C ++.Chúng tôi sẽ sử dụng thuật toán quay lại, là một thuật toán đệ quy cố gắng tìm giải pháp bằng cách khám phá tất cả các kết hợp có thể xảy ra của Nữ hoàng.
Bước đầu tiên là xác định cấu trúc dữ liệu để thể hiện trạng thái của bảng.Chúng tôi sẽ sử dụng một loạt các bools 2D, trong đó mỗi phần tử trong mảng đại diện cho việc một nữ hoàng được đặt trong hàng hoặc cột đó hay không.
`` `C ++
Bool Board [8] [8];
`` `
Bước tiếp theo là xác định chức năng quay lại.Hàm này sẽ lấy trạng thái hiện tại của bảng làm đầu vào và cố gắng tìm giải pháp bằng cách đặt nữ hoàng lên bảng.Hàm sẽ trả về true nếu nó tìm thấy một giải pháp và sai.
`` `C ++
Bool BackTrack (int Row) {
// 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) {
trả lại đúng;
}
// Cố gắng đặt một nữ hoàng trong mỗi cột của hàng hiện tại.
for (int col = 0; col <8; col ++) {
// Kiểm tra xem nữ hoàng có thể được đặt trong cột hiện tại không.
if (is_safe (hàng, col)) {
// Đặt nữ hoàng lên bảng.
Bảng [hàng] [col] = true;
// gọi đệ trình chức năng quay lại ở hàng tiếp theo.
if (backtrack (hàng + 1)) {
trả lại đúng;
}
// Nữ hoàng không thể được đặt trong cột hiện tại, vì vậy hãy xóa nó khỏi bảng.
bảng [hàng] [col] = false;
}
}
// Chúng tôi đã thử tất cả các cột có thể trong hàng hiện tại, vì vậy không có giải pháp.
trả lại sai;
}
`` `
Chức năng IS_SAFE kiểm tra xem nữ hoàng có thể được đặt trong một hàng và cột nhất định.Chức năng kiểm tra xem có nữ hoàng trong cùng một hàng, cột hoặc đường chéo khi nữ hoàng được đặt.
`` `C ++
bool is_safe (int row, int col) {
// Kiểm tra xem có nữ hoàng trong cùng một hàng không.
for (int i = 0; i <row; i ++) {
if (board [col]) {
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 <8; i ++) {
if (board [hàng] ) {
trả lại sai;
}
}
// Kiểm tra xem có nữ hoàng trong cùng một đường chéo không.
for (int i = row-1, j = col-1; i> = 0 && j> = 0; i--, j--) {
if (board [j]) {
trả lại sai;
}
}
// Kiểm tra xem có nữ hoàng trong cùng một đường chéo không.
for (int i = row+1, j = col+1; i <8 && j <8; i ++, j ++) {
if (board [j]) {
trả lại sai;
}
}
// Không có nữ hoàng trong cùng một hàng, cột hoặc đường chéo, vì vậy nữ hoàng có thể được đặt.
trả lại đúng;
}
`` `
Chức năng chính chỉ đơn giản gọi chức năng quay lại trên hàng đầu tiên của bảng.Nếu hàm trả về đúng, thì một giải pháp đã được tìm thấy.
`` `C ++
int main () {
// Khởi tạo bảng.
for (int i
=======================================
#8queens, #C++, #Chess, #Programming, #problemsolving ## 8 Queens in C++
The 8 queens problem is a classic problem in computer science. It is an NP-complete problem, meaning that there is no known polynomial-time algorithm to solve it. However, there are a number of efficient algorithms that can be used to find a solution to the problem.
In this article, we will show how to solve the 8 queens problem in C++. We will use a backtracking algorithm, which is a recursive algorithm that tries to find a solution by exploring all possible combinations of queens.
The first step is to define a data structure to represent the state of the board. We will use a 2D array of bools, where each element in the array represents whether or not a queen is placed in that row or column.
```c++
bool board[8][8];
```
The next step is to define the backtracking function. This function will take the current state of the board as input and try to find a solution by placing queens on the board. The function will return true if it finds a solution, and false otherwise.
```c++
bool backtrack(int row) {
// If we have reached the last row, we have found a solution.
if (row == 8) {
return true;
}
// Try to place a queen in each column of the current row.
for (int col = 0; col < 8; col++) {
// Check if the queen can be placed in the current column.
if (is_safe(row, col)) {
// Place the queen on the board.
board[row][col] = true;
// Recursively call the backtracking function on the next row.
if (backtrack(row + 1)) {
return true;
}
// The queen cannot be placed in the current column, so remove it from the board.
board[row][col] = false;
}
}
// We have tried all possible columns in the current row, so there is no solution.
return false;
}
```
The is_safe function checks if a queen can be placed in a given row and column. The function checks if there is a queen in the same row, column, or diagonal as the queen being placed.
```c++
bool is_safe(int row, int col) {
// Check if there is a queen in the same row.
for (int i = 0; i < row; i++) {
if (board[col]) {
return false;
}
}
// Check if there is a queen in the same column.
for (int i = 0; i < 8; i++) {
if (board[row]) {
return false;
}
}
// Check if there is a queen in the same diagonal.
for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
if (board[j]) {
return false;
}
}
// Check if there is a queen in the same anti-diagonal.
for (int i = row + 1, j = col + 1; i < 8 && j < 8; i++, j++) {
if (board[j]) {
return false;
}
}
// There is no queen in the same row, column, or diagonal, so the queen can be placed.
return true;
}
```
The main function simply calls the backtracking function on the first row of the board. If the function returns true, then a solution has been found.
```c++
int main() {
// Initialize the board.
for (int i
