zoj 2412 Farm Irrigation

最新推荐文章于 2017-11-05 17:49:18 发布
转载 最新推荐文章于 2017-11-05 17:49:18 发布 · 189 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/forever4444/archive/2009/05/11/1454349.html
文章标签：

#c/c++

本文探讨了一种通过连接不同类型的水管来实现农场灌溉的方法。利用并查集算法确定最少的水源点数量，确保整个农场得到充分灌溉。文章提供了具体的代码示例及分析。
ZOJ Problem Set - 2412
Farm Irrigation
Time Limit: 1 Second      Memory Limit: 32768 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


Author: ZHENG, Lu

Source: Zhejiang University Local Contest 2005
Submit    Status
// 1863626 2009-05-10 21:31:51 Wrong Answer  2412 C++ 0 200 Wpl 
 // 1864787 2009-05-11 18:23:54 Accepted  2412 C++ 10 200 Wpl 
#include  < iostream >
#define  MAX 55
using   namespace  std;
 int  n,m,un[MAX * MAX];
 char  map[MAX][MAX];
 int  dir[ 2 ][ 2 ] = {{ 0 , - 1 },{ - 1 , 0 }};
 void  Init()
{
     int  i,j;
     for (i = 0 ;i < m;i ++ )
         for (j = 0 ;j < n;j ++ )
        {
            un[i * n + j] = i * n + j;
            cin >> map[i][j];
        }
}
 bool  Bound( int  x, int  y)
{
     if (x >= 0 && y >= 0 && x < m && y < n)
         return   true ;
     else
         return   false ;
}
 int  Find( int  x)
{
     return  un[x];
}
 void  Merge( int  a, int  b)
{
     int  mmax,mmin,i,temp;
    mmax = Find(a);
    mmin = Find(b);
     if (mmax == mmin)
         return  ;
     if (mmin > mmax)
    {
        temp = mmin;
        mmin = mmax;
        mmax = temp;
    }
     for (i = 0 ;i < n * m;i ++ )
    {
         if (un[i] == mmax)
            un[i] = mmin;
    }
}
 int  main()
{
     int  i,j,k;
     while (scanf( " %d%d " , & m, & n) != EOF)
    {
         if (m < 0 || n < 0 )
             break ;
        Init();
         int  ti,tj,a,b;
         for (i = 0 ;i < m;i ++ )
             for (j = 0 ;j < n;j ++ )
            {
                 for (k = 0 ;k < 2 ;k ++ )
                {
                    ti = i + dir[k][ 0 ];
                    tj = j + dir[k][ 1 ];
                     if ( ! Bound(ti,tj))
                         continue ;
                    a = i * n + j;   // 我用行存储
                    b = ti * n + tj;
                     if (k == 0 )   // 向左
                    {
                         if (map[i][j] == ' A ' || map[i][j] == ' C ' || map[i][j] == ' F ' || map[i][j] == ' G ' || map[i][j] == ' H ' || map[i][j] == ' I ' || map[i][j] == ' K ' )
                        {
                             if (map[ti][tj] == ' B ' || map[ti][tj] == ' D ' || map[ti][tj] == ' F ' || map[ti][tj] == ' G ' || map[ti][tj] == ' I ' || map[ti][tj] == ' J ' || map[ti][tj] == ' K ' )
                            {
                                Merge(a,b);
                            }
                        }
                    }
                     else       // 向上
                    {
                         if (map[i][j] == ' A ' || map[i][j] == ' B ' || map[i][j] == ' E ' || map[i][j] == ' G ' || map[i][j] == ' H ' || map[i][j] == ' J ' || map[i][j] == ' K ' )
                        {
                             if (map[ti][tj] == ' C ' || map[ti][tj] == ' D ' || map[ti][tj] == ' E ' || map[ti][tj] == ' H ' || map[ti][tj] == ' I ' || map[ti][tj] == ' J ' || map[ti][tj] == ' K ' )
                            {
                                Merge(a,b);
                            }
                        }
                    }
                }
            }
         int  sum = 0 ;
         for (i = 0 ;i < m;i ++ )
             for (j = 0 ;j < n;j ++ )
            {
                 if (un[i * n + j] == (i * n + j))
                    sum ++ ;
            }
        printf( " %d\n " ,sum);
    }
     return   0 ;
}

