0x25 广度优先搜索

今天莫名不想说话。

结果发现效率挺高？

poj3322 本来可以1a的。。发现我宽搜写的是head<=tail而且初始是head=1，tail=2如果是多组数据简直就gg了。基础不牢固

这题虽然看起来麻烦，但是实际上仔细思考一下是不难推出对于各种不同放在地图上的方式分别表示的。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
const int dx[]={-,,,};
const int dy[]={,-,,};

int n,m;
char ss[][];
struct node
{
    int x,y,l,c;
}list[];
bool check(int x,int y){return <x&&x<=n&&<y&&y<=m&&ss[x][y]!='#';}

bool v[][][];
int main()
{
    int stx,sty,stl,edx,edy,edl;bool sb;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==&&m==)break;

        sb=false;
        for(int i=;i<=n;i++)scanf("%s",ss[i]+);
        for(int i=;i<=n;i++)
        {
            for(int j=;j<=m;j++)
                if(ss[i][j]=='X'&&sb==false)
                {
                    sb=true;
                    stx=i, sty=j;
                         if(ss[i+][j]=='X')stl=;
                    else if(ss[i][j+]=='X')stl=;
                    else stl=;
                }
                else if(ss[i][j]=='O') edx=i, edy=j;
        }
        memset(v,false,sizeof(v));
        for(int i=;i<=;i++)list[i].x=list[i].y=list[i].l=list[i].c=;
        list[].x=stx;list[].y=sty;list[].l=stl;list[].c=;
        int head=,tail=;
        while(head<=tail)
        {
            if(list[head].x==edx&&list[head].y==edy&&list[head].l==)
            {
                printf("%d\n",list[head].c);
                break;
            }

            for(int k=;k<=;k++)
            {
                node tno=list[head];tno.c++;
                if(tno.l==)
                {
                    tno.x+=dx[k]<?dx[k]*:dx[k];
                    tno.y+=dy[k]<?dy[k]*:dy[k];
                    tno.l=dx[k]==?:;
                }
                else if(tno.l==)
                {
                    tno.x+=dx[k]>?dx[k]*:dx[k];
                    tno.y+=dy[k];
                    tno.l=dx[k]==?:;
                }
                else if(tno.l==)
                {
                    tno.x+=dx[k];
                    tno.y+=dy[k]>?dy[k]*:dy[k];
                    tno.l=dy[k]==?:;
                }

                if(check(tno.x,tno.y))
                {
                    if(tno.l==&&ss[tno.x][tno.y]=='E')continue;
                    if(tno.l==&&!check(tno.x+,tno.y))continue;
                    if(tno.l==&&!check(tno.x,tno.y+))continue;
                    if(v[tno.x][tno.y][tno.l]==false)
                    {
                        v[tno.x][tno.y][tno.l]=true;
                        list[tail]=tno;
                        tail++;
                    }
                }
            }
            head++;
        }
        if(!v[edx][edy][])printf("Impossible\n");
    }
    return ;
}

poj3322

bzoj2252 又是gb权限题。。可以说是相当简单，让1去找0，直到全图被访问过

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
const int dx[]={-,,,};
const int dy[]={,-,,};

struct node
{
    int x,y;
}list[];
int d[][];

char ss[];
int main()
{
    int n,m,cnt;
    scanf("%d%d",&n,&m);cnt=n*m;

    int head=,tail=;
    memset(d,-,sizeof(d));
    for(int i=;i<=n;i++)
    {
        scanf("%s",ss+);
        for(int j=;j<=m;j++)
        {
            if(ss[j]=='')
            {
                d[i][j]=;
                list[tail].x=i,list[tail].y=j;
                tail++;
            }
        }
    }

    while(head<=tail)
    {
        int x=list[head].x,y=list[head].y;
        for(int k=;k<=;k++)
        {
            int tx=x+dx[k],ty=y+dy[k];
            if(<tx&&tx<=n&&<ty&&ty<=m&&d[tx][ty]==-)
            {
                d[tx][ty]=d[x][y]+;
                list[tail].x=tx,list[tail].y=ty;
                tail++;
            }
        }
        head++;
    }

    for(int i=;i<=n;i++)
    {
        for(int j=;j<m;j++)
            printf("%d ",d[i][j]);
        printf("%d\n",d[i][m]);
    }
    return ;
}

bzoj2252

poj1475 码量大而且麻烦，这种题是需要沉下心做的。先bfs让人到箱子周边，再让箱子bfs，实际上就是bfs套bfs，人和箱子绑成一块，记得算答案是有四种不同情况的。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
const int dx[]={-,,,};
const int dy[]={,-,,};
const char ch[]={'N','W','S','E'};

