求助明天的面试题,大家帮看看 -----使用java语言,编写在有向图中查找最小路径的算法

[weichenggao]

此有向图是由通过"标准输入"进行输入，具体的输入格式是
<n1>:<n2>:<c1>
<n3>:<n4>:<c2>
<n5>:<n6>:<c3>
..
..
..
<nm>:<nn>:<cn>
其中，每一行<n1>:<n2>:<c1>
表示从<n1>节点到<n2>节点存在一个费用为<c1>的路径

此算法的输出是:从start节点到end节点找到一个费用为最小的路径，使用下面的形式输出:
start -> <m1> --> <m2> ....-> <mn> ->end: <cost>
其中<m1>,<m2>....<mn>为此路径上的节点,<cost>为此路径上总的花费

如果不存在这样的路径，就输出;此题无解

[飞跃颠峰]

有向图的最短路径，数据结构中有标准算法呀，建议你去查一下

[商科程序员]

先构造好图，然后广度优先搜索。

[qybao]

最基本的图遍历问题，每个节点设置一个访问状态，可以采用堆栈的方式处理

[shenyangong123]

你是hisoft的不？

[shenyangong123]

package com.lntu.test;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Graph {
//定义花费数组
private static int[][] cost;
//定义节点状态数组
private static boolean[] hasFlag;
//存储所有可能的路径的结果。每一条路径的格式是如：0->2->1->3:7
private static Map<Integer,String> minCostPath = new HashMap<Integer,String>();
// 求在图cost上起始节点s到目标节点d之间所有的简单路径，并求出路径的花费总和。
public static void getPaths(int s, int d, String path, int sum) {
// 设置起始节点已访问
hasFlag[s] = true;
for (int i = 0; i < cost.length; i++) {
// 若不可达或已访问过，则找下一个结点。
if (cost[s][i] == -1 || hasFlag[i]) {
continue;
}
//找到一条可达路径
if (i == d)
{
//如果花费与之前某可达路径的花费相同
if(minCostPath.containsKey((sum + cost[s][i]))){
//读取之前可达路径，并追加本次可达路径
String result=minCostPath.get((sum + cost[s][i]))+"\r"+path + "->" + d + ":" + (sum + cost[s][i]);
//将原来的minCostPath中的对象删除
minCostPath.remove((sum + cost[s][i]));
//添加新的更新后的对象
minCostPath.put((sum + cost[s][i]), result);
}else{
//向minCostPath中添加可达对象
minCostPath.put((sum + cost[s][i]), path + "->" + d + ":" + (sum + cost[s][i]));
}
continue;
}
//继续找其他可达路径
getPaths(i, d, path + "->" + i, sum + cost[s][i]);
hasFlag[i] = false;
}
}

[shenyangong123]

public static void main(String[] args) {
//定义控制台输入
Scanner sc=new Scanner(System.in);
//控制台输入节点数
int nodeCount=sc.nextInt();
//初始化有向带权图。-1表示无路可通。自己到自己也是-1。其它表示花费的权值。
cost=new int[nodeCount][nodeCount];
//初始化节点状态数组，true-表示该结点已访问过。false-表示还没有访问过。
hasFlag = new boolean[cost.length];
//生成有向带权图
for (int i = 0; i < nodeCount; i++) {
for (int j = 0; j < nodeCount; j++) {
if(i==j){
cost[i][j]=-1;
}else{
cost[i][j]=(int) Math.abs(Math.random()*10);
//如果i节点到j节点的花费等于0，则设i到j不可达
if(cost[i][j]==0){
cost[i][j]=-1;
}
}
System.out.print(cost[i][j]);
}
System.out.println();
}
//控制台输入起始节点
int start=sc.nextInt();
//如果起始节点超出节点范围，则重新输入
while(start<0||start>nodeCount){
start=sc.nextInt();
}
//输入结束结节点
int stop=sc.nextInt();
//同起始节点
while(stop<0||stop>nodeCount){
stop=sc.nextInt();
}
//从起始节点：start 到目的节点：stop,初始路径为："start" 初始花费：0
getPaths( start, stop,"" + start, 0);
//定义最小花费
int minCost=9999;
if(0==minCostPath.size()){
System.out.println(start+"到"+stop+"不可达！");
}else{
Set<Integer> key=minCostPath.keySet();
for (Integer integer : key) {
if(integer<minCost){
minCost=integer;
}
}
System.out.println(minCostPath.get(minCost));
}
}

}