算法导论——有向无环加权图的最短路径（使用拓扑排序）-CSDN博客

2019独角兽企业重金招聘Python工程师标准>>>

package org.loda.graph;

import org.loda.structure.Stack;
import org.loda.util.In;

/**
 * 
 * @ClassName: NoCycleSP
 * @Description: 有向无环图的最短路径算法
 * 
 * 无环图可以采用拓扑排序来处理，进行拓扑排序中不会有排名靠后的指向排名靠前的情况，所以拓扑排序的第一个节点是无法从其他节点抵达的
 * 
 * 无环权重有向图的算法时间复杂度可以高达O(V+E)，比Dijkstra算法更好，并且能解决负数权重问题，不过他需要有向图是无环的
 * 
 * @author minjun
 * @date 2015年5月28日 上午9:47:26
 * 
 */
public class NoCycleSP {

	/**
	 * 原点
	 */
	private int s;

	/**
	 * dist[i]表示s->i的距离
	 */
	private double[] dist;

	/**
	 * 最短路径上的前驱顶点
	 */
	private int[] prev;

	public NoCycleSP(WeightDigraph g, int s) {
		int v = g.v();
		this.s = s;

		dist = new double[v];

		prev = new int[v];

		for (int i = 0; i < v; i++) {
			prev[i] = -1;
			dist[i] = Double.POSITIVE_INFINITY;
		}

		dist[s] = 0.0;

		// 将权重有向图转成无权有向图图，然后进行拓扑排序
		Topological top = new Topological(g.toDigraph());

		for (int i : top.order()) {
			relax(i, g);
		}
	}

	/**
	 * 
	 * @Title: relax
	 * @Description: 松弛某个顶点周围的边
	 * @param @param i
	 * @param @param g 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	private void relax(int i, WeightDigraph g) {
		for (Edge edge : g.adj(i)) {
			int j = edge.otherSide(i);

			if (dist[j] > dist[i] + edge.weight()) {
				dist[j] = dist[i] + edge.weight();
				prev[j] = i;
			}
		}
	}

	/**
	 * 
	 * @Title: distTo
	 * @Description: s->v的最短距离
	 * @param @param v
	 * @param @return 设定文件
	 * @return double 返回类型
	 * @throws
	 */
	public double distTo(int v) {
		return dist[v];
	}

	/**
	 * 
	 * @Title: pathTo
	 * @Description: 最短路径
	 * @param @param v
	 * @param @return 设定文件
	 * @return Iterable<Integer> 返回类型
	 * @throws
	 */
	public Iterable<Integer> pathTo(int v) {
		if (distTo(v) == Double.POSITIVE_INFINITY)
			return null;

		Stack<Integer> path = new Stack<Integer>();

		for (int i = v; i != -1; i = prev[i]) {
			path.push(i);
		}
		return path;
	}

	public static void main(String[] args) {
		WeightDigraph g = new WeightDigraph(new In(
				"F:\\算法\\attach\\tinyEWDAG.txt"));
		
		//由于无法从其他节点到达5节点（拓扑排序第一个节点），所以这里我们采用5节点作为第一个节点，来观察所有的可达路径
		NoCycleSP d = new NoCycleSP(g, 5);

		for (int i = 0; i < g.v(); i++) {
			Iterable<Integer> path = d.pathTo(i);
			if (path == null) {
				System.out.println("从原点" + d.s + "到" + i + "没有可达路径");
			} else {
				System.out.println("从原点" + d.s + "到" + i + "的最短距离为："
						+ d.distTo(i));
				System.out.print("路径为：");
				for (int j : d.pathTo(i)) {
					System.out.print(j + "->");
				}
				System.out.println();
			}
		}
	}
}

文本数据：

8
13
5 4 0.35
4 7 0.37
5 7 0.28
5 1 0.32
4 0 0.38
0 2 0.26
3 7 0.39
1 3 0.29
7 2 0.34
6 2 0.40
3 6 0.52
6 0 0.58
6 4 0.93

这个无环图的输出结果为：

从原点5到0的最短距离为：0.73
路径为：5->4->0->
从原点5到1的最短距离为：0.32
路径为：5->1->
从原点5到2的最短距离为：0.6200000000000001
路径为：5->7->2->
从原点5到3的最短距离为：0.61
路径为：5->1->3->
从原点5到4的最短距离为：0.35
路径为：5->4->
从原点5到5的最短距离为：0.0
路径为：5->
从原点5到6的最短距离为：1.13
路径为：5->1->3->6->
从原点5到7的最短距离为：0.28
路径为：5->7->

转载于:https://my.oschina.net/u/1378920/blog/420938