hdu 3549 Flow Problem (最大流入门题)

增广路：

/*************************************************************
题目:       Flow Problem(HDU 3549)
链接:       http://acm.hdu.edu.cn/showproblem.php?pid=3549
题意:       给一个单向图，求从1到n的最大流
算法：      最大流之增广路（入门）
算法思想：  不断用BFS找通路，没每找一条路，记录这条路的最小流，
            再给这条路上的所有流量减去这个最小值。
**************************************************************/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

int cap[20][20];
int a[20],father[20];
int n,m;

void Init()
{
    memset(cap,0,sizeof(cap));
    memset(a,0,sizeof(a));
}

int bfs()
{
    queue<int>q;
    int ans=0;
    while (1)
    {
        while (!q.empty()) q.pop();
        memset(a,0,sizeof(a));
        a[1]=10000000;
        q.push(1);
        father[1]=-1;
        while (!q.empty())
        {
            int u=q.front();
            q.pop();
            for (int v=2;v<=n;v++)
            {
                if (!a[v]&&cap[u][v]>0)
                {
                    q.push(v);
                    father[v]=u;
                    a[v]=min(a[u],cap[u][v]);
                }
            }
        }
        if (!a[n]) return ans;
        for (int u=n;father[u]!=-1;u=father[u])
        {
            cap[u][father[u]]+=a[n];
            cap[father[u]][u]-=a[n];
        }
        ans+=a[n];

    }
}

int  main()
{
    int t,k=1;
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d%d",&n,&m);
        Init();
        int u,v,w;
        while (m--)
        {
            scanf("%d%d%d",&u,&v,&w);
            cap[u][v]+=w;
        }
        printf("Case %d: %d
",k++,bfs());
    }
}

dinic:

/***************************************************************
算法：      最大流之dinic（入门）
算法思想：  dinic的主要思想是层次图和阻塞流，只保留每个节点
             出发到下一个层次的弧，得到的图就叫层次图。阻塞
            流就是不考虑反向弧时的极大流。先用bfs分层，再计
            算阻塞流，不断从复这两步，直到找不到阻塞流结束。
***************************************************************/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

int cap[20][20];
int d[20];
int n,m;

int bfs()
{
    queue<int>q;
    memset(d,0,sizeof(d));
    q.push(1);
    while (!q.empty())
    {
        int u=q.front();
        q.pop();
        for (int v=2;v<=n;v++)
        {
           if (!d[v]&&cap[u][v]>0)
           {
               q.push(v);
               d[v]=d[u]+1;
           }
        }
    }
    return d[n];
}

int dfs(int u,int w)
{
    if (u==n||w==0) return w;
    int ans=0;
    for (int v=2;v<=n;v++)
    {
        if (cap[u][v]>0&&d[u]==d[v]-1)
        {
            int temp=dfs(v,min(w,cap[u][v]));
            cap[u][v]-=temp;
            cap[v][u]+=temp;
            w-=temp;
            ans+=temp;
        }
    }
    return ans;
}

int dinic()
{
    int ans=0;
    while (bfs()) ans+=dfs(1,100000000);
    return ans;
}

int main()
{
    int t,k=1;
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d%d",&n,&m);
        memset(cap,0,sizeof(cap));
        int u,v,w;
        while (m--)
        {
            scanf("%d%d%d",&u,&v,&w);
            cap[u][v]+=w;
        }
        printf("Case %d: %d
",k++,dinic());
    }
}

dinic之邻接表建图：

/************************************************
算法:  最大流之dinic（邻接表建图）
*************************************************/

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

const int mx=1005;
struct Eage
{
    int u,v;
    int next,cap;
};
Eage eage[mx*2];
int head[mx];
int d[mx];
int pos;
int n,m;

void Init()
{
    memset(head,-1,sizeof(head));
    pos=0;
}

void add(int u,int v,int w)
{
    eage[pos].v=v;
    eage[pos].cap=w;
    eage[pos].next=head[u];
    head[u]=pos++;
}

int bfs()
{
    queue<int>q;
    memset(d,0,sizeof(d));
    d[1]=1;
    q.push(1);
    while (!q.empty())
    {
        int u=q.front();
        q.pop();
        for (int i=head[u];i!=-1;i=eage[i].next)
        {
            int v=eage[i].v;
            if (!d[v]&&eage[i].cap>0)
            {
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
    return d[n];
}

int dfs(int u,int w)
{
    if (u==n||w==0) return w;
    int ans=0;
    for (int i=head[u];i!=-1;i=eage[i].next)
    {
        int v=eage[i].v;
        if (d[u]==d[v]-1&&eage[i].cap>0)
        {
            int temp=dfs(v,min(w,eage[i].cap));
            eage[i].cap-=temp;
            eage[i^1].cap+=temp;
            w-=temp;
            ans+=temp;
        }
    }
    return ans;
}

int dinic()
{
    int ans=0;
    while (bfs()) ans+=dfs(1,10000000);
    return ans;
}

int main()
{
    int t,k=1;
    scanf("%d",&t);
    while (t--)
    {
        Init();
        scanf("%d%d",&n,&m);
        int u,v,w;
        while (m--)
        {
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w);
            add(v,u,0);
        }
        printf("Case %d: %d
",k++,dinic());
    }
}