ZOJ 2314 带上下界的可行流

对于无源汇问题,方法有两种.

1 从边的角度来处理. 新建超级源汇, 对于每一条有下界的边,x->y, 建立有向边 超级源->y ,容量为x->y下界,建立有向边 x-> 超级汇,容量为x->y下界.建立有向边 x->y,容量为x->y的上界减下界.

2 从点的角度来处理. 新建超级源汇,对于每个点流进的下界和为 in, 流出此点的下界和为out.如果in > out. 建立有向边 超级源->i,容量为in-out.反之,建立有向边 i->超级汇,容量为out-in.

如果超级源的每一条出边都满流,则存在一个可行流,可行流的流量就是每一条逆向边的流量+ 此边下界.

从点的角度的处理方法是边的处理方法的拓展.基于边的处理比较容易理解,但是复杂度较高.

下面是基于点的处理的程序:

/*
    带上下界的可行流
*/
#include<iostream>
#include<cmath>
#include<memory>
#include <string.h>
#include <cstdio>
using namespace std;

#define V 300      // vertex
#define E  40800     // edge
#define INF 0x3F3F3F3F  // 1061109567

int i,j,k;
#define REP(i,n) for((i)=0;(i)<(int)(n);(i)++)
#define snuke(c,itr) for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)

struct MaxFlow
{
    struct Edge
    {
        int v, w, next;     //w for capicity
        int lb,up;
    } edge[E];

    int head[V];          // head[u]表示顶点u第一条邻接边的序号, 若head[u] = -1, u没有邻接边
    int e;                // the index of the edge
    int src, sink;
    int net[V];              // 流入此节点的流的下界和 - 流出此节点的流的下界和,对于带上下界的来进行使用


    void addedge(int  u, int v, int w, int lb = 0, int up = INF, int rw = 0)
    {
        edge[e].v = v;
        edge[e].w= w;
        edge[e].next = head[u];
        edge[e].lb = lb, edge[e].up = up;
        head[u] = e++;
        // reverse edge  v -> u
        edge[e].v = u;
        edge[e].w = rw;
        edge[e].lb = lb, edge[e].up = up;
        edge[e].next = head[v];
        head[v] = e++;
    }

    int ISAP(int VertexNum )
    {
        int u, v, max_flow, aug, min_lev;
        int curedge[V], parent[V], level[V];
        int count[V], augment[V];

        memset(level, 0, sizeof(level));
        memset(count, 0, sizeof(count));
        REP(i,VertexNum+1) curedge[i] = head[i];
        max_flow = 0;
        augment[src] = INF;
        parent[src] = -1;
        u = src;

        while (level[src] < VertexNum)
        {
            if (u == sink)
            {
                max_flow += augment[sink];
                aug = augment[sink];
                for (v = parent[sink]; v != -1; v = parent[v])
                {
                    i = curedge[v];
                    edge[i].w  -= aug;
                    edge[i^1].w  += aug;
                    augment[edge[i].v] -= aug;
                    if (edge[i].w == 0) u = v;
                }
            }
            for (i = curedge[u]; i != -1; i = edge[i].next)
            {
                v = edge[i].v;
                if (edge[i].w > 0 && level[u] == (level[v]+1))
                {
                    augment[v] = min(augment[u], edge[i].w);
                    curedge[u] = i;
                    parent[v] = u;
                    u = v;
                    break;
                }
            }
            if (i == -1)
            {
                if (--count[level[u]] == 0) break;
                curedge[u] = head[u];
                min_lev = VertexNum;
                for (i = head[u]; i != -1; i = edge[i].next)
                    if (edge[i].w > 0)
                        min_lev = min(level[edge[i].v], min_lev);
                level[u] = min_lev + 1;
                count[level[u]]++;
                if (u != src ) u = parent[u];
            }
        }
        return max_flow;
    }
    void solve()
    {
        int T; cin>>T;
        for(int cas =1; cas <=T; cas++)
        {
            int N,M; cin>>N>>M;
            e = 0;
            memset(head, -1, sizeof(head));
            memset(net, 0, sizeof(net));
            int a,b,c,d;
            for(int i=1; i<=M;i++)
            {
                scanf("%d%d%d%d", &a, &b, &c, &d);
                net[b] += c; net[a] -= c;
                addedge(a,b,d-c, c,d);
            }
            // 无源汇,这两个是super src, super sink.
            src =N+1; sink = N+2;
            for(int i=1; i<=N; i++)
            {
                if(net[i] > 0)
                    addedge(src, i, net[i]);
                else
                    addedge(i, sink, -net[i]);
            }
            ISAP(N+2);
            bool flag = true;
            for (i = head[src]; i != -1; i = edge[i].next)
            {
                if(edge[i].w !=0)
                {
                    flag = false;
                    break;
                }
            }
            if(flag)
            {
                cout<<"YES"<<endl;
                for(int i=0; i<M;i++)
                {
                    cout<<edge[i*2+1].w + edge[i*2+1].lb<<endl;
                }
                cout<<endl;
            }else
            {
                cout<<"NO"<<endl;
                cout<<endl;
            }
        }

    }
}sap;

int main()
{
//    freopen("1.txt","r",stdin);
    sap.solve();
    return 0;
}