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);
}
}