HDU - 2612 Find a way

题目：

https://vjudge.net/contest/169035#problem/N

 

本来很简单的一题，就是两边bfs，但是一直报超时，后来才知道用数组将两个人分别到每个KFC的最短距离存下来。注意，这里不能是遍历地图，每当到一个KFC的时候就用两次bfs再记录数据，这样和不用数组记录是等效的（而且空间复杂度还上升了）。

这种超时代码如下：

 

//N
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
#define MAXN 210
#define INF 0x3f3f3f3f

struct Node
{
    int x,y;
    int step;
    Node(){}
    Node(int a,int b,int c):x(a),y(b),step(c){}
};
char Map[MAXN][MAXN];
bool vis[MAXN][MAXN];
int Count1[MAXN][MAXN],Count2[MAXN][MAXN];
int dx[4]={-1,0,1,0};
int dy[4]={0,1,0,-1};
int ex,ey;
int n,m;

bool Judge(int x,int y)
{
    bool flag=false;
    if(x>=0&&x<n&&y>=0&&y<m)
        if(Map[x][y]=='.'||Map[x][y]=='@')
            if(!vis[x][y])
                flag=true;
    return flag;
}

int bfs(int sx,int sy)
{
    int i;
    int x,y;
    int xt,yt;
    Node now,next;
    queue<Node>q;

    while(!q.empty())
        q.pop();
    memset(vis,false,sizeof(vis));
    now=Node(sx,sy,0);
    q.push(now);
    vis[sx][sy]=true;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.x==ex&&now.y==ey)
            return now.step;
        x=now.x;
        y=now.y;
        for(i=0;i<4;i++)
        {
            xt=x+dx[i];
            yt=y+dy[i];
            if(Judge(xt,yt))
            {
                vis[xt][yt]=true;
                next=Node(xt,yt,now.step+1);
                if(xt==ex&&yt==ey)
                    return next.step;
                q.push(next);
            }
        }
    }
}

int main()
{
    int i,j;
    int ans,temp1,temp2;
    int sx1,sy1,sx2,sy2;

    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(!n||!m)
            break;
        memset(Map,0,sizeof(Map));
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
            {
                cin>>Map[i][j];
                if(Map[i][j]=='Y')
                {
                    sx1=i;
                    sy1=j;
                }
                else if(Map[i][j]=='M')
                {
                    sx2=i;
                    sy2=j;
                }
            }
        }
        ans=INF;
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
            {
                if(Map[i][j]=='@')
                {
                    ex=i;
                    ey=j;
                    temp1=bfs(sx1,sy1);
                    temp2=bfs(sx2,sy2);
                    ans=min(ans,(temp1+temp2)*11);
                }
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

 

正确方法是只用两次bfs，比如第一次在计算Y到每个KFC的最短距离时，就用一次bfs，因为这是队列中已经有所有的情况了，就可以省下遍历地图一个个找KFC的时间，应该是省下了O(n*m)的时间复杂度（maybe。。。）

 

在bfs中像这样：

本来按照常规套路，在画圈处一般是返回值了。

 

正确代码：
 

//N
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
#define MAXN 210
#define INF 0x3f3f3f3f

struct Node
{
    int x,y;
    int step;
    Node(){}
    Node(int a,int b,int c):x(a),y(b),step(c){}
};
char Map[MAXN][MAXN];
bool vis[MAXN][MAXN];
int Count[3][MAXN][MAXN];
int dx[4]={-1,0,1,0};
int dy[4]={0,1,0,-1};
int n,m;

bool Judge(int x,int y)
{
    bool flag=false;
    if(x>=0&&x<n&&y>=0&&y<m)
        if(Map[x][y]!='#')
            if(!vis[x][y])
                flag=true;
    return flag;
}

void bfs(int sx,int sy,int id)
{
    int i;
    int x,y;
    int xt,yt;
    Node now,next;
    queue<Node>q;

    while(!q.empty())
        q.pop();
    memset(vis,false,sizeof(vis));
    now=Node(sx,sy,0);
    q.push(now);
    vis[sx][sy]=true;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        x=now.x;
        y=now.y;
        for(i=0;i<4;i++)
        {
            xt=x+dx[i];
            yt=y+dy[i];
            if(Judge(xt,yt))
            {
                vis[xt][yt]=true;
                next=Node(xt,yt,now.step+11);
                if(Map[xt][yt]=='@')
                    Count[id][xt][yt]=next.step;
                q.push(next);
            }
        }
    }
}

int main()
{
    int i,j;
    int ans;
    int sx1,sy1,sx2,sy2;

    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(!n||!m)
            break;
        memset(Map,0,sizeof(Map));
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
            {
                cin>>Map[i][j];
                if(Map[i][j]=='Y')
                {
                    sx1=i;
                    sy1=j;
                }
                else if(Map[i][j]=='M')
                {
                    sx2=i;
                    sy2=j;
                }
            }
        }
        memset(Count,INF,sizeof(Count));
        bfs(sx1,sy1,1);
        bfs(sx2,sy2,2);
        ans=INF;
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
            {
                if(Map[i][j]=='@')
                    ans=min(ans,Count[1][i][j]+Count[2][i][j]);
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}