[TopCoder] SRM 578 DIV 2, Goose In Zoo, Solution

Problem Statement

     Crow Keith is looking at the goose cage in the zoo. The bottom of the cage is divided into a grid of square cells. There are some birds sitting on those cells (with at most one bird per cell). Some of them are geese and all the others are ducks. Keith wants to know which birds are geese. He knows the following facts about them:

• There is at least one goose in the cage.
• Each bird within Manhattan distance dist of any goose is also a goose.

You are given a vector <string> field and the int dist. The array field describes the bottom of the cage. Each character of each element of field describes one of the cells. The meaning of individual characters follows.

• The character ‘v’ represents a cell that contains a bird.
• The character ‘.’ represents an empty cell.

Return the number of possible sets of geese in the cage, modulo 1,000,000,007. Note that for some of the test cases there can be no possible sets of geese.

Definition

     Class: GooseInZooDivTwo Method: count Parameters: vector <string>, int Returns: int Method signature: int count(vector <string> field, int dist) (be sure your method is public)     

Notes

- The Manhattan distance between cells (a,b) and (c,d) is |a-c| + |b-d|, where || denotes absolute value. In words, the Manhattan distance is the smallest number of steps needed to get from one cell to the other, given that in each step you can move to a cell that shares a side with your current cell.

Constraints

- field will contain between 1 and 50 elements, inclusive. - Each element of field will contain between 1 and 50 characters, inclusive. - Each element of field will contain the same number of characters. - Each character of each element of field will be ‘v’ or ‘.’. - dist will be between 0 and 100, inclusive.

Examples

0)     

{"vvv"}

0

Returns: 7

There are seven possible sets of positions of geese: “ddg”, “dgd”, “dgg”, “gdd”, “gdg”, “ggd”, “ggg” (‘g’ are geese and ‘d’ are ducks). 1)     

{"."}

100

Returns: 0

The number of geese must be positive, but there are no birds in the cage. 2)     

{"vvv"}

1

Returns: 1

[Thoughts]

这道题非常有意思。刚拿到题的时候，第一个想法就是，这不是八皇后的变形吗？ DFS一通到底就好了。但是细细的品味之后，发现这个不是这么简单。这道题其实是图论中连通区域的变形。

在题目中已经说了，给定任意一个点，如果该节点是一只鹅，那么所有与该鹅在曼哈顿距离以内的节点都是鹅。换句话说，所有与该鹅在曼哈顿距离以内的，都是连通的，可以收缩成一个节点，因为他们的行为时一致的，要么都是鹅，要么都不是鹅。

到这里，题目就变形为，在一个二维数组里面，找出连通区域的个数。然后对连通区域数求排列（这里就是2的幂数）。

计算大数取余的时候，要考虑溢出，通过迭代法计算。
(a*b)%m=(a%m*b%m )%m;

[Code]

懒得自己写了，偷用Zhongwen的code。

1:  #define pb push_back  
2:  #define INF 100000000000  
3:  #define L(s) (int)((s).size())  
4:  #define FOR(i,a,b) for (int _n(b), i(a); i<=_n; i++)  
5:  #define rep(i,n) FOR(i,1,(n))  
6:  #define rept(i,n) FOR(i,0,(n)-1)  
7:  #define C(a) memset((a), 0, sizeof(a))  
8:  #define ll long long  
9:  #define VI vector<int>  
10:  #define ppb pop_back  
11:  #define mp make_pair  
12:  #define MOD 1000000007  
13:       struct Node {  
14:            int x;  
15:            int y;  
16:            Node(int a, int b) : x(a), y(b) { }  
17:       };  
18:       int toInt(string s){ istringstream sin(s); int t; sin>>t;return t;}  
19:       vector<Node> GooseInZooDivTwo::flood(vector<string> &field, vector<vector<bool> > &visit, int x, int y, int dist, int m, int n)  
20:       {  
21:            vector<Node> ret;  
22:            queue<Node> S;  
23:            visit[x][y] = true;  
24:            S.push(Node(x, y));  
25:            while (!S.empty())  
26:            {  
27:                 Node cur = S.front();  
28:                 ret.pb(S.front());  
29:                 S.pop();  
30:                 for (int i = max(0, cur.x-dist); i <= min(m-1, cur.x+dist); i++)  
31:                 {  
32:                      for (int j = max(0, cur.y-dist); j <= min(n-1, cur.y+dist); j++)  
33:                      {  
34:                           if (field[i][j] == 'v' && !visit[i][j] && (abs(i-cur.x)+abs(j-cur.y) <=dist))  
35:                           {  
36:                                S.push(Node(i, j));  
37:                                visit[i][j] = true;  
38:                           }  
39:                      }  
40:                 }  
41:            }  
42:            return ret;  
43:       }  
44:       int GooseInZooDivTwo::count(vector <string> field, int dist) {  
45:            int m = L(field);  
46:            if (!m) return 0;  
47:            int n = L(field[0]);  
48:            vector<vector<bool> > visit(m, vector<bool>(n, false));  
49:            vector<vector<Node> > ret;  
50:            rept(i, m)  
51:            {  
52:                 rept(j, n)  
53:                 {  
54:                      if (field[i][j] == 'v' && !visit[i][j])  
55:                      {  
56:                           ret.pb(flood(field, visit, i, j, dist, m, n));  
57:                      }  
58:                 }  
59:            }  
60:            if (!L(ret)) return 0;  
61:            long num=1;  
62:            for(int i =0; i< L(ret); i++) //要考虑排列溢出的情况 
63:            {  
64:                 num*=2;  
65:                 if(num> MOD)  
66:                 {  
67:                      num = num % MOD;  
68:                 }  
69:            }  
70:            return num-1;  
71:       }