最小费用流 用SPFA实现

/*
（1）找到一条从源点到达汇点的“距离最短”的路径，“距离”使用该路径上的边的单位费用之和来衡量。 
（2）然后找出这条路径上的边的容量的最小值f，则当前最大流max_flow扩充f，同时当前最小费用min_cost扩充 f*min_dist(s,t)。 
（3）将这条路径上的每条正向边的容量都减少f，每条反向边的容量都增加f。 
（4）重复（1）--（3）直到无法找到从源点到达汇点的路径。
*/
#define INF 0x3f3f3f3f;
const int N=1005;
struct edge{
	int to,cap,cost,rev;//终点、容量、费用、反向边的位置
};
int V;
vector<edge>vec[N];
int dis[N],vis[N];
int preV[N],preE[N];
void add_edge(int from,int to,int cap,int cost){
	vec[from].push_back((edge){to,cap,cost,vec[to].size()});
	vec[to].push_back((edge){from,0,-cost,vec[from].size()-1});
}
bool spfa(int s,int t){
	memset(preV,-1,sizeof(preV));
	memset(dis,INF,sizeof(dis));
	dis[s]=0;
	queue<int>que;
	que.push(s);
	while(!que.empty()){
		int now=que.front();
		que.pop(); vis[now]=false;
		for(int i=0;i<vec[now].size();i++){
			edge &e=vec[now][i];
			if(dis[now]+e.cost<dis[e.to]&&!vis[e.to]&&e.cap>0){
				dis[e.to]=dis[now]+e.cost;
				preV[e.to]=now;
				preE[e.to]=i;
				que.push(e.to);
				vis[e.to]=true;
			}
		}
	}
	if(preV[t]==-1) return false;
	return true;
}
int min_cost_flow(int s,int t){
	int cost=0;
	int flow=0;
	while(spfa(s,t)){
		int f=INF;
		for(int v=t;v!=s;v=preV[v]){
			f=min(f,vec[preV[v]][preE[v]].cap);
		}
		flow+=f;
		cost+=dis[t]*f;
		for(int v=t;v!=s;v=preV[v]){
			edge &e=vec[preV[v]][preE[v]];
			e.cap-=f;
			vec[v][e.rev].cap+=f;
		}
	}
	return cost;
}