#425967 (D) No.187 中華風 (Hard)

提出ソース

結果

問題	No.187 中華風 (Hard)
ユーザー	te-sh
提出日時	2020-02-04 20:29:27
言語	D (dmd 2.106.1)
結果	AC
実行時間	106 ms / 3,000 ms
コード長	7,186 bytes
コンパイル時間	1,252 ms
コンパイル使用メモリ	151,504 KB
実行使用メモリ	40,420 KB
最終ジャッジ日時	2023-09-04 05:25:19
合計ジャッジ時間	3,446 ms
ジャッジサーバーID （参考情報）	judge12 / judge14

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

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 4,380 KB
testcase_01	AC	3 ms 4,380 KB
testcase_02	AC	25 ms 22,592 KB
testcase_03	AC	25 ms 22,136 KB
testcase_04	AC	99 ms 38,700 KB
testcase_05	AC	99 ms 38,668 KB
testcase_06	AC	99 ms 38,684 KB
testcase_07	AC	99 ms 38,660 KB
testcase_08	AC	105 ms 40,420 KB
testcase_09	AC	105 ms 40,344 KB
testcase_10	AC	106 ms 40,340 KB
testcase_11	AC	99 ms 38,756 KB
testcase_12	AC	98 ms 38,756 KB
testcase_13	AC	5 ms 4,376 KB
testcase_14	AC	4 ms 4,376 KB
testcase_15	AC	22 ms 19,680 KB
testcase_16	AC	21 ms 20,176 KB
testcase_17	AC	2 ms 4,380 KB
testcase_18	AC	2 ms 4,376 KB
testcase_19	AC	1 ms 4,376 KB
testcase_20	AC	73 ms 30,700 KB
testcase_21	AC	2 ms 4,376 KB
testcase_22	AC	98 ms 38,752 KB
testcase_23	AC	1 ms 4,380 KB
testcase_24	AC	2 ms 4,376 KB

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

コンパイルメッセージ

Main.d(211): Deprecation: function `Main.IO!(makeGlobal, makeGlobal).IO.put!("{exit: true}", int).put.putMain!(c, int).putMain` function requires a dual-context, which is deprecated
Main.d-mixin-199(199):        instantiated from here: `putMain!(c, int)`
Main.d(13):        instantiated from here: `put!("{exit: true}", int)`
Main.d(211): Deprecation: function `Main.IO!(makeGlobal, makeGlobal).IO.put!("{}", GmpInt).put.putMain!(c, GmpInt).putMain` function requires a dual-context, which is deprecated
Main.d-mixin-199(199):        instantiated from here: `putMain!(c, GmpInt)`
Main.d(201):        instantiated from here: `put!("{}", GmpInt)`
Main.d(16):        instantiated from here: `putB!("{}", GmpInt, GmpInt)`

ソースコード

raw source code

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

import std.algorithm, std.array, std.container, std.math, std.range, std.typecons, std.string;

version(unittest) {} else
void main()
{
  int N; io.getV(N);
  int[] X, Y; io.getC(N, X, Y);

  auto x = GmpInt(X[0]), y = GmpInt(Y[0]);
  foreach (i; 1..N)
    if (!calc(x, y, GmpInt(X[i]), GmpInt(Y[i]))) io.put!"{exit: true}"(-1);

  auto mod = 10^^9+7;
  io.putB(x == 0, y%mod, x%mod);
}

auto calc(T)(ref T X1, ref T Y1, T X2, T Y2)
{
  T b1, b2;
  auto g = extGcd(Y1, Y2, b1, b2);
  if ((X2-X1)%g != 0) return false;

  auto y1 = Y1/g, y2 = Y2/g;
  Y1 = y1*y2*g;
  X1 = ((b1*y1*(X2-X1)+X1)%Y1+Y1)%Y1;
  return true;
}

struct GmpInt
{
  import std.conv;

  @property static init() { return GmpInt(0); }

  @property value() { return toLong(); }
  @property value(long v) { __gmpz_init_set_si(&z, v); }
  alias value this;

