Problem p03083 (C++)

Buggy submission (status: Time Limit Exceeded):
#include <bits/stdc++.h>

#pragma GCC optimize("O3")
#pragma GCC target("tune=native")
#pragma GCC target("avx")
// #pragma GCC target("avx2")
#pragma GCC optimize("unroll-loops")

using namespace std;

using i64 = int64_t;

const i64 MOD = 1e9 + 7;

const i64 INF = 1e18 + 7;

// pythonのrangeのような範囲for文用のclass for(const auto& i : Range<>(10))
// のように書く
template <typename T = i64> struct Range {
  struct iterator {
    T value;
    const T step, last;
    const T &operator*() { return value; }
    iterator(T value, T step, T last)
        : value(step < static_cast<T>(0) ? max(last, value) : min(last, value)),
          step(step), last(last) {}
    iterator operator++() {
      value = step < static_cast<T>(0) ? max(value + step, last)
                                       : min(value + step, last);
      return *this;
    }
    bool operator!=(const iterator &x) { return value != x.value; }
  };
  const T start, last, step;

  Range(const T start, const T last, const T step = static_cast<T>(1))
      : start(start), last(last), step(step) {}

  Range(const T last) : start(0), last(last), step(1) {}

  iterator begin() { return iterator(start, step, last); }
  iterator end() { return iterator(last, step, last); }
};

// lambda式を用いた再帰
template <typename F> struct FixPoint {
  const F _f;
  FixPoint(F &&f) : _f(forward<F>(f)) {}

  template <typename... Types>
  decltype(auto) operator()(Types &&...args) const {
    return _f(*this, forward<Types>(args)...);
  }
};

template <typename F> static decltype(auto) makeRec(F &&f) {
  return FixPoint<F>(forward<F>(f));
}

// 多次元vectorの一斉初期化 makeVector<i64, 0>(a, b, ...)のように書く
template <typename T, T Value = T()> vector<T> makeVector(size_t x) {
  return vector<T>(x, T(Value));
}

template <typename T, T Value = T(), typename... Types>
auto makeVector(size_t x, Types... args) {
  return vector<decltype(makeVector<T, Value>(args...))>(
      x, makeVector<T, Value>(args...));
}

// 最大値を更新し、更新できた時にはtrueを返す
template <typename T = i64> bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}

// 同様に最小値を更新する
template <typename T = i64> bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}

