huongthao438
New member
## 8 Mã nữ hoàng trong C ++
Câu đố 8 Nữ hoàng 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 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.
Câu đố 8 Nữ hoàng là một vấn đề đầy thách thức, nhưng nó có thể được giải quyết bằng cách sử dụng nhiều thuật toán.Một thuật toán phổ biến là thuật toán quay lại.Thuật toán này bắt đầu bằng cách đặt một nữ hoàng vào hàng đầu tiên của bàn cờ.Sau đó, nó đệ quy để đặt nữ hoàng vào các hàng còn lại, một hàng cùng một lúc.Nếu một nữ hoàng có thể được đặt liên tiếp mà không tấn công bất kỳ nữ hoàng nào trong các hàng trước, thì thuật toán tiếp tục.Mặt khác, thuật toán quay lại và cố gắng đặt một nữ hoàng vào một hàng khác.
Thuật toán quay lại cho 8 câu đố của Nữ hoàng được triển khai trong mã C ++ sau:
`` `C ++
#include <Istream>
sử dụng không gian tên STD;
// Xác định kích thước của bàn cờ.
const int n = 8;
// Xác định một chức năng để kiểm tra xem một nữ hoàng có thể được đặt trong 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 <row; i ++) {
if (board [col] == 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 <n; i ++) {
if (board [hàng] == 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 trong cùng một đường chéo không.
for (int i = row+1, j = col+1; i <n && j <n; 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;
}
// Xác định một hàm để giải câu đố 8 Nữ hoàng.
void giải quyết () {
// Khởi tạo bàn cờ.
bo mạch int [n] [n] = {0};
// Đặt nữ hoàng đầu tiên vào hàng đầu tiên.
Bảng [0] [0] = 1;
// đệ quy cố gắng đặt các nữ hoàng còn lại.
for (int i = 1; i <n; i ++) {
for (int j = 0; j <n; j ++) {
// Kiểm tra xem nữ hoàng có thể được đặt trong hàng và cột đã cho.
if (is_safe (i, j)) {
// Đặt nữ hoàng vào hàng và cột đã cho.
Bảng [j] = 1;
// đệ quy cố gắng đặt các nữ hoàng còn lại.
gỡ rối();
// Backtrack và loại bỏ nữ hoàng khỏi hàng và cột đã cho.
Bảng [j] = 0;
}
}
}
}
// Hàm chính.
int main () {
// Giải câu đố 8 Nữ hoàng.
gỡ rối();
// In giải pháp.
for (int i = 0; i <n; i ++) {
for (int j = 0; j <n; j ++) {
cout << board [j] << "";
}
cout << endl;
}
trả lại 0;
}
`` `
Mã này in
=======================================
## 8 Queen Code in C++
The 8 queens puzzle is a classic problem in computer science. The goal is to place eight queens on a chessboard so that no two queens attack each other. This means that no queen can be in the same row, column, or diagonal as another queen.
The 8 queens puzzle is a challenging problem, but it can be solved using a variety of algorithms. One common algorithm is the backtracking algorithm. This algorithm starts by placing a queen in the first row of the chessboard. Then, it recursively tries to place queens in the remaining rows, one row at a time. If a queen can be placed in a row without attacking any of the queens in the previous rows, then the algorithm continues. Otherwise, the algorithm backtracks and tries to place a queen in a different row.
The backtracking algorithm for the 8 queens puzzle is implemented in the following C++ code:
```c++
#include <iostream>
using namespace std;
// Define the size of the chessboard.
const int N = 8;
// Define a 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 < row; i++) {
if (board[col] == 1) {
return false;
}
}
// Check if there is a queen in the same column.
for (int i = 0; i < N; i++) {
if (board[row] == 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 same anti-diagonal.
for (int i = row + 1, j = col + 1; i < N && j < N; i++, j++) {
if (board[j] == 1) {
return false;
}
}
// The queen can be placed in the given row and column.
return true;
}
// Define a function to solve the 8 queens puzzle.
void solve() {
// Initialize the chessboard.
int board[N][N] = {0};
// Place the first queen in the first row.
board[0][0] = 1;
// Recursively try to place the remaining queens.
for (int i = 1; i < N; i++) {
for (int j = 0; j < N; j++) {
// Check if the queen can be placed in the given row and column.
if (is_safe(i, j)) {
// Place the queen in the given row and column.
board[j] = 1;
// Recursively try to place the remaining queens.
solve();
// Backtrack and remove the queen from the given row and column.
board[j] = 0;
}
}
}
}
// The main function.
int main() {
// Solve the 8 queens puzzle.
solve();
// Print the solution.
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cout << board[j] << " ";
}
cout << endl;
}
return 0;
}
```
This code prints the
Câu đố 8 Nữ hoàng 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 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.
Câu đố 8 Nữ hoàng là một vấn đề đầy thách thức, nhưng nó có thể được giải quyết bằng cách sử dụng nhiều thuật toán.Một thuật toán phổ biến là thuật toán quay lại.Thuật toán này bắt đầu bằng cách đặt một nữ hoàng vào hàng đầu tiên của bàn cờ.Sau đó, nó đệ quy để đặt nữ hoàng vào các hàng còn lại, một hàng cùng một lúc.Nếu một nữ hoàng có thể được đặt liên tiếp mà không tấn công bất kỳ nữ hoàng nào trong các hàng trước, thì thuật toán tiếp tục.Mặt khác, thuật toán quay lại và cố gắng đặt một nữ hoàng vào một hàng khác.
Thuật toán quay lại cho 8 câu đố của Nữ hoàng được triển khai trong mã C ++ sau:
`` `C ++
#include <Istream>
sử dụng không gian tên STD;
// Xác định kích thước của bàn cờ.
const int n = 8;
// Xác định một chức năng để kiểm tra xem một nữ hoàng có thể được đặt trong 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 <row; i ++) {
if (board [col] == 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 <n; i ++) {
if (board [hàng] == 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 trong cùng một đường chéo không.
for (int i = row+1, j = col+1; i <n && j <n; 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;
}
// Xác định một hàm để giải câu đố 8 Nữ hoàng.
void giải quyết () {
// Khởi tạo bàn cờ.
bo mạch int [n] [n] = {0};
// Đặt nữ hoàng đầu tiên vào hàng đầu tiên.
Bảng [0] [0] = 1;
// đệ quy cố gắng đặt các nữ hoàng còn lại.
for (int i = 1; i <n; i ++) {
for (int j = 0; j <n; j ++) {
// Kiểm tra xem nữ hoàng có thể được đặt trong hàng và cột đã cho.
if (is_safe (i, j)) {
// Đặt nữ hoàng vào hàng và cột đã cho.
Bảng [j] = 1;
// đệ quy cố gắng đặt các nữ hoàng còn lại.
gỡ rối();
// Backtrack và loại bỏ nữ hoàng khỏi hàng và cột đã cho.
Bảng [j] = 0;
}
}
}
}
// Hàm chính.
int main () {
// Giải câu đố 8 Nữ hoàng.
gỡ rối();
// In giải pháp.
for (int i = 0; i <n; i ++) {
for (int j = 0; j <n; j ++) {
cout << board [j] << "";
}
cout << endl;
}
trả lại 0;
}
`` `
Mã này in
=======================================
## 8 Queen Code in C++
The 8 queens puzzle is a classic problem in computer science. The goal is to place eight queens on a chessboard so that no two queens attack each other. This means that no queen can be in the same row, column, or diagonal as another queen.
The 8 queens puzzle is a challenging problem, but it can be solved using a variety of algorithms. One common algorithm is the backtracking algorithm. This algorithm starts by placing a queen in the first row of the chessboard. Then, it recursively tries to place queens in the remaining rows, one row at a time. If a queen can be placed in a row without attacking any of the queens in the previous rows, then the algorithm continues. Otherwise, the algorithm backtracks and tries to place a queen in a different row.
The backtracking algorithm for the 8 queens puzzle is implemented in the following C++ code:
```c++
#include <iostream>
using namespace std;
// Define the size of the chessboard.
const int N = 8;
// Define a 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 < row; i++) {
if (board[col] == 1) {
return false;
}
}
// Check if there is a queen in the same column.
for (int i = 0; i < N; i++) {
if (board[row] == 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 same anti-diagonal.
for (int i = row + 1, j = col + 1; i < N && j < N; i++, j++) {
if (board[j] == 1) {
return false;
}
}
// The queen can be placed in the given row and column.
return true;
}
// Define a function to solve the 8 queens puzzle.
void solve() {
// Initialize the chessboard.
int board[N][N] = {0};
// Place the first queen in the first row.
board[0][0] = 1;
// Recursively try to place the remaining queens.
for (int i = 1; i < N; i++) {
for (int j = 0; j < N; j++) {
// Check if the queen can be placed in the given row and column.
if (is_safe(i, j)) {
// Place the queen in the given row and column.
board[j] = 1;
// Recursively try to place the remaining queens.
solve();
// Backtrack and remove the queen from the given row and column.
board[j] = 0;
}
}
}
}
// The main function.
int main() {
// Solve the 8 queens puzzle.
solve();
// Print the solution.
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cout << board[j] << " ";
}
cout << endl;
}
return 0;
}
```
This code prints the
