#605358 (C#(csc)) No.1344 Typical Shortest Path Sum

提出ソース

結果

問題	No.1344 Typical Shortest Path Sum
ユーザー	kichi2004_
提出日時	2021-01-16 13:23:13
言語	C#(csc) (csc 3.9.0)
結果	AC
実行時間	138 ms / 2,000 ms
コード長	26,558 bytes
コンパイル時間	3,337 ms
コンパイル使用メモリ	131,068 KB
実行使用メモリ	20,736 KB
最終ジャッジ日時	2024-05-05 15:22:01
合計ジャッジ時間	9,319 ms
ジャッジサーバーID （参考情報）	judge1 / judge5

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	32 ms 19,712 KB
testcase_01	AC	33 ms 19,584 KB
testcase_02	AC	34 ms 19,456 KB
testcase_03	AC	34 ms 19,712 KB
testcase_04	AC	34 ms 19,712 KB
testcase_05	AC	32 ms 19,840 KB
testcase_06	AC	31 ms 19,584 KB
testcase_07	AC	34 ms 19,584 KB
testcase_08	AC	33 ms 19,584 KB
testcase_09	AC	33 ms 19,456 KB
testcase_10	AC	34 ms 19,328 KB
testcase_11	AC	34 ms 19,456 KB
testcase_12	AC	33 ms 19,456 KB
testcase_13	AC	32 ms 19,712 KB
testcase_14	AC	34 ms 19,584 KB
testcase_15	AC	34 ms 19,712 KB
testcase_16	AC	41 ms 19,456 KB
testcase_17	AC	33 ms 19,712 KB
testcase_18	AC	34 ms 19,328 KB
testcase_19	AC	32 ms 19,584 KB
testcase_20	AC	33 ms 19,456 KB
testcase_21	AC	32 ms 19,456 KB
testcase_22	AC	33 ms 19,712 KB
testcase_23	AC	34 ms 19,456 KB
testcase_24	AC	33 ms 19,712 KB
testcase_25	AC	32 ms 19,584 KB
testcase_26	AC	32 ms 19,456 KB
testcase_27	AC	32 ms 19,712 KB
testcase_28	AC	33 ms 19,584 KB
testcase_29	AC	33 ms 19,456 KB
testcase_30	AC	34 ms 19,712 KB
testcase_31	AC	35 ms 19,584 KB
testcase_32	AC	36 ms 19,712 KB
testcase_33	AC	35 ms 19,712 KB
testcase_34	AC	34 ms 19,456 KB
testcase_35	AC	36 ms 19,456 KB
testcase_36	AC	36 ms 19,328 KB
testcase_37	AC	34 ms 19,712 KB
testcase_38	AC	34 ms 19,712 KB
testcase_39	AC	35 ms 19,456 KB
testcase_40	AC	107 ms 20,480 KB
testcase_41	AC	123 ms 20,736 KB
testcase_42	AC	104 ms 20,480 KB
testcase_43	AC	103 ms 20,352 KB
testcase_44	AC	99 ms 20,608 KB
testcase_45	AC	105 ms 20,608 KB
testcase_46	AC	106 ms 20,608 KB
testcase_47	AC	109 ms 20,224 KB
testcase_48	AC	132 ms 20,608 KB
testcase_49	AC	105 ms 20,224 KB
testcase_50	AC	100 ms 20,224 KB
testcase_51	AC	102 ms 20,608 KB
testcase_52	AC	103 ms 20,480 KB
testcase_53	AC	138 ms 20,352 KB
testcase_54	AC	96 ms 20,224 KB
testcase_55	AC	106 ms 20,352 KB
testcase_56	AC	119 ms 20,480 KB
testcase_57	AC	108 ms 20,352 KB
testcase_58	AC	135 ms 20,608 KB
testcase_59	AC	124 ms 20,480 KB
testcase_60	AC	39 ms 19,456 KB
testcase_61	AC	38 ms 19,456 KB
testcase_62	AC	111 ms 20,480 KB
testcase_63	AC	43 ms 20,224 KB
testcase_64	AC	51 ms 19,968 KB
testcase_65	AC	129 ms 20,608 KB
testcase_66	AC	110 ms 20,736 KB
testcase_67	AC	112 ms 20,736 KB
testcase_68	AC	40 ms 19,968 KB
testcase_69	AC	40 ms 19,968 KB
testcase_70	AC	33 ms 19,584 KB
testcase_71	AC	32 ms 19,712 KB
testcase_72	AC	35 ms 19,584 KB
testcase_73	AC	34 ms 19,712 KB
testcase_74	AC	32 ms 19,712 KB
testcase_75	AC	34 ms 19,584 KB
testcase_76	AC	35 ms 19,712 KB
testcase_77	AC	35 ms 19,584 KB
testcase_78	AC	36 ms 19,584 KB
testcase_79	AC	39 ms 19,840 KB