// 行数と変数名、値をclogに表示するデバッグ用print
#define dump(x)                                                                \
  fprintf(stderr, "line =%4d, name =%7s , ", __LINE__, #x);                    \
  clog << "value = " << x << endl;

// 同様の配列向けデバッグ用print
#define vecdump(x)                                                             \
  fprintf(stderr, "line =%4d, name =%7s\n", __LINE__, #x);                     \
  _dump_macro(x);

void _dump(int, string &x) { clog << x << endl; }

template <typename T> void _dump(bool, T &x) { clog << x << " "; }

template <typename T, typename U = typename T::iterator> void _dump(int, T &x) {

  for (auto &elm : x)
    _dump(0, elm);

  clog << endl;
}

template <typename T> void _dump_macro(T &x) { _dump(0, x); }

// input用の関数群
void _input(int, string &x) { cin >> x; }

template <typename T> void _input(bool, T &x) { cin >> x; }

template <typename T, typename U = typename T::iterator>
void _input(int, T &x) {

  for (auto &elm : x)
    _input(0, elm);
}

template <typename T> void input_single(T &x) { _input(0, x); }

auto input() {}

template <typename T, typename... Types> void input(T &value, Types &&...args) {
  input_single(value);
  input(forward<Types>(args)...);
};

void _pararell_input(size_t) {}

template <typename T, typename... Types>
void _pararell_input(size_t index, T &value, Types &&...args) {
  input(value[index]);
  _pararell_input(index, forward<Types>(args)...);
}

template <typename... Types>
void pararell_input(size_t count, Types &&...args) {
  for (const auto &i : Range<>(count))
    _pararell_input(i, forward<Types>(args)...);
}

template <i64 mod = MOD> struct ModInt {
  i64 p;

  ModInt() : p(0) {}
  ModInt(i64 x) { p = x >= 0 ? x % mod : x + (-x + mod - 1) / mod * mod; }

  ModInt &operator+=(const ModInt &y) {
    p = p + *y - ((p + *y) >= mod ? mod : 0);
    return *this;
  }
  ModInt &operator-=(const ModInt &y) {
    p = p - *y + (p - *y < 0 ? mod : 0);
    return *this;
  }
  ModInt &operator*=(const ModInt &y) {
    p = (p * *y) % mod;
    return *this;
  }
  ModInt &operator%=(const ModInt &y) {
    if (y)
      p %= *y;
    return *this;
  }

  ModInt operator+(const ModInt &y) const {
    ModInt x = *this;
    return x += y;
  }
  ModInt operator-(const ModInt &y) const {
    ModInt x = *this;
    return x -= y;
  }
  ModInt operator*(const ModInt &y) const {
    ModInt x = *this;
    return x *= y;
  }
  ModInt operator%(const ModInt &y) const {
    ModInt x = *this;
    return x %= y;
  }

  friend ostream &operator<<(ostream &stream, const ModInt<mod> &x) {
    stream << *x;
    return stream;
  }

  friend ostream &operator>>(ostream &stream, const ModInt<mod> &x) {
    stream >> *x;
    return stream;
  }

  ModInt &operator++() {
    p = (p + 1) % mod;
    return *this;
  }
  ModInt &operator--() {
    p = (p - 1 + mod) % mod;
    return *this;
  }

  bool operator==(const ModInt &y) const { return p == *y; }
  bool operator!=(const ModInt &y) const { return p != *y; }

  const i64 &operator*() const { return p; }
  i64 &operator*() { return p; }
};

using mint = ModInt<>;

signed main() {

  cin.tie(0);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(20);

  int aa, bb;
  input(aa, bb);
  int n = aa + bb;

  auto mpow = [&](mint x, i64 y) {
    mint z = x;
    mint val = y & 1 ? x : 1L;
    while (z = z * z, y >>= 1)
      if (y & 1)
        val = val * z;
    return val;
  };

  vector<mint> fact(n + 1, 1), inv(n + 1, 1);
  for (const auto &i : Range<>(n)) {
    fact[i + 1] = fact[i] * (i + 1);
    inv[i + 1] = mpow(fact[i + 1], MOD - 2);
  }

  auto ncr = [&fact, &inv](int n, int r) {
    if (n < r)
      return mint(0);
    return fact[n] * inv[r] * inv[n - r];
  };

  vector<mint> tpow(n + 1, 1), tinv(n + 1);
  for (const auto &i : Range<>(1, n + 1)) {
    tpow[i] = tpow[i - 1] * 2;
    tinv[i] = mpow(tpow[i], MOD - 2);
  }

  auto f = [&](int a, int b) {
    vector<mint> dp(a + 1, 0);
    dp[a] = 1;
    int n = a + b;
    vector<mint> val(n, 0);
    for (const auto &i : Range<>(n)) {
      vector<mint> nex(a + 1, 0);
      for (const auto &j : Range<>(a + 1)) {
        if (j && i - (a - j) != b) {
          nex[j - 1] += dp[j];
          nex[j] += dp[j];
          val[i] += dp[j];
        } else if (j) {
          nex[j - 1] += dp[j] * 2;
          val[i] += dp[j] * 2;
        } else {
          nex[j] += dp[j] * 2;
        }
      }
      dp = move(nex);
    }

    vector<mint> da(n + 1, 0), db(n + 1, 0);
    for (const auto &i : Range<>(1, n + 1)) {
      da[i] = da[i - 1] + ncr(i - 1, a - 1) * tinv[i];
      db[i] = db[i - 1] + ncr(i - 1, b - 1) * tinv[i];
    }
    for (const auto &i : Range<>(0, n)) {
      cout << (mint(1) - da[i] + db[i]) * tinv[1] << endl;
    }
  };

  f(aa, bb);
}


Fixed submission:
#include <bits/stdc++.h>

#pragma GCC optimize("O3")
#pragma GCC target("tune=native")
#pragma GCC target("avx")
// #pragma GCC target("avx2")
#pragma GCC optimize("unroll-loops")

using namespace std;

using i64 = int64_t;

const i64 MOD = 1e9 + 7;

const i64 INF = 1e18 + 7;

// pythonのrangeのような範囲for文用のclass for(const auto& i : Range<>(10))
// のように書く
template <typename T = i64> struct Range {
  struct iterator {
    T value;
    const T step, last;
    const T &operator*() { return value; }
    iterator(T value, T step, T last)
        : value(step < static_cast<T>(0) ? max(last, value) : min(last, value)),
          step(step), last(last) {}
    iterator operator++() {
      value = step < static_cast<T>(0) ? max(value + step, last)
                                       : min(value + step, last);
      return *this;
    }
    bool operator!=(const iterator &x) { return value != x.value; }
  };
  const T start, last, step;

  Range(const T start, const T last, const T step = static_cast<T>(1))
      : start(start), last(last), step(step) {}

  Range(const T last) : start(0), last(last), step(1) {}

  iterator begin() { return iterator(start, step, last); }
  iterator end() { return iterator(last, step, last); }
};

// lambda式を用いた再帰
template <typename F> struct FixPoint {
  const F _f;
  FixPoint(F &&f) : _f(forward<F>(f)) {}

  template <typename... Types>
  decltype(auto) operator()(Types &&...args) const {
    return _f(*this, forward<Types>(args)...);
  }
};

template <typename F> static decltype(auto) makeRec(F &&f) {
  return FixPoint<F>(forward<F>(f));
}

// 多次元vectorの一斉初期化 makeVector<i64, 0>(a, b, ...)のように書く
template <typename T, T Value = T()> vector<T> makeVector(size_t x) {
  return vector<T>(x, T(Value));
}

template <typename T, T Value = T(), typename... Types>
auto makeVector(size_t x, Types... args) {
  return vector<decltype(makeVector<T, Value>(args...))>(
      x, makeVector<T, Value>(args...));
}

// 最大値を更新し、更新できた時にはtrueを返す
template <typename T = i64> bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}

// 同様に最小値を更新する
template <typename T = i64> bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}

