算法导论 第24章 单源最短路径

最短路径的定义

    在最短路径问题中，给出的是一个带权有向图G=(V,E)，加权函数w:E->R为从边到实值的映射。路径p = <v0,v1,v2...vk>的权是其组成该路径的各边的权值之和：

定义从u到v的最短路径的权为：

从顶点u到v的最短路径为权值等于最短路径权值的任何路径。

单源路径问题的诸多变体

    单终点最短路径：找出每个顶点v指向终点t的最短路径。将原有向图的每条边反向即可变为单源最短路径问题。

    单对顶点之间的最短路径问题：找出顶点u到v的最短路径。若解决了u的单源最短路径问题，那么u到顶点v的最短路径也就迎刃而解了，即使在最坏情况下，在渐进意义上，还没有比这个更好的解决该问题的方法。

    每对顶点间的最短路径：对任意的每对顶点u,v，找出它们之间的最短路径。可以对每个顶点u，来一次单源最短路径算法即可解决该问题。但是根据该问题的结构，可以有更好的方法予以解决，我们将在下一章讨论。

最短路径的最优子结构

    最短路径是具有最优子结构的，因此有些算法采用了贪心（还得具有贪性选择性）和动态规划方法（还得有重叠子问题性质）。下面的定理更加转却的表述了最短路径的最优子结构性质。

负权边和回路

    在单源最短路径问题的某些实例中，可能存在权值为负的边，特别的，如果图中存在着一个负权回路（权值和为负的环），则有些问题需要改变了。若从源点u出发不可达任何负权回路，则对于最短路径的权的定义依然正确，无需改变；但是若能够到达某一负权回路，则最短路径的权值问题就不再成立，此问题将会无解，因为对于该回路上的某顶点v，可以无限制的绕旋该回路，每次都能找到更短的最短路径。

    在我们将要介绍的dijkstra算法中，要求有向图不能包含负权边；Bellman_Ford算法可以允许负权边以及源点不可到达的负权回路的存在，如果存在能够达到的负权回路，则将不能求解，但是可以报告负权回路的存在，并且找出该回路。

最短路径的表示

    类似在第22章 图的基本算法中广度优先搜索BFS使用的，我们将用前驱数组parent来存储各个顶点的前驱。如果顶点v的前驱为u，那么设置parent[v] = u，若其不存在前驱，则设置为v本身。在算法结束之后，我们就可以得到每个顶点v到源点s的最短路径了，只是路径上的顶点是沿着s到v反向排列的。运用这个前驱数组，我们还可以构造出前驱子图Gpi = (Vpi,Epi)，或者叫做最短路径树。如下图阴影部分即为前驱子图或者最短路径树。

松弛技术

    本章算法采用松弛（relaxation）技术。对每个顶点v设置一个dis域，表示v到源点s的最短权值的上界，称之为最短路径估计（shortest-path estimate），在算法开始之前，采用下面的过程初始化每个顶点的相关域。

void initVertex(size_t source){for (size_t i = 1; i <= nodenum; ++i){V[i].dis = MAX;V[i].p = i;};V[source].dis = 0;}

以下为松弛操作代码

void relax(size_t u, size_t v, int w){if (V[v].dis > V[u].dis + w){V[v].dis = V[u].dis + w;V[v].p = u;}}

    在每一次的松弛边(u,v)的操作过程中，我们要测试是否能够通过u，更短的到达v，如果有，则更新dis[v]和parent[v]，每一次的松弛都会减小最短路径估计的值dis[v]。关于松弛可以这样理解：松弛，是对V[v].dis <= V[u].dis + w这个表达式的松弛，每次松弛之后V[v].dis的值都会减小，那么满足该表达式就更加没有压力，意即松弛了这种压力。

本章算法如下：