好好反思这个代码为什么错误??????

 

Problem :  1198  ( Farm Irrigation )     Judge Status : Wrong Answer
RunId :  1357129     Language : C ++     Author : forever4444
Code Render Status : Rendered By HDOJ C ++  Code Rander Version  0.01  Beta
 // 1863626 2009-05-10 21:31:51 Wrong Answer  2412 C++ 0 200 Wpl 
#include  < iostream >
#define  MAX 55
using   namespace  std;
 int  n,m,un[MAX * MAX];
 char  map[MAX][MAX];
 int  dir[ 2 ][ 2 ] = {{ 0 , - 1 },{ - 1 , 0 }};
 void  Init()
{
     int  i,j;
     for (i = 0 ;i < m;i ++ )
         for (j = 0 ;j < n;j ++ )
        {
            un[i * m + j] = i * m + j;
            cin >> map[i][j];
        }
}
 bool  Bound( int  x, int  y)
{
     if (x >= 0 && y >= 0 && x < m && y < n)
         return   true ;
     else
         return   false ;
}
 int  Find( int  x)
{
     return  un[x];
}
 void  Merge( int  a, int  b)
{
     int  mmax,mmin,i,temp;
    mmax = Find(a);
    mmin = Find(b);
     if (mmax == mmin)
         return  ;
     if (mmin > mmax)
    {
        temp = mmin;
        mmin = mmax;
        mmax = temp;
    }
     for (i = 0 ;i < n * m;i ++ )
    {
         if (un[i] == mmax)
            un[i] = mmin;
    }
}
 int  main()
{
     int  i,j,k;
     while (scanf( " %d%d " , & m, & n) != EOF)
    {
         if (m < 0 || n < 0 )
             break ;
        Init();
         int  ti,tj,a,b;
         for (i = 0 ;i < m;i ++ )
             for (j = 0 ;j < n;j ++ )
            {
                 for (k = 0 ;k < 2 ;k ++ )
                {
                    ti = i + dir[k][ 0 ];
                    tj = j + dir[k][ 1 ];
                    a = i * m + j;   // 我用行存储
                    b = ti * m + tj;
                     if ( ! Bound(ti,tj))
                         continue ;
                     if (k == 0 )   // 向左
                    {
                         if (map[i][j] == ' A ' || map[i][j] == ' C ' || map[i][j] == ' F ' || map[i][j] == ' G ' || map[i][j] == ' H ' || map[i][j] == ' I ' || map[i][j] == ' K ' )
                        {
                             if (map[ti][tj] == ' B ' || map[ti][tj] == ' D ' || map[ti][tj] == ' F ' || map[ti][tj] == ' G ' || map[ti][tj] == ' I ' || map[ti][tj] == ' J ' || map[ti][tj] == ' K ' )
                            {
                                Merge(a,b);
                            }
                        }
                    }
                     else       // 向上
                    {
                         if (map[i][j] == ' A ' || map[i][j] == ' B ' || map[i][j] == ' E ' || map[i][j] == ' G ' || map[i][j] == ' H ' || map[i][j] == ' J ' || map[i][j] == ' K ' )
                        {
                             if (map[ti][tj] == ' C ' || map[ti][tj] == ' D ' || map[ti][tj] == ' E ' || map[ti][tj] == ' H ' || map[ti][tj] == ' I ' || map[ti][tj] == ' J ' || map[ti][tj] == ' K ' )
                            {
                                Merge(a,b);
                            }
                        }
                    }
                }
            }
         int  sum = 0 ;
         for (i = 0 ;i < m;i ++ )
             for (j = 0 ;j < n;j ++ )
            {
                 if (un[i * m + j] == (i * m + j))
                    sum ++ ;
            }
        printf( " %d\n " ,sum);
    }
     return   0 ;
}
 // 1863626 2009-05-10 21:31:51 Wrong Answer  2412 C++ 0 200 Wpl 
