经典搜索bfs,dfs，优先队列的bfs

下面我将通过一个经典的例子来诠释解决这一类的问题！

 

给出两个整数n,m,接着给出n行m列的一个矩阵，然后给出一个起始位置(x1,y1)和一个终止位置(x2,y2),问从起始位置到终止位置的最少步数是多少？

例如n=5,m=4,起始位置为(1,1)，终止位置为(4,3)，样例形式如下：

5 4
0 0 1 0
0 0 0 0
0 0 1 0
0 1 0 0
0 0 0 1
1 1 4 3

输出为7

第一种解法dfs:

#include<iostream>
#include<algorithm>
#include<string.h>
#include<stdio.h>
using namespace std;
const int maxn = 100;
int minmum = 1e9+10; //取一个较大的数，留着与较小值比对
int n,m,n1,m1,n2,m2;
int vis[maxn][maxn],mapp[maxn][maxn];
int dir[4][2] = {1,0,-1,0,0,1,0,-1};
void dfs(int n1,int m1,int step)
{
    if(n1 == n2 && m1 == m2){
        if(minmum > step)
            minmum = step;
        return; //找到一种可行的路径，然后return去找下一跳
    }
    for(int i=0;i<4;i++){
        int xx = n1 + dir[i][0];
        int yy = m1 + dir[i][1];
        if(xx<1 || xx>n || yy<1 || yy>m) continue; //边界条件
        if(!vis[xx][yy] && !mapp[xx][yy]){
            vis[xx][yy] = 1; //走过的标记一下，防止重复走
            dfs(xx,yy,step+1); //顺着一条路径一直走到无路可走才掉头
            vis[xx][yy] = 0; //回溯，尝试所有可能的路径
        }
    }
    return;
}
int main(){
    while(cin>>n>>m){
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++)
                cin>>mapp[i][j];
        }
        cin>>n1>>m1>>n2>>m2;
        vis[n1][m1]=1;
        dfs(n1,m1,0);
        cout<<minmum<<endl;
    }
    return 0;
}

第二种解法bfs:

#include<iostream>
#include<algorithm>
#include<string.h>
#include<stdio.h>
using namespace std;
const int maxn = 100;
int mapp[maxn][maxn];
int dir[4][2] = {1,0,-1,0,0,1,0,-1};
int n,m,vis[maxn][maxn],start1,end1,start2,end2,ans;
struct node{
    int x; //横坐标
    int y; //纵坐标
    int step; //记录走的步数
    int fron; //记录某个给定节点的前驱节点
}q[maxn];
void bfs(int n1,int m1,int n2,int m2){
    int tail,head;
    tail = head =1;
    int flag = 0;
    q[tail].x = n1;
    q[tail].y = m1;
    q[tail].step = 0;
    q[tail].fron = head;
    tail++;
    while(head<tail)
    {
        for(int i=0;i<4;i++)
        {
            int tx = q[head].x + dir[i][0];
            int ty = q[head].y + dir[i][1];
            if(tx<1 || tx>n || ty<1 || ty>m)
                continue;
            if(!vis[tx][ty] && mapp[tx][ty] == 0){
                vis[tx][ty] = 1;
                q[tail].x = tx;
                q[tail].y = ty;
                q[tail].fron = head;
                q[tail].step = q[head].step + 1;
                tail++; //注意这里是tail++,所以最后输出步数的时候要-1
                if(tx == n2 && ty == m2 )
                {
                    ans = q[tail-1].step;
                    flag = 1;
                    break;
                }
                }
        }
        if(flag == 1)
            break;
        head++; //当从一个点拓完所有与其相邻接的点时，只需要head++即可让其出队列
    }
    cout<<ans<<endl;
}

int main()
{
    while(cin>>n>>m){
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++)
                cin>>mapp[i][j];
        }
        cin>>start1>>end1>>start2>>end2;
        vis[start1][end1]=1; //将起点标记，防止后面重复走
        bfs(start1,end1,start2,end2);
    }
    return 0;
}

第三种解法bfs+优先队列：

#include<iostream>
#include<algorithm>
#include<string.h>
#include<stdio.h>
#include<queue>
using namespace std;
const int maxn = 100;
int dir[4][2] = {1,0,-1,0,0,1,0,-1};
int n,m,n1,m1,n2,m2,ans;
int vis[maxn][maxn],mapp[maxn][maxn];
bool check(int x,int y)
{
    if(x>=1 && x<=n && y>=1 && y<=m && !vis[x][y] && !mapp[x][y])
        return true;
    return false;
}
struct node{
    int x;
    int y;
    int step;
    //下面一步时友元重载
    bool friend operator < (node a,node b){
        return a.step > b.step;
    }
};
void bfs(int n1,int m1,int n2,int m2)
{
    priority_queue<node>q;
    node e1,e2;
    e1.x = n1;
    e1.y = m1;
    e1.step = 0;
    vis[e1.x][e1.y] = 1;
    q.push(e1);
    ans = -1;
    while(!q.empty())
    {
        e2 = q.top();
        q.pop();
        if(e2.x == n2 && e2.y == m2) //找到时就可以退出
        {
            ans = e2.step;
            break;
        }
        for(int i=0;i<4;i++)
        {
            e1.x = e2.x + dir[i][0];
            e1.y = e2.y + dir[i][1];
            if(check(e1.x,e1.y))
            {
                vis[e1.x][e1.y] = 1;
                e1.step = e2.step + 1;
                q.push(e1); //将e1塞入队列
            }
        }
    }
    cout<<ans<<endl;
}
int main()
{
    while(cin>>n>>m){
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                cin>>mapp[i][j];
            }
        }
        cin>>n1>>m1>>n2>>m2;
        vis[n1][m1]=1;
        bfs(n1,m1,n2,m2);
    }
    return 0;
}