#434111 (D) No.307 最近色塗る問題多くない？

• 問題: No.307 最近色塗る問題多くない？
• ユーザー: te-sh
• 提出日時: 2020-02-24 17:30:26
• 言語: D (dmd 2.109.1)
• 結果: TLE
• 実行時間: -
• コード長: 8,558 bytes
• コンパイル時間: 876 ms
• コンパイル使用メモリ: 133,828 KB
• 実行使用メモリ: 128,960 KB
• 最終ジャッジ日時: 2024-06-22 05:30:21
• 合計ジャッジ時間: 12,422 ms
• ジャッジサーバーID （参考情報）: judge4 / judge2

ファイルパターン	結果
other	AC * 28 TLE * 1 -- * 7

コンパイルメッセージ

Main.d(374): Deprecation: function `Main.IO!(makeGlobal, makeGlobal).IO.put!("{}", MapResult!(__lambda35, Chunk)).put.putMain!(c, MapResult!(__lambda35, Chunk)).putMain` function requires a dual-context, which is deprecated
Main.d-mixin-344(344):        instantiated from here: `putMain!(c, MapResult!(__lambda35, Chunk))`
Main.d(44):        instantiated from here: `put!("{}", MapResult!(__lambda35, Chunk))`

ソースコード

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

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 H, W; io.getV(H, W);
  int[][] A; io.getM(H, W, A);

  alias rg = Region!(H, W), Pos = rg.Pos;
  auto g = rg.grid(A), uf = new UnionFind(H*W);
  auto subst(Pos p) { return uf.subst(p.p2i); }
  foreach (p; rg.allPos)
    foreach (q; p.around4)
      if (g[p] == g[q])
        uf.unite(p.p2i, q.p2i);

  auto c = new int[](H*W), d = new Pos[][](H*W);
  foreach (p; rg.allPos) {
    auto cp = c[subst(p)] = g[p];
    if (p.around4.any!(q => cp != g[q]))
      d[subst(p)] ~= p;
  }

  int Q; io.getV(Q);
  foreach (_; 0..Q) {
    int R, C, X; io.getV(R, C, X); --R; --C;
    auto p = Pos(R, C);
    if (c[subst(p)] == X) continue;
    c[subst(p)] = X;

    auto e = d[subst(p)].map!(q => q.around4).joiner
      .map!(q => subst(q)).filter!(q => q != subst(p)).array;
    e.sort;
    auto f = e.uniq.map!(s => d[s]).joiner.array;
    foreach (s; f)
      uf.unite(p.p2i, s.p2i);
    d[subst(p)] = f.filter!(q => q.around4.any!(r => X != c[subst(r)])).array;
  }

  foreach (q; rg.allPos.chunks(W))
    io.put(q.map!(r => c[subst(r)]));
}

