#8queensprobol #C ++ #backtracking #Recursion #Programming
## 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.Đó 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 đã biết để giải quyết nó.Tuy nhiên, có một số thuật toán ** heuristic khác nhau có thể được sử dụng để tìm ra giải pháp.
Trong bài viết này, chúng tôi sẽ thảo luận về một thuật toán quay lại để giải quyết vấn đề 8 nữ hoàng trong C ++.Backtracking là một thuật toán đa năng có thể được sử dụng để giải quyết nhiều vấn đề khác nhau.Nó hoạt động bằng cách khám phá đệ quy tất cả các giải pháp có thể cho một vấn đề và quay lại khi đạt đến ngõ cụt.
Vấn đề 8 Nữ hoàng có thể được biểu diễn dưới dạng bàn cờ có 8 hàng và 8 cột.Mục tiêu là đặt 8 nữ hoàng lên bàn cờ để không có nữ hoàng nào có thể tấn công một nữ hoàng khác.Nói cách khác, không có hai nữ hoàng nào có thể ở cùng một hàng, cột hoặc đường chéo.
Thuật toán quay lại để giải quyết vấn đề 8 Queens hoạt động bằng cách bắt đầu với một bàn cờ trống.Sau đó, nó cố gắng đặt một nữ hoàng vào mỗi hàng, mỗi lần một.Khi một nữ hoàng được đặt liên tiếp, thuật toán kiểm tra xem liệu nó có bị tấn công bởi bất kỳ nữ hoàng nào khác không.Nếu nó không bị tấn công, thuật toán sẽ chuyển sang hàng tiếp theo.Nếu nó bị tấn công, thuật toán quay lại và cố gắng đặt nữ hoàng vào một hàng khác.
Thuật toán tiếp tục quay lại và thử các vị trí khác nhau của nữ hoàng cho đến khi tìm thấy một giải pháp.Nếu nó không thể tìm thấy một giải pháp, nó sẽ chấm dứt.
Sau đây là mã giả cho thuật toán quay lại để giải quyết vấn đề 8 nữ hoàng trong C ++:
`` `C ++
#include <Istream>
sử dụng không gian tên STD;
// Xác định bàn cờ là mảng 2D
bo mạch int [8] [8];
// Chức năng kiểm tra xem nữ hoàng có thể được đặt ở một hàng và cột nhất định không
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 <col; i ++) {
if (board [hàng] == 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 [col] == 1) {
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] == 1) {
trả lại sai;
}
}
// Kiểm tra xem có nữ hoàng ở đường chéo đối diện không
for (int i = row+1, j = col-1; i <8 && j> = 0; i ++, j--) {
if (board [j] == 1) {
trả lại sai;
}
}
// Nữ hoàng có thể được đặt trong hàng và cột đã cho
trả lại đúng;
}
// Chức năng để giải quyết vấn đề 8 nữ hoàng
void giải quyết () {
// Khởi tạo bàn cờ vào tất cả các số không
for (int i = 0; i <8; i ++) {
for (int j = 0; j <8; j ++) {
Bảng [j] = 0;
}
}
// Bắt đầu với hàng đầu tiên
int hàng = 0;
// Đặt nữ hoàng đặt trên bàn cờ
while (hàng <8) {
// cố gắng đặt một nữ hoàng vào 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
=======================================
#8queensproblem #C++ #backtracking #Recursion #Programming
## 8 Queens Problem 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 different **heuristic** algorithms that can be used to find a solution.
In this article, we will discuss a backtracking algorithm for solving the 8 queens problem in C++. Backtracking is a general-purpose algorithm that can be used to solve a wide variety of problems. It works by recursively exploring all possible solutions to a problem, and backtracking when a dead end is reached.
The 8 queens problem can be represented as a chessboard with 8 rows and 8 columns. The goal is to place 8 queens on the chessboard so that no queen can attack another queen. In other words, no two queens can be in the same row, column, or diagonal.
The backtracking algorithm for solving the 8 queens problem works by starting with an empty chessboard. It then tries to place a queen in each row, one at a time. When a queen is placed in a row, the algorithm checks to see if it is attacked by any of the other queens. If it is not attacked, the algorithm moves on to the next row. If it is attacked, the algorithm backtracks and tries to place the queen in a different row.
The algorithm continues to backtrack and try different placements of the queens until it finds a solution. If it cannot find a solution, it terminates.
The following is the pseudocode for the backtracking algorithm for solving the 8 queens problem in C++:
```c++
#include <iostream>
using namespace std;
// Define the chessboard as a 2D array
int board[8][8];
// Function to check if a queen can be placed in a given row and column
bool is_safe(int row, int col) {
// Check if there is a queen in the same row
for (int i = 0; i < col; i++) {
if (board[row] == 1) {
return false;
}
}
// Check if there is a queen in the same column
for (int i = 0; i < row; i++) {
if (board[col] == 1) {
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] == 1) {
return false;
}
}
// Check if there is a queen in the opposite diagonal
for (int i = row + 1, j = col - 1; i < 8 && j >= 0; i++, j--) {
if (board[j] == 1) {
return false;
}
}
// The queen can be placed in the given row and column
return true;
}
// Function to solve the 8 queens problem
void solve() {
// Initialize the chessboard to all zeros
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
board[j] = 0;
}
}
// Start with the first row
int row = 0;
// Recursively place queens on the chessboard
while (row < 8) {
// Try to place a queen in the current row
for (int col = 0; col < 8; col++) {
// Check if the queen can be placed in the current column
if (is_safe
## 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.Đó 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 đã biết để giải quyết nó.Tuy nhiên, có một số thuật toán ** heuristic khác nhau có thể được sử dụng để tìm ra giải pháp.
Trong bài viết này, chúng tôi sẽ thảo luận về một thuật toán quay lại để giải quyết vấn đề 8 nữ hoàng trong C ++.Backtracking là một thuật toán đa năng có thể được sử dụng để giải quyết nhiều vấn đề khác nhau.Nó hoạt động bằng cách khám phá đệ quy tất cả các giải pháp có thể cho một vấn đề và quay lại khi đạt đến ngõ cụt.
Vấn đề 8 Nữ hoàng có thể được biểu diễn dưới dạng bàn cờ có 8 hàng và 8 cột.Mục tiêu là đặt 8 nữ hoàng lên bàn cờ để không có nữ hoàng nào có thể tấn công một nữ hoàng khác.Nói cách khác, không có hai nữ hoàng nào có thể ở cùng một hàng, cột hoặc đường chéo.
Thuật toán quay lại để giải quyết vấn đề 8 Queens hoạt động bằng cách bắt đầu với một bàn cờ trống.Sau đó, nó cố gắng đặt một nữ hoàng vào mỗi hàng, mỗi lần một.Khi một nữ hoàng được đặt liên tiếp, thuật toán kiểm tra xem liệu nó có bị tấn công bởi bất kỳ nữ hoàng nào khác không.Nếu nó không bị tấn công, thuật toán sẽ chuyển sang hàng tiếp theo.Nếu nó bị tấn công, thuật toán quay lại và cố gắng đặt nữ hoàng vào một hàng khác.
Thuật toán tiếp tục quay lại và thử các vị trí khác nhau của nữ hoàng cho đến khi tìm thấy một giải pháp.Nếu nó không thể tìm thấy một giải pháp, nó sẽ chấm dứt.
Sau đây là mã giả cho thuật toán quay lại để giải quyết vấn đề 8 nữ hoàng trong C ++:
`` `C ++
#include <Istream>
sử dụng không gian tên STD;
// Xác định bàn cờ là mảng 2D
bo mạch int [8] [8];
// Chức năng kiểm tra xem nữ hoàng có thể được đặt ở một hàng và cột nhất định không
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 <col; i ++) {
if (board [hàng] == 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 [col] == 1) {
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] == 1) {
trả lại sai;
}
}
// Kiểm tra xem có nữ hoàng ở đường chéo đối diện không
for (int i = row+1, j = col-1; i <8 && j> = 0; i ++, j--) {
if (board [j] == 1) {
trả lại sai;
}
}
// Nữ hoàng có thể được đặt trong hàng và cột đã cho
trả lại đúng;
}
// Chức năng để giải quyết vấn đề 8 nữ hoàng
void giải quyết () {
// Khởi tạo bàn cờ vào tất cả các số không
for (int i = 0; i <8; i ++) {
for (int j = 0; j <8; j ++) {
Bảng [j] = 0;
}
}
// Bắt đầu với hàng đầu tiên
int hàng = 0;
// Đặt nữ hoàng đặt trên bàn cờ
while (hàng <8) {
// cố gắng đặt một nữ hoàng vào 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
=======================================
#8queensproblem #C++ #backtracking #Recursion #Programming
## 8 Queens Problem 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 different **heuristic** algorithms that can be used to find a solution.
In this article, we will discuss a backtracking algorithm for solving the 8 queens problem in C++. Backtracking is a general-purpose algorithm that can be used to solve a wide variety of problems. It works by recursively exploring all possible solutions to a problem, and backtracking when a dead end is reached.
The 8 queens problem can be represented as a chessboard with 8 rows and 8 columns. The goal is to place 8 queens on the chessboard so that no queen can attack another queen. In other words, no two queens can be in the same row, column, or diagonal.
The backtracking algorithm for solving the 8 queens problem works by starting with an empty chessboard. It then tries to place a queen in each row, one at a time. When a queen is placed in a row, the algorithm checks to see if it is attacked by any of the other queens. If it is not attacked, the algorithm moves on to the next row. If it is attacked, the algorithm backtracks and tries to place the queen in a different row.
The algorithm continues to backtrack and try different placements of the queens until it finds a solution. If it cannot find a solution, it terminates.
The following is the pseudocode for the backtracking algorithm for solving the 8 queens problem in C++:
```c++
#include <iostream>
using namespace std;
// Define the chessboard as a 2D array
int board[8][8];
// Function to check if a queen can be placed in a given row and column
bool is_safe(int row, int col) {
// Check if there is a queen in the same row
for (int i = 0; i < col; i++) {
if (board[row] == 1) {
return false;
}
}
// Check if there is a queen in the same column
for (int i = 0; i < row; i++) {
if (board[col] == 1) {
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] == 1) {
return false;
}
}
// Check if there is a queen in the opposite diagonal
for (int i = row + 1, j = col - 1; i < 8 && j >= 0; i++, j--) {
if (board[j] == 1) {
return false;
}
}
// The queen can be placed in the given row and column
return true;
}
// Function to solve the 8 queens problem
void solve() {
// Initialize the chessboard to all zeros
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
board[j] = 0;
}
}
// Start with the first row
int row = 0;
// Recursively place queens on the chessboard
while (row < 8) {
// Try to place a queen in the current row
for (int col = 0; col < 8; col++) {
// Check if the queen can be placed in the current column
if (is_safe
