BZOJ 1443 [JSOI2009]游戏Game

AC通道:http://www.lydsy.com/JudgeOnline/problem.php?id=1443

分析:对于这种棋子在棋盘上走来走去,只能走相邻的格子的问题,感觉还是挺好玩的...

　　然后好玩归好玩,可是有点不会做啊.

　　貌似棋盘上相邻格子这种不断移动的问题,都大概能扯到一点网络流吧.

　　咦,二分图?唔...在二分图上走来走去.最后不能走的人算输?...

　　吖,然后结论就是:求一个最大匹配,只要放在非匹配点上就可以啦...

　　为什么呢?

　　如果放在非匹配点,那么对手只能走到匹配点上去[不然就是走到非匹配点,然后增广了,就和最大匹配不符合了...]

　　但是对手走到了匹配点上,我就一定能沿着匹配边往后走.

　　然后就是对手走一条不是匹配边的边,但是他到达的点一定有一条连出去的匹配边,不然就是找到了一条增广路,与最大匹配不符.

　　好神奇啊!

　　但是我们发现可能的最大匹配不止一种.

　　而且对于每一种可能的最大匹配,所有不在最大匹配中的点都可以作为最优点.

　　所以统计方案还有技巧.

　　

　　求解方案步骤:

　　1.从s出发,找到所有能到达的,属于X集合的点.

　　能到达的这个部分包括:一是非匹配点(直接到达),二是经过一个非匹配点,然后走一条类似增广路所到达的匹配点(即可以将这条路上的匹配边和非匹配边翻转得到另一组解,而这条路的终点就是另一组解中的非匹配点)

　　2.从t出发,倒着找到所有能到达t的点[也就是沿着反向弧为0的边前进],属于Y集合的点

　　能到达t的部分包括:一是非匹配点(直接到达),二是一个匹配点,经过匹配边再到匹配边再到某个非匹配点然后到达t的过程[原理和上面的类似].

　　然后就比较好打了...不过似乎窝代码有点丑陋的样子= =...

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int maxn=10010;
const int INF=0x3f3f3f3f;

struct Node{
    int data,next,low;
}node[1000010];

#define www node[point].low
#define now node[point].data
#define then node[point].next

int n,m,cnt;
int s,t;
int que[maxn],dis[maxn];
int head[maxn],cur[maxn];
int tp[maxn],rx[maxn],ry[maxn];
int stack[maxn],top;
int id[110][110],Idex;
int x[4]={0,0,1,-1},y[4]={1,-1,0,0};
char ch[110][110];
bool vis[maxn];

struct Pot{
    int x,y;
}a[maxn];

bool cmp(const Pot &A,const Pot &B){
    if(A.x!=B.x) return A.x<B.x;
    return A.y<B.y;
}

inline void add(int u,int v,int w){
    node[cnt].data=v;node[cnt].next=head[u];node[cnt].low=w;head[u]=cnt++;
    node[cnt].data=u;node[cnt].next=head[v];node[cnt].low=0;head[v]=cnt++;
}

bool BFS(){
    memset(dis,-1,sizeof(dis));
    
    int H=0,T=1,k;que[1]=s;dis[s]=0;
    
    while(H<T){
        k=que[++H];
        for(int point=head[k];point!=-1;point=then)
            if(www && dis[now]<0)
                dis[now]=dis[k]+1,que[++T]=now;
    }
    return dis[t]>0;
}

int dfs(int x,int low){
    if(x==t) return low;
    for(int &point=cur[x];point!=-1;point=then)
        if(www && dis[now]==dis[x]+1){
            int Low=dfs(now,min(www,low));
            if(Low){
                www-=Low,node[point^1].low+=Low;
                return Low;
            }
        }
    return 0;
}

void Build(){
    int nx,ny;
    
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
        if(ch[i][j]=='.'){
            id[i][j]=++Idex;
            rx[Idex]=i,ry[Idex]=j;
        }
    s=0;t=Idex+1;
    for(int i=s;i<=t;i++) head[i]=-1;
    
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    if(ch[i][j]=='.'){
        if((i^j)&1){
            add(s,id[i][j],1);
            tp[id[i][j]]=1;
            for(int k=0;k<4;k++){
                nx=i+x[k],ny=j+y[k];
                if(nx>n || nx<1 || ny<1 || ny>m || ch[nx][ny]=='#') continue;
                add(id[i][j],id[nx][ny],1);
            }
        }
        else
            add(id[i][j],t,1),tp[id[i][j]]=2;
    }
}

void Calcu(int x,int d){
    vis[x]=1;
    if(tp[x]==d) stack[++top]=x;
    for(int point=head[x];point!=-1;point=then)
    if(!vis[now] && www==(d!=2)) Calcu(now,d);
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("1443.in","r",stdin);
    freopen("1443.out","w",stdout);
#endif
    
    int flag,rec;
    
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%s",ch[i]+1);
    
    Build();
    rec=Idex;
    while(BFS()){
        memcpy(cur,head,sizeof(head));
        while(flag=dfs(s,INF)) Idex-=(flag<<1);
    }
    
    if(!Idex){
        puts("LOSE");
    }
    else{
        puts("WIN");
        
        Calcu(s,1);
        memset(vis,0,sizeof(vis));
        Calcu(t,2);
        
        for(int i=1;i<=top;i++){
            a[i].x=rx[stack[i]];
            a[i].y=ry[stack[i]];
        }
        sort(a+1,a+top+1,cmp);
        for(int i=1;i<=top;i++)
            printf("%d %d
",a[i].x,a[i].y);
    }
    return 0;
}