ZOJ 3229 有上下界最大流

 

/**
    ZOJ 3229 有上下界的最大流
    两次求最大流的过程,非二分
    有源汇上下界的最大流问题, 首先连接 sink -> src, [0,INF].
    根据net的正负,来建立 Supersrc 与 supersink 之间的边,做一次 maxflow.
    若所有的Supersrc 与 Supersink满流,则说明存在可行流.
    然后删除 sink -> src之间的边.(cap 置零即可). 从src -> sink 做一次最大流.
    两次最大流的和即为整个网络的最大流.
*/

#include<iostream>
#include<cmath>
#include<memory>
#include <string.h>
#include <cstdio>
#include <vector>
using namespace std;

#define V 1500      // vertex
#define E  V *80     // 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;
    }
    // girl 0-m-1, day m,m+n-1, src m+n, sink m+n+1. all m+n+2 point
    void solve()
    {
        int N,M; // n days m girl
        while(scanf("%d%d", &N,&M) != EOF)
        {
            e = 0;
            memset(head, -1, sizeof(head));
            memset(net, 0, sizeof(net));
            int G; src = M+N, sink = M+N+1;
            for(int i=0; i<M; i++)
            {
                scanf("%d", &G);
                addedge(i,sink,INF-G, G,INF);
                net[i] -= G;
                net[sink] += G;
            }
            vector<int> CE;
            for(int i=0; i<N; i++)
            {
                int C,D; scanf("%d%d", &C,&D);
                addedge(src, M+i, D, 0, D);
                for(int j=0; j<C; j++)
                {
                    int T,L,R; scanf("%d%d%d", &T,&L,&R);
                    CE.push_back(e);
                    addedge(M+i,T,R-L, L,R);
                    net[M+i] -= L;
                    net[T] += L;
                }
            }
            int spec = e;
            // 添加从sink -> src 容量为INF的边
            addedge(sink, src, INF,0,INF);
            src = M+N+2; sink = M+N+3;  // M+N+4 point
            int rangea = e;
            for(int i=0; i<M+N+2; i++)
            {
                if(net[i] >= 0) addedge(src, i, net[i]);
                else  addedge(i, sink,-net[i]);
            }
            double ret = 0;
            int rangeb = e;
            // 从super src ->super sink 做一次最大流
            ret+=ISAP(M+N+4);
            bool flag = true;
            // 判断是否满流
            for(int i= rangea; i<rangeb; i+=2)
            {
                if(edge[i].w !=0)
                {
                    flag = false;
                    break;
                }
            }
            if(flag)
            {
                // 修改 src sink,然后把 从sink -> src 的边删除
                src = M+N; sink = M+N+1;
                edge[spec].w = 0; edge[spec+1].w = 0;
                // 从 src->sink 做一次最大流
                ret += ISAP(M+N+2);
                int tmp = ret;
                printf("%d\n", tmp);
                for(int i=0; i<CE.size(); i++)
                    printf("%d\n", edge[CE[i]+1].lb + edge[CE[i]+1].w);
            }else printf("-1\n");
            cout<<endl;
        }
    }
}sap;

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