#include<iostream>#include<fstream>#include<vector>#include<stack>#include<algorithm>#include<functional>#include"FibonacciHeap.h"#define NOPARENT 0#define MAX0x7ffffff#define MIN 0x8000000using namespace std;enum color{ WHITE, GRAY, BLACK };struct edgeNode{//边节点size_t adjvertex;//该边的关联的顶点int weight;//边权重edgeNode *nextEdge;//下一条边edgeNode(size_t adj, int w) :adjvertex(adj), weight(w), nextEdge(nullptr){}};struct vertex{size_t id;//顶点idcolor c;int dis;//距源点距离size_t p;//父顶点size_t s, f;//访问开始和结束时间vertex(size_t i = 0) :id(i), p(NOPARENT), c(WHITE),dis(0),s(0),f(0){}};class AGraph{//有向图private:vector<edgeNode*> E;vector<vertex> V;size_t nodenum;void initVertex(size_t source){for (size_t i = 1; i <= nodenum; ++i){V[i].dis = MAX;V[i].p = i;};V[source].dis = 0;}void relax(size_t u, size_t v, int w){if (V[v].dis > V[u].dis + w){V[v].dis = V[u].dis + w;V[v].p = u;}}void printSP(size_t v){if (v != V[v].p){printSP(V[v].p);cout << " --> " << v;}else cout << v;}void printASP(){for (size_t i = 1; i <= nodenum; ++i){printSP(i);cout << '\t' << V[i].dis << endl;}cout << endl;}size_t vertexIndex(size_t vertex_id){size_t index;for (size_t i = 1; i <= nodenum; ++i)if (V[i].id == vertex_id) index = i;return index;}void SPT(AGraph*);void printCycle(size_t);void DFS();void DFS_aux_Not_recursive(size_t, size_t&);public:AGraph(size_t n = 0) :nodenum(n) { editGraph(n); }void editGraph(size_t n){ V.resize(n + 1);E.resize(n + 1);for (size_t i = 1; i <= nodenum; ++i)V[i].id = i;}void initGraph();//初始化有向图edgeNode* search(size_t, size_t);//查找边void addEdge(size_t, size_t, int);//有向图中添加边void deleteEdge(size_t, size_t);//有向图中删除边bool Bellman_Ford(size_t,AGraph*);void dagSP(size_t);void dijkstra(size_t,AGraph *);void topSort(vector<size_t>&);void print();~AGraph();};void AGraph::initGraph(){size_t start, end;int w;ifstream infile("F:\\djikstra.txt");while (infile >> start >> end >> w)addEdge(start, end, w);}edgeNode* AGraph::search(size_t start, size_t end){edgeNode *curr = E[start];while (curr != nullptr && curr->adjvertex != end)curr = curr->nextEdge;return curr;}void AGraph::addEdge(size_t start, size_t end, int weight = 1){edgeNode *curr = search(start, end);if (curr == nullptr){edgeNode *p = new edgeNode(end, weight);p->nextEdge = E[start];E[start] = p;}}void AGraph::deleteEdge(size_t start, size_t end){edgeNode *curr = search(start, end);if (curr != nullptr){if (curr->adjvertex == end){E[start] = curr->nextEdge;delete curr;}else{edgeNode *pre = E[start];while (pre->nextEdge->adjvertex != end)pre = pre->nextEdge;pre->nextEdge = curr->nextEdge;delete curr;}}}void AGraph::SPT(AGraph *spt){//根据前驱子图构造最短路径树for (size_t i = 1; i <= nodenum; ++i){size_t j = i;while (j != V[j].p){edgeNode *curr = search(V[j].p, j);spt->addEdge(V[j].p, j, curr->weight);j = V[j].p;}}}void AGraph::printCycle(size_t cycle){//求负权回路,时间复杂度O(V)vector<color> onCycle(nodenum + 1);for (size_t i = 1; i <= nodenum; ++i)onCycle[i] = WHITE;//顶点全部初始化为白色while (onCycle[cycle] == WHITE){//当遇到黑色顶点时退出，表明此时是第二次扫描到，可断定该顶点必在回路上onCycle[cycle] = BLACK;cycle = V[cycle].p;}while (onCycle[cycle] == BLACK){//以该顶点为起点，开始输出回路上的顶点onCycle[cycle] = WHITE;cout << cycle << ' ';cycle = V[cycle].p;}}bool AGraph::Bellman_Ford(size_t source,AGraph *spt){//Bellman-Ford算法计算单源最短路径，spt存储最短路径树SPTinitVertex(source);for (size_t i = 1; i != nodenum; ++i){//进行V-1此迭代for (size_t j = 1; j != E.size(); ++j){//每次都对所有边进行一次松弛edgeNode *curr = E[j];while (curr != nullptr){relax(j, curr->adjvertex, curr->weight);curr = curr->nextEdge;}}}for (size_t j = 1; j != E.size(); ++j){//判断是否有负权回路edgeNode *curr = E[j];while (curr != nullptr){if (V[curr->adjvertex].dis > V[j].dis + curr->weight){//有则打印出该回路,并终止程序printCycle(curr->adjvertex);cout << endl;return false;}curr = curr->nextEdge;}}SPT(spt);//否则计算出最短路径树return true;}void AGraph::dagSP(size_t source){//有向无环图求单源最短路径vector<size_t> topsort;topSort(topsort);//先进行拓扑排序，并将拓扑顺序的顶点标号存入topsortinitVertex(source);//初始化顶点的距离和父顶点for (size_t i = 0; i != topsort.size(); ++i){//按拓扑顺序edgeNode *curr = E[topsort[i]];while (curr != nullptr){//对每个顶点的边进行一次松弛relax(topsort[i], curr->adjvertex, curr->weight);curr = curr->nextEdge;}}for (size_t i = 0; i != topsort.size(); ++i){size_t index = vertexIndex(topsort[i]);cout << topsort[i] << '\t' << V[index].dis << endl;}//SPT(spt);//这里最好不要构造最短路径树了，若要构造，则需对SPT进行些许修改，//因为顶点编号和索引不在对应，在排序过程中移动了。}void AGraph::dijkstra(size_t source,AGraph *spt){//dijkstra算法求单源最短路径，只适用于非负权值无回路图，斐波那契堆实现initVertex(source);fibonacci_heap<int, size_t> Q;vector<fibonacci_heap_node<int,size_t>*> ptr_fibo_node(nodenum + 1);//顶点所关联的堆结点地址for (size_t i = 1; i <= nodenum; ++i)ptr_fibo_node[i] = Q.insert(V[i].dis, i);while (!Q.empty()){pair<int, size_t> min = Q.extractMin();//取得当前离远点最近顶点ptr_fibo_node[min.second] = nullptr;//置空，表明堆中已删除该顶点edgeNode *curr = E[min.second];while (curr != nullptr){relax(min.second, curr->adjvertex, curr->weight);if (ptr_fibo_node[curr->adjvertex] != nullptr && //如果该顶点到源点距离减小V[curr->adjvertex].dis < ptr_fibo_node[curr->adjvertex]->key)Q.decreaseKey(ptr_fibo_node[curr->adjvertex], V[curr->adjvertex].dis);curr = curr->nextEdge;}}SPT(spt);//根据前驱子图求得最短路径树邻接表printASP();//打印源点到各顶点路径及最小权值和}inline void AGraph::print(){for (size_t i = 1; i != E.size(); ++i){edgeNode *curr = E[i];cout << i;if (curr == nullptr) cout << " --> null";elsewhile (curr != nullptr){cout << " --" << "<" << curr->weight << ">--> " << curr->adjvertex;curr = curr->nextEdge;}cout << endl;}}void AGraph::DFS_aux_Not_recursive(size_t u, size_t &time){stack<size_t> S;vector<edgeNode*> access_edge(E);//记下每个顶点下一条将被访问的边V[u].c = GRAY;V[u].s = ++time;S.push(u);while (!S.empty()){//只要栈不空，不断访问size_t i = S.top();edgeNode *curr = access_edge[i];//得到顶点i当前将要被访问的边while (curr != nullptr){//不断循环，直到访问到一个白节点，或者顶点i的所有邻接点已被访问if (V[curr->adjvertex].c == WHITE){//与i相邻的是白节点，即未被访问过V[curr->adjvertex].c = GRAY;V[curr->adjvertex].s = ++time;S.push(curr->adjvertex);//访问后入栈access_edge[i] = curr->nextEdge;//记下顶点i下一条将要被访问的边break;}else curr = curr->nextEdge;}if (curr == nullptr){//顶点i的所有邻接点已被访问，则出栈V[i].c = BLACK;V[i].f = ++time;S.pop();}}}void AGraph::DFS(){size_t time = 0;for (size_t i = 1; i != E.size(); ++i)if (V[i].c == WHITE)DFS_aux_Not_recursive(i, time);}void AGraph::topSort(vector<size_t> &topsort){struct vertexCompare{bool operator()(const vertex &lhs, const vertex &rhs)const{return lhs.f > rhs.f;}};DFS();sort(++V.begin(), V.end(), vertexCompare());for (size_t i = 1; i != V.size(); ++i)topsort.push_back(V[i].id);}AGraph::~AGraph(){for (size_t i = 1; i != E.size(); ++i){edgeNode *curr = E[i], *pre;while (curr != nullptr){pre = curr;curr = curr->nextEdge;delete pre;}}}const int nodenum = 5;int main(){AGraph graph(nodenum),spt(nodenum);graph.initGraph();graph.print();cout << endl;graph.dijkstra(1, &spt);spt.print();getchar();return 0;}

