PAT Advanced Level 1030. Travel Plan (30)(Java and C++)

PAT Advanced Level 1030. Travel Plan (30)

最短路径问题

我的思路：

1、SPFA算法，求出各个点的最短路径

2、DFS遍历，并将个各条到达目的地且路径最短的路线存储到pathVC

3、遍历pathVC求出minCost

看到别的大神有更加简便的思路：

思路（使用Dijkstra或者SPFA）：比较大小时，将距离相同但花费更短也作为更新的条件之一

            //比较大小时，将距离相同但花费更短也作为更新的条件之一  
            if (d[t]>d[v] + e.dis || (d[t] == d[v] + e.dis&&cost[t] > cost[v] + e.cost))  
            {  
                d[t] = d[v] + e.dis;  
                cost[t] = cost[v] + e.cost;  
                pre[t] = v;  
                que.push(P(d[t], t));  
            }

Java代码如下（AC）：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Vector;


public class Main{
	static Main  instance =new Main();
	
	static int N;
	static int M;
	static int S;
	static int D;
	
	static int[] dis;
	static int[] cost;
	static int[] vis;
	static Vector<Edge>[] map ;
	static final  int Inf  =Integer.MAX_VALUE-10000;
	public static void main(String[] args){
		Scanner sc =new Scanner(System.in);
		N =sc.nextInt();
		M =sc.nextInt();
		S =sc.nextInt();
		D =sc.nextInt();
		
		map =new Vector[N];
		vis =new int[N];
		dis =new int[N];
		for(int i =0;i<N;i++){
			map[i]=new Vector<Edge>();
			vis[i]=0;
			dis[i]=Inf;
		}
		cost=new int[M];
		
		for(int i=0;i<M;i++){
			int  c1 = sc.nextInt();
			int  c2 = sc.nextInt();
			int  distance = sc.nextInt();
			cost[i] = sc.nextInt();
			
			Edge e1 =instance.new Edge();
			e1.to=c2;
			e1.len  = distance;
			e1.eCost = cost[i];
			map[c1].add(e1);
			
			Edge e2 =instance.new Edge();
			e2.to=c1;
			e2.len =  distance;
			e2.eCost= cost[i];
			map[c2].add(e2);
		}
		
		SPFA(S);
		DFS(S,D,0);
		path.clear();
		int idx =-1;
		int minCost=Integer.MAX_VALUE;
		int[] shortedCost =new int[pathVC.size()];
		for(int i=0;i<pathVC.size();i++){
			path=pathVC.get(i);
			for(int j=0;j<path.size();j++){
				shortedCost[i] +=path.get(j).eCost;
			}
			if(minCost > shortedCost[i]){
				   minCost = shortedCost[i];
				   idx     = i;
			}
		}
		
		path =pathVC.get(idx);
		System.out.print(S+" ");
		for(int i=0;i<path.size();i++){
			System.out.print(path.get(i).to+" ");
		}
		System.out.print(dis[D]);
		System.out.print(" ");
		System.out.print(minCost);
	}
	
	public static void SPFA(int st){
		Queue<Integer> q =new LinkedList<Integer>();
		q.add(st);
		dis[st]=0;
		vis[st]=1;
		while(!q.isEmpty()){
			int cur =q.poll();
			Vector<Edge> adjEdges =map[cur];
			for(int i =0;i<adjEdges.size();i++){
				int to  =adjEdges.get(i).to;
				int len =adjEdges.get(i).len;
                if(dis[cur]+len <dis[to]){
                   dis[to]=dis[cur]+len;
                	if(vis[to]==0){
                		vis[to]=1;
                		q.add(to);
                	}
                }				
			}
		}
	}
	
	static Vector<Vector<Edge>>  pathVC =new Vector<Vector<Edge>>();
	static Vector<Edge>  path =new Vector<Edge>();
	public static void DFS(int st ,int des ,int distance){
		if(st==des){
			if(distance==dis[des]){
				Vector<Edge>  onePath =new Vector<Edge>();
				for(int i=0;i<path.size();i++){
					onePath.add(path.get(i));
				}
				pathVC.add(onePath);
			}
			path.clear();
			return;
		}
		if(distance>dis[st]){
			path.clear();
			return;
		}
		
		Vector<Edge> adjEdges =map[st];
		for(int i=0;i<adjEdges.size();i++){
			Edge e =adjEdges.get(i);
			int to  =e.to;
			int len =e.len;	
			if(dis[st]+len<=dis[to]){
				path.add(e);
				DFS(to,des,dis[to]);
			}
		}
		path.clear();
	}
	
	class Edge{
		int to;
		int len;
		int eCost;
	}

}

参考博客：

http://blog.csdn.net/gemire/article/details/20698375