HDU3549：Flow Problem（最大流 & Ek算法 + Dinic算法）

Flow Problem

Time Limit: 5000/5000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 15720    Accepted Submission(s): 7443

Problem Description

Network flow is a well-known difficult problem for ACMers. Given a graph, your task is to find out the maximum flow for the weighted directed graph.

 

Input

The first line of input contains an integer T, denoting the number of test cases.
For each test case, the first line contains two integers N and M, denoting the number of vertexes and edges in the graph. (2 <= N <= 15, 0 <= M <= 1000)
Next M lines, each line contains three integers X, Y and C, there is an edge from X to Y and the capacity of it is C. (1 <= X, Y <= N, 1 <= C <= 1000)

 

Output

For each test cases, you should output the maximum flow from source 1 to sink N.

 

Sample Input

  
  

   
   2
3 2
1 2 1
2 3 1
3 3
1 2 1
2 3 1
1 3 1
  
  

 

Sample Output

  
  

   
   Case 1: 1
Case 2: 2
  
  

 

Author

HyperHexagon

 

Source

HyperHexagon's Summer Gift (Original tasks)

思路：最大流入门题。

①EK算法，重复多次BFS，所以效率较低。

其实这题点的范围极小，边有重复，用二位数组邻接矩阵存边会更快，但作为模板练手下面用前向星存边。

# include <iostream>
# include <cstdio>
# include <queue>
# include <algorithm>
# include <cstring>
using namespace std;

const int N = 2e3+3;
struct node
{
    int v, c, next;
}edge[N];
int cnt, n, m, pre[N], nex[N], id[N];

void add_edge(int u, int v, int c)
{
    edge[cnt].v = v;
    edge[cnt].c = c;
    edge[cnt].next = nex[u];
    nex[u] = cnt++;
}

int BFS()//找出一条增广路。
{
    memset(pre, -1, sizeof(pre));
    queue<int>q;
    q.push(1);
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        if(u == n)
            return 1;
        for(int i=nex[u]; i!= -1; i=edge[i].next)
        {
            int v = edge[i].v;
            if(pre[v]==-1 && edge[i].c > 0)
            {
                q.push(v);
                pre[v] = u;//路径记录。
                id[v] = i;//记录边的编号。
            }
        }
    }
    return 0;
}

int EK()
{
    int ans = 0;
    while(1)
    {
        if(!BFS())
            return ans;
        int imin = 0x7fffffff;
        for(int i=n; i!=1; i=pre[i])
            imin = min(imin, edge[id[i]].c);//找出可以增加的最大流量。
        for(int i=n; i!=1; i=pre[i])
        {
            edge[id[i]].c -= imin;//正向边减少剩余容量。
            edge[id[i]^1].c += imin;//反向边增加剩余“容量”。
        }
        ans += imin;
    }
}

int main()
{
    int t, a, b, c, cas=1;;
    scanf("%d",&t);
    while(t--)
    {
        cnt = 0;
        memset(nex, -1, sizeof(nex));
        scanf("%d%d",&n,&m);
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a, b, c);
            add_edge(b, a, 0);
        }
        printf("Case %d: %d\n",cas++, EK());
    }
    return 0;
}

②Dinic算法

1、根据残量网络计算层次图。（其中作用之一是快速判断是否还有增广路，没有就停止DFS）。
2、在层次图中使用DFS进行增广直到不存在增广路。
3、重复以上步骤直到无法增广。

# include <iostream>
# include <cstdio>
# include <queue>
# include <cstring>
# include <algorithm>
using namespace std;

const int N = 2e3+3;
const int INF = 0x7fffffff;
int cnt, n, m, nex[N], dis[N];
struct node
{
    int v, c, next;
}edge[N];

void add_edge(int u, int v, int c)
{
    edge[cnt].v = v;
    edge[cnt].c = c;
    edge[cnt].next = nex[u];
    nex[u] = cnt++;
}

int BFS()//建立层次图。
{
    memset(dis, -1, sizeof(dis));
    dis[1] = 0;
    queue<int>q;
    q.push(1);
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        for(int i=nex[u]; i!=-1; i=edge[i].next)
        {
            int v = edge[i].v;
            if(dis[v] == -1 && edge[i].c > 0)
            {
                dis[v] = dis[u] + 1;
                q.push(v);
            }
        }
    }
    return dis[n] != -1;
}

int DFS(int u, int pre)
{
    int f = 0;
    if(u == n) return pre;
    for(int i=nex[u]; i!=-1; i=edge[i].next)
    {
        int v = edge[i].v, c = edge[i].c;
        if(c > 0 && dis[v] == dis[u]+1 && (f=DFS(v, min(pre, c))))
        {
            edge[i].c -= f;
            edge[i^1].c += f;
            return f;
        }
    }
    return 0;
}

int main()
{
    int t, a, b, c, add, ans, cas=1;
    scanf("%d",&t);
    while(t--)
    {
        ans = cnt = 0;
        scanf("%d%d",&n,&m);
        memset(nex, -1, sizeof(nex));
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a, b, c);
            add_edge(b, a, 0);
        }
        while(BFS())//重建层次图。
            while(add = DFS(1,INF))//找出并处理所有增广路。
                ans += add;
        printf("Case %d: %d\n",cas++, ans);
    }
    return 0;
}