Problem p02808 (C++)

Buggy submission (status: Runtime Error):
#line 1 "main.cpp"
#include <bits/stdc++.h>
#line 2 "/home/ubuntu/Library/utils/macros.hpp"
#define REP(i, n) for (int i = 0; (i) < (int)(n); ++(i))
#define REP3(i, m, n) for (int i = (m); (i) < (int)(n); ++(i))
#define REP_R(i, n) for (int i = (int)(n)-1; (i) >= 0; --(i))
#define REP3R(i, m, n) for (int i = (int)(n)-1; (i) >= (int)(m); --(i))
#define ALL(x) std::begin(x), std::end(x)
#line 2 "/home/ubuntu/Library/modulus/mint.hpp"
#include <algorithm>
#include <cassert>
#include <iostream>
#line 2 "/home/ubuntu/Library/modulus/modpow.hpp"
#include <cassert>

inline constexpr int32_t modpow(uint_fast64_t x, uint64_t k, int32_t MOD) {
  assert(0 <= x and x < MOD);
  uint_fast64_t y = 1;
  for (; k; k >>= 1) {
    if (k & 1)
      (y *= x) %= MOD;
    (x *= x) %= MOD;
  }
  assert(0 <= y and y < MOD);
  return y;
}
#line 2 "/home/ubuntu/Library/modulus/modinv.hpp"
#include <algorithm>
#include <cassert>

inline int32_t modinv_nocheck(int32_t value, int32_t MOD) {
  assert(0 <= value and value < MOD);
  if (value == 0)
    return -1;
  int64_t a = value, b = MOD;
  int64_t x = 0, y = 1;
  for (int64_t u = 1, v = 0; a;) {
    int64_t q = b / a;
    x -= q * u;
    std::swap(x, u);
    y -= q * v;
    std::swap(y, v);
    b -= q * a;
    std::swap(b, a);
  }
  if (not(value * x + MOD * y == b and b == 1))
    return -1;
  if (x < 0)
    x += MOD;
  assert(0 <= x and x < MOD);
  return x;
}

inline int32_t modinv(int32_t x, int32_t MOD) {
  int32_t y = modinv_nocheck(x, MOD);
  assert(y != -1);
  return y;
}
#line 7 "/home/ubuntu/Library/modulus/mint.hpp"

template <int32_t MOD> struct mint {
  int32_t value;
  mint() : value() {}
  mint(int64_t value_)
      : value(value_ < 0      ? value_ % MOD + MOD
              : value_ >= MOD ? value_ % MOD
                              : value_) {}
  mint(int32_t value_, std::nullptr_t) : value(value_) {}
  explicit operator bool() const { return value; }
  inline constexpr mint<MOD> operator+(mint<MOD> other) const {
    return mint<MOD>(*this) += other;
  }
  inline constexpr mint<MOD> operator-(mint<MOD> other) const {
    return mint<MOD>(*this) -= other;
  }
  inline constexpr mint<MOD> operator*(mint<MOD> other) const {
    return mint<MOD>(*this) *= other;
  }
  inline constexpr mint<MOD> &operator+=(mint<MOD> other) {
    this->value += other.value;
    if (this->value >= MOD)
      this->value -= MOD;
    return *this;
  }
  inline constexpr mint<MOD> &operator-=(mint<MOD> other) {
    this->value -= other.value;
    if (this->value < 0)
      this->value += MOD;
    return *this;
  }
  inline constexpr mint<MOD> &operator*=(mint<MOD> other) {
    this->value = (uint_fast64_t)this->value * other.value % MOD;
    return *this;
  }
  inline constexpr mint<MOD> operator-() const {
    return mint<MOD>(this->value ? MOD - this->value : 0, nullptr);
  }
  inline constexpr mint<MOD> pow(uint64_t k) const {
    return mint<MOD>(modpow(value, k, MOD), nullptr);
  }
  inline mint<MOD> inv() const {
    return mint<MOD>(modinv(value, MOD), nullptr);
  }
  inline constexpr mint<MOD> operator/(mint<MOD> other) const {
    return *this * other.inv();
  }
  inline constexpr mint<MOD> operator/=(mint<MOD> other) {
    return *this *= other.inv();
  }
  inline constexpr bool operator==(mint<MOD> other) const {
    return value == other.value;
  }
  inline constexpr bool operator!=(mint<MOD> other) const {
    return value != other.value;
  }
};
template <int32_t MOD> mint<MOD> operator*(int64_t value, mint<MOD> n) {
  return mint<MOD>(value) * n;
}
template <int32_t MOD>
std::istream &operator>>(std::istream &in, mint<MOD> &n) {
  int64_t value;
  in >> value;
  n = value;
  return in;
}
template <int32_t MOD>
std::ostream &operator<<(std::ostream &out, mint<MOD> n) {
  return out << n.value;
}
#line 2 "/home/ubuntu/Library/modulus/choose.hpp"
#include <cassert>
#line 2 "/home/ubuntu/Library/modulus/factorial.hpp"
#include <vector>
#line 4 "/home/ubuntu/Library/modulus/factorial.hpp"

