HOJ 位图[BFS]

位图

Time Limit: 1000ms, Special Time Limit:2500ms, Memory Limit:32768KB

Total submit users: 230, Accepted users: 201

Problem 10109 : No special judgement

Problem description

现在我们给出一个n×m的单色位图，且该为图中至少含有一个白色的像素。我们用(i, j)来代表第i行第j列的像素，并且定义两点p1=(i1, j1)和p2=(i2, j2)之间的距离为： d(p1, p2)=|i1 - i2| + |j1 - j2|
请写一个程序：
读入该位图；对于每个像素，计算出离该像素最近的白色像素与它的距离。

Input

第一行包括两个用空格分开的整数n和m，1<=n<=182，1<=m<=182。以下的n行每行包括一个长度为m的用0和1组成的字符串，在第i+1行的第j个字符如果为”1”，那么表示像素(i, j)为白的，否则为黑的。

Output

输出一个n×m的数表，其中的第i行的第j个数字为f(i, j)表示像素(i, j)到最近的白色像素的距离。

Sample Input

3 4
0001
0011
0110

Sample Output

3 2 1 0
2 1 0 0
1 0 0 1

Judge Tips

注意输出的f(i,j)数据，每两个之间为一个空格。
你可以在网站http://www.mimuw.edu.pl/~msawicki/stereo.html上找到一个叫做Stereogram的小程序，这就是该问题的原型。

Problem Source

SDOI

Submit   Discuss   Judge Status  Problems  Ranklist 

刚开始的时候一直想着用1来作为起点进行搜索，后来才改过来，BFS搜的就是最短距离。

code:

/*
3 2
01
00
10
1 0
1 1
0 1
4 4
1000
0000
0000
0001
0 1 2 3
1 2 3 2
2 3 2 1
3 2 1 0
5 5
00000
00000
00100
00000
00000
4 3 2 3 4
3 2 1 2 3
2 1 0 1 2
3 2 1 2 3
4 3 2 3 4
5 5
10001
00000
00100
00000
10001
0 1 2 1 0
1 2 1 2 1
2 1 0 1 2
1 2 1 2 1
0 1 2 1 0
*/ 
#include <iostream>   
#include <iomanip>   
#include <fstream>   
#include <sstream>   
#include <algorithm>   
#include <string>   
#include <set>   
#include <utility>   
#include <queue>   
#include <stack>   
#include <list>   
#include <vector>   
#include <cstdio>   
#include <cstdlib>   
#include <cstring>   
#include <cmath>   
#include <ctime>   
#include <ctype.h> 
using namespace std;

int n,m; 
int map[205][205];
int res[205][205];
int record[100205][2];
int vst[205][205]; 
int cnt;
char str[1100];
int dir[4][2]={
    0,1,
    0,-1,
    1,0,
    -1,0 
};

typedef struct node 
{
    int x,y;
    int step;
}Node;

bool check(int x,int y)
{
    if(x>=0&&x<n&&y>=0&&y<m&&!vst[x][y])
        return true;
    else
        return false;
}

void BFS(int sx,int sy)
{
    int i;
    memset(vst,0,sizeof(vst));
    vst[sx][sy]=1;
    queue<Node>Que;
    Node pre,last;
    pre.x=sx;
    pre.y=sy;
    pre.step=0;
    Que.push(pre);
    while(!Que.empty())
    {
        pre=Que.front();
        Que.pop();
        if(map[pre.x][pre.y]==1)
        {
            res[sx][sy]=pre.step;
             return;
        } 
        for(i=0;i<4;i++)
        {
            last.x=pre.x+dir[i][0];
            last.y=pre.y+dir[i][1];
            last.step=pre.step+1;
            if(check(last.x,last.y))
            {
                Que.push(last);
                vst[last.x][last.y]=1;
            }
        }
    }
}
    

int main()
{
    int i,j;
    while(~scanf("%d%d",&n,&m))
    { 
        cnt=0;
        memset(map,0,sizeof(map));
        memset(res,0,sizeof(res)); 
        getchar();
        for(i=0;i<n;i++)
        {
             for(j=0;j<m;j++)
            {
                 if(getchar()=='0')
                 {
                    map[i][j]=0;
                     record[cnt][0]=i;
                     record[cnt++][1]=j;
                } 
                 else
                    map[i][j]=1;
              }
            getchar();
        }
        for(i=0;i<cnt;i++)
            BFS(record[i][0],record[i][1]);
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
            {
                if(j==0)
                   printf("%d",res[i][j]);
                else
                   printf(" %d",res[i][j]);
            }
            printf("\n");
        }  
    } 
    return 0;
}