DFS和BFS

模板：

1.dfs

#include<bits/stdc++.h>
using namespace std;
int n, m;
int a[ ];
int ans[ ];
void dfs(int x){
    if (判断条件){
    cout<<输出
        return ; 
    }
    for (int i = 开始的地方; i <= n; i++)
        if (a[i] == 0) {
            a[i]=1;//标记上
            dfs(x + 1);//下一个数字 
            a[i]=0;//回溯
            }
    return ;
}
int main(){
    dfs(1);
    return 0;
}

例题：P1219 [USACO1.5]八皇后 Checker Challenge

题目描述

一个如下的 6 \times 66×6 的跳棋棋盘，有六个棋子被放置在棋盘上，使得每行、每列有且只有一个，每条对角线（包括两条主对角线的所有平行线）上至多有一个棋子。

上面的布局可以用序列 2\ 4\ 6\ 1\ 3\ 52 4 6 1 3 5 来描述，第 ii 个数字表示在第 ii 行的相应位置有一个棋子，如下：

行号 1\ 2\ 3\ 4\ 5\ 61 2 3 4 5 6

列号 2\ 4\ 6\ 1\ 3\ 52 4 6 1 3 5

这只是棋子放置的一个解。请编一个程序找出所有棋子放置的解。
并把它们以上面的序列方法输出，解按字典顺序排列。
请输出前 33 个解。最后一行是解的总个数。

输入格式

一行一个正整数 nn，表示棋盘是 n \times nn×n 大小的。

输出格式

前三行为前三个解，每个解的两个数字之间用一个空格隔开。第四行只有一个数字，表示解的总数。

输入输出样例

输入 #1复制

6

输出 #1复制

2 4 6 1 3 5
3 6 2 5 1 4
4 1 5 2 6 3
4

#include <iostream>
using namespace std;
#define maxn 100
int b1[maxn], b2[maxn], b3[maxn];
int a[maxn];
int n;
int ans = 0;
void dfs(int x) {
    if (x > n) {//判断条件
        ans++;
    
        if (ans <= 3) {
            for (int i = 1; i <= n; i++) {
                cout << a[i] << " ";//输出
            }
            cout << endl;
        }
    }
    else {
        for (int i = 1; i <= n; i++) {
            if (b1[i] == 0 && b2[x + i] == 0 && b3[x - i + 15] == 0) {//未被标记
                a[x] = i;
                b1[i] = 1; b2[x + i] = 1; b3[x - i + 15] = 1;//标记
                dfs(x + 1);//递归
                b1[i] = 0; b2[x + i] = 0; b3[x - i + 15] = 0;//未被标记
            }

        }
    }
}

int main()
{
    cin >> n;
    dfs(1);
    cout<<ans;
}

 2.BFS

利用队列进行回溯，用例题说明会更加好理解一点

P1443 马的遍历

题目描述

有一个 n \times mn×m 的棋盘，在某个点 (x, y)(x,y) 上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。

输入格式

输入只有一行四个整数，分别为 n, m, x, yn,m,x,y。

输出格式

一个 n \times mn×m 的矩阵，代表马到达某个点最少要走几步（左对齐，宽 55 格，不能到达则输出 -1−1）。

输入输出样例

输入 #1复制

3 3 1 1

输出 #1复制

0    3    2    
3    -1   1    
2    1    4    

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;
int n, m, sx, sy;
int mp[420][420];
int xx[] = { 2,2,1,1,-1,-1,-2,-2 };
int yy[] = { 1,-1,2,-2,2,-2,1,-1 };
struct node {
    int x, y, s;
};

int main()
{
    cin >> n >> m >> sx >> sy;
    memset(mp, -1, sizeof(mp));//初始化数组取-1
    queue<node>v;
    v.push((node){sx,sy,0});//向队列里面压入开始的点
    mp[sx][sy] = 0;//开始的点标记为0
    while (!v.empty()) {//当队列为空时
        for (int i = 0; i < 8; i++) {//马的跳动方向最多8个
            int dx = xx[i] + v.front().x;
            int dy = yy[i] + v.front().y;
            if (dx >=1 && dx <= n && dy >=1 && dy <= m&&mp[dx][dy]==-1) {//在这个范围内且没有被扫描到，进入
                v.push((node){dx,dy,v.front().s + 1 });//压入该数并标记好，步数加一
                mp[dx][dy] = v.front().s + 1;//标记到达该位置的步数
            }
        }
        v.pop();//弹出已扫描的元素
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            printf("%-5d", mp[i][j]);//输出
        }
        printf("\n");
    }
}

        整体的模板，思路还是比较清晰地，在搜索方面一定要注意是否该数被搜索过，注意if判断的条件回溯，递归的细节，刚接触时确实思路不太清晰，复习过后，明显思路清晰多了 ，加油，明天复习完基础数学，就继续按老师的节奏走了，开心，加油!