poj 1273 Drainage Ditches | hdoj 1532

类型：最大流

经典题目 本题同hdoj 1532

dinic算法实现 [可做模板]

！！！ ne 需要从2开始，正向边的编号为偶数，反向边的编号为奇数

如果从1开始，那么当更新编号为3的边时，其反向边的编号为4，而此时更新的是编号为2的边，出现错误

// hdoj 1532 | poj 1273
// poj 0ms hdoj 15ms
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
using namespace std;

const int inf = 1 << 30;
const int MAXN = 2000;

struct node {
    int c,u,v,next;
}edge[MAXN];
int ne, head[MAXN];
int cur[MAXN], ps[MAXN], dep[MAXN];

void addedge(int u, int v,int w) {
    edge[ne].u = u;
    edge[ne].v = v;
    edge[ne].c = w;
    edge[ne].next = head[u];
    head[u] = ne ++;
    edge[ne].u = v;
    edge[ne].v = u;
    edge[ne].c = 0;
    edge[ne].next = head[v];
    head[v] = ne ++;
}

int dinic(int s, int t) {                       //  dinic
    int tr, res = 0;
    int i, j, k, f, r, top;
    while(1) {
        memset(dep, -1, sizeof(dep));
        for(f = dep[ps[0] = s] = 0, r = 1; f != r;)
            for(i = ps[f++], j = head[i]; j != -1; j = edge[j].next)
                if(edge[j].c && dep[k = edge[j].v] == -1) {
                    dep[k] = dep[i] + 1;
                    ps[r++] = k;
                    if(k == t) {
                        f = r; break;
                    }
                }
        if(dep[t] == -1) break;
        memcpy(cur, head, sizeof(cur));
        i = s, top = 0;
        while(1) {
            if(i == t) {
                for(tr = inf, k = 0; k < top; k++)
                    if(edge[ps[k]].c < tr)
                        tr = edge[ps[f = k]].c;
                for(k = 0; k < top; k++) {
                    edge[ps[k]].c -= tr;
                    edge[ps[k]^1].c += tr;
                }
                i = edge[ps[top=f]].u;
                res += tr;
            }
            for(j = cur[i]; cur[i] != -1; j = cur[i] = edge[cur[i]].next) {
                if(edge[j].c && dep[i]+1 == dep[edge[j].v]) break;
            }
            if(cur[i] != -1) {
                ps[top++] = cur[i];
                i = edge[cur[i]].v;
            }
            else {
                if(top == 0) break;
                dep[i] = -1;
                i = edge[ps[--top]].u;
            }
        }
    }
    return res;
}

int main() {
    int cas, i, j, M, N, a, b, c;

    while(scanf("%d %d", &N, &M) == 2) {
        ne = 2;
        memset(head,-1,sizeof(head));
        for(i = 0; i < N; ++i) {
            scanf("%d %d %d", &a, &b, &c);
            addedge(a, b, c);
        }
        cout<<dinic(1, M)<<endl;
    }
    return 0;
}