template <int32_t MOD> mint<MOD> fact(int n) {
  static std::vector<mint<MOD>> memo(1, 1);
  while (n >= memo.size()) {
    memo.push_back(memo.back() * mint<MOD>(memo.size()));
  }
  return memo[n];
}
template <int32_t MOD> mint<MOD> inv_fact(int n) {
  static std::vector<mint<MOD>> memo;
  if (memo.size() <= n) {
    int l = memo.size();
    int r = n * 1.3 + 100;
    memo.resize(r);
    memo[r - 1] = fact<MOD>(r - 1).inv();
    for (int i = r - 2; i >= l; --i) {
      memo[i] = memo[i + 1] * (i + 1);
    }
  }
  return memo[n];
}
#line 6 "/home/ubuntu/Library/modulus/choose.hpp"

/**
 * @note O(n log n) at first time, otherwise O(1)
 */
template <int32_t MOD> mint<MOD> choose(int n, int r) {
  assert(0 <= r and r <= n);
  return fact<MOD>(n) * inv_fact<MOD>(n - r) * inv_fact<MOD>(r);
}
template <int32_t MOD> mint<MOD> permute(int n, int r) {
  assert(0 <= r and r <= n);
  return fact<MOD>(n) * inv_fact<MOD>(n - r);
}
template <int32_t MOD> mint<MOD> multichoose(int n, int r) {
  assert(0 <= n and 0 <= r);
  if (n == 0 and r == 0)
    return 1;
  return choose<MOD>(n + r - 1, r);
}
#line 5 "main.cpp"
using namespace std;
template <typename T> istream &operator>>(istream &in, vector<T> &xs) {
  REP(i, xs.size()) { in >> xs[i]; }
  return in;
}

constexpr int MOD = 1e9 + 7;
mint<MOD> solve(int n, int k, const vector<int> &a) {
  vector<mint<MOD>> cur(n + 1), prv;
  cur[0] += 1;
  REP(i, k) {
    cur.swap(prv);
    cur.assign(n + 1, 0);
    REP(x, n + 1) {
      REP(y, min(a[i] + 1, n + 1 - x)) {
        int z = a[i] - y;
        cur[x + y] += prv[x] * choose<MOD>(n - x, y) * choose<MOD>(n - y, z);
      }
    }
  }
  return cur[n];
}

int main() {
  int n, k;
  cin >> n >> k;
  vector<int> a(n);
  cin >> a;
  cout << solve(n, k, a) << endl;
  return 0;
}


Fixed submission:
#line 1 "main.cpp"
#include <bits/stdc++.h>
#line 2 "/home/ubuntu/Library/utils/macros.hpp"
#define REP(i, n) for (int i = 0; (i) < (int)(n); ++(i))
#define REP3(i, m, n) for (int i = (m); (i) < (int)(n); ++(i))
#define REP_R(i, n) for (int i = (int)(n)-1; (i) >= 0; --(i))
#define REP3R(i, m, n) for (int i = (int)(n)-1; (i) >= (int)(m); --(i))
#define ALL(x) std::begin(x), std::end(x)
#line 2 "/home/ubuntu/Library/modulus/mint.hpp"
#include <algorithm>
#include <cassert>
#include <iostream>
#line 2 "/home/ubuntu/Library/modulus/modpow.hpp"
#include <cassert>

inline constexpr int32_t modpow(uint_fast64_t x, uint64_t k, int32_t MOD) {
  assert(0 <= x and x < MOD);
  uint_fast64_t y = 1;
  for (; k; k >>= 1) {
    if (k & 1)
      (y *= x) %= MOD;
    (x *= x) %= MOD;
  }
  assert(0 <= y and y < MOD);
  return y;
}
#line 2 "/home/ubuntu/Library/modulus/modinv.hpp"
#include <algorithm>
#include <cassert>

inline int32_t modinv_nocheck(int32_t value, int32_t MOD) {
  assert(0 <= value and value < MOD);
  if (value == 0)
    return -1;
  int64_t a = value, b = MOD;
  int64_t x = 0, y = 1;
  for (int64_t u = 1, v = 0; a;) {
    int64_t q = b / a;
    x -= q * u;
    std::swap(x, u);
    y -= q * v;
    std::swap(y, v);
    b -= q * a;
    std::swap(b, a);
  }
  if (not(value * x + MOD * y == b and b == 1))
    return -1;
  if (x < 0)
    x += MOD;
  assert(0 <= x and x < MOD);
  return x;
}

inline int32_t modinv(int32_t x, int32_t MOD) {
  int32_t y = modinv_nocheck(x, MOD);
  assert(y != -1);
  return y;
}
#line 7 "/home/ubuntu/Library/modulus/mint.hpp"

