結果
| 問題 | No.117 組み合わせの数 |
| ユーザー |
 not_522
|
| 提出日時 | 2020-01-17 23:46:36 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 303 ms / 5,000 ms |
| コード長 | 26,873 bytes |
| コンパイル時間 | 1,531 ms |
| コンパイル使用メモリ | 125,368 KB |
| 実行使用メモリ | 26,908 KB |
| 最終ジャッジ日時 | 2024-06-26 01:48:45 |
| 合計ジャッジ時間 | 2,166 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge3 |
（要ログイン）
ソースコード
// This is free and unencumbered software released into the public domain.
// Anyone is free to copy, modify, publish, use, compile, sell, or
// distribute this software, either in source code form or as a compiled
// binary, for any purpose, commercial or non-commercial, and by any
// means.
// In jurisdictions that recognize copyright laws, the author or authors
// of this software dedicate any and all copyright interest in the
// software to the public domain. We make this dedication for the benefit
// of the public at large and to the detriment of our heirs and
// successors. We intend this dedication to be an overt act of
// relinquishment in perpetuity of all present and future rights to this
// software under copyright law.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
// For more information, please refer to <http://unlicense.org>
/****************/
/* template.hpp */
/****************/
#include <algorithm>
#include <cassert>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
using std::cerr;
using std::cout;
using std::endl;
using std::max;
using std::min;
using std::swap;
struct BoolName : std::numpunct<char> {
std::string t, f;
BoolName(std::string t, std::string f) : t(t), f(f) {}
std::string do_truename() const { return t; }
std::string do_falsename() const { return f; }
};
void setBoolName(std::string t, std::string f) {
cout.imbue(std::locale(cout.getloc(), new BoolName(t, f)));
}
struct Initializer {
Initializer() {
cout << std::fixed << std::setprecision(15) << std::boolalpha;
setBoolName("Yes", "No");
}
} initializer;
struct Input {
bool eof;
Input() : eof(false) {}
operator char() {
char v;
while (!(this->eof = (std::scanf("%c", &v) != 1)) && std::isspace(v)) {
}
return v;
}
operator int() {
int v;
this->eof = (std::scanf("%d", &v) != 1);
return v;
}
operator long() {
long v;
this->eof = (std::scanf("%ld", &v) != 1);
return v;
}
operator long long() {
long long v;
this->eof = (std::scanf("%lld", &v) != 1);
return v;
}
operator unsigned int() {
unsigned int v;
this->eof = (std::scanf("%u", &v) != 1);
return v;
}
operator unsigned long() {
unsigned long v;
this->eof = (std::scanf("%lu", &v) != 1);
return v;
}
operator unsigned long long() {
unsigned long long v;
this->eof = (std::scanf("%llu", &v) != 1);
return v;
}
operator double() {
double v;
this->eof = (std::scanf("%lf", &v) != 1);
return v;
}
operator long double() {
long double v;
this->eof = (std::scanf("%Lf", &v) != 1);
return v;
}
void ignore() const { getchar(); }
} in;
template <typename T> T abs(T a) { return a >= 0 ? a : -a; }
template <typename T, typename S> bool chmin(T &a, const S &b) {
return a > b ? a = b, true : false;
}
template <typename T, typename S> bool chmax(T &a, const S &b) {
return a < b ? a = b, true : false;
}
template <typename T, typename S> std::function<S(T)> cast() {
return [](const T &t) { return static_cast<S>(t); };
}
template <typename T> T copy(const T &a) { return T(a); }
class ZeroPadding {
public:
ZeroPadding(int n) : n(n) {}
int n;
};
std::ostream &operator<<(std::ostream &os, const ZeroPadding &z) {
os << std::setw(z.n) << std::setfill('0');
return os;
}
template <typename T> constexpr T inf() {
return std::numeric_limits<T>::max() / 2 - 1;
}
/*********************/
/* bit_operation.hpp */
/*********************/
template <typename T> int least_bit(T n) {
static_assert(sizeof(T) == 4 || sizeof(T) == 8, "unsupported size");
if (sizeof(T) == 4) {
return __builtin_ffs(n) - 1;
}
if (sizeof(T) == 8) {
return __builtin_ffsll(n) - 1;
}
}
// n must be greater than 0.
template <typename T> int least_bit_fast(T n) {
static_assert(sizeof(T) == 4 || sizeof(T) == 8, "unsupported size");
if (sizeof(T) == 4) {
return __builtin_ctz(n);
}
if (sizeof(T) == 8) {
return __builtin_ctzll(n);
}
}
template <typename T> int most_bit(T n) {
static_assert(sizeof(T) == 4 || sizeof(T) == 8, "unsupported size");
if (sizeof(T) == 4) {
return n ? 31 - __builtin_clz(n) : -1;
}
if (sizeof(T) == 8) {
return n ? 63 - __builtin_clzll(n) : -1;
}
}
template <typename T> int count_bit(T n) {
static_assert(sizeof(T) == 4 || sizeof(T) == 8, "unsupported size");
if (sizeof(T) == 4) {
return __builtin_popcount(n);
}
if (sizeof(T) == 8) {
return __builtin_popcountll(n);
}
}
template <typename T> int bit_parity(T n) {
static_assert(sizeof(T) == 4 || sizeof(T) == 8, "unsupported size");
if (sizeof(T) == 4) {
return __builtin_parity(n);
}
if (sizeof(T) == 8) {
return __builtin_parityll(n);
}
}
/*************/
/* tuple.hpp */
/*************/
#include <tuple>
template <typename... T> class Tuple : public std::tuple<T...> {
public:
Tuple(Input &in) : std::tuple<T...>() { (void)in; }
};
template <typename T, typename... S>
class Tuple<T, S...> : public std::tuple<T, S...> {
public:
Tuple() : std::tuple<T, S...>() {}
Tuple(T t, S... s) : std::tuple<T, S...>(t, s...) {}
Tuple(const std::tuple<T, S...> &t) : std::tuple<T, S...>(t) {}
Tuple(Input &in) {
auto a = std::tuple<T>(in);
std::tuple<S...> b = Tuple<S...>(in);
std::tuple<T, S...> c = std::tuple_cat(a, b);
*this = c;
}
template <int n> auto &get() { return std::get<n>(*this); }
template <int n> const auto &get() const { return std::get<n>(*this); }
};
template <typename... T> Tuple<T...> makeTuple(const T &... args) {
return Tuple<T...>(args...);
}
namespace std {
template <typename... T>
class tuple_size<Tuple<T...>>
: public std::integral_constant<size_t, sizeof...(T)> {};
template <std::size_t I, typename... T> class tuple_element<I, Tuple<T...>> {
public:
using type = tuple_element_t<I, std::tuple<T...>>;
};
} // namespace std
/*****************/
/* container.hpp */
/*****************/
#include <vector>
template <typename T> class Container : public T {
private:
using S = typename T::value_type;
using Itr = typename T::iterator;
public:
Container() : T() {}
Container(int n) : T(n) {}
Container(int n, S s) : T(n, s) {}
template <typename Itr> Container(Itr first, Itr last) : T(first, last) {}
Container(const std::initializer_list<S> &v) : T(v) {}
Container(int n, Input &in) {
std::vector<S> v(n);
for (auto &i : v) {
i = in;
}
*this = Container<T>(v.begin(), v.end());
}
S max() const { return *std::max_element(this->begin(), this->end()); }
template <typename Function> auto max(Function func) const {
std::vector<std::pair<decltype(func(S())), S>> res;
for (const auto &i : *this) {
res.emplace_back(func(i), i);
}
return std::max_element(res.begin(), res.end())->second;
}
S min() const { return *std::min_element(this->begin(), this->end()); }
Tuple<S, S> minmax() const {
auto itrs = std::minmax_element(this->begin(), this->end());
return Tuple<S, S>(*itrs.first, *itrs.second);
}
template <typename Function> auto min(Function func) const {
std::vector<std::pair<decltype(func(S())), S>> res;
for (const auto &i : *this) {
res.emplace_back(func(i), i);
}
return std::min_element(res.begin(), res.end())->second;
}
int argmax() const {
return std::distance(this->begin(),
std::max_element(this->begin(), this->end()));
}
int argmin() const {
return std::distance(this->begin(),
std::min_element(this->begin(), this->end()));
}
int find(const S &a) const {
return std::distance(this->begin(),
std::find(this->begin(), this->end(), a));
}
bool contains(const S &a) const {
return std::find(this->begin(), this->end(), a) != this->end();
}
int size() const { return T::size(); }
std::pair<Itr, Itr> equal_range(const S &a) {
return std::equal_range(this->begin(), this->end(), a);
}
template <typename Function> bool all_of(Function func) const {
return std::all_of(this->begin(), this->end(), func);
}
template <typename Function> bool any_of(Function func) const {
return std::any_of(this->begin(), this->end(), func);
}
template <typename Function> bool none_of(Function func) const {
return std::none_of(this->begin(), this->end(), func);
}
int count(const S &s) const {
return std::count(this->begin(), this->end(), s);
}
bool is_sorted() const { return std::is_sorted(this->begin(), this->end()); }
void output(std::string sep = "\n", std::string end = "\n") const {
bool first = true;
for (const auto &i : *this) {
if (!first) {
cout << sep;
}
first = false;
cout << i;
}
cout << end;
}
};
/***********/
/* map.hpp */
/***********/
#include <map>
template <typename T, typename S> class Map : public Container<std::map<T, S>> {
public:
Map() : Container<std::map<T, S>>() {}
bool contains(const T &a) const { return this->count(a) != 0; }
int count(const T &t) const { return std::map<T, S>::count(t); }
};
/***************/
/* ordered.hpp */
/***************/
template <typename T> class Ordered {
public:
template <typename V> bool operator==(const V &v) const {
return !(static_cast<T>(v) < static_cast<const T &>(*this) ||
static_cast<const T &>(*this) < static_cast<T>(v));
}
template <typename V> bool operator!=(const V &v) const {
return static_cast<T>(v) < static_cast<const T &>(*this) ||
static_cast<const T &>(*this) < static_cast<T>(v);
}
template <typename V> bool operator>(const V &v) const {
return static_cast<T>(v) < static_cast<const T &>(*this);
}
template <typename V> bool operator<=(const V &v) const {
return !(static_cast<T>(v) < static_cast<const T &>(*this));
}
template <typename V> bool operator>=(const V &v) const {
return !(static_cast<const T &>(*this) < static_cast<T>(v));
}
};
/**************/
/* vector.hpp */
/**************/
#include <numeric>
template <typename T>
class Vector : public Container<std::vector<T>>, public Ordered<Vector<T>> {
public:
Vector() = default;
Vector(const Vector<T> &v) = default;
Vector(int n) : Container<std::vector<T>>(n) {}
Vector(int n, T t) : Container<std::vector<T>>(n, t) {}
template <typename Itr>
Vector(Itr first, Itr last) : Container<std::vector<T>>(first, last) {}
Vector(const std::initializer_list<T> &v) : Container<std::vector<T>>(v) {}
Vector(int n, Input &in) : Container<std::vector<T>>(n, in) {}
Vector &operator+=(const Vector &v) {
if (this->size() < v.size()) {
this->resize(v.size());
}
for (int i = 0; i < v.size(); ++i) {
(*this)[i] += v[i];
}
return *this;
}
Vector &operator+=(const T &v) {
for (auto &i : *this) {
i += v;
}
return *this;
}
Vector &operator-=(const Vector &v) {
if (this->size() < v.size()) {
this->resize(v.size());
}
for (int i = 0; i < v.size(); ++i) {
(*this)[i] -= v[i];
}
return *this;
}
Vector &operator-=(const T &v) {
for (auto &i : *this) {
i -= v;
}
return *this;
}
Vector &operator*=(const Vector &v) {
for (int i = 0; i < this->size(); ++i) {
(*this)[i] *= v[i];
}
return *this;
}
Vector &operator*=(const T &v) {
for (auto &i : *this) {
i *= v;
}
return *this;
}
Vector &operator/=(const Vector &v) {
for (int i = 0; i < this->size(); ++i) {
(*this)[i] /= v[i];
}
return *this;
}
Vector &operator/=(const T &v) {
for (auto &i : *this) {
i /= v;
}
return *this;
}
Vector &operator%=(const Vector &v) {
for (int i = 0; i < this->size(); ++i) {
(*this)[i] %= v[i];
}
return *this;
}
Vector &operator%=(const T &v) {
for (auto &i : *this) {
i %= v;
}
return *this;
}
Vector operator+(const Vector &v) const { return Vector(*this) += v; }
Vector operator+(const T &v) const { return Vector(*this) += v; }
Vector operator-(const Vector &v) const { return Vector(*this) -= v; }
Vector operator-(const T &v) const { return Vector(*this) -= v; }
Vector operator*(const Vector &v) const { return Vector(*this) *= v; }
Vector operator*(const T &v) const { return Vector(*this) *= v; }
Vector operator/(const Vector &v) const { return Vector(*this) /= v; }
Vector operator/(const T &v) const { return Vector(*this) /= v; }
Vector operator%(const Vector &v) const { return Vector(*this) %= v; }
Vector operator%(const T &v) const { return Vector(*this) %= v; }
bool operator<(const Vector &v) const {
if (this->size() != v.size()) {
return this->size() < v.size();
}
for (int i = 0; i < this->size(); ++i) {
if ((*this)[i] != v[i]) {
return (*this)[i] < v[i];
}
}
return false;
}
Vector operator-() const { return *this * -1; }
T inner_product(const Vector<T> &v) const {
return std::inner_product(this->begin(), this->end(), v.begin(), T(0));
}
Vector<T> &partial_sort(int k, bool reverse = false) {
if (!reverse) {
std::partial_sort(this->begin(), this->begin() + k, this->end());
} else {
std::partial_sort(this->begin(), this->begin() + k, this->end(),
std::greater<T>());
}
return *this;
}
Vector<T> &sort() {
std::sort(this->begin(), this->end());
return *this;
}
template <typename Function> Vector<T> &sort(Function func) {
std::sort(this->begin(), this->end(), func);
return *this;
}
Vector<T> &rsort() {
std::sort(this->rbegin(), this->rend());
return *this;
}
Vector<int> argsort() const {
Vector<Tuple<T, int>> v;
for (int i = 0; i < this->size(); ++i) {
v.emplace_back((*this)[i], i);
}
v.sort();
auto f = [](const Tuple<T, int> &t) { return t.template get<1>(); };
return v.transform(f);
}
Vector<T> &nth_element(int n, bool reverse = false) {
if (!reverse) {
std::nth_element(this->begin(), this->begin() + n, this->end());
} else {
std::nth_element(this->begin(), this->begin() + n, this->end(),
std::greater<T>());
}
return *this;
}
Vector<T> subvector(int a) const {
return Vector<T>(this->begin(), this->begin() + a);
}
Vector<T> subvector(int a, int b) const {
return Vector<T>(this->begin() + a, this->begin() + b);
}
template <typename Function> auto transform(Function func) const {
Vector<decltype(func(T()))> res;
std::transform(this->begin(), this->end(), std::back_inserter(res), func);
return res;
}
Vector<T> partial_sum() const {
Vector<T> res;
std::partial_sum(this->begin(), this->end(), std::back_inserter(res));
return res;
}
template <typename Function> Vector<T> partial_sum(Function func) const {
Vector<T> res;
std::partial_sum(this->begin(), this->end(), std::back_inserter(res), func);
return res;
}
Vector<T> &reverse() {
std::reverse(this->begin(), this->end());
return *this;
}
template <typename Function> int count_if(Function func) const {
return std::count_if(this->begin(), this->end(), func);
}
Vector<T> adjacent_difference() const {
Vector<T> res;
std::adjacent_difference(this->begin(), this->end(),
std::back_inserter(res));
return res;
}
T lower_bound(T t) const {
return std::lower_bound(this->begin(), this->end(), t) - this->begin();
}
T upper_bound(T t) const {
return std::upper_bound(this->begin(), this->end(), t) - this->begin();
}
T accumulate() const {
return std::accumulate(this->begin(), this->end(), T());
}
template <typename S, typename Function>
S accumulate(S n, Function func) const {
return std::accumulate(this->begin(), this->end(), n, func);
}
template <typename Int> static Vector<T> makeVector(Int n) {
return Vector<T>(n);
}
template <typename Int> static Vector<T> makeVector(Input &in, Int n) {
return Vector<T>(n, in);
}
template <typename Int, typename... Ints>
static auto makeVector(Input &in, Int n, Ints... ints) {
Vector<decltype(makeVector(in, ints...))> res;
for (int i = 0; i < n; ++i) {
res.emplace_back(makeVector(in, ints...));
}
return res;
}
template <typename Int, typename... Ints>
static auto makeVector(Int n, Ints... ints) {
Vector<decltype(makeVector(ints...))> res;
for (int i = 0; i < n; ++i) {
res.emplace_back(makeVector(ints...));
}
return res;
}
Vector<T> &unique() {
this->erase(std::unique(this->begin(), this->end()), this->end());
return *this;
}
bool next_permutation() {
return std::next_permutation(this->begin(), this->end());
}
Vector<T> &rotate(int n) {
std::rotate(this->begin(), this->begin() + n, this->end());
return *this;
}
Map<T, int> countAll() const {
Map<T, int> res;
for (const auto &i : *this) {
++res[i];
}
return res;
}
T matmul(const T &a) const {
return this->transform([&](const T &i) { return i.inner_product(a); });
}
};
template <typename T> Vector<T> iota(int n, T m = 0) {
Vector<T> v(n);
std::iota(v.begin(), v.end(), m);
return v;
}
template <typename T, typename S> void read(Vector<T> &t, Vector<S> &s) {
for (int i = 0; i < t.size(); ++i) {
t[i] = T(in);
s[i] = S(in);
}
}
template <typename T, typename S, typename U>
void read(Vector<T> &t, Vector<S> &s, Vector<U> &u) {
for (int i = 0; i < t.size(); ++i) {
t[i] = T(in);
s[i] = S(in);
u[i] = U(in);
}
}
template <typename T> Vector<T> operator+(const T &a, const Vector<T> &b) {
return b + a;
}
template <typename T> Vector<T> operator-(const T &a, const Vector<T> &b) {
return -b + a;
}
template <typename T> Vector<T> operator*(const T &a, const Vector<T> &b) {
return b * a;
}
/************/
/* math.hpp */
/************/
#include <cmath>
template <typename T = double> constexpr T pi() { return acos(T(-1)); }
template <typename T> T gcd(T t) { return abs(t); }
template <typename T, typename... S> T gcd(T a, S... s) {
a = abs(a);
auto b = gcd(s...);
if (a == 0 || b == 0) {
return max(a, b);
}
int fa = least_bit_fast(a);
int fb = least_bit_fast(b);
a >>= fa;
b >>= fb;
while (a != b) {
auto &c = a > b ? a : b;
c = abs(a - b);
c >>= least_bit_fast(c);
}
return a << min(fa, fb);
}
template <typename T> T gcd(const Vector<T> &v) {
T g = abs(v[0]);
for (int i = 1; i < int(v.size()); ++i) {
g = gcd(g, v[i]);
}
return g;
}
template <typename T> T lcm(T t) { return abs(t); }
template <typename T, typename... S> T lcm(T t, S... s) {
T l = lcm(s...);
return abs(t) / gcd(t, l) * l;
}
template <typename T> T lcm(const Vector<T> &v) {
T l = abs(v[0]);
for (int i = 1; i < int(v.size()); ++i) {
l = lcm(l, v[i]);
}
return l;
}
template <typename T> T floor(T a, T b) {
auto d = std::div(a, b);
return d.quot - (d.rem && (a < 0) != (b < 0) ? 1 : 0);
}
template <typename T> T ceil(T a, T b) {
auto d = std::div(a, b);
return d.quot + (d.rem && (a > 0) == (b > 0) ? 1 : 0);
}
template <typename T> T round(T a) { return std::round(a); }
template <typename T> T round(T a, T b) { return floor(a + b / 2, b); }
template <typename T> T mod(T a, T b) {
T c = a % b;
return c < 0 ? c + abs(b) : c;
}
template <typename T> T factorial(T n) {
return n <= 1 ? 1 : factorial(n - 1) * n;
}
template <typename T> Vector<T> factorial_vector(int n) {
Vector<T> v(n + 1, 1);
for (int i = 1; i <= n; ++i) {
v[i] = v[i - 1] * i;
}
return v;
}
template <typename T> T square(T n) { return n * n; }
template <typename T> T cube(T n) { return n * n * n; }
template <typename T> T norm(T x1, T y1, T x2, T y2) {
return square(x1 - x2) + square(y1 - y2);
}
template <typename T> bool isSquare(T n) { return square(T(sqrt(n))) == n; }
template <typename T> T clamp(T v, T l, T u) {
return v < l ? l : v > u ? u : v;
}
template <typename T> auto hypot(T a, T b) { return std::hypot(a, b); }
template <typename T> auto pow(T a, T b) { return std::pow(a, b); }
template <typename T> auto log10(T a) { return std::log10(a); }
template <typename T> T sqrt_int(T a) {
T x = std::sqrt(a);
while (x * x > a) {
--x;
}
while ((x + 1) * (x + 1) < a) {
++x;
}
return x;
}
/************************/
/* math/combination.hpp */
/************************/
template <typename T> class Combination {
private:
Vector<T> factorial;
public:
Combination(int n = 0) : factorial(n + 1, 1) {
for (int i = 1; i <= n; ++i) {
factorial[i] = factorial[i - 1] * i;
}
}
T partial_permutation(int n, int m) {
if (n < m) {
return 0;
}
if (n < factorial.size()) {
return factorial[n] / factorial[n - m];
}
T res = 1;
for (int i = n; i > n - m; --i) {
res *= i;
}
return res;
}
T combination(int n, int m) {
if (n < m) {
return 0;
}
if (n < factorial.size()) {
return factorial[n] / factorial[m] / factorial[n - m];
}
T res = 1;
for (int i = 0; i < min(m, n - m); ++i) {
res = res * (n - i) / (i + 1);
}
return res;
}
T combination_safety(int n, int m) {
m = min(m, n - m);
auto a = iota(m, n - m + 1), b = iota(m, 1);
for (auto i : b) {
for (auto &j : a) {
auto g = gcd(i, j);
i /= g;
j /= g;
if (i == 1) {
break;
}
}
}
return a.accumulate(T(1), std::multiplies<T>());
}
T repetition(int n, int m) {
if (m == 0) {
return 1;
}
return combination(n + m - 1, m);
}
};
/******************/
/* arithmetic.hpp */
/******************/
template <typename T> class Addition {
public:
template <typename V> T operator+(const V &v) const {
return T(static_cast<const T &>(*this)) += v;
}
T operator++() { return static_cast<T &>(*this) += 1; }
};
template <typename T> class Subtraction {
public:
template <typename V> T operator-(const V &v) const {
return T(static_cast<const T &>(*this)) -= v;
}
};
template <typename T> class Multiplication {
public:
template <typename V> T operator*(const V &v) const {
return T(static_cast<const T &>(*this)) *= v;
}
};
template <typename T> class Division {
public:
template <typename V> T operator/(const V &v) const {
return T(static_cast<const T &>(*this)) /= v;
}
};
template <typename T> class Modulus {
public:
template <typename V> T operator%(const V &v) const {
return T(static_cast<const T &>(*this)) %= v;
}
};
template <typename T>
class IndivisibleArithmetic : public Addition<T>,
public Subtraction<T>,
public Multiplication<T> {};
template <typename T>
class Arithmetic : public IndivisibleArithmetic<T>, public Division<T> {};
/********************/
/* math/inverse.hpp */
/********************/
class Inverse {
private:
int64_t mod;
Vector<int64_t> inv;
public:
Inverse() {}
Inverse(int64_t mod, int64_t n = 1000000) : mod(mod), inv(n, 1) {
for (int i = 2; i < n; ++i) {
inv[i] = inv[mod % i] * (mod - mod / i) % mod;
}
}
int64_t operator()(int64_t a) const {
if (a < inv.size()) {
return inv[a];
}
int64_t b = mod, x = 1, y = 0;
while (b) {
int64_t t = a / b;
swap(a -= t * b, b);
swap(x -= t * y, y);
}
return x < 0 ? x + mod : x;
}
};
int64_t inverse(int64_t n, int64_t mod) {
Inverse inv(mod, 0);
return inv(n);
}
/*****************/
/* math/mint.hpp */
/*****************/
class Mint : public Arithmetic<Mint> {
private:
static int64_t mod;
static Inverse inverse;
int64_t val;
public:
Mint() : val(0) {}
Mint(const int64_t &val) {
this->val = val % mod;
if (this->val < 0) {
this->val += mod;
}
}
Mint(Input &in) : val(in) {
this->val = this->val % mod;
if (this->val < 0) {
this->val += mod;
}
}
static void setMod(const int64_t &m) {
mod = m;
inverse = Inverse(m);
}
Mint operator-() const { return Mint(val ? mod - val : 0); }
Mint &operator+=(const Mint &m) {
val += m.val;
if (val >= mod) {
val -= mod;
}
return *this;
}
Mint &operator-=(const Mint &m) {
val -= m.val;
if (val < 0) {
val += mod;
}
return *this;
}
Mint &operator*=(const Mint &m) {
val *= m.val;
val %= mod;
return *this;
}
Mint &operator/=(const Mint &m) {
val *= inverse(m.val);
val %= mod;
return *this;
}
bool operator==(const Mint &m) const { return val == m.val; }
Mint &operator++() { return *this += 1; }
Mint &operator--() { return *this -= 1; }
template <typename T> Mint operator-(const T &m) {
return Arithmetic<Mint>::operator-(m);
}
explicit operator char() const { return val; }
explicit operator int() const { return val; }
explicit operator int64_t() const { return val; }
static Mint identity() { return 1; }
};
int64_t Mint::mod = 1000000007;
Inverse Mint::inverse(1000000007);
std::ostream &operator<<(std::ostream &os, Mint a) {
os << int64_t(a);
return os;
}
Mint operator+(const int &n, const Mint &m) { return m + n; }
Mint operator-(const int &n, const Mint &m) { return -m + n; }
Mint operator*(const int &n, const Mint &m) { return m * n; }
Mint operator/(const int &n, const Mint &m) { return Mint(n) / m; }
Mint operator+(const int64_t &n, const Mint &m) { return m + n; }
Mint operator-(const int64_t &n, const Mint &m) { return -m + n; }
Mint operator*(const int64_t &n, const Mint &m) { return m * n; }
Mint operator/(const int64_t &n, const Mint &m) { return Mint(n) / m; }
/************/
/* main.cpp */
/************/
int main() {
Combination<Mint> comb(2000000);
int t(in);
for (int i = 0; i < t; ++i) {
char c(in);
in.ignore();
int n(in);
in.ignore();
int k(in);
in.ignore();
switch (c) {
case 'C':
cout << comb.combination(n, k) << endl;
break;
case 'P':
cout << comb.partial_permutation(n, k) << endl;
break;
case 'H':
cout << comb.repetition(n, k) << endl;
break;
}
}
}