关于网络流算法(2)

了解最大流解法：

网络流的相关基础知识很容易获得，详细的有《算导》，简单的有刘汝佳《算法竞赛入门》，这里选用的也是刘的书从Page207开始的内容。

这里要补充一些值得注意的基础：

• 最大流问题中的三个约束条件：容量限制条件、斜对成性条件、流量平衡条件；
• 网络流问题中边（Edge）的有向性。

1.1 BFS 算法

因为《算法竞赛入门》中的E-K算法是基于BFS遍历方法的，说是很容易找到让DFS很慢的例子所以改为BFS，自己又已经把以前看的书全部忘记了，无奈只能开这个1.1，非常惭愧。

BFS，Broad First Search，广度优先搜索算法，或，层序遍历算法。算法的理解部分只需要记住一句话：依次访问已经访问过的顶点的未访问临接顶点。、

实现层面，由于对于节点的遍历是顺序的、FIFO的，所以使用队列辅助进行顺序控制。

用邻接矩阵实现的BFS算法代码如下：

void bfs(int s, bool edge[][maxn])
{
    visit(s,visited);
    q.push(s);
    while(!q.empty()) 
    {
        s = q.front();
        q.pop();
        for(int w = next_Neighbor(s,0,edge);w>=0;w=next_Neighbor(s,w,edge))
        {
            if(!visited[w])
            {
                visit(w,visited);
                q.push(w);
            }            
        }
    }
}

1.2 Edmonds-Karp 算法（增广路算法）

E-K算法是最基础的最大流算法，主要思想是从最小流状态迭代增加流量，直到不能继续增加达到稳态。

其中迭代的过程称为“增广”，即对于某个s到t的流量通路，如果其上各边流量都没有达到各自的容量（流量上限），那么就在这条通路上增加这些边中的最小残量单位的流量。

E-K算法涉及到一个反向更新流量的问题，需要在代码中自己体会。

这里我贴个随笔，觉得写得很接地气。这篇文章中关于反向边权值的表达是“退回”，这个在《算法竞赛入门》也有部分表述，可以结合在一起看，另外补充一个比较全面的教程。

使用邻接矩阵实现的代码如下：

/*
不断寻找残量网络中汇点的可达路径，
可达路径中的各条边每次迭代减少可达路径中所有边 capacity 最小值直到在残量网络中汇点不可达 
*/

#include<iostream>
#include<queue>
using namespace std;
const int arrsize = 10;
const int maxdata = INT_MAX;

int cap[arrsize][arrsize];        //表示两个结点之间的最大可用流量 
int flow[arrsize],pre[arrsize];    //表示从原点到index结点的当前剩余可用流量 
queue<int> q;


int BFS(int src, int des)
//BFS函数，寻找可行通路 
{
//cout<<endl<<"进入BFS"<<endl; 
    while(!q.empty())
        q.pop();
    
    memset(pre,-1,sizeof(pre));
    
    pre[src] = 0;
    flow[src] = maxdata;
    
    q.push(src);
    while(!q.empty())
    {
        int index = q.front();
        q.pop();
        
        if(index == des)
            break;    
        //层序寻找下一个可行通路
        for(int i=0;i<arrsize;i++)
        {
            if(i!=src && cap[index][i]>0 && pre[i]==-1)
            {
                pre[i]=index;                            //  保存当前结点的父结点 
                flow[i]=min(cap[index][i],flow[index]);    //★更新从源结点到当前结点的当前剩余可用流量 
                q.push(i);
            }
        }
    }
    if(pre[des]==-1)
        return -1;
    else
        return flow[des];
}

int maxFlow(int src, int des)
//s最大流函数，迭代残量网络 
{
    int increasement,sumfolw = 0;
    while((increasement = BFS(src,des)) != -1)
    {        
        int cur = des;
        while(cur != src)
        {
            int last = pre[cur];
            cap[last][cur] -= increasement;
            cap[cur][last] += increasement;
            cur=last; 
        }
        sumfolw += increasement;
    }
    return sumfolw;
}



