ZOJ3231 Apple Transportation(最小费用流)

题目给你一棵苹果树，然后每个结点上有一定的苹果树，你要将苹果运输达到某个状态，使得均方差最小。 将苹果x个从a->b的花费是x*w，w是边权。

当时比赛的时候想的就是，最后达到的状态一定是sum/n，但是除不尽的时候可能有些会多出1，譬如7个苹果，3个结点，最后的平衡一定是2,2,3。 问题就是我们需要考虑的是哪些结点是3和2，我就在这里卡住了。赛后看了一些题解，其实可以把这个看成是树dp，dp[v][n]表示结点v下有n个多出来是1的结点，然后做一个树dp,我之所以没有这么想是考虑复杂了，我是直接算从(u,v)的路径长度乘以x，但实际上没必要，因为传输的时候必然是经过父边来传输的。树dp是我的弱项，所以在这里就不写了。

然后看了一下别人的解题报告，发现原来有费用流的做法，于是我马上就恶补了一下相关的知识点。其中下面的博客介绍了建图的方法。http://blog.csdn.net/qq564690377/article/details/8870587

然后就是关于对费用流算法的消化的问题了，找了份师兄AC的代码拿来学习了一下。个人理解费用流是这么做的，每次我们利用spfa找出一条最短路（最少花费的路）从source 到sink的，然后对沿途的边求一下容量的最小值，这就是这条边可以流过的最大的流，然后我们就用花费＊最大流，然后扣掉流量，反向边加上流量。但是SPFA的时候会有可能存在负环的时候，所以要用一个in数组记录入队次数，大于顶点数就跳出。留两份代码当模板也当作学习吧。！

此外有些还是最大费用最大流，处理的方法好像就是将费用取负数就可以了，最后结果取个反。网络流建模是个神奇的东西，包括像SAP最大流我改天也是要学学的，但貌似不怎么好理解的样子，所以暂时我还是用Dicnic代替一下先。。。－ －0

#pragma warning(disable:4996)
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#define ll long long
#define maxn 250
#define maxe 1000
#define inf 0x3f3f3f3f
using namespace std;

struct Edge{
	int u, v, nxt, cap, cost;
}edge[maxe];
int head[maxn];
int n, m;

struct MinCostMaxFlow
{
	queue<int> que;
	int add; // edges number
	int vn; // total vertex number
	int cost[maxn], in[maxn], pre[maxn];
	bool vis[maxn];
	void init(){
		add = 0; vn = n + 5; memset(head, -1, sizeof(head));
		while (!que.empty()) que.pop();
	}
	void insert(int u, int v, int w, int c){
		edge[add].u = u; edge[add].v = v; edge[add].cap = w; edge[add].cost= c;
		edge[add].nxt = head[u]; head[u] = add++;
		edge[add].u = v; edge[add].v = u; edge[add].cap = 0; edge[add].cost = -c;
		edge[add].nxt = head[v]; head[v] = add++;
	}

	bool spfa(int s, int e){
		memset(cost, 0x3f3f3f3f, sizeof(cost));
		memset(in, 0, sizeof(in));
		memset(vis, 0, sizeof(vis));
		cost[s] = 0; pre[s] = -1;
		que.push(s); vis[s] = true; in[s]++;
		while (!que.empty()){
			int u = que.front(); que.pop();
			vis[u] = false;
			for (int i = head[u]; i != -1; i = edge[i].nxt){
				int v = edge[i].v;
				if (edge[i].cap > 0 && cost[v] > cost[u] + edge[i].cost){
					cost[v] = cost[u] + edge[i].cost; pre[v] = i;
					if (!vis[v]){
						que.push(v); vis[v] = true; in[v]++;
						if (in[v] > vn) return false;
					}
				}
			}
		}
		if (cost[e] < inf) return true;
		else return false;
	}
	int mincostmaxflow(int s, int e){
		int mincost = 0, maxflow = 0;
		while (spfa(s, e)){
			int flow = inf;
			for (int i = pre[e]; i != -1; i = pre[edge[i].u]){
				flow = min(flow, edge[i].cap);
			}
			maxflow += flow;
			for (int i = pre[e]; i != -1; i = pre[edge[i].u]){
				edge[i].cap -= flow;
				edge[i ^ 1].cap += flow;
			}
			mincost += cost[e] * flow;
		}
		return mincost;
	}
}net;

