文献阅读01-1-空间众包-最大化任务分配数量-代码实现

代码介绍：

       文件数据格式：点的数量，边的数量，源点序号，汇点序号

                每条边：起点，终点，容量

从文件中读取数据，构建网络流图，使用dinic算法求解最大流，采用数组邻接表存储数据。

 

求最大流过程：不断找一条源点到汇点的路径，若有，找出增广路径上每一段权值的最小值，然后构建残余网络。再在残余网络上寻找新的路径，再依据路径的最小值，构建新的残余网络，再寻找新的路径...直至某个残余网络找不到从源点到汇点的路径为止，最大流即为每次最小值之和。

 

Dinic算法：

       先使用宽度优先搜索，根据源点到每个点的最短距离(边数)不同，对每个点进行分层，只要进行到计算出汇点的层次数，即为分层成功。

       之后利用深度优先搜索从前一层向后一层反复寻找增广路径，寻找的增广路径要求满足所有的点分别属于不同的层，且点应满足depp_v=depp_v-1+1。DFS过程中，进行到了汇点，则说明找到了一条增广路径，此时对总流量进行增加，并消减增广路径各边的容量，并添加反向边，即进行增广。找到一条增广路径后，回溯继续寻找下一个增广路径。

       DFS结束后，对残余网络再次进行分层，当分层操作无法算出汇点的层次是，即求得最大流。

　　 头文件：

#include <queue>
#include <fstream>
#include <iostream>
#include <string>
using namespace std;
const int inf = 0x3f3f3f3f;
const int worker_number = 5000;
const int task_number = 5000;

struct Edge
{
    int to;
    int next;
    int cap;
};

class Graph
{
private:
    int src;//源点
    int dst;//汇点
    int edge_num;//边数
    int note_num;//点数
    int num;
    int max_flow;
    int head[worker_number + task_number + 3];
    int cur[worker_number + task_number + 3];
    int level[worker_number + task_number];
    Edge edges[worker_number + task_number];
    queue<int> Q;
    void add_edge(int from,int to,int dis);
    bool bfs(int begin, int end);
    int dfs(int now,int flow);
    

public:
    Graph(int n = 0, int m = 0, int s = 0, int d = 0);
    void read(string file_name);//从文件中读取数据
    int Dinic();
};

Graph::Graph(int n,int m,int s,int d)
{
    this->note_num = n;
    this->edge_num = m;
    this->src = s;
    this->dst = d;
    this->max_flow = 0;
    this->num = -1;

    memset(this->head, -1, sizeof(this->head));
    memset(this->cur, -1, sizeof(this->cur));
    memset(this->level, -1, sizeof(this->level));
}

void Graph::add_edge(int from,int to,int dis)
{
    this->edges[++this->num].next = this->head[from];
    this->edges[this->num].to = to;
    this->edges[this->num].cap = dis;
    this->head[from] = this->num;    
}

void Graph::read(string file_name)
{
    ifstream fin(file_name);
    int x, y, z;

    if (fin.good())
    {
        //n结点数，m边数，s源点，d汇点
        fin >> this->note_num >> this->edge_num >> this->src >> this->dst;
        this->num = -1;

        for (int i = 0;i < this->edge_num;i++)
        {
            //边：起点，终点，容量
            fin >> x >> y >> z;

            this->add_edge(x, y, z);//添加边
            this->add_edge(y, x, 0);//添加反向边
        }
    }
    else
    {
        cout << "文件打开失败！" << endl;
        exit(0);
    }

    fin.close();
}

//利用bfs进行分层
bool Graph::bfs(int begin, int end)
{
    memset(this->level, -1, sizeof(this->level));//更新层次，对残余网络进行分层
    int now;//当前点

    while (!this->Q.empty())this->Q.pop();
    this->level[begin] = 0;//起点深度为0
    this->Q.push(begin);

    while (!this->Q.empty())
    {
        now = this->Q.front();
        this->Q.pop();

        for (int i = this->head[now];i != -1;i = this->edges[i].next)
        {
            //如果该点没有被标记层次并且该边的流量不为零
            if (this->level[this->edges[i].to] == -1 && this->edges[i].cap)
            {
                this->level[this->edges[i].to] = this->level[now] + 1;
                this->Q.push(this->edges[i].to);
            }
        }
    }
    
    return this->level[this->dst] != -1;//若没有到达汇点，则返回false
}

//flow为源点到now的路径中的最小边权
int Graph::dfs(int now, int flow)
{
    if (now == this->dst)return flow;//如果当前点为汇点，则返回flow

    int detla = flow, d, f;
    for (int i = this->cur[now];i != -1;i = this->edges[i].next)
    {
        //寻找路径时，点要属于不同的层次并且边为通
        if (this->level[this->edges[i].to] == (this->level[now] + 1) && (this->edges[i].cap > 0))
        {
            //向下递归，求后续结点的最大流量，即最小边权
            this->cur[now] = this->edges[i].next;
            d = (detla < this->edges[i].cap) ? detla : this->edges[i].cap;
            f = this->dfs(this->edges[i].to, d);

            this->edges[i].cap -= f;
            //处理反向边，存边时从0开始，边和其反向边相邻
            this->edges[i ^ 1].cap += f;
            detla -= f;//更新本节点的残余量
            //若本节点的残余量消耗完，则返回
            if (detla == 0)break;
        }
    }

    return flow - detla;//返回该点已经被允许流过的流量
}

int Graph::Dinic()
{
    while (this->bfs(this->src, this->dst))
    {
        for (int i = 1;i <= this->note_num;i++)this->cur[i] = this->head[i];
        this->max_flow += this->dfs(this->src, inf);
    }

    return this->max_flow;
}

　　源文件：

#include "标头.h"

int main()
{
    Graph G;
    string file_name;

    cout << "请输入存储数据的文件" << endl;
    cin >> file_name;

    G.read(file_name);
    cout << "最大流：" << G.Dinic() << endl;

    return 0;
}