Mr.Panda and TubeMaster Gym - 101194J （二分染色有源汇上下界最大费用流）

Mr.Panda and TubeMaster

 Gym - 101194J 

题目链接就这样了，题面难得获得就算了。

题目大意：

给出一面方格纸，上面布满了方格，方格中能且只能如下图部署水管:

每两个方格之间连接具有一定的收益，问在满足所有的水管成环，且一些水管必须经过的前提下可以获得的最大收益是多少。

思路：

很容易感觉出来，这应该是一个费用流问题。但是显然得，解决起来并不简单。

首先，我们为方格进行染色，使得一些方格只能横向出纵向入，而他们相邻的方格只能纵向出横向入，这样就可以保证任意环内的流向是一致的，再接着对不是必须经过的点连上一条费用为0的边，这样就保证这些点必然可以经过，因为他们并不占用额外的流量，假如流量不等于方格的总数，则必然是那些必须经过的点没有被经过。最终跑一遍费用流即可

AC代码：

#include<cstring>
#include<queue>
#include<vector>
#include<iostream>
using namespace std;
const int maxn=2005;
const int INF=0x3f3f3f3f;
struct Edge{
	int from,to,cap,flow,cost;
	Edge(){}
	Edge(int from,int to,int cap,int flow,int cost):from(from),to(to),cap(cap),flow(flow),cost(cost){}
};
struct MCMF
{
    int n,m,s,t;
    vector<Edge> edges;
    vector<int> g[maxn];
    int inq[maxn];
    int d[maxn];
    int p[maxn];
    int a[maxn];

    void init(int n)
    {
        this->n =n;
        for(int i=0; i<n; i++)g[i].clear();
        edges.clear();
    }
    void AddEdge(int from,int to,int cap,int cost)
    {
        Edge e1= Edge(from,to,cap,0,cost), e2= Edge(to,from,0,0,-cost);
        edges.push_back(e1);
        edges.push_back(e2);
        m=edges.size();
        g[from].push_back(m-2);
        g[to].push_back(m-1);
    }
    bool spfa(int s,int t, int & flow,int & cost)
    {
        for(int i=0; i<=n; i++)
            d[i]=INF;
        memset(inq,0,sizeof(inq));
        d[s]=0;
        inq[s]=1;
        p[s]=0;
        a[s]=INF;
        queue<int>q;
        q.push(s);
        while(!q.empty())
        {
            int u=q.front();
            q.pop();
            inq[u]=0;
            for(int i=0; i<g[u].size(); i++)
            {
                Edge & e = edges[g[u][i]];
                if(e.cap>e.flow && d[e.to]>d[u]+e.cost)
                {
                    d[e.to]=d[u]+e.cost;
                    p[e.to]=g[u][i];
                    a[e.to]=min(a[u],e.cap-e.flow);
                    if(!inq[e.to])
                    {
                        q.push(e.to);
                        inq[e.to]=1;
                    }
                }
            }
        }
        if(d[t]==INF)
            return false;

        flow+=a[t];
        cost+=a[t]*d[t];
        for(int u=t; u!=s; u=edges[p[u]].from)
        {
            edges[p[u]].flow +=a[t];
            edges[p[u]^1].flow-=a[t];
        }
        return true;
    }

    pair<int,int>  Mincost(int s,int t)
    {
        int flow=0,cost =0;
        while(spfa(s,t,flow,cost));
        return pair<int,int>(cost,flow);
    }
};
int idl[35][35],idr[35][35];
int valr[35][35],valc[35][35];
int vis[35][35];
int main()
{
	int t;
	int kace=1;
	scanf("%d",&t);
	while(t--){
		memset(vis,0,sizeof(vis));
		int n,m;
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<m;j++)
			{
				scanf("%d",&valc[i][j]);
			}
		}
		for(int i=1;i<n;i++)
		{
			for(int j=1;j<=m;j++)
			{
				scanf("%d",&valr[i][j]);
			}
		}
		MCMF pro;
		int cnt=0;
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=m;j++)
			{
				idl[i][j]=++cnt;idr[i][j]=++cnt;
			}
		}
		pro.init(cnt+10);
		int ss=0,tt=cnt+1;
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=m;j++)
			{
				if((i+j)&1)
				{
					if(j+1<=m)  pro.AddEdge(idl[i][j],idr[i][j+1],1,-valc[i][j]);
					if(j-1>=1)  pro.AddEdge(idl[i][j],idr[i][j-1],1,-valc[i][j-1]);
				}
				else
				{
					if(i+1<=n)  pro.AddEdge(idl[i][j],idr[i+1][j],1,-valr[i][j]);
					if(i-1>=1)  pro.AddEdge(idl[i][j],idr[i-1][j],1,-valr[i-1][j]);
				}
			}
		}
		int k;
		scanf("%d",&k);
		while(k--)
		{
			int x,y;
			scanf("%d%d",&x,&y);
			vis[x][y]=1;
		}
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=m;j++)
			{
				pro.AddEdge(ss,idl[i][j],1,0);
				pro.AddEdge(idr[i][j],tt,1,0);
				if(!vis[i][j])
				 pro.AddEdge(idl[i][j],idr[i][j],1,0);
			}
		}
		printf("Case #%d: ",kace++);
		pair<int,int> ans=pro.Mincost(ss,tt);
		if(ans.second!=n*m) printf("Impossible\n");
		else printf("%d\n",-ans.first);
	}
}