BFS&&DFS模板

DFS较为简单，本质就是最蠢笨的深度优先搜索。

#include<iostream>
#define N 100
using namespace std;
int di[4][2] = {1,0,-1,0,0,1,0,-1};
char map[N][N];
int DFS(int x,int y)
{
    int a,b,flag;
    if(x == m&&y == n)
    {
        map[x][y] = '#';
        return 1;
    }
    for(i = 0; i < 4; ++i)
    {
        a = x+di[i][0]; b = y+di[i][1];
        if(map[a][b] == '*')
            continue;
        else if(DFS(a,b) == 1)
            flag = 1;
    }
    if(flag == 1)
        map[x][y] = '#';
    else
        map[x][y] = '0';
}
int main()
{
    
    return 0;
}

bfs就是用一个队列存储其结点  然后进行层次性的访问。

#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
const int n = 16;
using namespace std;
typedef struct {
int x,y,count;
}Node;
int map[n+1][n+1] = {0};
int sta(int x,int y)
{
    if(vis[x][y] == 0&&(x>0&&x <= n)&&(y>0&&y<=n))
        return 1;//没被访问过。
        else
            return 0;
}
int di[8][2] = {1,-2,-1,-2,-2,-1,2,-1,-2,1,2,1,1,2,-1,2};
int bfs(int x,int y)
{
    queue<Node> p;
    Node now,nxt;
    now.x = x; now.y = y; now.count = 0;
    p.push(now);
    map[x][y] = 1;
    while(!empty(p))
    {
        now = p.front(p);//
        if(now.x == x1&&now.y == y1)
            return count;
        for(i = 0; i <8; ++i)
        {
            nxt.x = now.x+di[i][0]; nxt.y = now.y + di[i][1];
            if(sta(vis[nxt.x][nxt.y]))
            {
                vis[nxt.x][nxt.y] = 1;
                nxt.count = now.count + 1;
                p.push(nxt);
            
            }
        }
        p.pop();
    }
}