一些搜索总结

双向BFS

我们在BFS时，要从起点，搜遍整颗搜索树，然后找到终点，整个过程大概是一个如下的结构

我比较懒，所以图非常简陋。

最上面的节点表示起点，最下面的点表示终点。

我们正常的BFS是从起点一路向下搜到终点，这样要扩展不少的状态，耗费不少的时间。

这样我们想我们其实可以从起点和终点同时开始搜，起点和终点同时向外扩展一步，当两个搜索路径交会时，结束搜索。

这样我们可以省去一半的时间。

我们用两个队列分别表示起点的扩展和终点的扩展

例题：

常见的迷宫问题，0表示有障碍，1表示无障碍，假设没有无法走到的情况，求最少需要多少步

非常显然的BFS

#include<bits/stdc++.h>
using namespace std;
const int maxn = 3030;
struct node {
    int x, y;
}q1[maxn], q2[maxn];
//int stx, sty, edx, edy;
int a[maxn][maxn];
int n, m;
int    tail1 = 0, head1 = 1, tail2 = 0, head2 = 1;
//int dx[9] = {-1, -1, 1, 1, -2, -2, 2, 2};
//int dy[9] = {2, -2, 2, -2, -1, 1, -1, 1};
//int vis[maxn][maxn];
int dx[5] = {-1, 0, 1, 0}, dy[5] = {0, -1, 0, 1};
int st[maxn][maxn], ed[maxn][maxn];
int stept[maxn][maxn], stepe[maxn][maxn];
bool flag = 0;
int ans = 0;

inline int read() {
    int x = 0, y = 1;
    char ch = getchar();
    while(!isdigit(ch)) {
        if(ch == '-') y = -1;
        ch = getchar();
    }
    while(isdigit(ch)) {
        x = (x << 1) + (x << 3) + ch - '0';
        ch = getchar();
    }
    return x * y;
}

int main() {
    memset(st, 0, sizeof(st));
    memset(ed, 0, sizeof(ed));
    memset(a, -1, sizeof(a)); 
    n = read(), m = read();
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= m;++j)
            a[i][j] = read();
    q1[++tail1].x = 1, q1[tail1].y = 1;
    q2[++tail2].x = n, q2[tail2].y = m;
    for(head1 = 1, head2 = 1; head1 <= tail1 || head2 <= tail2; head1++, head2++) {
        for(int i = 0; i < 4; ++i) {
            int xx = q1[head1].x + dx[i];
            int yy = q1[head1].y + dy[i];
            if(a[xx][yy] == -1) continue;
            if(!st[xx][yy] && a[xx][yy]) {
                stept[xx][yy] = stept[q1[head1].x][q1[head1].y] + 1;
                if(ed[xx][yy]) {
                    flag = 1;
                    ans = stept[xx][yy] + stepe[xx][yy];
                    break;
                }
                st[xx][yy] = 1;
                q1[++tail1].x = xx;
                q1[tail1].y = yy;
            }
        }
        if(flag == 1) break;
        for(int i = 0; i < 4; ++i) {
            int xx = q2[head2].x + dx[i];
            int yy = q2[head2].y + dy[i];
            if(a[xx][yy] == -1) continue;
            if(!ed[xx][yy] && a[xx][yy]) {
                stepe[xx][yy] = stepe[q2[head2].x][q2[head2].y] + 1;
                if(st[xx][yy]) {
                    flag = 1;
                    ans = stepe[xx][yy] + stept[xx][yy];
                    break;
                }
                ed[xx][yy] = 1;
                q2[++tail2].x = xx;
                q2[tail2].y = yy;
            }
        }
        if(flag == 1) break;
    }
    cout << ans << '
';
    return 0;
}

迭代加深搜索

在一些需要搜索的情况下，使用DFS会因为搜索树的深度太深，加上结果比较靠后，而导致耗费巨大的时间，而如果使用BFS，则会因为要存储大量状态而耗费大量的空间

这个时候我们可以使用迭代加深搜索。

简而言之就是我们人为规定一个搜索深度，每次到限定的搜索深度时停止。

比如说第一次我们规定搜索深度为1，我们搜索一层，结束

