带权图 最短路径 代码自己写
最短路径问题
可能在带权图中，最常用遇到的问题就是，寻找两个点间的最短路径问题。
这个问题的解决方法可以应用在现实生活中很多情况，从印刷电路板到项目的调度都适合，但是它
比前面见到过的问题更负责一些，所以首先还是来看一个真是世界的场景，它还是发生在前面的引入的那个虚拟的国家
铁路线。
这次我们来模拟的是铁路线而不是有线电路线了。然而，这个项目不像上一个那么浩大，这次并不是要修铁路
而是铁路已经建好了。这次只是想找到从一个到另一个城市的最低费用
旅客在两个城市间搭乘火车需要固定的费用。
图的边是有方向的，也就是有向带权的。我们要最关心的是路费的便宜了。最类问题叫做最短路径问题。这里说说的最短
并不一定只的是距离的最短，可能是费用的最少，时间的最少，效果的最好。、
最便宜的费用
任何两个城市间都有几条可能的路线，最短路径是这样的：
对一个给定的原点和终止点，走哪条线路费用最低，带有向带权图
正如前面提到的，铁路只有一个方向，所以火车在任何两个城市间只能朝一个方向进行。这相当于一个有向图，本来应该
描述一个更接近现实的情况，也就是乘客可以花同样的钱在两个城市间往返。那就相当于一个无向图了。然而最短路径的问题
在这两种情况下是类似的。所以为了体现多样性，我们来看这个问题在有向图中是怎样解决掉的
Dijkstra 算法
为了解决最短路径问题而提出来的方法叫做Dijkstra算法，Edsger Dijkstra在1959年解决了这个问题。
这个算法是的实现是基于图的连接矩阵的表示法中的。让人感到有些惊奇的是它不仅仅能够找到任意两点间的最短路径，
还可以找到某个指定点到其其他所有顶点的最短路径。
代理人和铁路路线
我们假设的要从a这个顶点开始，找到它到其他顶点的最低费用的路线。
我们开始我们的想法了：
在每个城市中，站长会告诉从该站到下一个站点的费用，也就是单程的费用。但是这个站长不知道，其他站的价格了。
这里需要用到一个记事本，本子为每个城市留一列位子，并且希望每一列的最后显示从源点到其他城市的最低费用。
第一个代理人：在A城市
最终，需要再每个城市放一个代理人，这个代理人的工作就是保持到其他城市的信息费用的信息的。你自己就是A的代理人
A城市站长所能告诉你的是到B城市的价格还有就是D城市的费用，把这些记录叜笔记本上，如果站长不知道，那么就记无限大。
意味着不能从A到达表中的每一列的列头所示的城市，或者至少目前为止不知道如何到达那里。 （这个信息有用的，不要着急）
规则
总是把本站代理人的弟弟派到下一个城市去，从源点到这个城市的最低费用。一起到B城市去，在那里成成为了代理人。当他达到那里的时候，
他将问站长到下一站 C 和 D的费用 其他是无线大
经过简单的计算以后，从A到B到C的费用110，所以修改了在笔记本上的条目，从A经过B到D的费用是140元
然而刚才知道了从A到D的费用是80元，由于值关心的是从A出发到目的地的最低费用，所以忽略这条最贵的路线了。笔记本上相应的条目也不做修改了
在某个城市有代理人以后，可以确定的是这个代理人走过的路费是费用最低的路线。为什么呢？考虑现在的情况，如果有另一个线路比从A到B的直接
连接更便宜，它需要通过其他的城市，但是从A厨房的另一条路线到D，它已经比到B的直接费用更加贵了。加上D到B的费用，使得这条费用更加贵了
因此可以确定的是，从现在开始，不需要改动A到B的最低费用了，不管找到什么城市，这个费用都是不会变的。在它的旁边标注一个*号，表示在这个
城市有一个代理人了，并且到它的最低费用是固定的。
/**
* path()方法真正的执行了最短路径算法，它使用DisPar类和Vertex类，这个类在mstw.java程序
* 原点总是在vertxList[] 数组下标为0的位子，path()方法的第一个任务是把这个顶点放入树中，算法
* 执行过程中，将会把其他顶点也逐一放入树中。把顶点放入树中的操作是设置标志，并把nTree变量增加1，
* 这个变量记录了树中有多少个顶点。
*
* 第二path()方法把邻接矩阵的对应行表达的距离的值复制到sPath[]中，实际总是先从第0行
* 复制，为了简单，假定源点的下标总为0，最开始，所有sPath[]数组中父节点字段为A，也就是源点。
* 现在进入算法的主要循环，等到所有的顶点都放入到树中，这个循环 就结束，这个循环中有是基本操作
*
* 1. 选择sPath[]数组的最小距离
* 2. 把对应的顶点找出来（这个最小距离所在列的题头）放入树中，这个点变成当前的顶点，currentVer
* 3.根据currentVert的变化，更新所有的sPath[]数组的内容。
*如果path()方法发现最小距离是无穷大，它就知道有些顶点从源点不能到达。为什么？因为不是所有的顶点都是在树中
*（while 循环没有结束），尚无方法可以到达那些树外的顶点；如果有，就不会足无穷大了的距离了
*
* 返回前path()方法调用display显示 并且最后复位所有的顶点
*
*
*
*
* @return
*/
public int[] djisk() {
// this.currentVetex = 0 ;
// this.vertexList[0].setProxyer(true) ; //标记为设置了代理人的
//
// for (int i=currentVetex+1; i<this.nVertex; i++) {
//
// if(this.adjMat[currentVetex][i] == this.BIGGER) {
//
// this.sPath[i] = this.BIGGER ;
// continue ;
//
// }
//
// this.sPath[i] = this.adjMat[]
//
//
//
// }
//
//
return null ;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
迪杰斯特拉（Dijkstra）
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
创建边
package endual;
public class Edge {
public int srcVert ; //一个顶点开始的序列好
public int destVert ; //一个顶点结束的序号
public int distance ;//从开始到介绍的长度
public Edge(int srcVert, int destVert, int distance) {
super();
this.srcVert = srcVert;
this.destVert = destVert;
this.distance = distance;
}
}
创建顶点
package endual;
public class Vertex {
private char label;
private boolean isInTree;
public Vertex(char a) {
this.label = a;
this.isInTree = false;
}
public char getLabel() {
return label;
}
public void setLabel(char label) {
this.label = label;
}
public boolean isInTree() {
return isInTree;
}
public void setInTree(boolean isInTree) {
this.isInTree = isInTree;
}
}
创建一个辅助的类
package endual;
public class DistPar {
private int distance;
private int parentVert;
public DistPar(int distance, int parentVert) {
super();
this.distance = distance;
this.parentVert = parentVert;
}
public int getDistance() {
return distance;
}
public void setDistance(int distance) {
this.distance = distance;
}
public int getParentVert() {
return parentVert;
}
public void setParentVert(int parentVert) {
this.parentVert = parentVert;
}
}
创建一个图
其中path就是最短路径算法了
package endual;
public class Graph {
private final int MAX_SIZE = 20;
private final int INF = 1000000;
private Vertex[] vertexList;
private int adjMat[][];
private int nVerts;
private int nTree;
private DistPar sPath[];
private int currrentSize;
private int startTOCurrent;
private int currentVertex;
public Graph() {
super();
this.vertexList = new Vertex[this.MAX_SIZE];
this.adjMat = new int[this.MAX_SIZE][this.MAX_SIZE];
initialAdjMat();
this.nVerts = 0;
this.nTree = 0;
this.sPath = new DistPar[this.MAX_SIZE];
this.currrentSize = 0;
this.startTOCurrent = 0;
}
private void initialAdjMat() {
for (int i = 0; i < this.MAX_SIZE; i++) {
for (int j = 0; j < this.MAX_SIZE; j++) {
this.adjMat[i][j] = this.INF;
}
}
}
// 插入顶点
public void insert(char a) {
Vertex v = new Vertex(a);
this.vertexList[this.nVerts] = v;
this.nVerts++;
}
// 插入边怎么没有边啊啊
public void addEdge(int start, int end, int weight) {
this.adjMat[start][end] = weight;
}
public void path() {
int startTree = 0;
this.vertexList[startTree].setInTree(true); // 已经放入到树中了
this.nTree++;
// 转换虫adjMat的列的长度到数组中去sPath
for (int j = 0; j < this.nVerts; j++) {
int tempDist = this.adjMat[startTree][j];
DistPar tempDistPar = new DistPar(startTree, tempDist);
sPath[j] = tempDistPar;
}
while (this.nTree < this.nVerts) {
// 从sPath()中选择出边的长度最短的，这个getMin的是这个边的标号，最先的indexMin的标号
int indexMin = getMin();
//
int minDist = this.sPath[indexMin].getDistance(); // 得到这个长度
if (minDist == this.INF) {
System.out.printf("None Edges");
break;
} else {
currentVertex = indexMin; // 当前的顶点的在数组中的标号
this.startTOCurrent = sPath[indexMin].getDistance(); // 当前顶点连接各个边的最短的长度
// 最小的长度从开始的顶点开始的，转换到当前的顶点，然后
}
this.vertexList[this.currentVertex].setInTree(true); // 设置到树中了
this.nTree++;
adjust_sPath(); // 更新spathp[]数组
} //end while
displayPaths() ;
this.nTree = 0 ;
for (int j=0; j < this.nVerts; j++) {
this.vertexList[j].setInTree(false) ;
}
}
//显示所有的最短路径
private void displayPaths() {
for (int i=0; i < this.nVerts; i++) {
System.out.println(this.vertexList[i].getLabel()) ;
if (this.sPath[i].getDistance() == this.INF) {
System.out.println("Inf") ;
}else {
System.out.println(this.sPath[i].getDistance()) ;
}
char parent = this.vertexList[this.sPath[i].getDistance()].getLabel() ;
System.out.print("{" + parent + "}") ;
}
System.out.println(" ") ;
}
private void adjust_sPath() {
int column = 1 ;
while (column < this.nVerts) {
if (this.vertexList[column].isInTree()) {
column++ ;
continue ;
} // end if
int currentToFringe = this.adjMat[this.currentVertex][column] ;
int startToFrige = this.startTOCurrent + currentToFringe ;
int sPathDist = this.sPath[column].getDistance() ;
if (startToFrige < sPathDist) {
this.sPath[column].setParentVert(currentVertex) ;
this.sPath[column].setDistance(startToFrige) ;
}
column++ ;
} //end while
}
private int getMin() {
int minDist = this.INF;
int indexMin = 0;
for (int j = 1; j < this.nVerts; j++) {
if (!this.vertexList[j].isInTree()
&& this.sPath[j].getDistance() < minDist) {
minDist = this.sPath[j].getDistance();
indexMin = j;
}
}
return indexMin;
}
}