最小费用最大流；最小费用路算法；

#include <iostream> #include <queue> using namespace std; //SPFA()使用#define MAX 100000 //const int numV=5; //SPFA记录是否已访问 bool inQueue[numV]; //路径前驱结点数组int preV[numV];//路径上最小残流int preF[numV];//顶点到源的最小耗费int cost[numV];//由用户输入的边单位流量耗费值int cPerF[numV][numV];//流网络 struct { int c; //容量 int f; //流 }flowNet[numV][numV]; /*****************************************************************///SPFA()在残留网络中，找源点s到汇点t的最小耗费路径(耗费有正负,能实现费用减小,因为给负费用+,相当于给正费用-)void SPFA(){memset(inQueue,0,sizeof(inQueue)); //队列标记清空for(int i=0;i<numV;++i){preV[i]=-1; //清空前驱数组cost[i]=MAX; //设置最小耗费数组}cost[0]=0; //设置源点最小耗费为0preF[0]=MAX; //源点入队列queue<int> costQ;costQ.push(0);inQueue[0]=true;int u,v;//计算单源最小耗费路径while(!costQ.empty()){u=costQ.front();costQ.pop();inQueue[u]=false;for(v=0;v<numV;++v){if((flowNet[u][v].c-flowNet[u][v].f)>0&&(cost[v]>cost[u]+cPerF[u][v])){cost[v]=cost[u]+cPerF[u][v];preV[v]=u;preF[v]=preF[u]<(flowNet[u][v].c-flowNet[u][v].f) ? preF[u]:(flowNet[u][v].c-flowNet[u][v].f);if(inQueue[v]==false){inQueue[v]=true;costQ.push(v);}}}}}/*求解最小费用路:步骤0：初始可行0流 02 步骤1：如果不存在最小费用流，则计算结束，已经找到最小费用流；否则，用最短路算法(由于存在负圈，只能采用SPFA或者Bellman-Ford算法)在残留网络中找到源点到终点的最小费用可增广路，转步骤2。 03 步骤2：沿找到的最小费用可增广路增流，并转步骤1 。 */int minCostPath(){while(true){SPFA();if(-1==preV[numV-1]){break;}else{int now=numV-1;int pre=preV[numV-1];int minF=preF[numV-1];while(-1!=pre){flowNet[pre][now].f+=minF;flowNet[now][pre].f-=minF;now=pre;pre=preV[now];}}}int totalCost=0;for(int i=0;i<numV;++i){for(int j=0;j<numV;++j){if(flowNet[i][j].f>0){totalCost+=flowNet[i][j].f*cPerF[i][j];}}}return totalCost;}int main() { for(int i=0;i<numV;++i) { for(int j=0;j<numV;++j) { cin>>flowNet[i][j].c; //有边为实际容量,无边为0，flowNet(u,u)=0 flowNet[i][j].f=0; } } for(int i=0;i<numV;++i) { for(int j=0;j<numV;++j) { cin>>cPerF[i][j]; //单位耗费:正向边输入正值,负向边输入负值. 无边输入10000 } } cout<<minCostPath()<<endl; return 0; } //给出一个容量全为1，费用有所明显区别的物流示意图//容量矩阵//0 1 1 0 0//0 0 0 0 1//0 0 0 1 0//0 1 0 0 1//0 0 0 0 0 //单位耗费//0 1 1 10000 10000//-1 0 10000 -1 2//-1 10000 0 1 10000//10000 1 -1 0 0//10000 -2 10000 0 0

 

 

每次在残留网络里找一个以边的价值耗费为权值的最短路径（s到t），如果能找到，就给这条路径压入流。

否则，算法结束. 计算所有正流*单位流耗费即得最小耗费最大流.

 

