最大流

//isap
struct isap_edge{
    int from, to, next, val;
}isap_e[MAXM];

int isap_cnt, isap_h[MAXN];

void isap_init(){
    isap_cnt = 0;
    memset( isap_h, -1, sizeof( isap_h ) );
}

void isap_add( int from, int to, int v1, int v2 ){
    isap_e[isap_cnt].from = from;
    isap_e[isap_cnt].to = to;
    isap_e[isap_cnt].val = v1;
    isap_e[isap_cnt].next = isap_h[from];
    isap_h[from] = isap_cnt++;

    swap( from, to );

    isap_e[isap_cnt].from = from;
    isap_e[isap_cnt].to = to;
    isap_e[isap_cnt].val = v2;
    isap_e[isap_cnt].next = isap_h[from];
    isap_h[from] = isap_cnt++;
}

int isap( int s, int t, int n ){
    int Q[MAXN], cnt[MAXN], d[MAXN], low[MAXN], cur[MAXN];

    int l = 0, r = 0;
    for( int i = 1; i <= n; i++ ){
        d[i] = n; cnt[i] = 0;
    }
    cnt[n] = n - 1; cnt[0]++; d[t] = 0;

    Q[r++] = t;
    while( l < r ){
        int v = Q[l++];
        for( int i = isap_h[v]; i != -1; i = isap_e[i].next ){
            if( d[isap_e[i].to] == n && isap_e[i ^ 1].val > 0 ){
                d[isap_e[i].to] = d[v] + 1;
                cnt[n]--;
                cnt[d[isap_e[i].to]]++;
                Q[r++] = isap_e[i].to;
            }
        }
    }

    int max_flow = 0, pos = s, top = 0; low[0] = INF;
    for( int i = 1; i <= n; i++ )
        cur[i] = isap_h[i];
    while( d[s] < n ){
        int &i = cur[pos];
        for( ; i != -1; i = isap_e[i].next ){
            if( isap_e[i].val > 0 && d[pos] == d[isap_e[i].to] + 1 ){
                low[top + 1] = min( low[top], isap_e[i].val );
                Q[++top] = i;
                pos = isap_e[i].to;
                break;
            }
        }

        if( i != -1 ){
            if( pos == t ){
                int minf = low[top];
                for( int p = 1,i; p <= top; ++p ){
                    i = Q[p];
                    isap_e[i].val -= minf;
                    isap_e[i ^ 1].val += minf;
                }
                max_flow += minf;
                pos = s;
                low[0] = INF;
                top = 0;
            }
        }
        else{
            int old = d[pos];
            cnt[old]--;
            d[pos] = n - 1;
            for( int i = isap_h[pos]; i != -1; i = isap_e[i].next )
                if( isap_e[i].val > 0 && d[pos] > d[isap_e[i].to] )
                    d[pos] = d[isap_e[i].to];
            cnt[++d[pos]]++;
            if( d[pos] < n )
                    cur[pos] = isap_h[pos];
            if( pos != s ){
                pos = isap_e[Q[top]].from;
                --top;
            }
            if( cnt[old] == 0 )
                break;
        }
    }
    return max_flow;
}