int n,m;
char sc[][];
struct node
{
    int x,y,k;
}list[];
int d[][][],f[][][];
char ss[][][][];

int xx[],yy[];
int E[][];
char sd[][][];
bool check(int x,int y){return <x&&x<=n&&<y&&y<=m&&sc[x][y]!='#';}
int getdis(int stx,int sty,int edx,int edy,int k)
{
    memset(E,-,sizeof(E));
    xx[]=stx,yy[]=sty;E[stx][sty]=;
    int head=,tail=;
    while(head<tail)
    {
        int x=xx[head],y=yy[head];
        if(x==edx&&y==edy)return E[x][y];
        for(int i=;i<=;i++)
        {
            int tx=x+dx[i],ty=y+dy[i];
            if(check(tx,ty)&&(tx!=edx+dx[k]||ty!=edy+dy[k])&&E[tx][ty]==-)
            {
                for(int o=;o<=E[x][y];o++)sd[tx][ty][o]=sd[x][y][o];
                sd[tx][ty][E[x][y]+]=ch[i]+;
                E[tx][ty]=E[x][y]+;

                xx[tail]=tx,yy[tail]=ty;
                tail++;
            }
        }
        head++;
    }
    return -;
}
int main()
{
//    freopen("a.out","w",stdout);
    int T_T=;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==&&m==)break;
        printf("Maze #%d\n",++T_T);

        int stpx,stpy,stbx,stby,edx,edy;
        for(int i=;i<=n;i++)
        {
            scanf("%s",sc[i]+);
            for(int j=;j<=m;j++)
                     if(sc[i][j]=='S') stpx=i, stpy=j;
                else if(sc[i][j]=='B') stbx=i, stby=j;
                else if(sc[i][j]=='T') edx=i, edy=j;
        }

        int head=,tail=;
        memset(d,-,sizeof(d));
        for(int i=;i<=;i++)
        {
            int ux=stbx+dx[i],uy=stby+dy[i];
            if(check(ux,uy))
            {
                int dis=getdis(stpx,stpy,ux,uy,(i+)%);
                if(dis==-)continue;

                for(int o=;o<=dis;o++)ss[stbx][stby][i][o]=sd[ux][uy][o];
                d[stbx][stby][i]=;
                f[stbx][stby][i]=dis;

                list[tail].x=stbx,list[tail].y=stby,list[tail].k=i;
                tail++;
            }
        }
        bool bk=false;int id=-,cnt=;
        while(head<tail)
        {
            int x=list[head].x,y=list[head].y,k=list[head].k;
            if(x==edx&&y==edy)
            {
                if(id==-||(d[x][y][k]<d[x][y][id]||(d[x][y][k]==d[x][y][id]&&f[x][y][k]<f[x][y][id])))
                {
                    id=k;
                    cnt++;if(cnt==)break;
                    bk=true;
                }
            }

            int px=x+dx[k],py=y+dy[k];
            for(int i=;i<=;i++)
            {
                int ux=x+dx[i],uy=y+dy[i];
                int tx=x-dx[i],ty=y-dy[i];
                if(check(tx,ty)&&check(ux,uy)&&(d[tx][ty][i]==-||d[x][y][k]+==d[tx][ty][i]))
                {
                    int dis=getdis(px,py,ux,uy,(i+)%);
                    if(dis==-||(d[x][y][k]+==d[tx][ty][i]&&f[x][y][k]+dis>=f[tx][ty][i]))continue;

                    int tot=d[x][y][k]+f[x][y][k];
                    for(int o=;o<=tot;o++)ss[tx][ty][i][o]=ss[x][y][k][o];
                    for(int o=;o<=dis;o++)ss[tx][ty][i][tot+o]=sd[ux][uy][o];
                    ss[tx][ty][i][tot+dis+]=ch[(i+)%];

                    d[tx][ty][i]=d[x][y][k]+;
                    f[tx][ty][i]=f[x][y][k]+dis;

                    list[tail].x=tx,list[tail].y=ty,list[tail].k=i;
                    tail++;
                }
            }
            head++;
        }
        if(bk==false)printf("Impossible.\n\n");
        else
        {
            for(int o=;o<=d[edx][edy][id]+f[edx][edy][id];o++)printf("%c",ss[edx][edy][id][o]);
            printf("\n\n");
        }
    }
    return ;
}

poj1475