#432279 (D) No.160 最短経路のうち辞書順最小

提出ソース

結果

問題	No.160 最短経路のうち辞書順最小
ユーザー	te-sh
提出日時	2020-02-21 17:21:58
言語	D (dmd 2.106.1)
結果	AC
実行時間	18 ms / 5,000 ms
コード長	5,415 bytes
コンパイル時間	853 ms
コンパイル使用メモリ	124,092 KB
実行使用メモリ	6,944 KB
最終ジャッジ日時	2024-06-22 05:19:44
合計ジャッジ時間	1,826 ms
ジャッジサーバーID （参考情報）	judge1 / judge5

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

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	1 ms 6,816 KB
testcase_01	AC	1 ms 6,944 KB
testcase_02	AC	1 ms 6,940 KB
testcase_03	AC	1 ms 6,944 KB
testcase_04	AC	6 ms 6,940 KB
testcase_05	AC	10 ms 6,944 KB
testcase_06	AC	14 ms 6,940 KB
testcase_07	AC	3 ms 6,944 KB
testcase_08	AC	3 ms 6,940 KB
testcase_09	AC	3 ms 6,940 KB
testcase_10	AC	4 ms 6,940 KB
testcase_11	AC	4 ms 6,940 KB
testcase_12	AC	4 ms 6,940 KB
testcase_13	AC	3 ms 6,940 KB
testcase_14	AC	4 ms 6,944 KB
testcase_15	AC	3 ms 6,944 KB
testcase_16	AC	3 ms 6,944 KB
testcase_17	AC	3 ms 6,944 KB
testcase_18	AC	3 ms 6,940 KB
testcase_19	AC	3 ms 6,944 KB
testcase_20	AC	4 ms 6,944 KB
testcase_21	AC	3 ms 6,944 KB
testcase_22	AC	4 ms 6,940 KB
testcase_23	AC	4 ms 6,940 KB
testcase_24	AC	4 ms 6,940 KB
testcase_25	AC	4 ms 6,940 KB
testcase_26	AC	3 ms 6,940 KB
testcase_27	AC	1 ms 6,940 KB
testcase_28	AC	18 ms 6,944 KB
testcase_29	AC	1 ms 6,944 KB

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

コンパイルメッセージ

Main.d(251): Deprecation: function `Main.IO!(makeGlobal, makeGlobal).IO.put!("{}", int[]).put.putMain!(c, int[]).putMain` function requires a dual-context, which is deprecated
Main.d-mixin-221(221):        instantiated from here: `putMain!(c, int[])`
Main.d(33):        instantiated from here: `put!("{}", int[])`

ソースコード

raw source code

// URL: https://yukicoder.me/problems/no/160

import std.algorithm, std.array, std.bitmanip, std.container, std.conv, std.format,
       std.functional, std.math, std.range, std.traits, std.typecons, std.stdio, std.string;

version(unittest) {} else
void main()
{
  int N, M, S, G; io.getV(N, M, S, G);

  auto g = GraphW!int(N);
  foreach (_; 0..M) {
    int a, b, c; io.getV(a, b, c);
    g.addEdgeB(a, b, c);
  }

  auto d = g.dijkstra(G).dist;

  auto r = [S], t = 0;
  while (r.back != G) {
    auto nt = t, nv = N;
    foreach (e; g[r.back]) {
      if (t+e.wt+d[e.dst] != d[S]) continue;
      if (e.dst < nv) {
        nt = e.wt;
        nv = e.dst;
      }
    }
    t += nt;
    r ~= nv;
  }

  io.put(r);
}

struct Graph
{
  alias Node = int;
  Node n;
  Node[][] g;
  alias g this;

  pure nothrow @safe
  {
    this(Node n)
    {
      this.n = n;
      g = new Node[][](n);
    }
    void addEdge(Node u, Node v)
      in { assert(0 <= u && u < n && 0 <= v && v < n); }
    do
    {
      g[u] ~= v;
    }
    void addEdgeB(Node u, Node v)
      in { assert(0 <= u && u < n && 0 <= v && v < n); }
    do
    {
      g[u] ~= v;
      g[v] ~= u;
    }
  }
}

struct GraphW(W = int, W i = 10^^9)
{
  alias Node = int, Wt = W, inf = i;
  struct Edge
  {
    Node src, dst;
    Wt wt;
    alias cap = wt;
  }
  Node n;
  Edge[][] g;
  alias g this;

  pure nothrow @safe
  {
    this(Node n)
    {
      this.n = n;
      g = new Edge[][](n);
    }
    void addEdge(Node u, Node v, Wt w)
      in { assert(0 <= u && u < n && 0 <= v && v < n); }
    do
    {
      g[u] ~= Edge(u, v, w);
    }
    void addEdgeB(Node u, Node v, Wt w)
      in { assert(0 <= u && u < n && 0 <= v && v < n); }
    do
    {
      g[u] ~= Edge(u, v, w);
      g[v] ~= Edge(v, u, w);
    }
  }
}

