2. 程式人生 > 實用技巧 >八皇后模板

八皇后模板

阿新 • • 發佈：2020-10-04

八皇后 - queen 模板

題目連結

Code

1_queen.rar：https://www.90pan.com/b2125383

密碼：bvsw

  • queen

檔名

queen.cpp

分數

1

初始化程式碼

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];

int main() {
    cin >> n;

    return 0;
}

第一步

講解

通過本節課，我們來用 dfs 演算法來解決一個實際問題——N皇后問題。

N皇后問題是一個經典的問題，在一個N*N的棋盤上放置N個皇后，每行一個並使其不能互相攻擊（同一行、同一列、同一斜線上的皇后都會自動攻擊）。

我們先定義一些標記陣列。在main函式的上方寫下

bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況

提示

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];
bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況
int main() {
    cin >> n;

    return 0;
}

程式碼

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];
bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況
int main() {
    cin >> n;

    return 0;
}

第二步

講解

下面我們要將剛剛定義的標記陣列初始化。在main

函式裡寫下

memset(a, false, sizeof(a));
memset(x1, false, sizeof(x1));
memset(y1, false, sizeof(y1));
memset(G, 0, sizeof(G));

提示

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];
bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況
int main() {
    cin >> n;
    memset(a, false, sizeof(a));
    memset(x1, false, sizeof(x1));
    memset(y1, false, sizeof(y1));
    memset(G, 0, sizeof(G));

    return 0;
}

程式碼

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];
bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況
int main() {
    cin >> n;
    memset(a, false, sizeof(a));
    memset(x1, false, sizeof(x1));
    memset(y1, false, sizeof(y1));
    memset(G, 0, sizeof(G));

    return 0;
}

第三步

講解

接下來我們要實現一個dfs的函式框架，flag為1表示已經搜到了一個符合要求的N皇后。在main函式上面繼續寫下

void dfs(int deep) {
    if (flag == 1) {
        return;
    }
}

提示

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];
bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況
void dfs(int deep) {
    if (flag == 1) {
        return;
    }
}
int main() {
    cin >> n;
    memset(a, false, sizeof(a));
    memset(x1, false, sizeof(x1));
    memset(y1, false, sizeof(y1));
    memset(G, 0, sizeof(G));

    return 0;
}

程式碼

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];
bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況
void dfs(int deep) {
    if (flag == 1) {
        return;
    }
}
int main() {
    cin >> n;
    memset(a, false, sizeof(a));
    memset(x1, false, sizeof(x1));
    memset(y1, false, sizeof(y1));
    memset(G, 0, sizeof(G));

    return 0;
}

第四步

講解

當搜尋的深度deep大於等於n時，說明已經搜尋完了，這時輸出我們搜尋到的結果並把flag標記設定為1。在dfs函式裡面寫下

if (deep >= n) {
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            cout << G[i][j] << " ";
        }
        cout << endl;
    }
    flag = 1;
    return;
}

提示

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];
bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況
void dfs(int deep) {
    if (flag == 1) {
        return;
    }
    if (deep >= n) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                cout << G[i][j] << " ";
            }
            cout << endl;
        }
        flag = 1;
        return;
    }
}
int main() {
    cin >> n;
    memset(a, false, sizeof(a));
    memset(x1, false, sizeof(x1));
    memset(y1, false, sizeof(y1));
    memset(G, 0, sizeof(G));

    return 0;
}

程式碼

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];
bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況
void dfs(int deep) {
    if (flag == 1) {
        return;
    }
    if (deep >= n) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                cout << G[i][j] << " ";
            }
            cout << endl;
        }
        flag = 1;
        return;
    }
}
int main() {
    cin >> n;
    memset(a, false, sizeof(a));
    memset(x1, false, sizeof(x1));
    memset(y1, false, sizeof(y1));
    memset(G, 0, sizeof(G));

    return 0;
}

第五步

講解

接下來我們遍歷每一列看是否可以繼續放皇后，如果可以那麼dfs(deep + 1)。在dfs函式裡繼續寫下

for (int i = 0; i < n; i++) {
    if (x1[i + deep] == false && y1[i - deep + n] == false && a[i] == false) {
        dfs(deep + 1);
    }
}

注意標記陣列在dfs前後的true和false的轉化。當出了dfs一定要記得還原標記，否則會影響下一次dfs的結果。

for (int i = 0; i < n; i++) {
    if (x1[i + deep] == false && y1[i - deep + n] == false && a[i] == false) {
        x1[deep + i] = true;
        y1[i - deep + n] = true;
        a[i] = true;
        G[deep][i] = 1;
        dfs(deep + 1);
        a[i] = false;
        x1[deep + i]=false;
        y1[i - deep + n] = false;
        G[deep][i] = 0;
    }
}

