結果

問題 No.318 学学学学学
ユーザー te-shte-sh
提出日時 2017-06-21 14:45:50
言語 D
(dmd 2.106.1)
結果
WA  
実行時間 -
コード長 2,056 bytes
コンパイル時間 806 ms
コンパイル使用メモリ 110,780 KB
実行使用メモリ 17,252 KB
最終ジャッジ日時 2024-06-12 20:24:10
合計ジャッジ時間 4,786 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 10 ms
6,816 KB
testcase_01 AC 19 ms
6,816 KB
testcase_02 AC 23 ms
6,940 KB
testcase_03 AC 16 ms
6,940 KB
testcase_04 AC 21 ms
6,944 KB
testcase_05 AC 115 ms
17,252 KB
testcase_06 WA -
testcase_07 WA -
testcase_08 WA -
testcase_09 WA -
testcase_10 WA -
testcase_11 AC 114 ms
16,728 KB
testcase_12 WA -
testcase_13 WA -
testcase_14 WA -
testcase_15 WA -
testcase_16 WA -
testcase_17 AC 83 ms
14,056 KB
testcase_18 WA -
testcase_19 AC 84 ms
14,748 KB
testcase_20 WA -
testcase_21 AC 1 ms
6,940 KB
testcase_22 AC 2 ms
6,944 KB
testcase_23 AC 2 ms
6,944 KB
testcase_24 AC 1 ms
6,940 KB
testcase_25 AC 1 ms
6,944 KB
testcase_26 AC 1 ms
6,940 KB
testcase_27 AC 1 ms
6,944 KB
testcase_28 AC 1 ms
6,944 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

import std.algorithm, std.conv, std.range, std.stdio, std.string;

void main()
{
  auto n = readln.chomp.to!size_t;
  auto ai = readln.split.to!(int[]);

  int[int] buf;
  auto di = ai.dup.sort().uniq.array, k = 0;
  foreach (d; di) buf[d] = k++;

  auto inf = k+1;

  auto ci = new int[](n);
  foreach (i, a; ai) ci[i] = buf[ai[i]];

  auto mi = new size_t[](k), ma = new size_t[](k);
  mi[] = inf;
  foreach (i, c; ci)
    if (mi[c] > k)
      mi[c] = ma[c] = i;
    else
      ma[c] = i;

  auto st = SegmentTreeLazy!int(n);
  foreach (j; 0..k)
    st[mi[j]..ma[j]+1] = j;

  writeln(di.indexed(st.all).array.to!(string[]).join(" "));
}

struct SegmentTreeLazy(T)
{
  import core.bitop, std.conv, std.range;

  const size_t n, an;
  T[] buf;
  bool[] op;

  this(size_t n)
  {
    this.n = n;
    an = (1 << ((n - 1).bsr + 1));
    buf = new T[](an * 2);
    op = new bool[](an * 2);
  }

  void propagate(size_t k, size_t nl, size_t nr)
  {
    if (!op[k]) return;

    size_t nm = (nl + nr) / 2;
    setLazy(buf[k], k*2,   nl, nm);
    setLazy(buf[k], k*2+1, nm, nr);

    op[k] = false;
  }

  void setLazy(T val, size_t k, size_t nl, size_t nr)
  {
    buf[k] = val;
    op[k] = true;
  }

  void addOpe(T val, size_t l, size_t r, size_t k, size_t nl, size_t nr)
  {
    if (nr <= l || r <= nl) return;

    if (l <= nl && nr <= r) {
      setLazy(val, k, nl, nr);
      return;
    }

    propagate(k, nl, nr);

    auto nm = (nl + nr) / 2;
    addOpe(val, l, r, k*2,   nl, nm);
    addOpe(val, l, r, k*2+1, nm, nr);
  }

  void opSliceAssign(T val, size_t l, size_t r)
  {
    addOpe(val, l, r, 1, 0, an);
  }

  void propagateAll(size_t k, size_t nl, size_t nr)
  {
    size_t nm = (nl + nr) / 2;

    if (op[k]) {
      setLazy(buf[k], k*2,   nl, nm);
      setLazy(buf[k], k*2+1, nm, nr);

      op[k] = false;
    }

    if (nr - nl > 1) {
      propagateAll(k*2,   nl, nm);
      propagateAll(k*2+1, nm, nr);
    }
  }

  T[] all()
  {
    propagateAll(0, 0, an);
    return buf[an..an+n];
  }

  pure size_t opDollar() const { return n; }
}
0