无向图的最小费用最大流问题 UVa 10594 - Data Flow
- 题目链接:UVa10594-Data Flow
- 预备知识:最大流问题,增广路算法,有向图的最小费用最大流问题。
- 问题说明:把物品从结点s(称为源点)运送至结点t(称为汇点),连接结点u和结点v的无向边上有两个二元组(x,y)和(x’,y’),x表示边u->v的最大运送能力,y表示边u->v运送单位物品的花费,x’表示边v->u的最大运送能力,y’表示边v->u运送单位物品的花费(其中,x可以等于x’,y可以等于y’)。寻找总流量最大的前提下(或者把结点s上的物品全部运送至结点t),总费用最小的流。
- 算法思想:
1、在源点s处增加一个”超级源点S”,在汇点t处增加一个”超级汇点T”,其中S->s,T->t,且这两条边运送单位物品的花费为0。
2、最大流:残量网络中一条从s到t的有向道路对应原图中的一条增广路,求出该道路中所有残量的最小值chang[t],把该道路中所有边的当前流量(若从零流开始,则所有边的当前流量为0)增加chang[t],即求出一条从s到t的有向道路的最大流,依次将从s到t的所有有向道路的最大流求出。
3、最小费用最大流:只要初始流是该流量下的最小费用可行流,且每次增广后的新流都是新流量下的最小费用流即可。 - 注意:无向图的最小费用最大流问题,有向图的最小费用最大流问题,有什么区别呢?答案很简单,每条无向边u-v,看成两条相互独立的有向边u->v和v->u。反映在代码中则为:Add_Edge(u, v, cap, cost) 以及 Add_Edge(v, u, cap’, cost’)。每条有向边由正向弧和反向弧组成,因此,无向边u-v可表示为:u->v的正向弧和反向弧,v->u的正向弧和反向弧,一共四条弧。Edges存储弧信息,所存弧数为原无向图边数的四倍,一条无向边由两条有向边组成,每条有向边由正向弧(正向弧为这条边本身)和反向弧组成。
附录代码,可以直接运行得到结果
/**********************无向图的最小费用最大流问题************************/
#define _CRT_SECURE_NO_WARNINGS
#include <queue>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef struct
{
int from, to, cap, flow, cost;
void getinf(int u, int v, int c, int f, int w)
{
from = u; to = v; cap = c; flow = f; cost = w;
}
}Edge; //边信息
typedef struct{
int Path_flow; //路径的最大流量
vector<int> Path; //路径所经过的结点ID
}OnePath; //源点到汇点的一条路径的信息
class MCMF
{
public:
int node_num; //结点个数
int edge_num; //边的个数
vector<Edge> Edges; //存储弧信息,边数的四倍,一条无向边由两条有向边组成,每条有向边由正向弧(正向弧为这条边本身)和反向弧组成
vector<int> *G; //邻接表,G[i][j]表示结点i的第j条边在edges中的序号
int *vis; //标记矩阵,是否在队列中
int *dis; //Bellman-Ford
int *father; //上一条弧
int *change; //可改进量
vector<OnePath> res_path; //保存路径结果,以及对应路径上的总流量
public:
//初始化函数
void init(int node_num, int edge_num)
{
this->node_num = node_num;
this->edge_num = edge_num;
this->G = new vector<int> [node_num];
this->vis = new int [node_num];
this->dis = new int [node_num];
this->father = new int [node_num];
this->change = new int [node_num];
}
//存储边信息,一条有向边的正向弧和反向弧保存在一起,即ID为0和1的弧互为反向弧,ID为2和3的弧互为反向弧...弧i的反向弧为i^1,其中^为二进制异或运算符
void Add_Edge(int from,int to,int cap,int cost)
{
Edge edge;
edge.getinf(from, to, cap, 0, cost);
this->Edges.push_back(edge); //正向弧
edge.getinf(to, from, 0, 0, -cost);
this->Edges.push_back(edge); //反向弧
int len = Edges.size();
this->G[to].push_back(len-1);
this->G[from].push_back(len-2);
}
//BellmanFord算法,最小费用最大流
bool BellmanFord(int s, int t, int& flow, int& cost)
{
for(int i=0; i<node_num; i++)
this->vis[i] = 0;
for(int i=0; i<node_num; i++)
this->dis[i] = INF;
dis[s] = 0;
vis[s] = 1;
father[s] = -1;
change[s] = INF;
queue<int> q;
q.push(s);
while( !q.empty() )
{
int u = q.front();
q.pop();
vis[u] = 0;
for(int i=0; i<G[u].size(); i++)
{
Edge& e = Edges[G[u][i]];
if( e.cap>e.flow && dis[e.to]>dis[u]+e.cost )
{
dis[e.to] = dis[u] + e.cost;
father[e.to] = G[u][i];
change[e.to] = min(change[u], e.cap-e.flow);
if(vis[e.to] == 0)
{
vis[e.to] = 1;
q.push(e.to);
}
}
}
}
if(dis[t] == INF)
return false;
flow += change[t];
cost += dis[t]*change[t];
//change[t]为当前路径的总流量
OnePath temp_one_path;
temp_one_path.Path_flow = change[t];
for(int u = t; u!=s ; u = Edges[father[u]].from)
{
Edges[father[u]].flow += change[t];
Edges[father[u]^1].flow -= change[t];
//u即为路径上的点,此处是反向的
if(u==t)
continue;
else
temp_one_path.Path.push_back(u);
}
res_path.push_back(temp_one_path);
return true;
}
//最小费用最大流
//maxflow:需要从源点s运送至汇点t的全部物品。当问题为计算从s到t的最大流时,不需要maxflow;当问题为将全部物品maxflow从s运送至t时,需要maxflow。
int MinCostMaxFlow(int s, int t, int maxflow)
{
int flow = 0, cost = 0;
while(BellmanFord(s, t, flow, cost));
if(flow < maxflow)
return -1;
else
return cost;
}
//析构函数释放内存
~MCMF()
{
Edges.clear();
for(int i=0; i<node_num; i++)
G[i].clear();
delete [] G;
delete [] vis;
delete [] dis;
delete [] father;
delete [] change;
}
};
void main()
{
MCMF mcmf_sample;
int node_num, edge_num; //输入结点个数(包含源点和汇点),无向边的个数
cout << "input node_num and edge_num: ";
cin >> node_num >> edge_num;
mcmf_sample.init(node_num+2, edge_num);
int from, to, cap01, cost01, cap02, cost02; //输入每条边的信息:起点,终点,边的最大运送能力,单位花费
for(int i=0; i<edge_num; i++)
{
cout << "input from, to, cap, cost, cap', cost':" << endl;
cin >> from >> to >> cap01 >> cost01 >> cap02 >> cost02;
mcmf_sample.Add_Edge(from, to, cap01, cost01);//有向边u->v
mcmf_sample.Add_Edge(to, from, cap02, cost02);//有向边v->u
}
int s, t; //源点,汇点
int maxflow; //maxflow:需要从源点s运送至汇点t的全部物品。当问题为计算从s到t的最大流时,不需要maxflow;当问题为将全部物品maxflow从s运送至t时,需要maxflow。
cout << "input s, t, maxflow: ";
cin >> s >> t >> maxflow;
int S = node_num; //超级源点
int T = node_num+1; //超级汇点
mcmf_sample.Add_Edge(S, s, maxflow, 0);
mcmf_sample.Add_Edge(t, T, maxflow, 0);
cout << "totle cost: " << mcmf_sample.MinCostMaxFlow(S, T, maxflow) << endl; //输出最小费用
for(vector<OnePath>::iterator it=mcmf_sample.res_path.begin(); it!=mcmf_sample.res_path.end(); it++)
{
cout << "current path flow: " << it->Path_flow << endl; //输出当前路径的总流量
cout << "current path flow: "; //输出当前路径
for(int i=it->Path.size()-1; i>=0; i--)
cout << it->Path[i] << ' '; //输出s到t的路径
cout << endl;
}
}