結果

問題 No.1503 Bitwise And Convolution Twisted
ユーザー risujirohrisujiroh
提出日時 2021-05-08 02:25:54
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 346 ms / 2,000 ms
コード長 4,452 bytes
コンパイル時間 2,575 ms
コンパイル使用メモリ 206,180 KB
実行使用メモリ 11,440 KB
最終ジャッジ日時 2024-09-15 16:48:48
合計ジャッジ時間 8,883 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
5,248 KB
testcase_01 AC 2 ms
5,376 KB
testcase_02 AC 2 ms
5,376 KB
testcase_03 AC 2 ms
5,376 KB
testcase_04 AC 2 ms
5,376 KB
testcase_05 AC 2 ms
5,376 KB
testcase_06 AC 7 ms
5,376 KB
testcase_07 AC 87 ms
5,376 KB
testcase_08 AC 7 ms
5,376 KB
testcase_09 AC 346 ms
11,264 KB
testcase_10 AC 345 ms
11,252 KB
testcase_11 AC 343 ms
11,440 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>

template <class ForwardIterator, class F> void bitwise_transform(ForwardIterator first, ForwardIterator last, F f) {
  int n = std::distance(first, last);
  assert((n & (n - 1)) == 0);
  for (int step = 1; step < n; step *= 2)
    for (auto it0 = first; it0 != last;) {
      auto it1 = std::next(it0, step);
      for (auto end = it1; it0 != end; ++it0, ++it1) f(*it0, *it1);
      it0 = it1;
    }
}

template <uint32_t Modulus> class ModularInt {
  using M = ModularInt;

 public:
  static_assert(int(Modulus) >= 1, "Modulus must be in the range [1, 2^31)");
  static constexpr int modulus() { return Modulus; }
  static M raw(uint32_t v) { return *reinterpret_cast<M*>(&v); }

  ModularInt() : v_(0) {}
  ModularInt(int64_t v) : v_((v %= Modulus) < 0 ? v + Modulus : v) {}

  template <class T> explicit operator T() const { return v_; }
  M& operator++() { return v_ = ++v_ == Modulus ? 0 : v_, *this; }
  M& operator--() { return --(v_ ? v_ : v_ = Modulus), *this; }
  M& operator*=(M o) { return v_ = uint64_t(v_) * o.v_ % Modulus, *this; }
  M& operator/=(M o) {
    auto [inv, gcd] = extgcd(o.v_, Modulus);
    assert(gcd == 1);
    return *this *= inv;
  }
  M& operator+=(M o) { return v_ = int(v_ += o.v_ - Modulus) < 0 ? v_ + Modulus : v_, *this; }
  M& operator-=(M o) { return v_ = int(v_ -= o.v_) < 0 ? v_ + Modulus : v_, *this; }

  friend M operator++(M& a, int) { return std::exchange(a, ++M(a)); }
  friend M operator--(M& a, int) { return std::exchange(a, --M(a)); }
  friend M operator+(M a) { return a; }
  friend M operator-(M a) { return a.v_ = a.v_ ? Modulus - a.v_ : 0, a; }
  friend M operator*(M a, M b) { return a *= b; }
  friend M operator/(M a, M b) { return a /= b; }
  friend M operator+(M a, M b) { return a += b; }
  friend M operator-(M a, M b) { return a -= b; }
  friend std::istream& operator>>(std::istream& is, M& x) {
    int64_t v;
    return is >> v, x = v, is;
  }
  friend std::ostream& operator<<(std::ostream& os, M x) { return os << x.v_; }
  friend bool operator==(M a, M b) { return a.v_ == b.v_; }
  friend bool operator!=(M a, M b) { return a.v_ != b.v_; }

 private:
  static std::pair<int, int> extgcd(int a, int b) {
    std::array x{1, 0};
    while (b) std::swap(x[0] -= a / b * x[1], x[1]), std::swap(a %= b, b);
    return {x[0], a};
  }

  uint32_t v_;
};

#pragma region my_template

struct Rep {
  struct I {
    int i;
    void operator++() { ++i; }
    int operator*() const { return i; }
    bool operator!=(I o) const { return i < *o; }
  };
  const int l_, r_;
  Rep(int l, int r) : l_(l), r_(r) {}
  Rep(int n) : Rep(0, n) {}
  I begin() const { return {l_}; }
  I end() const { return {r_}; }
};
struct Per {
  struct I {
    int i;
    void operator++() { --i; }
    int operator*() const { return i; }
    bool operator!=(I o) const { return i > *o; }
  };
  const int l_, r_;
  Per(int l, int r) : l_(l), r_(r) {}
  Per(int n) : Per(0, n) {}
  I begin() const { return {r_ - 1}; }
  I end() const { return {l_ - 1}; }
};

template <class F> struct Fix : private F {
  Fix(F f) : F(f) {}
  template <class... Args> decltype(auto) operator()(Args&&... args) const {
    return F::operator()(*this, std::forward<Args>(args)...);
  }
};

template <class T = int> T scan() {
  T res;
  std::cin >> res;
  return res;
}

template <class T, class U = T> bool chmin(T& a, U&& b) { return b < a ? a = std::forward<U>(b), true : false; }
template <class T, class U = T> bool chmax(T& a, U&& b) { return a < b ? a = std::forward<U>(b), true : false; }

#ifndef LOCAL
#define DUMP(...) void(0)
template <int OnlineJudge, int Local> constexpr int OjLocal = OnlineJudge;
#endif

using namespace std;

#define ALL(c) begin(c), end(c)

#pragma endregion

using Mint = ModularInt<998244353>;

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  cout << fixed << setprecision(20);
  int n = scan();
  vector<Mint> a(1 << n), b(1 << n);
  generate(ALL(a), scan<>);
  generate(ALL(b), scan<>);

  bitwise_transform(ALL(a), [](auto&& lo, auto&& hi) { lo += hi; });

  bitwise_transform(ALL(b), [](auto&& lo, auto&& hi) { hi = lo - hi; });

  for (int i : Rep(1 << n)) a[i] *= b[i];

  bitwise_transform(ALL(a), [](auto&& lo, auto&& hi) { hi = lo - hi; });

  for (int i : Rep(1 << n)) cout << a[i] << " \n"[i + 1 == 1 << n];
}
0