POJ 2396 Budget 有上下界的网络流

有上下界网络流问题

1.无源汇最大流

2.有源汇最大流

3.有源汇最小流

1.无源汇最大流问题

sgu194

题意：

   给n个点，及m根pipe，每根pipe用来流躺液体的，单向的，每时每刻每根pipe流进来的物质要等于流出去的物质，要使得m条pipe组成一个循环体，里面流躺物质。

并且满足每根pipe一定的流量限制，范围为[Li,Ri].即要满足每时刻流进来的不能超过Ri(最大流问题)，同时最小不能低于Li。

例如：

46(4个点，6个pipe)
12 1 3 (1->2上界为3，下界为1)
23 1 3
3 4 1 3
4 1 1 3
1 3 1 3
4 2 1 3

可行流：

 

再如：所有pipe的上界为2下界为1的话，就不能得到一种可行流。

 

题解：

上界用ci表示，下界用bi表示。

下界是必须流满的，那么对于每一条边，去掉下界后，其自由流为ci– bi。

主要思想：每一个点流进来的流=流出去的流

对于每一个点i，令

Mi= sum(i点所有流进来的下界流)– sum(i点所有流出去的下界流)

如果Mi大于0，代表此点必须还要流出去Mi的自由流，那么我们从源点连一条Mi的边到该点。

如果Mi小于0，代表此点必须还要流进来Mi的自由流，那么我们从该点连一条Mi的边到汇点。

如果求S->T的最大流，看是否满流(S的相邻边都流满)。

满流则有解，否则无解。

 

2.有源汇最大流

zoj3229

题意：经过构图之后得到这样的问题，源点s，汇点t，有些边有上下界[Li,Ri].求s->t的最大流。

题解：

满足所有下界的情况下，判断是否存在可行流，方法可以转化成上面无源汇上下界判断方法。

只要连一条T→ S的边，流量为无穷，没有下界，那么原图就得到一个无源汇的循环流图。接下来的事情一样：原图中的边的流量设成自由流量ci– bi。新建源点SS汇点TT，求Mi，连边。然后求SS→ TT最大流，判是否满流。

判定有解之后然后求最大流，信息都在上面求得的残留网络里面。满足所有下界时，从s→ t的流量为多少？后悔边s→ t的边权！然后在残留网络中s→ t可能还有些自由流没有流满，再做一次s→ t的最大流，所得到的最大流就是原问题的最大流(内含两部分：残留的自由流所得到的流+后悔边s→ t)。

 

3.有源汇最小流

题意：经过构图之后得到这样的问题，源点s，汇点t，有些边有上下界[Li,Ri].求s->t的最小流。

题解：

同样先转换为无源汇网络流问题，添加t→ s边权为无穷。那么最小流不就是在满足所有下界的情况的流么。即上面提到的，求得SS→ TT的最大流之后，其后悔边s→ t的边权即为最小流。但是wa了，下面看一个wa的例子：

 

最后求得SS→ TT的最大流之后，得到后悔边s→ t的边权为200，实际上该网络最小流只要100：

s→ 1:100

1→ 3:200

3→ 2:200

2→ 1:100

2→ t:100

问题出在原图中存在环，循环流，而我们没有利用，导致流增大了。

解决方法：先不加t→ s边权为无穷的边，求SS→ TT的最大流，如果还没有流满则再加t→ s边权为无穷的边，再求一次最大流得到后悔边s→ t就是原问题的最小流了。

对于这题就更简单了

有源点和汇点,但是没有要求最大流

每一行和每一列的和都是限定的,

这就严格限定了上届和下届,

最后只要输出一种满足条件的方案就足够了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
using namespace std;
#define FOR(i,l,r) for(int i=(l);i<=(r);++i)
#define REP(i,n) for(int i=0;i<(n);++i)
#define DSC(i,r,l) for(int i=(r);i>=(l);--i)

