Problem p03082 (C++)

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

using namespace std;

typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<LD, LD> PLDLD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<char> VB;

#define FOR(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define CLR(a) memset((a), 0, sizeof(a))
#define ALL(a) a.begin(), a.end()
#define UNQ(a) a.erase(std::unique(ALL(a)), a.end());
#define endl "\n"

const LD EPS = 1e-5;
const long long INFLL = (LL)(1e9) * (LL)(1e9);
const int INF = 1e9 + 7;

template <class T> void chmin(T &a, const T b) {
  if (a > b)
    a = b;
}
template <class T> void chmax(T &a, const T b) {
  if (a < b)
    a = b;
}

const LL powLL(const LL p, const LL q) {
  LL t = 1;
  for (int i = 0; i < q; i++)
    t *= p;
  return t;
}

template <typename T> struct has_iter {
private:
  template <typename U>
  static constexpr true_type check(typename U::iterator *);
  template <typename U> static constexpr false_type check(...);

public:
  static constexpr bool value = decltype(check<T>(nullptr))::value;
};

template <typename T, typename U = typename T::iterator>
void print(const T &container) {
  auto &&first = begin(container), last = end(container);
  auto &&back = prev(last);
  for (auto e = first; e != last; e = next(e))
    cout << *e << " \n"[e == back];
}

extern void *enabler;
template <typename Head,
          typename enable_if<!has_iter<Head>::value>::type *& = enabler>
void print(const Head &head) {
  cout << head << endl;
}

template <> void print<string>(const string &container) {
  cout << container << endl;
}

template <typename Head, typename... Tail>
void print(const Head &head, const Tail &...tail) {
  cout << head << " ";
  print(tail...);
}

template <typename... Args> void printd(const Args &...args) {
#ifdef DEBUG
  print(args...);
#endif
}

template <typename Head> void input(Head &head) { cin >> head; }

template <typename Head, typename... Tail>
void input(Head &head, Tail &...tail) {
  cin >> head;
  input(tail...);
}

void io_speedup() {
  cin.tie(0);
  cout.tie(0);
  ios::sync_with_stdio(false);
}

template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
  for (T &x : vec)
    is >> x;
  return is;
}

template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &t) {
  is >> t.first >> t.second;
  return is;
}

template <int N, typename... Ts,
          typename enable_if<N == sizeof...(Ts) - 1>::type *& = enabler>
void tuple_in(istream &is, tuple<Ts...> &t) {
  is >> get<N>(t);
}
template <int N, typename... Ts,
          typename enable_if<N<sizeof...(Ts) - 1>::type *& = enabler> void
              tuple_in(istream &is, tuple<Ts...> &t) {
  is >> get<N>(t);
  tuple_in<N + 1, Ts...>(is, t);
}

template <typename... Ts> istream &operator>>(istream &is, tuple<Ts...> &t) {
  tuple_in<0, Ts...>(is, t);
  return is;
}

template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &t) {
  os << '(' << t.first << ", " << t.second << ')';
  return os;
}

template <int N, typename... Ts,
          typename enable_if<N == sizeof...(Ts) - 1>::type *& = enabler>
void tuple_out(ostream &os, const tuple<Ts...> &t) {
  os << get<N>(t);
}
template <int N, typename... Ts,
          typename enable_if<N<sizeof...(Ts) - 1>::type *& = enabler> void
              tuple_out(ostream &os, const tuple<Ts...> &t) {
  os << get<N>(t) << ", ";
  tuple_out<N + 1, Ts...>(os, t);
}

template <typename... Ts>
ostream &operator<<(ostream &os, const tuple<Ts...> &t) {
  os << '(';
  tuple_out<0, Ts...>(os, t);
  os << ')';
  return os;
}

template <typename T> vector<T> read(int n) {
  vector<T> t(n);
  cin >> t;
  return t;
}

template <typename T> T read() {
  T t;
  cin >> t;
  return t;
}

template <typename Head, typename... Tail> struct vector_demensions {
  using type = vector<typename vector_demensions<Tail...>::type>;
};

template <typename Head> struct vector_demensions<Head> {
  using type = Head;
};

template <typename T> vector<T> make_vectors(int size, T val) {
  return vector<T>(size, val);
}