#include <iostream> #include <queue> using namespace std; //SPFA()使用 #define MAX 100000 // const int numV=9; //SPFA记录是否已访问 bool inQueue[numV]; //路径前驱结点数组 int preV[numV]; //路径上最小残流 int preF[numV]; //顶点到源的最小耗费 int cost[numV]; //由用户输入的边单位流量耗费值 int cPerF[numV][numV]; //流网络 struct { int c; //容量 int f; //流 }flowNet[numV][numV]; /*****************************************************************/ //SPFA()在残留网络中，找源点s到汇点t的最小耗费路径(耗费有正负,能实现费用减小,因为给负费用+,相当于给正费用-) void SPFA() { memset(inQueue,0,sizeof(inQueue)); //队列标记清空 for(int i=0;i<numV;++i) { preV[i]=-1; //清空前驱数组 cost[i]=MAX; //设置最小耗费数组 } cost[0]=0; //设置源点最小耗费为0 preF[0]=MAX; //源点入队列 queue<int> costQ; costQ.push(0); inQueue[0]=true; int u,v; //计算单源最小耗费路径 while(!costQ.empty()) { u=costQ.front(); costQ.pop(); inQueue[u]=false; for(v=0;v<numV;++v) { if((flowNet[u][v].c-flowNet[u][v].f)>0&&(cost[v]>cost[u]+cPerF[u][v])) { cost[v]=cost[u]+cPerF[u][v]; preV[v]=u; preF[v]=preF[u]<(flowNet[u][v].c-flowNet[u][v].f) ? preF[u]:(flowNet[u][v].c-flowNet[u][v].f); if(inQueue[v]==false) { inQueue[v]=true; costQ.push(v); } } } } } /*求解最小费用路: 步骤0：初始可行0流 02 步骤1：如果不存在最小费用流，则计算结束，已经找到最小费用流； 否则，用最短路算法(由于存在负圈，只能采用SPFA或者Bellman-Ford算法)在残留网络中找到源点到终点的最小费用可增广路，转步骤2。 03 步骤2：沿找到的最小费用可增广路增流，并转步骤1 。 */ int minCostPath() { while(true) { SPFA(); if(-1==preV[numV-1]) { break; } else { int now=numV-1; int pre=preV[numV-1]; int minF=preF[numV-1]; while(-1!=pre) { flowNet[pre][now].f+=minF; flowNet[now][pre].f-=minF; now=pre; pre=preV[now]; } } } int totalCost=0; for(int i=0;i<numV;++i) { for(int j=0;j<numV;++j) { if(flowNet[i][j].f>0) { totalCost+=flowNet[i][j].f*cPerF[i][j]; } } } return totalCost; } int main() { for(int i=0;i<numV;++i) { for(int j=0;j<numV;++j) { cin>>flowNet[i][j].c; //有边为实际容量,无边为0，flowNet(u,u)=0 flowNet[i][j].f=0; } } for(int i=0;i<numV;++i) { for(int j=0;j<numV;++j) { cin>>cPerF[i][j]; //单位耗费:正向边输入正值,负向边输入负值. 无边输入10000 } } cout<<minCostPath()<<endl; return 0; } //容量矩阵 0 60 40 50 0 0 0 0 00 0 0 0 1000 1000 1000 1000 00 0 0 0 1000 1000 1000 1000 00 0 0 0 1000 1000 1000 1000 00 0 0 0 0 0 0 0 200 0 0 0 0 0 0 0 350 0 0 0 0 0 0 0 330 0 0 0 0 0 0 0 340 0 0 0 0 0 0 0 0//单位耗费 0 0 0 0 10000 10000 10000 10000 10000 0 0 10000 10000 2 1 3 2 100000 10000 0 10000 1 3 2 1 100000 10000 10000 0 3 4 1 1 1000010000 -2 -1 -3 0 10000 10000 10000 010000 -1 -3 -4 10000 0 10000 10000 010000 -3 -2 -1 10000 10000 0 10000 010000 -2 -1 -1 10000 10000 10000 0 010000 10000 10000 10000 0 0 0 0 0相当复杂的图,数了半天...也不知道对不对的,结果是122

 

运输问题

有A、B、C三个食品加工厂，负责供给甲、乙、丙、丁四个市场。三个厂每天生产食品箱数上限如下表：
工厂 A B C
生产数 60 40 50
四个市场每天的需求量如下表：
市场 甲 乙 丙 丁
需求量 20 35 33 34
从各厂运到各市场的运输费(元/每箱)由下表给出：

市 场
甲 乙 丙 丁
工
厂 A 2 1 3 2
B 1 3 2 1
C 3 4 1 1
（1）求在基本满足供需平衡的约束条件下使总运输费用最小。
（2）由于某种原因，若A的产品不能运到丁，B的产品不能运到乙，则满足供需平衡的约束下又该怎么安排运输才能使运输费用最小。

 

这是狼大哥的算法，应该就是最小费用最大流的思想：

 

//其实很好理解，我们找张纸，先把数据按照这个格式抄下来

//最后一列是供应数，最后一行是需求数
2    1    3    2    60
1    3    2    1    40
3     4    1    1    50
20    35    33    34

//第一步，找到价格是最低的，1块钱的
//第一行第二列，产是60，需是35，
//把60个产量，拿35个满足之；
//可以分配的产量就是25
//需求就是0了,表就变成了下边

2    1    3    2    [25]
1    3    2    1    40
3     4    1    1    50
20    [0]    33    34

//重复这个过程，直到产方全是0，或者供方全是0
//就完成了。