解法一：Dijkstra+堆优化

真是艹了。题目没明确说是无向图，WA了还几次。用 BufferedReader.readLine() 读入，最大的那个测试点输入就直接超内存了。找了一种Java快速IO的写法重新处理了一下输入。

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
class Main {
    public static void main(String[] args) throws IOException {
        StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        in.nextToken();
        final int N = (int) in.nval;
        in.nextToken();
        final int M = (int) in.nval;
        in.nextToken();
        final int src = (int) in.nval;
        in.nextToken();
        final int dst = (int) in.nval;
        Point[] points = new Point[N];
        for (int i = 0; i < N; ++i) {
            points[i] = new Point();
        }
        int[][][] graph = new int[2][N][N];
        for (int i = 0; i < 2; ++i) {
            for (int j = 0; j < N; ++j) {
                Arrays.fill(graph[i][j], 10000000);
            }
        }
        for (int i = 0, u, v, dis, cost; i < M; ++i) {
            in.nextToken();
            u = (int) in.nval;
            in.nextToken();
            v = (int) in.nval;
            in.nextToken();
            dis = (int) in.nval;
            in.nextToken();
            cost = (int) in.nval;
            graph[0][u][v] = dis;
            graph[1][u][v] = cost;
            graph[0][v][u] = dis;
            graph[1][v][u] = cost;
        }
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return points[o1].dis - points[o2].dis;
            }
        };
        PriorityQueue<Integer> heap = new PriorityQueue<>(comparator);
        points[src].dis = 0;
        heap.offer(src);
        int cnt = 0;
        int newDis, newCost;
        while (!heap.isEmpty()) {
            int start = heap.poll();
            if (points[start].isVisited) {
                continue;
            }
            points[start].isVisited = true;
            if (++cnt == N) {
                break;
            }
            for (int i = 0; i < N; ++i) {
                if (points[i].isVisited) {
                    continue;
                }
                newDis = points[start].dis + graph[0][start][i];
                newCost = points[start].cost + graph[1][start][i];
                if ((newDis < points[i].dis) ||
                        ((newDis == points[i].dis) && (newCost < points[i].cost))) {
                    points[i].dis = newDis;
                    points[i].cost = newCost;
                    heap.offer(i);
                }
            }
        }
        out.println(points[dst].dis + " " + points[dst].cost);
        out.flush();
    }
}
class Point {
    int dis;
    int cost;
    boolean isVisited;
    Point() {
        dis = Integer.MAX_VALUE;
        cost = 0;
        isVisited = false;
    }
}