int main()
{
    freopen("C:\Users\lenovo\Desktop\工作\华为挑战赛\数据_E-K.txt","r",stdin);
    
    for(short i=0;i<arrsize;i++)
    for(short j=0;j<arrsize;j++)
        cin>>cap[i][j];
    
    //打印邻接矩阵 
    cout<<"邻接矩阵(有向图)为："<<endl;
    for(short i=0;i<arrsize;i++)
    for(short j=0;j<arrsize;j++)
    {
        cout<<cap[i][j]<<" ";
        if(j==arrsize-1)
            cout<<endl;
    }
    cout<<endl;
    
    memset(flow,0,sizeof(flow)); 
    cout<<"最大流为："<<maxFlow(0,3)<<endl<<endl;

    fclose(stdin);
}

 1.3 Bellman-Ford / SPFA 算法

由于在费用流中可能出现的负费用情况，必须考虑对含有负权边的有向图进行寻路的算法，一般采用Dijikstra或者Bellman-Ford算法，在这里也补充讨论下Bellman-Ford算法（下称B-F算法）。

基本的算法理解这篇文章对B-F算法介绍得已经很详细，另外《算导》Page379有更详细的证明可以参考 。在刘汝佳的《算法竞赛入门》中有进阶的算法实现，即使用FIFO队列辅助剪枝（或SPFA），这个方法在这篇文章中解释得很详细。这里附上两段自己实现的代码。

/*
B-F算法是一个有固定迭代次数的寻路算法，在 m*n 次试探迭代中寻找更短路径（即寻找 A+B<C ）
这个算得特点是可以判断负环路，因为算法的收敛过程是定长的，所以在完成迭代部分后很方便找到图中的负环而不会陷入其中。 
*/

#include<iostream>  
#include<cstdio>  
using namespace std;
const int arrsize=100;
const int maxnum=INT_MAX;

typedef struct Edge
{
    int u,v;
    int evalue;
}Edge;

Edge edge[arrsize];
int dist[arrsize],pre[arrsize];

bool bellmanFord(int src, int dist[], int nodenum, int edgenum, Edge edge[])
{
    for(int i=1; i<=nodenum; i++)
        dist[i]=maxnum;
    dist[src]=0;
    
    for(int i=1; i<=nodenum-1; i++)
    for(int j=1; j<=edgenum; j++)
    {
        if(dist[edge[j].v] > dist[edge[j].u] + edge[j].evalue)
        {
            dist[edge[j].v] = dist[edge[j].u] + edge[j].evalue;
            pre[edge[j].v] = edge[j].u;
        }
    }    
    
    for(int i=1;i<=edgenum;i++)
    {
        if(dist[edge[i].v] > dist[edge[i].u] + edge[i].evalue)
            return false;
        return true;
    }
} 

void printPath(int dest)
{
    while(pre[dest]!=dest)
    {
        cout<<dest<<" -> ";
        dest=pre[dest];
    }
    if(pre[dest]==dest)
        cout<<dest;
    cout<<endl<<endl;
}

int main()
{
    freopen("C:\Users\lenovo\Desktop\工作\华为挑战赛\数据_B-F.txt","r",stdin);

    int nodenum,edgenum,src;
    
    cin>>nodenum>>edgenum>>src;
    for(int i=1; i<=edgenum; i++)
        cin>>edge[i].u>>edge[i].v>>edge[i].evalue;
    pre[src]=src;
    
    if(bellmanFord(src,dist,nodenum,edgenum,edge))
    {
        for(int i=1; i<=nodenum; i++)
        {
            cout<<"Distance of Node "<<i<<" : "<<dist[i]<<endl;
            printPath(i);
        }
                    
    }
    
    fclose(stdin);
}

