bfs和dfs

搜索

dfs：空间O（n）不具有最短性 栈 回溯和剪枝
bfs：空间O（n^2）具有最短性 队列

dfs有两大特点：回溯和剪枝

例:数字全排列问题

#include<stdio.h>
#include<iostream>
using namespace std;

const int N=10;
int n;
int path[N];
int col[N];

void dfs(int u)
{
    if(u==n){
        for(int i=0;i<n;i++){cout<<path[i]<<" ";};
        cout<<endl;
        return;
    }
    
    for(int i=1;i<n+1;i++){
        if(!col[i]){
            path[u]=i;
            col[i]=1;
            dfs(u+1);
            col[i]=0;
        }
    }
}

int main(){
    cin>>n;
    dfs(0);
    return 0;
    
}

八皇后问题：

#include<iostream>
using namespace std;

const int N=20;
int n;
char path[N][N];
int col[N];
int ks[N];
int iks[N];

void dfs(int a){
    if(a==n){
        for(int i=0;i<n;i++)puts(path[i]);
        cout<<endl;
        return ;
    }
    for(int i=0;i<n;i++){
        if(!col[i]&&!ks[a+i]&&!iks[i-a+n]){
             path[a][i]='Q';
             col[i]=ks[a+i]=iks[i-a+n]=1;
             dfs(a+1);
             path[a][i]='.';
             col[i]=ks[a+i]=iks[i-a+n]=0;
        }
    }
}
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            path[i][j]='.';
        }
    }
    dfs(0);
    return 0;
}

```cpp
#include <iostream>
using namespace std;
const int N=20;
char path[N][N];
int col[N];
int ab[N];
int ba[N];
int row[N];
int n;

void dfs(int x,int y,int s){
    if(y==n)y=0,x++;
    if(x==n){
        if(s==n){
            for(int i=0;i<n;i++)puts(path[i]);
            puts(" ");
           
        } return;
    }
    //不放皇后
    dfs(x,y+1,s);
    //放
    if(row[x]!=1&&col[y]!=1&&ab[x+y]!=1&&ba[x-y+n]!=1){
        path[x][y]='Q';
        row[x]=col[y]=ab[x+y]=ba[x-y+n]=1;
        dfs(x,y+1,s+1);
        row[x]=col[y]=ab[x+y]=ba[x-y+n]=0;
        path[x][y]='.';
    }
}

int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        for(int g=0;g<n;g++){
            path[i][g]='.';
        }
    }
    dfs(0,0,0);
}

bfs的求最短路的时候使用只能是所有边的权重一样的时候用
bfs的走迷宫问题：

```cpp
#include <iostream>
#include<algorithm>
#include<queue>
#include <cstring>

using namespace std;

const int N=110;

typedef pair<int,int> PII;
int n,m,idx,t;
int g[N][N],d[N][N];
//g是迷宫记录，d记录的是到这个点走了多少步
PII path[N];
int ne[N];
int bfs(){
    queue<PII> q;
    memset(d,-1,sizeof d);
    memset(ne,-1,sizeof ne);
    d[0][0]=0;
    q.push({0,0});
    int dx[4]={-1,0,1,0};//记录的是上下左右的走法
    int dy[4]={0,-1,0,1};
    
    while(q.size()){
        PII a=q.front();
        q.pop();
        for(int i=0;i<4;i++){
            int x=a.first+dx[i];
            int y=a.second+dy[i];
            
            if(x>=0&&x<n&&y>=0&&y<m&&g[x][y]==0&&d[x][y]==-1){
                d[x][y]=d[a.first][a.second]+1;
                q.push({x,y});
                
            }
        }
    }
    return d[n-1][m-1];
}
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
            cin>>g[i][j];
    cout<<bfs()<<endl;
    return 0;
}