最短路径问题
用d(i,j)表示节点i到节点j的最短路径,w(i,j)表示节点i到节点j的权重；
对于n个节点的图，采用邻接矩阵的方式输入输出，输出及中间结果的矩阵也是n*n的矩阵，第i行j列表示从i到j的当前最短路径
矩阵乘法的动态规划
适用条件：
没有负环（可有负权重）
步骤：
1.分析最优解的结构 （最短路径结构）
根据最短路径的最优子结构性质，有d(i,j) = d(i,k) + w(k,j)
2.递归定义最优解的值
(所有节点对最短路径问题的递归解)
首先要获取递归求解的对象表达式
这里采取最短路径的边数作为递归的计数对象，因为图中没有负环，所以对于边数大于n-1的最短路径计算也就没有意义（因为n-1条边已经能够将所有节点连接，一旦大于n-1条边则会形成环，并且所有的环都是正权重，所以会使结果变大），因此我们递归时控制边数m使其m>0 && m < n。m=1时，即为输入的邻接矩阵M。
在递归时，我们计算边数为m的最短路径时，将m-1的最短路径与d(i,j) = d(i,k) + w(k,j)进行比较，取最小值。因为k=j时，即为m-1的最短路径，因此问题简化为循环遍历k求d(i,j) = d(i,k) + w(k,j)的最小值。如下图公式：
3.自底向上计算最优解的值
（自底向上计算最短路径权重）
因为含有m条边的距离是在m-1条边的基础上计算出来的，所以从含有一条边开始，自底向上求值，按照第二步所述编写代码，详见具体代码。
4.从计算出的最优解的值上构建最优解
按照正常步骤，按部就班的每次递归m++；这样最终的时间复杂度为O(n^4)。但我们要的只是m=n-1的结果，而对中间步骤不感兴趣，所以我们可以使m每次增加一倍，m>n-1时的结果与n-1时结果相同，最终被压缩到O(n3*lgn).
具体代码
import java.util.Scanner;
public class Dynamic_ShortestPath {
private static final int INFINITE = 1000000;
public static void main(String[] args) {
int[][] matrix = initialize();
print(getShortestPath(matrix));
}
public static int[][] initialize(){
Scanner input = new Scanner(System.in);
System.out.print("Please enter the size of the matrix:");
int n = input.nextInt();
System.out.println("Please enter the elements of the matrix:");
int[][] data = new int[n][n];
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
data[i][j] = input.nextInt();
return data;
}
public static int[][] extendPath(int[][] matrix){
int[][] newmatrix = new int[matrix.length][matrix.length];
for(int i=0;i<matrix.length;++i)
for(int j=0;j<matrix.length;++j){
newmatrix[i][j]=INFINITE;
for(int k=0;k<matrix.length;++k)
if(matrix[i][k] + matrix[k][j] < newmatrix[i][j]){
newmatrix[i][j] = matrix[i][k] + matrix[k][j];
}
}
return newmatrix;
}
public static int[][] getShortestPath(int[][] matrix){
int m = matrix.length;
int i = 1;
while(i<m-1){
matrix = extendPath(matrix);
m*=2;
}
return matrix;
}
public static void print(int[][] matrix){
for(int i=0;i<matrix.length;i++)
for(int j=0;j<matrix.length;j++){
//if(matrix[i][j]!=INFINITE && i!=j) {
if(i!=j) {
System.out.println("From " + i + " to " + j + " the cost is " + matrix[i][j]);
}
}
}
}实验结果
输入：（取自算法书P134）
Please enter the size of the matrix:5
Please enter the elements of the matrix:
0 3 8 1000000 -5
1000000 0 1000000 1 7
1000000 4 0 1000000 3
2 1000000 -4 0 1000000
1000000 1000000 1000000 6 0输出：
From 0 to 1 the cost is 1
From 0 to 2 the cost is -3
From 0 to 3 the cost is 1
From 0 to 4 the cost is -5
From 1 to 0 the cost is 3
From 1 to 2 the cost is -3
From 1 to 3 the cost is 1
From 1 to 4 the cost is -2
From 2 to 0 the cost is 7
From 2 to 1 the cost is 4
From 2 to 3 the cost is 5
From 2 to 4 the cost is 2
From 3 to 0 the cost is 2
From 3 to 1 the cost is 0
From 3 to 2 the cost is -4
From 3 to 4 the cost is -3
From 4 to 0 the cost is 8
From 4 to 1 the cost is 6
From 4 to 2 the cost is 2
From 4 to 3 the cost is 6
Process finished with exit code 0FloydWarshall算法
适用条件：
没有负环（可有负权重）
原理讲解：
warshall时间复杂度可以达到O(V^3)，而warshall算法的实现基于以下现象的观察：
对于中间节点取自（1,2,3,…,k）的最短路径，它是由中间节点取自（1,2,3,…,k-1）的最短路径构成的。
得到以下递归式：
算法步骤：
1.初始化存储权重的矩阵和前驱结点矩阵
2.自底向上进行动态规划，k从0到matrix.length，判断if(matrix[i][k] + matrix[k][j] < matrix[i][j])来创建新的数据矩阵和前驱矩阵；
3.根据遍历完的结果，输出答案。
具体代码
import java.util.Scanner;
public class FloydWarshall {
private static final int INFINITE = 1000000000;
public static void main(String[] args){
int[][] matrix = initialize();
int[][] parent = new int[matrix.length][matrix.length];
for(int i = 0; i < parent.length; ++i)
for(int j = 0; j < parent.length; ++j){
if(i == j)
parent[i][j] = 0;
else{
if(matrix[i][j] != INFINITE)
parent[i][j] = i;
else
parent[i][j] = -1;
}
}
printPath(floyd_warshall(matrix,parent),parent);
}
public static int[][] initialize(){
Scanner input = new Scanner(System.in);
System.out.print("Please enter the size of the matrix:");
int n = input.nextInt();
System.out.println("Please enter the elements of the matrix:");
int[][] data = new int[n][n];
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
data[i][j] = input.nextInt();
return data;
}
public static int[][] floyd_warshall(int[][] matrix,int[][] parent){
for(int k = 0; k < matrix.length; ++k){
int[][] newMatrix = new int[matrix.length][matrix.length];
int[][] newParent = new int[parent.length][parent.length];
for(int i = 0; i < matrix.length; ++i)
for(int j = 0; j < matrix.length; ++j){
if(matrix[i][k] + matrix[k][j] < matrix[i][j]){
newMatrix[i][j] = matrix[i][k] + matrix[k][j];
newParent[i][j] = parent[k][j];
}else{
newMatrix[i][j] = matrix[i][j];
newParent[i][j] = parent[i][j];
}
}
matrix = newMatrix;
for(int m = 0; m < parent.length; ++m)
for(int n = 0; n < parent.length; ++n)
parent[m][n] = newParent[m][n];
}
return matrix;
}
public static void printPath(int[][] matrix,int[][] parent){
for(int i = 0; i < matrix.length; ++i)
for(int j = 0; j < matrix.length; ++j){
if(matrix[i][j] != INFINITE && i != j){
System.out.print("From " + i + " to " + j + " the cost is:" + matrix[i][j]
+ "\nThe path is: " + j +" ");
int temp = j;
while((temp = parent[i][temp]) != i)
System.out.print("<< " + temp + " ");
System.out.println("<< " + i + " ");
}
}
}
}实验结果
输入：
Please enter the size of the matrix:5
Please enter the elements of the matrix:
0 3 8 1000000 -5
1000000 0 1000000 1 7
1000000 4 0 1000000 3
2 1000000 -4 0 1000000
1000000 1000000 1000000 6 0输出：
From 0 to 1 the cost is:1
The path is: 1 << 2 << 3 << 4 << 0
From 0 to 2 the cost is:-3
The path is: 2 << 3 << 4 << 0
From 0 to 3 the cost is:1
The path is: 3 << 4 << 0
From 0 to 4 the cost is:-5
The path is: 4 << 0
From 1 to 0 the cost is:3
The path is: 0 << 3 << 1
From 1 to 2 the cost is:-3
The path is: 2 << 3 << 1
From 1 to 3 the cost is:1
The path is: 3 << 1
From 1 to 4 the cost is:-2
The path is: 4 << 0 << 3 << 1
From 2 to 0 the cost is:7
The path is: 0 << 3 << 1 << 2
From 2 to 1 the cost is:4
The path is: 1 << 2
From 2 to 3 the cost is:5
The path is: 3 << 1 << 2
From 2 to 4 the cost is:2
The path is: 4 << 0 << 3 << 1 << 2
From 3 to 0 the cost is:2
The path is: 0 << 3
From 3 to 1 the cost is:0
The path is: 1 << 2 << 3
From 3 to 2 the cost is:-4
The path is: 2 << 3
From 3 to 4 the cost is:-3
The path is: 4 << 0 << 3
From 4 to 0 the cost is:8
The path is: 0 << 3 << 4
From 4 to 1 the cost is:6
The path is: 1 << 2 << 3 << 4
From 4 to 2 the cost is:2
The path is: 2 << 3 << 4
From 4 to 3 the cost is:6
The path is: 3 << 4
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
