对于一般的加权图,Bellman-Ford计算单源点最短路径时间复杂度为O(VE),斐波那契堆优化后的Dijkstrs为O(E+VLogV)
如果图可以满足Directed Acyclic Graph(DAG)有向无环图,那么求单源点最短路径问题时间复杂度可以缩减到O(V+E)
同样这个方法可以解决多段图问题,多段图属于DAG。
初始化dist[]={INF,INF,...} and dist[src]=0;
对图进行拓扑排序
按拓扑排序的顺序对每一个顶点u执行
if(dist[u]+weight(u,v)<dist[v])
dist[v]=dist[u]+weight(u,v);
#include <iostream>
#include <stack>
#include <list>
#include <vector>
#include <functional>
using namespace std;
typedef pair<int, int> AdjListNode;
class Graph {
int V;
list<AdjListNode> * adj;
void topologicalSortUtil(int v, vector<bool>& visited, stack<int> & Stack);
public:
Graph(int _V) : V(_V),adj(new list<AdjListNode>[V]) { }
void addEdge(int u, int v, int weight);
void shortestPath(int s);
};
void Graph::addEdge(int u, int v, int weight)
{
adj[u].push_back(AdjListNode(v, weight));
}
void Graph::topologicalSortUtil(int v,vector<bool>& visited, stack<int > & stack)
{
visited[v] = true;
list<AdjListNode>::iterator i;
for (i = adj[v].begin();i != adj[v].end();i++)
if (!visited[i->first])
topologicalSortUtil(i->first, visited, stack);
stack.push(v);
}
void printSolution(vector<int> & dist,int src)
{
cout << "Following are shortest distances from source " << src << endl;
for (int i = 0;i < dist.size();i++)
(dist[i] == INT_MAX) ? cout << "INF " : cout << dist[i] << " ";
cout << endl;
}
void Graph::shortestPath(int src)
{
stack<int> stack;
vector<int> dist(V, INT_MAX);
vector<bool>visited(V, false);
for (int i = 0;i < V;i++)
if (visited[i] == false)
topologicalSortUtil(i, visited, stack);
dist[src] = 0;
while (stack.empty() == false)
{
int u = stack.top();
stack.pop();
list<AdjListNode>::iterator i;
if (dist[u] != INT_MAX)
{
for (i = adj[u].begin();i != adj[u].end();i++)
if (dist[u] + i->second < dist[i->first])
dist[i->first] = dist[u] + i->second;
}
}
printSolution(dist, src);
}
int main()
{
Graph g(6);
g.addEdge(0, 1, 5);
g.addEdge(0, 2, 3);
g.addEdge(1, 3, 6);
g.addEdge(1, 2, 2);
g.addEdge(2, 4, 4);
g.addEdge(2, 5, 2);
g.addEdge(2, 3, 7);
g.addEdge(3, 4, -1);
g.addEdge(4, 5, -2);
g.shortestPath(2);
return 0;
}