PAT 1030

　　dij最短路，这道题稍微麻烦一点的是如果路径长度相同，需要找到cost更小的那条路。在dij最短路中，如果更新到某个节点，发现从该路到这个节点的dist相同，且cost更小，则直接更新cost就可以了。因为只是看该节点的最短路如何，贪心就能过，不知道是不是正确的，如果我自己实现的话肯定是反过来再加一个dfs了，也比较好写。感觉C++在传值，传引用这方面更加灵活，JAVA就很不靠谱的感觉。刚看了一个文章说是scala会取代JAVA，JAVA的确是太庞大了，比起C++来说，直观感觉还是JAVA更大一点。另外JAVA写程序真没什么优势，都要写好长啊... 和C++差不太多，因为要写一个FastReader看起来就更蠢了... 但是没办法o(︶︿︶)o 

　　首先还是再写一下dij最短路算法吧。步骤如下

　　1. 初始化一个dij_dist数组，数组中将start定为0，其余为MAX

　　2. 重复以下过程，直到所有节点都被访问过了

　　　　a. 从未访问过的节点中找到dij_dist值最小的节点，并且将它标记为访问过了

　　　　b. 更新未访问过的节点的dij_dist值，如果graph[least_idx][i] + dij_dist[least_idx] < dij_dist[i]，则更新

　　对dij_cost的更新放在每次更新dij_dist值的时候，如果dist值相等再比较一下cost值，并更新。

　　从这道题我想到了，和leetcode很不一样的是，PAT更像ACM一点，如果能够直接用数组开出来空间就不要怕浪费了，无所谓的... 不要强迫症了... 能直接贪心过的也不要管，PAT考完就好了。

　　对于我这种不会写JAVA的人来说还是轻松点好..  　　

　　而且这道题很容易过啊= = 耗时最长的一个点才50ms

　　代码如下

　

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;

class FastReader{
    BufferedReader reader;
    StringTokenizer tokenizer;
    
    public FastReader(InputStream stream){
        reader = new BufferedReader(new InputStreamReader(stream), 1 << 10);
        tokenizer = null;
    }
    
    public String next(){
        while (tokenizer == null || !tokenizer.hasMoreTokens()){
            try{
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (Exception e){
                throw new RuntimeException(e);
            }
        }
        
        return tokenizer.nextToken();
    }
    
    public long next_long(){
        return Long.parseLong(next());
    }
    
    public int next_int(){
        return Integer.parseInt(next());
    }
}

public class Main {
    static int[] dij_dist;
    static int[] dij_cost;
    
    static int[] prev;
    static int[][] graph_cost;
    static int[][] graph_dist;
    static int MAX;
    static int N, M, S, D;
    
    static void dij_calc(){
        int start = S;
        
        dij_dist = new int[N];
        dij_cost = new int[N];
        prev = new int[N];
        
        Arrays.fill(dij_dist, Integer.MAX_VALUE);
        dij_dist[start] = 0;
        dij_cost[start] = 0;
        
        Set<Integer> done_set = new HashSet<Integer>();
        Set<Integer> find_set = new HashSet<Integer>();
        
        for (int i = 0; i < N; i++)
            find_set.add(i);
        
        while (!find_set.isEmpty()){
            Iterator<Integer> it;
            
            it = find_set.iterator();
            int least_dij_dist = MAX;
            int least_idx = 0;
            while (it.hasNext()){
                int next_idx = it.next();
                if (dij_dist[next_idx] < least_dij_dist){
                    least_dij_dist = dij_dist[next_idx];
                    least_idx = next_idx;
                }
            }
            
            if (least_dij_dist == MAX || least_idx == D)
                return;
            
            done_set.add(least_idx);
            find_set.remove(least_idx);
            
            it = find_set.iterator();
            while (it.hasNext()){
                int idx = it.next();
                if (least_dij_dist + graph_dist[least_idx][idx] < dij_dist[idx]){
                    dij_dist[idx] = least_dij_dist + graph_dist[least_idx][idx];
                    dij_cost[idx] = graph_cost[least_idx][idx] + dij_cost[least_idx];
                    prev[idx] = least_idx;
                } else if (least_dij_dist + graph_dist[least_idx][idx] == dij_dist[idx]){
                    if (graph_cost[least_idx][idx] + dij_cost[least_idx] < dij_cost[idx]){
                        dij_cost[idx] = graph_cost[least_idx][idx] + dij_cost[least_idx];
                        prev[idx] = least_idx;
                    }
                }
            }
        }
    }
    
    @SuppressWarnings("unchecked")
    public static void main(String[] args){
        FastReader reader = new FastReader(System.in);
        
        MAX = (1 << 20);
        
        N = reader.next_int();
        M = reader.next_int();
        S = reader.next_int();
        D = reader.next_int();
        
        graph_cost = new int[N][N];
        graph_dist = new int[N][N];
        
        for (int i = 0; i < N; i++){
            Arrays.fill(graph_dist[i], MAX);
            Arrays.fill(graph_cost[i], MAX);
        }
        
        for (int i = 0; i < M; i++){
            int city1, city2;
            int dist, cost;
            
            city1 = reader.next_int();
            city2 = reader.next_int();
            dist = reader.next_int();
            cost = reader.next_int();
            
            graph_dist[city1][city2] = dist;
            graph_dist[city2][city1] = dist;
            graph_cost[city1][city2] = cost;
            graph_cost[city2][city1] = cost;
        }
        
        dij_calc();
        
        Stack<Integer> ans_stack = new Stack<Integer>();
        int idx = D;
        while (idx != S){
            ans_stack.push(idx);
            idx = prev[idx];
        }
        ans_stack.push(S);
        
        while (!ans_stack.empty())
            System.out.print(ans_stack.pop() + " ");
        System.out.println(dij_dist[D] + " " + dij_cost[D]);
    }
}