poj 2396(有上下界的 可行流)

Amber大牛的《图论原理》：

问题模型：

给定一个加权的有向图，满足：

(1)容量限制条件：

(2)流量平衡条件：

(2)中的即除了源汇外，所有点都满足流量平衡条件，则称G为有源汇网络；否则，即不存在源汇，所有点都满足流量平衡条件，则称G为无源汇网络。

将这类问题由易到难一一解决：

问题[1] 求无源汇的网络有上下界的可行流

由于下界是一条弧上的流必需要满足的确定值。下面引入必要弧的概念：必要弧是一定流要满的弧。必要弧的构造，将容量下界的限制分离开了，从而构造了一个没有下界的网络G’：

1． 将原弧(u,v)分离出一条必要弧：。（红色表示）

2． 原弧：。

由于必要弧的有一定要满的限制，将必要弧“拉”出来集中考虑：

添加附加源x, 附加汇y。想像一条不限上界的(y, x)，用必要弧将它们“串”起来，即对于有向必要弧(u, v)，添加(u, y)，(x, v)，容量为必要弧容量。这样就建立了一个等价的网络。

一个无源汇网络的可行流的方案一定是必要弧是满的。若去掉(y, x)后，附加源x到附加汇y的最大流，能使得x的出弧或者y的入弧都满，充要于原图有可行流。

算法：

1. 按上述方法构造新网络(分离必要弧，附加源汇)

2. 求附加源x到附加汇y的最大流

3. 若x的出弧或y的入弧都满，则有解，将必要弧合并回原图；否则，无解。

问题[2] 求有源汇的网络有上下界的可行流

加入边(t, s)，下界为0(保证不会连上附加源汇x, y)，不限上界，将问题[2]转化为问题[1]来求解。

问题[3]求有源汇的网络有上下界的最大流

算法：

1. 先转化为问题[2]来求解一个可行流。若可行无解，则退出。由于必要弧是分离出来的，所以就可以把必要弧（附加源汇及其临边）及其上的流，暂时删去。再将(T,S)删去，恢复源汇。

2. 再次，从S到T找增广轨，求最大流。

3. 最后将暂时删去的下界信息恢复，合并到当前图中。输出解。

这样既不破坏下界(分离出来)也不超出上界(第2步满足容量限制)，问题解决。

问题[4]求有源汇的网络有上下界的最小流

算法：

1. 同问题[3]。

2. 从T到S找增广轨，不断反着改进。

3. 同问题[3]。

问题[3]与问题[4]的另一种简易求法：

注意问题[2]中，构造出的(t, s)，上下界几乎没什么限制。下面看看它的性质：

定理：如果从s到t有一个流量为a的可行流f，那么从t到s连一条弧(t, s)，其流量下界b(t, s) = a，则这个图一定有一个无源汇的可行流：除了弧(t, s)的容量为a外，其余边的容量与f相同。

证明：如果从s到t的最大流量为amax，那么从t到s连一条下界b(t, s) = a’ > amax的弧(t, s)，则从在这个改造后的图中一定没有无源汇的可行流：否则将这个可行流中的弧(t, s)除去，就得到了原图中s到t的流量为a’的流，大于最大流量amax，产生矛盾。

可以二分枚举这个参数a，即下界b(t, s)，每次用问题[1]判断是否有可行流。这样就可以求出最大流。

同理，问题[4]要求最小流，只要二分枚举上界c(t, s)即可。

因为朴素的预流推进算法O(N3)，总复杂度为O(N3 log2流量) 。

思路：

无源汇 (附加源汇+最大解决)

有源汇 (附加(T,S)->无源汇)

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
using namespace std;
#define maxM 50000
#define maxN 500
#define inf 1<<30
struct NOde
{
    int u,v,f,next;
}edge[maxM];
int head[maxN],p,lev[maxN],cur[maxN];
int que[maxM];
int tre[maxN];//行、列的可行流
int up[maxN][50];//上界
int low[maxN][50];//下界
void init1(int n,int m)
{
    p=0,memset(head,-1,sizeof(head));
    memset(tre,0,sizeof(tre));
    for(int i=0;i<=n;i++)
      for(int j=0;j<=m;j++)
        up[i][j]=inf,low[i][j]=0;//初始化
}


