USACO-2.1.1- The Castle

题目链接

题目大意：
现在，有一座城堡，城堡里面有很多个房间。给定这个城堡的地图，让你求这个城堡有多少个房间，最大的房间面积是多大。然后，如果可以拆掉一堵墙，那么拆掉哪堵墙，可以使得最大的房间最大化。输出拆掉一堵墙后，可以得到的最大房间面积，以及这堵墙的位置。
输入：
第一行有两个数字，表示有Ｍ列，Ｎ行　
之后有Ｎ行，每行有Ｍ个数字，表示一个空间，值为0-15
其中１表示该房间西边有墙，２表示该房间北边有墙，４表示该房间东边有墙，８表示该房间南边有墙。如11表示这个房间的南，北，西三个方向都有墙。
解题思路
题目的数据规模很小，直接搜索就行了。
代码

/*
ID: xxx
LANG: C++
PROG: castle
*/
#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;

int const N = 55;

int col, row;
int castle[N][N];
int count, alargest_size, blargest_size;
bool vis[N][N];
int vis_count;

void search(int posi, int posj, int &size)
{
        if( posi == 0 || posj == 0 || posi > row || posj > col)
                return ;
        vis[posi][posj] = 1;
        ++size; --vis_count;
        int val = castle[posi][posj];
        //fout << posi << " " << posj << endl;
        if ( val == 15 )
                return ;
        if ( val < 8 && vis[posi + 1][posj] == 0)
        {
                search(posi + 1, posj, size);
        }
        val = val >= 8? val - 8 : val;

        if ( val < 4 && vis[posi][posj + 1] == 0)
        {
                search(posi, posj + 1, size);
        }
        val = val >= 4? val - 4 : val;

        if ( val < 2 && vis[posi - 1][posj] == 0)
        {
                search(posi - 1, posj, size);
        }
        val = val >= 2? val - 2 : val;

        if ( val < 1 && vis[posi][posj - 1] == 0)
        {
                search(posi, posj - 1, size);
        }
}

int main()
{
        ifstream fin("castle.in");
        ofstream fout("castle.out");

        memset(vis, 0, sizeof(vis));
        fin >> col >> row;
        for(int i = 1; i <= row; ++i)
        {
                for(int j = 1; j <= col; ++j)
                {
                        fin >> castle[i][j];
                }
        }

        count = 0;
        int size;
        vis_count = col * row;
        alargest_size = 0;
        while( vis_count > 0 )
        {
                for(int i = 1; i <= row; ++i)
                {
                        for(int j = 1; j <= col; ++j)
                        {
                                if(vis[i][j] == 0)
                                {
                                        size = 0;
                                        search(i, j, size);
                                        alargest_size = size > alargest_size ? size : alargest_size;
                                        count++;
                                }
                        }
                }
        }
        fout << count << endl << alargest_size << endl;

        vis_count = col * row;
        alargest_size = 0;
        int wx, wy;
        char mv;
        while( vis_count > 0 )
        {
                for(int j = 1; j <= col; ++j)
                {
                        for(int i = row; i > 0; --i)
                        {
                                int val = castle[i][j];
                                val = val >= 8 ? val - 8 : val;
                                val = val >= 4 ? val - 4 : val;
                                if(val >= 2)
                                {
                                        castle[i][j] -= 2;
                                        memset(vis, 0, sizeof(vis));
                                        size = 0;
                                        search(i, j, size);
                                        if( size > alargest_size )
                                        {
                                                alargest_size = size;
                                                wx = i;
                                                wy = j;
                                                mv = 'N';
                                        }
                                        castle[i][j] += 2;
                                }

                                val = castle[i][j];
                                val = val >= 8? val - 8 : val;
                                if(val >= 4)
                                {
                                        castle[i][j] -= 4;
                                        memset(vis, 0, sizeof(vis));
                                        size = 0;
                                        search(i, j, size);
                                        if( size > alargest_size )
                                        {
                                                alargest_size = size;
                                                wx = i;
                                                wy = j;
                                                mv = 'E';
                                        }
                                        castle[i][j] += 4;
                                }


                        }
                }
        }
        fout << alargest_size << endl;
        fout << wx << ' ' << wy << ' ' << mv << endl;

        return 0;
}