java最短路径
我用的是递归调用方法，有个小问题就是在打印步数的时候是返向的，原因是就是程序不断的调用自己，到最后判断基值位准退出调用。这才开始从栈里取出方法进行执行的原因。
代码欣赏：
publicstaticintstep=1;
=newStringBuffer();
publicstaticint[][]maze={{1,1,1,1,1,1,1,1,1,1,1},
{1,0,1,0,1,0,0,0,0,0,1},
{1,0,1,0,0,0,1,0,1,1,1},
{1,0,0,0,1,0,1,0,0,0,1},
{1,0,1,1,0,0,1,0,0,1,1},//0代表可以通过，1代表不可通过
{1,0,1,0,1,1,0,1,0,0,1},
{1,0,0,0,0,0,0,0,1,0,1},
{1,0,1,0,1,0,1,0,1,0,1},
{1,0,0,1,0,0,1,0,1,0,1},
{1,1,1,1,1,1,1,1,1,1,1}};
publicstaticvoidmain(String[]args){
inti,j;//循环记数变量
Sample.way(1,1);//二维数组起始值从下标1，1开始
System.out.println("起点从坐标x=1,y=1开始");
System.out.println("终点坐标是x=8,y=9结束");
System.out.println("这是迷宫图表");
System.out.println("012345678910");
System.out.println("+---+---+---+---+---+---+---+---+---+---+---+---+---+");
for(i=0;i<10;i++){
System.out.print(""+i+"‖");
for(j=0;j<11;j++)
System.out.print("-"+maze[i][j]+"-‖");
System.out.println("");
System.out.println("+---+---+---+---+---+---+---+---+---+---+---+---+---+");
}
//打印显示步数
System.out.print(printStep.toString());
}
publicstaticbooleanway(intx,inty){
if(maze[8][9]==2)//代表递归终止条件（也就是当走出出口时标记为2）
returntrue;
else{
if(maze[y][x]==0){
maze[y][x]=2;
/*
*下面if判断条件代表当前坐标为基点，
*根据判断对当前位置进行递归调用：如：
*往上、往右上、往右、往右下、往下、
*往左下、往左、往左上的坐标是否可走，
*判断是否可走的返回条件是：
*2代表可通过、1代表不能通过、3表示已经走过，但是未能走通。
*/
if(way(x,y-1)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x+1,y-1)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x+1,y)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x+1,y+1)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x,y+1)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x-1,y+1)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x-1,y)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}elseif(way(x-1,y-1)){
printStep.append("第"+step+"步的所走的位置是x="+x+"y="+y+" ");
step++;
returntrue;
}else{
maze[y][x]=3;
returnfalse;
}
}else
returnfalse;
}
}
复制代码前需要楼主自己创建个类
Sample.way(1,1);这句代码是我的类的静态调用，改下XXXXX.way(1,1);
XXXXX代表你创建的类。
下面是这个程序运行后的截图
⑵ 求java算法源代码 求出汽车从起点S出发到达终点T的一条行驶路程最短的路线。
呵呵，你如果最短路径是m*n的这个前提就好算；如果最短不一定是m*n的话就成了一个迷宫问题同样求指点啊
⑶ 用java语言求最短路径
最短路径就是敲代码。 这个东西行业公认,没有比敲代码学语言更加快的路了。
如果是单纯感兴趣可以买两本书自学 什么thinkinjava之类的，开始肯定看不懂的,谁开始都看不懂,摸索着来,时间长了就理解了。如果有其它语言基础学起来就快多了,因为语言这种东西,除了语法不一样,逻辑都是一样的。
如果是工作需要什么的,可以找个培训啥的。当然前提你有钱。
最后顺带吐个槽,捷径好找的话，程序员这工作就不值钱了。
⑷ java中如何邻接矩阵遍历最短路径长度
packagetest;
importjava.util.ArrayList;
import清厅java.util.List;
/**
*java-用邻接矩阵求图的最短路径、最长途径。弗洛伊德算法
*/
publicclassFloydInGraph{
privatestaticintINF=Integer.MAX_VALUE;
privateint[][]dist;
privateint[][]path;
privateList<Integer>result=newArrayList<Integer>();
publicFloydInGraph(intsize){
this.path=newint[size][size];
this.dist=newint[size][size];
}
publicvoidfindPath(inti,intj){
intk=path[i][j];
答如隐if(k==-1)return;
findPath(i,k);
result.add(k);
findPath(k,j);
}
publicvoidfindCheapestPath(intbegin,intend,int[][]matrix){
floyd(matrix);
result.add(begin);
findPath(begin,end);
result.add(end);
}
publicvoidfloyd(int[][]matrix){
intsize=matrix.length;
for(inti=0;i<size;i++){
for(intj=0;j<size;j++){
path[i][j]=-1;
dist[i][j]=matrix[i][j];
}
}
for(intk=0;k<size;k++){
for(inti=0;i<size;i++){
for(intj=0;j<size;j++){
if(dist[i][k]!=INF&&
dist[k][j]!=INF&&
橡伍dist[i][k]+dist[k][j]<dist[i][j]){//dist[i][k]+dist[k][j]>dist[i][j]-->longestPath
dist[i][j]=dist[i][k]+dist[k][j];
path[i][j]=k;
}
}
}
}
}
publicstaticvoidmain(String[]args){
FloydInGraphgraph=newFloydInGraph(5);
int[][]matrix={
{INF,30,INF,10,50},
{INF,INF,60,INF,INF},
{INF,INF,INF,INF,INF},
{INF,INF,INF,INF,30},
{50,INF,40,INF,INF},
};
intbegin=0;
intend=4;
graph.findCheapestPath(begin,end,matrix);
List<Integer>list=graph.result;
System.out.println(begin+"to"+end+",thecheapestpathis:");
System.out.println(list.toString());
System.out.println(graph.dist[begin][end]);
}
}