template Region(alias h, alias w)
{
  struct Pos
  {
    pure nothrow @nogc @safe
    {
      int r, c;
      this(int r, int c)
      {
        this.r = r; this.c = c;
      }
      bool inRegion() const
      {
        return 0 <= r && r < h && 0 <= c && c < w;
      }
      int p2i() const
      {
        return cast(int)w*r+c;
      }

      Pos opBinary(string op)(Pos q) const
        if (op == "+" || op == "-")
      {
        return mixin("Pos(r"~op~"q.r, c"~op~"q.c)");
      }
      ref Pos opOpAssign(string op)(Pos q)
        if (op == "+" || op == "-")
      {
        mixin("r"~op~"=q.r; c"~op~"=q.c;");
        return this;
      }
      Pos opBinary(string op, U)(U a) const
        if ((op == "*" || op == "/") && isIntegral!U)
      {
        return mixin("Pos(r"~op~"a, c"~op~"a)");
      }
      ref Pos opOpAssign(string op, U)(U a)
        if ((op == "*" || op == "/") && isIntegral!U)
      {
        mixin("r"~op~"=a; c"~op~"=a;");
        return this;
      }
      int opBinary(string op: "*")(Pos q) const
      {
        return r*q.r+c*q.c;
      }
    }

    pure nothrow @safe
    {
      auto toString() const
      {
        return "Pos("~r.to!string~", "~c.to!string~")";
      }
      auto around4() const
      {
        return [Pos(r-1, c), Pos(r, c+1), Pos(r+1, c), Pos(r, c-1)]
          .filter!(p => p.inRegion);
      }
      auto around8() const
      {
        return [Pos(r-1, c), Pos(r-1, c+1), Pos(r, c+1), Pos(r+1, c+1),
                Pos(r+1, c), Pos(r+1, c-1), Pos(r, c-1), Pos(r-1, c-1)]
          .filter!(p => p.inRegion);
      }
    }
  }

  pure nothrow @safe
  {
    auto allPos()
    {
      return AllPosRange();
    }
  }

  private
  {
    struct AllPosRange
    {
      int r, c;
      @property pure Pos front() { return Pos(r, c); }
      void popFront() { if (++c >= w) { c = 0; ++r; } }
      pure bool empty() const { return r >= h; }
    }
  }

  struct Grid(T)
  {
    T[][] data;

    pure nothrow @safe
    {
      Grid!T dup() const
      {
        return Grid!T(data.map!"a.dup".array);
      }
    }

    pure nothrow @nogc @safe
    {
      this(T[][] data)
      {
        this.data = data;
      }

      T opIndex(size_t r, size_t c) const
        in { assert(0 <= r && r < h && 0 <= c && c < w); }
      do
      {
        return data[r][c];
      }
      T opIndex(Pos p) const
        in { assert(p.inRegion); }
      do
      {
        return data[p.r][p.c];
      }
      Grid!T opIndexAssign(T v, size_t r, size_t c)
        in { assert(0 <= r && r < h && 0 <= c && c < w); }
      do
      {
        data[r][c] = v;
        return this;
      }
      Grid!T opIndexAssign(T v, Pos p)
        in { assert(p.inRegion); }
      do
      {
        data[p.r][p.c] = v;
        return this;
      }
      Grid!T opIndexOpAssign(string op)(T v, size_t r, size_t c)
        in { assert(0 <= r && r < h && 0 <= c && c < w); }
      do
      {
        mixin("data[r][c]"~op~"=v;");
        return this;
      }
      Grid!T opIndexOpAssign(string op)(T v, Pos p)
        in { assert(p.inRegion); }
      do
      {
        mixin("data[p.r][p.c]"~op~"=v;");
        return this;
      }
      Grid!T opIndexUnary(string op)(size_t r, size_t c)
        if (op == "++" || op == "--")
        in { assert(0 <= r && r < h && 0 <= c && c < w); }
      do
      {
        mixin(op~"data[r][c];"); return this; }
      Grid!T opIndexUnary(string op)(Pos p)
        if (op == "++" || op == "--")
        in { assert(p.inRegion); }
      do
      {
        mixin(op~"data[p.r][p.c];");
        return this;
      }
    }
  }
  pure nothrow @safe
  {
    auto grid(T)(T[][] data = new T[][](h, w))
    {
      return Grid!T(data);
    }
  }
}

class UnionFind
{
  int n;

  pure nothrow @safe
  {
    this(int n)
    {
      this.n = this.s = n;
      p = new int[](n); p[] = s;
      cf = n;
      cn = new size_t[](n); cn[] = 1;
    }
  }

  pure nothrow @nogc @safe
  {
    bool unite(int u, int v)
      in { assert(0 <= u && u < n && 0 <= v && v < n); }
    do
    {
      auto pu = subst(u), pv = subst(v);
      if (pu != pv) {
        p[pv] = pu;
        --cf;
        cn[pu] += cn[pv];
        return true;
      } else {
        return false;
      }
    }

    int subst(int u)
      in { assert(0 <= u && u < n); }
    do
    {
      return p[u] == s ? u : (p[u] = subst(p[u]));
    }

    bool isSame(int u, int v)
      in { assert(0 <= u && u < n && 0 <= v && v < n); }
    do
    {
      return subst(u) == subst(v);
    }
    size_t countForests()
    {
      return cf;
    }
    size_t countNodes(int u)
    {
      return cn[subst(u)];
    }
  }

  pure nothrow @safe
  {
    auto groups()
    {
      auto g = new int[][](n);
      foreach (i; 0..n) g[subst(i)] ~= i;
      return g.filter!(l => !l.empty);
    }
  }

  private
  {
    int[] p; int s;
    size_t cf; size_t[] cn;
  }
}

pure nothrow @safe
{
  auto unionFind(int n)
  {
    return new UnionFind(n);
  }
}

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);
      }
    }
  }
}