HDU-3549-Flow Problem-最大流问题（dinic(）算法）

Flow Problem
Time Limit: 5000/5000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 19822 Accepted Submission(s): 9331

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

解题思路： 这道题是简单的最大流入门题，与1532那道题一样，不同的是那道题我用的是EK算法，这道题用的dinic（）算法，dinic（）算法与EK算法的思想是一样的,但dinic()算法加入了层次的思想，用广搜算法来构造层次图，用深搜找最广路，对最大流EK算法不明白可以看这个文章HDU-1532
//AC代码

#include 
#include
#include
#include
using namespace std;
#define INF 0x3f3f3f
struct node
{
    int c,f;//c用来表示容量，f用来表示流量
}flow[205][205];
int N,M;
int level[205];//用于表示每个节点的层次
queue<int> Q;
bool dinic_bfs()//构造层次图
{
    Q.push(1);
    memset(level,0,sizeof(level));
    level[1]=1;
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        for(int v=1;v<=N;v++)
        {
            if(!level[v]&&flow[u][v].f//如果u-v相通且v在这次构造层次图中没有被访问到过
            {
                level[v]=level[u]+1;//后继节点的层次是前驱结点的层次+1
                Q.push(v);
            }
        }
    }
    if(level[N]==0)
        return false;
    return true;
}
int dinic_dfs(int u,int minflow)//根据增广路，找最小残留量，深搜思想
{
    int tmp=minflow;
    if(u==N)
        return minflow;
    for(int v=1;v<=N&&tmp;v++)
    {
        if(level[v]==level[u]+1&&flow[u][v].fint t=dinic_dfs(v,min(tmp,flow[u][v].c-flow[u][v].f));
                flow[u][v].f += t;
                flow[v][u].f -= t;
                tmp -= t;
        }
    }
    return minflow-tmp;
}
int dinic()
{

    int maxflow=0;
    int t=0;
    while(dinic_bfs())
    {
        while(t=dinic_dfs(1,INF))
        {
            maxflow+=t;
        }
    }
    return maxflow;
}
int main()
{
    int T;
    scanf("%d",&T);
    int si,ci,wi;
    for(int icase=1;icase<=T;icase++)
    {
        memset(flow,0,sizeof(flow));
        scanf("%d%d",&N,&M);
        for(int i=1;i<=M;i++)
        {
            scanf("%d%d%d",&si,&ci,&wi);
            flow[si][ci].c+=wi;
        }
        printf("Case %d: %d\n",icase,dinic());

    }
    return 0;
}