ural 1250. Sea Burial

1250. Sea Burial

Time limit: 1.0 second
Memory limit: 64 MB

There is Archipelago in the middle of a shoreless ocean. An ancient tribe of cannibals lives there. Shamans of this race have been communicating with gods and admonishing people for ages. They could generate a rain during a drought and clear the sky in a raining season. A long time ago the first shaman of the tribe jumped into one of the seas and drowned while being in a sacred trance. Since then all the land inside this sea is regarded as sacred. According to an ancient law, all shamans must be buried on a sacred land. However, souls of dead shamans cannot get on with each other, so each shaman must be buried on a separate island. An old prophecy says that if two shamans are buried on the same land, then a dreadful time will come and the tribe will perish.

How many shamans will the tribe outlive? This problem bothered all the chiefs of the tribe who were coming into power. So one of the chiefs ordered to compile a map of Archipelago. The cannibals toiled for a whole year and coped with the task. But the map was too large and complicated to count all the sacred islands. So the tribe's shaman appealed to gods and asked them to help with counting the islands. And the tribe was blessed with a Programmer and a Computer, which came down to earth in a cloud of light and fire. Yes, you are this Programmer, and you are destined to live with these cannibals until you have counted the islands; then you'll be transferred back home. Remember that there may be seas inside islands, and islands inside those seas.

Input

The first input line contains four integers W, H, X and Y, separated with one or several spaces. 1 ≤ W, H ≤ 500 are respectively the width and the height of the map. 1 ≤ X ≤ W and 1 ≤ Y ≤ Hare the coordinates of the point where the first shaman drowned. The next H lines contain description of the map. Each line contains W symbols describing correspondent fragments of the map. Symbol "." stands for a sea fragment and symbol "#" stands for a land fragment. Two fragments belong to the same sea if they are adjacent horizontally, vertically, or diagonally. Two fragments belong to the same island if they are adjacent horizontally or vertically (but not diagonally). Land fragments that are adjacent to the map's border are not considered as islands. Coordinates are counted from the left upper corner.

Output

The output should contain a single integer, which is the number of the islands inside the sacred sea.

Samples

input	output
9 7 1 1 ........# .#######. .#.....#. .#.#.#.#. .#.....#. .#######. #........	3
9 7 3 3 ........# .#######. .#.....#. .#.#.#.#. .#.....#. .#######. #........	2

Problem Author: Stanislav Skorb (prepared by Ivan Dashkevich)
Problem Source: Open collegiate programming contest for student teams, Ural State University, March 15, 2003

Tags: graph theory  (hide tags for unsolved problems)

Difficulty: 723

 

题意：给出一张海图，#代表陆地，.代表海洋。

八方向相连为同一片海域，四方向相连为同一个岛屿。与边界相连的岛屿不算。

给出一个点，问这个点所在海域包含了几个岛屿。

注意如果包含一个岛屿，那么这个岛屿的内海包含的岛屿也算。

 

分析：暴力搜索。注意处理即可。

可以先把掉落所在海域求出。

然后将不在海域之内的所有格子标记。

然后问题就变为求一张图内#连通块的个数。

 

 /**
 Create By yzx - stupidboy
 */
 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <cmath>
 #include <deque>
 #include <vector>
 #include <queue>
 #include <iostream>
 #include <algorithm>
 #include <map>
 #include <set>
 #include <ctime>
 #include <iomanip>
 using namespace std;
 typedef long long LL;
 typedef double DB;
 #define MIT (2147483647)
 #define INF (1000000001)
 #define MLL (1000000000000000001LL)
 #define sz(x) ((int) (x).size())
 #define clr(x, y) memset(x, y, sizeof(x))
 #define puf push_front
 #define pub push_back
 #define pof pop_front
 #define pob pop_back
 #define ft first
 #define sd second
 #define mk make_pair

 inline int Getint()
 {
     int Ret = ;
     char Ch = ' ';
     bool Flag = ;
     while(!(Ch >= '' && Ch <= ''))
     {
         if(Ch == '-') Flag ^= ;
         Ch = getchar();
     }
     while(Ch >= '' && Ch <= '')
     {
         Ret = Ret *  + Ch - '';
         Ch = getchar();
     }
     return Flag ? -Ret : Ret;
 }

 const int N = ;
 const int DX[] = {-, , , , -, -, , }, DY[] = {, -, , , -, , -, };
 #define Land 1
 #define Sea 2
 int n, m, sx, sy;
 int graph[N][N], mark[N][N];
 int ans;

 inline void Input()
 {
     scanf("%d%d%d%d", &n, &m, &sx, &sy);
     swap(sx, sy), swap(n, m);
     for(int i = ; i <= n; i++)
         for(int j = ; j <= m; j++)
         {
             char ch = ' ';
             while(ch != '.' && ch != '#') ch = getchar();
             graph[i][j] = ch == '.' ? Sea : Land;
         }
 }

 inline bool Check(int x, int y, int state)
 {
     if(x <  || x > n || y <  || y > m) return ;
     if(!(graph[x][y] & state) || mark[x][y]) return ;
     return ;
 }

 inline void Draw(int sx, int sy, int state, int tag)
 {
     static int que[N * N][], tail;
     mark[sx][sy] = tag;
     tail = , que[][] = sx, que[][] = sy;
     for(int head = ; head <= tail; head++)
     {
         int ux = que[head][], uy = que[head][];
         for(int t = ; t < ; t++)
         {
             if(t >  && graph[ux][uy] == Land) break;
             int vx = ux + DX[t], vy = uy + DY[t];
             if(!Check(vx, vy, state)) continue;
             mark[vx][vy] = tag, tail++;
             que[tail][] = vx, que[tail][] = vy;
         }
     }
 }

 inline void Solve()
 {
     if(graph[sx][sy] == '#')
     {
         puts("");
         return;
     }

     Draw(sx, sy, Sea, );
     for(int i = ; i <= n; i++)
     {
         Draw(i, , Land | Sea, );
         Draw(i, m + , Land | Sea, );
     }
     for(int i = ; i <= m; i++)
     {
         Draw(, i, Land | Sea, );
         Draw(n + , i, Land | Sea, );
     }

     for(int i = ; i <= n; i++)
         for(int j = ; j <= m; j++)
             if(!mark[i][j] && graph[i][j] == Land)
             {
                 ans++;
                 Draw(i, j, Land, );
             }

     printf("%d\n", ans);
 }

 int main()
 {
     freopen("a.in", "r", stdin);
     Input();
     Solve();
     return ;
 }