提示

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];
bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況
void dfs(int deep) {
    if (flag == 1) {
        return;
    }
    if (deep >= n) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                cout << G[i][j] << " ";
            }
            cout << endl;
        }
        flag = 1;
        return;
    }
    for (int i = 0; i < n; i++) {
        if (x1[i + deep] == false && y1[i - deep + n] == false && a[i] == false) {
            x1[deep + i] = true;
            y1[i - deep + n] = true;
            a[i] = true;
            G[deep][i] = 1;
            dfs(deep + 1);
            a[i] = false;
            x1[deep + i]=false;
            y1[i - deep + n] = false;
            G[deep][i] = 0;
        }
    }
}
int main() {
    cin >> n;
    memset(a, false, sizeof(a));
    memset(x1, false, sizeof(x1));
    memset(y1, false, sizeof(y1));
    memset(G, 0, sizeof(G));

    return 0;
}

程式碼

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];
bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況
void dfs(int deep) {
    if (flag == 1) {
        return;
    }
    if (deep >= n) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                cout << G[i][j] << " ";
            }
            cout << endl;
        }
        flag = 1;
        return;
    }
    for (int i = 0; i < n; i++) {
        if (x1[i + deep] == false && y1[i - deep + n] == false && a[i] == false) {
            x1[deep + i] = true;
            y1[i - deep + n] = true;
            a[i] = true;
            G[deep][i] = 1;
            dfs(deep + 1);
            a[i] = false;
            x1[deep + i]=false;
            y1[i - deep + n] = false;
            G[deep][i] = 0;
        }
    }
}
int main() {
    cin >> n;
    memset(a, false, sizeof(a));
    memset(x1, false, sizeof(x1));
    memset(y1, false, sizeof(y1));
    memset(G, 0, sizeof(G));

    return 0;
}

第六步

講解

最後在main加上dfs函式的呼叫。繼續寫下

dfs(0);

提示

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];
bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況
void dfs(int deep) {
    if (flag == 1) {
        return;
    }
    if (deep >= n) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                cout << G[i][j] << " ";
            }
            cout << endl;
        }
        flag = 1;
        return;
    }
    for (int i = 0; i < n; i++) {
        if (x1[i + deep] == false && y1[i - deep + n] == false && a[i] == false) {
            x1[deep + i] = true;
            y1[i - deep + n] = true;
            a[i] = true;
            G[deep][i] = 1;
            dfs(deep + 1);
            a[i] = false;
            x1[deep + i]=false;
            y1[i - deep + n] = false;
            G[deep][i] = 0;
        }
    }
}
int main() {
    cin >> n;
    memset(a, false, sizeof(a));
    memset(x1, false, sizeof(x1));
    memset(y1, false, sizeof(y1));
    memset(G, 0, sizeof(G));
    dfs(0);
    return 0;
}

程式碼

#include <iostream>
#include <cstring>
using namespace std;

int n;
bool flag = 0;
int G[20][20];
bool a[20];  // 列佔用情況，若第 i 列被佔用，則 a[i] = true，否則為 false
bool x1[20];  // 左下-右上 對角線的佔用情況
bool y1[20];  // 左上-右下 對角線的佔用情況
void dfs(int deep) {
    if (flag == 1) {
        return;
    }
    if (deep >= n) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                cout << G[i][j] << " ";
            }
            cout << endl;
        }
        flag = 1;
        return;
    }
    for (int i = 0; i < n; i++) {
        if (x1[i + deep] == false && y1[i - deep + n] == false && a[i] == false) {
            x1[deep + i] = true;
            y1[i - deep + n] = true;
            a[i] = true;
            G[deep][i] = 1;
            dfs(deep + 1);
            a[i] = false;
            x1[deep + i]=false;
            y1[i - deep + n] = false;
            G[deep][i] = 0;
        }
    }
}
int main() {
    cin >> n;
    memset(a, false, sizeof(a));
    memset(x1, false, sizeof(x1));
    memset(y1, false, sizeof(y1));
    memset(G, 0, sizeof(G));
    dfs(0);
    return 0;
}

完成講解

終於完成了，點選執行，輸入8看看效果吧。

聰明的你一定學會了dfs怎麼用了。

相關推薦

八皇后模板

八皇后 - queen 模板 題目連結 Code 1_queen.rar：https://www.90pan.com/b2125383 密碼：bvsw queen

如何基於java語言實現八皇后問題

這篇文章主要介紹瞭如何基於java語言實現八皇后問題,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

python 使用遞歸回溯完美解決八皇后的問題

八皇后問題描述：在一個8✖️8的棋盤上，任意擺放8個棋子，要求任意兩個棋子不能在同一行，同一列，同一斜線上，問有多少種解法。

