DFS和广度优先遍历求两点最短路

DFS求两点最短路。

给定2个点，from和to，代表出发点和结束点，求从from到to的一条最优路径。

从from点开始，以优先深度遍历整个图。

使用一个数组s，对于已经遍历过的顶点，标志为1，回溯的时候重置回0.为的是防止重复遍历图的某个环。

当该点对应的s数组为0时，递归下去决策该点。

package 两点最短路径;

import java.util.ArrayList;

public class DFS求两点最短路 {
	static final int N=8;
	static int from=5,to=6;//出发点到结束点
	static int map[][]={
			{0,0,0,0,0,0,0,0,0},
			{0,0,17,13,0,21,0,0,0},
			{0,0,0,0,11,0,13,0,0},
			{0,7,0,0,22,0,0,0,13},
			{0,0,0,0,0,0,1,0,18},
			{0,0,0,0,0,0,0,10,0},
			{0,0,0,0,0,0,0,0,0},
			{0,0,0,1,0,0,0,0,15},
			{0,0,0,3,0,0,21,0,0}
	};
	
	static int s[]=new int[N+1];
	static int pre[]=new int[N+1];//最终解
	static int temppre[]=new int[N+1];//临时解
	static int best=Integer.MAX_VALUE;
	public static void main(String args[])
	{
		ArrayList list = new ArrayList();
		f(from,0);
		System.out.println("最优路径权值为:"+best);
		System.out.println("最优路为:");
		prin(to);
	}
	
	public static void prin(int n)
	{
		if(n==0)return;
		prin(pre[n]);
		System.out.print(" "+n);
			
	}
	
	public static void f(int n,int sum)
	{
		if(n==to)
		{
			if(best>sum)
			{
				best=sum;
				for(int i =1;i

广度优先遍历，用一个队列存放当前顶点合法的邻接点。

每次出队一个顶点，然后把该顶点的邻接点入队。

每个顶点有一个前驱属性，指向该顶点的前驱节点。

package 两点最短路径;

import java.util.ArrayList;
import java.util.Collections;

public class 广度优先求两点最短路 {
	 public static  class Node implements Comparable{
		int bh;
		int sum;
		Node pre;
		public Node(int bh,int sum,Node pre){
			this.bh=bh;
			this.sum=sum;
			this.pre=pre;
		}
		
		public int compareTo(Node o) {
			if(this.sum>o.sum)
				return -1;
			else if(this.sum list = new ArrayList();
		list.add(new Node(from,0,null));
		
		while(list.size()>=1)
		{
			Node temp = list.remove(0);
			if(temp.bh==to)//如果到达目标点
			{
				if(best.sum>temp.sum)
					best=temp;
			}
			else
			{
				for(int i=1;i<=N;i++)//没有到达目标点，则把出队顶点的邻接点纳入队列
				{
					if(map[temp.bh][i]!=0&&ifz(temp,i) && temp.sum

运行结果：

最优权值为：29
最优路径是：
 1 2 4 6