TYVJ 2009「Poetize8」Lagoon

描述

忘川沧月的小水塘的水面是一片由以下两种图形组成的图案：


 <图lagoon-1>

这两种图形都由一个边长为2的正方形和两个半径为1的1/4圆组成，圆心在正方形的两个对角顶点上。

小水塘左上角坐标为(0,0)，右下角坐标为(2*n,2*m)。水面上每一个顶点坐标为偶数的2*2正方形，都是上面两个图形中的一种。如果我们往水塘中的某个位置倒一桶污水，那么这桶污水会像画图中的油漆桶一样扩散开来，占据一片连续的区域，但是在线条边界处会停止扩散。注意如果倒在了线条上，扩散面积为0。

如下图所示，就是一个由4行4列上述图形组成的、左上角坐标(0,0)、右下角坐标(8,8)、某些位置倒了污水的水塘（白色部分为线条边界，线条实际宽度认为是0，为了明显、美观，此处加粗显示）：


 <图lagoon-2>

现在给出一个n行m列的由上述两种图形组成的水塘，起初水塘中全部为净水。给定q个往某个坐标上(x,y)倾倒污水的操作，对于每次操作，请求出在(x,y)上倾倒的污水最终会扩散多大的面积。

输入格式

第一行两个整数n、m。

接下来n行每行m个整数，每个整数是0或者1，中间没有空格隔开。0代表此处是<图lagoon-1>中左侧那个2*2的图形，1代表此处是右侧那个图形。例如<图lagoon-2>中的第一行用“0001”表示。

第n+2行是一个整数q。

接下来q行每行两个用空格隔开的整数x、y，表示这一次倾倒污水的坐标。

输出格式

对于每个询问，输出此次倾倒的污水最终扩散的面积，四舍五入保留4位小数。

测试样例1

输入

样例输入1

1 2

01

4

0 0

2 0

0 1

0 2

样例输入2

3 1

1

0

1

2

3 1

4 2

输出

样例输出1

0.7854

4.8584

0.0000

4.8584

样例输出2

7.2876

1.5708

备注

对于 100% 的数据，1<=n,m,q<=100，0<=x<=2*n，0<=y<=2*m。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
BFS遍历一遍，要用数组记录可能的情况。
思路说起来很简单，但是情况好多写起来好麻烦的。
我的写了180行······丑到不能看······写完的时候才想起来可以用数组记录······好方······
（下面是神犇GZZ的代码）

#include <cstdio>
#include <cmath>
#include <queue>
#include <cstring>
#include <vector>
using std::queue;
using std::vector;

const int maxnm=100+5;
int map[maxnm][maxnm];

struct Size {
int x; //1*1正方形个数
int y; //1/4圆个数
Size(int x, int y): x(x), y(y) {}
inline Size operator +(const Size &b) const
{
Size r(x+b.x, y+b.y);
return r;
}
inline double get()
{
#ifdef TEST
printf("{%d, %d}.get()!\n", x, y);
#endif
const double pi=acos(-1.0);
return x*1.0+y*pi*0.25;
}
};

Size dw[3]={Size(0, 1), Size(4, -2), Size(0, 1)};
bool vis[maxnm][maxnm][3]; //某地砖某位置是否被vis了...QAQ
struct Pos {
int x, y; //所在地砖坐标
int t; //所在位置类型
Pos(int x, int y, int t): x(x), y(y), t(t) { }
};

int pace[4][2]={{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
int turn[2][4][2][3]={
{//0->...
//0
{{1, 2, -1}, {0, 1, -1}},
//1
{{1, 2, -1}, {2, 1, -1}},
//2
{{-1, 0, 1}, {-1, 1, 2}},
//3
{{-1, 0, 1}, {-1, 1, 0}}
},
{//1->...
//0
{{-1, 1, 2}, {-1, 0, 1}},
//1
{{2, 1, -1}, {1, 2, -1}},
//2
{{0, 1, -1}, {1, 2, -1}},
//3
{{-1, 1, 0}, {-1, 0, 1}}
}
};
int have[2][4]= {
{0, 1, 1, 2},
{1, 2, 0, 1}
};

int n, m;

inline Size bfs(const vector<Pos> &st)
{
memset(vis, 0, sizeof(vis));
Size ans(0, 0);
queue<Pos> q;
for(int i=0; i<(signed int)st.size(); ++i)
{
if(st[i].x<1 || st[i].x>n || st[i].y<1 || st[i].y>m) continue;
q.push(st[i]);
vis[st[i].x][st[i].y][st[i].t]=true;
ans=ans+dw[st[i].t];
}
while(!q.empty())
{
Pos p=q.front(); q.pop();
#ifdef TEST
printf("getting in (%d, %d) type %d!\n", p.x, p.y, p.t);
#endif
for(int k=0; k<4; ++k)
{
int x1=p.x+pace[k][0], y1=p.y+pace[k][1];
if(x1<1 || x1>n || y1<1 || y1>m) continue;
int tu=turn[map[p.x][p.y]][k][map[x1][y1]][p.t];
if(tu==-1 || vis[x1][y1][tu]) continue;
ans=ans+dw[tu];
vis[x1][y1][tu]=true;
q.push(Pos(x1, y1, tu));
}
}
return ans;
}

char t_str[maxnm];

int main()
{
//freopen("flooding.in", "r", stdin);
//freopen("flooding.out", "w", stdout);
scanf("%d%d", &n, &m);
for(int i=1; i<=n; ++i)
{
scanf("%s", t_str+1);
for(int j=1; j<=m; ++j) map[i][j]=t_str[j]-'0';
}
int q; scanf("%d", &q);
while(q--)
{
int x, y; scanf("%d%d", &x, &y);
vector<Pos> v;
if((x&1) && (y&1))
{
v.push_back(Pos((x>>1)+1, (y>>1)+1, 1));
}
else if((x&1) || (y&1))
{
puts("0.0000");
continue;
}
else
{
v.push_back(Pos(x>>1, y>>1, have[map[x>>1][y>>1]][3]));
v.push_back(Pos(x>>1, (y>>1)+1, have[map[x>>1][(y>>1)+1]][2]));
v.push_back(Pos((x>>1)+1, y>>1, have[map[(x>>1)+1][y>>1]][1]));
v.push_back(Pos((x>>1)+1, (y>>1)+1, have[map[(x>>1)+1][(y>>1)+1]][0]));
}
printf("%.4f\n", bfs(v).get());
}
return 0;
}