最短路径问题

最短路算法的求解，都是基于下列事实：节点A到节点B的最短路径有两种可能，一种是直接从A到B，另一种是从A经过若干个节点到B。

 

Dijkstra算法：单源最短路径问题，时间复杂度为O(n^2)；不能处理权值为负的边；

Floyd算法：求解图中任意节点之间的最短路径，时间复杂度为O(n^3)；可以处理任意数值权重的边。

 

程序（朴素版本）

Dijkstra算法

public class Dijkstra {

	public int[] getShortestPath(int[][] adjacencyMatrix) {

		if (adjacencyMatrix == null || adjacencyMatrix.length == 0

				|| adjacencyMatrix[0].length == 0) {

			return null;

		}



		int n = adjacencyMatrix.length;

		boolean[] visited = new boolean[n];

		int[] shortestPath = new int[n];

		visited[0] = true;

		int lastNodes = n - 1;



		// initialize

		for (int i = 0; i < n; i++) {

			shortestPath[i] = adjacencyMatrix[0][i];

		}



		while (lastNodes > 0) {

			int shortest = Integer.MAX_VALUE;

			int idx = 0;

			for (int i = 1; i < n; i++) {

				if (visited[i]) {

					continue;

				}

				if (shortestPath[i] < shortest) {

					// choose the nearby node

					shortest = shortestPath[i];

					idx = i;

				}

			}

			visited[idx] = true;

			// update shortest path

			for (int i = 1; i < n; i++) {

				if (visited[i] || adjacencyMatrix[idx][i] == Integer.MAX_VALUE) {

					continue;

				}

				shortestPath[i] = Math.min(shortestPath[i], shortestPath[idx]

						+ adjacencyMatrix[idx][i]);

			}

			--lastNodes;

		}



		return shortestPath;

	}

}

 

Floyd算法

经典的三层for循环结构，

public class Floyd {

	public int[][] getShortestMatrix(int[][] adj) {

		if (adj == null || adj.length == 0 || adj[0].length == 0) {

			return null;

		}



		int n = adj.length;



		for (int i = 0; i < n; i++) {

			for (int j = 0; j < n; j++) {

				for (int k = 0; k < n; k++) {

					if (adj[i][k] == Integer.MAX_VALUE

							|| adj[j][k] == Integer.MAX_VALUE) {

						continue;

					}

					if (adj[i][k] + adj[j][k] < adj[i][j]) {

						adj[i][j] = adj[i][k] + adj[j][k];

					}

				}

			}

		}



		return adj;

	}

}