第二次我们规定搜索深度为2，我们搜索两层，结束

.......

这样我们会发现我们绝对会出现大量的重复计算，但是这对于我们直接进行DFS在搜索树上跑所需要的时间来说，是少得多的，这样这个算法就显得优秀了

例题1：

这题我们可以发现直接DFS我们似乎无法下手，我们可以脑洞一下，构造出一颗搜索树（当然我在口胡）

我们可以发现从第一个分叉向下扩展，可能会扩展的非常深都没有找到答案。用BFS我们固然可写，但是会耗费不小的空间。

这样我们就可以迭代加深搜索。

需要注意的是黑白棋是交替下的，而且题面并没有明确说是黑棋先下还是白棋先下

我们需要对黑先和白先分别进行计算

#include<bits/stdc++.h>
using namespace std;
const int maxn = 6;
const int deep = 1000000000;
int ox1, oy1, ox2, oy2;//分别记录两个空白地带的坐标
char ch[maxn]; 
char a[maxn][maxn];
bool flag = 0;
int dx[5] = {-1, 0, 1, 0}, dy[5] = {0, 1, 0, -1};
int ans = 0;

inline bool check() {
    for(int i = 1; i <= 4; ++i) {
        if(a[1][i] == a[2][i] && a[1][i] == a[3][i] && a[1][i] == a[4][i]) return 1;//判断是否存在竖着的四子连棋 
        if(a[i][1] == a[i][2] && a[i][1] == a[i][3] && a[i][1] == a[i][4]) return 1;//判断是否存在横着的四子连棋 
    }
    if(a[1][1] == a[2][2] && a[1][1] == a[3][3] && a[1][1] == a[4][4]) return 1;//判断是否存在由左上到右下角的四子连棋 
    if(a[1][4] == a[2][3] && a[1][4] == a[3][2] && a[1][4] == a[4][1]) return 1;//判断是否存在由右上到左下角的四子连棋 
    return 0;
}

inline bool able(int x, int y, int dad) {
return x >= 1 && x <= 4 && y >= 1 && y <= 4 && a[x][y] != dad;}

bool deepdfs(int x1, int y1, int x2, int y2, char pre, int begin) {
    if(begin == ans) {
        if(check()) return 1;
        else return 0;
    }
    for(int i = 0; i < 4; ++i) {
        int xx = x1 + dx[i];
        int yy = y1 + dy[i];
        if(able(xx, yy, pre)) {
            swap(a[x1][y1], a[xx][yy]);
            if(deepdfs(xx, yy, x2, y2, (pre == 'W' ? 'B' : 'W'), begin + 1)) return 1;
            swap(a[x1][y1], a[xx][yy]);
        }
        xx = x2 + dx[i];
        yy = y2 + dy[i];  
        if(able(xx, yy, pre)) {
            swap(a[x2][y2], a[xx][yy]);
            if(deepdfs(x1, y1, xx, yy, (pre == 'W' ? 'B' : 'W'), begin + 1)) return 1;
            swap(a[x2][y2], a[xx][yy]);
        }
    }
    return 0;
}

int main() {
    //memset(a, -1, sizeof(a));
    for(int i = 1; i <= 4; ++i) {
        cin >> ch + 1;
        for(int j = 1; j <= 4; ++j) {
            if(ch[j] == 'B') a[i][j] = 'B';
            else if(ch[j] == 'W') a[i][j] = 'W';
            if(ch[j] == 'O') {
                a[i][j] = 'O';
                if(!flag) {ox1 = i, oy1 = j;flag = 1;}
                else if(flag) ox2 = i, oy2 = j;
            }
        }
    }
    /*for(uint i = 1; i <= 4; ++i) {
        for(uint j = 1; j <= 4; ++j)
            cout << a[i][j] << ' ';
        cout << '
';
    }*/
    for(ans = 1; ans <= deep; ++ans) {//迭代加深搜索枚举搜索限定深度 
        if(deepdfs(ox1, oy1, ox2, oy2, 'B', 0))
            break;
        if(deepdfs(ox1, oy1, ox2, oy2, 'W', 0))
            break;
    }
    cout << ans << '
';
    return 0;
}