BZOJ1443: [JSOI2009]游戏Game

不妨先黑白染色，然后做二分图匹配，考虑出发点如果是非最大匹配必经点，那么无论第一个人怎么走都只能走非匹配边走到一个匹配点上（或不能走），另一个人走匹配边，那么先手必败，反之必胜
于是问题变成了哪些点是非最大匹配的必经点
先做一次最大匹配，那些没有被匹配到的点，一定是非必经点，然后从这些点开始增广，按照非匹配边，匹配边走交错路，和出发点在同一个点集里的，就是要找的非必经点，时间复杂度$O(n^2)$
考虑这样做的正确性，一个非必经点，要么他没有连边（就是那些没有被匹配到的点），要么他可以通过走一条交错路和某个点交换 是否匹配 ，那么如果他不在一开始的最大匹配里显然可以被找到，如果在，因为它是非必经点，那么一定存在上文说的“某个点”，是没有被匹配并且可以通过交错路找到他，于是他也可以被找到
那么这样找就不会遗漏任何一个非必经点（证明我也不知道我写的是什么…大家意会一下….）

没有判环还RE了几次…

UPD(2017.9.21)：被人hack了..尴尬…现在补好了..不过感觉代码好像还是有问题…

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;

const int maxn = 11000;
const int maxm = 210000;
const int maxr = 105;
const int maxc = 105;
const int dx[] = {-1,0,1,0};
const int dy[] = {0,1,0,-1};

int n,m;

struct edge
{
    int y,nex;
    edge(){}
    edge(const int _y,const int _nex){y=_y;nex=_nex;}
}a[maxm<<1]; int len,fir[maxn];
inline void ins(const int x,const int y){a[++len]=edge(y,fir[x]);fir[x]=len;}

int col[maxr][maxc],id[maxr][maxc],num;
int in[2],nowi[2][maxn];

bool v[maxn];
int match[2][maxn];
int t[maxn],tp;
bool find_(const int x)
{
    if(v[x]) return false;
    v[x]=true; t[++tp]=x;
    for(int k=fir[x];k;k=a[k].nex)
    {
        const int y=a[k].y;
        if(!match[1][y]||find_(match[1][y]))
        {
            match[1][y]=x;
            match[0][x]=y;
            return true;
        }
    }
    return false;
}
bool ans[maxn];
void dfs(const int x,const int ki)
{
    if(v[x]) return;
    ans[x]=true; v[x]=true;
    for(int k=fir[x];k;k=a[k].nex)
    {
        const int y=a[k].y;
        if(match[!ki][y]&&match[!ki][y]!=x) dfs(match[!ki][y],ki);
    }
}

int main()
{
    len=0; //
    memset(col,-1,sizeof col);

    scanf("%d%d",&n,&m);

    char str[maxr];
    for(int i=1;i<=n;i++)
    {
        scanf("%s",str+1);
        for(int j=1;j<=m;j++) 
            if(str[j]=='.') 
                col[i][j]=(i+j)&1,id[i][j]=++num,
                nowi[(i+j)&1][++in[(i+j)&1]]=num;
    }

    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++) if(col[i][j]!=-1)
        {
            for(int k=0;k<4;k++)
            {
                const int x=i+dx[k],y=j+dy[k];
                if(col[x][y]!=-1) ins(id[i][j],id[x][y]),ins(id[x][y],id[i][j]);
            }
        }
    }

    int ret=0;
    for(int i=1;i<=in[0];i++)
        if(!match[0][nowi[0][i]])
        {
            if(find_(nowi[0][i])) ret+=2;
            while(tp) v[t[tp--]]=false;
        }

    if(ret==in[0]+in[1]) puts("LOSE");
    else
    {
        puts("WIN");
        for(int ki=0;ki<2;ki++)
        {
            for(int i=1;i<=in[ki];i++) 
                if(!match[ki][nowi[ki][i]]) 
                    dfs(nowi[ki][i],ki);
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++) if(col[i][j]!=-1)
                if(ans[id[i][j]]) printf("%d %d\n",i,j);
        }
    }

    return 0;
}