struct GraphM(W = int, W i = 10^^9)
{
  alias Node = int, Wt = W, inf = i;
  Node n;
  Wt[][] g;
  alias g this;

  pure nothrow @safe
  {
    this(int n)
    {
      this.n = n;
      g = new Wt[][](n, n);
    }
    static GraphM!(W, i) init(Node n)
    {
      auto g = GraphM!(W, i)(n);
      foreach (i; 0..n) { g[i][] = inf; g[i][i] = 0; }
      return g;
    }
  }
}

struct Dijkstra(Graph)
{
  alias Node = Graph.Node, Wt = Graph.Wt, Edge = Graph.Edge;
  Graph g;
  alias g this;
  Wt[] dist;
  Node[] prev;

  pure
  {
    @trusted this(Graph g, Node s)
      in { assert(0 <= s && s < g.n); }
    do
    {
      this.g = g;
      auto sent = n;

      dist = new Wt[](n);
      dist[] = g.inf;
      dist[s] = 0;

      prev = new Node[](n);
      prev[] = sent;

      auto q = heapify!("a.wt>b.wt")(Array!Edge(Edge(sent, s, 0)));
      while (!q.empty) {
        auto e = q.front; q.removeFront();
        if (prev[e.dst] != sent) continue;
        prev[e.dst] = e.src;
        foreach (f; g[e.dst]) {
          auto w = e.wt+f.wt;
          if (dist[f.dst] > w) {
            dist[f.dst] = w;
            q.insert(Edge(f.src, f.dst, w));
          }
        }
      }
    }
  }
}
pure
{
  @trusted auto dijkstra(Graph, Node)(Graph g, Node s)
    in { assert(0 <= s && s < g.n); }
  do
  {
    return Dijkstra!Graph(g, s);
  }
}

auto io = IO!()();
import std.stdio;
struct IO(alias IN = stdin, alias OUT = stdout)
{
  import std.meta : allSatisfy;
  import core.stdc.stdlib : exit;

  void getV(T...)(ref T v)
  {
    foreach (ref w; v) get(w);
  }
  void getA(T)(size_t n, ref T v)
    if (hasAssignableElements!T)
  {
    v = new T(n);
    foreach (ref w; v) get(w);
  }
  void getC(T...)(size_t n, ref T v)
    if (allSatisfy!(hasAssignableElements, T))
  {
    foreach (ref w; v) w = new typeof(w)(n);
    foreach (i; 0..n) foreach (ref w; v) get(w[i]);
  }
  void getM(T)(size_t r, size_t c, ref T v)
    if (hasAssignableElements!T && hasAssignableElements!(ElementType!T))
  {
    v = new T(r);
    foreach (ref w; v) getA(c, w);
  }
  template getS(E...)
  {
    void getS(T)(size_t n, ref T v)
    {
      v = new T(n);
      foreach (ref w; v) foreach (e; E) mixin("get(w."~e~");");
    }
  }

  const struct PutConf
  {
    bool newline = true, flush, exit;
    string floatFormat = "%.10f", delimiter = " ";
  }

  void put(alias conf = "{}", T...)(T v)
  {
    mixin("const PutConf c = "~conf~"; putMain!c(v);");
  }
  void putB(alias conf = "{}", S, T)(bool c, S t, T f)
  {
    if (c) put!conf(t);
    else put!conf(f);
  }
  void putRaw(T...)(T v)
  {
    OUT.write(v);
    OUT.writeln;
  }

  private
  {
    dchar[] buf;
    auto sp = (new dchar[](0)).splitter;

    void nextLine()
    {
      IN.readln(buf);
      sp = buf.splitter;
    }
    void get(T)(ref T v)
    {
      if (sp.empty) nextLine();
      v = sp.front.to!T;
      sp.popFront();
    }

    void putMain(PutConf c, T...)(T v)
    {
      foreach (i, w; v) {
        putOne!c(w);
        if (i+1 < v.length) OUT.write(c.delimiter);
      }
      static if (c.newline) OUT.writeln;
      static if (c.flush) OUT.flush();
      static if (c.exit) exit(0);
    }
    void putOne(PutConf c, T)(T v)
    {
      static if (isInputRange!T && !isSomeString!T) putRange!c(v);
      else static if (isFloatingPoint!T) OUT.write(format(c.floatFormat, v));
      else static if (hasMember!(T, "fprint")) v.fprint(OUT);
      else OUT.write(v);
    }
    void putRange(PutConf c, T)(T v)
    {
      auto w = v;
      while (!w.empty) {
        putOne!c(w.front); w.popFront();
        if (!w.empty) OUT.write(c.delimiter);
      }
    }
  }
}