题目1008：最短路径问题(2010年浙江大学计算机及软件工程研究生机试真题)

题目1008：最短路径问题

时间限制：1 秒

内存限制：32 兆

特殊判题：否

提交：5199

解决：1655

题目描述：

给你n个点，m条无向边，每条边都有长度d和花费p，给你起点s终点t，要求输出起点到终点的最短距离及其花费，如果最短距离有多条路线，则输出花费最少的。

输入：

输入n,m，点的编号是1~n,然后是m行，每行4个数 a,b,d,p，表示a和b之间有一条边，且其长度为d，花费为p。最后一行是两个数 s,t;起点s，终点t。n和m为0时输入结束。
(1<n<=1000, 0<m<100000, s != t)

输出：

输出 一行有两个数， 最短距离及其花费。

样例输入：

3 2
1 2 5 6
2 3 4 5
1 3
0 0

样例输出：

9 11

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class Main {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
         
        while( scanner.hasNext() ){
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            if(n == 0 && m == 0) break;
             
            List<Edge> edges[] = new ArrayList[n+1];
            for (int i = 1; i < edges.length; i++) {
                edges[i] = new ArrayList<Edge>();
            }
             
            Edge edgetmps[] = new Edge[1001];
            for (int i = 0; i < edgetmps.length; i++) {
                edgetmps[i] = new Edge();
            }
             
            while(m-- != 0){
                int a = scanner.nextInt();
                int b = scanner.nextInt();
                int d = scanner.nextInt();
                int p = scanner.nextInt();
                edgetmps[a] = new Edge();
                edgetmps[a].d = d;
                edgetmps[a].p = p;
                edgetmps[a].next = b;
                 
                edges[a].add(edgetmps[a]);
 
 
                edgetmps[b] = new Edge();
                edgetmps[b].d = d;
                edgetmps[b].p = p;
                edgetmps[b].next = a;
                edges[b].add(edgetmps[b]);
            }
             
            int s = scanner.nextInt();
            int e = scanner.nextInt();
            int Dis[] = new int[1001];
            int cost[] = new int[1001];
            boolean mark[] = new boolean[1001];
            Arrays.fill(mark, false);
            Arrays.fill(Dis, -1);
            Arrays.fill(cost, 0);
             
            Dis[s] = 0;
            mark[s] = true;
            int newP = 1;
            for (int i = 1; i < n; i++) {
                for (int j = 0; j < edges[newP].size(); j++) {
                    int t = edges[newP].get(j).next;
                    int d = edges[newP].get(j).d;
                    int p = edges[newP].get(j).p;
                     
                    if(mark[t] == true) continue;
                    if(Dis[t] == -1 || Dis[t] > Dis[newP] + d 
                            || (Dis[t] == Dis[newP] + d && cost[t] > cost[newP] + p)){
                        Dis[t] = Dis[newP] + d;
                        cost[t] = cost[newP] + p;
                    }
                }
                 
                int min = 123123123;
                for (int j = 1; j <=n; j++) {
                    if(mark[j] == true) continue;
                    if(Dis[j] == -1) continue;
                    if(Dis[j] < min){
                        min = Dis[j];
                        newP = j;
                    }
                }
                mark[newP] = true;
                 
            }
             
            System.out.println(Dis[e]+" "+cost[e]);
        }
    }
     
    public static class Edge{
        int next;
        int p;
        int d;
         
    }
 
}
 
/**************************************************************
    Problem: 1008
    User: yihukurama
    Language: Java
    Result: Accepted
    Time:370 ms
    Memory:27484 kb
****************************************************************/