結果

問題 No.807 umg tours
ユーザー neko_the_shadowneko_the_shadow
提出日時 2019-05-17 12:55:01
言語 Java21
(openjdk 21)
結果
TLE  
(最新)
AC  
(最初)
実行時間 -
コード長 3,246 bytes
コンパイル時間 3,700 ms
コンパイル使用メモリ 84,408 KB
実行使用メモリ 132,800 KB
最終ジャッジ日時 2024-05-02 23:52:33
合計ジャッジ時間 33,670 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 102 ms
43,860 KB
testcase_01 AC 105 ms
38,812 KB
testcase_02 AC 122 ms
39,340 KB
testcase_03 AC 112 ms
38,756 KB
testcase_04 AC 96 ms
38,064 KB
testcase_05 AC 103 ms
38,480 KB
testcase_06 AC 112 ms
39,064 KB
testcase_07 AC 106 ms
38,584 KB
testcase_08 AC 72 ms
37,904 KB
testcase_09 AC 79 ms
38,272 KB
testcase_10 AC 79 ms
37,976 KB
testcase_11 AC 1,976 ms
96,556 KB
testcase_12 AC 1,725 ms
95,604 KB
testcase_13 AC 2,117 ms
113,512 KB
testcase_14 AC 1,202 ms
76,756 KB
testcase_15 AC 1,026 ms
72,696 KB
testcase_16 AC 2,316 ms
118,092 KB
testcase_17 AC 2,590 ms
132,620 KB
testcase_18 AC 2,673 ms
132,800 KB
testcase_19 AC 2,338 ms
128,552 KB
testcase_20 AC 1,535 ms
94,684 KB
testcase_21 AC 1,510 ms
95,372 KB
testcase_22 AC 817 ms
69,712 KB
testcase_23 AC 697 ms
63,700 KB
testcase_24 TLE -
testcase_25 -- -
権限があれば一括ダウンロードができます

ソースコード

diff # 

package _0807;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
        String[] first = stdin.readLine().split(" ");
        int n = Integer.parseInt(first[0]);
        int m = Integer.parseInt(first[1]);
        
        Map<Integer, Map<Integer, Long>> costs = new HashMap<>();
        for (int i = 0; i < m; i++) {
            String[] line = stdin.readLine().split(" ");
            int a = Integer.parseInt(line[0]) - 1;
            int b = Integer.parseInt(line[1]) - 1;
            long c = Long.parseLong(line[2]);
            
            costs.computeIfAbsent(a, unused -> new HashMap<>()).put(b, c);
            costs.computeIfAbsent(b, unused -> new HashMap<>()).put(a, c);
        }

        
        long[] d1 = new long[n];
        long[] d2 = new long[n];
        PriorityQueue<Tuple> q = new PriorityQueue<>();
        Arrays.fill(d1, Long.MAX_VALUE);
        Arrays.fill(d2, Long.MAX_VALUE);
        d1[0] = 0;
        d2[0] = 0;
        q.add(new Tuple(0, 0, false));
        q.add(new Tuple(0, 0, true));
        
        while (!q.isEmpty()) {
            Tuple t = q.poll();
            int u = t.ptr;
            if (!costs.containsKey(u)) {
                continue;
            }
            
            if (t.skipped) {
                for (Entry<Integer, Long> e : costs.get(u).entrySet()) {
                    int v = e.getKey();
                    long d = e.getValue();
                    if (d2[u] + d < d2[v]) {
                        d2[v] = d2[u] + d;
                        q.add(new Tuple(d2[v], v, true));
                    }
                }
            } else {
                for (Entry<Integer, Long> e : costs.get(u).entrySet()) {
                    int v = e.getKey();
                    long d = e.getValue();
                    
                    if (d1[u] + d < d1[v]) {
                        d1[v] = d1[u] + d;
                        q.add(new Tuple(d1[v], v, false));
                    }
                    
                    if (d1[u] < d2[v]) {
                        d2[v] = d1[u];
                        q.add(new Tuple(d2[v], v, true));
                    }
                }
            }
        }
        
        PrintWriter stdout = new PrintWriter(System.out);
        IntStream.range(0, n).mapToLong(i -> d1[i] + d2[i]).forEach(stdout::println);
        stdout.flush();
    }
    
    private static class Tuple implements Comparable<Tuple>{
        private long d;
        private int ptr;
        private boolean skipped;
        
        
        public Tuple(long d, int ptr, boolean skipped) {
            super();
            this.d = d;
            this.ptr = ptr;
            this.skipped = skipped;
        }

        @Override
        public int compareTo(Tuple other) {
            return Long.compare(this.d, other.d);
        }
    }
}
0