ACM-水池数目问题

大家好，这是我的第一篇博文。

最近在做ACM练习，在讨论区发现有很多问题的解法多种多样，故萌生念头将自己已AC题目的解题思路整理发文。

发此博文不为求得最高效的解题代码，旨在分享自己的解题方法，与大家交流学习，共同探讨。

言归正传-----南阳ACM-27题  水池数目

水池数目

时间限制：3000 ms  |  内存限制：65535 KB

难度：4

描述

***校园里有一些小河和一些湖泊，现在，我们把它们通一看成水池，假设有一张我们学校的某处的地图，这个地图上仅标识了此处是否是水池，现在，你的任务来了，请用计算机算出该地图中共有几个水池。

输入

第一行输入一个整数N，表示共有N组测试数据
每一组数据都是先输入该地图的行数m(0<m<100)与列数n(0<n<100)，然后，输入接下来的m行每行输入n个数，表示此处有水还是没水（1表示此处是水池，0表示此处是地面）

输出

输出该地图中水池的个数。
要注意，每个水池的旁边（上下左右四个位置）如果还是水池的话的话，它们可以看做是同一个水池。

样例输入

2
3 4
1 0 0 0 
0 0 1 1
1 1 1 0
5 5
1 1 1 1 0
0 0 1 0 1
0 0 0 0 0
1 1 1 0 0
0 0 1 1 1

样例输出

　　　  2

　　　  3

我的思路

在《数字图像处理》中，这类问题可用“区域生长法”来解决，有兴趣的可以查阅相关文献；

根据题目描述，四邻域有1相连通，可认为是一个区域（水池）。

这里利用数据结构中的堆栈来解决。

⑴首先将矩阵第一个为1（且未被标记）的点作为起始点，压入栈，并对其标记已入栈，水池数目+1；

⑵栈顶元素出栈，检查出栈元素周围四邻域^[1]有无1（并且该位置没有被压入过栈^[2]），若有则将其压入栈，并对其标记已入栈；

⑶返回（2），至栈底为空结束。

⑷返回（1），至循环矩阵结束。

[1]注意边界位置，四邻域不要导致数组下标越界。

[2]可建立一个临时标记场，标记入栈元素。

代码如下：

#include <iostream>
#include <string.h>
using namespace std;

typedef struct Point
{
    int x;
    int y;
    int val;
}Point;

