hdoj 3657 Game 【最小割】

题目：hdoj 3657 Game

分类：

题意：给出一个矩阵，里面有值，要求按规则取一定的数使得得分最大，规则如下：

1：规定一些格子必须要拿，得分为拿了的格子的值得和

2：拿相邻的格子的需减去所有2*（x | y）

分析：这是一个标准的求最小割的题目，做这个题目推荐先做一下hdoj 1659，讲解：点击打开链接

同样是格子类题目，限制为相邻的，那么我们可以按照格子类题目的一般建图方案，按照格子的行列和的奇偶性把图分成一个二分图。

现在要求一个最大的得分，我们可以转化为求最小割来做，建图之后至少要割去权值最小的边，使得从源点s到汇点t没有流量。

那么首先我们知道有一些格子是必须要拿的，那么我们建图的时候把流量设置为无穷大，然后让最小割割不掉就可以了。还有一个条件就是相邻的减去一定值，我们可以给相邻的建边容量为当前值。

建图方案：

设置一个超级源点S ，超级汇点 T

连接S到奇数一边，容量为当前格子值，如果为必拿点，则容量inf

连接T到偶数点，同样容量为当前值，若为必须拿的点，则容量inf

然后每个格子相邻点之间建边，容量为 2*（x | y）

然后求一次最小割，即最大流。然后：ans = 所有格子的和sum - 最小割

AC代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
#define Del(a,b) memset(a,b,sizeof(a))
const int N = 3500;
const int inf = 0x3f3f3f3f;
int n,m;
struct Node
{
    int from,to,cap,flow;
};
vector<int> v[N];
vector<Node> e;
int vis[N];  //构建层次图
int cur[N];
void add_Node(int from,int to,int cap)
{
    e.push_back((Node)
    {
        from,to,cap,0
    });
    e.push_back((Node)
    {
        to,from,0,0
    });
    int tmp=e.size();
    v[from].push_back(tmp-2);
    v[to].push_back(tmp-1);
}
bool bfs(int s,int t)
{
    Del(vis,-1);
    queue<int> q;
    q.push(s);
    vis[s] = 0;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        for(int i=0; i<v[x].size(); i++)
        {
            Node tmp = e[v[x][i]];
            if(vis[tmp.to]<0 && tmp.cap>tmp.flow)  //第二个条件保证
            {
                vis[tmp.to]=vis[x]+1;
                q.push(tmp.to);
            }
        }
    }
    if(vis[t]>0)
        return true;
    return false;
}
int dfs(int o,int f,int t)
{
    if(o==t || f==0)  //优化
        return f;
    int a = 0,ans=0;
    for(int &i=cur[o]; i<v[o].size(); i++) //注意前面 ’&‘,很重要的优化
    {
        Node &tmp = e[v[o][i]];
        if(vis[tmp.to]==(vis[o]+1) && (a = dfs(tmp.to,min(f,tmp.cap-tmp.flow),t))>0)
        {
            tmp.flow+=a;
            e[v[o][i]^1].flow-=a; //存图方式
            ans+=a;
            f-=a;
            if(f==0)  //注意优化
                break;
        }
    }
    return ans;  //优化
}

int dinci(int s,int t)
{
    int ans=0;
    while(bfs(s,t))
    {
        Del(cur,0);
        int tm=dfs(s,inf,t);
        ans+=tm;
    }
    return ans;
}
struct NNO
{
    int x,ok;
};
NNO mp[60][60];
int id(int i,int j)
{
    return (i-1)*m+j;
}
int main()
{
    int k;
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++){
                scanf("%d",&mp[i][j].x);
                mp[i][j].ok=0;
                sum+=mp[i][j].x;
            }
        }
        for(int i=0;i<k;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            mp[x][y].ok=1;
        }
        int s=0,t=m*n+1;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if((i+j)%2)
                {
                    if(mp[i][j].ok)
                        add_Node(s,id(i,j),inf);
                    else
                        add_Node(s,id(i,j),mp[i][j].x);
                    if(i>1)
                    {
                        int tmp = mp[i][j].x & mp[i-1][j].x;
                        add_Node(id(i,j),id(i-1,j),2*tmp);
                    }
                    if(j>1)
                    {
                        int tmp = mp[i][j].x & mp[i][j-1].x;
                        add_Node(id(i,j),id(i,j-1),2*tmp);
                    }
                    if(i<n)
                    {
                        int tmp = mp[i][j].x & mp[i+1][j].x;
                        add_Node(id(i,j),id(i+1,j),2*tmp);
                    }
                    if(j<m)
                    {
                        int tmp = mp[i][j].x & mp[i][j+1].x;
                        add_Node(id(i,j),id(i,j+1),2*tmp);
                    }
                }
                else
                {
                    if(mp[i][j].ok)
                        add_Node(id(i,j),t,inf);
                    else
                        add_Node(id(i,j),t,mp[i][j].x);
                }
            }
        }
        printf("%d\n",sum-dinci(s,t));
        for(int i=0;i<=t;i++)
            v[i].clear();
        e.clear();
    }
    return 0;
}