有向无环图求单源最短路径问题

1，有向无环图可以用拓扑排序先求得拓扑序列；对于得到的拓扑序列，我们遍历一遍，对于每一个元素，我们看它的邻接边，（因为拓扑序列中当前元素只可能存在指向在它之后的元素的边），对它的邻接边做松弛操作，这样一遍过后，就得到了给定源节点的单源最短路径！

2，时间复杂度分析：

拓扑排序的时间复杂度为O(n+e),遍历一遍拓扑序列，以及松弛操作的代价为O(n+e);所以总的时间代价为O（n+e).

3，下边是简单实现：

#include "stdafx.h"
#include <iostream>
#include <stack>
#include <fstream>
using namespace std;

typedef int ElemType;
#define path "D:\\test1.txt"
#define INFENITE 65535
struct DAGNode{
	ElemType data;
	struct arcnode *firstarc;
};
struct arcnode{
	ElemType adjvex;
	struct arcnode *nextarc;
	int weight;
	arcnode(ElemType x, int y)
	{
		adjvex = x;
		weight = y;
		nextarc = NULL;
	}
};

struct DAG{
	int vernum;
	int arcnum;
	int *indegree;//入度数组
	ElemType *pre;//前驱数组，pre[i]表示的是顶点i的最短路径上的前驱顶点
	int *dist;//距离数组
	DAGNode *AdjList;
};

void Readfile(DAG &g)
{
	cout << "读入图的顶点数和边数并输出！" << endl;
	ifstream infile(path);
	infile >> g.vernum >> g.arcnum;
	cout << g.vernum << ' ' << g.arcnum << endl;
	cout << "建立邻接表！" << endl;
	g.AdjList = new DAGNode[g.vernum];
	g.indegree = new int[g.vernum];
	g.pre = new ElemType[g.vernum];
	g.dist = new int[g.vernum];
	for (int i = 0; i < g.vernum; i++)//初始化
	{
		g.AdjList[i].data = i;
		g.AdjList[i].firstarc = NULL;
		g.indegree[i] = 0;
		g.pre[i] = i;
		g.dist[i] = INFENITE;
	}
	ElemType head, tail; 
	int weight;
	for (int j = 0; j < g.arcnum; j++)
	{
		infile >> head >> tail >> weight;
		arcnode *s = new arcnode(tail, weight);
		s->nextarc = g.AdjList[head].firstarc;
		g.AdjList[head].firstarc = s;//头插法
		g.indegree[tail]++;//tail顶点入度增加
	}
}
void TuoPuSort(DAG &g, ElemType *&e)//e是存储拓扑序列
{
	e = new ElemType[g.vernum];
	stack <ElemType> s;
	for (int i = 0; i < g.vernum; i++)
	{
		if (!g.indegree[i])
		{
			s.push(i);//零入度顶点入栈
		}
	}
	int count = 0;//出栈次数
	while (!s.empty())
	{
		e[count] = s.top();
		//cout << s.top() << endl;
		s.pop();//出栈,所有邻接点的入度减少1
		arcnode *t;
		for (t = g.AdjList[e[count]].firstarc; t; t = t->nextarc)
		{
			g.indegree[t->adjvex]--;
			if (!g.indegree[t->adjvex])
			{
				s.push(t->adjvex);
			}
		}
		count++;
	}
}
void Relax(DAG &g, ElemType u, ElemType v, int weight)
{
	if (g.dist[u] == INFENITE)
	{
		return;
	}
	if (g.dist[v] > g.dist[u] + weight)
	{
		g.dist[v] = g.dist[u] + weight;
		g.pre[v] = u;
	}
}
void ShortRoot(DAG &g, ElemType source, ElemType *s)
{
	g.dist[source] = 0;
	for (int i = 0; i < g.vernum; i++)
	{
		arcnode *t;
		for (t = g.AdjList[s[i]].firstarc; t; t = t->nextarc)
		{
			Relax(g, s[i], t->adjvex, t->weight);
		}
	}
}
void printroot(DAG g, ElemType x)
{
	//反向打印出
	if (g.dist[x] == INFENITE)
	{
		cout << "该点源节点不可达！" << endl;
	}
	else
	{
		while (g.pre[x] != x)
		{
			cout << x << "-->";
			x = g.pre[x];
		}
		cout << x;
	}
}
int _tmain(int argc, _TCHAR* argv[])
{
	DAG g;
	Readfile(g);
	ElemType *e = NULL;
	TuoPuSort(g, e);
	cout << "拓扑序列为：" << endl;
	for (int i = 0; i < g.vernum; i++)
	{
		cout << e[i] << "-->";
	}
	cout << endl;
	cout << "最短路径：" << endl;
	ShortRoot(g, 0, e);
	printroot(g, 6);
	cout << endl;
	cout << "最短距离为：" << g.dist[6];
	system("pause");
	return 0;
}

test1.txt数据为：

12 16
0 1 2
0 2 -1
1 2 3
0 3 4
2 4 5
3 4 10
10 5 3
4 6 7 
2 6 21
2 7 -5
5 7 9
8 9 11
8 10 6
8 11 4
9 11 10
0 11 11
运行结果为：