HDU 1198 Farm Irrigation 两种方法（dfs，并查集）

http://acm.hdu.edu.cn/showproblem.php?pid=1198

Farm Irrigation

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

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

 题目大意：给定农田的水管的走向，如果两块农田有水管能够互相连通，则它们是相连的，水流能通过两块农田。要你求出最少需要挖多少口井（水井在每块农田的正中央），才能使所有农田都被灌溉。根据上图例子，需要3口水井就能将所有农田都被灌溉。

分析：这道题有两种方法可以做，第一种是简单dfs，第二种是并查集，dfs如果不懂的同学就要去普及搜索知识了。并查集的话同样，求连通区域的个数，如果两块农田连通，则它们在一个等价类中，最后求等价类个数。

dfs方法实现如下，首先要对11个农田状态进行标记，个人标记的方法各不相同，可以使用二维数组存储，这里我用结构体表示更为直观：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

struct farm
{
    bool left,right,top,bottom;
    farm()
    {
        left=right=top=bottom=false;
    }
}FM[13];
char mp[55][55];
bool vis[55][55];
int n, m;
void init()
{
    FM[0].left=FM[0].top=true;
    FM[1].right=FM[1].top=true;
    FM[2].left=FM[2].bottom=true;
    FM[3].right=FM[3].bottom=true;
    FM[4].top=FM[4].bottom=true;
    FM[5].left=FM[5].right=true;
    FM[6].left=FM[6].right=FM[6].top=true;
    FM[7].left=FM[7].top=FM[7].bottom=true;
    FM[8].left=FM[8].right=FM[8].bottom=true;
    FM[9].top=FM[9].right=FM[9].bottom=true;
    FM[10].left=FM[10].right=FM[10].top=FM[10].bottom=true;
}
void dfs(int x, int y)
{
    vis[x][y] = true;
    int c  = mp[x][y]-'A';
    if(x-1>=0 && FM[c].top && FM[mp[x-1][y]-'A'].bottom && !vis[x-1][y])
        dfs(x-1, y);
    if(y-1>=0 && FM[c].left && FM[mp[x][y-1]-'A'].right && !vis[x][y-1])
        dfs(x, y-1);
    if(x+1 < m && FM[c].bottom &&  FM[mp[x+1][y]-'A'].top && !vis[x+1][y])
        dfs(x+1, y);
    if(y+1 < n && FM[c].right && FM[mp[x][y+1]-'A'].left && !vis[x][y+1])
        dfs(x, y+1);
}
int main()
{
    init();
    while(cin >> m >> n)
    {
        if(m<0 || n<0) break;
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                cin >> mp[i][j];
        memset(vis, false,sizeof(vis));
        int sum = 0;
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(!vis[i][j])
                {
                    sum++;
                    dfs(i, j);
                }
        printf("%d\n", sum);
    }
    return 0;
}

并查集方法，将二维坐标转化为一维，对每块农田找左、上连通情况，合并等价类，关于等价类更多知识，请读者补充知识：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

int F[3100];
char mp[55][55];
int m, n;
char pipe[11][5] = {"1100", "0110", "1001", "0011", "0101",
    "1010", "1110", "1101", "1011", "0111", "1111"};
int Find(int x)
{
    if(F[x] == -1) return x;
    return Find(F[x]);
}
void Union(int x, int y)
{
    int t1 = Find(x);
    int t2 = Find(y);
    if(t1 != t2)
        F[t1] = t2;
}
int main()
{
    while(scanf("%d%d", &m, &n))
    {
        if(m<0 || n<0) break;
        for(int i = 0; i < m; i++)
                scanf("%s", &mp[i]);
        memset(F, -1, sizeof(F));
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
            {
                if(i>0 && pipe[mp[i][j]-'A'][1]=='1' && pipe[mp[i-1][j]-'A'][3]=='1')
                    Union(i*n+j, (i-1)*n+j);
                if(j>0 && pipe[mp[i][j]-'A'][0]=='1' && pipe[mp[i][j-1]-'A'][2]=='1')
                    Union(i*n+j, i*n+j-1);
            }
        int cnt = 0;
        for(int i = 0; i < m*n; i++)
            if(F[i] == -1)
                cnt++;
        printf("%d\n", cnt);
    }
    return 0;
}