无向图的最小费用最大流问题 UVa 10594 - Data Flow

无向图的最小费用最大流问题 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;
    }
}