## Sunday, May 12, 2013

### 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 , int Returns: int Method signature: int count(vector 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]

(a*b)%m=(a%m*b%m )%m;

[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:       }
``````