USACO The Castle

首先看一下题目。

The Castle
IOI'94 - Day 1

In a stroke of luck almost beyond imagination, Farmer John was sent a ticket to the Irish Sweepstakes (really a lottery) for his birthday. This ticket turned out to have only the winning number for the lottery! Farmer John won a fabulous castle in the Irish countryside.

Bragging rights being what they are in Wisconsin, Farmer John wished to tell his cows all about the castle. He wanted to know how many rooms it has and how big the largest room was. In fact, he wants to take out a single wall to make an even bigger room.

Your task is to help Farmer John know the exact room count and sizes.

The castle floorplan is divided into M (wide) by N (1 <=M,N<=50) square modules. Each such module can have between zero and four walls. Castles always have walls on their "outer edges" to keep out the wind and rain.

Consider this annotated floorplan of a castle:

     1   2   3   4   5   6   7
   #############################
 1 #   |   #   |   #   |   |   #
   #####---#####---#---#####---#
 2 #   #   |   #   #   #   #   #
   #---#####---#####---#####---#
 3 #   |   |   #   #   #   #   #
   #---#########---#####---#---#
 4 # ->#   |   |   |   |   #   #
   ############################# 

#  = Wall     -,|  = No wall
-> = Points to the wall to remove to
     make the largest possible new room

By way of example, this castle sits on a 7 x 4 base. A "room" includes any set of connected "squares" in the floor plan. This floorplan contains five rooms (whose sizes are 9, 7, 3, 1, and 8 in no particular order).

Removing the wall marked by the arrow merges a pair of rooms to make the largest possible room that can be made by removing a single wall.

The castle always has at least two rooms and always has a wall that can be removed.

PROGRAM NAME: castle

INPUT FORMAT

The map is stored in the form of numbers, one number for each module, M numbers on each of N lines to describe the floorplan. The input order corresponds to the numbering in the example diagram above.

Each module number tells how many of the four walls exist and is the sum of up to four integers:

• 1: wall to the west
• 2: wall to the north
• 4: wall to the east
• 8: wall to the south

Inner walls are defined twice; a wall to the south in module 1,1 is also indicated as a wall to the north in module 2,1.

Line 1:	Two space-separated integers: M and N
Line 2..:	M x N integers, several per line.

SAMPLE INPUT (file castle.in)

7 4
11 6 11 6 3 10 6
7 9 6 13 5 15 5
1 10 12 7 13 7 5
13 11 10 8 10 12 13

OUTPUT FORMAT

The output contains several lines:

Line 1:	The number of rooms the castle has.
Line 2:	The size of the largest room
Line 3:	The size of the largest room creatable by removing one wall
Line 4:	The single wall to remove to make the largest room possible

Choose the optimal wall to remove from the set of optimal walls by choosing the module farthest to the west (and then, if still tied, farthest to the south). If still tied, choose 'N' before 'E'. Name that wall by naming the module that borders it on either the west or south, along with a direction of N or E giving the location of the wall with respect to the module.

SAMPLE OUTPUT (file castle.out)

5
9
16
4 1 E
这其中我们可以看出来可以分成两部分求解，第一部分先求解城堡的房间数目和最大的房间的大小。
首先我们可以看出可以用图来解决的。这里我一开始是把每个房间当成一个点，每个墙当成一条边，后来发现并没有用到点，于是就删掉了。
这里的边就是我代码里面的wall，wall是一个三维数组，前两位是表示坐标，第三位是表示方向。可以看出来0w,1n,2e,3s（第0号元素表示west方向，诸如此类）。
这里的顺序是算出来的。具体是这样的，第一次%2得到的值是用来判断是否是2的倍数，如果是2的倍数，则表示不含有1，
同理，在temp除以2之后，temp%2的值就表示是否是4的倍数，如果是4的倍数，则不含2……同理推下去。
此时把wall[i][j][4]赋值为0，为的是之后给这个变量赋值颜色。
此时我们对所有的元素遍历，进行flood_fill。
至此前两问就解决了。

至于问合并后的房间大小，这个也很好解决。由于考虑到优先级的问题，所以这里遍历的顺序需要注意一下，另外只需要看两个方向就好了。

我认为本题的主要难点在于对于x,y不要写反掉。
最后放一下代码。

 /**
 ID: njuwz151
 TASK: castle
 LANG: C++
 **/
 #include <bits/stdc++.h>

 #define MAXN 55

 using namespace std;

 int wall[MAXN][MAXN][] = {};
 bool visit[MAXN][MAXN] = {false};
 int m, n;
 int color = ;
 int roomSize[MAXN * MAXN] = {};
 int dx[] = {, -, , };
 int dy[] = {-, , , };
 int max_after = -;
 int x_a;
 int y_a;
 char dir; 

 void flood_fill(int x, int y);

 void merge(int x, int y);

 int main() {
     freopen("castle.in", "r", stdin);
     freopen("castle.out", "w", stdout);

     cin >> m >> n;
     int t;
     for(int i = ; i < n; i++) {
         for(int j = ; j < m; j++) {
             cin >> t;
             /**
             1: wall to the west
             2: wall to the north
             4: wall to the east
             8: wall to the south
             */
             for(int k = ; k < ; k++) {
 //                cout << i << " " << j << " " << k << " " << t%2 << endl;
                 wall[i][j][k] = t%;
                 t /= ;
             }
             wall[i][j][] = ;
         }
     }

     for(int i = ; i < n; i++) {
         for(int j = ; j < m; j++) {
             if(!visit[i][j]) {
                 roomSize[color] = ;
                 flood_fill(i, j);
                 color++;
             }
         }
     }
     int max = ;
     for(int i = ; i < color; i++) {
         if(roomSize[i] > max) {
             max = roomSize[i];
         }
 //        cout << roomSize[i] << " ";
     }
     cout << color -  << endl;
     cout << max << endl;

     for(int i = ; i < m; i++) {
         for(int j = n-; j >= ; j--) {
             merge(j, i);
         }
     }
     cout << max_after << endl;
     cout << x_a+ << " " << y_a+ << " " << dir << endl;
 } 

 void flood_fill(int x, int y) {
     visit[x][y] = true;
     roomSize[color]++;
     wall[x][y][] = color;
     for(int i = ; i < ; i++) {
         int nx = x + dx[i];
         int ny = y + dy[i];
         if(nx <  || ny < ) {
             continue;
         }
         if(nx >= n || ny >= m) {
             continue;
         }
         if(visit[nx][ny]) {
             continue;
         }
         if(wall[x][y][i]) {
             continue;
         }
         flood_fill(nx, ny);
     }

 }

 void merge(int x, int y) {
     int sum;
     if(x -  >=  && wall[x][y][] != wall[x-][y][]) {
         sum = roomSize[wall[x][y][]] + roomSize[wall[x-][y][]];
         if(sum > max_after) {
             max_after = sum;
             x_a = x;
             y_a = y;
             dir = 'N';
         }
     }
     if(y +  < m && wall[x][y][] != wall[x][y+][]) {
         sum = roomSize[wall[x][y][]] + roomSize[wall[x][y+][]];
         if(sum > max_after) {
             max_after = sum;
             x_a = x;
             y_a = y;
             dir = 'E';
         }
     }
 }

castle