BZOJ1443: [JSOI2009]游戏Game

1443: [JSOI2009]游戏Game

Time Limit: 10 Sec Memory Limit: 162 MB

Submit: 1334 Solved: 613

[Submit][Status][Discuss]

Description

Input

输入数据首先输入两个整数N,M，表示了迷宫的边长。 接下来N行，每行M个字符，描述了迷宫。

Output

若小AA能够赢得游戏，则输出一行"WIN"，然后输出所有可以赢得游戏的起始位置，按行优先顺序输出 每行一个,否则输出一行"LOSE"（不包含引号）。

Sample Input

3 3

.##

...

.

Sample Output

WIN

2 3

3 2

HINT

对于100%的数据，有1≤n,m≤100。 对于30%的数据，有1≤n,m≤5。

题解

黑白染色，可走的点连边，做最大匹配

发现如果先手放到非匹配点上，后手要么无路可走，失败，要么走到匹配点上；如果后手走到匹配点上，先手沿匹配点走，后手要么无路可走，要么走非匹配边，由于不存在增广路，后手走到的一定是一个匹配点。。。。一直这样走下去，发现走的是交替路，由于不存在增广路，交替路的结尾一定是匹配边，后手一定无路可走。此时先手必胜

必胜点即为所有最大匹配方案中的未匹配点

其他点均为必败点（相当于先手走必胜点后，后手不得不走的那个点，因此必败）

怎么求呢？

发现从未匹配点开始，走非匹配边、匹配边后，交换匹配边与非匹配边，匹配合法且最大匹配不变。即我们从每个非匹配点走交替路，然后所有匹配点连过来的点都是答案（即与起点同集合的点）

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <map>
#include <string>
#include <cmath>
#include <sstream>
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define abs(a) ((a) < 0 ? (-1 * (a)) : (a))
template<class T>
inline void swap(T &a, T &b)
{
T tmp = a;a = b;b = tmp;
}
inline void read(int &x)
{
x = 0;char ch = getchar(), c = ch;
while(ch < '0' || ch > '9') c = ch, ch = getchar();
while(ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
if(c == '-') x = -x;
}
const int INF = 0x3f3f3f3f;
const int MAXN = 100 + 10;
const int dx[4] = {0,0,1,-1};
const int dy[4] = {1,-1,0,0};
int n, m, hao[MAXN][MAXN], vis1[MAXN * MAXN], vis2[MAXN * MAXN], cnt1, cnt2, lk1[MAXN * MAXN], lk2[MAXN * MAXN], vis[MAXN * MAXN];
char s[MAXN][MAXN];
struct Edge
{
int u,v,nxt;
Edge(int _u, int _v, int _nxt){u = _u;v = _v;nxt = _nxt;}
Edge(){}
}edge[100000];
int head[MAXN * MAXN], cnt;
inline void insert(int a, int b)
{
edge[++cnt] = Edge(a,b,head[a]);
head[a] = cnt;
}
int dfs(int x)
{
for(int pos = head[x];pos;pos = edge[pos].nxt)
{
int i = edge[pos].v;
if(vis[i]) continue;
vis[i] = 1;
if(lk2[i] == -1 || dfs(lk2[i]))
{
lk2[i] = x, lk1[x] = i;
return 1;
}
}
return 0;
}
void dfs1(int x)
{
vis1[x] = 1;
for(int pos = head[x];pos;pos = edge[pos].nxt)
{
int i = edge[pos].v;
if(lk2[i] == -1 || vis1[lk2[i]]) continue;
dfs1(lk2[i]);
}
}
void dfs2(int x)
{
vis2[x] = 1;
for(int pos = head[x];pos;pos = edge[pos].nxt)
{
int i = edge[pos].v;
if(lk1[i] == -1 || vis2[lk1[i]]) continue;
dfs2(lk1[i]);
}
}
int main()
{
read(n), read(m);
for(int i = 1;i <= n;++ i)
scanf("%s", s[i] + 1);
for(int i = 1;i <= n;++ i)
for(int j = 1;j <= m;++ j)
if(s[i][j] == '#') continue;
else if((i + j & 1)) hao[i][j] = ++ cnt1;
else hao[i][j] = ++ cnt2;
//左奇右偶
for(int i = 1;i <= n;++ i)
for(int j = 1;j <= m;++ j)
if(s[i][j] == '.' && (i + j) & 1)
{
for(int k = 0;k < 4;++ k)
{
int x = i + dx[k], y = j + dy[k];
if(x <= 0 || x > n || y <= 0 || y > m || s[x][y] == '#') continue;
insert(hao[i][j], hao[x][y]);
}
}
memset(lk1, -1, sizeof(lk1));
memset(lk2, -1, sizeof(lk2));
for(int i = 1;i <= cnt1;++ i)
{
memset(vis, 0, sizeof(vis));
dfs(i);
}
for(int i = 1;i <= cnt1;++ i)
if(lk1[i] == -1) dfs1(i);
cnt = 0;memset(head, 0, sizeof(head));
for(int i = 1;i <= n;++ i)
for(int j = 1;j <= m;++ j)
if(s[i][j] == '.' && (i + j) & 1)
{
for(int k = 0;k < 4;++ k)
{
int x = i + dx[k], y = j + dy[k];
if(x <= 0 || x > n || y <= 0 || y > m || s[x][y] == '#') continue;
insert(hao[x][y], hao[i][j]);
}
}
for(int i = 1;i <= cnt2;++ i)
if(lk2[i] == -1) dfs2(i);
int flag = 0;
for(int i = 1;i <= n;++ i)
for(int j = 1;j <= m;++ j)
if(s[i][j] == '#') continue;
else if((i + j) & 1 && vis1[hao[i][j]])
{
if(!flag) printf("WIN\n"), flag = 1;
printf("%d %d\n", i, j);
}
else if(!((i + j) & 1) && vis2[hao[i][j]])
{
if(!flag) printf("WIN\n"), flag = 1;
printf("%d %d\n", i, j);
}
if(!flag) printf("LOSE");
return 0;
}