  this(long v) { __gmpz_init_set_si(&z, v); }
  this(string s, int base = 10) { __gmpz_init_set_str(&z, s.toStringz, base); }

  long toLong() { return __gmpz_get_si(&z); }
  string toString(int base = 10)
  {
    import std.string;
    auto sz = __gmpz_sizeinbase(&z, base);
    auto buf = new char[](sz + 2);
    __gmpz_get_str(buf.ptr, base, &z);
    return buf.ptr.fromStringz.to!string;
  }

  bool opEquals(GmpInt v) { return __gmpz_cmp(&z, &v.z) == 0; }
  bool opEquals(long v) { return __gmpz_cmp_si(&z, v) == 0; }
  int opCmp(GmpInt v) { return __gmpz_cmp(&z, &v.z); }
  int opCmp(long v) { return __gmpz_cmp_si(&z, v); }

  GmpInt opAssign(long v) { __gmpz_init_set_si(&z, v); return this; }
  GmpInt opAssign(GmpInt v) { __gmpz_init_set(&z, &v.z); return this; }

  GmpInt opBinary(string op)(GmpInt v) if (op=="+"||op=="-"||op=="*"||op=="/"||op=="%")
  {
    auto r = GmpInt.init;
    static if (op == "+") __gmpz_add(&r.z, &z, &v.z);
    else   if (op == "-") __gmpz_sub(&r.z, &z, &v.z);
    else   if (op == "*") __gmpz_mul(&r.z, &z, &v.z);
    else   if (op == "/") __gmpz_tdiv_q(&r.z, &z, &v.z);
    else   if (op == "%") __gmpz_tdiv_r(&r.z, &z, &v.z);
    return r;
  }
  ref GmpInt opOpAssign(string op)(GmpInt v) if (op=="+"||op=="-"||op=="*"||op=="/"||op=="%")
  {
    static if (op == "+") __gmpz_add(&z, &z, &v.z);
    else   if (op == "-") __gmpz_sub(&z, &z, &v.z);
    else   if (op == "*") __gmpz_mul(&z, &z, &v.z);
    else   if (op == "/") __gmpz_tdiv_q(&z, &z, &v.z);
    else   if (op == "%") __gmpz_tdiv_r(&z, &z, &v.z);
    return this;
  }

  GmpInt opBinary(string op)(ulong v) if (op=="+"||op=="-"||op=="*"||op=="/"||op=="%"||op=="^^")
  {
    auto r = GmpInt.init;
    static if (op == "+") __gmpz_add_ui(&r.z, &z, v);
    else   if (op == "-") __gmpz_sub_ui(&r.z, &z, v);
    else   if (op == "*") __gmpz_mul_ui(&r.z, &z, v);
    else   if (op == "/") __gmpz_tdiv_q_ui(&r.z, &z, v);
    else   if (op == "%") __gmpz_tdiv_r_ui(&r.z, &z, v);
    else   if (op == "^^") __gmpz_pow_ui(&r.z, &z, v);
    return r;
  }
  ref GmpInt opOpAssign(string op)(ulong v) if (op=="+"||op=="-"||op=="*"||op=="/"||op=="%"||op=="^^")
  {
    static if (op == "+") __gmpz_add_ui(&z, &z, v);
    else   if (op == "-") __gmpz_sub_ui(&z, &z, v);
    else   if (op == "*") __gmpz_mul_ui(&z, &z, v);
    else   if (op == "/") __gmpz_tdiv_q_ui(&z, &z, v);
    else   if (op == "%") __gmpz_tdiv_r_ui(&z, &z, v);
    else   if (op == "^^") __gmpz_pow_ui(&z, &z, v);
    return this;
  }

  GmpInt sqrt()
  {
    auto r = GmpInt.init;
    __gmpz_sqrt(&r.z, &z);
    return r;
  }

  size_t popcnt()
  {
    return __gmpz_popcount(&z);
  }

  bool probabPrime(int reps = 20)
  {
    return __gmpz_probab_prime_p(&z, reps) != 0;
  }

  private __mpz_struct z;
}

