hdu 2549 Flow Problem 最大流

//hdu 2549 Flow Problem 最大流
//简单最大流
//EK算法居然比 同时找多条增广路的dinic算法还快
//
//dinic要注意找不到增广路的点的层次要标为-1
//
//具体看代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>

using namespace std;

#define INF (1<<30)
#define N 25

int map[N][N], fa[N];
bool vis[N];

bool bfs(int n)
{
    memset(vis, false, sizeof(vis));
    memset(fa, -1, sizeof(fa));
    queue<int>que;
    que.push(1);
    vis[1] = true;
    while(!que.empty())     //广搜找增广路
    {
        int now = que.front();
        que.pop();
        vis[now] = true;
        for(int i = 1; i <= n; ++i)
        {
            if(vis[i] == false && map[now][i] > 0)
            {
                vis[i] = true;
                fa[i] = now;
                if(i == n)
                    return true;
                que.push(i);
            }
        }
    }
    return false;
}


void EK(int n, int m)
{
    int ans = 0;
    while(bfs(n))   //找增广路
    {
        int min = INF;//找增广路的瓶颈,也就是找到这条增广路
        for(int i = n; i != 1; i = fa[i])   //留向汇点的流量
            min = map[fa[i]][i] < min ? map[fa[i]][i] : min;

        for(int i = n; i != 1; i = fa[i])
        {
            map[fa[i]][i] -= min;
            map[i][fa[i]] += min;   //建反向边
        }
        ans += min;
    }
    printf("%d\n", ans);
}

int main()
{
    int n_case;
    scanf("%d", &n_case);
    for(int j = 1; j <= n_case; ++j)
    {
        printf("Case %d: ", j);
        int n, m;
        scanf("%d%d", &n, &m);
        memset(map, 0, sizeof(map));
        for(int i = 0; i < m; ++i)
        {
            int from, to, f;
            scanf("%d%d%d", &from, &to, &f);
            map[from][to] += f;
        }
        EK(n, m);
    }
    return 0;
}

 

#define comein freopen("in.txt", "r", stdin);
#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>
using namespace std;


#define INF 1<<30
#define N 2000

int eid;
int head[N], to[N], cap[N], next[N];
int level[N];

void add_edge(int from, int t, int f)
{
    to[eid] = t;
    cap[eid] = f;
    next[eid] = head[from];
    head[from] = eid++;

    to[eid] = from;   //建反向边
    cap[eid] = 0;
    next[eid] = head[t];
    head[t] = eid++;
}

bool bfs(int root, int n_point)     //残余网络分层
{
    memset(level, -1, sizeof(level));
    queue<int>que;
    que.push(root);
    level[root] = 0;
    while(!que.empty())
    {
        root = que.front();
        que.pop();
        for(int i = head[root]; i != -1; i = next[i])
        {   //边还有残余容量，且下一个点还没分层
            if(level[to[i]] == -1 && cap[i])
            {
                level[to[i]] = level[root] + 1;
                if(to[i] == n_point)
                    return true;
                que.push(to[i]);
            }
        }
    }
    return false;
}

int dfs(int root, int f, int n_point)
{
    if(root == n_point)
        return f;
    int flow, ans = 0;
    for(int i = head[root]; i != -1; i = next[i])
    {
        int m = min(cap[i], f - ans);
        if(cap[i] && level[root]+1 == level[to[i]] &&
           (flow = dfs(to[i], m, n_point ) )   )
        {   //下标从0开始，则正向边为偶数，反向边为基数;
            cap[i] -= flow;
            cap[i^1] += flow;//下标从1开始则不能用  异或
            ans += flow;
        }
    }
    if(ans == 0)    //若没找到增广路，这时注意要把该点
        level[root] = -1;   //的层次标为-1，表示不能到达
    return ans;
}

void dinic(int n_point)
{
    int flow = 0;
    while(bfs(1, n_point))  //分层
    {
        while(1)    //每条增广路都有一个瓶颈(增光路上最小容量的边)
        {   //每次分层都要把所有增广路的瓶颈都清除掉，再重新分层
            int f = dfs(1, INF, n_point);//因此最多层分v次
            if(f == 0)
                break;
            flow += f;
        }
    }
    printf("%d\n", flow);
}

int main()
{
    eid = 0;

    int n_case;
    scanf("%d", &n_case);
    for(int t = 1; t <= n_case; ++t)
    {
        printf("Case %d: ", t);
        int n_point, n_edge;
        scanf("%d%d", &n_point, &n_edge);
        memset(head, -1, sizeof(head));
        while(n_edge--)
        {
            int from, to, f;
            scanf("%d%d%d", &from, &to, &f);
            add_edge(from, to, f);
        }
        dinic(n_point);
    }
    return 0;
}