算法设计与分析基础-8.2、warshall算法和Floyd算法

求传递闭包
warshall算法时间复杂度O(n3)

传递闭包：一个n阶布尔矩阵T={i，j}，如果从第i个顶点到第j个顶点之间存在一条有效的有向路径，则T[i][j]=1,否则T[i][j]=0

完全最短路径问题要求找到从每个顶点到其他所有顶点之间的距离

Floyd算法通过一系列n阶矩阵来计算一个n顶点加权图的距离矩阵

import java.util.ArrayList;
public class MatrixGraph<T> {
public final static int MAX_VERTEX = 6;
private ArrayList<T> vertexList;
private int[][] matrix;
private int edgeNum;
private int vertexNum;


public MatrixGraph() {
edgeNum = 0;
vertexNum = 0;
vertexList = new ArrayList<T>();
matrix = new int[MAX_VERTEX][MAX_VERTEX];
}


public MatrixGraph(int max)
{
edgeNum = 0;
vertexNum = 0;
vertexList = new ArrayList<T>();
matrix = new int[MAX_VERTEX][MAX_VERTEX];
for (int i = 0; i < MAX_VERTEX; i++) {
for (int j = 0; j < MAX_VERTEX; j++)
matrix[i][j]=max;
}
}

private boolean addEdge(T startVertex, T endVertex, int length) {
boolean isAdd = false;
if (vertexList.contains(startVertex) && vertexList.contains(endVertex)) {
int startNum = vertexList.indexOf(startVertex);
int endNum = vertexList.indexOf(endVertex);
isAdd = true;
if (matrix[startNum][endNum] == 0)
edgeNum++;
matrix[startNum][endNum] = length;
}
return isAdd;


}


private boolean addEdge(T startVertex, T endVertex) {
return addEdge(startVertex, endVertex, 1);
}


private boolean addVertex(T vertex) {
boolean isAdd = false;
if (getVertexNum() < MAX_VERTEX && !vertexList.contains(vertex)) {
vertexList.add(vertex);
matrix[vertexNum][vertexNum]=0;
vertexNum++; 
isAdd = true;
}
return isAdd;
}


public int getEdgeNum() {
return edgeNum;
}


public int getVertexNum() {
return vertexNum;
}


public int[][] getMatrix() {
return matrix;
}


public int[][] warshall() {
int[][] warshallMatrix = new int[vertexNum][vertexNum];
for (int i = 0; i < vertexNum; i++)
for (int j = 0; j < vertexNum; j++)
warshallMatrix[i][j] = matrix[i][j];
for (int k = 0; k < vertexNum; k++) {
for (int i = 0; i < vertexNum; i++)
for (int j = 0; j < vertexNum; j++)
if (warshallMatrix[i][k] > 0 && warshallMatrix[k][j] > 0)
warshallMatrix[i][j] = 1;
showMatrix(warshallMatrix);
}
return warshallMatrix;
}


public int[][] Floyd() {
int[][] floydMatrix = new int[vertexNum][vertexNum];
for (int i = 0; i < vertexNum; i++)
for (int j = 0; j < vertexNum; j++)
floydMatrix[i][j] = matrix[i][j];
for (int k = 0; k < vertexNum; k++) {
for (int i = 0; i < vertexNum; i++)
for (int j = 0; j < vertexNum; j++) {
int d = floydMatrix[i][k] + floydMatrix[k][j];
if (d < floydMatrix[i][j])
floydMatrix[i][j] = d;
}
showMatrix(floydMatrix);
}
return floydMatrix;
}


public void showMatrix(int[][] matrix) {
for (int i = 0; i < vertexNum; i++) {
for (int j = 0; j < vertexNum; j++)
System.out.print(matrix[i][j] + "  ");
System.out.println();
}
}


public void removeAllEdges() {
for (int i = 0; i < MAX_VERTEX; i++)
for (int j = 0; j < MAX_VERTEX; j++)
matrix[i][j] = 0;
}


public boolean removeEdge(T startVertex, T endVertex) {
boolean isRemove = false;
if (vertexList.contains(startVertex) && vertexList.contains(endVertex)) {
int startNum = vertexList.indexOf(startVertex);
int endNum = vertexList.indexOf(endVertex);
isRemove = true;
if (matrix[startNum][endNum] != 0) {
edgeNum--;
matrix[startNum][endNum] = 0;
} else {
isRemove = false;
}
}
return isRemove;
}


public static void main(String[] argv) {
MatrixGraph<String> matrixGraph = new MatrixGraph<String>();
matrixGraph.addVertex("a");
matrixGraph.addVertex("b");
matrixGraph.addVertex("c");
matrixGraph.addVertex("d");
matrixGraph.addEdge("a", "b");
matrixGraph.addEdge("b", "d");
matrixGraph.addEdge("d", "a");
matrixGraph.addEdge("d", "c");
for (int i = 0; i < MAX_VERTEX; i++) {
for (int j = 0; j < MAX_VERTEX; j++)
System.out.print(matrixGraph.getMatrix()[i][j] + "  ");
System.out.println();
}
matrixGraph.warshall();


MatrixGraph<String> matrixGraph2=new MatrixGraph<String>(999);
matrixGraph2.addVertex("a");
matrixGraph2.addVertex("b");
matrixGraph2.addVertex("c");
matrixGraph2.addVertex("d");
matrixGraph2.addEdge("a", "c", 3);
matrixGraph2.addEdge("b", "a", 2);
matrixGraph2.addEdge("c", "b", 7);
matrixGraph2.addEdge("c", "d", 1);
matrixGraph2.addEdge("d", "a", 6);
for (int i = 0; i < MAX_VERTEX; i++) {
for (int j = 0; j < MAX_VERTEX; j++)
System.out.print(matrixGraph2.getMatrix()[i][j] + "  ");
System.out.println();
}
matrixGraph2.Floyd();
}
}