BZOJ5120 [2017国家集训队测试]无限之环

题面

题意

给出一个网格图，每个格子内可能有一个水管，水管有15种形状，也就是说它向每个方向都有可能有分支，请问至少旋转（顺时针或逆时针90度）几个非直线型的水管，使没有水管漏水，即每个水管的每个分支都与其他的某个分支相连。

做法

算法是费用流，难点在于建图：
因为要求每个分支都与其他某个分支相连，因此就要使它满流，不难想到根据每个点横纵坐标和的奇偶性将它与源点或汇点相连，然后将每个点拆为5个：上下左右中。中与源点或汇点连，其他四个点分别代表四个不同的方向。中向该水管分支的方向对应的点连边，然后考虑旋转：
1.直线型，四个方向没有边和都有边的：无法旋转或旋转了也没用，不考虑。
2.只有1个分支：最容易理解，对于初始向上有分支的水管，由中向左右两边连费用为1的边，向下连费用为2的边。
2.直角型：对于初始分支向右上两个方向的水管，它向顺时针旋转90度后，方向为右下，可看作将原本向上的分支改为向下，因此可以由上向下连一条费用为1的边，同理，它逆时针旋转90度后，方向为左下，因此可以由右向左连一条费用为1的边，可以发现，旋转180度后也依然满足题意。
3.丁字型：与直角型相同，对于初始方向为上左右的水管，可以由上向下连费用为2的边，左右分别向下连费用为1的边。
然后根据最大流判断是否有解，最小费用即为最小旋转次数。

代码

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#define INF 0x3f3f3f3f
#define N 10010
#define M 5001000
using namespace std;

int m,n,first[N],bb=1,s,t,sum,dir[4][2]= {-1,0,0,1,1,0,0,-1},mf,ans,d[N],B[N],last[N],xd[4]={2,3,0,1};
bool in[N];
struct Bn
{
    int to,next,quan,cst;
} bn[M];
vector<int>sg;
queue<int>que;

inline void add(int u,int v,int w,int z)
{
    bb++;
    bn[bb].to=v;
    bn[bb].quan=w;
    bn[bb].cst=z;
    bn[bb].next=first[u];
    first[u]=bb;
}

inline void ad(int u,int v,int w,int z)
{
    add(u,v,w,z);
    add(v,u,0,-z);
}

inline int zh(int u,int v)
{
    return (u-1)*n+v;
}

inline bool bfs()
{
    int i,j,p,q,mn=INF;
    memset(d,0x3f,sizeof(d));
    d[s]=0;
    que.push(s);
    for(; !que.empty();)
    {
        q=que.front();
        que.pop();
        in[q]=0;
        for(p=first[q]; p!=-1; p=bn[p].next)
        {
            if(!bn[p].quan || d[bn[p].to]<=d[q]+bn[p].cst) continue;
            d[bn[p].to]=d[q]+bn[p].cst;
            B[bn[p].to]=p;
            last[bn[p].to]=q;
            if(!in[bn[p].to])
            {
                in[bn[p].to]=1;
                que.push(bn[p].to);
            }
        }
    }
    if(d[t]==INF) return 0;
    for(p=t; p!=s; p=last[p])
    {
        mn=min(mn,bn[B[p]].quan);
    }
    mf-=mn;
    ans+=mn*d[t];
    for(p=t; p!=s; p=last[p])
    {
        bn[B[p]].quan-=mn;
        bn[B[p]^1].quan+=mn;
    }
    return 1;
}

int main()
{
    memset(first,-1,sizeof(first));
    int i,j,k,tmp,p,q,o;
    cin>>m>>n;
    sum=m*n;
    s=0,t=5*sum+1;
    for(i=1; i<=m; i++)
    {
        for(j=1; j<=n; j++)
        {
            tmp=zh(i,j),q=0;
            sg.clear();
            scanf("%d",&p);
            for(k=0; k<4; k++) if(p&(1 << k)) sg.push_back(k+1),mf++,q++;
            if((i+j)&1)
            {
                ad(s,tmp,q,0);
                for(k=0; k<4; k++)
                {
                    p=i+dir[k][0];
                    q=j+dir[k][1];
                    if(!p||p>m||!q||q>n) continue;
                    ad(tmp+(k+1)*sum,zh(p,q)+(xd[k]+1)*sum,1,0);
                }
                for(k=0;k<sg.size();k++) ad(tmp,tmp+sg[k]*sum,1,0);
                if(sg.size()==1)
                {
                    for(k=1;k<=4;k++)
                    {
                        if(k==sg[0]) continue;
                        else if(xd[sg[0]-1]==k-1) ad(tmp,tmp+k*sum,1,2);
                        else ad(tmp,tmp+k*sum,1,1);
                    }
                }
                else if(sg.size()==2)
                {
                    if(xd[sg[0]-1]==sg[1]-1) continue;
                    for(k=0;k<2;k++)
                    {
                        ad(tmp+sg[k]*sum,tmp+(xd[sg[k]-1]+1)*sum,1,1);
                    }
                }
                else if(sg.size()==3)
                {
                    q=9;
                    for(k=0;k<3;k++) q-=sg[k];
                    for(k=0;k<4;k++)
                    {
                        if(k==q) continue;
                        else if(k==xd[q]) ad(tmp+(k+1)*sum,tmp+(q+1)*sum,1,2);
                        else ad(tmp+(k+1)*sum,tmp+(q+1)*sum,1,1);
                    }
                }
            }
            else
            {
                ad(tmp,t,q,0);
                for(k=0;k<sg.size();k++) ad(tmp+sg[k]*sum,tmp,1,0);
                if(sg.size()==1)
                {
                    for(k=1;k<=4;k++)
                    {
                        if(k==sg[0]) continue;
                        else if(xd[sg[0]-1]==k-1) ad(tmp+k*sum,tmp,1,2);
                        else ad(tmp+k*sum,tmp,1,1);
                    }
                }
                else if(sg.size()==2)
                {
                    if(xd[sg[0]-1]==sg[1]-1) continue;
                    for(k=0;k<2;k++)
                    {
                        ad(tmp+(xd[sg[k]-1]+1)*sum,tmp+sg[k]*sum,1,1);
                    }
                }
                else if(sg.size()==3)
                {
                    q=9;
                    for(k=0;k<3;k++) q-=sg[k];
                    for(k=0;k<4;k++)
                    {
                        if(k==q) continue;
                        else if(k==xd[q]) ad(tmp+(q+1)*sum,tmp+(k+1)*sum,1,2);
                        else ad(tmp+(q+1)*sum,tmp+(k+1)*sum,1,1);
                    }
                }
            }
        }
    }
    if(mf&1)
    {
        puts("-1");
        return 0;
    }
    mf/=2;
    for(; bfs(););
    if(mf) ans=-1;
    cout<<ans;
}