暑假acwing算法总结12：dfs与bfs

• 1、dfs深度优先搜索

• dfs很讲究很执着，一条路不走到头不会回来，往树深处搜
• 基于栈
• 空间复杂度：o(h)树高
• 第一次搜到的点：不具有最短性
• dfs就是递归不用区分，有些题需要剪枝，脑子里有回溯过程，dfs就很简单
• next_permutation的底层实现

#include<iostream>
using namespace std;
int n;
int path[7];
bool st[7];
void dfs(int u)
{
    for(int i=1;i<=n;i++)
    {
        if(u==n)
        {
            for(int i=0;i<n;i++)
            cout<<path[i]<<' ';
            cout<<endl;
            return;
        }
        else
        {
            if(!st[i])
            {
                path[u]=i;
                st[i]=true;
                dfs(u+1);
                st[i]=false;//恢复战场
            }
        }
    }
    return;
}
//回溯但不仅仅是回溯和循环有关，递归回溯模拟就是一条路走到黑
int main()
{
    cin>>n;
    dfs(0);
    return 0;
}
//2021-07-15/09:02

• 为3的循环dfs模拟，先1 2 3走到黑，然后回溯到1 2，3被释放，遇见return就是删掉当前的dfs也就是回溯到上一步，放进去3又把2释放得以1开始的两个字典序1 2 3，1 3 2剩余类似
• 经典n皇后问题

#include<iostream>

using namespace std;

int n;
char a[10][10];
bool hang[10],zdj[10],fdj[10];

void dfs(int u)
{
    if(u==n)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(a[i][j]=='Q')
                cout<<a[i][j];
                else cout<<'.';
            }
            cout<<endl;
        }
        cout<<endl;
        return ;
    }
    else
    {
        for(int i=0;i<n;i++)//按照列来排序，行必不相同，然后判断三个条件就好
        {
            if(!hang[i]&&!zdj[u+i]&&!fdj[n-u+i])
            {
                a[i][u]='Q';
                hang[i]=zdj[u+i]=fdj[n-u+i]=true;
                dfs(u+1);
                a[i][u]='.';
                hang[i]=zdj[u+i]=fdj[n-u+i]=false;
            }
        }
    }
    return;
}
int main()
{
    cin>>n;
    dfs(0);
    return 0;
}
//2021-07-15/14:59

• 2、bfs广度优先搜索

• bfs不讲究很渣男，眼观六路耳听八方，一层一层搜
• 基于队列
• 空间复杂度：o(2^h)
• 第一次搜到的点：具有最短性

#include<iostream>
#include<queue>
#include<cstring>

using namespace std;
typedef pair<int,int>P;

int a[110][110];
int dx[]={1,0,-1,0},dy[]={0,1,0,-1};
int d[110][110];
P q[110*110];
int hh,tt;
int bfs(int n,int m)
{
    q[0]={0,0};
    memset(d,-1,sizeof d);
    d[0][0]=0;
    while(tt>=hh)
    {
        P t=q[hh];
        hh++;
        if(t.first==n-1&&t.second==m-1)
        {
            return d[t.first][t.second];
        }
        for(int i=0;i<4;i++)
        {
            int x=t.first+dx[i],y=t.second+dy[i];
            if(x>=0&&x<n&&y>=0&&y<m&&d[x][y]==-1&&a[x][y]==0)
            {
                d[x][y]=d[t.first][t.second]+1;
                q[++tt]={x,y};
            }
        }
    }
    //return d[n-1][m-1];
}
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
            cin>>a[i][j];
    }
    cout<<bfs(n,m);
    return 0;
}

#include<iostream>
#include<queue>
#include<cstring>

using namespace std;
typedef pair<int,int>P;

int a[110][110];
int dx[]={1,0,-1,0},dy[]={0,1,0,-1};
struct node
{
    int x,y,step;//当前步到原点距离
};
queue<node>q;

int bfs(int n,int m)
{
    q.push({0,0,0});
    a[0][0]=1;
    while(q.size())
    {
        auto t=q.front();
        q.pop();
        if(t.x==n-1&&t.y==m-1)
        {
            return t.step;
        }
        for(int i=0;i<4;i++)
        {
            node tt=t;//最最最最关键，拿到前一步的step要不然一定错
            tt.x+=dx[i];
            tt.y+=dy[i];
            if(tt.x>=0&&tt.x<n&&tt.y>=0&&tt.y<m&&a[tt.x][tt.y]==0)
            {
                a[tt.x][tt.y]=1;
                tt.step++;
                q.push(tt);
            }
        }
    }
}
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
            cin>>a[i][j];
    }
    cout<<bfs(n,m);
    return 0;
}

• 2021-07-15写于南宁