Bellman-Ford算法

    1、调用initVertex初始化各个顶点，包括dis域和前驱域；

    2、对所有边进行松弛，连续进行|V| - 1次；

    3、对所有边进行一次检测，判断是否有环，有则调用printCycle输出此环，并退出；

    4、根据前驱数组，构造出最短路径树（SPT）。

习题 24.1-5

    题目意思是计算每个顶点到其他顶点的各条最短路径中的最小权值？！O(VE)算法，求思路？

习题 24.1-6

    具体代码见上述printCycle函数，思路：当出现d[v] > d[u] + w(u,v)时，说明顶点u和v均受到了负权回路对最短路径权值的影响，但并不能说明u或者v就在此回路上。我们可以从u或者v开始，根据前驱数组找到位于该环上的任意顶点，然后再从该顶点开始根据前去数组逆推得到该环，算法如下：

    1、从顶点u后者v开始根据前驱数组逆推，直到两次遇到同一个顶点，记为x，那么x必在此环上；

    2、重新以x为起点根据前驱数组逆推，依次输出各顶点，直到再次遇到x则停止，即求得该环。

有向无回路图的单源最短路径

    有向无回路图（dag）G可以根据其结构特点——无回路——构造出线性时间的单元最短路径算法，如下：

    1、首先对G进行拓扑排序得到拓扑序列；

    2、根据拓扑序列一次对每个顶点的邻接边进行松弛。

具体代码见上述dagSP函数。

习题 24.2-2

    最后一个顶点没有出边，因而无所谓松不松弛。

习题 24.2-3

    松弛条件改为“d[v] < d[u] + w(v)”，初始化时对每个顶点v，d[v] = 0.

Dijkstra算法

    Dijkstra算法是一个贪心算法，算法伪代码如下：

Dijkstra(G, s){initVertex(G, s);Q <- V[G];S <- NULL;while (Q != NULL){u <- EXTRACT - MIN(Q);S <- S + {u};for each v in Adj[u]relax(u, v, w(u, v));}}

其中Q是一个优先级队列，优先权即为其中的顶点离源点的距离。在本篇博客的实现中采用的是斐波那契堆实现，因而时间复杂度为O(VlgV+E)。详情请见源代码。