ZOJ 2412 Farm Irrigation

　　

Farm Irrigation

---

Time Limit: 2 Seconds      Memory Limit: 65536 KB

---

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

分析：

　　该题目的大致意思就是，给定你一个农田的矩阵，矩阵中每个元素都有一种类型的水管，问最少配置几个水源可以灌溉整个农田？很显然，这是一个图的遍历问题。每个元素做为一个节点，水管的方向代表从当前这个节点可以到达的方向（同时要保证相邻的节点也有对应的水管进行连接）。所以，这里的主要问题就是：当处于农田某个位置时，如何判断他的四个方向是否可以走？可以得话，直接递归调用遍历函数dfs（）访问下个一元素即可，这里便是dfs思想的体现。我一开始想到的办法是，判断当前的字母是什么，比如说是A，然后再判断四个方向是否可以走：因为A的下和右没有水管指向，所以这两个方向肯定不可以走，然后判断左边是否是B或者C或者F或者G或者I或者J或者K（因为这几个字母都有指向左边的水管），有则可以从这个方向进行DFS。A的上方向同样处理。这样做下来之后，可以发现十分的不方便，要处理情况太多，代码量也将变得十分复杂（出现了很多的重复代码，几乎相当于用代码穷举出每个字母的每个方向是否可以走）。

　　后来想到了一个比较巧妙的方法，其做法如下：

　　声明一个如下的结构体

struct node
{
    char ch;//该位置的字母
    int flag;//用于判断该位置 是否遍历过
    int a,b,c,d;//分别表示左、上、右、下是否有水管。0表示没有，1表示有
};
node src[][];

　　那么如何快速判断当前位置(x,y)的下一个方向(xx,yy)是否可达呢(假设(xx,yy)未访问过且没有越界)？前面已经说过，(x,y)可以向左边走的条件是左边那小块农田有个指向右边的水管，所以，我们只要判断(x,y)的各方向是否可以走，可以这样判断:

　　假设(xx,yy)为(x,y)的上边相邻元素：若(x,y).b*(xx,yy).d==1,则可从(x,y)往上走

　　假设(xx,yy)为(x,y)的下边相邻元素：若(x,y).d*(xx,yy).b==1,则可从(x,y)往下走

　　假设(xx,yy)为(x,y)的左边相邻元素：若(x,y).a*(xx,yy).c==1,则可从(x,y)往左走

　  假设(xx,yy)为(x,y)的右边相邻元素：若(x,y).c*(xx,yy).a==1,则可从(x,y)往右走

　　所以，dfs(int x,int y)的函数实现如下：

void dfs (int x,int y)
{
    if(x<||x>=m||y<||y>=n) return ;//判断越界
    src[x][y].flag=;
    if(x->=&&src[x-][y].flag==&&src[x][y].b*src[x-][y].d==){//越界判断+访问标志判断+是否可走判断
        dfs(x-,y);
    }
    if(x+<m&&src[x+][y].flag==&&src[x][y].d*src[x+][y].b==){
        dfs(x+,y);
    }
    if(y->=&&src[x][y-].flag==&&src[x][y].a*src[x][y-].c==){
        dfs(x,y-);
    }
    if(y+<n&&src[x][y+].flag==&&src[x][y].c*src[x][y+].a==){
        dfs(x,y+);
    }
    return ;
}

　　具备以上的了解，则求其最小连通度即可。

　　该题目的完整C++实现代码如下：

 #include <iostream>
 using namespace std;
 int m,n;
 struct node
 {
     char ch;
     int flag;
     int a,b,c,d;//分别表示左、上、右、下
 };

 node src[][];

 void dfs (int x,int y)
 {
     if(x<||x>=m||y<||y>=n) return ;
     src[x][y].flag=;
     if(x->=&&src[x-][y].flag==&&src[x][y].b*src[x-][y].d==){
         dfs(x-,y);
     }
     if(x+<m&&src[x+][y].flag==&&src[x][y].d*src[x+][y].b==){
         dfs(x+,y);
     }
     if(y->=&&src[x][y-].flag==&&src[x][y].a*src[x][y-].c==){
         dfs(x,y-);
     }
     if(y+<n&&src[x][y+].flag==&&src[x][y].c*src[x][y+].a==){
         dfs(x,y+);
     }
     return ;
 }

 int main()
 {
     while(cin>>m>>n){
         if(m<||n<) break;
         for(int i=;i<m;i++){
             for(int j=;j<n;j++){
                 cin>>src[i][j].ch;
                 switch(src[i][j].ch){
                     case 'A':
                         src[i][j].a=;
                         src[i][j].b=;
                         src[i][j].c=;
                         src[i][j].d=;
                         break;
                     case 'B':
                         src[i][j].a=;
                         src[i][j].b=;
                         src[i][j].c=;
                         src[i][j].d=;
                         break;
                     case 'C':
                         src[i][j].a=;
                         src[i][j].b=;
                         src[i][j].c=;
                         src[i][j].d=;
                         break;
                     case 'D':
                         src[i][j].a=;
                         src[i][j].b=;
                         src[i][j].c=;
                         src[i][j].d=;
                         break;
                     case 'E':
                         src[i][j].a=;
                         src[i][j].b=;
                         src[i][j].c=;
                         src[i][j].d=;
                         break;
                     case 'F':
                         src[i][j].a=;
                         src[i][j].b=;
                         src[i][j].c=;
                         src[i][j].d=;
                         break;
                     case 'G':
                         src[i][j].a=;
                         src[i][j].b=;
                         src[i][j].c=;
                         src[i][j].d=;
                         break;
                     case 'H':
                         src[i][j].a=;
                         src[i][j].b=;
                         src[i][j].c=;
                         src[i][j].d=;
                         break;
                     case 'I':
                         src[i][j].a=;
                         src[i][j].b=;
                         src[i][j].c=;
                         src[i][j].d=;
                         break;
                     case 'J':
                         src[i][j].a=;
                         src[i][j].b=;
                         src[i][j].c=;
                         src[i][j].d=;
                         break;
                     case 'K':
                         src[i][j].a=;
                         src[i][j].b=;
                         src[i][j].c=;
                         src[i][j].d=;
                         break;
                 }
                 src[i][j].flag=;
             }
         }
         int ans=;
         for(int i=;i<m;i++){
             for(int j=;j<n;j++){
                 if(src[i][j].flag==){
                     ans++;
                     dfs(i,j);
                 }
             }
         }
         cout<<ans<<endl;
     }
 }