結果

問題 No.117 組み合わせの数
ユーザー もりを
提出日時 2019-09-19 15:10:04
言語 C++14
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 252 ms / 5,000 ms
コード長 4,977 bytes
コンパイル時間 1,496 ms
コンパイル使用メモリ 172,460 KB
実行使用メモリ 50,128 KB
最終ジャッジ日時 2024-07-19 06:27:22
合計ジャッジ時間 2,374 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge4
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
other AC * 1
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
using ui64 = uint_fast64_t;
#define REP(i, n) for (i64 (i) = 0; (i) < (n); ++(i))
#define FOR(i, a, b) for (i64 (i) = (a); (i) < (b); ++(i))

template< int MODULO > struct ModInt {
  using int64 = int_fast64_t;
  using uint32 = uint_fast32_t;
  using uint64 = uint_fast64_t;
  uint64 x; ModInt() : x(0) {}
  ModInt(uint64 y) : x(set(y % MODULO + MODULO)) {}
  static uint64 set(const uint64 &y) { return (y < MODULO) ? y : y - MODULO; }
  static ModInt make(const uint64 &y) { ModInt ret = y; return ret; }
  ModInt operator+(const ModInt &m) const { return make(set(x + m.x)); }
  ModInt operator-(const ModInt &m) const { return make(set(x + MODULO - m.x)); }
  ModInt operator*(const ModInt &m) const { return make(x * m.x % MODULO); }
  ModInt operator/(const ModInt &m) const { return make(x) * ~make(m.x); }
  ModInt &operator+=(const ModInt &m) { return *this = *this + m; }
  ModInt &operator-=(const ModInt &m) { return *this = *this - m; }
  ModInt &operator*=(const ModInt &m) { return *this = *this * m; }
  ModInt &operator/=(const ModInt &m) { return *this = *this / m; }
  ModInt &operator^=(const uint64 &y) { return *this = *this ^ y; }
  ModInt operator~ () const { return *this ^ (MODULO - 2); }
  ModInt operator- () const { return make(set(MODULO - x)); }
  ModInt operator! () const { init(uint32(*this)); return fact[uint32(*this)]; }
  ModInt operator& () const { init(uint32(*this)); return finv[uint32(*this)]; }
  ModInt operator++() { return *this = make(set(x + 1)); }
  ModInt operator--() { return *this = make(set(x + MODULO - 1)); }
  bool operator==(const ModInt &m) const { return x == m.x; }
  bool operator!=(const ModInt &m) const { return x != m.x; }
  bool operator< (const ModInt &m) const { return x <  m.x; }
  bool operator<=(const ModInt &m) const { return x <= m.x; }
  bool operator> (const ModInt &m) const { return x >  m.x; }
  bool operator>=(const ModInt &m) const { return x >= m.x; }
  explicit operator   bool() const { return x; }
  explicit operator uint64() const { return x; }
  ModInt operator^(uint64 y) const {
    uint64 t = x, u = 1;
    while (y) { if (y & 1) (u *= t) %= MODULO; (t *= t) %= MODULO; y >>= 1; }
    return make(u);
  }
  friend ostream &operator<<(ostream &os, const ModInt< MODULO > &m) { return os << m.x; }
  friend istream &operator>>(istream &is, ModInt< MODULO > &m) { uint64 y; is >> y; m = make(y); return is; }
  static vector< ModInt > fact, finv, invs;
  static void init(uint32 n) {
    uint32 m = fact.size();
    if (n < m) return;
    fact.resize(n + 1, 1);
    finv.resize(n + 1, 1);
    invs.resize(n + 1, 1);
    if (m == 0) m = 1;
    for (uint32 i = m; i <= n; ++i) fact[i] = fact[i - 1] * ModInt(i);
    finv[n] = ModInt(1) / fact[n];
    for (uint32 i = n; i >= m; --i) finv[i - 1] = finv[i] * make(i);
    for (uint32 i = m; i <= n; ++i) invs[i] = finv[i] * fact[i - 1];
  }
  static ModInt C(int64 n, int64 r) {
    if (r == 0) return make(1);
    if (r <  0) return make(0);
    if (n <  0) return make(r & 1 ? MODULO - 1 : 1) * C(-n + r - 1, r);
    if (n == 0 || n < r) return make(0);
    init(n);
    return fact[n] * finv[n - r] * finv[r];
  }
  static ModInt P(int64 n, int64 r) {
    if (n < r || r < 0) return make(0);
    init(n);
    return fact[n] * finv[n - r];
  }
  static ModInt H(int64 n, int64 r) {
    if (n < 0 || r < 0) return make(0);
    if (!n && !r) return make(1);
    init(n + r - 1);
    return C(n + r - 1, r);
  }
  static ModInt montmort(uint32 n) {
    ModInt res;
    init(n);
    for (uint32 k = 2; k <= n; ++k) {
      if (k & 1) res -= finv[k];
      else res += finv[k];
    }
    return res *= fact[n];
  }
  static ModInt LagrangePolynomial(vector<ModInt> &y, ModInt t) {
    uint32 n = y.size() - 1;
    if (t.x <= n) return y[t.x];
    init(n + 1);
    ModInt res, num(1);
    for (uint32 i = 0; i <= n; ++i) num *= t - make(i);
    for (uint32 i = 0; i <= n; ++i) {
      ModInt tmp = y[i] * num / (t - make(i)) * finv[i] * finv[n - i];
      if ((n - i) & 1) res -= tmp;
      else res += tmp;
    }
    return res;
  }
};
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::fact = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::finv = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::invs = vector<ModInt< MODULO >>();
const int MOD = int(1e9) + 7;
using modint = ModInt< MOD >;

signed main() {

    cin.tie(0);
    ios::sync_with_stdio(false);

    int N;
    cin >> N;

    REP(i, N) {
        char in;
        cin >> in;
        char dust;
        cin >> dust;
        i64 a, b;
        cin >> a >> dust >> b >> dust;
        if (in == 'C') {
            cout << modint::C(a, b) << endl;
        } else if (in == 'P') {
            cout << modint::P(a, b) << endl;
        } else {
            cout << modint::H(a, b) << endl;
        }
    }

}
0