int a[maxn];

int main()
{
	while (cin >> n){
		net.init(); int sum = 0;
		for (int i = 1; i <= n; i++) {
			scanf("%d", a + i);
			sum += a[i];
		}
		int avg = sum / n;
		for (int i = 1; i <= n; i++){
			net.insert(0, i, a[i], 0);
			net.insert(i, n + 1, 1, 0);
			net.insert(i, n + 2, avg, 0);
		}
		int ui, vi, wi;
		for (int i = 0; i < n - 1; i++){
			scanf("%d%d%d", &ui, &vi, &wi);
			++ui; ++vi;
			net.insert(ui, vi, inf, wi);
			net.insert(vi, ui, inf, wi);
		}
		net.insert(n + 1, n + 2, sum - avg*n, 0);
		printf("%d\n", net.mincostmaxflow(0, n + 2));
	}
	return 0;
}

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

int n,m;
#define maxn 310
#define maxe 202020
#define INF 1<<30

struct node{
	int u,v,next,w,c;
}edge[maxe];
int head[maxn],add;
inline int min(int a,int b) { return a>b?b:a; }
struct  MinCostMaxFlow
{
	int q[maxn],front,rear,add,vn;
	bool vis[maxn];
	int cost[maxn]; int in[maxn],pre[maxn];
	void init()
	{
		add=0;
		memset(head,-1,sizeof(head));
		vn=n+10;
	}
	void insert(int u,int v,int w,int c)
	{
		edge[add].u=u; edge[add].v=v; edge[add].w=w; edge[add].c=c;
		edge[add].next=head[u]; head[u]=add++;
		edge[add].u=v; edge[add].v=u; edge[add].w=0; edge[add].c=-c;
		edge[add].next=head[v]; head[v]=add++;
	}

	bool spfa(int s,int e)
	{
		int i,j;
		for(i=0;i<=vn;i++)
			cost[i]=INF;
		memset(vis,0,sizeof(vis));
		memset(in,0,sizeof(in));
		cost[s]=0; pre[s]=-1;
		front=0,rear=1;
		q[front]=s;
		vis[s]=true; in[s]++;
		while(front!=rear){
			int u=q[front++],v;
			front%=maxn; vis[u]=false;
			for(i=head[u];i!=-1;i=edge[i].next)
			{
				v=edge[i].v;
				if(edge[i].w>0&&cost[v]>cost[u]+edge[i].c)
				{
					cost[v]=cost[u]+edge[i].c;
					pre[v]=i;
					if(!vis[v])
					{
						q[rear++]=v;
						rear%=maxn;
						vis[v]=true; in[v]++;
						if(in[v]>vn) return false;
					}
				}
			}
		}
		if(cost[e]<INF) return true;
		else return false;
	}
	int mincostmaxflow(int s,int e)
	{
		int mincost=0,i,j,maxflow=0;
		while(spfa(s,e)){
			int flow=INF;
			for(i=pre[e];i!=-1;i=pre[edge[i].u])
				flow=min(flow,edge[i].w);
			maxflow+=flow;
			for(i=pre[e];i!=-1;i=pre[edge[i].u]){
				edge[i].w-=flow;
				edge[i^1].w+=flow;
			}
			mincost+=cost[e]*flow;
		}
		return mincost;
	}
}net;
int val[maxn];
int main()
{
	int i,j,s,e,sum,t,u,v,w;
	while(scanf("%d",&n)!=EOF)
	{
		for(sum=0,i=1;i<=n;i++)scanf("%d",&val[i]),sum+=val[i];
		int av=sum/n;
		net.init();
		s=0;
		for(i=1;i<=n;i++) net.insert(s,i,val[i],0);
		t=n+1,e=n+2;
		for(i=1;i<=n;i++) net.insert(i,t,1,0),net.insert(i,e,av,0);
		for(i=1;i<n;i++)
		{
			scanf("%d %d %d",&u,&v,&w);
			u++; v++;
			net.insert(u,v,INF,w);
			net.insert(v,u,INF,w);
		}
		net.insert(t,e,sum-av*n,0);
		printf("%d\n",net.mincostmaxflow(s,e));
	}
	return 0;
}