hdu 1532 Drainage Ditches

题目：http://acm.hdu.edu.cn/showproblem.php?pid=1532

最基础的网络流

花姐给的代码，终于看懂了。。。T_T。。。

删改了部分注释。

AC代码：

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

#define N 202
int capacity[N][N];//map[x][y]为x到y的残余空闲容量
int flow[N];//留到这个点的最大流量
int pre[N]; //保存到达N点得前驱

int n, m;
queue<int> Q;

int BFS(int src, int des)
{
    //初始化，清空队列
    while (!Q.empty())
    {
        Q.pop();
    }
    for (int i = 1; i < n + 1; i++)
    {
        pre[i] = -1;
    }
    pre[src] = 0;
    flow[src] = INT_MAX;//初始化源点的流量为无穷大
    Q.push(src);
    while (!Q.empty())
    {
        int index = Q.front();
        Q.pop();
        if (index == des)  //找到了增广路径
        {
            break;
        }
        for (int i = 1; i < n + 1; i++)
        {
            if (i != src && capacity[index][i] > 0 && pre[i] == -1)
            {
                pre[i] = index;   //保存前驱
                //增广路残容流量
                flow[i] = min(capacity[index][i], flow[index]);
                Q.push(i);
            }
        }
    }//while
    if (pre[des] == -1)
    {
        return -1;  //残留图中不存在增广路径
    }
    else
    {
        return flow[des];
    }
}

int MaxFlow(int src, int des)
{
    int aug = 0;     //找到一条增广路时的最大流量
    int sumflow = 0;
    while ((aug = BFS (src, des)) != -1)
    {
        int k = des;  //利用前驱寻找路径，并更新此路径上得残量
        while (k != src)
        {
            int last = pre[k];
            capacity[last][k] -= aug;
            capacity[k][last] += aug;
            k = last;
        }
        sumflow += aug;
    }
    return sumflow;
}

int main()
{
    int cas, cases = 1;
    while (scanf("%d%d", &m, &n)!=EOF)
    {
        memset(capacity, 0, sizeof(capacity));
        memset(flow, 0, sizeof(flow));
        for (int i = 0; i < m; i++)
        {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            if (u == v) //起点终点相同
            {
                continue;
            }
            capacity[u][v] += w;
        }
        printf("%d\n", MaxFlow(1, n));
    }
    return 0;
}

转载于： http://blog.csdn.net/akof1314/article/details/4845183

转载代码：

#include <iostream>
using namespace std;
#define MAXN 205
#define INF 2110000000
#define MIN(x,y) (x<y?x:y)
int map[MAXN][MAXN];
int max_flow(int num,int map[][MAXN],int source,int sink)//参数含义：结点数量 网络 源点 汇点
{
	int my_queue[MAXN],queue_first,queue_end;//数组做队列 实现BFS搜索路径 
	int pre[MAXN],min_flow[MAXN];//记录结点的父节点 当前路径中最小的一段的值，也即限制值
	int flow[MAXN][MAXN];//记录当前网络中的流
	int ans=0;//最终结果
	memset(flow,0,sizeof(flow));
	while(1)//一直循环，直到不存在增广路径
	{
		queue_first=0;//初始化队列
		queue_end=0;
		my_queue[queue_end++]=source;
		memset(pre,-1,sizeof(pre));
		min_flow[source]=INF;
		pre[source]=-2;//源点的父节点需特殊标示
		while(queue_first<queue_end)//BFS寻找增广路径
		{
			int temp=my_queue[queue_first++];//出队列
			for(int i=0;i<num;i++)//由结点temp往外扩展
			{
				if(pre[i]==-1&&flow[temp][i]<map[temp][i])//当结点i还未被探索到，并且还有可用流量
				{	
					my_queue[queue_end++]=i;//加入队列
					pre[i]=temp;//标示父节点
					min_flow[i]=MIN(min_flow[temp],(map[temp][i]-flow[temp][i]));//求得min_flow
				}
			}
			if(pre[sink]!=-1)//sink的父节点不为初始值，说明BFS已经找到了一条路径
			{
				int k=sink;
				while(pre[k]>=0)
				{
					flow[pre[k]][k]+=min_flow[sink];//将新的流量加入flow
					flow[k][pre[k]]=-flow[pre[k]][k];
					k=pre[k];
				}
				break;
			}
		}
		if(pre[sink]==-1) return ans;//不存在增广路径，返回
		else ans+=min_flow[sink];
	}	
}
int main()
{
	int m,n;
	while(cin>>n>>m)
	{
		int a,b,cost;
		memset(map,0,sizeof(map));
		for(int i=0;i<n;i++)
		{
			cin>>a>>b>>cost;
			map[a-1][b-1]+=cost;
		}
		cout<<max_flow(m,map,0,m-1)<<endl;
	}
	return 0;
}