#include  < iostream >
#define  MAX 55
using   namespace  std;
 int  n,m,un[MAX * MAX];
 char  map[MAX][MAX];
 int  dir[ 2 ][ 2 ] = {{ 0 , - 1 },{ - 1 , 0 }};
 void  Init()
{
     int  i,j;
     for (i = 0 ;i < m;i ++ )
         for (j = 0 ;j < n;j ++ )
        {
            un[i * m + j] = i * m + j;
            cin >> map[i][j];
        }
}
 bool  Bound( int  x, int  y)
{
     if (x >= 0 && y >= 0 && x < m && y < n)
         return   true ;
     else
         return   false ;
}
 int  Find( int  x)
{
     return  un[x];
}
 void  Merge( int  a, int  b)
{
     int  mmax,mmin,i,temp;
    mmax = Find(a);
    mmin = Find(b);
     if (mmax == mmin)
         return  ;
     if (mmin > mmax)
    {
        temp = mmin;
        mmin = mmax;
        mmax = temp;
    }
     for (i = 0 ;i < n * m;i ++ )
    {
         if (un[i] == mmax)
            un[i] = mmin;
    }
}
 int  main()
{
     int  i,j,k;
     while (scanf( " %d%d " , & m, & n) != EOF)
    {
         if (m < 0 || n < 0 )
             break ;
        Init();
         int  ti,tj,a,b;
         for (i = 0 ;i < m;i ++ )
             for (j = 0 ;j < n;j ++ )
            {
                 for (k = 0 ;k < 2 ;k ++ )
                {
                    ti = i + dir[k][ 0 ];
                    tj = j + dir[k][ 1 ];
                    a = i * m + j;   // 我用行存储
                    b = ti * m + tj;
                     if ( ! Bound(ti,tj))
                         continue ;
                     if (k == 0 )   // 向左
                    {
                         if (map[i][j] == ' A ' || map[i][j] == ' C ' || map[i][j] == ' F ' || map[i][j] == ' G ' || map[i][j] == ' H ' || map[i][j] == ' I ' || map[i][j] == ' K ' )
                        {
                             if (map[ti][tj] == ' B ' || map[ti][tj] == ' D ' || map[ti][tj] == ' F ' || map[ti][tj] == ' G ' || map[ti][tj] == ' I ' || map[ti][tj] == ' J ' || map[ti][tj] == ' K ' )
                            {
                                Merge(a,b);
                            }
                        }
                    }
                     else       // 向上
                    {
                         if (map[i][j] == ' A ' || map[i][j] == ' B ' || map[i][j] == ' E ' || map[i][j] == ' G ' || map[i][j] == ' H ' || map[i][j] == ' J ' || map[i][j] == ' K ' )
                        {
                             if (map[ti][tj] == ' C ' || map[ti][tj] == ' D ' || map[ti][tj] == ' E ' || map[ti][tj] == ' H ' || map[ti][tj] == ' I ' || map[ti][tj] == ' J ' || map[ti][tj] == ' K ' )
                            {
                                Merge(a,b);
                            }
                        }
                    }
                }
            }
         int  sum = 0 ;
         for (i = 0 ;i < m;i ++ )
             for (j = 0 ;j < n;j ++ )
            {
                 if (un[i * m + j] == (i * m + j))
                    sum ++ ;
            }
        printf( " %d\n " ,sum);
    }
     return   0 ;
}

转载于:https://www.cnblogs.com/forever4444/archive/2009/05/11/1454349.html

