HLPP 最大流 O(V^3)

HLPP 最大流 O(V^3)

| INIT: network g; g.build(nv, ne);

| CALL: res = g.maxflow(s, t);

| 注意 : 不要加入指向源点的边 , 可能死循环 .

\*==================================================*/

#define typef int // type of flow

const typef inf = 0x3f3f3f3f; // max of flow

typef minf(typef a, typef b) { return a < b ? a : b; }

struct edge {

int u, v; typef cuv, cvu, flow;

edge ( int x=0, int y=0, typef cu=0,

typef cv=0, typef f=0)

: u(x), v(y), cuv(cu), cvu(cv), flow(f) {}

int other( int p) { return p == u ? v : u; }

typef cap( int p) {

return p == u ? cuv-flow : cvu+flow;

}

void addflow( int p, typef f) { flow += (p == u ? f : -f); }

};

struct vlist {

int lv, next[N], idx[2 * N], v;

void clear( int cv) {

v = cv; lv = -1;

memset(idx, -1, sizeof (idx));

}

void insert( int n, int h) {

next[n] = idx[h]; idx[h] = n;

if (lv < h) lv = h;

}

int remove() {

int r = idx[lv]; idx[lv] = next[idx[lv]];

while (lv >= 0 && idx[lv] == -1) lv--;

return r;

}

bool empty() { return lv < 0; }

};

struct network {

vector eg;

vector net[N];

vlist list;

typef e[N];

int v, s, t, h[N], hn[2 * N], cur[N];

void push( int );

void relabel( int );

void build( int , int );

typef maxflow( int , int );

};

void network::push( int u) {

edge* te = net[u][cur[u]];

typef ex = minf(te->cap(u), e[u]);

int p = te->other(u);

if (e[p] == 0 && p != t) list.insert(p, h[p]);

te->addflow(u, ex); e[u] -= ex; e[p] += ex;

}

void network::relabel( int u) {

int i, p, mh = 2 * v, oh = h[u];

for (i = net[u].size()-1; i >= 0; i--) {

p = net[u][i]->other(u);

if (net[u][i]->cap(u) != 0 && mh > h[p] + 1)

mh = h[p] + 1;

}

hn[h[u]]--; hn[mh]++; h[u] = mh;

cur[u] = net[u].size()-1;

if (hn[oh] != 0 || oh >= v + 1) return ;

for (i = 0; i < v; i++)

if (h[i] > oh && h[i] <= v && i != s) {

hn[h[i]]--; hn[v+1]++; h[i] = v + 1;

}

}

typef network::maxflow( int ss, int tt) {

s = ss; t = tt;

int i, p, u; typef ec;

for (i = 0; i < v; i++) net[i].clear();

for (i = eg.size()-1; i >= 0; i--) {

net[eg[i].u].push_back(&eg[i]);

net[eg[i].v].push_back(&eg[i]);

}

memset(h, 0, sizeof (h)); memset(hn, 0, sizeof (hn));

memset(e, 0, sizeof (e)); e[s] = inf;

for (i = 0; i < v; i++) h[i] = v;

queue< int > q; q.push(t); h[t] = 0;

while (!q.empty()) {

p = q.front(); q.pop();

for (i = net[p].size()-1; i >= 0; i--) {

u = net[p][i]->other(p);

ec = net[p][i]->cap(u);

if (ec != 0 && h[u] == v && u != s) {

h[u] = h[p] + 1; q.push(u);

}

}

}

for (i = 0; i < v; i++) hn[h[i]]++;

for (i = 0; i < v; i++) cur[i] = net[i].size()-1;

list.clear(v);

for (; cur[s] >= 0; cur[s]--) push(s);

while (!list.empty()) {

for (u = list.remove(); e[u] > 0; ) {

if (cur[u] < 0) relabel(u);

else if (net[u][cur[u]]->cap(u) > 0 &&

h[u] == h[net[u][cur[u]]->other(u)]+1)

push(u);

else cur[u]--;

}

}

return e[t];

}

void network::build( int n, int m) {

v = n; eg.clear();

int a, b, i; typef l;

for (i = 0; i < m; i++) {

cin >> a >> b >> l;

eg.push_back(edge(a, b, l, 0)); // vertex: 0 ~ n-1

}

}