最短路径-Dijkstra和Floyd-JAVA代码

1、Dijkstra

import java.util.Scanner;

public class Dijkstra {

	/**
	 * Dijkstra是确定了起点，求起点到所有点的最短路径。
	 * floyd是求出了不同的起点到终点的最短路径。
	 */

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		while (scanner.hasNext()) {
			int n = scanner.nextInt();
			int m = scanner.nextInt();
			int val[] = new int[n];
			for (int i = 0; i < n; i++) {
				val[i] = scanner.nextInt();
			}
			int map[][] = new int[n][n];
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					map[i][j] = Integer.MAX_VALUE;
				}
			}
			for (int k = 0; k < m; k++) {
				int i = scanner.nextInt() - 1;
				int j = scanner.nextInt() - 1;
				map[i][j] = val[j];
				map[j][i] = val[i];
			}
			System.out.println(dijkstra(map, 0, n, val[0]));
		}
		scanner.close();
	}

	private static int dijkstra(int[][] map, int s, int n, int val) {
		int dist[] = new int[n];
		boolean isVisited[] = new boolean[n];
		for (int i = 1; i < n; i++) {
			dist[i] = map[s][i];
		}
		dist[s] = val;
		isVisited[s] = true;
		for (int i = 0; i < n; i++) {
			int minDist = Integer.MAX_VALUE;
			int v = 0;
			for (int j = 0; j < n; j++) {
				if (!isVisited[j] && dist[j] < minDist) {
					minDist = dist[j];
					v = j;
				}
			}
			isVisited[v] = true;
			for (int j = 0; j < n; j++) {
				if (!isVisited[j] && map[v][j] < Integer.MAX_VALUE) {
					int temp = dist[v] + map[v][j];
					dist[j] = dist[j] < temp ? dist[j] : temp;
				}
			}
		}
		return dist[n - 1] + val;
	}

	/*public static void main(String[] args) {
		int MAX = Integer.MAX_VALUE;
		int[][] map = new int[][] {
				{ 0, 10, MAX, MAX, MAX, 11, MAX, MAX, MAX },
				{ 10, 0, 18, MAX, MAX, MAX, 16, MAX, 12 },
				{ MAX, MAX, 0, 22, MAX, MAX, MAX, MAX, 8 },
				{ MAX, MAX, 22, 0, 20, MAX, MAX, 16, 21 },
				{ MAX, MAX, MAX, 20, 0, 26, MAX, 7, MAX },
				{ 11, MAX, MAX, MAX, 26, 0, 17, MAX, MAX },
				{ MAX, 16, MAX, MAX, MAX, 17, 0, 19, MAX },
				{ MAX, MAX, MAX, 16, 7, MAX, 19, 0, MAX },
				{ MAX, 12, 8, 21, MAX, MAX, MAX, MAX, 0 } };
		int len = map.length;
		VertexTest[] vertexTests = new VertexTest[len];
		for (int i = 0; i <= len - 1; i++) {
			VertexTest vertexTest;
			if (map[0][i] == MAX) {
				vertexTest = new VertexTest(map[0][i], -1, false);
			} else {
				vertexTest = new VertexTest(map[0][i], 0, false);
			}
			vertexTests[i] = vertexTest;

		}

		getMinPath(vertexTests, len, map);
	}

	public static String getMinPath(VertexTest[] vertexTests, int n, int[][] map) {
		String result = "";
		for (int i = 0; i <= n - 1; i++) {
			int min = Integer.MAX_VALUE;
			int j;
			int minIndex = 0;
			for (j = 0; j <= n - 1; j++) {
				if (vertexTests[j].isChoose != true
						&& vertexTests[j].weight <= min) {
					min = vertexTests[j].weight;
					minIndex = j;
				}
			}
			result += minIndex;
			vertexTests[minIndex].isChoose = true;
			for (int k = 0; k <= n - 1; k++) {
				if (vertexTests[k].isChoose != true
						&& vertexTests[minIndex].weight + map[minIndex][k] <= vertexTests[k].weight) {
					vertexTests[k].weight = vertexTests[minIndex].weight
							+ map[minIndex][k];
					vertexTests[k].pre = minIndex;
				}
			}
		}
		System.out.println(result);
		return result;
	}*/

}

/*class VertexTest {
	public int weight;
	public int pre;
	public boolean isChoose;
	
	public VertexTest(int weight , int pre , boolean state)
	{
		this.weight = weight;
		this.pre = pre;
		this.isChoose = state;
	}
	
	public int getWeight() {
		return weight;
	}
	public void setWeight(int weight) {
		this.weight = weight;
	}
	public int getPre() {
		return pre;
	}
	public void setPre(int pre) {
		this.pre = pre;
	}
	public boolean isChoose() {
		return isChoose;
	}
	public void setChoose(boolean isChoose) {
		this.isChoose = isChoose;
	}
}*/

2、Floyd

public class Floyd {
	static int MAX = Integer.MAX_VALUE;

	public static void main(String[] args) {
		int[][] map = new int[][] { 
				{ 0, 12, MAX, MAX, MAX, 16, 14 },
				{ 12, 0, 10, MAX, MAX, 7, MAX },
				{ MAX, 10, 0, 3, 5, 6, MAX },
				{ MAX, MAX, 3, 0, 4, MAX, MAX },
				{ MAX, MAX, 5, 4, 0, 2, 8 },
				{ 16, 7, 6, MAX, 2, 0, 9 },
				{ 14, MAX, MAX, MAX, 8, 9, 0 } };
		int len = map.length;
		int[][] nextVer = new int[len][map[0].length];
		int i, j, k;
		for (i = 0; i <= len - 1; i++) {
			for (j = 0; j <= len - 1; j++) {
				if (map[i][j] != MAX) {
					nextVer[i][j] = j;
				} else {
					nextVer[i][j] = -1;
				}
			}
		}
		for (k = 0; k <= len - 1; k++) {
			for (i = 0; i < len - 1; i++) {
				for (j = 0; j <= len - 1; j++) {
					if (map[i][k] >= MAX || map[k][j] >= MAX) {
						continue;
					}
					if (map[i][j] > map[i][k] + map[k][j]) {
						map[i][j] = map[i][k] + map[k][j];
						nextVer[i][j] = nextVer[i][k]; //状态转移
					}
				}
			}

		}
		System.out.println("0 -> 6 最短路径的权重为 ： " + map[0][6]);
		int m = 0, n = 6;
		System.out.print(m);
		while (nextVer[m][n] != n) {
			System.out.print(nextVer[m][n]);
			m = nextVer[m][n];
		}
		System.out.print(n);
	}
}