POJ 3801 有上下界最小流

/**
    POJ 3801 有上下界的最小流

1、对supersrc到supersink 求一次最大流，记为f1。（在有源汇的情况下，先使整个网络趋向必须边尽量满足的情况）
2、添加一条边sink -> src，流量上限为INF，这条边记为p。（构造无源汇网络）
3、对supersrc到supersink再次求最大流，记为f2,这里判断是否为可行流。（要判断可行，必须先构造无源汇网络流，因此要再次求最大流）

    此网络流的最小流即为 sink -> src 的流量
*/

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

#define V 150      // vertex
#define E  (V*V)     // 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 n, m;
        while (scanf("%d %d", &n, &m) != EOF)
        {
            if (n+m == 0) break;
            e = 0;
            memset(head, -1, sizeof(head));
            memset(net, 0, sizeof(net));

            int s = n+1, t = n+2;
            src = n+3, sink = n+4;
            char a[5], b[5];
            int c;
            while (m--)
            {
                scanf("%s %s %d", a, b, &c);
                int u, v;
                if (a[0] == '+') u = s;
                else sscanf(a, "%d", &u);   // 注意这里读取信息
                if (b[0] == '-') v = t;
                else sscanf(b, "%d", &v);
                net[v] += c, net[u] -= c;
                addedge(u,v,INF,c, INF);
            }
            vector<int> CE;
            for(int i=1; i<=n+2; i++)
            {
                if(net[i] >=0)
                {
                    CE.push_back(e);
                    addedge(src, i, net[i]);
                }
                else
                {
                    CE.push_back(e);
                    addedge(i, sink, -net[i]);
                }
            }
            int flow = 0;
            flow =  ISAP(n+4);
            int p = e;
            addedge(t, s, INF, 0, INF);
            flow += ISAP(n+4);
            bool flag = true;
            for(int i= 0; i< CE.size(); i++)
            {
                if(edge[CE[i]].w !=0)
                {
                    flag = false;
                    break;
                }
            }
            if (!flag)
                printf("impossible
");
            else
                printf("%d
", edge[p^1].w);
        }
    }
} sap;

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