hdu 1198 Farm Irrigation【BFS】

最新推荐文章于 2019-10-18 19:12:41 发布

原创最新推荐文章于 2019-10-18 19:12:41 发布 · 795 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#hdu 1198 #hdoj 1198 #杭电 1198

搜索专栏收录该内容

224 篇文章

订阅专栏

本文介绍了一种解决农场灌溉问题的方法，通过广度优先搜索算法确定最少需要多少个水源点才能灌溉整个农场。该问题转化为寻找图中连通区域的数量。

Farm Irrigation

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 8460 Accepted Submission(s): 3628

Problem Description

Benny has a spacious farm land to irrigate. The farm land is a rectangle, and is divided into a lot of samll squares. Water pipes are placed in these squares. Different square has a different type of pipe. There are 11 types of pipes, which is marked from A to K, as Figure 1 shows.

Figure 1

Benny has a map of his farm, which is an array of marks denoting the distribution of water pipes over the whole farm. For example, if he has a map

ADC
FJK
IHE

then the water pipes are distributed like

Figure 2

Several wellsprings are found in the center of some squares, so water can flow along the pipes from one square to another. If water flow crosses one square, the whole farm land in this square is irrigated and will have a good harvest in autumn.

Now Benny wants to know at least how many wellsprings should be found to have the whole farm land irrigated. Can you help him?

Note: In the above example, at least 3 wellsprings are needed, as those red points in Figure 2 show.

Input

There are several test cases! In each test case, the first line contains 2 integers M and N, then M lines follow. In each of these lines, there are N characters, in the range of 'A' to 'K', denoting the type of water pipe over the corresponding square. A negative M or N denotes the end of input, else you can assume 1 <= M, N <= 50.

Output

For each test case, output in one line the least number of wellsprings needed.

Sample Input
2 2
DK
HF

3 3
ADC
FJK
IHE

-1 -1

Sample Output
2
3

Author

ZHENG, Lu

Source

Zhejiang University Local Contest 2005

并查集也能AC。不过感觉还是搜索习惯些，这里我使用的广搜。

题目大意：给你一个图，连通在一起的管道需要用一口井来供给，判断一共需要几口井，简单的说就是判断有多少联通块。

思路：一共无非十一种草地，我们在判断两块草地能否相同的时候，需要一个判断是否连通的条件，我们这里这样来处理这个问题：

用dir【11】【4】二维数组存11种草地的四个方向是否有管道。初始化为这样：

dir【i】【0】表示上边是否有管道

dir【i】【1】表示左边是否有管道

dir【i】【2】表示下边是否有管道

dir【i】【3】表示右边是否有管道

1表示有，0表示没有。

int dir[11][4]={{1,1,0,0},{1,0,0,1},{0,1,1,0},{0,0,1,1},{1,0,1,0},{0,1,0,1},{1,1,0,1},{1,1,1,0},{0,1,1,1},{1,0,1,1},{1,1,1,1}};

然后思路就简单多了，直接遍历整个图，如果这个点没有走过就BFS一下，并且计数器加一，直到整个图遍历完为止。

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        if(n<0||m<0)break;
        for(int i=0;i<n;i++)
        {
            scanf("%s",a[i]);
        }
        memset(vis,0,sizeof(vis));
        int cont=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(vis[i][j]==0)
                {
                    cont++;
                    bfs(i,j);
                }
            }
        }
        printf("%d\n",cont);
    }
}

在BFS过程中：

void bfs(int x,int y)
{
    now.x=x;
    now.y=y;
    now.kind=a[x][y]-'A';//表示草地种类。
    vis[x][y]=1;
    queue<zuobiao >s;
    s.push(now);
    while(!s.empty())
    {
        now=s.front();
        s.pop();
        for(int i=0;i<4;i++)//只有四个方向会有管道
        {
            nex.x=now.x+fx[i];
            nex.y=now.y+fy[i];
            nex.kind=a[nex.x][nex.y]-'A';//下一块草地的种类
            if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&vis[nex.x][nex.y]==0)//在边界范围内并且这个草地没有走过
            {
                if(dir[now.kind][i]==1&&dir[nex.kind][(i+2)%4]==1)//如果这两个草地能连通，这个加2对4求余还是很好想的，拿草纸画画就推出来了。
                {
                    vis[nex.x][nex.y]=1;
                    s.push(nex);//入队。
                }
            }
        }
    }
}

完整AC代码：

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
struct zuobiao
{
    int x,y,kind;
}now,nex;
int n,m;
char a[55][55];
int vis[55][55];
int fx[4]={-1,0,1,0};
int fy[4]={0,-1,0,1};
int dir[11][4]={{1,1,0,0},{1,0,0,1},{0,1,1,0},{0,0,1,1},{1,0,1,0},{0,1,0,1},{1,1,0,1},{1,1,1,0},{0,1,1,1},{1,0,1,1},{1,1,1,1}};
void bfs(int x,int y)
{
    now.x=x;
    now.y=y;
    now.kind=a[x][y]-'A';
    vis[x][y]=1;
    queue<zuobiao >s;
    s.push(now);
    while(!s.empty())
    {
        now=s.front();
        s.pop();
        for(int i=0;i<4;i++)
        {
            nex.x=now.x+fx[i];
            nex.y=now.y+fy[i];
            nex.kind=a[nex.x][nex.y]-'A';
            if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&vis[nex.x][nex.y]==0)
            {
                if(dir[now.kind][i]==1&&dir[nex.kind][(i+2)%4]==1)
                {
                    vis[nex.x][nex.y]=1;
                    s.push(nex);
                }
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        if(n<0||m<0)break;
        for(int i=0;i<n;i++)
        {
            scanf("%s",a[i]);
        }
        memset(vis,0,sizeof(vis));
        int cont=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(vis[i][j]==0)
                {
                    cont++;
                    bfs(i,j);
                }
            }
        }
        printf("%d\n",cont);
    }
}