template <typename T = int, typename... Args>
auto make_vectors(int size, Args... tail) ->
    typename vector_demensions<Args..., T>::type {
  auto val = make_vectors<T>(forward<Args>(tail)...);
  return vector<decltype(val)>(size, val);
}

// c++14

class Mod {
public:
  using value_type = long long;

private:
  static const value_type MODULO = 1e9 + 7;
  value_type value;

  constexpr value_type Normalize(value_type x) const {
    return x < 0 ? (x % MODULO + MODULO) : (x % MODULO);
  }

public:
  constexpr Mod() : value(0) {}
  constexpr Mod(const value_type &val) : value(Normalize(val)) {}

  constexpr explicit operator value_type() const { return value; }

  constexpr const Mod operator-() const { return Mod(MODULO - value); }
  constexpr const Mod operator+(const Mod &rhs) const {
    return Mod(value + rhs.value);
  }
  constexpr const Mod operator-(const Mod &rhs) const {
    return Mod(value + (-rhs).value);
  }
  constexpr const Mod operator*(const Mod &rhs) const {
    return Mod(value * rhs.value);
  }
  constexpr Mod &operator+=(const Mod &rhs) {
    value = Normalize(value + rhs.value);
    return *this;
  }
  constexpr Mod &operator-=(const Mod &rhs) {
    value = Normalize(value - rhs.value);
    return *this;
  }
  constexpr Mod &operator*=(const Mod &rhs) {
    value = Normalize(value * rhs.value);
    return *this;
  }

  constexpr Mod pow(value_type p) const;

  constexpr Mod inv() const { return pow(MODULO - 2); }

  constexpr const Mod operator/(const Mod &rhs) const {
    return *this * rhs.inv();
  }
  constexpr Mod &operator/=(const Mod &rhs) { return *this = *this / rhs; }
  constexpr bool operator==(const Mod &rhs) { return value == rhs.value; }
};

constexpr Mod Mod::pow(value_type p) const {
  Mod tmp = 1, mult = *this;
  while (p) {
    if ((p & 1) > 0)
      tmp *= mult;
    p >>= 1;
    mult *= mult;
  }
  return tmp;
}

namespace std {
ostream &operator<<(ostream &os, const Mod mod) {
  os << (typename Mod::value_type)mod;
  return os;
}
}; // namespace std

template <size_t N> struct Factorial {
private:
  Mod ary[N];

public:
  constexpr explicit Factorial() : ary() {
    ary[0] = 1;
    for (size_t i = 1; i < N; i++)
      ary[i] = ary[i - 1] * i;
  }

  constexpr size_t size() const { return N; }

  constexpr Mod operator[](const int id) const { return ary[id]; }
};

template <size_t N> class FactorialInv {
private:
  Mod ary[N];

public:
  constexpr explicit FactorialInv(const Factorial<N> &fact) : ary() {
    for (size_t i = 0; i < N; i++)
      ary[i] = fact[i].inv();
  }

  // FactorialInv& operator=(FactorialInv&&)=default;

  constexpr Mod operator[](const int id) const { return ary[id]; }
};

template <size_t N, size_t M = N> class Combination {
private:
  const Factorial<N> fact;
  const FactorialInv<M> fact_inv;

public:
  constexpr Combination(const Factorial<N> fact_,
                        const FactorialInv<M> fact_inv_)
      : fact(fact_), fact_inv(fact_inv_) {}

  constexpr Mod operator()(const int n, const int m) const {
    return (fact)[n] * (fact_inv)[m] * (fact_inv)[n - m];
  }
};

int main() {
  Factorial<1024> fact;
  int n, x;
  cin >> n >> x;
  auto s(read<int>(n));
  sort(ALL(s), greater<int>());
  auto dp = make_vectors<Mod>(n + 1, x + 1, Mod(0));
  dp[0][x] = x;
  REP(i, n)
  REP(j, x + 1) {
    dp[i + 1][j % s[i]] += dp[i][j] * (j % s[i]) / j;
    dp[i + 1][j] += dp[i][j] * (n - i - 1);
  }
  Mod ans = 0;
  REP(j, x + 1)
  ans += dp[n][j];
  print(ans);
}

Fixed submission:
#include <bits/stdc++.h>
#include <iomanip>
#define DEBUG 1

