HDU 5335 Walk Out(BFS+BFS) 经典 2015 Multi-University Training Contest 4

Walk Out

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 506    Accepted Submission(s): 84

Problem Description

In an n∗m maze, the right-bottom corner is the exit (position (n,m) is the exit). In every position of this maze, there is either a 0 or a 1 written on it.

An explorer gets lost in this grid. His position now is (1,1) , and he wants to go to the exit. Since to arrive at the exit is easy for him, he wants to do something more difficult. At first, he'll write down the number on position (1,1) . Every time, he could make a move to one adjacent position (two positions are adjacent if and only if they share an edge). While walking, he will write down the number on the position he's on to the end of his number. When finished, he will get a binary number. Please determine the minimum value of this number in binary system.

 

Input

The first line of the input is a single integer T (T=10) , indicating the number of testcases.

For each testcase, the first line contains two integers n and m (1≤n,m≤1000) . The i -th line of the next n lines contains one 01 string of length m , which represents i -th row of the maze.

 

Output

For each testcase, print the answer in binary system. Please eliminate all the preceding 0 unless the answer itself is 0 (in this case, print 0 instead).

 

Sample Input

   
   
   
   

    
    
    
    2
2 2
11
11
3 3
001
111
101
   
   
   
   

 

Sample Output

   
   
   
   

    
    
    
    111
101
   
   
   
   

 

Author

XJZX

 

Source

2015 Multi-University Training Contest 4

 

题意：要求从（0，0）走到（n-1 , m-1）经过的位置里的值组合成二进制数值最小。

解题：先用BFS从（0，0）出发，去掉前导0，找出离（n-1 , m-1 ）最近的一些位置为1，然后再从找出的这些位置开始出发（每个位置只走一次），用两个数组模似两个队列，交换使用，每次队列里面的位置值要么全为0，要么全为1，这样即保证了最短长度，而且也保证了字典序最小。

5
15 15
101010111011010
110011011000111
100011110100100
101101100110011
100011000110011
100111111111001
101001101001100
100101001100110
100111111000010
101001001000110
101100100110100
100100110010010
110100100100110
100010010010001
111111111001001

10100000000000000100100001001

#include<stdio.h>
#include<queue>
#include<iostream>
#include<string.h>
#include<string>
using namespace std;
const int N = 1015;

char mapt[N*N];
int fath[N*N],vist[N*N],dir[4][2]={1,0,0,1,0,-1,-1,0};
int n,m;

int inq[2],q[2][N*N] , tq[N*N] , minlen;
int ABS(int aa){return aa>0?aa:-aa;}
void bfs1(int st)
{
    int x,y,kk=0;
    memset(vist,0,sizeof(vist));

    inq[0]=inq[1]=0;
    minlen=ABS(n-1-st/m)+ABS(m-1-st%m);//找一个位置为1的离（n-1,m-1）位置最近的一些点

    if(mapt[st]=='0')
        tq[kk++]=st;
   vist[st]=1;

    while(kk)
    {
        st=tq[--kk];
        x=st/m; y=st%m;
        for(int e=0; e<4; e++)
        {
            int tx=x+dir[e][0] , ty=y+dir[e][1];
            if(tx>=0&&tx<n&&ty>=0&&ty<m&&vist[tx*m+ty]==0)
            {
                if(mapt[tx*m+ty]=='0')
                    tq[kk++]=tx*m+ty;
                else
                {
                    int tlen=ABS(n-1-tx)+ABS(m-1-ty);
                    if(minlen>tlen)minlen=tlen;
                }
                vist[tx*m+ty]=1;
            }
        }
    }
    for(int i=0; i<n; i++)
    for(int j=0; j<m; j++)
    if(vist[i*m+j]==1&&mapt[i*m+j]=='1'&&ABS(n-1-i)+ABS(m-1-j)==minlen)
    {
        q[0][inq[0]++]=i*m+j;
    }
}

void bfs2(int endd)
{
    int x,y,st,flag=0;
    memset(fath,-1,sizeof(fath));
//两个队列交换使用保证序列的长度一样
    while(inq[flag])
    {
        bool bb=0; //队列里的位置所在的格子值要么全是0，要么全1，这要才能保证字典序最小
        for(int i=0; i<inq[flag]; i++)
        {
             st=q[flag][i];
            x=st/m; y=st%m;
            for(int e=0; e<2; e++)//走两个方向：向右向下
            {
                int tx=x+dir[e][0] , ty=y+dir[e][1] ;
                int tst=tx*m+ty;
                if(tx>=0&&tx<n&&ty>=0&&ty<m)
                if(mapt[tst]=='0'&&vist[tst]==0)//先找0
                {
                     fath[tst]=st;
                    vist[tst]=1+vist[st];
                    if(tst==endd)
                    {
                        return ;
                    }
                    q[!flag][inq[!flag]++]=tst;
                    bb=1;
                }
            }
        }
        if(bb==0)
        for(int i=0; i<inq[flag]; i++)
        {
             st=q[flag][i];
            x=st/m; y=st%m;
            for(int e=0; e<2; e++)
            {
                int tx=x+dir[e][0] , ty=y+dir[e][1] ;
                int tst=tx*m+ty;
                if(tx>=0&&tx<n&&ty>=0&&ty<m)
                if(mapt[tst]=='1'&&vist[tst]==0)
                {
                     fath[tst]=st;
                    vist[tst]=1+vist[st];
                    if(tst==endd)
                    {
                        return ;
                    }
                    q[!flag][inq[!flag]++]=tst;
                }
            }
        }
        inq[flag]=0;
        flag=!flag;
    }
}
char str[N*N];
void prin(int endd)
{
     int k=0;
    while(endd!=-1)
    {
        //printf("<-(%d,%d)%c ",endd/m,endd%m,mapt[endd]);
        str[k++]=mapt[endd];
        endd=fath[endd];
    }
    while(k--)
    {
        printf("%c",str[k]);
    }
    printf("\n");
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0; i<n; i++)
        {
            scanf("%s",str);
            for(int j=0; j<m; j++)
                mapt[i*m+j]=str[j];
        }

        int endd=n*m-1;
        bfs1(0);
        if(vist[endd]!=0)
        {
            printf("%c\n",mapt[endd]);
        }
        else
        {
            bfs2(endd);
            prin(endd);
        }
    }
}