bool bfs(int s,int t)
{
    int qin=0,qout=0,u,i,v;
    memset(lev,0,sizeof(lev));
    lev[s]=1,que[qin++]=s;
    while(qout!=qin){
        u=que[qout++];
        for(i=head[u];i!=-1;i=edge[i].next){
            if(edge[i].f>0 && lev[v=edge[i].v]==0){
                lev[v]=lev[u]+1,que[qin++]=v;
                if(v==t) return 1;
            }
        }
    }
    return lev[t];
}
int dinic(int s,int t)
{
    int qin,u,i,k,f;
    int flow=0;
    while(bfs(s,t))
    {
        memcpy(cur,head,sizeof(head));
        u=s,qin=0;
        while(1)
        {
            if(u==t)
            {
                for(k=0,f=inf;k<qin;k++)
                    if(edge[que[k]].f<f)
                        f=edge[que[i=k]].f;
                for(k=0;k<qin;k++)
                    edge[que[k]].f-=f,edge[que[k]^1].f+=f;
                flow+=f,u=edge[que[qin=i]].u;
            }
            for(i=cur[u];cur[u]!=-1;i=cur[u]=edge[cur[u]].next)
                if(edge[i].f>0 && lev[u]+1==lev[edge[i].v]) break;
            if(cur[u]!=-1)
                que[qin++]=cur[u],u=edge[cur[u]].v;
            else
            {
                if(qin==0) break;
                lev[u]=-1,u=edge[que[--qin]].u;
            }
        }
    }
    return flow;
}
void addedge(int u,int v,int f)
{
    edge[p].u=u,edge[p].v=v,edge[p].f=f,edge[p].next=head[u],head[u]=p++;
    edge[p].u=v,edge[p].v=u,edge[p].f=0,edge[p].next=head[v],head[v]=p++;
}
bool buit(int n,int m)
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            if(low[i][j]>up[i][j]) return 0;
            else
            {
                tre[i]-=low[i][j],tre[j+n]+=low[i][j];
                addedge(i,j+n,up[i][j]-low[i][j]);
            }
    return 1;
}
void limitflow(int s,int t,int n,int m)
{
    int i,j,x,y;
    x=t+1,y=t+2;//附加源汇点，x,y
    for(i=0;i<=t;i++)
    {
        if(tre[i]>0) addedge(x,i,tre[i]);
        else if(tre[i]<0) addedge(i,y,-tre[i]);
    }
    addedge(t,s,inf);
    dinic(x,y);//可行流
    for(i=head[x];i!=-1;i=edge[i].next)
        if(edge[i].f)//若x的出弧或y的入弧都满，则有解，将必要弧合并回原图；否则，无解。
        {
            printf("IMPOSSIBLE\n\n"); return ;
        }
    for(i=head[t];i!=-1;i=edge[i].next)
        if(edge[i].v==s) break;
    if(i<0)
    {
        printf("IMPOSSIBLE\n\n"); return;
    }
    for(i=1;i<=n;i++)
    {
        for(j=1;j<m;j++)
        printf("%d ",edge[((i-1)*m+j)*2-1].f+low[i][j]);//（(i-1)*m+j）*2是i,j的反边
        printf("%d\n",edge[i*m*2-1].f+low[i][j]);
    }
    printf("\n");
}
int main()
{
    int cas,cas1,n,m,i,j,sum1,sum2;
    int u,v,d,f1,t1,f2,t2,s,t;
    char c[5];
    scanf("%d",&cas);
    for(int tt=1;tt<=cas;tt++)
    {
        scanf("%d%d",&n,&m);
        s=0,t=n+m+1,sum1=0,sum2=0;
        init1(n,m);
        for(i=1;i<=n;i++)
         scanf("%d",&u),tre[s]-=u,tre[i]+=u,sum1+=u;;
        for(i=n+1;i<=n+m;i++)
         scanf("%d",&u),tre[i]-=u,tre[t]+=u,sum2+=u;


         scanf("%d",&cas1);
        while(cas1--)
        {
            scanf("%d%d%s%d",&u,&v,c,&d);
            f1=t1=u,f2=t2=v;
            if(u==0) f1=1,t1=n;
            if(v==0) f2=1,t2=m;
            for(i=f1;i<=t1;i++)
                for(j=f2;j<=t2;j++)
                {
                    if(c[0]=='=')
                    {
                        low[i][j]=max(d,low[i][j]),up[i][j]=min(d,up[i][j]);
                    }
                    else if(c[0]=='>')
                    {
                        low[i][j]=max(d+1,low[i][j]);
                    }
                    else if(c[0]=='<')
                    {
                        up[i][j]=min(d-1,up[i][j]);
                    }
                }
        }
        if(sum1==sum2 && buit(n,m))
              limitflow(s,t,n,m);
        else printf("IMPOSSIBLE\n\n");
    }
    return 0;
}