hdu 3657 Game 最小割

题意：给n*m大小的方格，每个方格里有一个数，现在从这些方格里取数，若取走一个方格后有两个相邻的格子没有数就-2*(x&y)，取走一个数可以得到那个方格的数，先给定一些方格必须选，然后求最大分数。。

比如：

假设x1,x2,x3已被取走，现在的总分数为s。

那么取走8之后剩余的分数为：s+8-2*(8&x1)-2*(8&x2)-2*(8&x3)

思路：

其实这题我没有做出来。。看了别人的建图方式之后，突然有种恍然大悟的感触，但是仔细一想，不对。。我并不知道为什么这样的。我想知道是为什么。所以做了很多猜测和探索。。如果不对请指正。

建图方式：

建立超级源点s和超级汇点t。

横纵坐标之和为偶数的为X集合，横纵坐标为奇数的为Y集合。

s->x 权值为点权，如果这个点必须选，那么就是INF

x->y 权值为2*(x&y)

y->t 权值为点权，如果这个点必须选，那么就是INF

最小割模型的解释：

假设有一个点x1，与之相邻的点分别为x2,x3,x4

那么，如果x2,x3,x4已经被取走了，现在再取x1获得的分数为：

x1-2*(x1&x2)-2*(x1&x3)-2*(x1&x4) 

我希望取x1获得的分数>0，那么就必须要求

x1>2*(x1&x2)+2*(x1&x3)+2*(x1&x4)

也就是说，x1限制了其周围的点的取法。。

每一个点都限制其周围的点的取法。。 

根据这一点来建图，那么，与某一点x相邻的点都为另一个集合Y，与Y集合中的点相邻的点都属于集合X，

这样我们就可以建立两个集合了：其横纵坐标之和为奇数和偶数。

我们限制得到的结果为

x1>2*(x1&y2)+2*(x1&y3)+2*(x1&y4)

那么我们可以建图

s->x 边权为点权，表示限制这个点使得x1>2*(x1&y2)+2*(x1&y3)+2*(x1&y4)，当然如果x必须选那么就INF吧

y->t 边权为点权，表示限制这个点使得x1>2*(x1&y2)+2*(x1&y3)+2*(x1&y4)，当然如果y必须寻那么就INF吧

x->y 边权为2*(x&y)，表示取两个点的代价

我们再来看看这个模型。。

s->x->y->t

我们设这个模型的最小割为(S-T)割

1)若s->x属于(S-T)割

那么代表若是取这个数的话可能导致x1<=2*(x1&y2)+2*(x1&y3)+2*(x1&y4)，分数不变或减少，还不如不取x点。

2)若x->y属于(S-T)割

那么代表若是取这个数的话那么x和y都会被取，失去的分数为2*(x&y)，但是获得的分数可能>=0。

3)若y->t属于(S-T)割

那么代表若是取这个数的话可能导致同1)的结果一致，不取y点。

最小割的答案为 取数过程中的最小花费(2*(x&y) 或 x 或 y)

最后总的点权之和减去最小割就是最大的分数了。。

//author: CHC
//First Edit Time:	2014-11-17 11:22
//Last Edit Time:	2014-11-17 11:29
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <set>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <algorithm>
#include <limits>
using namespace std;
typedef long long LL;
const int MAXN=1e+4;
const int MAXM=1e+5;
const int INF= numeric_limits<int>::max();
const LL LL_INF= numeric_limits<LL>::max();
struct Edge
{
    int from,to,ci,next;
    Edge(){}
    Edge(int _from,int _to,int _ci,int _next):from(_from),to(_to),ci(_ci),next(_next){}
}e[MAXM];
int head[MAXN],tot;
int dis[MAXN];
int top,sta[MAXN],cur[MAXN];
inline void init(){
    memset(head,-1,sizeof(head));
    tot=0;
}
inline void AddEdge(int u,int v,int ci0,int ci1=0){
    e[tot]=Edge(u,v,ci0,head[u]);
    head[u]=tot++;
    e[tot]=Edge(v,u,ci1,head[v]);
    head[v]=tot++;
}
inline bool bfs(int st,int et){
    memset(dis,0,sizeof(dis));
    dis[st]=1;
    queue <int> q;
    q.push(st);
    while(!q.empty()){
        int now=q.front();
        q.pop();
        for(int i=head[now];i!=-1;i=e[i].next){
            int next=e[i].to;
            if(e[i].ci&&!dis[next]){
                dis[next]=dis[now]+1;
                if(next==et)return true;
                q.push(next);
            }
        }
    }
    return false;
}
LL Dinic(int st,int et){
    LL ans=0;
    while(bfs(st,et)){
        //printf("here\n");
        top=0;
        memcpy(cur,head,sizeof(head));
        int u=st,i;
        while(1){
            if(u==et){
                int pos,minn=INF;
                //printf("top:%d\n",top);
                for(i=0;i<top;i++)
                {
                    if(minn>e[sta[i]].ci){
                        minn=e[sta[i]].ci;
                        pos=i;
                    }
                    //printf("%d --> %d\n",e[sta[i]].from,e[sta[i]].to);
                }
                for(i=0;i<top;i++){
                    e[sta[i]].ci-=minn;
                    e[sta[i]^1].ci+=minn;
                }
                top=pos;
                u=e[sta[top]].from;
                ans+=minn;
                //printf("minn:%d\n\n",minn);
            }
            for(i=cur[u];i!=-1;cur[u]=i=e[i].next)
                if(e[i].ci&&dis[u]+1==dis[e[i].to])break;
            if(cur[u]!=-1){
                sta[top++]=cur[u];
                u=e[cur[u]].to;
            }
            else {
                if(top==0)break;
                dis[u]=0;
                u=e[sta[--top]].from;
            }
        }
    }
    return ans;
}
int n,m,k;
int mapp[100][100];
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};
int main()
{
    while(~scanf("%d%d%d",&n,&m,&k)){
        init();
        int s=n*m+m+1;
        int t=s+1;
        LL sum=0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                scanf("%d",&mapp[i][j]);
                if((i+j)%2==0) AddEdge(s,i*m+j,mapp[i][j]);
                else AddEdge(i*m+j,t,mapp[i][j]);
                sum+=mapp[i][j];
            }
        }
        int x,y;
        while(k--){
            scanf("%d%d",&x,&y);
            if((x+y)%2==0)AddEdge(s,x*m+y,INF);
            else AddEdge(x*m+y,t,INF);
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if((i+j)%2==0){
                    for(int k=0;k<4;k++){
                        int tx=i+dx[k];
                        int ty=j+dy[k];
                        if(tx<1||tx>n||ty<1||ty>m)continue;
                        AddEdge(i*m+j,tx*m+ty,2*(mapp[i][j]&mapp[tx][ty]));
                    }
                }
            }
        }
        sum-=Dinic(s,t);
        printf("%I64d\n",sum);
    }
    return 0;
}