BZOJ1443: [JSOI2009]游戏Game

$n leq 100$,$m leq 100$的$n*m$地图，现进行一个博弈：后手先选个点放棋子，然后先后手轮流向上下左右某个方向移动棋子一步，不能移到障碍点，一个非障碍点不能走两次。问所有后手能赢的位置。

可以发现网格图是一个二分图，在移动时好像在二分图的两边反复横跳。可以在二分图这个模型上进行尝试，比如说，求最大匹配，看一下匹配点和非匹配点的情况。

从匹配点开始：（不如把放棋子那人叫B）

A如果走了一条匹配边，那B可以随意走一步，这一步一定是非匹配边，然后轮到A：1、如果A又走了一条匹配边，回到刚才情况；2、A没走匹配边，那情况就反转了，因为连走两条非匹配边一定会走到一个匹配点。等等蛤，B为啥一定可以随意走一步？陷入江局。。

从非匹配点开始：

A会走一条非匹配边到一个匹配点，然后B只要走最大匹配即可，因为A每一步都只能走非匹配边到另一个匹配点（如果不是匹配点，那他们走过的路就可以增广，不符合最大匹配）。这样A输定。

也就是说，只要选择不出现在某一个最大匹配的点，就一定赢。

直接一次最大匹配算法只能求一个最大匹配，没匹配的点一定是答案。但是，只要在最大匹配算法结束后，从S集的点沿着非匹配边-匹配边走到另外的S集点，这些“另外的点”也是答案，因为走过的路径相当于做了一次没损失没收益的增广，依然是最大匹配。同理，T集的点沿着非匹配边-匹配边走到的T集点也是答案。

我用的Dinic求最大匹配，所以就看S能到达哪些S集点以及哪些T集点能到T即可。

//#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
//#include<queue>
//#include<time.h>
//#include<complex>
#include<algorithm>
#include<stdlib.h>
using namespace std;

int n,m;
#define maxn 10011
#define maxm 100011

bool vis[111][111]; int col[maxn],id[111][111],tot;
int qx[maxn],qy[maxn],head,tail;
const int dx[]={0,0,1,-1},dy[]={1,-1,0,0};
bool mp[111][111]; char s[111];
void bfs(int sx,int sy)
{
    head=0; tail=1; qx[0]=sx; qy[0]=sy;
    col[id[sx][sy]]=1; vis[sx][sy]=1;
    while (head!=tail)
    {
        int nx=qx[head],ny=qy[head]; head++;
        for (int i=0;i<4;i++)
        {
            int xx=nx+dx[i],yy=ny+dy[i];
            if (xx<1 || xx>n || yy<1 || yy>m || !mp[xx][yy] || vis[xx][yy]) continue;
            vis[xx][yy]=1; col[id[xx][yy]]=-col[id[nx][ny]];
            qx[tail]=xx; qy[tail]=yy; tail++;
        }
    }
}

struct Edge{int from,to,cap,flow,next;};
struct Network
{
    Edge edge[maxm]; int first[maxn],le,n;
    Network() {le=2;}
    void in(int x,int y,int cap) {Edge &e=edge[le]; e.from=x; e.to=y; e.cap=cap; e.flow=0; e.next=first[x]; first[x]=le++;}
    void insert(int x,int y,int cap) {in(x,y,cap); in(y,x,0);}
    int dis[maxn],s,t,que[maxn],head,tail,cur[maxn];
    bool bfs()
    {
        for (int i=1;i<=n;i++) dis[i]=0x3f3f3f3f; dis[s]=0;
        head=0; tail=1; que[0]=s;
        while (head!=tail)
        {
            int now=que[head++];
            for (int i=first[now];i;i=edge[i].next)
            {
                Edge &e=edge[i];
                if (e.cap>e.flow && dis[e.to]==0x3f3f3f3f)
                {
                    dis[e.to]=dis[now]+1;
                    que[tail++]=e.to;
                }
            }
        }
        return dis[t]!=0x3f3f3f3f;
    }
    int dfs(int x,int a)
    {
        if (x==t || !a) return a;
        int flow=0,f;
        for (int &i=cur[x];i;i=edge[i].next)
        {
            Edge &e=edge[i];
            if (dis[e.to]==dis[x]+1 && (f=dfs(e.to,min(a,e.cap-e.flow)))>0)
            {
                flow+=f; e.flow+=f;
                edge[i^1].flow-=f; a-=f;
                if (!a) return flow;
            }
        }
        return flow;
    }
    int Dinic(int s,int t)
    {
        this->s=s; this->t=t;
        int ans=0;
        while (bfs())
        {
            for (int i=1;i<=n;i++) cur[i]=first[i];
            ans+=dfs(s,0x3f3f3f3f);
        }
        return ans;
    }
    bool vis[maxn],v2[maxn];
    void solve()
    {
        head=0; tail=1; que[0]=s;
        memset(v2,0,sizeof(v2)); v2[s]=1;
        while (head!=tail)
        {
            int now=que[head++]; if (col[now]==1) vis[now]=1;
            for (int i=first[now];i;i=edge[i].next)
            {
                Edge &e=edge[i]; if (v2[e.to] || e.to==t || e.cap<=e.flow) continue;
                que[tail++]=e.to,v2[e.to]=1;
            }
        }
        head=0; tail=1; que[0]=t;
        memset(v2,0,sizeof(v2)); v2[t]=1;
        while (head!=tail)
        {
            int now=que[head++]; if (col[now]==-1) vis[now]=1;
            for (int i=first[now];i;i=edge[i].next)
            {
                Edge &e=edge[i]; if (v2[e.to] || e.to==s) continue;
                if (e.cap==e.flow) que[tail++]=e.to,v2[e.to]=1;
            }
        }
    }
}g;

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++)
    {
        scanf("%s",s+1);
        for (int j=1;j<=m;j++) mp[i][j]=(s[j]=='.');
    }
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++) if (mp[i][j])
            id[i][j]=++tot;
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            if (mp[i][j] && !vis[i][j]) bfs(i,j);
    int s=tot+1,t=s+1; g.n=t;
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++) if (mp[i][j])
            for (int k=0;k<4;k+=2)
            {
                int xx=i+dx[k],yy=j+dy[k];
                if (xx<1 || xx>n || yy<1 || yy>m || mp[xx][yy]==0) continue;
                if (col[id[i][j]]==1) g.insert(id[i][j],id[xx][yy],1);
                else g.insert(id[xx][yy],id[i][j],1);
            }
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++) if (mp[i][j])
        {
            if (col[id[i][j]]==1) g.insert(s,id[i][j],1);
            else g.insert(id[i][j],t,1);
        }
    g.Dinic(s,t);
    g.solve();
    bool flag=0;
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            if (g.vis[id[i][j]])
            {
                if (!flag) {flag=1; puts("WIN");}
                printf("%d %d
",i,j);
            }
    if (!flag) puts("LOSE");
    return 0;
}