#define MAXSIZE 10000                //堆栈最大元素个数
#define OUTRANGE 0x0                //数组下标越界
//定义堆栈
template<class T>  //模版类
class CStack
{
public:
    CStack(int num);
    int Push(T elem);    //入栈
    int Pop(T& elem); //出栈
    int count();            //栈中元素个数
    ~CStack();
private:
    int Maxnum;            //栈元素最大数目
    T *top;                    //栈顶指针
    T *base;                //栈底指针            
};
template <typename T>
CStack<T>::CStack(int num)
{
　　if（num>MAXSIZE）
　　　　//exit(0);　//AC判题不允许
　　　　；　　　
    Maxnum = num;
    base = new T[Maxnum];
    top = base;
}
template <typename T>
CStack<T>::~CStack()            //析构函数
{
    top = NULL;
    delete []top;
    delete[]base;
    base = NULL;
}
template <typename T>
int CStack<T>::Push(T elem)
{
    if ((top-base)>=Maxnum)
    {
        return 0;
    }
     top++;
    *top = elem;
    return 1;
}
template<typename T>
int CStack<T>::Pop(T& elem)
{
    if (top==base)
    {
        return 0;
    }
    elem = *top;
    top--;
    return 1;
}
template<typename T>
int CStack<T>::count()
{
    return top - base;            //等于 取整 (指针间地址长度/每个元素占用地址长度)-->本程序中为 （int）（top地址-base地址/sizeof(Point)）=元素个数
}
int main()
{
    int i_ceshi, iLine, iSample;

    cin >> i_ceshi;
    while (i_ceshi--)
    {
        int icount = 0;//水池个数
        cin >> iLine >> iSample;

        //构造水池矩阵
        int **Matrix = new int*[iLine];
        for (int i = 0; i < iLine;i++)
        {
            Matrix[i] = new int[iSample];
        }

        for (int i = 0; i < iLine;i++)
        {
            for (int j = 0; j < iSample;j++)
            {
                cin >> Matrix[i][j];
            }
        }

        //构造像素标记场
        int *mark = new int[iLine*iSample];
        memset(mark, 0, iLine*iSample*sizeof(int));  //置为0

        //运用堆栈，区域生长
        CStack<Point> stack(iLine*iSample);
        
        for (int i = 0; i < iLine;i++)
        {
            for (int j = 0; j < iSample;j++)
            {
                Point pxlpoint;                                    //当前像元
                pxlpoint.x = i;
                pxlpoint.y = j;
                pxlpoint.val= Matrix[i][j];
                int currentpx = i*iSample + j;
                int mktmp = mark[currentpx];                        //标记场像元
                if (pxlpoint.val && mktmp == 0) {
                    stack.Push(pxlpoint);
                    mark[currentpx] = 1;
                    icount++;
                }

                while (stack.count())
                {
                    //pop
                    Point _pstack;
                    stack.Pop(_pstack);
                    Point _pLeft, _pRight, _pUp, _pDown;

                    /*----------------可修改为if  else if语句------------------------------------------------------------*/
                    _pLeft.x = _pstack.x;
                    _pLeft.y = _pstack.y> 0 ? _pstack.y -1  : _pstack.y;

                    _pRight.x = _pstack.x;
                    _pRight.y = _pstack.y< iSample - 1 ? _pstack.y+ 1 : _pstack.y;

                    _pUp.x = _pstack.x > 0 ? _pstack.x - 1 : _pstack.x;
                    _pUp.y = _pstack.y;

                    _pDown.x = _pstack.x < iLine - 1 ? _pstack.x + 1 : _pstack.x;
                    _pDown.y = _pstack.y;

                    _pLeft.val =_pstack.y > 0 ? Matrix[_pstack.x][_pstack.y - 1] : OUTRANGE;                    //上下左右四邻域
                    _pRight.val = _pstack.y < iSample - 1 ? Matrix[_pstack.x][_pstack.y + 1] : OUTRANGE;
                    _pUp.val = _pstack.x > 0 ? Matrix[_pstack.x - 1][_pstack.y] : OUTRANGE;
                    _pDown.val =_pstack.x < iLine - 1 ? Matrix[_pstack.x + 1][_pstack.y] : OUTRANGE;
                    /*---------------------------------------------------------------------------------------------------------*/
                    //检查pop周围4邻域像元，若存在1且未标记，push，并标记

                    int MarkLeft = mark[_pLeft.x*iSample + _pLeft.y];
                    int MarkRight = mark[_pRight.x*iSample + _pRight.y];
                    int MarkUp = mark[_pUp.x*iSample + _pUp.y];
                    int MarkDown = mark[_pDown.x*iSample + _pDown.y];

                    if (_pLeft.val&&!MarkLeft){
                        stack.Push(_pLeft);
                        mark[_pLeft.x*iSample +_pLeft.y] = 1;
                    }
                    if (_pUp.val&&!MarkUp){
                        stack.Push(_pUp);
                        mark[_pUp.x*iSample + _pUp.y ] = 1;
                    }
                    if (_pRight.val&&!MarkRight) {
                        stack.Push(_pRight);
                        mark[_pRight.x *iSample + _pRight.y] = 1;
                    }
                    if (_pDown.val&&!MarkDown) {
                        stack.Push(_pDown);
                        mark[_pDown.x*iSample + _pDown.y] = 1;
                    }

                }//while(stack.count())
            }//for
        }//for
        cout << icount << endl;
    }//while(ceshi--)
    return 0;
}