// 行数と変数名、値をclogに表示するデバッグ用print
#define dump(x)                                                                \
  fprintf(stderr, "line =%4d, name =%7s , ", __LINE__, #x);                    \
  clog << "value = " << x << endl;

// 同様の配列向けデバッグ用print
#define vecdump(x)                                                             \
  fprintf(stderr, "line =%4d, name =%7s\n", __LINE__, #x);                     \
  _dump_macro(x);

void _dump(int, string &x) { clog << x << endl; }

template <typename T> void _dump(bool, T &x) { clog << x << " "; }

template <typename T, typename U = typename T::iterator> void _dump(int, T &x) {

  for (auto &elm : x)
    _dump(0, elm);

  clog << endl;
}

template <typename T> void _dump_macro(T &x) { _dump(0, x); }

// input用の関数群
void _input(int, string &x) { cin >> x; }

template <typename T> void _input(bool, T &x) { cin >> x; }

template <typename T, typename U = typename T::iterator>
void _input(int, T &x) {

  for (auto &elm : x)
    _input(0, elm);
}

template <typename T> void input_single(T &x) { _input(0, x); }

auto input() {}

template <typename T, typename... Types> void input(T &value, Types &&...args) {
  input_single(value);
  input(forward<Types>(args)...);
};

void _pararell_input(size_t) {}

template <typename T, typename... Types>
void _pararell_input(size_t index, T &value, Types &&...args) {
  input(value[index]);
  _pararell_input(index, forward<Types>(args)...);
}

template <typename... Types>
void pararell_input(size_t count, Types &&...args) {
  for (const auto &i : Range<>(count))
    _pararell_input(i, forward<Types>(args)...);
}

template <i64 mod = MOD> struct ModInt {
  i64 p;

  ModInt() : p(0) {}
  ModInt(i64 x) { p = x >= 0 ? x % mod : x + (-x + mod - 1) / mod * mod; }

  ModInt &operator+=(const ModInt &y) {
    p = p + *y - ((p + *y) >= mod ? mod : 0);
    return *this;
  }
  ModInt &operator-=(const ModInt &y) {
    p = p - *y + (p - *y < 0 ? mod : 0);
    return *this;
  }
  ModInt &operator*=(const ModInt &y) {
    p = (p * *y) % mod;
    return *this;
  }
  ModInt &operator%=(const ModInt &y) {
    if (y)
      p %= *y;
    return *this;
  }

  ModInt operator+(const ModInt &y) const {
    ModInt x = *this;
    return x += y;
  }
  ModInt operator-(const ModInt &y) const {
    ModInt x = *this;
    return x -= y;
  }
  ModInt operator*(const ModInt &y) const {
    ModInt x = *this;
    return x *= y;
  }
  ModInt operator%(const ModInt &y) const {
    ModInt x = *this;
    return x %= y;
  }

  friend ostream &operator<<(ostream &stream, const ModInt<mod> &x) {
    stream << *x;
    return stream;
  }

  friend ostream &operator>>(ostream &stream, const ModInt<mod> &x) {
    stream >> *x;
    return stream;
  }

  ModInt &operator++() {
    p = (p + 1) % mod;
    return *this;
  }
  ModInt &operator--() {
    p = (p - 1 + mod) % mod;
    return *this;
  }

  bool operator==(const ModInt &y) const { return p == *y; }
  bool operator!=(const ModInt &y) const { return p != *y; }

  const i64 &operator*() const { return p; }
  i64 &operator*() { return p; }
};

using mint = ModInt<>;

signed main() {

  cin.tie(0);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(20);

  int aa, bb;
  input(aa, bb);
  int n = aa + bb;

  auto mpow = [&](mint x, i64 y) {
    mint z = x;
    mint val = y & 1 ? x : 1L;
    while (z = z * z, y >>= 1)
      if (y & 1)
        val = val * z;
    return val;
  };

  vector<mint> fact(n + 1, 1), inv(n + 1, 1);
  for (const auto &i : Range<>(n)) {
    fact[i + 1] = fact[i] * (i + 1);
    inv[i + 1] = mpow(fact[i + 1], MOD - 2);
  }

  auto ncr = [&fact, &inv](int n, int r) {
    if (n < r)
      return mint(0);
    return fact[n] * inv[r] * inv[n - r];
  };

  vector<mint> tpow(n + 1, 1), tinv(n + 1);
  for (const auto &i : Range<>(1, n + 1)) {
    tpow[i] = tpow[i - 1] * 2;
    tinv[i] = mpow(tpow[i], MOD - 2);
  }

  auto f = [&](int a, int b) {
    vector<mint> da(n + 1, 0), db(n + 1, 0);
    for (const auto &i : Range<>(1, n + 1)) {
      da[i] = da[i - 1] + ncr(i - 1, a - 1) * tinv[i];
      db[i] = db[i - 1] + ncr(i - 1, b - 1) * tinv[i];
    }
    for (const auto &i : Range<>(0, n)) {
      cout << (mint(1) - da[i] + db[i]) * tinv[1] << endl;
    }
  };

  f(aa, bb);
}