結果

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

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 103 ms
44,000 KB
testcase_01 AC 102 ms
38,560 KB
testcase_02 AC 122 ms
39,532 KB
testcase_03 AC 113 ms
39,208 KB
testcase_04 AC 98 ms
38,700 KB
testcase_05 AC 103 ms
39,004 KB
testcase_06 AC 114 ms
38,944 KB
testcase_07 AC 108 ms
39,036 KB
testcase_08 AC 80 ms
37,932 KB
testcase_09 AC 87 ms
38,120 KB
testcase_10 AC 87 ms
38,432 KB
testcase_11 AC 2,022 ms
96,564 KB
testcase_12 AC 1,633 ms
95,660 KB
testcase_13 AC 1,975 ms
114,452 KB
testcase_14 AC 1,238 ms
77,248 KB
testcase_15 AC 1,064 ms
72,900 KB
testcase_16 AC 2,126 ms
119,400 KB
testcase_17 AC 2,368 ms
132,852 KB
testcase_18 AC 2,461 ms
132,516 KB
testcase_19 AC 2,303 ms
129,676 KB
testcase_20 AC 1,428 ms
95,080 KB
testcase_21 AC 1,395 ms
95,900 KB
testcase_22 AC 836 ms
70,216 KB
testcase_23 AC 702 ms
64,688 KB
testcase_24 TLE -
testcase_25 AC 2,997 ms
248,060 KB
権限があれば一括ダウンロードができます

ソースコード

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