using namespace std;

typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<LD, LD> PLDLD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<char> VB;

#define FOR(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define CLR(a) memset((a), 0, sizeof(a))
#define ALL(a) a.begin(), a.end()
#define UNQ(a) a.erase(std::unique(ALL(a)), a.end());
#define endl "\n"

const LD EPS = 1e-5;
const long long INFLL = (LL)(1e9) * (LL)(1e9);
const int INF = 1e9 + 7;

template <class T> void chmin(T &a, const T b) {
  if (a > b)
    a = b;
}
template <class T> void chmax(T &a, const T b) {
  if (a < b)
    a = b;
}

const LL powLL(const LL p, const LL q) {
  LL t = 1;
  for (int i = 0; i < q; i++)
    t *= p;
  return t;
}

template <typename T> struct has_iter {
private:
  template <typename U>
  static constexpr true_type check(typename U::iterator *);
  template <typename U> static constexpr false_type check(...);

public:
  static constexpr bool value = decltype(check<T>(nullptr))::value;
};

template <typename T, typename U = typename T::iterator>
void print(const T &container) {
  auto &&first = begin(container), last = end(container);
  auto &&back = prev(last);
  for (auto e = first; e != last; e = next(e))
    cout << *e << " \n"[e == back];
}

extern void *enabler;
template <typename Head,
          typename enable_if<!has_iter<Head>::value>::type *& = enabler>
void print(const Head &head) {
  cout << head << endl;
}

template <> void print<string>(const string &container) {
  cout << container << endl;
}

template <typename Head, typename... Tail>
void print(const Head &head, const Tail &...tail) {
  cout << head << " ";
  print(tail...);
}

template <typename... Args> void printd(const Args &...args) {
#ifdef DEBUG
  print(args...);
#endif
}

template <typename Head> void input(Head &head) { cin >> head; }

template <typename Head, typename... Tail>
void input(Head &head, Tail &...tail) {
  cin >> head;
  input(tail...);
}

void io_speedup() {
  cin.tie(0);
  cout.tie(0);
  ios::sync_with_stdio(false);
}

template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
  for (T &x : vec)
    is >> x;
  return is;
}

template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &t) {
  is >> t.first >> t.second;
  return is;
}

template <int N, typename... Ts,
          typename enable_if<N == sizeof...(Ts) - 1>::type *& = enabler>
void tuple_in(istream &is, tuple<Ts...> &t) {
  is >> get<N>(t);
}
template <int N, typename... Ts,
          typename enable_if<N<sizeof...(Ts) - 1>::type *& = enabler> void
              tuple_in(istream &is, tuple<Ts...> &t) {
  is >> get<N>(t);
  tuple_in<N + 1, Ts...>(is, t);
}

template <typename... Ts> istream &operator>>(istream &is, tuple<Ts...> &t) {
  tuple_in<0, Ts...>(is, t);
  return is;
}

template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &t) {
  os << '(' << t.first << ", " << t.second << ')';
  return os;
}

template <int N, typename... Ts,
          typename enable_if<N == sizeof...(Ts) - 1>::type *& = enabler>
void tuple_out(ostream &os, const tuple<Ts...> &t) {
  os << get<N>(t);
}
template <int N, typename... Ts,
          typename enable_if<N<sizeof...(Ts) - 1>::type *& = enabler> void
              tuple_out(ostream &os, const tuple<Ts...> &t) {
  os << get<N>(t) << ", ";
  tuple_out<N + 1, Ts...>(os, t);
}

template <typename... Ts>
ostream &operator<<(ostream &os, const tuple<Ts...> &t) {
  os << '(';
  tuple_out<0, Ts...>(os, t);
  os << ')';
  return os;
}

template <typename T> vector<T> read(int n) {
  vector<T> t(n);
  cin >> t;
  return t;
}

template <typename T> T read() {
  T t;
  cin >> t;
  return t;
}

template <typename Head, typename... Tail> struct vector_demensions {
  using type = vector<typename vector_demensions<Tail...>::type>;
};

template <typename Head> struct vector_demensions<Head> {
  using type = Head;
};

template <typename T> vector<T> make_vectors(int size, T val) {
  return vector<T>(size, val);
}