#define N 400
#define M 100000
#define INF 1e9
int up[210][25],down[210][25];
int sum[410];
struct
{
    int to,next;
    int c;
} edge[M];
int head[N],level[N],ip;
int que[N];
bool makelevel(int s,int t)
{
    memset(level,0,sizeof(level));
    int iq=0;
    que[iq++]=s;
    level[s]=1;
    int top;
    for(int i=0; i<iq; i++)
    {
        top=que[i];
        if(top==t)  return 1;
        for(int k=head[top]; k!=-1; k=edge[k].next)
        {
            if(!level[edge[k].to]&&edge[k].c>0)
            {
                que[iq++]=edge[k].to;
                level[edge[k].to]=level[top]+1;
            }
        }
    }
    return 0;
}
int dfs(int now,int maxf,int t)
{
    if(now==t)  return maxf;
    int  ret=0,c;
    for(int k=head[now]; k!=-1; k=edge[k].next)
    {
        if(edge[k].c>0&&level[edge[k].to]==(level[now]+1))
        {
            c=dfs(edge[k].to,min(maxf-ret,edge[k].c),t);
            edge[k].c-=c;
            edge[k^1].c+=c;
            ret+=c;
            if(ret==maxf)   return  ret;
        }
    }
    if(!ret) --level[now];
    return ret;
}
int dinic(int s,int t)
{
    int  ans=0;
    while(makelevel(s,t))   ans+=dfs(s,INF,t);
    return ans;
}
void add(int u,int v,int c,int f)//有向边f为0 ,否则为 c
{
    edge[ip].to=v;  edge[ip].c=c;   edge[ip].next=head[u];  head[u]=ip++;
    edge[ip].to=u;  edge[ip].c=f;   edge[ip].next=head[v];  head[v]=ip++;
}

bool solve(int n,int m)
{
    memset(head,-1,sizeof(head));   ip=0;
    FOR(i,1,n)
        FOR(j,1,m)
        {
            if(up[i][j]<down[i][j]) return 0;
            sum[i]-=down[i][j];
            sum[j+n]+=down[i][j];
            add(i,j+n,up[i][j]-down[i][j],0);
        }
    int s=0,t=n+m+1,ss=t+1,tt=ss+1;
    FOR(i,0,t)
    {
        if(sum[i]>0) add(ss,i,sum[i],0);
        else if(sum[i]<0) add(i,tt,-sum[i],0);
    }
    add(t,s,INF,0);
    
    dinic(ss,tt);
    
    for(int p=head[ss]; p!=-1; p=edge[p].next) if(edge[p].c) return 0;
    FOR(i,1,n)
    {
        FOR(j,1,m)
        {
            if(j>1) putchar(' ');
            printf("%d",edge[((i-1)*m+j)*2-1].c+down[i][j]);
        }
        puts("");
    }
    return 1;
}

int main()
{
    //freopen("in.txt","r",stdin);
    int cas,cas1=1,n,m,temp;
    int x,y,c;
    char str[10];
    cin>>cas;
    while(cas--)
    {
        memset(sum,0,sizeof(sum));
        cin>>n>>m;
        FOR(i,0,n)
            FOR(j,0,m)
                down[i][j]=0,up[i][j]=INF;
        int sum1=0,sum2=0;
        FOR(i,1,n)
        {
            scanf("%d",&c),sum1+=c;
            sum[0]-=c;
            sum[i]+=c;
        }
        FOR(i,1,m)
        {
            scanf("%d",&c),sum2+=c;
            sum[i+n]-=c;
            sum[n+m+1]+=c;
        }
        cin>>temp;
        int u,d,l,r;
        while(temp--)
        {
            scanf("%d%d%s%d",&x,&y,str,&c);
            u=d=x,l=r=y;
            if(x==0) u=1,d=n;
            if(y==0) l=1,r=m;
            FOR(i,u,d)
            FOR(j,l,r)
            {
                if(str[0]=='>') down[i][j]=max(down[i][j],c+1);
                else if(str[0]=='<') up[i][j]=min(up[i][j],c-1);
                else
                {
                    down[i][j]=max(down[i][j],c);
                    up[i][j]=min(up[i][j],c);
                }
            }
        }
        if(cas1++>1) puts("");
        if(sum1!=sum2 || !solve(n,m)) puts("IMPOSSIBLE");
    }
    return 0;
}