zoj 2412 Farm Irrigation #DFS
Mr.CJ
08-03 680
/** 最少水源数目即 求农场中有几个联通的水源集合，数据较小，直接DFS。 注意邻接水源的可达性。 */ #include #include #include using namespace std; char mat[55][55]; int m,n; int cnt; int vis[55][55]; int move[][2] = {0,1,1,0,0,-1,-1,0}; int
Farm Irrigation（ZOJ - 2412 ）农田灌溉
shiuxin的博客
07-24 386
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.
hdu 1198 Farm Irrigation
我是传奇
08-10 180
点击打开hdu 1198 思路: 并查集 分析: 1 题目给定11快小方形，然后给定一个n*m的描述求n*m矩阵内的连通分量的个数 2 首先我们应该解决怎么保存11块小方形，我们可以利用一个思维的分量来描述，比如A我们描述成{1,0,0,1} 3 那么我们就可以做到在线进行并查集的操作，对于[i,j]这个方块，它可能和[i-1,j]和[i,j-1]进行相连，那么用i*m+j来唯一表示一个...
HDU1198-Farm Irrigation
wang_128的博客
09-12 336
Farm Irrigation                                                                            Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)                      
HDU 1198 Farm Irrigation
Ezereal的博客
12-12 458
题意：有如上图11种土地块，块中的绿色线条为土地块中修好的水渠，现在一片土地由上述的各种土地块组成，需要浇水，问需要打多少口井。 题解：联通块类型题，关键是预处理好给定的几个图形，按照4位二进制保存 #include #include #include #include #include #include #include #include #include #include
HDU 1198 Farm Irrigation （并查集 和 dfs两种实现）
凌风
04-20 4817
题意：有如上图11种土地块，块中的绿色线条为土地块中修好的水渠，现在一片土地由上述的各种土地块组成，需要浇水，问需要打多少口井。 例如下面这个土地块 ADC FJK IHE then the water pipes are distributed like 如图对于能相连的地只需要打一口井，所以以上需要打三口井就能浇所有的块。稍加分析就可得出本质上就是集合的合并，最后求有几个集合的问题，很容易想到并查集。只需要对每个地块与右方和下方的地块进行合并即可。合并之前先判断是否能连通，若能连通则合并，不
Farm Irrigation HDU - 1198
sunyutian1998的博客
11-05 276
点击打开链接 没什么道道 就是麻烦 要仔细 看每个块是什么类型 又能和什么类型的块相连 预处理一下即可   #include &lt;bits/stdc++.h&gt; using namespace std; struct node { int dir[4]; }; node per[11]; int mp[100][100]; int f[5000]; int n,m; ...
“农田灌溉(Farm Irrigation), ZOJ2412”问题的一种解法
PosPro的专栏
05-07 1658
本博客是Pospro对“ZOJ2412，农田灌溉（Farm Irrigation）问题”的一种解答，采用了递归的DFS方法，并引入了位运算。
zoj 1002_zoj1002_
09-29
【标题】"ZOJ 1002" 是一个在线编程竞赛题目，源自ZOJ（Zhejiang Online Judge），这是一个面向ACM/ICPC（国际大学生程序设计竞赛）的在线评测系统。题目编号1002，通常表示该题是ZOJ平台上的一个问题，可能涉及算法...
zoj.gz_ ZOJ_ZOJ 1016_max flow_zoj 1045_zoj.rar
09-24
标题中的"ZOJ.gz_ ZOJ_ZOJ 1016_max flow_zoj 1045_zoj.rar" 提到了两个ZOJ（Zhejiang Online Judge）的题目，分别是1016和1045，这两个数字通常代表在线编程竞赛中的题目编号。这些题目通常涉及到算法和数据结构的...
HDU-1198-Farm Irrigation
逐梦者
11-01 1105
ACM模版描述 题解使用二进制标记匹配状态，并查集搞搞，思路倒是不难，并查集的改造需要注意细节~~~还可以DFS搞。代码#include <iostream> #include <cstdio> #include <cstring>#define mem(a, b) memset(a, b, sizeof(a))using namespace std;// 二进制表示状态 const int m
(HDU - 1198)Farm Irrigation
The wind of freedom blows
08-24 335
(HDU - 1198)Farm Irrigation 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
HDU1198--Farm Irrigation
SCUT_Pein
04-11 771
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
Farm Irrigation HDU - 1198 （并查集）
lwgkzl的博客
08-08 321
Farm Irrigation Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 10286    Accepted Submission(s): 4523 Problem Description Benny has
HDU_1198_FarmIrrigation
OTTFF的博客
08-11 556
Farm Irrigation Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 7285    Accepted Submission(s): 3123 Problem Description Benny has
ZOJ入门与提高题目代码集锦
ZOJ（Zhejiang University Online Judge）是由浙江大学开发并维护的一个在线编程评测系统，广泛应用于算法训练、程序设计竞赛准备以及计算机相关专业学生的编程能力提升。该平台汇集了大量经典的算法题目，覆盖数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值