/*
模型理解： 
B-F算法的进阶版本是使用一个FIFO队列维护最短路迭代过程，这样做的好处是可以屏蔽循环中的盲目试探：采用类似
层序遍历的方法来试探更新最短路径，在这个过程中不会浪费资源考虑不在当前遍历层次上的结点（或者边），而这种
遍历又可以保证对图搜索的完整性，每个结点都可以多次入队——这是根据当前遍历结点的出边来决定的。
这个方法也被称为SPFA算法。 
模型实现：
数据结构上由于遍历需要，要新增 firstEdge数组、 inQueue数组、 inQueueTimes数组；
判断负环的依据是负环会被重复遍历，其上的结点将多次入队，当有结点的入队次数大于 vertexNum-1（已经试探图中
所有其他结点与之相连的边）则该结点一定存在于一个负环之中。 
*/

#include<iostream>
#include<queue>
using namespace std;
const int arrsize=100;
const int INF=INT_MAX;

typedef struct Edge
{
    int u,v;
    int weight;
    int cost;
    int nextEdgeID;
}Edge;

Edge edge[arrsize];
int firstEdge[arrsize];        //保存结点的第一出边 
int pre[arrsize],dist[arrsize];
bool inQueue[arrsize];        //记录结点的是否已经入队 
int inQueueTimes[arrsize];    //记录结点的已经入队次数 
queue<int> q;
int vertexNum,edgeNum,src;

bool bellmanFord(int src, int vertexNum, int edgeNum, Edge edge[], int dist[],bool inQueue[], int inQueueTimes[])
{
    for(int i=1; i<=vertexNum; i++)
        dist[i]=INF;
    dist[src]=0;
    
    memset(inQueue,false,sizeof(inQueue));
    memset(inQueueTimes,0,sizeof(inQueueTimes));
    
    memset(pre,-1,sizeof(pre));
    pre[src]=src;
        
    
    while(!q.empty())
        q.pop();
    q.push(src);
    inQueueTimes[src]++;
    if( inQueueTimes[src]>vertexNum )
        return false;
    
    while(!q.empty())
    {
        int cur=q.front();
        q.pop();
        inQueue[cur]=false;
        
        for(int e=firstEdge[cur]; e!=-1; e=edge[e].nextEdgeID)
        if( dist[edge[e].v] > dist[cur] + edge[e].weight )
        {
            dist[edge[e].v] = dist[cur] + edge[e].weight;
            pre[edge[e].v]=cur;
            if( !inQueue[edge[e].v] )
            {
                q.push(edge[e].v);
                inQueueTimes[edge[e].v]++;
                if( inQueueTimes[edge[e].v]>vertexNum )
                    return false;
                inQueue[edge[e].v]=true;
            }
        }
    }
    return true;
}

void printPath(int vertex)
{
    while(pre[vertex]!=vertex)
    {
        cout<<vertex<<" -> ";
        vertex=pre[vertex];
    }
    if( pre[vertex]==vertex )
        cout<<vertex;
    cout<<endl<<endl;
}

int main()
{
    freopen("C:\Users\lenovo\Desktop\工作\华为挑战赛\数据_最小费用最大流.txt","r",stdin);
    
    cin>>vertexNum>>edgeNum>>src;
    
    //初始化edge数组 
    for(int i=1; i<=edgeNum; i++)
        cin>>edge[i].u>>edge[i].v>>edge[i].weight>>edge[i].cost>>edge[i].nextEdgeID;
    
    //初始化 firstEdge 数组 
    memset(firstEdge,-1,sizeof(firstEdge));
    for(int i=1; i<=edgeNum; i++)
    {
        if( firstEdge[edge[i].u] == -1 )
            firstEdge[edge[i].u] = i;
    }
    
    //运行 B-F算法 并输出结果 
    if( bellmanFord(src, vertexNum, edgeNum, edge, dist, inQueue, inQueueTimes) )
    {
        for(int i=1; i<=vertexNum; i++)
        {
            cout<<"Distance of Node "<<i<<" : "<<dist[i]<<endl;
            printPath(i);
        }
    }
        
    fclose(stdin);
}

1.4 MCMF算法

算法思想简单说就是在证明了最小费用最大流路径是由残量网络中费用最小的残量路径增广而来的基础上，使用 Dijikstra / Bellman-Ford / SPFA 算法查找最小路，并用 Edmonds-Karp 算法中的增广方法更新网络。

同学 netcan 大神推荐了一些很有效的模板，非常感激。