権限があれば一括ダウンロードができます

コンパイルメッセージ

Microsoft (R) Visual C# Compiler version 3.9.0-6.21124.20 (db94f4cc)
Copyright (C) Microsoft Corporation. All rights reserved.

ソースコード

raw source code

// ReSharper disable RedundantUsingDirective
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.IO;
using System.Linq;
using System.Text;
using System.Numerics;
using Solve.Libraries.Graph.BellmanFord;
using Solve.Libraries.Graph.Graph;
using static Solve.Input;
using static Solve.Methods;
using static Solve.Output;
using static System.Math;

// Resharper restore RedundantUsingDirective


namespace Solve {
    public partial class Solver {
        public void Main() {
            var (N, M) = Int;
            

            var graph = new WeightGraph(N);
            graph.InputGraph(M);

            
            var res = new BellmanFord(graph);

            for (int i = 0; i < N; i++) {
                var a = res.Run(i);
                var ans = 0L;
                for (int j = 0; j < N; j++) {
                    ans += a[j] == BellmanFord.INF ? 0 : a[j];
                }

                print(ans);
            }
        }

        public const int MOD = 1000000007;
    }


    public static class Methods
    {
        [MethodImpl(256)] public static bool Assert(in bool b, in string message = null) =>
            b ? true : throw new Exception(message ?? "Assert failed.");
        [MethodImpl(256)] public static string JoinSpace<T>(this IEnumerable<T> source) => source.Join(" ");
        [MethodImpl(256)] public static string JoinEndline<T>(this IEnumerable<T> source) => source.Join("\n");
        [MethodImpl(256)] public static string Join<T>(this IEnumerable<T> source, string s) => string.Join(s, source);
        [MethodImpl(256)] public static string Join<T>(this IEnumerable<T> source, char c) =>
            string.Join(c.ToString(), source);
        public static int Gcd(int a, int b) => (int) Gcd((long) a, b);
        public static long Gcd(long a, long b) {
            while (true) {
                if (a < b) (a, b) = (b, a);
                if (a % b == 0) return b;
                (a, b) = (b, a % b);
            }
        }
        public static long Lcm(long a, long b) => a / Gcd(a, b) * b;
        public static bool IsPrime(long value) {
            if (value <= 1) return false;
            for (long i = 2; i * i <= value; ++i) if (value % i == 0) return false;
            return true;
        }
        public static long Pow(long a, int b) {
            long res = 1;
            while (b > 0) { if (b % 2 != 0) res *= a; a *= a; b >>= 1; }
            return res;
        }
        public static int PowMod(long a, long b, int p) => (int) PowMod(a, b, (long) p);
        public static long PowMod(long a, long b, long p) {
            long res = 1;
            while (b > 0) { if (b % 2 != 0) res = res * a % p; a = a * a % p; b >>= 1; }
            return res;
        }
        public static IEnumerable<long> Factors(long n) {
            Assert(n >= 0, "n must be greater than 0.");
            for (long i = 1; i * i <= n; ++i) {
                var div = DivRem(n, i, out var rem);
                if (rem > 0) continue;
                yield return div;
                if (i != div) yield return i;
            }
        }
        public static IEnumerable<int> Factors(int n) => Factors((long) n).Select(Convert.ToInt32);
        [MethodImpl(256)] public static int DivCeil(int a, int b) => (a + b - 1) / b;
        [MethodImpl(256)] public static long DivCeil(long a, long b) => (a + b - 1) / b;
        public static IEnumerable<T[]> Permutations<T>(IEnumerable<T> src) {
            var ret = new List<T[]>();
            Search(ret, new Stack<T>(), src.ToArray());
            return ret;

            static void Search(ICollection<T[]> perms, Stack<T> stack, T[] a) {
                int N = a.Length;
                if (N == 0) perms.Add(stack.Reverse().ToArray());
                else {
                    var b = new T[N - 1];
                    Array.Copy(a, 1, b, 0, N - 1);
                    for (int i = 0; i < a.Length; ++i) {
                        stack.Push(a[i]);
                        Search(perms, stack, b);
                        if (i < b.Length) b[i] = a[i];
                        stack.Pop();
                    }
                }
            }
        }
        public static long BinarySearch(long low, long high, Func<long, bool> expression) {
            while (low < high) {
                long middle = (high - low) / 2 + low;
                if (!expression(middle))
                    high = middle;
                else
                    low = middle + 1;
            }

            return high;
        }
        public static int LowerBound<T>(T[] arr, int start, int end, T value, IComparer<T> comparer) {
            int low = start;
            int high = end;
            while (low < high) {
                var mid = ((high - low) >> 1) + low;
                if (comparer.Compare(arr[mid], value) < 0)
                    low = mid + 1;
                else
                    high = mid;
            }

            return low;
        }
        public static int LowerBound<T>(T[] arr, T value) where T : IComparable =>
            LowerBound(arr, 0, arr.Length, value, Comparer<T>.Default);
        public static int UpperBound<T>(T[] arr, int start, int end, T value, IComparer<T> comparer) {
            var (low, high) = (start, end);
            while (low < high) {
                var mid = ((high - low) >> 1) + low;
                if (comparer.Compare(arr[mid], value) <= 0) low = mid + 1;
                else high = mid;
            }

            return low;
        }
        public static int UpperBound<T>(T[] arr, T value) => 
            UpperBound(arr, 0, arr.Length, value, Comparer<T>.Default);
        [MethodImpl(256)]
        public static IEnumerable<TResult> Repeat<TResult>(TResult value, int count) => Enumerable.Repeat(value, count);
        [MethodImpl(256)] public static string AsString(this IEnumerable<char> source) => new string(source.ToArray());
        public static IEnumerable<long> CumSum(this IEnumerable<long> source) {
            long sum = 0; foreach (var item in source) yield return sum += item;
        }
        public static IEnumerable<int> CumSum(this IEnumerable<int> source) {
            int sum = 0; foreach (var item in source) yield return sum += item;
        }
        [MethodImpl(256)] public static bool IsIn<T>(this T value, T l, T r) where T : IComparable<T> =>
            l.CompareTo(r) > 0 ? throw new ArgumentException() : l.CompareTo(value) <= 0 && value.CompareTo(r) < 0;
        [MethodImpl(256)] public static bool IsIn(this in int value, in Range range) =>
            value.IsIn(range.Start.Value, range.End.Value);
        [MethodImpl(256)] public static bool IsIn(this in Index value, in Range range) =>
            value.IsFromEnd && value.Value.IsIn(range.Start.Value, range.End.Value);
        public static IEnumerable<int> Range(int start, int end, int step = 1) {
            for (var i = start; i < end; i += step) yield return i;
        }
        public static IEnumerable<int> Range(int end) => Range(0, end);
        public static IEnumerable<int> Range(Range range, int step = 1) =>
            Range(range.Start.Value, range.End.Value, step);
        [MethodImpl(256)] public static T[] Sorted<T>(this T[] arr) where T : IComparable<T> {
            var array = arr[..]; Array.Sort(array); return array;
        }
        [MethodImpl(256)]
        public static T[] Sorted<T, U>(this T[] arr, Func<T, U> selector) where U : IComparable<U> {
            var array = arr[..];
            Array.Sort(array, (a, b) => selector(a).CompareTo(selector(b)));
            return array;
        }
        [MethodImpl(256)] public static T[] SortedDescending<T>(this T[] arr) where T : IComparable<T> {
            var array = arr[..];
            Array.Sort(array, (a, b) => b.CompareTo(a));
            return array;
        }
        [MethodImpl(256)]
        public static T[] SortedDescending<T, U>(this T[] arr, Func<T, U> selector) where U : IComparable<U> {
            var array = arr[..];
            Array.Sort(array, (a, b) => selector(b).CompareTo(selector(a)));
            return array;
        }
        public static T[] Unique<T>(this IEnumerable<T> arr) {
            var source = arr.ToArray();
            var ret = new List<T>(source.Length);
            var set = new SortedSet<T>();
            ret.AddRange(source.Where(val => set.Add(val)));

            return ret.ToArray();
        }
        [MethodImpl(256)] public static bool chmin<T>(ref T a, T b)
            where T : IComparable<T> {
            if (a.CompareTo(b) > 0) { a = b; return true; }
            return false;
        } 
        [MethodImpl(256)] public static bool chmax<T>(ref T a, T b)
            where T : IComparable<T> {
            if (a.CompareTo(b) < 0) { a = b; return true; }
            return false;
        }
        public static T[] InitArray<T>(int n, Func<int, T> init) {
            var res = new T[n];
            for (int i = 0; i < n; i++) res[i] = init(i);
            return res;
        }
        public static T[][] JaggedArray2D<T>(int a, int b, T defaultValue = default) {
            var ret = new T[a][];
            for (int i = 0; i < a; ++i) ret[i] = Enumerable.Repeat(defaultValue, b).ToArray();
            return ret;
        }
        public static T[,] Array2D<T>(int a, int b, T defaultValue = default) {
            var ret = new T[a, b];
            for (int i = 0; i < a; ++i) for (int j = 0; j < b; ++j) ret[i, j] = defaultValue;
            return ret;
        }
        public static T[,] To2DArray<T>(this T[][] array) {
            if (!array.Any()) return new T[0, 0];

            int len = array[0].Length;
            if (array.Any(x => x.Length != len))
                throw new ArgumentException("Length of each array must be same.", nameof(array));

            var ret = new T[array.Length, len];
            for (int i = 0; i < array.Length; ++i) for (int j = 0; j < len; ++j) ret[i, j] = array[i][j];
            return ret;
        }
        [MethodImpl(256)] public static T Min<T>(params T[] col) => col.Min();
        [MethodImpl(256)] public static T Max<T>(params T[] col) => col.Max();
        [MethodImpl(256)] public static IEnumerable<(T, int)> WithIndex<T>(this IEnumerable<T> source) =>
            source.Select((x, i) => (x, i));
        [MethodImpl(256)] public static (T, U, V)[] Zip<T, U, V>(
            IReadOnlyCollection<T> t,
            IReadOnlyCollection<U> u,
            IReadOnlyCollection<V> v
        ) {
            Assert(t.Count == u.Count && u.Count == v.Count);
            return t.Zip(u, (a, b) => (a, b))
                .Zip(v, (tuple, c) => (tuple.Item1, tuple.Item2, c)).ToArray();
        }
        [MethodImpl(256)] public static void rep(in int start, in int end, Action<int> func) {
            for (int i = start; i < end; ++i) func(i);
        }
        [MethodImpl(256)] public static void rep(in int end, Action<int> func) => rep(0, end, func);
        [MethodImpl(256)] public static void rep1(in int end, Action<int> func) => rep(1, end + 1, func);
        [MethodImpl(256)] public static void repr(in int end, Action<int> func) {
            for (int i = end - 1; i >= 0; --i) func(i);
        }
        [MethodImpl(256)]
        public static void each<T>(this IEnumerable<T> source, Action<T> func) {
            foreach (var item in source) func(item);
        }
        [MethodImpl(256)]
        public static void eachWithIndex<T>(this IEnumerable<T> source, Action<T, int> func) {
            int index = 0; foreach (var item in source) func(item, index++);
        }
        [MethodImpl(256)] public static int bit(in int x) => 1 << x;
        [MethodImpl(256)] public static long bitl(in int x) => 1L << x;
    }
    public class UnorderedMap<T, U> : Dictionary<T, U>
    {
        public new U this[T k] {
            get =>
                TryGetValue(k, out var v) ? v : base[k] = default;
            set =>
                base[k] = value;
        }
    }
    public class Map<T, U> : SortedDictionary<T, U>
    {
        readonly U _default;
        public Map(U defaultValue = default) {
            _default = defaultValue;
        }
        public new U this[T k] {
            get =>
                TryGetValue(k, out var v) ? v : base[k] = _default;
            set =>
                base[k] = value;
        }
    }
    public class Scanner<T>
    {
        public T r => next<T>();
        public T next() => r;