template <typename T = int, typename... Args>
auto make_vectors(int size, Args... tail) ->
    typename vector_demensions<Args..., T>::type {
  auto val = make_vectors<T>(forward<Args>(tail)...);
  return vector<decltype(val)>(size, val);
}

// c++14

class Mod {
public:
  using value_type = long long;

private:
  static const value_type MODULO = 1e9 + 7;
  value_type value;

  constexpr value_type Normalize(value_type x) const {
    return x < 0 ? (x % MODULO + MODULO) : (x % MODULO);
  }

public:
  constexpr Mod() : value(0) {}
  constexpr Mod(const value_type &val) : value(Normalize(val)) {}

  constexpr explicit operator value_type() const { return value; }

  constexpr const Mod operator-() const { return Mod(MODULO - value); }
  constexpr const Mod operator+(const Mod &rhs) const {
    return Mod(value + rhs.value);
  }
  constexpr const Mod operator-(const Mod &rhs) const {
    return Mod(value + (-rhs).value);
  }
  constexpr const Mod operator*(const Mod &rhs) const {
    return Mod(value * rhs.value);
  }
  constexpr Mod &operator+=(const Mod &rhs) {
    value = Normalize(value + rhs.value);
    return *this;
  }
  constexpr Mod &operator-=(const Mod &rhs) {
    value = Normalize(value - rhs.value);
    return *this;
  }
  constexpr Mod &operator*=(const Mod &rhs) {
    value = Normalize(value * rhs.value);
    return *this;
  }

  constexpr Mod pow(value_type p) const;

  constexpr Mod inv() const { return pow(MODULO - 2); }

  constexpr const Mod operator/(const Mod &rhs) const {
    return *this * rhs.inv();
  }
  constexpr Mod &operator/=(const Mod &rhs) { return *this = *this / rhs; }
  constexpr bool operator==(const Mod &rhs) { return value == rhs.value; }
};

constexpr Mod Mod::pow(value_type p) const {
  Mod tmp = 1, mult = *this;
  while (p) {
    if ((p & 1) > 0)
      tmp *= mult;
    p >>= 1;
    mult *= mult;
  }
  return tmp;
}

namespace std {
ostream &operator<<(ostream &os, const Mod mod) {
  os << (typename Mod::value_type)mod;
  return os;
}
}; // namespace std

template <size_t N> struct Factorial {
private:
  Mod ary[N];

public:
  constexpr explicit Factorial() : ary() {
    ary[0] = 1;
    for (size_t i = 1; i < N; i++)
      ary[i] = ary[i - 1] * i;
  }

  constexpr size_t size() const { return N; }

  constexpr Mod operator[](const int id) const { return ary[id]; }
};

template <size_t N> class FactorialInv {
private:
  Mod ary[N];

public:
  constexpr explicit FactorialInv(const Factorial<N> &fact) : ary() {
    for (size_t i = 0; i < N; i++)
      ary[i] = fact[i].inv();
  }

  // FactorialInv& operator=(FactorialInv&&)=default;

  constexpr Mod operator[](const int id) const { return ary[id]; }
};

template <size_t N, size_t M = N> class Combination {
private:
  const Factorial<N> fact;
  const FactorialInv<M> fact_inv;

public:
  constexpr Combination(const Factorial<N> fact_,
                        const FactorialInv<M> fact_inv_)
      : fact(fact_), fact_inv(fact_inv_) {}

  constexpr Mod operator()(const int n, const int m) const {
    return (fact)[n] * (fact_inv)[m] * (fact_inv)[n - m];
  }
};

int main() {
  Factorial<1024> fact;
  int n, x;
  cin >> n >> x;
  auto s(read<int>(n));
  sort(ALL(s), greater<int>());
  auto dp = make_vectors<Mod>(n + 1, x + 1, Mod(0));
  dp[0][x] = x;
  REP(i, n)
  REP(j, x + 1) {
    if (dp[i][j] == 0)
      continue;
    dp[i + 1][j % s[i]] += dp[i][j] * (j % s[i]) / j;
    dp[i + 1][j] += dp[i][j] * (n - i - 1);
  }
  Mod ans = 0;
  REP(j, x + 1)
  ans += dp[n][j];
  print(ans);
}