节点拓扑应用拓扑排序来解决DAG(directed acylic graph)的单源最短路径问题
时光紧张，先记一笔，后续优化与完善。
熟习图的人可以知道，对于单源最短路径的问题，我们可以用bellman-ford算法，或者dijkstra算法来处理，bellman-ford可以处理 有向无环图中边的权值为负数的情况，但是dijkstra不能处理复权值的问题。如果给定一个图G (v, e)， bellman-ford求最短路径的时光复杂度是O(ve)， 而dijkstra所用的时光是O(vlogv)。对于这两种方法就不介绍了。下面介绍一种应用拓扑排序的来处理单源最短路径的问题。时光复杂度是O(v+e)，想了很久，为什么要用拓扑排序可以很好的处理单源最短路径的问题呢。大家想一想拓扑排序的规矩：不断的寻觅入度为0的节点，那么入度为0的节点代表什么呢，入度为0的节点说明在它入度变成0之前，全部指向它的节点已经通过邻接关系拜访过它，也就是说，如果以拓扑排序拜访的次序来计算最短路径的话，那么给定一个节点，只有在拓扑排序次序排在它之前的节点才有边指向这个节点，排在它之后的就可以忽略掉了，这样就节省了遍历的时光，而且保证不会遗漏任何一个指向它的节点。在遍历到这个节点之前，就已经计算好某个节点，到这个节点的单源最短路值。这就是应用拓扑排序的最大精巧之处。
拓扑排序设定规矩如下：如果给定一个图中含有V个节点，初始化一个int数组，dist[V], 将指定的源点的值设置为0之外，其他的都设置成无穷大。之后停止拓扑排序，按照拓扑排序的次序处理每一个节点到邻接点的距离。下面给个详细的例子：
之后给出代码：
#include<iostream>
#include<list>
#include<stack>
#include<limits.h>
using namespace std;
#define INF INT_MAX
class AdjListNode {
int v;
int weight;
public:
AdjListNode(int _v, int _weight) {
v = _v;
weight = _weight;
}
int getV() {
return v;
}
int getWeight() {
return weight;
}
};
class Graph {
int vertexNum;
list<AdjListNode> *adjacents;
public:
Graph(int _vertexNum) {
vertexNum = _vertexNum;
adjacents = new list<AdjListNode>[vertexNum];
}
void topologicalUtil(int v, bool *visited, stack<int> &m_stack);
void addEdge(int u, int v, int weight);
void shortestPath(int s);
};
void Graph::addEdge(int u, int v, int weight) {
AdjListNode node = AdjListNode(v, weight);
adjacents[u].push_back(node);
}
void Graph::topologicalUtil(int v, bool *visited, stack<int> &m_stack) {
visited[v] = true;
list<AdjListNode>::iterator iter;
for (iter = adjacents[v].begin(); iter != adjacents[v].end(); iter++) {
if (false == visited[iter->getV()])
topologicalUtil(iter->getV(), visited, m_stack);
}
m_stack.push(v);
}
void Graph::shortestPath(int s) {
stack<int> m_stack;
bool *visited = new bool[vertexNum];
int v, u;
for (v = 0; v < vertexNum; v++)
visited[v]= false;
int *dist = new int[vertexNum];
for (v = 0; v < vertexNum; v++)
dist[v] = INF;
for (v = 0; v < vertexNum; v++)
if (false == visited[v])
topologicalUtil(v, visited, m_stack);
dist[s] = 0;
while (!m_stack.empty()) {
u = m_stack.top();
m_stack.pop();
list<AdjListNode>::iterator iter;
if (INF != dist[u]) {
for (iter = adjacents[u].begin(); iter != adjacents[u].end(); iter++) {
v = iter->getV();
if (dist[v] > dist[u] + iter->getWeight())
dist[v] = dist[u] + iter->getWeight();
}
}
}
for (v = 0; v < vertexNum; v++) {
if (INF == dist[v])
cout << "INF" << " ";
else
cout << dist[v] << " ";
}
}
int main(int argc, char *argv[]) {
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);
int s = 1;
cout << "Following are shortest distances from source " << s <<" \n";
g.shortestPath(s);
cin.get();
return 0;
}
Following are shortest distances from source 1 INF 0 2 6 5 3
文章结束给大家分享下程序员的一些笑话语录： 很多所谓的牛人也不过如此，离开了你，微软还是微软，Google还是Google，苹果还是苹果，暴雪还是暴雪，而这些牛人离开了公司，自己什么都不是。