        IEnumerable<T> enumerable(int N) { for (int i = 0; i < N; ++i) yield return r; }

        public T[] array(in int N) => enumerable(N).ToArray();
        public List<T> list(in int N) => enumerable(N).ToList();
        public T[,] array2d(in int N, in int M) => next2DArray<T>(N, M);
        public T[][] listArray(in int n) {
            var ret = new T[n][];
            for (int i = 0; i < n; i++) ret[i] = array(next<int>());
            return ret;
        }

        public void Deconstruct(out T _1, out T _2) => (_1, _2) = (r, r);
        public void Deconstruct(out T _1, out T _2, out T _3) => (_1, _2, _3) = (r, r, r);
        public void Deconstruct(out T _1, out T _2, out T _3, out T _4) =>
            (_1, _2, _3, _4) = (r, r, r, r);
        public void Deconstruct(out T _1, out T _2, out T _3, out T _4, out T _5) =>
            (_1, _2, _3, _4, _5) = (r, r, r, r, r);
        public void Deconstruct(out T _1, out T _2, out T _3, out T _4, out T _5, out T _6) =>
            (_1, _2, _3, _4, _5, _6) = (r, r, r, r, r, r);
        public void Deconstruct(out T _1, out T _2, out T _3, out T _4, out T _5, out T _6, out T _7) =>
            (_1, _2, _3, _4, _5, _6, _7) = (r, r, r, r, r, r, r);
        public void Deconstruct(out T _1, out T _2, out T _3, out T _4, out T _5, out T _6, out T _7, out T _8) =>
            (_1, _2, _3, _4, _5, _6, _7, _8) = (r, r, r, r, r, r, r, r);
        public void Deconstruct(out T _1, out T _2, out T _3, out T _4, 
            out T _5, out T _6, out T _7, out T _8, out T _9) =>
            (_1, _2, _3, _4, _5, _6, _7, _8, _9) = (r, r, r, r, r, r, r, r, r);
        public void Deconstruct(out T _1, out T _2, out T _3, out T _4,
            out T _5, out T _6, out T _7, out T _8, out T _9, out T _10) =>
            (_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) = (r, r, r, r, r, r, r, r, r, r);
        
