110102 MineSweeper

#include <iostream>
#include <stdlib.h>
#include <malloc.h>
#include <vector>

using namespace std;

typedef unsigned int Dim_t;

class MineMatrix
{
public:
    MineMatrix(Dim_t rows, Dim_t cols) : m_rows(rows + 2), m_cols(cols + 2), m_MineCnt(0)
    {
        m_pInfo = new int*[m_rows];
        for(Dim_t i = 0; i < m_rows; ++i)
        {
            m_pInfo[i] = (int*)calloc(m_cols, sizeof(int));
        }
    }

    ~MineMatrix()
    {
        for(Dim_t i = 0; i < m_rows; ++i)
        {
            free(m_pInfo[i]);
        }
        delete[] m_pInfo;
    }

    void Display()
    {
        Dim_t rowCnt = m_rows - 1, colCnt = m_cols - 1;
        for(Dim_t i = 1; i < rowCnt; ++i)
        {
            for(Dim_t j = 1; j < colCnt; ++j)
            {
                if (m_pInfo[i][j] < 0)
                    cout << "*";
                else
                    cout << m_pInfo[i][j];
            }
            cout << endl;
        }
    }

    void SetMine(Dim_t row, Dim_t col)
    {
        m_pInfo[row + 1][col + 1] = 0 - (m_rows * m_cols);
        ++m_MineCnt;
    }

    void Calculate()
    {
        if (m_MineCnt > (((m_rows/* - 2*/) * (m_cols/* - 2*/)) / 2))
            CalculateByNonMines();
        else
            CalculateByMines();
    }

private:
    int GetSurroundedMineCnt(Dim_t row, Dim_t col)
    {
        int sum = 0;
        for (Dim_t i = row - 1; i <= row + 1; ++i)
        {
            if (m_pInfo[i][col - 1] < 0)
                ++sum;
            if (m_pInfo[i][col + 1] < 0)
                ++sum;
        }
        if (m_pInfo[row - 1][col] < 0)
            ++sum;
        if (m_pInfo[row + 1][col] < 0)
            ++sum;

        return sum;
    }

    void CalculateByNonMines()
    {
        Dim_t rowCnt = m_rows - 1, colCnt = m_cols - 1;
        for(Dim_t i = 1; i < rowCnt; ++i)
        {
            for(Dim_t j = 1; j < colCnt; ++j)
            {
                if (m_pInfo[i][j] == 0)
                    m_pInfo[i][j] = GetSurroundedMineCnt(i, j);
            }
        }
    }

    void AddMines(Dim_t row, Dim_t col)
    {
        for (Dim_t i = row - 1; i <= row + 1; ++i)
        {
            ++m_pInfo[i][col - 1];
            ++m_pInfo[i][col + 1];
        }
        ++m_pInfo[row - 1][col];
        ++m_pInfo[row + 1][col];
    }

    void CalculateByMines()
    {
        Dim_t rowCnt = m_rows - 1, colCnt = m_cols - 1;
        for(Dim_t i = 1; i < rowCnt; ++i)
        {
            for(Dim_t j = 1; j < colCnt; ++j)
            {
                if (m_pInfo[i][j] < 0)
                    AddMines(i, j);
            }
        }
    }

private:
    int** m_pInfo;
    Dim_t m_rows;
    Dim_t m_cols;
    Dim_t m_MineCnt;
};

void Input(vector<MineMatrix*>& mineMatrixVec)
{
    Dim_t rows, cols;

    while(true)
    {
        cin >> rows >> cols;
        if ((rows * cols) == 0)
            return;

        MineMatrix* pMineMatrix = new MineMatrix(rows, cols);
        char* pLine = new char[cols + 2];

        for(Dim_t i = 0; i < rows; ++i)
        {
            cin >> pLine;
            for(Dim_t j = 0; j < cols; ++j)
            {
                if (pLine[j] == '*')
                    pMineMatrix->SetMine(i, j);
            }
        }

        mineMatrixVec.push_back(pMineMatrix);
        delete[] pLine;
    }
}

void Calc(vector<MineMatrix*>& mineMatrixVec)
{
    for(size_t i = 0; i < mineMatrixVec.size(); ++i)
    {
        mineMatrixVec[i]->Calculate();
    }
}

void Display(vector<MineMatrix*>& mineMatrixVec)
{
    size_t cnt = mineMatrixVec.size();
    for(size_t i = 0; i < cnt; ++i)
    {
        cout << "Field #" << (i + 1) << ':' << endl;
        mineMatrixVec[i]->Display();
        if (i < (cnt - 1))
            cout << endl;
    }
}

void Clean(vector<MineMatrix*>& mineMatrixVec)
{
    for(size_t i = 0; i < mineMatrixVec.size(); ++i)
    {
        delete mineMatrixVec[i];
    }
}

int main(int argc, char* argv[])
{
    vector<MineMatrix*> mineMatrixVec;
    Input(mineMatrixVec);
    Calc(mineMatrixVec);
    Display(mineMatrixVec);
    Clean(mineMatrixVec);
    return 0;
}