text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int n, w, b, c[4005][4005], fac[4005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> w >> b;
c[0][0] = 1;
for (int i = 1; i <= 4000; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000009;
}
}
fac[0] = 1;
for (int i = 1; i <= 4000; i++) {
fac[i] = (1ll * fac[i - 1] * i) % 1000000009;
}
long long ans = 0;
for (int i = 2; i <= n - 1; i++) {
for (int j = i; j <= n - 1; j++) {
int bd = j - i + 1, wd = n - bd;
ans = (ans + (1ll * fac[b] * c[b - 1][bd - 1] % 1000000009) *
(1ll * fac[w] * c[w - 1][wd - 1] % 1000000009) %
1000000009) %
1000000009;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4003, P = 1e9 + 9;
int n, w, b, jc[N << 1];
inline void in(register int &x) {
int f = 0;
x = 0;
char c = getchar();
while (c < '0' || c > '9') f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
x = f ? -x : x;
}
inline int mi(register int x, register int k) {
register int s = 1;
while (k) {
if (k & 1) s = (long long)s * x % P;
x = (long long)x * x % P, k >>= 1;
}
return s;
}
inline int inv(register int x) { return x == 0 ? 1 : mi(x, P - 2); }
inline int C(register int m, register int n) {
return (long long)jc[n] * inv(jc[n - m]) % P * inv(jc[m]) % P;
}
int main() {
in(n), in(w), in(b), jc[0] = 1;
for (register int i = 1; i <= w + b; ++i)
jc[i] = (long long)jc[i - 1] * i % P;
printf("%d\n",
(long long)C(n - 3, w + b - 3) * (w - 1) % P * jc[w] % P * jc[b] % P);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, w, t;
long long ans = 1, mod = (long long)1e9 + 9;
long long cnt = 0;
long long pow(long long a, long long b) {
if (b == 0) return 1;
long long s = pow(a, b / 2);
s *= s;
s %= mod;
if (b & 1) s *= a;
s %= mod;
return s;
}
long long c(long long a, long long b) {
long long s = 1;
for (long long i = 0; i < b; i++) s = (s * (a - i)) % mod;
for (long long i = 1; i <= b; i++) s = (s * pow(i, mod - 2)) % mod;
return s;
}
int main() {
scanf("%I64d%I64d%I64d", &n, &w, &t);
for (long long i = 1; i <= w; i++) {
ans *= i;
ans %= mod;
}
for (long long i = 1; i <= t; i++) {
ans *= i;
ans %= mod;
}
ans *= (w - 1);
ans %= mod;
ans *= c(t + w - 3, n - 3);
ans %= mod;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4003, P = 1e9 + 9;
int n, w, b, jc[N << 1];
inline void in(register int &x) {
int f = 0;
x = 0;
char c = getchar();
while (c < '0' || c > '9') f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
x = f ? -x : x;
}
inline int mi(register int x, register int k) {
register int s = 1;
while (k) {
if (k & 1) s = (long long)s * x % P;
x = (long long)x * x % P, k >>= 1;
}
return s;
}
inline int inv(register int x) { return mi(x, P - 2); }
inline int C(register int m, register int n) {
return (long long)jc[n] * inv(jc[n - m]) % P * inv(jc[m]) % P;
}
int main() {
in(n), in(w), in(b), jc[0] = 1;
for (register int i = 1; i <= w + b; ++i)
jc[i] = (long long)jc[i - 1] * i % P;
printf("%d\n",
(long long)C(n - 3, w + b - 3) * (w - 1) % P * jc[w] % P * jc[b] % P);
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = INT_MAX >> 1;
const int Mo = 1000000009;
long long C[4100][4100];
long long fac[4100];
int main() {
int i, j;
fac[0] = C[0][0] = 1;
for (i = 1; i <= 4000; i++) {
fac[i] = fac[i - 1] * i % Mo;
C[i][0] = 1;
for (j = 1; j <= i; j++) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % Mo;
}
int N, w, b;
cin >> N >> w >> b;
long long ans = 0;
int l = max(1, N - w), r = min(b, N);
for (i = l; i <= r; i++)
ans = (ans + C[b - 1][i - 1] * fac[b] % Mo * C[w - 1][N - i - 1] % Mo *
fac[w] % Mo * (N - i - 1) % Mo) %
Mo;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, b;
long long fact[4096], inv[4096];
long long quick_pow(long long a, int k) {
int ans = 1;
while (k > 0) {
if (k & 1) ans = (ans * a) % 1000000009;
k >>= 1;
a = (a * a) % 1000000009;
}
return ans % 1000000009;
}
void init() {
fact[0] = 1;
inv[0] = 1;
for (int i = 1; i < 4096; i++) {
fact[i] = fact[i - 1] * i % 1000000009;
inv[i] = quick_pow(fact[i], 1000000009 - 2);
}
}
long long C(int M, int N) {
if (M > N) return 0;
return inv[M] * fact[N] % 1000000009 * inv[N - M] % 1000000009;
}
void work() {
long long ans = 0;
for (int i = 2; i < n; i++) {
for (int j = i; j < n; j++) {
int x = C(j - i, b - 1), y = C(n - (j - i + 1) - 1, w - 1);
;
;
ans =
(ans + C(j - i, b - 1) * C(n - (j - i + 1) - 1, w - 1) % 1000000009) %
1000000009;
}
}
cout << ans * fact[w] % 1000000009 * fact[b] % 1000000009 << endl;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> w >> b;
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int C[4010][4010];
long long mi[4010];
const int mod = 1000000009;
void init() {
int i, j;
C[0][0] = 1;
for (i = 1; i <= 4000; i++) {
C[i][0] = C[i][i] = 1;
for (j = 1; j < i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] >= mod) C[i][j] -= mod;
}
}
}
int main() {
int n, w, b, i, j, k, m;
for (i = 1, mi[0] = 1; i <= 4000; i++) mi[i] = mi[i - 1] * i % mod;
init();
scanf("%d%d%d", &n, &m, &b);
int ans = 0;
long long t;
for (i = 1; i + 2 <= n; i++) {
t = C[b - 1][i - 1];
t *= mi[b], t %= mod;
t *= n - i - 1;
t %= mod;
t *= C[m - 1][n - i - 1], t %= mod;
t *= mi[m], t %= mod;
ans += t, ans %= mod;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int Read() {
char c;
while (c = getchar(), (c != '-') && (c < '0' || c > '9'))
;
bool neg = (c == '-');
int ret = (neg ? 0 : c - 48);
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + c - 48;
return neg ? -ret : ret;
}
const int MOD = 9 + 1e9;
int N, W, B;
int Pow(int x, int y) {
if (y == 1) return x;
int tmp = Pow(x, y >> 1);
tmp = (long long)tmp * tmp % MOD;
return y & 1 ? (long long)tmp * x % MOD : tmp;
}
long long fac(int n) {
long long ret = 1;
for (int i = 2; i <= n; i++) (ret *= i) %= MOD;
return ret;
}
long long C(int n, int m) {
return fac(n) * Pow(fac(m), MOD - 2) % MOD * Pow(fac(n - m), MOD - 2) % MOD;
}
int main() {
scanf("%d%d%d", &N, &W, &B);
printf("%d\n",
fac(W) * fac(B) % MOD * (W - 1) % MOD * C(W + B - 3, N - 3) % MOD);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4005;
const long long mod = 1000000009;
int n, w, b;
long long f[MAXN][MAXN], C[MAXN][MAXN];
int main() {
scanf("%d %d %d", &n, &w, &b);
f[0][0] = 1;
for (int i = 0; i <= 4000; i++) C[i][0] = 1;
for (int i = 1; i <= 4000; i++)
for (int j = 1; j <= 4000; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
long long ans = 0;
for (int i = 1; i <= n; i++)
for (int j = i + 2; j <= n; j++)
if (i + (1 + n - j) <= w && j - i - 1 <= b) {
int x = i + n - j + 1, y = n - x;
ans += C[w - 1][x - 1] * C[b - 1][y - 1] % mod;
ans %= mod;
}
for (int i = 1; i <= w; i++) ans = ans * i % mod;
for (int i = 1; i <= b; i++) ans = ans * i % mod;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ch[4010][4010];
long long ans, jc[4010];
long long p;
int n, a, b, i, j, c;
int main() {
scanf("%d%d%d", &n, &a, &b);
for (i = 0; i <= 4000; i++) ch[i][0] = 1;
for (i = 1; i <= max(a, b); i++)
for (j = 1; j <= max(a, b); j++)
ch[i][j] = (ch[i - 1][j - 1] + ch[i - 1][j]) % 1000000009ll;
jc[1] = 1;
for (i = 1; i <= 4000; i++) jc[i + 1] = (jc[i] * (i + 1)) % 1000000009ll;
for (i = 1; i <= b; i++) {
if (n - i < 2 || n - i > a) continue;
c = n - i;
p = jc[b] * ch[b - 1][i - 1] % 1000000009;
p = p * jc[a] % 1000000009;
p = p * ch[a - 1][c - 1] % 1000000009;
p = p * ch[c - 1][1] % 1000000009;
ans = ans + p;
ans %= 1000000009;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int modd = 1e9 + 9;
const int maxn = 4000 + 15;
long long C[maxn][maxn];
int n, w, b;
int main() {
scanf("%d%d%d", &n, &w, &b);
long long jc = 1ll;
for (int i = 2; i <= w; i++) jc = jc * i % modd;
for (int i = 2; i <= b; i++) jc = jc * i % modd;
long long ans = 0;
for (int i = 0, j; i <= max(w, b); i++)
for (C[i][0] = j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % modd;
for (int i = 2; i < n; i++)
if (w >= i && b >= n - i)
ans += C[w - 1][i - 1] * C[b - 1][n - i - 1] % modd * (i - 1) % modd;
ans %= modd;
ans = ans * jc % modd;
printf("%d\n", (int)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000009;
int n, b, w;
long long c[4010][4010];
long long ans;
void init() {
int sz = max(max(n, b), w);
c[0][0] = 1;
for (int i = 1; i <= sz; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
if (c[i][j] >= mod) c[i][j] -= mod;
}
}
}
long long frac(int x) {
long long res = 1;
for (int i = 2; i <= x; i++) res = res * i % mod;
return res;
}
int main() {
cin >> n >> w >> b;
init();
for (int i = 2; i <= n; i++) {
for (int j = i; j < n; j++) {
ans += c[b - 1][j - i] * c[w - 1][n - j + i - 2] % mod;
if (ans >= mod) ans -= mod;
}
}
ans = ans * frac(b) % mod * frac(w) % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long san(long long x) {
if (x < 0) x = (x % 1000000009) + 1000000009;
if (x >= 1000000009) x %= 1000000009;
return x;
}
long long P[4001];
int C[2 * 4001][4001][2];
int main() {
int N, W, B;
scanf("%d %d %d", &N, &W, &B);
P[0] = 1;
for (int i = 1; i < 4001; i++) P[i] = san(P[i - 1] * i);
memset(C, 0, sizeof C);
C[0][0][0] = C[0][0][1] = 1;
for (int i = 1; i < 2 * 4001 - 1; i++) {
C[i][0][0] = 1;
C[i][0][1] = 1 + C[i - 1][0][1];
for (int j = 1; 2 * j < i; j++) {
for (int k = 0; k < 2; k++) {
if (k)
C[i][j][k] = san(C[i][j][0] + C[i - 1][j][1]);
else if (i - 2 >= 0)
C[i][j][k] = san(C[i - 2][j - 1][1] - C[0][j - 1][1]);
}
}
}
int w;
long long ans = 0;
for (int b = max(1, N - W); b <= B and b <= N - 2; b++) {
w = N - b;
ans = san(ans +
san((long long)C[W + w - 1][w - 1][0] * C[B + b - 1][b - 1][0]) *
(w - 1));
}
ans = san(ans * san(P[W] * P[B]));
printf("%d\n", (int)ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, W, B;
long long b[4005], f[4005][4005], ans = 0;
long long mo(long long a) {
if (a >= 0 && a < 1000000009) return a;
a %= 1000000009;
if (a < 0) a += 1000000009;
return a;
}
long long cal(int n, int m) { return f[m][n]; }
int main() {
scanf("%d%d%d", &n, &W, &B);
b[0] = 1;
for (int i = 1; i <= max(W, B); i++) b[i] = mo(b[i - 1] * i);
for (int i = 1; i <= max(W, B); i++) {
f[i][1] = b[i];
for (int j = 2; j <= n; j++)
f[i][j] = mo(f[i - 1][j] * (i - 1 + j) + f[i - 1][j - 1] * j);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j + i < n; j++)
if (W >= i + j && B >= n - i - j)
ans = mo(ans + cal(i + j, W) * cal(n - i - j, B));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m[5000][5000];
char v[5000][5000];
long long int force(int p, int t) {
if (p == 0 && t == 0) return 1;
if (p == 0 || t == 0) return 0;
if (p > t) return 0;
if (v[p][t]) return m[p][t];
long long int s = 0;
s += t * force(p - 1, t - 1);
s %= 1000000009;
s += t * force(p, t - 1);
s %= 1000000009;
v[p][t] = 1;
m[p][t] = s;
return s;
}
int main() {
long long int s = 0;
int n, w, b;
cin >> n >> w >> b;
for (int i = 2; i <= n - 1; i++) {
for (int j = i; j <= n - 1; j++) {
long long int u = 1;
u *= force(i - 1 + n - j, w);
u %= 1000000009;
u *= force(j - i + 1, b);
u %= 1000000009;
s += u;
s %= 1000000009;
}
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 4010;
const int MOD = 1e9 + 9;
long long f[MAX], finv[MAX], inv[MAX];
void init() {
f[0] = inv[0] = inv[1] = finv[0] = finv[1] = f[1] = 1;
for (int i = 2; i < MAX; ++i) {
f[i] = f[i - 1] * i % MOD;
inv[i] = (MOD - MOD / i) * inv[MOD % i] % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long C(int n, int m) {
if (m < 0 || m > n) return 0;
return f[n] * finv[n - m] % MOD * finv[m] % MOD;
}
int main(void) {
init();
int n, w, b;
scanf("%d%d%d", &n, &w, &b);
long long ans = 0;
for (int i = 1; i <= b && i <= n - 2; ++i) {
ans = (ans + C(b - 1, i - 1) * f[b] % MOD * C(w - 1, n - i - 1) % MOD *
f[w] % MOD * (n - i - 1) % MOD) %
MOD;
}
printf("%lld\n", (ans % MOD + MOD) % MOD);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, b;
int fac[4044], c[4044][4044];
struct modular_arithmetic {
int mod;
modular_arithmetic() { mod = 1000000009; }
int add(int x, int y) { return (x += y) < mod ? x : x - mod; }
int mul(int x, int y) { return (int)((long long int)x * y % mod); }
};
modular_arithmetic ma;
int f(int n, int m) { return ma.mul(fac[m], c[m - 1][n - 1]); }
int main() {
scanf("%d%d%d", &n, &w, &b);
int lim = max(w, b);
fac[0] = fac[1] = 1;
for (int i = 2; i <= lim; i++) fac[i] = ma.mul(fac[i - 1], i);
for (int i = 0; i <= lim; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) c[i][j] = ma.add(c[i - 1][j], c[i - 1][j - 1]);
}
int ans = 0;
for (int lb = max(1, n - w); lb <= min(n - 2, b); lb++) {
int cb = 0;
cb = ma.add(cb, f(lb, b));
int cw = 0;
cw = ma.add(cw, f(n - lb, w));
cw = ma.mul(cw, n - lb - 1);
ans = ma.add(ans, ma.mul(cb, cw));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4, mod = 1e9 + 9;
int fact[maxn], prv[maxn];
int power(int a, int b) {
if (b == 0) return 1;
int t = power(a, b >> 1);
t = (1LL * t * t) % mod;
if (b & 1) t = (1LL * t * a) % mod;
return t;
}
int C(int n, int r) {
if (r < 0 || r > n) return 0;
int ret = (1LL * prv[r] * prv[n - r]) % mod;
ret = (1LL * ret * fact[n]) % mod;
return ret;
}
int main() {
fact[0] = 1;
for (int i = 1; i < maxn; i++) fact[i] = (1LL * i * fact[i - 1]) % mod;
for (int i = 0; i < maxn; i++) prv[i] = power(fact[i], mod - 2);
int n, w, b;
cin >> n >> w >> b;
int ans = (1LL * (w - 1) * C(w + b - 3, n - 3)) % mod;
ans = (1LL * ans * fact[w]) % mod;
ans = (1LL * ans * fact[b]) % mod;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
const int N = 4005, mo = (int)1e9 + 9;
int n, a, b, ans;
int C[N][N];
int calc(int n, int m) {
if (n < m) return 0;
return C[n - 1][m - 1];
}
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = 0; i <= a || i <= b; i++)
for (int j = 0; j <= i; j++)
C[i][j] = j ? (C[i - 1][j - 1] + C[i - 1][j]) % mo : 1;
for (int i = 1; i < n; i++)
for (int j = i + 1; j < n; j++)
ans = (ans + 1LL * calc(a, n - (j - i)) * calc(b, j - i)) % mo;
for (int i = 1; i <= a; i++) ans = 1LL * ans * i % mo;
for (int i = 1; i <= b; i++) ans = 1LL * ans * i % mo;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
const int maxn = 4e3 + 10;
const int mod = 1e9 + 9;
int n, a, b, ans, fac[maxn], inv[maxn];
inline int power(int x, int y) {
int ans = 1;
for (; y; y >>= 1, x = 1ll * x * x % mod)
if (y & 1) ans = 1ll * ans * x % mod;
return ans;
}
inline int C(int n, int m) {
if (n == 0 && m == 0) return 1;
if (n < m) return 0;
return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}
int main() {
fac[0] = inv[0] = 1;
for (int i = 1; i < maxn; i++) {
fac[i] = 1ll * fac[i - 1] * i % mod;
inv[i] = power(fac[i], mod - 2);
}
scanf("%d%d%d", &n, &a, &b);
for (int i = 2; i <= n; i++)
for (int j = i; j < n; j++)
(ans += 1ll * C(b - 1, j - i) * C(a - 1, n - j + i - 2) % mod * fac[a] %
mod * fac[b] % mod) %= mod;
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x20202020;
const int mod = 1000000009;
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
template <class T>
inline void read(T& x, T& y) {
read(x);
read(y);
}
template <class T>
inline void read(T& x, T& y, T& z) {
read(x);
read(y);
read(z);
}
template <class T>
inline void read(T& x, T& y, T& z, T& q) {
read(x);
read(y);
read(z);
read(q);
}
const int DX[] = {1, 0, -1, 0}, DY[] = {0, 1, 0, -1};
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int N = 4444, M = 4000;
int l, m, n, t, C[N][N];
int main() {
scanf("%d%d%d", &n, &m, &l);
for (int _tmp = M, i = 0; i <= _tmp; ++i) C[i][0] = 1;
for (int _tmp = M, i = 1; i <= _tmp; ++i)
for (int _tmp = i, j = 1; j <= _tmp; ++j)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
long long ans = 0;
for (int _tmp = n - 1, i = 1; i <= _tmp; ++i)
for (int _tmp = n - 1, j = i + 1; j <= _tmp; ++j) {
ans =
(ans + 1ll * C[l - 1][j - i - 1] * C[m - 1][(n - (j - i)) - 1]) % mod;
}
for (int _tmp = m, i = 1; i <= _tmp; ++i) ans = (ans * i) % mod;
for (int _tmp = l, i = 1; i <= _tmp; ++i) ans = (ans * i) % mod;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 4005, P = (int)1e9 + 9;
void Add(int &x, int y) {
x += y;
if (x >= P) x -= P;
}
int fast(int x, int p) {
int re = 1;
while (p) {
if (p & 1) re = (long long)re * x % P;
x = (long long)x * x % P, p >>= 1;
}
return re;
}
int n, a, b;
int fac[M * 3], rfac[M * 3];
int C(int a, int b) {
if (a < b) return 0;
return (long long)fac[a] * rfac[b] % P * rfac[a - b] % P;
}
int main() {
fac[0] = 1;
for (int i = 1; i < M * 3; i++) fac[i] = (long long)fac[i - 1] * i % P;
rfac[M * 3 - 1] = fast(fac[M * 3 - 1], P - 2);
for (int i = M * 3 - 2; i >= 0; i--)
rfac[i] = (long long)rfac[i + 1] * (i + 1) % P;
scanf("%d %d %d", &n, &a, &b);
int ans = 0;
for (int i = 1, up = min(n - 2, b); i <= up; i++)
Add(ans,
(long long)(n - i - 1) * C(b - 1, i - 1) % P * C(a - 1, n - i - 1) % P);
ans = (long long)ans * fac[a] % P * fac[b] % P;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans, dp[4001][4001], n, w, b, hehe;
int main() {
cin >> n >> w >> b;
for (int i = 0; i <= max(w, b); i++) dp[0][i] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= max(w, b); j++)
dp[i][j] = (dp[i][j - 1] + dp[i - 1][j - 1]) % 1000000009;
for (int i = 1; i <= n - 2; i++)
ans = (ans + (dp[i][b] - dp[i][b - 1] + 1000000009) % 1000000009 *
(dp[n - i][w] - dp[n - i][w - 1] + 1000000009) %
1000000009 * (n - i - 1) % 1000000009) %
1000000009;
for (int i = 1; i <= w; i++) ans = ans * i % 1000000009;
for (int i = 1; i <= b; i++) ans = ans * i % 1000000009;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int mod = (int)1e9 + 9;
const int maxn = 4004;
int A[maxn], B[maxn], C[2 * maxn][2 * maxn], dp1[maxn], dp2[maxn];
int main() {
for (int i = 0; i < 2 * maxn; i++) {
C[i][0] = 1;
}
for (int i = 1; i < 2 * maxn; i++) {
for (int j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
C[i][j] %= mod;
}
}
int n, w, b;
cin >> n >> w >> b;
A[1] = w;
for (int i = 2; i <= w; i++) {
A[i] = A[i - 1] * (long long)(w - i + 1) % mod;
}
B[1] = b;
for (int i = 2; i <= b; i++) {
B[i] = B[i - 1] * (long long)(b - i + 1) % mod;
}
for (int i = 1; i <= w; i++) {
dp1[i] += C[w - 1][i - 1] * (long long)A[w] % mod;
dp1[i] %= mod;
}
for (int i = 1; i <= b; i++) {
dp2[i] += C[b - 1][i - 1] * (long long)B[b] % mod;
dp2[i] %= mod;
}
int res = 0;
for (int i = 2; i < n; i++) {
if (i <= w && n - i <= b) {
res += dp1[i] * (long long)dp2[n - i] % mod * (long long)(i - 1) % mod;
res %= mod;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4003, P = 1e9 + 9;
int n, w, b, jc[N << 1];
inline void in(register int &x) {
int f = 0;
x = 0;
char c = getchar();
while (c < '0' || c > '9') f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
x = f ? -x : x;
}
inline int mi(register int x, register int k) {
register int s = 1;
while (k) {
if (k & 1) s = (long long)s * x % P;
x = (long long)x * x % P, k >>= 1;
}
return s;
}
inline int inv(register int x) { return x == 0 ? 1 : mi(x, P - 2); }
inline int C(register int m, register int n) {
return (long long)jc[n] * inv(jc[n - m]) % P * inv(jc[m]) % P;
}
int main() {
in(n), in(w), in(b), jc[0] = 1;
for (register int i = 1; i <= w + b; ++i)
jc[i] = (long long)jc[i - 1] * i % P;
printf("%d\n",
(long long)C(n - 3, w + b - 3) * (w - 1) % P * jc[w] % P * jc[b] % P);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4000 + 10, MOD = (int)1e9 + 9;
int n, m, b, w, f[MAXN][MAXN];
int main() {
cin >> n >> w >> b;
m = max(b, w);
f[0][0] = 1;
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= i; ++j)
f[i][j] = ((long long)f[i - 1][j] * (j + i - 1) +
(long long)f[i - 1][j - 1] * j) %
MOD;
}
int Tohka = 0;
for (int i = 1; i <= min(b, n - 2); ++i)
Tohka = ((long long)Tohka +
(long long)f[w][n - i] * f[b][i] % MOD * (n - i - 1)) %
MOD;
cout << Tohka << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4010, mod = 1e9 + 9;
long long fact[maxn], C[maxn][maxn];
void init(long long n) {
for (int i = 0; i <= n; i++) {
C[i][0] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
}
fact[0] = 1;
for (long long i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
}
int main() {
long long n, w, b;
cin >> n >> w >> b;
init(max(n, max(b, w)));
long long res = 0;
for (long long i = 1; i <= b; i++) {
long long add = n - i - 1;
if (add == 0) break;
add = (add * C[b - 1][i - 1]) % mod;
add = (add * fact[b]) % mod;
add = (add * C[w - 1][n - i - 1]) % mod;
add = (add * fact[w]) % mod;
res = (res + add) % mod;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int md = 1e9 + 9;
long long ans = 0;
long long f[4444][4444], fact[4444];
int good, bad, i, n, j;
int main() {
scanf("%d %d %d", &n, &good, &bad);
int t = max(max(good, bad), n);
for (i = 0; i <= t; i++) f[i][0] = 1;
for (i = 1; i <= t; i++)
for (j = 1; j <= i; j++) f[i][j] = (f[i - 1][j - 1] + f[i - 1][j]) % md;
fact[0] = 1;
for (i = 1; i <= t; i++) fact[i] = fact[i - 1] * i % md;
for (j = 1; j <= good; j++) {
for (i = 1; i <= bad; i++) {
if (n - i > good || i + j >= n) continue;
ans += f[good - 1][n - i - 1] * fact[good] % md * f[bad - 1][i - 1] % md *
fact[bad];
ans = ans % md;
}
}
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 4005;
const int M = 1000000009;
int n, u, v;
int binom[MaxN][MaxN];
int main() {
cin >> n >> u >> v;
for (int i = 0; i <= max(max(u, v), n); ++i) {
binom[i][0] = 1;
for (int j = 1; j <= i; ++j) {
binom[i][j] = binom[i - 1][j] + binom[i - 1][j - 1];
if (binom[i][j] >= M) binom[i][j] -= M;
}
}
int res = 0;
for (int i = 1; i <= n - 2; ++i)
for (int j = i + 1; j <= n - 1; ++j)
res = (res +
(long long)binom[v - 1][j - i - 1] * binom[u - 1][n - j + i - 1]) %
M;
for (int i = 2; i <= u; ++i) res = (long long)res * i % M;
for (int i = 2; i <= v; ++i) res = (long long)res * i % M;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000009;
int n, w, b;
long long fac[8005], inv[8005];
inline void pre() {
fac[0] = fac[1] = inv[0] = inv[1] = 1;
for (int i = 2; i <= 8000; i++) fac[i] = fac[i - 1] * i % mod;
for (int i = 2; i <= 8000; i++) inv[i] = (mod - mod / i) * inv[mod % i] % mod;
for (int i = 2; i <= 8000; i++) inv[i] = inv[i - 1] * inv[i] % mod;
}
int C(int n, int m) { return fac[n] * inv[m] % mod * inv[n - m] % mod; }
int main() {
pre();
scanf("%d%d%d", &n, &w, &b);
cout << fac[w] * fac[b] % mod * (w - 1) % mod * C(w + b - 3, n - 3) % mod
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fact[4010], invfact[4010];
int Power(int p, int n) {
int ans = 1;
for (; n; n >>= 1, p = (long long)p * p % 1000000009)
if (n & 1) ans = (long long)ans * p % 1000000009;
return ans;
}
int C(int n, int m) {
if (n < m) return 0;
return (long long)fact[n] * invfact[m] % 1000000009 * invfact[n - m] %
1000000009;
}
int n, w, b;
int work() {
fact[0] = 1, invfact[0] = 1;
int N = max(max(w, b), n);
for (int i = 1; i <= N; ++i)
fact[i] = (long long)fact[i - 1] * i % 1000000009,
invfact[i] = Power(fact[i], 1000000009 - 2);
int ans = 0;
for (int i = 2; i < n; ++i)
for (int j = i; j < n; ++j)
ans = (ans + (long long)C(b - 1, j - i) * C(w - 1, n - (j - i + 1) - 1)) %
1000000009;
return (long long)ans * fact[w] % 1000000009 * fact[b] % 1000000009;
}
int main() {
scanf("%d %d %d", &n, &w, &b);
printf("%d\n", work());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
x = 0;
char c;
int sign = 1;
do {
c = getchar();
if (c == '-') sign = -1;
} while (!isdigit(c));
do {
x = x * 10 + c - '0';
c = getchar();
} while (isdigit(c));
x *= sign;
}
long long n, w, b, ans;
long long fac[5010], c[5010][5010];
long long comb(long long n, long long m) {
if (c[n][m] > 0) return c[n][m];
if (m == 0) return c[n][m] = 1;
if (n >= m + 1)
return c[n][m] = (comb(n - 1, m) + comb(n - 1, m - 1)) % 1000000009;
else
return c[n][m] = comb(n - 1, m - 1);
}
int main() {
read(n), read(w), read(b);
fac[0] = 1;
for (long long i = 1; i <= max(w, b); i++)
fac[i] = (fac[i - 1] * i) % 1000000009;
for (long long i = max(n - w, 1ll); i <= min(n - 2, b); i++) {
long long k = comb(b - 1, i - 1) * fac[b] % 1000000009;
k = k * fac[w] % 1000000009 * comb(w - 1, n - i - 1) % 1000000009 *
(n - i - 1) % 1000000009;
ans = (ans + k) % 1000000009;
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 9;
const int mxn = 4005;
int n, w, b;
long long ans, res;
long long c[mxn][mxn], fac[mxn];
inline void init() {
int tmp = max(n, max(w, b));
for (int i = 0; i <= tmp; i++) c[i][0] = 1;
for (int i = 1; i <= tmp; i++)
for (int j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
fac[0] = 1;
for (int i = 1; i <= max(w, b); i++) fac[i] = (i * fac[i - 1]) % mod;
}
int main() {
scanf("%d%d%d", &n, &w, &b);
init();
for (int i = 1; i <= b; i++) {
long long res = n - i - 1;
if (!res) break;
res = res * c[b - 1][i - 1] % mod;
res = res * fac[b] % mod;
res = res * c[w - 1][n - i - 1] % mod;
res = res * fac[w] % mod;
ans = (ans + res) % mod;
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4005, oo = 1000000009;
long long p[N], c[N][N], res, ans;
int n, w, b;
int main() {
p[0] = 1;
for (int i = 1; i < N - 2; i++) p[i] = p[i - 1] * i % oo;
for (int i = 0; i < N - 2; i++)
for (int j = 0; j < i + 1; j++)
c[i][j] = i && j ? (c[i - 1][j - 1] + c[i - 1][j]) % oo : 1;
scanf("%d%d%d", &n, &w, &b);
for (int i = max(n - w, 1); i < b + 1; i++)
if (i < n - 1)
ans =
(c[b - 1][i - 1] * c[w - 1][n - i - 1] % oo * (n - 1 - i) + ans) % oo;
printf("%d\n", p[w] * p[b] % oo * ans % oo);
return 0;
}
|
#include <bits/stdc++.h>
const int MOD = (int)(1e9) + 9;
const int N = 4000 + 9;
int f[N][N], n, c[N * 2][N], res;
int fac(int x) {
long long res = 1;
for (int i = 1; i <= x; ++i) res = res * i % MOD;
return res;
}
int main() {
int a[2];
scanf("%d%d%d", &n, &a[1], &a[0]);
for (int i = 1; i <= a[1]; ++i) f[1][i] = 1;
f[0][0] = 1;
for (int i = 2; i <= n; ++i) {
int sum = f[i - 2][0];
for (int j = 1; j <= a[i & 1]; ++j) {
f[i][j] = (f[i][j] + sum) % MOD;
sum = (sum + f[i - 2][j]) % MOD;
}
}
c[0][1] = 1;
for (int i = 1; i <= a[0] + a[1]; ++i)
for (int j = 1; j <= n && j <= i; ++j)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
for (int i = 2; i < 3; ++i)
res = (res + 1ll * f[i][a[i & 1]] * f[i + 1][a[i + 1 & 1]] % MOD *
c[a[0] + a[1] - i][n - i] % MOD) %
MOD;
printf("%I64d\n", 1ll * res * fac(a[0]) % MOD * fac(a[1]) % MOD);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T &first) {
return first * first;
}
template <class _T>
inline string tostr(const _T &a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-9;
char TEMPORARY_CHAR;
const int INF = 1e9;
inline void fft(vector<complex<long double> > &a, bool invert) {
int n = (int)a.size();
for (int i = 1, j = 0; i < n; ++i) {
int bit = n >> 1;
for (; j >= bit; bit >>= 1) j -= bit;
j += bit;
if (i < j) swap(a[i], a[j]);
}
for (int len = 2; len <= n; len <<= 1) {
long double ang = 2 * PI / len * (invert ? -1 : 1);
complex<long double> wlen(cos(ang), sin(ang));
for (int i = 0; i < n; i += len) {
complex<long double> w(1);
for (int j = 0; j < len / 2; ++j) {
complex<long double> u = a[i + j], v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w *= wlen;
}
}
}
if (invert)
for (int i = 0; i < n; ++i) a[i] /= n;
}
inline void input(int &a) {
a = 0;
while (((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') &&
(TEMPORARY_CHAR != '-')) {
}
char neg = 0;
if (TEMPORARY_CHAR == '-') {
neg = 1;
TEMPORARY_CHAR = getchar();
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = (a << 3) + (a << 1) + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
if (neg) a = -a;
}
inline void out(long long a) {
if (!a) putchar('0');
if (a < 0) {
putchar('-');
a = -a;
}
char s[20];
int i;
for (i = 0; a; ++i) {
s[i] = '0' + a % 10;
a /= 10;
}
for (int j = (i)-1; j >= 0; j--) putchar(s[j]);
}
inline int nxt() {
int(ret);
input((ret));
;
return ret;
}
struct lnum {
vector<int> a;
int base;
lnum(int num = 0, int base = 1000000000) : base(base) {
if (!num) a.resize(1);
while (num) {
a.push_back(num % base);
num /= base;
}
}
inline int len() const { return a.size(); }
lnum &operator=(const lnum &l) {
if (this != &l) {
a = l.a;
base = l.base;
}
return *this;
}
inline friend lnum operator+(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
int ln = l.len(), rn = r.len();
int n = max(ln, rn);
ret.a.resize(n);
int o = 0;
for (int i = 0; i < n; ++i) {
int s = o;
if (i < ln) s += l.a[i];
if (i < rn) s += r.a[i];
o = s >= base;
if (o) s -= base;
ret.a[i] = s;
}
if (o) ret.a.push_back(1);
return ret;
}
inline friend lnum operator-(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
int n = l.len();
int rn = r.len();
ret.a.resize(n);
int o = 0;
for (int i = 0; i < n; ++i) {
int s = l.a[i] - o;
if (i < rn) s -= r.a[i];
o = s < 0;
if (o) s += base;
ret.a[i] = s;
}
if (ret.len() > 1 && !ret.a.back()) ret.a.pop_back();
return ret;
}
inline friend lnum operator*(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
if (l.len() * r.len() > 1000000) {
vector<complex<long double> > fa(l.a.begin(), l.a.end()),
fb(r.a.begin(), r.a.end());
int n = 1;
while (n < max(l.len(), r.len())) n <<= 1;
n <<= 1;
fa.resize(n), fb.resize(n);
fft(fa, false), fft(fb, false);
for (int i = 0; i < n; ++i) fa[i] *= fb[i];
fft(fa, true);
ret.a.resize(n);
for (int i = 0; i < n; ++i) ret.a[i] = int(fa[i].real() + 0.5);
int carry = 0;
for (int i = 0; i < n; ++i) {
ret.a[i] += carry;
carry = ret.a[i] / base;
ret.a[i] %= base;
}
} else {
ret.a.resize(l.len() + r.len());
for (int i = 0; i < l.len(); ++i)
for (int j = 0, carry = 0; j < r.len() || carry; ++j) {
long long cur = ret.a[i + j] +
(long long)l.a[i] * (j < r.len() ? r.a[j] : 0) +
carry;
ret.a[i + j] = cur % base;
carry = cur / base;
}
}
while (ret.len() > 1 && !ret.a.back()) ret.a.pop_back();
return ret;
}
inline friend lnum operator/(const lnum &l, const int &r) {
lnum ret(0, l.base);
ret.a.resize(l.len());
int carry = 0;
for (int i = l.len() - 1; i >= 0; --i) {
long long cur = l.a[i] + (long long)carry * l.base;
ret.a[i] = cur / r;
carry = cur % r;
}
while (ret.len() > 1 && ret.a.back() == 0) ret.a.pop_back();
return ret;
}
inline friend bool operator<(const lnum &l, const lnum &r) {
if (l.len() < r.len()) return true;
if (l.len() > r.len()) return false;
int n = l.len();
for (int i = n - 1; i >= 0; --i) {
if (l.a[i] < r.a[i]) return true;
if (l.a[i] > r.a[i]) return false;
}
return false;
}
inline friend bool operator>(const lnum &l, const lnum &r) { return r < l; }
inline friend bool operator==(const lnum &l, const lnum &r) {
if (l.len() != r.len()) return false;
int n = l.len();
for (int i = n - 1; i; --i) {
if (l.a[i] != r.a[i]) return false;
}
return true;
}
inline friend bool operator!=(const lnum &l, const lnum &r) {
return !(l == r);
}
inline void print() {
if (base == 1000000000) {
printf("%d", a.back());
for (int i = a.size() - 2; i >= 0; --i) printf("%09d", a[i]);
} else {
for (int i = a.size() - 1; i >= 0; --i) printf("%d", a[i]);
}
}
};
int c[4001][4001];
int main() {
int N = 4000;
int mod = 1000000009;
memset((c), 0, sizeof(c));
for (int i = 0; i <= N; ++i) {
c[i][0] = 1;
for (int j = 1; j <= i; ++j) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]);
if (c[i][j] >= mod) c[i][j] -= mod;
}
}
int(n);
input((n));
;
int(a);
input((a));
;
int(b);
input((b));
;
long long ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; i + j < n; ++j)
ans = (ans + (long long)c[b - 1][(n - i - j) - 1] * c[a - 1][i + j - 1]) %
mod;
for (int i = 0; i < (int)(a); i++) ans = ans * (i + 1) % mod;
for (int i = 0; i < (int)(b); i++) ans = ans * (i + 1) % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4003, P = 1e9 + 9;
int n, w, b, jc[N << 1];
inline void in(register int &x) {
int f = 0;
x = 0;
char c = getchar();
while (c < '0' || c > '9') f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
x = f ? -x : x;
}
inline int mi(register int x, register int k) {
register int s = 1;
while (k) {
if (k & 1) s = (long long)s * x % P;
x = (long long)x * x % P, k >>= 1;
}
return s;
}
inline int inv(register int x) { return mi(x, P - 2); }
inline int C(register int m, register int n) {
return (long long)jc[n] * inv(jc[n - m]) % P * inv(jc[m]) % P;
}
int main() {
in(n), in(w), in(b), jc[0] = 1;
for (register int i = 1; i <= w + b; ++i)
jc[i] = (long long)jc[i - 1] * i % P;
printf("%d\n",
(long long)C(n - 3, w + b - 3) * (w - 1) % P * jc[w] % P * jc[b] % P);
}
|
#include <bits/stdc++.h>
using namespace std;
const int modulo = 1000000009;
long long A(int events, int days) {
if (events < days) return 0;
long long result = 1;
for (int e = events - 1; e >= days; --e) {
result *= e;
result %= modulo;
}
for (int i = 0; i < days; i++) {
result *= events;
result %= modulo;
--events;
}
return result;
}
int main() {
int n, w, b;
scanf("%i%i%i", &n, &w, &b);
long long result = 0;
for (int i = 2; i < n; i++) {
result += ((i - 1) * A(w, i)) % modulo * A(b, n - i);
result %= modulo;
}
printf("%i\n", (int)result);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[4010];
long long c[4010][4010];
void geta() {
int i;
a[1] = 1;
for (i = 2; i < 4010; i++) {
a[i] = a[i - 1] * i;
a[i] %= 1000000009;
}
}
void getc() {
int i, j;
for (i = 0; i < 4010; i++) {
for (j = 0; j <= i; j++) {
if (!j || i == j)
c[i][j] = 1;
else
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
c[i][j] %= 1000000009;
}
}
}
int main() {
int n, w, b;
int i, j;
long long ans, nn;
geta();
getc();
scanf("%d%d%d", &n, &w, &b);
ans = 0;
for (i = max(1, n - w); i <= min(n - 2, b); i++) {
j = n - i;
ans += ((c[b - 1][i - 1] * c[w - 1][j - 1]) % 1000000009) * (j - 1) %
1000000009;
ans %= 1000000009;
}
ans = ((ans * a[b]) % 1000000009) * a[w] % 1000000009;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modulo(long long base, long long exponent, long long modulus);
long long choose(long long n, long long k);
long long inverse(long long a, long long m);
void build();
void fileio();
long long ncr(long long n, long long r);
const int nax = 1e6 + 10;
const int LG = log2(nax) + 1;
vector<long long> fact(nax);
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
build();
long long n, w, b;
cin >> n >> w >> b;
long long ans = 0;
for (long long i = 1; i < w; i++) {
long long temp = (ncr(w, i) * fact[i]) % 1000000009;
temp = (temp * fact[w - i]) % 1000000009;
temp = (temp * fact[b]) % 1000000009;
temp = (temp * ncr(i - 1 + w - i - 1 + b - 1, n - 3)) % 1000000009;
ans = (ans + temp) % 1000000009;
}
cout << ans << '\n';
return 0;
}
long long ncr(long long n, long long r) {
if (r > n || r < 0 || n < 0) return 0;
long long ans = fact[n];
long long temp = (fact[n - r] * fact[r]) % 1000000009;
ans = (ans * inverse(temp, 1000000009)) % 1000000009;
return ans;
}
void fileio() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void build() {
fact[0] = 1;
for (long long i = 1; i < nax; i++) fact[i] = (fact[i - 1] * i) % 1000000009;
}
long long modulo(long long base, long long exponent, long long modulus) {
if (modulus == 1) return 0;
long long result = 1;
base = base % modulus;
while (exponent > 0) {
if (exponent % 2 == 1) {
result = (result * base) % modulus;
}
exponent = exponent >> 1;
base = (base * base) % modulus;
}
return result;
}
long long choose(long long n, long long k) {
if (k == 0) return 1;
return (n * choose(n - 1, k - 1)) / k;
}
void EE(long long a, long long b, long long &co1, long long &co2) {
if (a % b == 0) {
co1 = 0;
co2 = 1;
return;
}
EE(b, a % b, co1, co2);
long long temp = co1;
co1 = co2;
co2 = temp - co2 * (a / b);
}
long long inverse(long long a, long long m) {
long long x, y;
EE(a, m, x, y);
if (x < 0) x += m;
return x;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4005;
const long long mod = 1000000009;
long long fact[maxn], invfact[maxn];
int w, b, n;
long long power(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y >>= 1;
}
return res;
}
long long C(int x, int y) {
if (x < y) return 0;
return fact[x] * invfact[y] % mod * invfact[x - y] % mod;
}
int main() {
scanf("%d%d%d", &n, &w, &b);
fact[0] = invfact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = fact[i - 1] * i % mod;
invfact[i] = power(fact[i], mod - 2);
}
long long ans = 0;
for (int i = 1; i <= n - 2; i++)
ans = (ans +
C(b - 1, i - 1) * C(w - 1, n - i - 1) % mod * (n - i - 1) % mod) %
mod;
printf("%I64d\n", ans * fact[w] % mod * fact[b] % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long C[4444][4444];
long long n, w, b, ans;
void init() {
for (int i = 0; i < 4444; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i) {
C[i][j] = 1;
} else {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] > 1000000009LL) C[i][j] -= 1000000009LL;
}
}
}
}
int main() {
init();
cin >> n >> w >> b;
for (int i = 1; i < n; i++) {
for (int j = 1; j + i < n; j++) {
ans = (ans + C[w - 1][n - j - 1] * C[b - 1][j - 1]) % 1000000009LL;
}
}
for (int i = 1; i <= w; i++) {
ans = ans * i % 1000000009LL;
}
for (int i = 1; i <= b; i++) {
ans = ans * i % 1000000009LL;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000009;
const int N = 4005;
long long fac[N], ifac[N], inv[N], pw2[N];
void pre() {
fac[0] = ifac[0] = fac[1] = ifac[1] = inv[1] = 1;
for (int i = 2; i < N; i++) {
fac[i] = i * fac[i - 1] % mod;
inv[i] = inv[mod % i] * (mod - mod / i) % mod;
ifac[i] = ifac[i - 1] * inv[i] % mod;
}
pw2[0] = 1;
for (int i = 1; i < N; i++) {
pw2[i] = pw2[i - 1] << 1;
if (pw2[i] >= mod) pw2[i] -= mod;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << setprecision(32);
pre();
int n, w, b;
cin >> n >> w >> b;
long long ans = 0;
for (int r = 1; r <= w; r++) {
if (1 <= n - r && n - r <= b) {
long long tmp = (fac[w - 1] * ifac[r - 1]) % mod;
(tmp *= ifac[w - r]) %= mod;
(tmp *= fac[b - 1]) %= mod;
(tmp *= ifac[n - r - 1]) %= mod;
(tmp *= ifac[b - n + r]) %= mod;
(tmp *= (r - 1)) %= mod;
ans += tmp;
if (ans >= mod) ans -= mod;
}
}
(ans *= fac[w]) %= mod;
(ans *= fac[b]) %= mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 4010;
const long long mod = 1e9 + 9;
long long f[maxn * 2][maxn], n, w, b;
long long num[maxn * 2], inv[maxn * 2];
long long pp(long long a, long long b) {
if (!b) return 1;
long long cnt = pp(a, b / 2);
cnt = 1ll * cnt * cnt % mod;
if (b & 1) cnt = 1ll * cnt * a % mod;
return cnt;
}
long long calc(long long n, long long m) {
if (n < m) return 0;
return 1ll * num[n] * num[n - 1] % mod * inv[m - 1] % mod * inv[n - m] % mod;
}
int main() {
cin >> n >> w >> b;
f[1][1] = 1;
for (long long i = 2; i <= w + b; ++i)
for (long long j = 1; j <= min(n, i); ++j)
f[i][j] = (1ll * f[i - 1][j] * j + f[i - 1][j - 1]) % mod;
num[0] = 1;
for (long long i = 1; i <= w + b; ++i) num[i] = 1ll * num[i - 1] * i % mod;
inv[w + b] = pp(num[w + b], mod - 2);
for (long long i = w + b - 1; i >= 0; --i)
inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
long long ans = 0;
for (long long i = 1; i < n - 1; ++i) {
long long cur = n - i - 1;
cur = 1ll * cur * calc(w, n - i) % mod * calc(b, i) % mod;
(ans += cur) %= mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000009;
int Ja[4005], Jb[4005], Ja1[4005], Jb1[4005];
int main() {
int n, a, b, i, ans = 0;
scanf("%d%d%d", &n, &a, &b);
Ja[a] = Jb[b] = Ja1[a - 1] = Jb1[b - 1] = 1;
for (i = a - 1; i >= 0; i--) Ja[i] = Ja[i + 1] * (i + 1LL) % mod;
for (i = b - 1; i >= 0; i--) Jb[i] = Jb[i + 1] * (i + 1LL) % mod;
for (i = a - 2; i >= 0; i--) Ja1[i] = Ja1[i + 1] * (i + 1LL) % mod;
for (i = b - 2; i >= 0; i--) Jb1[i] = Jb1[i + 1] * (i + 1LL) % mod;
for (i = max(n - b, 2); i < n && i <= a; i++)
ans = (ans + (long long)Ja1[i - 1] * Ja[a - i] % mod * Jb1[n - i - 1] %
mod * Jb[b - n + i] % mod * (i - 1)) %
mod;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int w, b, x, n;
long long int pp[3000000], jc[5050], jcn[5050], qq[3000000];
long long int modpow(long long int x, long long int y) {
long long int p = 1, s = x;
for (; y; y >>= 1) {
if (y & 1) (p *= s) %= 1000000009;
(s *= s) %= 1000000009;
}
return p;
}
long long int tm(long long int x, long long int y) {
return (x * y) % 1000000009;
}
long long int tm4(long long int x, long long int y, long long int z,
long long int w) {
return tm(tm(x, y), tm(z, w));
}
long long int C(long long int x, long long int y) {
return tm(jc[x], tm(jcn[x - y], jcn[y]));
}
int main() {
long long int i, j, k, ans = 0;
cin >> n >> w >> b;
for (i = jc[0] = 1; i <= 4000; i++) jc[i] = (jc[i - 1] * i) % 1000000009;
for (jcn[4000] = modpow(jc[4000], 1000000009 - 2), i = 4000; i; i--)
jcn[i - 1] = (jcn[i] * i) % 1000000009;
for (x = 1; x <= b && x <= n - 2; x++)
(ans +=
tm(n - x - 1, tm4(C(b - 1, x - 1), C(w - 1, n - x - 1), jc[b], jc[w]))) %=
1000000009;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = INT_MAX >> 1;
const int Mo = 1000000009;
int C[4100][4100];
long long fac[4100];
int main() {
int i, j;
fac[0] = C[0][0] = 1;
for (i = 1; i <= 4000; i++) {
fac[i] = fac[i - 1] * i % Mo;
C[i][0] = 1;
for (j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
if (C[i][j] >= Mo) C[i][j] -= Mo;
}
}
int N, w, b;
cin >> N >> w >> b;
long long ans = 0;
int l = max(1, N - w), r = min(b, N);
for (i = l; i <= r; i++)
ans = (ans + ((long long)C[b - 1][i - 1] * fac[b] % Mo) *
((long long)C[w - 1][N - i - 1] * fac[w] % Mo *
(N - i - 1) % Mo)) %
Mo;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 10000, M = 1000000009;
long long i, j, k, l, m, n, o, p, W, B, f[N], ans, cul;
inline long long ni(long long x) {
long long m = M - 2, ans = 1;
while (m) {
if (m & 1) ans = (ans * x) % M;
x = (x * x) % M;
m >>= 1;
}
return ans;
}
inline long long C(long long n, long long k) {
if (k > n) return 0;
long long ans = f[n];
ans = (ans * ni(f[n - k])) % M;
ans = (ans * ni(f[k])) % M;
return ans;
}
int main() {
cin >> n >> W >> B;
ans = 0;
f[0] = 1;
for (i = 1; i <= 4000; i++) f[i] = (f[i - 1] * i) % M;
for (i = 2; i <= n - 1; i++) {
j = n - i;
cul = (C(W - 1, i - 1) * f[W]) % M;
cul *= (C(B - 1, j - 1) * f[B]) % M;
cul %= M;
cul = (cul * (i - 1)) % M;
ans += cul;
if (ans >= M) ans -= M;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000009;
int n, b, w, C[4005][4005];
int main() {
long long ans, x, y;
cin >> n >> b >> w;
C[0][0] = 1;
for (int i = 1; i < 4001; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
if (C[i][j] >= mod) C[i][j] -= mod;
}
}
ans = 0ll;
for (int i = 1; i <= n - 2; i++) {
x = (long long)C[b - 1][n - i - 1];
y = (long long)C[w - 1][i - 1];
ans = (ans + (((x * y) % mod) * (n - i - 1)) % mod) % mod;
}
for (int i = 1; i <= b; i++) ans = (ans * (long long)i) % mod;
for (int i = 1; i <= w; i++) ans = (ans * (long long)i) % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4005;
const int moder = 1e9 + 9;
int fact[4005];
int c[4005][4005];
int n, w, b;
int ans = 0;
int main() {
scanf("%d%d%d", &n, &w, &b);
fact[0] = 1;
for (int i = 1; i < maxn; i++) fact[i] = 1LL * i * fact[i - 1] % moder;
for (int i = 0; i < maxn; i++) c[i][0] = 1;
for (int i = 0; i < maxn; i++)
for (int j = 1; j <= i; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
if (c[i][j] >= moder) c[i][j] -= moder;
}
for (int i = 2; i <= n; i++)
for (int j = i; j < n; j++) {
int len = j - i + 1;
if (n - len - 1 >= 0)
ans = (ans + (1LL * fact[b] * c[b - 1][len - 1] % moder) *
(1LL * fact[w] * c[w - 1][n - len - 1] % moder)) %
moder;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, w, b, s, W, B, ans, c[4005][4005];
long long C(int x, int y) {
if (c[x][y]) {
return c[x][y];
}
if (y == 0) {
return c[x][y] = 1;
}
return c[x][y] =
((x - 1 >= y ? C(x - 1, y) : 0) + C(x - 1, y - 1)) % 1000000009;
}
int main() {
scanf("%lld%lld%lld", &n, &w, &b);
W = B = 1;
for (long long i = 1; i <= w; i++) {
W *= i;
W %= 1000000009;
}
for (long long i = 1; i <= b; i++) {
B *= i;
B %= 1000000009;
}
for (long long i = max((long long)1, n - w); i <= b && i != n - 1; i++) {
ans = (ans + C(b - 1, i - 1) * B % 1000000009 * C(w - 1, n - i - 1) %
1000000009 * (n - i - 1) % 1000000009 * W % 1000000009) %
1000000009;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mo = 1000000009;
int n, a, b;
long long ans;
long long zxy(int a, int b) {
long long hzh = 1;
for (int i = 1; i <= a; i++) {
hzh *= b - i;
hzh %= mo;
}
for (int i = b; i > a; i--) {
hzh *= i;
hzh %= mo;
}
return hzh;
}
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i <= n - 2; i++)
if (i <= b && n - i <= a) {
long long tmp = zxy(n - i - 1, a);
long long tmp2 = zxy(i - 1, b);
long long sum = (tmp * tmp2) % mo;
sum *= n - i - 1;
sum %= mo;
ans += sum;
ans %= mo;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int C[4010][4010];
int main() {
int n = read(), w = read(), b = read();
for (int i = (0); i <= (4000); i++) C[i][0] = 1;
for (int i = (1); i <= (4000); i++)
for (int j = (1); j <= (4000); j++) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
if (C[i][j] >= 1000000009) C[i][j] -= 1000000009;
}
long long res = 0;
for (int i = (1); i <= (n - 1); i++) {
for (int j = (i + 1); j <= (n - 1); j++) {
res = (res + (long long)C[w - 1][n - j + i - 1] *
(long long)C[b - 1][j - i - 1]) %
1000000009;
}
}
for (int i = (1); i <= (w); i++) res = (res * i) % 1000000009;
for (int i = (1); i <= (b); i++) res = (res * i) % 1000000009;
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int fact[1000001], ifact[1000001];
long long int bpow(long long int x, long long int n) {
long long int ans = 1;
while (n > 0) {
if (n & 1) ans *= x;
x *= x;
ans %= 1000000009;
x %= 1000000009;
n /= 2;
}
return ans;
}
void pre_calc(long long int N) {
fact[0] = ifact[0] = 1;
for (long long int i = 1; i <= N; ++i) {
fact[i] = (fact[i - 1] * i) % 1000000009;
ifact[i] = bpow(fact[i], 1000000009 - 2);
}
}
long long int ncr(int n, int r) {
if (r < 0 or n < r) return 0;
long long int ans = fact[n];
ans = (ans * ifact[r]) % 1000000009;
ans = (ans * ifact[n - r]) % 1000000009;
return ans;
}
int main() {
long long int n, w, b, i, j, blen, wlen, temp, ans = 0;
pre_calc(100000);
cin >> n >> w >> b;
for (i = 1; i <= n - 2; i++) {
for (j = i + 1; j < n; j++) {
blen = j - i;
wlen = n - blen;
temp = ncr(b - 1, b - blen);
temp *= ncr(w - 1, w - wlen);
temp %= 1000000009;
ans += temp;
ans %= 1000000009;
}
}
ans *= fact[w];
ans %= 1000000009;
ans *= fact[b];
ans %= 1000000009;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 9;
long long c[4005][4005];
void getc() {
memset(c, 0, sizeof(c));
c[0][0] = 1;
for (int i = 1; i < 4001; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
}
long long a[4005];
void geta() {
a[0] = 1;
a[1] = 1;
for (long long i = 2; i <= 4000; i++) a[i] = a[i - 1] * i % mod;
}
int main() {
getc();
geta();
int n, w, b;
while (scanf("%d%d%d", &n, &w, &b) == 3) {
int x = max(1, n - w), y = min(b, n - 2);
long long ans = 0;
for (int i = x; i <= y; i++) {
ans = (ans +
c[b - 1][i - 1] * c[w - 1][n - i - 1] % mod * (n - i - 1) % mod) %
mod;
}
ans = ans * a[w] % mod * a[b] % mod;
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 4000;
const int MAX_N2 = MAX_N * 2;
const int MOD = 1000000009;
int fs[MAX_N2 + 1], invfs[MAX_N2 + 1];
int powmod(int a, int n) {
int pm = 1;
while (n > 0) {
if (n & 1) pm = (long long)pm * a % MOD;
a = (long long)a * a % MOD;
n >>= 1;
}
return pm;
}
inline int npk(int n, int k) { return (long long)fs[n] * invfs[n - k] % MOD; }
inline int nck(int n, int k) {
return (long long)fs[n] * invfs[n - k] % MOD * invfs[k] % MOD;
}
inline int nhk(int n, int k) { return nck(n + k - 1, k); }
int main() {
fs[0] = invfs[0] = 1;
for (int i = 1; i <= MAX_N2; i++) {
fs[i] = (long long)fs[i - 1] * i % MOD;
invfs[i] = powmod(fs[i], MOD - 2);
}
int n, w, b;
scanf("%d%d%d", &n, &w, &b);
int sum = 0;
for (int i = max(2, n - b), j = n - i; i <= w && j >= 1; i++, j--) {
int d = (long long)nhk(i, w - i) * nhk(j, b - j) % MOD * (i - 1) % MOD;
sum = (sum + d) % MOD;
}
int ans = (long long)sum * fs[w] % MOD * fs[b] % MOD;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000009;
int n, w, b;
long long c[4005][4005];
long long ans = 0;
int main() {
int i, j, k;
scanf("%d%d%d", &n, &w, &b);
for (i = 0; i < (4001); i++) {
for (j = 0; j < (i + 1); j++) {
if (j == 0 || j == i) {
c[i][j] = 1;
continue;
}
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
for (i = 1; i < n; i++) {
for (j = 1; i + j < n; j++) {
k = n - i - j;
ans = (ans + c[w - 1][i + k - 1] * c[b - 1][j - 1]) % mod;
}
}
for (i = 1; i <= (w); i++) ans = ans * i % mod;
for (i = 1; i <= (b); i++) ans = ans * i % mod;
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int choose(int k, int n) {
static int F[4003][4003], FF[4003][4003];
if (k == 0 || k == n) return 1;
if (k < 0 || k > n) return 0;
if (FF[k][n]++) return F[k][n];
F[k][n] = (choose(k - 1, n - 1) + choose(k, n - 1)) % 1000000009;
return F[k][n];
}
int fact(int n) {
static int F[4003], FF[4003];
if (n == 0) return 1;
if (FF[n]++) return F[n];
F[n] = 1LL * fact(n - 1) * n % 1000000009;
return F[n];
}
long long f(int m, int n) {
long long r = 1LL * fact(m) * choose(n - 1, m - 1) % 1000000009;
return r;
}
int n, A, B;
long long Answer = 0;
int main() {
scanf("%d%d%d", &n, &A, &B);
for (int i = 1; i <= n - 2; i++) {
Answer +=
1LL * f(B, i) * f(A, n - i) % 1000000009 * (n - i - 1) % 1000000009;
Answer %= 1000000009;
}
cout << Answer << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 9;
long long C[4010][4010];
long long n, x, y;
long long func(int a, int b) { return C[a - 1][b - 1]; }
int main() {
cin >> n >> x >> y;
for (int i = 0; i <= 4005; i++) {
for (int j = 0; j <= i; j++) {
if (i == j) {
C[i][j] = 1;
} else if (j == 0) {
C[i][j] = 1;
} else {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
}
}
long long ans = 0ll;
for (int i = 1; i < n; i++) {
for (int j = 1; i + j < n; j++) {
int k = n - i - j;
ans = (ans + func(x, i + k) * func(y, j)) % MOD;
}
}
for (int i = 1; i <= x; i++) {
ans = ans * i % MOD;
}
for (int i = 1; i <= y; i++) {
ans = ans * i % MOD;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 9;
int n, m, z, x, y, mai, maj;
long long f[4005][4005], c[4005][4005], jc[4005], ans;
int main() {
scanf("%d%d%d", &n, &x, &y);
c[0][0] = 1;
for (int i = 1; i <= 4000; ++i)
for (int j = 0; j <= i; ++j) {
if (j != 0)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
else
c[i][j] = c[i - 1][j];
}
jc[0] = 1;
for (int i = 1; i <= 4000; ++i) jc[i] = (jc[i - 1] * i) % mod;
mai = min(x - 1, n - 2);
ans = 0;
for (int i = 1; i <= mai; ++i) {
maj = min(x - 1, n - i - 1);
for (int j = 1; j <= maj; ++j)
ans = (ans + c[y - 1][n - i - j - 1] * c[x - 1][i + j - 1]) % mod;
}
ans = ans * jc[x] % mod * jc[y] % mod;
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int md = 1000000009;
long long c[4010][4010];
long long f(int i, int j) { return c[i - 1][j - 1]; }
int main() {
int n, w, b, k;
for (int i = 0; i < 4010; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i) {
c[i][j] = 1;
} else {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % md;
}
}
}
cin >> n >> w >> b;
long long ans = 0;
for (int i = 1; i < n; i++) {
for (int j = 1; j < n - i; j++) {
k = n - i - j;
ans = (ans + f(w, i + k) * f(b, j)) % md;
}
}
for (int i = 1; i <= w; i++) {
ans = ans * i % md;
}
for (int i = 1; i <= b; i++) {
ans = ans * i % md;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0U >> 1;
const long long INF = ~0ULL >> 1;
;
const double pi = acos(-1.0);
template <class T>
inline T sqr(T a) {
return a * a;
}
template <class T>
inline void read(T &n) {
char c;
for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar())
;
n = c - '0';
for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
}
int Pow(int base, int n, int mo) {
if (n == 0) return 1;
if (n == 1) return base;
int tmp = Pow(base, n >> 1, mo);
tmp = (long long)tmp * tmp % mo;
if (n & 1) tmp = (long long)tmp * base % mo;
return tmp;
}
struct point {
int x, y;
point() {}
point(int _x, int _y) : x(_x), y(_y) {}
};
const int mo = 1000000009, maxn = 5000;
long long ans;
int n, a, b, inv[maxn], fac[maxn], f[maxn], g[maxn];
int C(int n, int m) {
if (n < m) return 0;
if (n == 0) return 1;
long long ret = fac[n];
ret = ret * inv[m] % mo;
ret = ret * inv[n - m] % mo;
return int(ret);
}
int main() {
scanf("%d%d%d", &n, &a, &b);
fac[0] = 1;
for (int i = (1); i <= (4000); ++i) fac[i] = (long long)fac[i - 1] * i % mo;
for (int i = (0); i <= (4000); ++i) inv[i] = Pow(fac[i], mo - 2, mo);
for (int i = (1); i <= (n); ++i) f[i] = C(a - 1, i - 1);
for (int i = (1); i <= (n); ++i) g[i] = C(b - 1, i - 1);
for (int i = (1); i <= (n); ++i)
for (int j = (i + 1); j <= (n - 1); ++j) {
ans += (long long)f[i + n - j] * g[j - i] % mo;
ans %= mo;
}
ans = ans * fac[a] % mo * fac[b] % mo;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 1000000009, maxn = 4010;
int cw[maxn], cb[maxn], inv[maxn], prm[maxn], tot, n, m, w, b;
int pow(int x, int k) {
int ret = 1;
for (; k; k >>= 1, x = (long long)x * x % p)
if (k & 1) ret = (long long)ret * x % p;
return ret;
}
int main() {
int ans = 0;
scanf("%d%d%d", &n, &w, &b);
m = max(w, b);
inv[1] = 1;
for (int i = 2; i <= m; i++) {
if (!inv[i]) {
inv[i] = pow(i, p - 2);
prm[++tot] = i;
}
for (int j = 1; i * prm[j] <= m; j++) {
inv[i * prm[j]] = (long long)inv[i] * inv[prm[j]] % p;
if (i % prm[j] == 0) break;
}
}
cw[0] = 1;
for (int i = 1; i < w; i++)
cw[i] = (long long)cw[i - 1] * inv[i] % p * (w - i) % p;
cb[0] = 1;
for (int i = 1; i < b; i++)
cb[i] = (long long)cb[i - 1] * inv[i] % p * (b - i) % p;
for (int i = max(1, n - w); i <= n - 2 && i <= b; i++)
ans = (ans + (long long)(n - i - 1) * cw[n - i - 1] % p * cb[i - 1]) % p;
for (int i = 2; i <= b; i++) ans = (long long)ans * i % p;
for (int i = 2; i <= w; i++) ans = (long long)ans * i % p;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, w, b;
int C[8020][8020], f[8020 << 1];
void init() {
C[0][0] = 1;
for (int i = 1; i < 8020; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
if (C[i][j] >= 1000000009) C[i][j] -= 1000000009;
}
}
f[0] = 1;
for (int i = 1; i < 8020; i++) f[i] = 1LL * f[i - 1] * i % 1000000009;
}
int main() {
init();
cin >> n >> w >> b;
long long ans = 0;
for (int i = 1; i < w; i++) {
ans += 1LL * C[w + b - 3][n - 3] * C[w][i] % 1000000009 * f[i] %
1000000009 * f[b] % 1000000009 * f[w - i] % 1000000009;
if (ans >= 1000000009) ans -= 1000000009;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int get() {
int f = 0, v = 0;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') break;
if (ch == '-')
f = 1;
else
v = ch - '0';
while (isdigit(ch = getchar())) v = v * 10 + ch - '0';
if (f == 1)
return -v;
else
return v;
}
const int maxn = 4003, mod = 1000000009;
int n, w, b, m;
long long fac[maxn], inv[maxn], ans = 0;
long long C(int k, int n) {
if (n < k) return 0;
return fac[n] * inv[n - k] % mod * inv[k] % mod;
}
long long Pow(long long a, long long b) {
long long res = 1;
for (; b; b /= 2, a = a * a % mod)
if (b & 1) res = res * a % mod;
return res;
}
int main() {
scanf("%d%d%d", &n, &w, &b);
m = max(w, b);
fac[0] = 1;
for (int i = 1; i <= m; i++) fac[i] = fac[i - 1] * i % mod;
inv[m] = Pow(fac[m], mod - 2);
for (int i = m - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
for (int i = 1; i <= n - 2; i++)
ans =
(C(n - i - 1, w - 1) * (n - i - 1) % mod * C(i - 1, b - 1) + ans) % mod;
cout << ans * fac[b] % mod * fac[w] % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4010, mod = 1e9 + 9;
long long ksm(long long sum, int num) {
long long ans = 1;
while (num) {
if (num & 1) ans = ans * sum % mod;
sum = sum * sum % mod;
num >>= 1;
}
return ans;
}
int i, j, k, n, m, a, b;
long long jc[maxn], ny[maxn];
long long ans = 0;
void init() {
jc[0] = 1;
for (int i = 1; i < maxn; i++) jc[i] = jc[i - 1] * i % mod;
ny[maxn - 1] = ksm(jc[maxn - 1], mod - 2);
for (int i = maxn - 2; i >= 0; i--) ny[i] = ny[i + 1] * (i + 1) % mod;
}
long long C(int A, int B) {
if (B > A) return 0;
return jc[A] * ny[B] % mod * ny[A - B] % mod;
}
long long make(int A, int B) { return C(A - 1, B - 1) % mod; }
int main() {
cin >> n >> a >> b;
init();
for (i = 2; i < n; i++)
for (j = i; j < n; j++) {
int lenb = (j - i) + 1, lena = n - lenb;
ans += make(b, lenb) * make(a, lena) % mod;
ans %= mod;
}
cout << ans * (jc[a] * jc[b] % mod) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, b;
int fac[4044], c[4044][4044];
struct modular_arithmetic {
int mod;
modular_arithmetic() { mod = 1000000009; }
int add(int x, int y) { return (x += y) < mod ? x : x - mod; }
int mul(int x, int y) { return (int)((long long int)x * y % mod); }
};
modular_arithmetic ma;
int f(int n, int m) { return ma.mul(fac[m], c[m - 1][n - 1]); }
int main() {
scanf("%d%d%d", &n, &w, &b);
int lim = max(w, b);
fac[0] = fac[1] = 1;
for (int i = 2; i <= lim; i++) fac[i] = ma.mul(fac[i - 1], i);
for (int i = 0; i <= lim; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) c[i][j] = ma.add(c[i - 1][j], c[i - 1][j - 1]);
}
int ans = 0;
for (int lb = max(1, n - w); lb <= min(n - 2, b); lb++) {
int cb = 0;
cb = ma.add(cb, f(lb, b));
int cw = 0;
cw = ma.add(cw, f(n - lb, w));
cw = ma.mul(cw, n - lb - 1);
ans = ma.add(ans, ma.mul(cb, cw));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = INT_MAX >> 1;
const int Mo = 1000000009;
long long C[4100][4100];
long long fac[4100];
int main() {
int i, j;
fac[0] = C[0][0] = 1;
for (i = 1; i <= 4000; i++) {
fac[i] = fac[i - 1] * i % Mo;
C[i][0] = 1;
for (j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
if (C[i][j] >= Mo) C[i][j] -= Mo;
}
}
int N, w, b;
cin >> N >> w >> b;
long long ans = 0;
int l = max(1, N - w), r = min(b, N);
for (i = l; i <= r; i++)
ans = (ans + ((long long)C[b - 1][i - 1] * fac[b] % Mo) *
((long long)C[w - 1][N - i - 1] * fac[w] % Mo *
(N - i - 1) % Mo)) %
Mo;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int INP, AM, REACHEOF;
char BUF[(1 << 12) + 1], *inp = BUF;
const long double PI = acos((long double)-1.0);
const long long MOD = 1000000009LL;
int n, w, b;
long long gt[4011], revgt[4011];
long long power(long long x, long long k) {
if (k == 0) return 1;
if (k == 1) return x % MOD;
long long mid = power(x, k >> 1);
mid = (mid * mid) % MOD;
if (k & 1)
return (mid * x) % MOD;
else
return mid;
}
long long get(int n, int k) {
return gt[n] * gt[n - 1] % MOD * revgt[k - 1] % MOD * revgt[n - k] % MOD;
}
int main() {
gt[0] = 1;
for (int i = (1), _b = (4000); i <= _b; i++) gt[i] = (gt[i - 1] * i) % MOD;
for (int i = (0), _b = (4000); i <= _b; i++) revgt[i] = power(gt[i], MOD - 2);
while (cin >> n >> w >> b) {
long long res = 0;
for (int y = (1), _b = (n - 2); y <= _b; y++)
if (b >= y && n - y <= w) {
int xz = n - y;
long long now = (n - y) - 2 + 1;
now = (now * get(w, xz)) % MOD * get(b, y) % MOD;
res = (res + now) % MOD;
}
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T[50], J, m, n, i, j, k, l, r, K, K0, x, y, first, second, xx, yy;
int D[4001][4001];
long long A = 0;
int main() {
cin >> n >> x >> y;
m = (x > y ? x : y);
D[0][0] = 1;
for (i = 1; i <= m; i++)
for (j = i; j <= m; j++)
D[i][j] = (D[i][j - 1] + D[i - 1][j - 1]) % 1000000009ll;
for (i = 2; i < n; i++)
for (j = i; j < n; j++)
A = (A + (long long)D[j - i + 1][y] * D[n - j + i - 1][x]) % 1000000009ll;
for (i = 1; i <= x; i++) A = (A * i) % 1000000009ll;
for (i = 1; i <= y; i++) A = (A * i) % 1000000009ll;
cout << A << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long wdp[4001][4001], bdp[4001][4001];
long long mod = 1e9 + 9;
int main() {
int n, b, w;
cin >> n >> w >> b;
wdp[0][0] = 1;
bdp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= w; j++) {
wdp[i][j] = (wdp[i - 1][j - 1] + wdp[i][j - 1]) * (w - j + 1);
wdp[i][j] %= mod;
}
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= b; j++) {
bdp[i][j] = (bdp[i - 1][j - 1] + bdp[i][j - 1]) * (b - j + 1);
bdp[i][j] %= mod;
}
}
long long ans = 0;
for (int i = 1; i < n; i++) {
ans = (ans + (wdp[i][w] * bdp[n - i][b] % mod) * (i - 1)) % mod;
;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4003, P = 1e9 + 9;
int n, w, b, jc[N << 1];
inline void in(register int &x) {
int f = 0;
x = 0;
char c = getchar();
while (c < '0' || c > '9') f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
x = f ? -x : x;
}
inline int mi(register int x, register int k) {
register int s = 1;
while (k) {
if (k & 1) s = (long long)s * x % P;
x = (long long)x * x % P, k >>= 1;
}
return s;
}
inline int inv(register int x) { return mi(x, P - 2); }
inline int C(register int m, register int n) {
return (long long)jc[n] * inv(jc[n - m]) % P * inv(jc[m]) % P;
}
int main() {
in(n), in(w), in(b), jc[0] = 1;
for (register int i = 1; i <= w + b; ++i)
jc[i] = (long long)jc[i - 1] * i % P;
printf("%d\n",
(long long)C(n - 3, w + b - 3) * (w - 1) % P * jc[w] % P * jc[b] % P);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e3 + 5, mod = 1e9 + 9;
long long fac[maxn], ine[maxn];
int n, w, b;
long long ans;
long long pow(long long x, int k) {
long long ret = 1;
for (int i = k; i; i >>= 1, x = x * x % mod)
if (i & 1) ret = ret * x % mod;
return ret;
}
void prepare() {
int m = max(n, max(w, b));
fac[0] = 1;
for (int i = 1; i <= m; i++) fac[i] = fac[i - 1] * i % mod;
ine[m] = pow(fac[m], mod - 2);
for (int i = m - 1; i >= 0; i--) ine[i] = ine[i + 1] * (i + 1) % mod;
}
long long C(int x, int y) { return fac[x] * ine[x - y] % mod * ine[y] % mod; }
int main() {
scanf("%d%d%d", &n, &w, &b);
prepare();
for (int i = 1; i <= n - 2; i++) {
int j = n - i;
if (i > b || j > w) continue;
ans = (ans + C(b - 1, i - 1) * C(w - 1, j - 1) % mod * (j - 1) % mod) % mod;
}
ans = ans * fac[w] % mod * fac[b] % mod;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long JC[4001], ans;
int n, C[4001][4001], m, p;
inline int Add(int x) { return x < 1000000009 ? x : x - 1000000009; }
int main() {
cin >> n >> m >> p;
for (int i = 0; i < 4001; i++) C[i][0] = 1;
for (int i = 1; i < 4001; i++)
for (int j = 1; j <= i; j++) C[i][j] = Add(C[i - 1][j - 1] + C[i - 1][j]);
JC[0] = 1;
for (int i = 1; i < 4001; i++) JC[i] = JC[i - 1] * i % 1000000009;
for (int i = 2; i < n; i++)
ans = (ans + C[m - 1][i - 1] * JC[m] % 1000000009 * C[p - 1][n - i - 1] %
1000000009 * JC[p] % 1000000009 * (i - 1) % 1000000009) %
1000000009;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int qp(int a, int b) {
int ans = 1;
do {
if (b & 1) ans = 1ll * ans * a % 1000000009;
a = 1ll * a * a % 1000000009;
} while (b >>= 1);
return ans;
}
int main() {
int n, w, b;
scanf("%d%d%d", &n, &w, &b);
int ans = w - 1;
for (int i = 1; i <= w; i++) ans = 1ll * ans * i % 1000000009;
for (int i = 1; i <= b; i++) ans = 1ll * ans * i % 1000000009;
for (int i = w + b - 3; i >= w + b - n + 1; i--)
ans = 1ll * ans * i % 1000000009;
for (int i = 1; i <= n - 3; i++)
ans = 1ll * ans * qp(i, 1000000009 - 2) % 1000000009;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 4005;
const int Mod = 1000000009;
int n, w, b;
long long jc(int x) {
long long res = 1;
int i;
for (i = 1; i <= x; i++) {
res *= i;
res %= Mod;
}
return res;
}
long long inv(long long x) {
int ci = Mod - 2;
long long res = 1;
while (ci) {
if (ci & 1) {
res *= x;
res %= Mod;
}
x *= x;
x %= Mod;
ci >>= 1;
}
return res;
}
long long zuhe(int x, int y) {
long long res = jc(x);
res *= inv(jc(y));
res %= Mod;
res *= inv(jc(x - y));
res %= Mod;
return res;
}
int main() {
int i, j;
scanf("%d%d%d", &n, &w, &b);
long long ans = w - 1;
ans *= jc(w);
ans %= Mod;
ans *= jc(b);
ans %= Mod;
ans *= zuhe(w + b - 3, n - 3);
ans %= Mod;
int ansx = ans;
printf("%d\n", ansx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 4010;
const int MOD = 1000000009;
int n, w, b;
long long p[MaxN], r[MaxN];
long long power(long long x, long long y) {
if (!y) return 1;
long long t = power(x, y / 2);
t = t * t % MOD;
if (y & 1) t = t * x % MOD;
return t;
}
long long C(long long n, long long m) {
return p[n] * r[m] % MOD * r[n - m] % MOD;
}
int main() {
cin >> n >> w >> b;
for (int i = p[0] = r[0] = 1; i < MaxN; ++i) {
p[i] = p[i - 1] * i % MOD;
r[i] = power(p[i], MOD - 2);
}
long long ans = 0;
for (int i = max(1, n - w); i <= min(n - 2, b); ++i)
ans += p[w] * p[b] % MOD * (n - i - 1) % MOD * C(b - 1, i - 1) % MOD *
C(w - 1, n - i - 1) % MOD;
cout << ans % MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int C[4100][4100];
int F[4100];
int main() {
int n, w, b;
scanf("%d%d%d", &n, &w, &b);
int ans = 0;
for (int i = 0; i < 4100; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] >= 1000000009) C[i][j] -= 1000000009;
}
}
F[0] = 1;
for (int i = 1; i < 4100; i++) {
F[i] = (long long)F[i - 1] * i % 1000000009;
}
for (int j = 1; j <= min(b, n - 2); j++) {
if (w >= n - j) {
long long cur =
((long long)C[w - 1][w - (n - j)] * C[b - 1][b - j]) % 1000000009;
cur = cur * (n - j - 1) % 1000000009;
cur = cur * F[w] % 1000000009;
cur = cur * F[b] % 1000000009;
ans += (int)cur;
if (ans >= 1000000009) ans -= 1000000009;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200004;
long long inv[N], fac[N], fnv[N], mod = 1000000009;
long long C(int n, int m) {
if (n < m) return 0;
return fac[n] * fnv[m] % mod * fnv[n - m] % mod;
}
int n, m, k;
int main() {
for (int i = 0; i < 2; i++) fac[i] = inv[i] = fnv[i] = 1;
for (int i = 2; i < N; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
fnv[i] = fnv[i - 1] * inv[i] % mod;
}
scanf("%d %d %d", &n, &m, &k);
long long ans = 0;
for (int i = 1; i <= m - 1; i++) {
long long t = C(m + k - 3, n - 3) * C(m, i) % mod * fac[i] % mod *
fac[m - i] % mod * fac[k] % mod;
ans = (ans + t) % mod;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long c[4002][4002], b, w, n, ans;
int main() {
for (int i = 1; i <= 4000; i++) {
c[i][1] = c[i][i] = 1;
for (int j = 2; j < i; j++) {
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
if (c[i][j] >= 1000000009) c[i][j] -= 1000000009;
}
}
scanf("%I64d%I64d%I64d", &n, &w, &b);
for (int i = 1; i < n; i++) {
for (int j = 1; j < n - i; j++) {
ans += c[w][n - j] * c[b][j];
ans %= 1000000009;
}
}
for (long long i = 2; i <= w; i++) ans *= i, ans %= 1000000009;
for (long long i = 2; i <= b; i++) ans *= i, ans %= 1000000009;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long max(long long a, long long b) { return a > b ? a : b; }
inline long long min(long long a, long long b) { return a > b ? b : a; }
template <typename T>
inline int read(T& res) {
long long x = 0, f = 1, flag = 0;
char ch;
flag = ch = getchar();
if (flag == -1) return -1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
flag = ch = getchar();
if (flag == -1) return -1;
}
while (ch >= '0' && ch <= '9' && flag != -1) {
x = (x << 1) + (x << 3) + (ch ^ 48);
flag = ch = getchar();
}
res = x * f;
return flag;
}
template <typename T, typename... Args>
inline int read(T& t, Args&... a) {
int res;
res = read(t);
if (res == -1) return -1;
res = read(a...);
return res;
}
const int maxn = 5511, mod = 1e9 + 9;
long long n, m, k;
long long qpow(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = (ans * x) % mod;
y >>= 1;
x = (x * x) % mod;
}
return ans % mod;
}
long long A1, A2, C1[maxn], C2[maxn], w, b;
inline void solve() {
long long ans = 0, mx = max(w, b);
A1 = A2 = 1;
for (int i = 2; i <= w; i++) A1 = (A1 * i) % mod;
for (int i = 2; i <= b; i++) A2 = (A2 * i) % mod;
C1[2] = w - 1;
C2[2] = b - 1;
C1[1] = C2[1] = 1;
for (int i = 3; i <= mx; i++) {
long long inv = qpow(i - 1, mod - 2);
C1[i] = (C1[i - 1] * (w - i + 1) % mod * inv) % mod,
C2[i] = (C2[i - 1] * (b - i + 1) % mod * inv) % mod;
}
int lim = max(1, n - w);
for (int x = min(n - 2, b); x >= lim; x--) {
ans = (ans + (((((n - x - 1) * A1 % mod) * C1[n - x] % mod) * A2) % mod) *
C2[x]) %
mod;
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
while (cin >> n >> w >> b) solve();
}
|
#include <bits/stdc++.h>
const long long MOD = 1e9 + 9;
const int NMAX = 4020;
int fac[NMAX], inv[NMAX];
int n, w, b, ans;
void calfac() {
fac[0] = 1;
for (int i = 1; i < NMAX; i++) fac[i] = (long long)i * fac[i - 1] % MOD;
}
void calinv() {
inv[0] = inv[1] = 1;
for (int i = 2; i < NMAX; i++) {
inv[i] = MOD - (long long)(MOD / i) * inv[MOD % i] % MOD;
}
for (int i = 1; i < NMAX; i++) inv[i] = (long long)inv[i - 1] * inv[i] % MOD;
}
int cnm(int n, int m) {
return (long long)fac[n] * inv[m] % MOD * inv[n - m] % MOD;
}
int main() {
calfac();
calinv();
scanf("%d%d%d", &n, &w, &b);
for (int i = 1; i <= b; i++) {
if (n - i >= 2 && n - i <= w)
ans = ((long long)ans + (long long)(n - i - 1) * cnm(b - 1, i - 1) % MOD *
cnm(w - 1, n - i - 1) % MOD) %
MOD;
}
ans = (long long)ans * fac[w] % MOD * fac[b] % MOD;
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000009;
long long fac[8080];
long long ex(int a, int n) {
if (n == 0) return 1;
long long res = ex(a, n / 2);
res *= res;
res %= mod;
if (n % 2 == 1) res *= a;
res %= mod;
return res;
}
long long inv(int a) { return ex(a, mod - 2); }
long long C(int n, int k) {
long long res = fac[n];
res *= inv(fac[k]);
res %= mod;
res *= inv(fac[n - k]);
return res % mod;
}
int main() {
fac[0] = 1;
for (int i = 1; i < 8080; i++) {
fac[i] = fac[i - 1] * i;
fac[i] %= mod;
}
int N, W, B;
scanf("%d%d%d", &N, &W, &B);
long long ans = 0;
long long coe = (fac[W] * fac[B]) % mod;
for (int x = 1; x <= N - 2; x++) {
if (x > B || N - x > W) continue;
long long tmp = C(B - 1, x - 1) * C(W - 1, N - x - 1);
tmp %= mod;
tmp *= (N - x - 1);
tmp %= mod;
ans += coe * tmp;
ans %= mod;
}
ans += mod;
ans %= mod;
printf("%d\n", (int)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int modi = 1000000009;
const int N = 4010;
int n, w, b, c, WC[N], BC[N], ni[N], ans, i;
int main() {
scanf("%d%d%d", &n, &w, &b);
for (ni[1] = 1, i = 2; i < N; i++)
ni[i] = (-(modi / i) * (long long)ni[modi % i] % modi + modi) % modi;
c = 1;
for (i = 1; i <= w; i++) c = (long long)c * i % modi;
for (i = 1; i <= b; i++) c = (long long)c * i % modi;
for (WC[0] = 1, i = 1; i <= w - 1; i++)
WC[i] = (long long)WC[i - 1] * (w - i) % modi * ni[i] % modi;
for (BC[0] = 1, i = 1; i <= b - 1; i++)
BC[i] = (long long)BC[i - 1] * (b - i) % modi * ni[i] % modi;
for (i = 1; i <= min(b, n - 1); i++) {
ans = (ans + (long long)BC[i - 1] * WC[n - i - 1] % modi * c % modi *
(n - i - 1)) %
modi;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, b;
long long f[4010], ans, c[4010][4010];
int main() {
scanf("%d%d%d", &n, &w, &b), f[0] = 1;
for (int i = 0; c[i][0] = 1, i <= 4000; i++)
for (int j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000009;
for (int i = 1; i <= n; i++)
(ans += c[w - 1][n - 1 - i] * c[b - 1][i - 1] % 1000000009 * (n - 1 - i) %
1000000009) %= 1000000009;
for (int i = 1; i <= w; i++) (ans *= i) %= 1000000009;
for (int i = 1; i <= b; i++) (ans *= i) %= 1000000009;
printf("%lld\n", ans);
fclose(stdin), fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000009, N = 4005;
int cal[N][N], fac[N];
inline int add(int a, int b) {
if (a < 0) a += mod;
if (b < 0) b += mod;
int ret = a + b;
if (ret >= mod)
return ret %= mod;
else
return ret;
}
inline int mul(int a, int b) {
if (a < 0) a += mod;
if (b < 0) b += mod;
long long ret = (long long)a * b;
if (ret >= mod)
return ret % mod;
else
return ret;
}
int main() {
memset(cal, 0, sizeof(cal));
cal[0][0] = 1;
fac[0] = 1;
for (int i = 1; i < N; i++) {
fac[i] = mul(fac[i - 1], i);
cal[i][0] = cal[i][i] = 1;
for (int j = 1; j < i; j++) {
cal[i][j] = add(cal[i - 1][j], cal[i - 1][j - 1]);
}
}
int n, a, b, ans = 0;
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i < n - 1; i++) {
for (int j = i + 2; j <= n; j++) {
int cntb = j - i - 1, cnta = n - cntb;
if (cntb > b) break;
if (cnta > a) continue;
ans = add(ans, mul(mul(cal[a - 1][cnta - 1], fac[a]),
mul(cal[b - 1][cntb - 1], fac[b])));
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, w, b, C[4011][4011], ans;
int main() {
C[0][1] = 1;
for (int i = 1; i <= 4000; i++)
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000009;
cin >> n >> w >> b;
for (int i = 1; i <= min(n - 2, b); i++)
ans =
(ans + C[b][i] * C[w][n - i] % 1000000009 * (n - i - 1) % 1000000009) %
1000000009;
for (int i = 1; i <= w; i++) ans = ans * i % 1000000009;
for (int i = 1; i <= b; i++) ans = ans * i % 1000000009;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 9;
template <class T>
inline bool read(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
const int maxn = 4100;
long long c[maxn][maxn], fac[maxn];
void init(long long m) {
for (int i = 0; i <= m; i++) {
c[i][0] = 1;
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
fac[0] = 1;
for (long long i = 1; i <= m; i++) {
fac[i] = (fac[i - 1] * i) % mod;
}
}
int main() {
long long n, w, b;
read(n), read(w), read(b);
init(max(n, max(w, b)) + 1);
long long ans = 0;
for (long long i = 1; i <= b; i++) {
long long tmp = n - i - 1;
if (!tmp) break;
tmp = (tmp * c[b - 1][i - 1]) % mod;
tmp = (tmp * fac[b]) % mod;
tmp = (tmp * c[w - 1][n - i - 1]) % mod;
tmp = (tmp * fac[w]) % mod;
ans = (ans + tmp) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <int MOD = 1000000009>
struct ModInteger {
int x;
ModInteger(int x = 0) : x(x) {}
int getValue() { return x; }
void operator=(const int v) { x = v; }
ModInteger operator+(const int v) {
return ModInteger(x >= MOD - v ? x - MOD + v : x + v);
}
ModInteger operator+(const ModInteger &rhs) {
return ModInteger(x >= MOD - rhs.x ? x - MOD + rhs.x : x + rhs.x);
}
void operator+=(const int v) { x = x >= MOD - v ? x - MOD + v : x + v; }
void operator+=(const ModInteger &rhs) {
x = x >= MOD - rhs.x ? x - MOD + rhs.x : x + rhs.x;
}
ModInteger operator-(const int v) {
return ModInteger(x < v ? x - v + MOD : x - v);
}
ModInteger operator-(const ModInteger &rhs) {
return ModInteger(x < rhs.x ? x - rhs.x + MOD : x - rhs.x);
}
void operator-=(const int v) { x = x < v ? x - v + MOD : x - v; }
void operator-=(const ModInteger &rhs) {
x = x < rhs.x ? x - rhs.x + MOD : x - rhs.x;
}
ModInteger operator*(const int v) {
return ModInteger((long long)x * v % MOD);
}
ModInteger operator*(const ModInteger &rhs) {
return ModInteger((long long)x * rhs.x % MOD);
}
void operator*=(const int v) { x = (long long)x * v % MOD; }
void operator*=(const ModInteger &rhs) { x = (long long)x * rhs.x % MOD; }
ModInteger operator^(int e) {
ModInteger res = ModInteger(1), a = *this;
for (; e; e >>= 1, a *= a)
if (e & 1) res *= a;
return res;
}
void operator^=(int e) {
ModInteger res = ModInteger(1), a = *this;
for (; e; e >>= 1, a *= a)
if (e & 1) res *= a;
x = res.x;
}
ModInteger operator/(const int v) {
return ModInteger((long long)x * (ModInteger(v) ^ (MOD - 2)).getValue() %
MOD);
}
ModInteger operator/(const ModInteger &rhs) {
ModInteger a = rhs;
return ModInteger((long long)x * (a ^ (MOD - 2)).getValue() % MOD);
}
void operator/=(const int v) {
x = (long long)x * (ModInteger(v) ^ (MOD - 2)).getValue() % MOD;
}
void operator/=(const ModInteger &rhs) {
ModInteger a = rhs;
x = (long long)x * (a ^ (MOD - 2)).getValue() % MOD;
}
};
const int MAXN = 4096;
ModInteger<> fact[MAXN];
int n, w, b;
ModInteger<> calc(int n, int m) {
if (n > m) return ModInteger<>(0);
return fact[m - 1] / fact[n - 1] / fact[m - n];
}
int main() {
fact[0] = ModInteger<>(1);
for (int i = (1); i < (MAXN); i++) fact[i] = fact[i - 1] * i;
scanf("%d%d%d", &n, &w, &b);
ModInteger<> res = ModInteger<>(0);
for (int i = (2); i < (n); i++) res += calc(i, w) * calc(n - i, b) * (i - 1);
res *= fact[w] * fact[b];
printf("%d\n", res.getValue());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1e9 + 9;
int N, W, B;
long long POW(long long base, int exp) {
if (!exp) return 1;
if (exp & 1) return POW(base, exp - 1) * base % mo;
long long tmp(POW(base, exp >> 1));
return tmp * tmp % mo;
}
long long f(int x) {
long long ret(1);
for (int i = 2; i <= x; i++) ret *= i, ret %= mo;
return ret;
}
long long C(int n, int m) {
return f(n) * POW(f(m) * f(n - m) % mo, mo - 2) % mo;
}
int main() {
scanf("%d%d%d", &N, &W, &B);
printf("%I64d\n", f(W) * f(B) % mo * (W - 1) % mo * C(W + B - 3, N - 3) % mo);
return 0;
}
|
#include <bits/stdc++.h>
long long f[200001], C[4001][4001];
int main() {
int n, w, b;
scanf("%d%d%d", &n, &w, &b);
C[0][0] = 1;
for (int i = 1; i <= 4000; ++i)
for (int j = 0; j <= 4000; ++j) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
if (C[i][j] >= 1000000009) C[i][j] -= 1000000009;
}
f[0] = 1;
for (int i = 1; i <= 200000; i++) f[i] = (f[i - 1] * i) % 1000000009;
long long ans = 0;
for (int i = 2; i < n; ++i)
for (int j = i; j < n; ++j) {
int bad_days = j - i + 1;
int good_days = n - bad_days;
(ans +=
(((((C[w - 1][good_days - 1] * C[b - 1][bad_days - 1]) % 1000000009) *
f[w]) %
1000000009) *
f[b]) %
1000000009) %= 1000000009;
}
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int C[8001][6001], mo = 1e9 + 9, n, w, b, A[8001], m, I[8001];
int main() {
scanf("%d%d%d", &n, &b, &w);
for (int i = 0; i <= w + b; i++) {
C[i][0] = 1;
for (int j = 1; j <= n; j++) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mo;
}
I[0] = 1;
for (int i = 1; i <= w + b; i++) I[i] = 1ll * i * I[i - 1] % mo;
m = max(w, b);
for (int i = 1; i <= n; i++) A[i] = 1ll * C[w - 1][i - 1] * I[w] % mo;
int ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n - i - 1; j++)
ans = (ans + 1ll * I[b] * C[b - 1][i + j - 1] % mo * A[n - i - j]) % mo;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,abm,mmx,tune=native")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline void boostIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
}
bool isPrime(int x) {
if (x <= 4 || x % 2 == 0 || x % 3 == 0) return x == 2 || x == 3;
for (int i = 5; i * i <= x; i += 6)
if (x % i == 0 || x % (i + 2) == 0) return 0;
return 1;
}
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
long long int lcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
long long Mod = 1e9 + 9;
long long inf = 1e9;
long long Pow(long long a, long long b) {
if (b == 0) return 1;
long long c = Pow(a, b / 2);
c = c * c % Mod;
if (b % 2 == 1) c = c * a % Mod;
return c;
}
long long fac[1000001];
long long d(long long v) { return Pow(v, Mod - 2); }
long long CC(long long n, long long k) {
return fac[n] * d(fac[n - k]) % Mod * d(fac[k]) % Mod;
}
int32_t main() {
boostIO();
fac[0] = 1;
for (long long i = 1; i <= 1000000; ++i) {
fac[i] = fac[i - 1] * i % Mod;
}
long long n, w, b;
cin >> n >> w >> b;
long long ans = 0;
for (long long i = 1; i <= w - 1; ++i) {
long long cuts = n - 3;
long long left = i - 1;
long long mid = b - 1;
long long right = w - i - 1;
long long P = left + mid + right;
ans += fac[w] * fac[b] % Mod * CC(P, cuts) % Mod;
ans %= Mod;
}
cerr << "ans = ";
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4000 + 5, mod = 1000000009;
int n, x, y;
long long P[N], d[N][N];
int main() {
scanf("%d", &n);
scanf("%d", &x);
scanf("%d", &y);
for (int i = 0; i <= max(x, y); i++) d[i][0] = 1;
for (int i = 1; i <= max(x, y); i++)
for (int j = 1; j <= min(n, i); j++)
d[i][j] = (d[i - 1][j] + d[i - 1][j - 1]) % mod;
P[0] = 1;
for (int i = 1; i <= max(x, y); i++) P[i] = (P[i - 1] * i) % mod;
long long ans = 0;
for (int l = 2; l <= n - 1; l++)
for (int r = l; r <= n - 1; r++)
ans = (ans + (d[y - 1][r - l] * d[x - 1][n - (r - l + 2)]) % mod) % mod;
ans = ans * ((P[x] * P[y]) % mod) % mod;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, w, b, ans, jc[4005], inv[4005], mod = 1e9 + 9;
long long C(long long n, long long m) {
return jc[n] * inv[m] % mod * inv[n - m] % mod;
}
signed main() {
scanf("%lld%lld%lld", &n, &w, &b);
jc[0] = 1;
for (long long i = 1; i <= 4002; i++) jc[i] = i * jc[i - 1] % mod;
inv[0] = inv[1] = 1;
for (long long i = 2; i <= 4002; i++)
inv[i] = mod - (mod / i) * inv[mod % i] % mod;
for (long long i = 1; i <= 4002; i++) inv[i] = inv[i - 1] * inv[i] % mod;
for (long long i = 1; i <= b; i++)
if (n - i >= 2 && n - i <= w)
ans = (ans +
(n - i - 1) * C(b - 1, i - 1) % mod * C(w - 1, n - i - 1) % mod) %
mod;
ans = (ans * jc[w] % mod * jc[b] % mod) % mod;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000009;
const int N = 4000 + 11;
int n, w, b, inv[N][2], mul[N];
long long ans;
inline int P(int n) { return mul[n]; }
inline int C(int n, int m) {
return mul[n] * (long long)inv[m][1] % mod * inv[n - m][1] % mod;
}
int main(int argc, char **argv) {
inv[0][1] = mul[0] = 1;
inv[1][0] = inv[1][1] = mul[1] = 1;
for (int i = 2; i < N; ++i)
inv[i][0] = -inv[mod % i][0] * (long long)(mod / i) % mod,
inv[i][1] = inv[i - 1][1] * (long long)inv[i][0] % mod,
mul[i] = mul[i - 1] * (long long)i % mod;
scanf("%d%d%d", &n, &w, &b);
for (int i = 1; i <= w && i <= n; ++i)
for (int j = max(1, n - w); i + j < n && j <= b; ++j)
ans = (ans + C(b - 1, j - 1) * (long long)C(w - 1, n - j - 1)) % mod;
ans = ans * P(w) % mod * P(b) % mod;
printf("%d\n", (ans + mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int C[8020][8020];
int f[8020];
void init() {
for (int i = 0; i < 8020; ++i) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; ++j) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
if (C[i][j] >= 1000000009) C[i][j] -= 1000000009;
}
}
f[0] = 1;
for (int i = 1; i < 8020; ++i) f[i] = 1LL * f[i - 1] * i % 1000000009;
}
int n, w, b;
int main() {
init();
cin >> n >> w >> b;
int ans = 0;
for (int i = 1; i <= w - 1; ++i) {
ans += 1LL * C[w + b - 3][n - 3] * C[w][i] % 1000000009 * f[i] %
1000000009 * f[b] % 1000000009 * f[w - i] % 1000000009;
if (ans >= 1000000009) ans -= 1000000009;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4010;
const long long M = 1000000009;
int main(int argc, char *argv[]) {
vector<long long> A(1, 1);
for (int n_ = (MAXN), i = 0; i < n_; ++i) A.push_back(A.back() * (i + 1) % M);
vector<vector<long long> > C(MAXN, vector<long long>(MAXN));
for (int n_ = (MAXN), i = 0; i < n_; ++i)
for (int n_ = (i + 1), j = 0; j < n_; ++j) {
if (i == j || j == 0)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % M;
}
long long N, W, B;
cin >> N >> W >> B;
long long ans = 0;
for (int n_ = (N + 1), a = 0; a < n_; ++a) {
int b = N - a;
if (a && a <= B && b && b <= W) {
ans = (ans + C[B - 1][a - 1] * A[B] % M * C[W - 1][b - 1] % M * A[W] % M *
(b - 1)) %
M;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const double eps = 1e-9;
const double INF = inf;
const double EPS = eps;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int N[2][1100 * 1100 * 4];
long long T[110000];
int V[110000];
int main() {
int x, y, n, q, a, b, c, d, bb, it;
int i, j, k, nx, ny;
char ch;
scanf("%d%d", &n, &b);
for (i = 0; i <= b; i++)
for (j = 0; j <= b; j++)
for (k = 0; k < 4; k++) {
nx = i + dx[k], ny = j + dy[k];
nx = max(nx, 0), nx = min(nx, b);
ny = max(ny, 0), ny = min(ny, b);
N[0][(i * (b + 1) + j) * 4 + k] = (nx * (b + 1) + ny) * 4 + k;
}
for (i = 0; i < n; i++) {
scanf("%d%d%d%d", &a, &bb, &c, &d);
assert(a != c || bb != d);
int len = abs(a - c) + abs(bb - d);
for (it = 0; it < 4; it++)
if (c == a + len * dx[it] && d == bb + len * dy[it]) {
for (j = 0; j <= len; j++) {
x = a + j * dx[it], y = bb + j * dy[it];
int id = (x * (b + 1) + y) * 4;
for (k = 0; k < 4; k++) {
N[0][id + k] = N[0][id + it];
}
}
break;
}
}
scanf("%d", &q);
for (i = 0; i < q; i++) {
scanf("%d%d %c %I64d", &x, &y, &ch, &T[i]);
V[i] = (x * (b + 1) + y) * 4;
if (ch == 'L') V[i]++;
if (ch == 'U') V[i] += 2;
if (ch == 'D') V[i] += 3;
}
for (it = 0; it < 55; it++) {
for (i = 0; i < q; i++)
if (T[i] & (1ll << it)) V[i] = N[0][V[i]];
for (j = 0; j < (b + 1) * (b + 1) * 4; j++) N[1][j] = N[0][N[0][j]];
memcpy(N[0], N[1], sizeof(N[0]));
}
for (i = 0; i < q; i++)
printf("%d %d\n", V[i] / (4 * (b + 1)), (V[i] / 4) % (b + 1));
;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const double pi = acos(-1.0);
const int size = 1010;
const int px[] = {1, 0, -1, 0};
const int py[] = {0, 1, 0, -1};
const int mdeg = 12;
const int onelvl = 20;
int ways[size][size];
int n, b;
int ans[mdeg][size * size * 4];
inline int dirts(int x, int y, int d) {
return d * (b + 1) * (b + 1) + x * (b + 1) + y;
}
inline void backts(int num, int &x, int &y, int &d) {
y = num % (b + 1);
num /= b + 1;
x = num % (b + 1);
num /= b + 1;
d = num;
}
int main() {
scanf("%d%d", &n, &b);
for (int i = 0; i <= b; i++)
for (int j = 0; j <= b; j++) ways[i][j] = -1;
int xs1, xs2, ys1, ys2;
for (int i = 0; i < n; i++) {
scanf("%d%d%d%d", &xs1, &ys1, &xs2, &ys2);
int len = abs(xs1 - xs2) + abs(ys1 - ys2);
int dir = -1;
for (int j = 0; j < 4; j++)
if (xs1 + px[j] * len == xs2 && ys1 + py[j] * len == ys2) dir = j;
for (int j = 0; j <= len; j++)
ways[xs1 + px[dir] * j][ys1 + py[dir] * j] = dir;
}
int hx, hy, hd;
for (int i = 0; i <= b; i++)
for (int j = 0; j <= b; j++) {
for (int k = 0; k < 4; k++) {
if (ways[i][j] == -1) {
hx = i + px[k];
hy = j + py[k];
hx = max(0, min(hx, b));
hy = max(0, min(hy, b));
ans[0][dirts(i, j, k)] = dirts(hx, hy, k);
} else {
hd = ways[i][j];
hx = i + px[hd];
hy = j + py[hd];
hx = max(0, min(hx, b));
hy = max(0, min(hy, b));
ans[0][dirts(i, j, k)] = dirts(hx, hy, hd);
}
}
}
for (int lvl = 1; lvl < mdeg; lvl++) {
for (int i = 0; i <= b; i++)
for (int j = 0; j <= b; j++)
for (int k = 0; k < 4; k++) {
int num = dirts(i, j, k);
for (int hp = 0; hp < onelvl; hp++) num = ans[lvl - 1][num];
ans[lvl][dirts(i, j, k)] = num;
}
}
int q, xc, yc;
char mdir;
long long len;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%d %c%I64d", &xc, &yc, &mdir, &len);
int d = -1;
if (mdir == 'R') d = 0;
if (mdir == 'U') d = 1;
if (mdir == 'L') d = 2;
if (mdir == 'D') d = 3;
int num = dirts(xc, yc, d);
for (int j = 0; j < mdeg; j++) {
while (len % onelvl != 0) {
num = ans[j][num];
len--;
}
len /= onelvl;
}
int xa, ya, da;
backts(num, xa, ya, da);
printf("%d %d\n", xa, ya);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.