        public static implicit operator T(Scanner<T> sc) => sc.r;
    }
    public static class Input
    {
        const char _separator = ' ';
        static readonly Queue<string> _input = new Queue<string>();
        static readonly StreamReader sr =
#if FILE
            new StreamReader("in.txt");
#else
            new StreamReader(Console.OpenStandardInput());
#endif

        public static string ReadLine => sr.ReadLine();
        static string ReadStr => Read;
        static int ReadInt => int.Parse(Read);
        static long ReadLong => long.Parse(Read);
        static ulong ReadULong => ulong.Parse(Read);
        static double ReadDouble => double.Parse(Read);
        static BigInteger ReadBigInteger => BigInteger.Parse(Read);

        public static string Read {
            get {
                if (_input.Any()) return _input.Dequeue();
                foreach (var val in sr.ReadLine().Split(_separator)) _input.Enqueue(val);
                return _input.Dequeue();
            }
        }

        public static string next() => Read;
        public static T next<T>() =>
            default(T) switch {
                sbyte _ => (T) (object) (sbyte) ReadInt,
                short _ => (T) (object) (short) ReadInt,
                int _ => (T) (object) ReadInt,
                long _ => (T) (object) ReadLong,
                byte _ => (T) (object) (byte) ReadULong,
                ushort _ => (T) (object) (ushort) ReadULong,
                uint _ => (T) (object) (uint) ReadULong,
                ulong _ => (T) (object) ReadULong,
                float _ => (T) (object) (float) ReadDouble,
                double _ => (T) (object) ReadDouble,
                string _ => (T) (object) ReadStr,
                char _ => (T) (object) ReadStr[0],
                BigInteger _ => (T) (object) ReadBigInteger,
                _ => typeof(T) == typeof(string)
                    ? (T) (object) ReadStr
                    : throw new NotSupportedException(),
            };
        public static (T, U) next<T, U>() => (next<T>(), next<U>());
        public static (T, U, V) next<T, U, V>() => (next<T>(), next<U>(), next<V>());
        public static (T, U, V, W) next<T, U, V, W>() => (next<T>(), next<U>(), next<V>(), next<W>());
        public static (T, U, V, W, X) next<T, U, V, W, X>() => (next<T>(), next<U>(), next<V>(), next<W>(), next<X>());
        public static T[] nextArray<T>(in int size) {
            var ret = new T[size]; for (int i = 0; i < size; ++i) ret[i] = next<T>(); return ret;
        }
        public static T[,] next2DArray<T>(int n, in int m) {
            var ret = new T[n, m];
            for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) ret[i, j] = next<T>(); return ret;
        }
        public static (T[], U[]) nextArray<T, U>(in int size) {
            var ret1 = new T[size]; var ret2 = new U[size];
            for (int i = 0; i < size; ++i) (ret1[i], ret2[i]) = next<T, U>();
            return (ret1, ret2);
        }
        public static (T[], U[], V[]) nextArray<T, U, V>(in int size) {
            var ret1 = new T[size]; var ret2 = new U[size]; var ret3 = new V[size];
            for (int i = 0; i < size; ++i) (ret1[i], ret2[i], ret3[i]) = next<T, U, V>();
            return (ret1, ret2, ret3);
        }
    }
    public static class Output
    {
        [MethodImpl(256)] public static void print() => Console.WriteLine();
        [MethodImpl(256)] public static void print(in string s, bool endline = true) {
            if (endline) Console.WriteLine(s); else Console.Write(s);
        }
        [MethodImpl(256)] public static void print(in char s, bool endline = true) {
            if (endline) Console.WriteLine(s); else Console.Write(s);
        }
        [MethodImpl(256)] public static void print(in int v, bool endline = true) {
            if (endline) Console.WriteLine(v); else Console.Write(v);
        }
        [MethodImpl(256)] public static void print(in long v, bool endline = true) {
            if (endline) Console.WriteLine(v); else Console.Write(v);
        }
        [MethodImpl(256)] public static void print(in ulong v, bool endline = true) {
            if (endline) Console.WriteLine(v); else Console.Write(v);
        }
        [MethodImpl(256)] public static void print(in bool b) => PrintBool(b);
        [MethodImpl(256)] public static void print(in object v) => Console.WriteLine(v);
        [MethodImpl(256)] public static void print<T>(in IEnumerable<T> array, string separator = " ") =>
            Console.WriteLine(array.Join(separator));
        [MethodImpl(256)] public static void prints<T>(params T[] t) => print(t);
        
#if LOCAL
        [MethodImpl(256)] public static void debug<T>(in T value, bool endline = true) {
            if (endline) Console.WriteLine(value);else Console.Write(value);
        }
#else
        public static void debug(params object[] obj) { }
#endif

        [MethodImpl(256)] static void PrintBool(in bool val, in string yes = null, in string no = null) =>
            print(val ? yes ?? _yes : no ?? _no);
        static string _yes = "Yes", _no = "No";

        public static void SetYesNoString(in YesNoType t) => (_yes, _no) = YesNoString[t];
        public static void SetYesNoString(in string yes, in string no) => (_yes, _no) = (yes, no);

        static readonly Dictionary<YesNoType, (string yes, string no)>
            YesNoString = new Dictionary<YesNoType, (string, string)> {
                    {YesNoType.Yes_No, ("Yes", "No")},
                    {YesNoType.YES_NO, ("YES", "NO")},
                    {YesNoType.Upper, ("YES", "NO")},
                    {YesNoType.yes_no, ("yes", "no")},
                    {YesNoType.Lower, ("yes", "no")},
                    {YesNoType.Possible_Impossible, ("Possible", "Impossible")},
                    {YesNoType.Yay, ("Yay!", ":(")},
                };

        public static readonly (string yes, string no) YN_Possible = ("Possible", "Impossible"),
            YN_lower = ("yes", "no"), YN_upper = ("YES", "NO"), YN_Yay = ("Yay!", ":(");

        public static void Yes() => print(_yes);
        public static void No() => print(_no);

        public static object cout { set => Console.WriteLine(value); }
#if LOCAL
        public static object dout { set => Console.WriteLine(value); }
#else
        public static object dout { set { } }
#endif
        public static object cerr { set => Console.Error.WriteLine(value); }

        public const string endl = "\n";

        public enum YesNoType { Yes_No, YES_NO, Upper, yes_no, Lower, Possible_Impossible, Yay }
    }
    public class Program
    {
        public static void Main(string[] args) {
            var sw = new StreamWriter(Console.OpenStandardOutput()) {AutoFlush = false};
            Console.SetOut(sw);
            new Solver().Main();
            Console.Out.Flush();
        }
    }
    partial class Solver
    {
        readonly Scanner<int> Int;
        readonly Scanner<long> Long;
        readonly Scanner<string> String;
        public Solver() => (Int, String, Long) = (new Scanner<int>(), new Scanner<string>(), new Scanner<long>());
        const int INF = 1000000010;
        const long LINF = 1000000000000000100;
        const double EPS = 1e-9;
        public static readonly int[] dx = {-1, 0, 0, 1, -1, -1, 1, 1}, dy = {0, 1, -1, 0, -1, 1, -1, 1};
    }
}namespace Solve.Libraries.Graph.BellmanFord
{
    public class BellmanFord
    {
        public const long INF = 1000000000000000100;
        readonly int _n;
        readonly List<IEdge>[] _graph;
        public BellmanFord(int N)
        {
            _graph = InitArray(N, _ => new List<IEdge>());
            _n = N;
        }
        public BellmanFord(WeightGraph graph) : this(graph.Length) {
            for (int i = 0; i < _n; i++) _graph[i].AddRange(graph[i].Cast<IEdge>());
        }
        public BellmanFord(UnweightGraph graph) : this(graph.Length)
        {
            for (int i = 0; i < _n; i++) _graph[i].AddRange(graph[i].Cast<IEdge>());
        }
        public void Add(int start, int end, long cost, bool undirected = false)
        {
            Validate(start, nameof(start)); Validate(end, nameof(end));
            _graph[start].Add(new WeightEdge(end, cost));
            if (undirected) _graph[end].Add(new WeightEdge(start, cost));
        }
        IEnumerable<(int from, int to, long cost)> Edges {
            get { for (int i = 0; i < _n; i++) foreach (var (to, cost) in _graph[i]) yield return (i, to, cost); }
        }
        /// <remarks>O(VE)</remarks>
        /// <returns>Shortest pathes from start, null if contains negative cycle.</returns>
        public long[] Run(int start, long firstCost = 0)
        {
            Validate(start, nameof(start));
            var dist = InitArray(_n, _ => INF);
            dist[start] = firstCost;
            for (int i = 0; i < _n; i++) {
                foreach (var (from, to, cost) in Edges) {
                    if (dist[from] == INF) continue;
                    if (chmin(ref dist[to], dist[from] + cost) && i == _n - 1) return null;
                }
            }
            return dist;
        }
        void Validate(int val, string argument) {
            if (val.IsIn(.._n)) return;
            throw new ArgumentOutOfRangeException(argument);
        }
    }
}
namespace Solve.Libraries.Graph.Graph
{
    public interface IEdge
    {
        int To { get; } 
        long Cost { get; }
        public void Deconstruct(out int t, out long c) => (t, c) =(To, Cost);
    }
    public interface Graph<EdgeType> where EdgeType : IEdge
    {
        int Length { get; }
        List<EdgeType> this[int i] { get; }
        List<EdgeType>[] Graph { get; }
        void InputGraph(int m, in bool directed, in int offset);
    }
    public readonly struct WeightEdge : IEdge
    {
        public WeightEdge(int to, long cost) => (To, Cost) = (to, cost);
        public int To { get; }
        public long Cost { get; }
        public void Deconstruct(out int t, out long c) => (t, c) = (To, Cost);
    }
    public class WeightGraph : Graph<WeightEdge>
    {
        public WeightGraph(int n)
        {
            Graph = new List<WeightEdge>[n]; 
            rep(n, i => Graph[i] = new List<WeightEdge>());
        }
        public int Length => Graph.Length;
        public List<WeightEdge> this[int i] => Graph[i];
        public List<WeightEdge>[] Graph { get; }
        public void InputGraph(int m, in bool directed = true, in int offset = 1)
        {
            while (m-- > 0)
            {
                var (a, b, c) = Input.next<int, int, long>();
                a -= offset;
                b -= offset;
                Graph[a].Add(new WeightEdge(b, c));
                if (!directed) Graph[b].Add(new WeightEdge(a, c));
            }
        }
        public void AddEdge(in int from, in int to, in long cost, in bool directed = true) 
        {
            Graph[from].Add(new WeightEdge(to, cost));
            if(!directed) Graph[to].Add(new WeightEdge(from, cost));
        }
    }
    public readonly struct UnweightEdge : IEdge
    {
        public UnweightEdge(int to) => To = to;
        public int To { get; }
        public long Cost => 1;
        public void Deconstruct(out int t, out long c) => (t, c) = (To, Cost);
    }
    public class UnweightGraph : Graph<UnweightEdge>
    {
        public UnweightGraph(int n)
        {
            Graph = new List<UnweightEdge>[n]; 
            rep(n, i => Graph[i] = new List<UnweightEdge>());
        }
        public int Length => Graph.Length;
        public List<UnweightEdge> this[int i] => Graph[i];
        public List<UnweightEdge>[] Graph { get; }
        public void InputGraph(int m, in bool directed = true, in int offset = 1)
        {
            while (m-- > 0)
            {
                var (a, b) = Input.next<int, int>();
                a -= offset;
                b -= offset;
                Graph[a].Add(new UnweightEdge(b));
                if (!directed) Graph[b].Add(new UnweightEdge(a));
            }
        }
    }
}

yukicoder

結果

テストケース

コンパイルメッセージ

ソースコード