GmpInt extGcd(GmpInt a, GmpInt b, out GmpInt x, out GmpInt y)
{
  auto g = a; x = 1; y = 0;
  if (b) { g = extGcd(b, a%b, y, x); y -= a/b*x; }
  return g;
}

extern(C) pragma(inline, false)
{
  alias __mp_limb_t = ulong;

  struct __mpz_struct
  {
    int _mp_alloc;
    int _mp_size;
    __mp_limb_t* _mp_d;
  }

  alias mpz_srcptr = const(__mpz_struct)*;
  alias mpz_ptr = __mpz_struct*;

  void __gmpz_init_set(mpz_ptr, mpz_srcptr);
  void __gmpz_init_set_si(mpz_ptr, long);
  int __gmpz_init_set_str(mpz_ptr, const char*, int);

  long __gmpz_get_si(mpz_srcptr);
  char *__gmpz_get_str(char*, int, mpz_srcptr);
  size_t __gmpz_sizeinbase(mpz_srcptr, int);

  int __gmpz_cmp(mpz_srcptr, mpz_srcptr);
  int __gmpz_cmp_si(mpz_srcptr, long);

  void __gmpz_add(mpz_ptr, mpz_srcptr, mpz_srcptr);
  void __gmpz_add_ui(mpz_ptr, mpz_srcptr, ulong);
  void __gmpz_sub(mpz_ptr, mpz_srcptr, mpz_srcptr);
  void __gmpz_sub_ui(mpz_ptr, mpz_srcptr, ulong);
  void __gmpz_mul(mpz_ptr, mpz_srcptr, mpz_srcptr);
  void __gmpz_mul_ui(mpz_ptr, mpz_srcptr, ulong);
  void __gmpz_tdiv_q(mpz_ptr, mpz_srcptr, mpz_srcptr);
  void __gmpz_tdiv_r(mpz_ptr, mpz_srcptr, mpz_srcptr);
  ulong __gmpz_tdiv_q_ui(mpz_ptr, mpz_srcptr, ulong);
  ulong __gmpz_tdiv_r_ui(mpz_ptr, mpz_srcptr, ulong);
  void __gmpz_pow_ui(mpz_ptr, mpz_srcptr, ulong);

  void __gmpz_sqrt(mpz_ptr, mpz_srcptr);
  size_t __gmpz_popcount(mpz_srcptr);
  int __gmpz_probab_prime_p(mpz_ptr, int reps);
}
pragma(lib, "gmp");

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

  auto getV(T...)(ref T v) { foreach (ref w; v) get(w); }
  auto getA(T)(size_t n, ref T v) if (hasAssignableElements!T)
  { v = new T(n); foreach (ref w; v) get(w); }
  auto 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]);
  }
  auto 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...)
  {
    auto getS(T)(size_t n, ref T v)
    { v = new T(n); foreach (ref w; v) foreach (e; E) mixin("get(w."~e~");"); }
  }

  auto put(alias conf = "{}", T...)(T v)
  { mixin("const PutConf c = "~conf~"; putMain!c(v);"); }
  auto putB(alias conf = "{}", S, T)(bool c, S t, T f)
  { if (c) put(t); else put(f); }
  auto 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; }
    auto get(T)(ref T v) { if (sp.empty) nextLine(); v = sp.front.to!T; sp.popFront(); }

    auto putMain(PutConf c, T...)(T v)
    {
      foreach (i, w; v) {
        putOne!c(w);
        if (i < v.length-1) OUT.write(c.delimiter);
      }
      static if (c.newline) OUT.writeln;
      static if (c.flush) OUT.flush();
      static if (c.exit) exit(0);
    }
    auto putOne(PutConf c, T)(T v)
    {
      static if (isInputRange!T && !isSomeString!T) putRange!c(v);
      else if (isFloatingPoint!T) OUT.write(format(c.floatFormat, v));
      else OUT.write(v);
    }
    auto 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);
      }
    }
  }
}
const struct PutConf
{
  bool newline = true, flush, exit;
  string floatFormat = "%.10f", delimiter = " ";
}