template <int32_t MOD> struct mint {
  int32_t value;
  mint() : value() {}
  mint(int64_t value_)
      : value(value_ < 0      ? value_ % MOD + MOD
              : value_ >= MOD ? value_ % MOD
                              : value_) {}
  mint(int32_t value_, std::nullptr_t) : value(value_) {}
  explicit operator bool() const { return value; }
  inline constexpr mint<MOD> operator+(mint<MOD> other) const {
    return mint<MOD>(*this) += other;
  }
  inline constexpr mint<MOD> operator-(mint<MOD> other) const {
    return mint<MOD>(*this) -= other;
  }
  inline constexpr mint<MOD> operator*(mint<MOD> other) const {
    return mint<MOD>(*this) *= other;
  }
  inline constexpr mint<MOD> &operator+=(mint<MOD> other) {
    this->value += other.value;
    if (this->value >= MOD)
      this->value -= MOD;
    return *this;
  }
  inline constexpr mint<MOD> &operator-=(mint<MOD> other) {
    this->value -= other.value;
    if (this->value < 0)
      this->value += MOD;
    return *this;
  }
  inline constexpr mint<MOD> &operator*=(mint<MOD> other) {
    this->value = (uint_fast64_t)this->value * other.value % MOD;
    return *this;
  }
  inline constexpr mint<MOD> operator-() const {
    return mint<MOD>(this->value ? MOD - this->value : 0, nullptr);
  }
  inline constexpr mint<MOD> pow(uint64_t k) const {
    return mint<MOD>(modpow(value, k, MOD), nullptr);
  }
  inline mint<MOD> inv() const {
    return mint<MOD>(modinv(value, MOD), nullptr);
  }
  inline constexpr mint<MOD> operator/(mint<MOD> other) const {
    return *this * other.inv();
  }
  inline constexpr mint<MOD> operator/=(mint<MOD> other) {
    return *this *= other.inv();
  }
  inline constexpr bool operator==(mint<MOD> other) const {
    return value == other.value;
  }
  inline constexpr bool operator!=(mint<MOD> other) const {
    return value != other.value;
  }
};
template <int32_t MOD> mint<MOD> operator*(int64_t value, mint<MOD> n) {
  return mint<MOD>(value) * n;
}
template <int32_t MOD>
std::istream &operator>>(std::istream &in, mint<MOD> &n) {
  int64_t value;
  in >> value;
  n = value;
  return in;
}
template <int32_t MOD>
std::ostream &operator<<(std::ostream &out, mint<MOD> n) {
  return out << n.value;
}
#line 2 "/home/ubuntu/Library/modulus/choose.hpp"
#include <cassert>
#line 2 "/home/ubuntu/Library/modulus/factorial.hpp"
#include <vector>
#line 4 "/home/ubuntu/Library/modulus/factorial.hpp"

template <int32_t MOD> mint<MOD> fact(int n) {
  static std::vector<mint<MOD>> memo(1, 1);
  while (n >= memo.size()) {
    memo.push_back(memo.back() * mint<MOD>(memo.size()));
  }
  return memo[n];
}
template <int32_t MOD> mint<MOD> inv_fact(int n) {
  static std::vector<mint<MOD>> memo;
  if (memo.size() <= n) {
    int l = memo.size();
    int r = n * 1.3 + 100;
    memo.resize(r);
    memo[r - 1] = fact<MOD>(r - 1).inv();
    for (int i = r - 2; i >= l; --i) {
      memo[i] = memo[i + 1] * (i + 1);
    }
  }
  return memo[n];
}
#line 6 "/home/ubuntu/Library/modulus/choose.hpp"

/**
 * @note O(n log n) at first time, otherwise O(1)
 */
template <int32_t MOD> mint<MOD> choose(int n, int r) {
  assert(0 <= r and r <= n);
  return fact<MOD>(n) * inv_fact<MOD>(n - r) * inv_fact<MOD>(r);
}
template <int32_t MOD> mint<MOD> permute(int n, int r) {
  assert(0 <= r and r <= n);
  return fact<MOD>(n) * inv_fact<MOD>(n - r);
}
template <int32_t MOD> mint<MOD> multichoose(int n, int r) {
  assert(0 <= n and 0 <= r);
  if (n == 0 and r == 0)
    return 1;
  return choose<MOD>(n + r - 1, r);
}
#line 5 "main.cpp"
using namespace std;
template <typename T> istream &operator>>(istream &in, vector<T> &xs) {
  REP(i, xs.size()) { in >> xs[i]; }
  return in;
}

constexpr int MOD = 1e9 + 7;
mint<MOD> solve(int n, int k, const vector<int> &a) {
  vector<mint<MOD>> cur(n + 1), prv;
  cur[0] += 1;
  REP(i, k) {
    cur.swap(prv);
    cur.assign(n + 1, 0);
    REP(x, n + 1) {
      REP(y, min(a[i] + 1, n + 1 - x)) {
        int z = a[i] - y;
        cur[x + y] += prv[x] * choose<MOD>(n - x, y) * choose<MOD>(n - y, z);
      }
    }
  }
  return cur[n];
}

int main() {
  int n, k;
  cin >> n >> k;
  vector<int> a(k);
  cin >> a;
  cout << solve(n, k, a) << endl;
  return 0;
}