POJ 2396 有上下界的可行流

题意：

有一个n*m的方阵，里面的数字未知，但是我们知道如下约束条件：

每一行的数字的和

每一列的数字的和

某些格子有特殊的大小约束，用大于号，小于号和等于号表示

问：是否存在用正数填充这个方阵的方案，满足所有的约束，若有，输出之，否则输出IMPOSSIBLE。

 

题解：

参考的别人（darksword）的。

总结一下建图，忘了的时候还可以回顾~

 

求解一个有上下界的网络流的步骤：

1.首先进行构图，对于那么对流量没有限制的边，我们直接将容量赋值为原始的容量，而对于有流量要求的边，我们将容量减去下界并将其等价与无下界的边。最后就是添加一个附
加汇点和一个附加源点，从附加源点连向每个顶点的容量为以该点所有流入的下界流量总和，每个顶点流向附加汇点是该点流出的下界流量总和。

2.我们要添加一条从汇点到源点流量为INF的边，这条边的意义在于，能够使得源点会汇点满足成为流量平衡条件的普通节点。

（以下为有上下界的最小流求解步骤）
3.我们在以附加源点和附加汇点求一次最大流，如果所有的到附加汇点的边都满载，那么说明这个网络是存在满足所有下界的可行流的。因为去除了下界容量的图具备这个能力。但
　是此时的可行流（从汇点流向源点的流量）并不一定是最小流，因为满足情况的可行流是不唯一的。

4.紧接着，我们在原图上从汇点向源点求一次最大流（此时要删除掉那条从汇点到源点的INF的边），此时便是一个缩流的过程，旨在试探图中是否还存在流量去替代汇点到源点的流量。这里计算出来的结果可能比我们已得到的可行流还要大，意思是说从汇点到源点有的是空间，因此也就不必连接那条INF的边了，整个网络的流量可以为0，网络中存在环流。

 

由于这里免不了会进行删边的操作，因此我们直接找到那条边，把流量赋值为0就可以了。

 

求解有上下界的最小流还有一种二分从汇点到原点的边的容量的方法~

 

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cstdlib>

#define N 400
#define INF 1000000000

using namespace std;

int cap[N][N],up[N][N],down[N][N],flow[N][N],in[N],out[N];
int q[N*100],layer[N];
int n,m,T,S,TT,SS,sum,cas;

inline void read()
{
    memset(down,0,sizeof down);
    memset(flow,0,sizeof flow);
    memset(cap,0,sizeof cap);
    memset(in,0,sizeof in);
    memset(out,0,sizeof out);
    memset(up,0,sizeof up);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            up[i][j+n]=INF;
    S=0; T=n+m+1;
    for(int i=1,a;i<=n;i++)
    {
        scanf("%d",&a);
        up[S][i]=down[S][i]=a;
    }
    for(int i=1,a;i<=m;i++)
    {
        scanf("%d",&a);
        up[i+n][T]=down[i+n][T]=a;
    }
    int qu; char str[4]; scanf("%d",&qu);
    for(int i=1,a,b,c;i<=qu;i++)
    {
        scanf("%d%d%s%d",&a,&b,str,&c);
        if(a==0&&b==0)
        {
            if(str[0]=='=')
            { 
                for(int j=1;j<=n;j++)
                    for(int k=1;k<=m;k++)
                    {
                        down[j][k+n]=c;
                        up[j][k+n]=c;
                    }
            }
            else if(str[0]=='>')
            {
                for(int j=1;j<=n;j++)
                    for(int k=1;k<=m;k++)
                        down[j][k+n]=max(c+1,down[j][k+n]);
            }
            else
            {
                for(int j=1;j<=n;j++)
                    for(int k=1;k<=m;k++)
                        up[j][k+n]=min(c-1,up[j][k+n]);
            }
        }
        else if(a==0&&b!=0)
        {
            if(str[0]=='=')
            {
                for(int j=1;j<=n;j++)
                {
                    down[j][b+n]=c;
                    up[j][b+n]=c;
                }
            }
            else if(str[0]=='>')
            {
                for(int j=1;j<=n;j++)
                    down[j][b+n]=max(c+1,down[j][b+n]);
            }
            else
            {
                for(int j=1;j<=n;j++)
                    up[j][b+n]=min(c-1,up[j][b+n]);
            }
        }
        else if(b==0&&a!=0)
        {
            if(str[0]=='=')
            {
                for(int j=1;j<=m;j++)
                {
                    down[a][j+n]=c;
                    up[a][j+n]=c;
                }
            }
            else if(str[0]=='>')
            {
                for(int j=1;j<=m;j++)
                    down[a][j+n]=max(c+1,down[a][j+n]);
            }
            else
            {
                for(int j=1;j<=m;j++)
                    up[a][j+n]=min(c-1,up[a][j+n]);
            }
        }
        else if(a!=0&&b!=0)
        {
            if(str[0]=='=')
            {
                down[a][b+n]=c;
                up[a][b+n]=c;
            }
            else if(str[0]=='>') down[a][b+n]=max(c+1,down[a][b+n]);
            else up[a][b+n]=min(c-1,up[a][b+n]);
        }
    }
}

inline bool bfs(int st,int ed)
{
    memset(layer,-1,sizeof layer);
    int h=1,t=2,sta;
    q[1]=st; layer[st]=0;
    while(h<t)
    {
        sta=q[h++];
        for(int i=0;i<=ed;i++)
            if(cap[sta][i]>0&&layer[i]<0)
            {
                layer[i]=layer[sta]+1;
                q[t++]=i;
            }
    }
    return layer[ed]!=-1;
}

inline int find(int u,int t,int cur_flow)
{
    if(u==t) return cur_flow;
    int res=0,tmp;
    for(int i=0;i<=t&&res<cur_flow;i++)
        if(cap[u][i]>0&&layer[i]==layer[u]+1)
        {
            tmp=find(i,t,min(cur_flow-res,cap[u][i]));
            cap[u][i]-=tmp; cap[i][u]+=tmp; 
            flow[u][i]+=tmp; flow[i][u]-=tmp;
            res+=tmp;
        }
    if(!res) layer[u]=-1;
    return res;
}

inline int dinic(int s,int t)
{
    int ans=0;
    while(bfs(s,t)) ans+=find(s,t,INF);
    return ans;
}

inline void go()
{
    sum=0;
    SS=T+1; TT=SS+1;
    for(int i=0;i<=T;i++)
        for(int j=0;j<=T;j++)
        {
            cap[i][j]=up[i][j]-down[i][j];
            in[j]+=down[i][j];
            out[i]+=down[i][j];
            sum+=down[i][j];
        }
    for(int i=0;i<=T;i++)
    {
        cap[SS][i]=in[i];
        cap[i][TT]=out[i];
    }
    cap[T][S]=INF;
    int ans=dinic(SS,TT);
    if(ans!=sum)
    {
        printf("IMPOSSIBLE\n");
        return;
    }
    cap[T][S]=cap[S][T]=0;
    ans=dinic(S,T);
    for(int i=1;i<=n;i++)
    {
        printf("%d",flow[i][1+n]+down[i][1+n]);
        for(int j=2;j<=m;j++)
            printf(" %d",flow[i][j+n]+down[i][j+n]);
        puts("");
    }
    puts("");
}

int main()
{
    scanf("%d",&cas);
    while(cas--) read(),go();
    return 0;
}