[HDOJ3549]Flow Problem

赤裸裸最大流~

#include <cstdio>
#include <cstring>

 const int INF = (1 << 30);

 class Network
{
private:
    const static int MAXV = 512; // 顶点数
    const static int MAXE = 512000; // 边数 * 2

    struct List
    {
        int v;
        int f;
        List * rev;
        List * next;
    };

    List pool[MAXE];
    List * path[MAXV];
    List * head[MAXV];
    List * cur[MAXV];
    List * pp;

    int n;
    int s;
    int t;
    int dist[MAXV];
    int num[MAXV];
    int pred[MAXV];

    inline List * create(int v,int f,List * next)
    {
        pp->v = v;
        pp->f = f;
        pp->next = next;
        return pp++;
    }

    void InitDist();
    int Augment(int &);
public:
    void Init(int nv,int ss,int tt);
    void addEdge(int u,int v,int f);
    int maxFlow();
};

void Network::Init(int nv,int ss,int tt)
{
    n = nv;
    s = ss;
    t = tt;

    pp = pool;
    memset(head,0,n * sizeof(head[0]));
    memset(cur,0,n * sizeof(cur[0]));
    memset(num,0,n * sizeof(int));

    pred[s] = -1;

    for (int i = 0;i < n;i++)
        dist[i] = n;

    return;
}

void Network::addEdge(int u,int v,int f)
{
    head[u] = create(v,f,head[u]);
    head[v] = create(u,0,head[v]);

    head[u]->rev = head[v];
    head[v]->rev = head[u];

    return;
}

void Network::InitDist()
{
    int queue[MAXV];
    int qh = -1;
    int qe = 0;

    dist[t] = 0;
    queue[0] = t;

    while (qh != qe)
    {
        qh++;
        int u = queue[qh];
        for (List * p = head[u];p;p = p->next)
            if (p->f == 0 && dist[p->v] == n)
            {
                dist[p->v] = dist[u] + 1;
                num[dist[p->v]]++;
                queue[++qe] = p->v;
            }
    }

    return;
}

int Network::Augment(int & sum)
{
    int last = s;
    int minl = INF;
    for (int u = t;u != s;u = pred[u])
        minl = minl < path[u]->f ? minl : path[u]->f;
    sum += minl;
    for (int u = t;u != s;u = pred[u])
    {
        path[u]->f -= minl;
        path[u]->rev->f += minl;
        if(path[u]->f == 0)
            last = pred[u];
    }

    return last;
}

int Network::maxFlow()
{
    bool update;
    int u = s;
    int ret = 0;

    InitDist();
    for (int i = 0;i < n;i++)
        cur[i] = head[i];

    while (dist[s] < n)
    {
        update = false;
        for (List * p = cur[u];p;p = p->next)
            if (dist[p->v] + 1 == dist[u] && p->f > 0)
            {
                update = true;
                pred[p->v] = u;
                path[p->v] = p;
                cur[u] = p;
                u = p->v;    // 前进步
                if (u == t)
                    u = Augment(ret);
                break;
            }
        if (!update)
        {
            if ( --num[dist[u]] == 0)    // 间隙优化
                break;
            cur[u] = head[u];
            dist[u] = n;
            for (List * p = head[u];p;p = p->next)    // 重标号
                if (p->f > 0 && dist[u] > dist[p->v] + 1)
                    dist[u] = dist[p->v] + 1;
            if (dist[u] < n)
                num[dist[u]]++;
            if (u != s)                // 回退步
                u = pred[u];
        }
    }
    return ret;
}

Network net;

int main()
{
    int nd;
    int nw;
    int u;
    int v;
    int val;
    int cas;

    scanf("%d",&cas);
    for(int cc = 0;cc < cas;cc++)
    {
        scanf("%d %d",&nd,&nw);
        net.Init(nd,0,nd - 1);
        for(int i = 0;i < nw;i++)
        {
            scanf("%d %d %d",&u,&v,&val);
            net.addEdge(u-1,v-1,val);
        }
        printf("Case %d: %d\n",cc+1,net.maxFlow());
    }
    return 0;
}