C#資料結構與算法系列（十四）：遞迴——八皇后問題（回溯演演算法）

1.介紹 八皇后問題，是一個古老而著名的問題，是回溯演演算法的經典案例，該問題是國際西洋棋棋手馬克斯.貝瑟爾於1848年提出：在8×8格的國際象棋上擺放八個皇后，使其不能互相攻擊，即

遞迴－八皇后問題

誒，好多東西都忘了呀，看來從頭看一遍真的很有必要啊！ 1 // 2 // #include <stdio.h>

八皇后問題

八皇后 第一個皇后先放第一行第一列 第二個皇后放在第二行第一列、然後判斷是否OK， 如果不OK，繼續放在第二列、第三列、依次把所有列都放完，找到一個合適

八、模板方法模式（Template Method Pattern）《HeadFirst設計模式》讀書筆記

　　在抽象類中建立一個模板方法，這個方法可以呼叫在抽象類中定義好的其它方法，這些方法可以是抽象的，也可以是預設方法，甚至還可以是一個空的方法（叫做鉤子），可以在子類中重寫抽象方法或重寫鉤子方法，從而實

八皇后||演算法

一、背景 八皇后問題是一個以國際象棋為背景的問題：如何能夠在8×8個格子的國際象棋棋盤上放置八個皇后，使得任何一個皇后都無法直接吃掉其他的皇后, 為了達到此目的，任兩個皇后都不能處於同一條橫行、縱行或斜線上

13，遞迴，八皇后問題

每擺放一個皇后，都檢查和之前所有皇后是否衝突，否則回溯 1，ArrayQueen[i] == ArrayQueen[n]皇后是否在同一列2，Math.Abs(n - i) == Math.Abs(ArrayQueen[n] - ArrayQueen[i])皇后是否在同一斜線上

八皇后的n种放置方法

八皇后問題 八皇后問題是一個以國際象棋為背景的問題：如何能夠在8×8的國際象棋棋盤上放置八個皇后，使得任何一個皇后都無法直接吃掉其他的皇后？為了達到此目的，任兩個皇后都不能處於同一條橫行、縱行或斜線

計蒜客：八皇后+最大和

1 #include <cstdio> 2 #include <iostream> 3 using namespace std; 4 int n=0;//n皇后 5 int ans=0;//解個數

回溯法（一）——八皇后問題

  八皇后問題，陣列使用result[8]太妙了，切忌不要使用二維陣列result，這樣反而會增大難度，因為使用result[8]的話，每行路徑在找到正確位置都是更新的最新值；如果使用二維陣列的話，還要考慮當皇后回溯的時候，

用 Vue 簡單實現一個八皇后小遊戲

八皇后小遊戲規則與效果預覽 效果預覽： 實現步驟 之前建立了專案，筆記：https://www.cnblogs.com/xiaoxuStudy/p/12663218.html

面試題 08.12. 八皇后

題目描述連結：https://leetcode-cn.com/problems/eight-queens-lcci/ 解題思路：DFS。要求不同行，不同列，不同對角線。對於不同行每搜尋完一行，則

php 實現八皇后問題

php實現的八皇后問題，可以推廣到N皇后 <?php classEmpress{ private$queen;//儲存位置，例如$queen[2] = 3表示第三行的第四列位置，行列從0計數

洛谷 [USACO1.5]八皇后 Checker Challenge

題目描述 一個如下的6×6的跳棋棋盤，有六個棋子被放置在棋盤上，使得每行、每列有且只有一個，每條對角線（包括兩條主對角線的所有平行線）上至多有一個棋子。

面試題 08.12.八皇后

程式碼思路：用三個set標記當前位置所在的行、主、次對角線方向上是否合法。

八皇后問題遺傳演算法實現(C語言）

八皇后問題的遺傳演算法實現過程詳解 1、八皇后問題描述19 世紀著名的數學家Gauss 在1850 年提出八皇后問題後， 該問題成為各類語言程式設計的經典題目。八皇后問題要求在8×8 格的國際象棋上擺放八個皇后，使橫、

八皇后問題遺傳演算法實現(python版）

八皇后問題的遺傳演算法實現過程詳解 1、八皇后問題描述19 世紀著名的數學家Gauss 在1850 年提出八皇后問題後， 該問題成為各類語言程式設計的經典題目。八皇后問題要求在8×8 格的國際象棋上擺放八個皇后，使橫、豎

P1219 [USACO1.5]八皇后 Checker Challenge

一個如下的6×6的跳棋棋盤，有六個棋子被放置在棋盤上，使得每行、每列有且只有一個，每條對角線（包括兩條主對角線的所有平行線）上至多有一個棋子。