text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long N = 10000, Mod = 998244353;
long long p, s, r, ans = 0;
long long fac[10010] = {}, inac[10010] = {};
inline long long Add(long long a, long long b) {
return a + b >= Mod ? a + b - Mod : a + b;
}
inline long long Sub(long long a, long long b) {
return a - b >= 0 ? a - b : a - b + Mod;
}
inline long long Mul(long long a, long long b) { return 1ll * a * b % Mod; }
inline long long Pow(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1, a = Mul(a, a))
if (b & 1) res = Mul(res, a);
return res;
}
inline long long Inv(long long a) { return Pow(a, Mod - 2); }
inline long long C(long long n, long long m) {
return n < m || m < 0 ? 0 : Mul(fac[n], Mul(inac[m], inac[n - m]));
}
inline long long f(long long n, long long m, long long lim) {
if (n == 0 && m == 0) return 1;
long long res = 0;
for (long long i = 0; i <= m; i++) {
res = i & 1 ? Sub(res, Mul(C(m, i), C(n - (lim + 1) * i + m - 1, m - 1)))
: Add(res, Mul(C(m, i), C(n - (lim + 1) * i + m - 1, m - 1)));
}
return res;
}
void pret() {
fac[0] = 1;
for (long long i = 1; i <= N; i++) fac[i] = Mul(fac[i - 1], i);
inac[N] = Inv(fac[N]);
for (long long i = N - 1; i >= 0; i--) inac[i] = Mul(inac[i + 1], i + 1);
return;
}
signed main() {
pret();
scanf("%lld%lld%lld", &p, &s, &r);
for (long long i = r; i <= s; i++)
for (long long j = 1; j <= p; j++) {
ans = Add(ans,
Mul(Mul(C(p - 1, j - 1), f(s - i * j, p - j, i - 1)), Inv(j)));
}
printf("%lld", Mul(ans, Inv(C(s - r + p - 1, p - 1))));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string to_string(const string& str) { return str; }
template <typename T>
string to_string(const set<T>& mys) {
if (mys.empty()) return "{}";
string ret = "{";
for (auto el : mys) ret += to_string(el) + ", ";
ret.pop_back(), ret.pop_back();
ret += "}";
return ret;
}
template <typename T>
string to_string(const pair<T, T>& pr) {
return "(" + to_string(pr.first) + "," + to_string(pr.second) + ")";
}
template <typename T>
string to_string(const vector<T>& vc, int w) {
if (vc.empty()) return "";
if (w + 1 == vc.size()) return to_string(vc[w]);
return to_string(vc[w]) + "," + to_string(vc, w + 1);
}
template <typename T>
string to_string(const vector<T>& vc) {
return "{" + to_string(vc, 0) + "}";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
class DebugStream {
} LOG;
template <typename T>
DebugStream& operator<<(DebugStream& s, const T&) {
return s;
}
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const int maxN = 1e2 + 9, maxV = 1e6 + 9, MOD = 998244353, SQ = 335, lg = 20,
bs = 29;
long long ncr[maxN][maxN], invs[maxN];
inline void add(int& a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
inline void sub(int& a, int b) {
a -= b;
if (a < 0) a += MOD;
}
long long fastPow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
clock_t begi = clock();
for (int i = 1; i < maxN; i++) invs[i] = fastPow(i, MOD - 2);
for (int i = 0; i < maxN; i++)
for (int j = ncr[i][0] = 1; j <= i; j++)
ncr[i][j] = (ncr[i - 1][j] + ncr[i - 1][j - 1]) % MOD;
int p, s, r;
cin >> p >> s >> r;
if (s == 0) {
cout << invs[p] << '\n';
exit(0);
}
int ans = 0;
auto slv = [&](int u, int totS, vector<int>& dp) {
int cnt = 0, tmp;
for (int i = max(0, totS - u + 1); i <= totS; i++) add(cnt, dp[i]);
for (int i = totS; i >= 0; i--) {
if (i - u >= 0) add(cnt, dp[i - u]);
tmp = cnt;
sub(cnt, dp[i]);
dp[i] = tmp;
}
};
for (int u = max(1, r); u <= s; u++) {
int totS = s - u;
vector<int> dp(totS + 1);
dp[0] = 1;
for (int x = 0; x < p; x++) {
int rst = p - x;
if (rst * u <= s) {
add(ans, dp[s - rst * u] * invs[rst] % MOD * ncr[p - 1][rst - 1] % MOD);
}
slv(u - 1, totS, dp);
}
}
vector<int> ovr(s + 1);
for (int i = r; i <= s; i++) ovr[i] = 1;
for (int x = 1; x < p; x++) slv(s, s, ovr);
42;
cout << ans * fastPow(ovr[s], MOD - 2) % MOD << '\n';
auto elapsed = double(clock() - begi) / CLOCKS_PER_SEC;
42;
}
|
#include <bits/stdc++.h>
using namespace std;
class Math {
private:
long long fact[20000 + 1] = {};
long long ifac[20000 + 1] = {};
public:
Math() {
fact[0] = 1;
for (long long i = (1); i <= (20000); i++)
fact[i] = (fact[i - 1] * i) % 998244353;
ifac[20000] = pow(fact[20000], 998244353 - 2);
for (long long i = (20000 - 1); i >= (0); i--)
ifac[i] = (ifac[i + 1] * (i + 1)) % 998244353;
}
long long pow(long long a, long long n) {
if (n == 0) return 1;
long long ans = pow(a, n >> 1);
ans *= ans, ans %= 998244353;
if (n & 1) return (ans * a) % 998244353;
return ans;
}
long long C(long long n, long long k) {
if (k < 0 || k > n) return 0;
return (((fact[n] * ifac[k]) % 998244353) * ifac[n - k]) % 998244353;
}
long long P(long long n, long long k) {
return (fact[n] * ifac[n - k]) % 998244353;
}
long long factorial(long long n) { return fact[n]; }
long long chiaKeo(long long candy, long long people) {
if (candy == 0 && people == 0) return 1;
return C(candy + people - 1, candy);
}
};
Math math;
long long p, s, r;
long long process(long long score) {
long long remain = s - score;
long long people = remain / score;
if (people >= p) return 0;
long long way = 0;
for (long long i = (0); i <= (people); i++) {
long long curr = 0;
long long remainP = p - 1 - i, remainS = remain - i * score;
for (long long j = (0); j <= (people - i); j++) {
long long x = math.chiaKeo(remainS - j * score, remainP) *
math.C(remainP, j) % 998244353;
if (j & 1)
curr = (curr + 998244353 - x) % 998244353;
else
curr = (curr + x) % 998244353;
}
curr *= math.C(p - 1, i), curr %= 998244353;
cerr << curr << ' ' << i + 1 << '\n';
curr *= math.pow(i + 1, 998244353 - 2), curr %= 998244353;
way += curr, way %= 998244353;
}
return way;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> p >> s >> r;
if (s == r && s == 0) {
cout << math.pow(p, 998244353 - 2);
return 0;
}
long long remain = s - r;
long long totalCases = math.chiaKeo(remain, p);
long long suitable = 0;
for (long long score = (max(1ll, r)); score <= (s); score++) {
suitable += process(score);
suitable %= 998244353;
}
cout << (suitable * math.pow(totalCases, 998244353 - 2)) % 998244353;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fact[110000], invfact[110000];
long long invexp[105][5010];
long long ncr(long long n, long long r) {
if (r < 0 or r > n or n < 0) return 0;
long long ans = (fact[n] * invfact[r]) % 998244353;
ans = (ans * invfact[n - r]) % 998244353;
return ans;
}
void inverse(long long a, long long b, long long &d, long long &x,
long long &y) {
if (b == 0)
d = a, x = 1, y = 0;
else {
inverse(b, a % b, d, x, y);
long long temp = x;
x = y;
y = temp - (a / b) * x;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long p, s, r0;
cin >> p >> s >> r0;
long long pinv = 1;
fact[0] = fact[1] = invfact[0] = invfact[1] = 1;
for (long long i = 2; i < 110000; ++i) {
fact[i] = (fact[i - 1] * i) % 998244353;
invfact[i] = ((-998244353 / i) * invfact[998244353 % i]) % 998244353;
invfact[i] += 998244353;
if (i == p) pinv = invfact[i];
}
for (long long i = 2; i < 110000; ++i)
invfact[i] = (invfact[i - 1] * invfact[i]) % 998244353;
for (long long i = 0; i < 5010; ++i) invexp[0][i] = (i == 0);
for (long long i = 1; i < 105; ++i) {
for (long long j = 0; j < 5010; ++j) {
invexp[i][j] = ncr(i + j - 1, i - 1);
}
}
long long temp = 0;
for (long long r = r0; r < s + 1; ++r) {
for (long long i = 0; i < p; ++i) {
long long res = 0;
long long peff = p - i - 1, ind = 0, k = s - (i + 1) * r;
while (r * ind <= k) {
long long lcoeff = (ind & 1 ? -1 : 1) * ncr(peff, ind);
if (lcoeff < 0)
lcoeff += 998244353;
else if (lcoeff == 0)
break;
long long req = k - ind * r;
long long rcoeff = invexp[peff][req];
res = (res + ((lcoeff * rcoeff) % 998244353)) % 998244353;
ind++;
}
res = (res * ncr(p, i + 1)) % 998244353;
temp = (temp + res) % 998244353;
}
}
temp = (temp * pinv) % 998244353;
long long div = ncr(s - r0 + p - 1, p - 1);
long long d, x1, y1;
inverse(div, 998244353, d, x1, y1);
x1 %= 998244353;
x1 += 998244353;
x1 %= 998244353;
cout << (temp * x1) % 998244353 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 100010;
const int INF = 2147483600;
const long long Mod = 998244353LL;
const int MAX = 10010;
int P, S, R;
long long inv[MAXN + 1], ifac[MAXN + 1], fac[MAXN + 1];
inline long long C(long long n, long long m) {
if (n < 0 || n < m) return 0;
return fac[n] * ifac[m] % Mod * ifac[n - m] % Mod;
}
inline long long D(long long n, long long m) {
if (!m) {
return ((!n) ? 1 : 0);
}
return C(n + m - 1, m - 1);
}
inline void Add(long long &a, long long b) {
a = (a + b >= Mod ? a + b - Mod : a + b);
}
inline long long Pow(long long a, long long b) {
long long ret = 1;
for (; b; b >>= 1, a = a * a % Mod)
if (b & 1) ret = ret * a % Mod;
return ret;
}
long long ans = 0;
int main() {
P = read(), S = read(), R = read();
fac[0] = ifac[0] = inv[1] = 1;
for (int i = 2; i <= MAX; i++)
inv[i] = (Mod - inv[Mod % i] * (Mod / i) % Mod) % Mod;
for (int i = 1; i <= MAX; i++)
ifac[i] = ifac[i - 1] * inv[i] % Mod, fac[i] = fac[i - 1] * i % Mod;
for (int i = R; i <= S; i++) {
for (int j = 1; j <= P; j++) {
long long sum = 0;
for (int k = 0; k <= P - j && (k + j) * i <= S; k++) {
long long val = C(P - j, k) * C(P - 1, j - 1) % Mod *
D(S - (k + j) * i, P - j) % Mod;
Add(sum, (k & 1) ? Mod - val : val);
}
Add(ans, sum * inv[j] % Mod);
}
}
printf("%lld\n", ans * Pow(D(S - R, P), Mod - 2) % Mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
long long ksm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD, b >>= 1;
}
return res;
}
const int N = 6005;
long long fac[N], inv[N];
void init(int n = 6000) {
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % MOD;
inv[n] = ksm(fac[n], MOD - 2);
for (int i = n; i >= 1; i--) inv[i - 1] = inv[i] * i % MOD;
return;
}
long long C(int n, int m) {
if (m > n) return 0;
if (m == 0 || m == n) return 1;
return fac[n] * inv[m] % MOD * inv[n - m] % MOD;
}
long long calc(int n, int m, int x) {
if (m == 0) {
if (n == 0)
return 1;
else
return 0;
}
long long res = 0;
for (int i = 0; i <= m; i++) {
long long sum = C(m, i) * C(n - x * i + m - 1, m - 1) % MOD;
if (i & 1)
res = (res - sum + MOD) % MOD;
else
res = (res + sum) % MOD;
}
return res;
}
int p, s, r;
int main() {
init();
scanf("%d%d%d", &p, &s, &r);
if (p == 1) {
printf("1");
return 0;
}
long long ans = 0;
for (int x = r; x <= s; x++) {
if (x * p < s) continue;
for (int i = 1; i <= p; i++) {
if (i * x > s) break;
if ((p - i) * (x - 1) + i * x < s) continue;
ans = (ans + C(p - 1, i - 1) * calc(s - x * i, p - i, x) % MOD *
ksm(i, MOD - 2) % MOD) %
MOD;
}
}
ans = ans * ksm(C(s - r + p - 1, p - 1), MOD - 2) % MOD;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 6010;
const int M = 1e6;
const long long base = 998244353;
const int digit = 9;
const long long mod = 998244353;
long long p, s, r;
vector<long long> gt({1}), dv({1});
long long mu(long long a, long long b) {
if (b == 0) return 1;
long long d = mu(a, b / 2);
d = (d * d) % mod;
if (b % 2) d = (d * a) % mod;
return d;
}
long long inv(long long q) { return mu(q, mod - 2); }
long long C(long long n, long long k) {
return ((gt[n] * dv[k] % base) * dv[n - k]) % base;
}
long long star(long long n, long long k) { return C(n + k - 1, k - 1); }
long long cntgame(long long n, long long k, long long x) {
if (k == 0) return (n == 0);
long long ans = 0;
for (int i = 0; i <= k; i++) {
long long t = n - x * i;
if (t < 0) break;
if (i % 2)
ans = (ans - C(k, i) * star(t, k)) % base;
else
ans = (ans + C(k, i) * star(t, k)) % base;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> p >> s >> r;
for (int i = 1; i <= 6005; i++) {
gt.push_back((gt[i - 1] * i) % base);
dv.push_back(inv(gt[i]));
}
long long sz = cntgame(s - r, p, 1e18);
sz = inv(sz);
long long res = 0;
for (int q = r; q <= s; q++) {
for (int i = 0; i < p; i++) {
long long t = s - (i + 1) * q;
if (t < 0) break;
res =
(res + (((C(p - 1, i) * cntgame(t, p - 1 - i, q)) % mod) * sz % mod) *
inv(i + 1)) %
mod;
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 998244353;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double pi = acosl(-1.), eps = 1e-9;
inline void sum(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
inline int power(int a, int b, int m = mod, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
const int NN = 10010;
int ch[NN], rch[NN];
int c(int n, int m) {
if (n < m) return 0;
if (!m) return 1;
return (long long)ch[n] * rch[n - m] % mod * rch[m] % mod;
}
int dp[111][5555];
int s[111][5555];
int main() {
ch[0] = 1;
for (int i = 1; i < NN; i++) ch[i] = (long long)ch[i - 1] * i % mod;
rch[NN - 1] = power(ch[NN - 1], mod - 2);
for (int i = NN - 1; i; i--) {
rch[i - 1] = (long long)rch[i] * i % mod;
}
int N, S, R;
cin >> N >> S >> R;
if (N == 1) {
puts("1");
return 0;
}
int tmp;
if (R == 0) {
tmp = c(N + S - 1, N - 1);
} else {
dp[0][0] = 1;
for (int i = 0; i <= S; i++) s[0][i] = 1;
for (int i = 1; i <= N; i++) {
for (int j = 0; j <= S; j++) {
dp[i][j] = s[i - 1][j];
if (j >= R) dp[i][j] -= s[i - 1][j - R];
if (dp[i][j] < 0) dp[i][j] += mod;
}
s[i][0] = 1;
for (int j = 1; j <= S; j++) {
s[i][j] = s[i][j - 1] + dp[i][j];
if (s[i][j] >= mod) s[i][j] -= mod;
}
}
tmp = c(S + N - 1, N - 1) - dp[N][S];
if (tmp < 0) tmp += mod;
}
tmp = (long long)tmp * power(N, mod - 2) % mod;
int tot = 0;
for (int i = R; i <= S; i++) {
sum(tot, c(S - i + N - 1 - 1, N - 2));
}
tot = power(tot, mod - 2);
cout << (long long)tmp * tot % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fac[10010], inv[10010];
int ksm(int a, int b = 998244353 - 2) {
int r = 1;
for (; b; b >>= 1) {
if (b & 1) r = 1ll * r * a % 998244353;
a = 1ll * a * a % 998244353;
}
return r;
}
void init(int n = 10010 - 10) {
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % 998244353;
inv[n] = ksm(fac[n]);
for (int i = n - 1; i >= 0; i--)
inv[i] = 1ll * inv[i + 1] * (i + 1) % 998244353;
}
int C(int x, int y) {
return x < y || y < 0
? 0
: 1ll * fac[x] * inv[y] % 998244353 * inv[x - y] % 998244353;
}
int B(int x, int y) { return y < 0 ? 0 : C(x + y - 1, x - 1); }
int F(int n, int m, int r) {
if (!n && !m) return 1;
int ans = 0, f = (n & 1) ? 998244353 - 1 : 1;
for (int i = 0; i <= n; i++, f = 998244353 - f)
ans = (ans +
1ll * f * C(n, i) % 998244353 * B(n, m - (r + 1) * (n - i)) %
998244353 +
998244353) %
998244353;
return ans;
}
int main() {
int p, s, r;
scanf("%d%d%d", &p, &s, &r);
init();
int ans = 0;
for (int i = r; i <= s; i++)
for (int j = 0; (j + 1) * i <= s && j < p; j++)
ans = (ans + F(p - j - 1, s - (j + 1) * i, i - 1) * 1ll * C(p - 1, j) %
998244353 * ksm(j + 1) % 998244353) %
998244353;
ans = 1ll * ans * ksm(B(p, s - r)) % 998244353;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10000, Mod = 998244353;
int p, s, r, ans = 0;
int fac[10010] = {}, inac[10010] = {};
inline int Add(int a, int b) { return a + b >= Mod ? a + b - Mod : a + b; }
inline int Sub(int a, int b) { return a - b >= 0 ? a - b : a - b + Mod; }
inline int Mul(int a, int b) { return 1ll * a * b % Mod; }
inline int Pow(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = Mul(a, a))
if (b & 1) res = Mul(res, a);
return res;
}
inline int Inv(int a) { return Pow(a, Mod - 2); }
inline int C(int n, int m) {
return n < m || m < 0 ? 0 : Mul(fac[n], Mul(inac[m], inac[n - m]));
}
inline int f(int n, int m, int lim) {
if (n == 0 && m == 0) return 1;
int res = 0;
for (int i = 0; i <= m; i++)
res = i & 1 ? Sub(res, Mul(C(m, i), C(n - (lim + 1) * i + m - 1, m - 1)))
: Add(res, Mul(C(m, i), C(n - (lim + 1) * i + m - 1, m - 1)));
return res;
}
void pret() {
fac[0] = 1;
for (int i = 1; i <= N; i++) fac[i] = Mul(fac[i - 1], i);
inac[N] = Inv(fac[N]);
for (int i = N - 1; i >= 0; i--) inac[i] = Mul(inac[i + 1], i + 1);
return;
}
int main() {
pret();
scanf("%d%d%d", &p, &s, &r);
for (int i = r; i <= s; i++)
for (int j = 1; j <= p; j++) {
ans = Add(ans,
Mul(Mul(C(p - 1, j - 1), f(s - i * j, p - j, i - 1)), Inv(j)));
}
printf("%d", Mul(ans, Inv(C(s - r + p - 1, p - 1))));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long MOD998 = 998244353;
const int INF = 1e9;
const long long LLINF = 1e18;
mt19937_64 rng(
(unsigned int)chrono::steady_clock::now().time_since_epoch().count());
template <class T>
T rnd(T l, T r) {
return uniform_int_distribution<T>(l, r)(rng);
}
int add(int x, int y) { return x + y >= MOD998 ? x + y - MOD998 : x + y; }
int mul(int x, int y) { return 1LL * x * y % MOD998; }
int sub(int x, int y) { return x - y < 0 ? x - y + MOD998 : x - y; }
int pw(int a, int n) {
int res = 1;
while (n) {
if (n & 1) {
res = mul(res, a);
}
a = mul(a, a);
n >>= 1;
}
return res;
}
int inv(int x) { return pw(x, MOD998 - 2); }
void run() {
int p, s, r;
cin >> p >> s >> r;
vector<vector<int>> choose(p + s + 1, vector<int>(p + s + 1));
for (int i = 0; i <= p + s; i++) {
choose[i][0] = choose[i][i] = 1;
for (int j = 1; j < i; j++) {
choose[i][j] = add(choose[i - 1][j - 1], choose[i - 1][j]);
}
}
auto binom = [&](int n, int k) {
if (k < 0 || n < 0) {
return 1;
}
return choose[n][k];
};
auto binom_repl = [&](int n, int k) { return binom(n + k - 1, k); };
int good = 0, total = 0;
for (int score = r; score <= s; score++) {
total = add(total, binom_repl(p - 1, s - score));
for (int same = 0; score * (same + 1) <= s && same < p; same++) {
int left_people = p - same - 1, left_sum = s - score * (same + 1);
int res = 0;
for (int k = 0; k <= left_people && k * score <= left_sum; k++) {
int ways = mul(binom(left_people, k),
binom_repl(left_people, left_sum - k * score));
res = (k & 1 ? sub(res, ways) : add(res, ways));
}
good = add(good, mul(binom(p - 1, same), mul(res, inv(same + 1))));
}
}
cout << mul(good, inv(total)) << "\n";
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.precision(10);
cout << fixed;
int tests;
tests = 1;
while (tests--) {
run();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[105][5005], MOD = 998244353;
int n, s, r;
long long mu(long long cs, long long sm) {
if (sm == 0) return 1ll;
if (sm == 1) return cs;
long long mid = mu(cs, sm / 2);
if (sm % 2 == 0)
return (mid * mid) % MOD;
else
return (((mid * mid) % MOD) * cs) % MOD;
}
long long tohop(long long n, long long k) {
long long tu = 1, mau = 1;
for (int i = n - k + 1; i <= n; i++) tu = (tu * i) % MOD;
for (int i = 1; i <= k; i++) mau = (mau * i) % MOD;
return (tu * mu(mau, MOD - 2)) % MOD;
}
int main() {
cin >> n >> s >> r;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= s; j++) {
dp[i][j] = dp[i - 1][j];
if (j) {
dp[i][j] = (dp[i][j] + dp[i][j - 1]) % MOD;
}
if (j >= r) {
dp[i][j] = (dp[i][j] - dp[i - 1][j - r] + MOD) % MOD;
}
}
}
long long ans = mu(n, MOD - 2);
ans = ans * (tohop(s + n - 1, n - 1) - dp[n][s] + MOD) % MOD;
ans = ans * mu(tohop(s + n - 1 - r, n - 1), MOD - 2) % MOD;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
void upd(int &x, int y) { x = x + y < 998244353 ? x + y : x + y - 998244353; }
int dp[100 + 5][5100 + 5];
long long qp(long long a, int k) {
long long ans = 1;
while (k) {
if (k & 1) ans = ans * a % 998244353;
a = a * a % 998244353;
k >>= 1;
}
return ans;
}
long long fac[5100 + 5], inv[5100 + 5], ifac[5100 + 5];
long long C(int n, int m) {
if (m < 0 || m > n) return 0;
return fac[n] * ifac[m] % 998244353 * ifac[n - m] % 998244353;
}
long long cal(int n, int m) {
if (m == 0) return n == 0;
return C(n - 1, m - 1);
}
long long f(int N, int S, int upp) {
long long ans = 0;
for (int p = 0; p <= N && p * upp <= S; p++) {
ans = (ans + (p & 1 ? -1 : 1) * C(N, p) * cal(S - p * upp, N)) % 998244353;
}
return (ans + 998244353) % 998244353;
}
int main() {
fac[0] = ifac[0] = 1;
inv[1] = 1;
for (int i = 1; i <= 5100; i++) fac[i] = fac[i - 1] * i % 998244353;
for (int i = 2; i <= 5100; i++)
inv[i] = inv[998244353 % i] * (998244353 - 998244353 / i) % 998244353;
for (int i = 1; i <= 5100; i++) ifac[i] = ifac[i - 1] * inv[i] % 998244353;
int p, s, r;
scanf("%d%d%d", &p, &s, &r);
int ans = 0;
for (int i = r; i <= s; i++) {
for (int num = 0; num <= p - 1 && num * i <= s - i; num++) {
long long tmp = f(p - 1 - num, s - i - num * i + p - 1 - num, i) *
qp(num + 1, 998244353 - 2) % 998244353;
tmp = tmp * C(p - 1, num) % 998244353;
upd(ans, tmp);
}
}
ans = ans * qp(C(s - r + p - 1, p - 1), 998244353 - 2) % 998244353;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
long long dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
long long dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
long long x;
long long y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
long long x;
long long y, z, w;
pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long gcd(long long v, long long b) {
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
long long mod;
long long extgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pair<long long, long long> operator+(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first + r.first, l.second + r.second};
}
pair<long long, long long> operator-(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first - r.first, l.second - r.second};
}
long long pr[1001010];
long long inv[1001010];
long long beki(long long wa, long long rr, long long warukazu) {
if (rr == 0) return 1 % warukazu;
if (rr == 1) return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
long long comb(long long nn, long long rr) {
if (rr < 0 || rr > nn || nn < 0) return 0;
long long r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(long long ert) {
pr[0] = 1;
for (long long i = 1; i <= ert; i++) {
pr[i] = (pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (long long i = ert - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
long long solve(long long W, long long T, long long n) {
if ((T - 1) * n < W) return 0;
long long ans = 0;
if (n == 0) {
if (W == 0) return 1;
return 0;
}
if (W < 0) return 0;
if (T == 0) return 0;
if (W == 0) {
return 1;
}
for (long long i = 0; i <= n; i++) {
long long p = 1;
if (i % 2) p = mod - 1;
p *= comb(n, i);
p %= mod;
p *= comb(W - T * i + n - 1, n - 1);
p %= mod;
ans += p;
}
return ans % mod;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long p, s, r;
cin >> p >> s >> r;
mod = 998244353;
gya(100000);
long long memo[110] = {};
for (long long sc = r; sc <= s; sc++) {
for (long long nin = 1; nin <= p; nin++) {
if (s - sc * nin < 0) break;
memo[nin] +=
solve(s - sc * nin, sc, p - nin) * comb(p - 1, nin - 1) % mod;
memo[nin] %= mod;
}
}
long long zen = comb(s - r + p - 1, p - 1);
long long kati = 0;
for (long long i = 1; i <= p; i++)
kati += memo[i] * beki(i, mod - 2, mod) % mod;
kati %= mod;
cout << kati * beki(zen, mod - 2, mod) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long c[6011][201], n, p, r, s, ans;
long long ksm(long long a, long long b) {
long long ans = 1, aa = a;
while (b) {
if (b & 1) ans *= aa, ans %= 998244353;
aa *= aa;
aa %= 998244353;
b /= 2;
}
return ans;
}
void C_c() {
for (long long i = 0; i <= 5100; i++) {
c[i][0] = 1;
for (long long j = 1; j <= i && j <= 100; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 998244353;
}
}
}
long long sigema(long long a, long long b, long long cc) {
long long sum = 0;
for (long long i = 0; i <= b && i * cc <= a; i++) {
long long ss = c[b][i] * c[a - cc * i + b - 1][b - 1] % 998244353;
if (i & 1) {
sum -= ss;
} else {
sum += ss;
}
}
return (sum % 998244353 + 998244353) % 998244353;
}
int main() {
C_c();
cin >> p >> s >> r;
if (p == 1) {
cout << "1";
return 0;
}
for (long long x = r; x <= s; x++) {
if (x * p < s) continue;
for (long long j = 1; j <= p; j++) {
if (j * x > s || j * x + (p - j) * (x - 1) < s) continue;
if (j == p) {
if (j * x == s) ans += ksm(j, 998244353 - 2), ans %= 998244353;
} else {
ans += c[p - 1][j - 1] * sigema(s - j * x, p - j, x) % 998244353 *
ksm(j, 998244353 - 2) % 998244353;
ans %= 998244353;
}
}
}
cout << ans * ksm(c[s - r + p - 1][p - 1], 998244353 - 2) % 998244353;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void minn(T &a, T b) {
a = min(a, b);
}
template <class T>
void maxx(T &a, T b) {
a = max(a, b);
}
void io() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
const long long MOD = 998244353LL;
long long add(long long a, long long b) { return (a + b) % MOD; }
long long mul(long long a, long long b) { return (1LL * a * b) % MOD; }
long long pow(long long a, long long p) {
long long ret = 1LL;
while (p) {
if (p & 1LL) ret *= a;
a *= a;
ret %= MOD;
a %= MOD;
p >>= 1;
}
return ret;
}
long long inv(long long x) { return pow(x, MOD - 2); }
const long long MX = 10000;
long long fact[MX], ifact[MX];
long long choose(long long n, long long r) {
long long ans;
if (n < r)
ans = 0;
else if (n == r)
ans = 1;
else
ans = (((fact[n] * ifact[n - r]) % MOD) * ifact[r]) % MOD;
return ans;
}
long long parity(long long i) {
if (i % 2 == 0)
return 1;
else
return -1 + MOD;
}
long long g(long long s, long long p, long long m) {
long long ans = 0;
for (int i = 0; i <= (int)p; i++)
ans = add(ans, mul(parity(i), mul(choose(p, i),
choose(s + p - 1 - i * (m + 1), p - 1))));
return ans;
}
int main() {
io();
long long n = 9999;
fact[0] = 1;
for (int i = 1; i <= (int)n; i++) fact[i] = mul(i, fact[i - 1]);
for (int i = 0; i <= (int)n; i++) ifact[i] = inv(fact[i]);
long long p, s, r;
cin >> p >> s >> r;
long long ans = 0;
for (int t = r; t <= (int)s; t++)
for (int q = 1; q <= (int)p; q++)
ans = add(ans, mul(choose(p - 1, q - 1),
mul(inv(q), g(s - q * t, p - q, t - 1))));
ans = mul(ans, inv(choose(s - r + p - 1, p - 1)));
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 Rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
template <typename T>
inline void chkmax(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
inline void chkmin(T &x, T y) {
if (x > y) x = y;
}
inline int read() {
int x = 0;
char c = getchar();
while (c < 48) c = getchar();
while (c > 47) x = x * 10 + (c ^ 48), c = getchar();
return x;
}
const int maxn = 10010, P = 998244353;
int Inc(int x, int y) { return x + y < P ? x + y : x + y - P; }
int Dec(int x, int y) { return x < y ? x - y + P : x - y; }
void Add(int &x, int y) {
x += y;
if (x >= P) x -= P;
}
void Sub(int &x, int y) {
x -= y;
if (x < 0) x += P;
}
int qp(int a, int k) {
int res = 1;
for (; k; k >>= 1, a = 1ll * a * a % P) {
if (k & 1) res = 1ll * res * a % P;
}
return res;
}
int inv[maxn], fac[maxn], ifac[maxn];
int binom(int n, int m) {
return n < m ? 0 : 1ll * fac[n] * ifac[m] % P * ifac[n - m] % P;
}
void init() {
fac[0] = ifac[0] = 1;
inv[1] = fac[1] = ifac[1] = 1;
for (int i = (2), iend = (maxn - 1); i <= iend; ++i) {
inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
fac[i] = 1ll * i * fac[i - 1] % P;
ifac[i] = 1ll * inv[i] * ifac[i - 1] % P;
}
}
int n, s, r;
int get(int n, int m) {
if (n < 0 || m < 0) return 0;
return binom(n + m - 1, n - 1);
}
int calc(int n, int m, int k) {
if (n < 0 || m < 0) return 0;
int res = 0;
for (int i = (0), iend = (n); i <= iend; ++i) {
if (m - k * i < 0) break;
int tmp = 1ll * binom(n, i) * get(n, m - k * i) % P;
i & 1 ? Sub(res, tmp) : Add(res, tmp);
}
return res;
}
void solve() {
init();
cin >> n >> s >> r;
if (n == 1) return puts("1"), void();
int ans = 0;
for (int i = (r), iend = (s); i <= iend; ++i) {
int cnt = s - i;
int tmp = Dec(get(n - 1, cnt), calc(n - 1, cnt, i + 1));
for (int j = (1), jend = (n - 1); j <= jend; ++j) {
int t = j == n - 1 ? cnt == i * j : calc(n - j - 1, cnt - i * j, i);
Add(tmp, 1ll * binom(n - 1, j) * t % P * (1 - qp(j + 1, P - 2) + P) % P);
}
Add(ans, tmp);
}
ans = 1ll * ans * qp(get(n, s - r), P - 2) % P;
ans = (1 - ans + P) % P;
cout << ans << endl;
}
signed main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
Solution() { init(11000); }
int calc(int n, int s, int l) {
int r = s;
long long p = 0;
long long q = nCk(s - l + n - 1, n - 1);
for (int i = l; i <= r; ++i) {
p = addM(p, count(n, s, i));
}
long long res = mulM(p, invM(q));
return res;
}
int count(int n, int s, int x) {
long long res = 0;
for (int i = 1; i <= n; ++i) {
res = addM(res, mulM(invs[i], mulM(nCk(n - 1, i - 1),
count2(n - i, s - i * x, x))));
}
return res;
}
int count2(int n, int s, int x) {
long long res = 0;
for (int i = 0, sign = 1; i <= n; ++i, sign = (sign == 1 ? -1 : 1)) {
res = addM(res, sign * mulM(nCk(n, i), nCk(s - i * x + n - 1, n - 1)));
}
return res;
}
private:
const int M = 998244353;
vector<long long> fs;
vector<long long> ifs;
vector<long long> invs;
long long normalize(long long a) {
a %= M;
if (a < 0) {
a += M;
}
return a;
}
long long addM(long long a, long long b) {
a += b;
while (a >= M) {
a -= M;
}
while (a < 0) {
a += M;
}
return a;
}
long long mulM(long long a, long long b) { return normalize(a * b); }
long long powM(long long x, long long e) {
long long res = 1;
while (e > 0) {
if (e & 0x1) {
res = mulM(res, x);
}
x = mulM(x, x);
e >>= 1;
}
return res;
}
long long invM(long long a) {
long long b = M;
long long u = 0, v = 1;
a = normalize(a);
while (a > 0) {
long long d = b / a;
b -= d * a;
u -= d * v;
swap(a, b);
swap(u, v);
}
assert(b == 1);
u = normalize(u);
return u;
}
void init(int n) {
fs.clear();
fs.resize(n + 1, 1);
ifs.clear();
ifs.resize(n + 1, 1);
invs.clear();
invs.resize(n + 1, 1);
for (int i = 1; i <= n; ++i) {
fs[i] = mulM(fs[i - 1], i);
}
ifs[n] = invM(fs[n]);
for (int i = n - 1; i >= 0; --i) {
ifs[i] = mulM(ifs[i + 1], i + 1);
}
for (int i = 1; i <= n; ++i) {
invs[i] = mulM(ifs[i], fs[i - 1]);
}
}
long long nCk(int n, int k) {
if (n == k) {
return 1;
}
if (n < k || k < 0) {
return 0;
}
return mulM(fs[n], mulM(ifs[n - k], ifs[k]));
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
Solution sol;
int n, s, l;
cin >> n >> s >> l;
cout << sol.calc(n, s, l) << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 10005;
const int MOD = 998244353;
long long qpow(long long a, long long n) {
long long res = 1;
for (; n; n >>= 1, a = a * a % MOD)
if (n & 1) res = res * a % MOD;
return res;
}
long long inv(long long x) { return qpow(x, MOD - 2); }
long long fact[MAXN], invFact[MAXN];
void init() {
fact[0] = 1;
for (int i = 1; i < MAXN; i++) fact[i] = fact[i - 1] * i % MOD;
invFact[MAXN - 1] = inv(fact[MAXN - 1]);
for (int i = MAXN - 2; ~i; i--) invFact[i] = invFact[i + 1] * (i + 1) % MOD;
}
long long combi(int n, int m) {
if (n < 0 || n < m) return 0;
return fact[n] * invFact[m] % MOD * invFact[n - m] % MOD;
}
long long calc(int n, int l, int s) {
if (!n) return !s;
long long res = 0;
for (int i = 0; i <= n; i++) {
long long temp = combi(n, i) * combi(s + n - 1 - i * l, n - 1) % MOD;
i % 2 ? res -= temp : res += temp;
res < 0 ? res += MOD : 0;
res >= MOD ? res -= MOD : 0;
}
return res;
}
int main() {
init();
int p, s, r;
scanf("%d %d %d", &p, &s, &r);
long long ans = 0;
for (int i = r; i <= s; i++)
for (int j = 1; j <= p && j * i <= s; j++) {
long long temp =
combi(p - 1, j - 1) * calc(p - j, i, s - j * i) % MOD * inv(j) % MOD;
ans += temp;
ans >= MOD ? ans -= MOD : 0;
}
ans = ans * inv(calc(p, s + 1, s - r)) % MOD;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1000010, N = 1000000, md = 998244353;
int T, p, s, r, f[128][10010], fct[mxn], ifc[mxn];
int power(int x, int p, int num = 1) {
for (; p; p >>= 1, x = 1ll * x * x % md)
if (p & 1) num = 1ll * num * x % md;
return num;
}
void add(int &x, int y) { x = (x + y) % md; }
int F(int s, int p) {
return 1ll * fct[s + p - 1] * ifc[p - 1] % md * ifc[s] % md;
}
int main() {
fct[0] = ifc[0] = 1;
for (int i = 1; i <= N; ++i) fct[i] = 1ll * fct[i - 1] * i % md;
ifc[N] = power(fct[N], md - 2);
for (int i = N - 1; i; --i) ifc[i] = (i + 1ll) * ifc[i + 1] % md;
scanf("%d%d%d", &p, &s, &r);
if (p == 1) {
puts("1");
return 0;
}
if (r == 0) {
printf("%d\n", power(p, md - 2));
return 0;
}
int num = F(s, p);
for (int i = 0, flg = -1; i <= p && r * i <= s; ++i, flg = -flg)
num = (num + 1ll * flg * fct[p] * ifc[i] % md * ifc[p - i] % md *
F(s - r * i, p)) %
md;
num = 1ll * num * power(p, md - 2) % md;
int sum = 1ll * fct[s - r + p - 1] * ifc[s - r] % md * ifc[p - 1] % md;
num = 1ll * num * power(sum, md - 2) % md;
printf("%d\n", (num + md) % md);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 6e5, mod = 998244353;
long long T, p, s, r, Ans, fac[maxn], inv[maxn];
long long read() {
long long x = 0, f = 1;
char c;
do {
c = getchar();
if (c == '-') f *= -1;
} while (!isdigit(c));
while (isdigit(c)) {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x * f;
}
long long qpow(long long x, long long i) {
long long res = 1;
while (i) {
if (i & 1) {
res = 1ll * res * x % mod;
}
x = 1ll * x * x % mod;
i /= 2;
}
return res;
}
long long C(long long x, long long y) {
if (y > x) return 0;
return 1ll * fac[x] * inv[y] % mod * inv[x - y] % mod;
}
int main() {
fac[0] = 1;
for (long long i = 1; i <= 500000; i++) {
fac[i] = 1ll * fac[i - 1] * i % mod;
}
inv[500000] = qpow(fac[500000], mod - 2);
for (long long i = 500000; i; i--) {
inv[i - 1] = 1ll * inv[i] * i % mod;
}
Ans = 0;
p = read();
s = read();
r = read();
long long opt = 1;
for (long long i = 1; i <= p; i++) {
Ans = (Ans + mod + opt * C(p, i) * C(s - i * r + p - 1, p - 1) % mod) % mod;
opt *= -1;
}
Ans =
1ll * Ans * qpow(1ll * C(s - r + p - 1, p - 1) * p % mod, mod - 2) % mod;
printf("%lld\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[10005][205];
long long bigMod(long long a, long long p) {
if (p == 0LL) return 1LL;
if (p == 1LL) return a;
long long ret = bigMod(a, p / 2);
ret = (ret * ret) % 998244353;
if (p % 2 == 1LL) ret = (ret * a) % 998244353;
return ret;
}
long long f(long long n, long long r) {
if (n == 0 || n == 1 || r == 0 || n == r) return dp[n][r] = 1LL;
if (dp[n][r] != -1) return dp[n][r];
return dp[n][r] = (f(n - 1, r) + f(n - 1, r - 1)) % 998244353;
}
long long calc(long long n, long long s, long long m) {
if (n == 0 && s == 0) return 1LL;
long long ans = 0;
for (long long i = 0; i <= n; i++) {
long long x = s - i * (m + 1) + (n - 1), y = n - 1;
long long sign = 1;
if (i % 2 == 1) sign = -1;
if (x >= y && x >= 0 && y >= 0) {
long long t = (dp[x][y] * dp[n][i]) % 998244353;
t = (t * sign + 998244353) % 998244353;
if (t < 0) t += 998244353;
ans += t;
ans = ans % 998244353;
} else
break;
}
return ans;
}
int main() {
memset(dp, -1, sizeof dp);
for (int i = 0; i < 10005; i++) {
for (int j = 0; j <= min(i, 203); j++) long long t = f(i, j);
}
long long p, s, r;
scanf("%lld %lld %lld", &p, &s, &r);
long long ans = 0;
for (long long t = r; t <= s; t++) {
for (long long q = 1; q <= p; q++) {
if (s - q * t < 0) break;
long long u = calc(p - q, s - q * t, t - 1);
long long v = dp[p - 1][q - 1];
long long w = bigMod(q, 998244353 - 2);
u = (u * v) % 998244353;
u = (u * w) % 998244353;
ans += u;
ans = ans % 998244353;
}
}
long long h = dp[s - r + p - 1][p - 1];
h = bigMod(h, 998244353 - 2);
ans = (ans * h) % 998244353;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
inline int add(int a, int b) {
if ((a += b) >= mod) a -= mod;
return a;
}
inline int dec(int a, int b) {
if ((a -= b) < 0) a += mod;
return a;
}
inline int mult(int a, int b) {
long long t = 1ll * a * b;
if (t >= mod) t %= mod;
return t;
}
inline int power(int a, int b) {
int out = 1;
while (b) {
if (b & 1) out = mult(out, a);
a = mult(a, a);
b >>= 1;
}
return out;
}
int p, s, r, fac[100010], ifac[100010];
inline int C(int a, int b) {
if (a < b) return 0;
return mult(fac[a], mult(ifac[b], ifac[a - b]));
}
int main() {
fac[0] = 1;
for (int i = 1; i <= 100000; i++) fac[i] = mult(fac[i - 1], i);
ifac[100000] = power(fac[100000], mod - 2);
for (int i = 99999; i >= 0; i--) ifac[i] = mult(ifac[i + 1], i + 1);
scanf("%d%d%d", &p, &s, &r);
if (p == 1) {
puts("1");
return 0;
}
int ans = 0, tot = C(s - r + p - 1, p - 1);
for (int i = r; i <= s; i++) {
if (i * p < s) continue;
for (int j = 0; j < p; j++) {
int sum = s - (j + 1) * i, peo = p - 1 - j, cur = 0;
if (!peo) {
cur = (sum == 0);
ans = add(ans, mult(cur, power(j + 1, mod - 2)));
break;
}
if (sum < 0) break;
for (int l = 0; l <= peo; l++) {
if (l * i > sum) break;
if (l == peo) {
if (l & 1)
cur = dec(cur, 1);
else
cur = add(cur, 1);
break;
}
if (l & 1)
cur = dec(cur, mult(C(peo, l), C(sum - l * i + peo - 1, peo - 1)));
else
cur = add(cur, mult(C(peo, l), C(sum - l * i + peo - 1, peo - 1)));
}
ans = add(ans, mult(mult(cur, C(p - 1, j)), power(j + 1, mod - 2)));
}
}
printf("%d\n", mult(ans, power(tot, mod - 2)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10006, M = 106, P = 998244353;
int jc[N], jcinv[N];
inline int ksm(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (long long)ans * a % P;
a = (long long)a * a % P;
b >>= 1;
}
return ans;
}
inline int C(int b, int a) {
if (a == b) return 1;
if (a < 0 || a > b) return 0;
return (long long)jc[b] * jcinv[a] % P * jcinv[b - a] % P;
}
inline int g(int s, int p, int x) {
int ans = 0;
for (int i = 0; i <= p; i++)
ans = (ans + (long long)((i & 1) ? P - 1 : 1) * C(p, i) % P *
C(s + p - 1 - i * (x + 1), p - 1) % P) %
P;
return ans;
}
inline int inv(int x) { return (long long)jc[x - 1] * jcinv[x] % P; }
int main() {
jc[0] = 1;
for (int i = 1; i <= 10000; i++) jc[i] = (long long)jc[i - 1] * i % P;
jcinv[10000] = ksm(jc[10000], P - 2);
for (int i = 10000; i; i--) jcinv[i - 1] = (long long)jcinv[i] * i % P;
int p, s, r;
cin >> p >> s >> r;
int ans = 0;
for (int i = r; i <= s; i++)
for (int j = 1; j <= p; j++)
ans = (ans + (long long)C(p - 1, j - 1) * inv(j) % P *
g(s - i * j, p - j, i - 1) % P) %
P;
cout << ((long long)ans * ksm(C(s - r + p - 1, p - 1), P - 2) % P + P) % P
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 7;
const long long MOD = 998244353;
long long fac[N], inv[N];
long long qpow(long long n, long long k) {
long long res = 1;
while (k) {
if (k & 1) res = res * n % MOD;
n = n * n % MOD;
k >>= 1;
}
return res;
}
void init() {
fac[0] = 1;
for (int i = 1; i < N; i++) fac[i] = fac[i - 1] * i % MOD;
inv[N - 1] = qpow(fac[N - 1], MOD - 2);
for (int i = N - 2; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % MOD;
}
long long C(int n, int k) {
if (k >= 0 && k <= n) return (fac[n] * inv[k] % MOD) * inv[n - k] % MOD;
return 0;
}
long long calc(int p, int s, int r) {
if (s == 0 && p == 0) return 1;
if (r < 0 || p < 0 || s < 0) return 0;
long long res = 0;
for (int i = 0; i <= p; i++)
res += C(p, i) * C(s + p - 1 - i * (r + 1), p - 1) % MOD * (i % 2 ? -1 : 1);
return (res + MOD) % MOD;
}
int main() {
init();
int p, s, r;
scanf("%d%d%d", &p, &s, &r);
long long ans = 0;
for (int i = r; i <= s; i++) {
for (int j = 1; j <= p; j++) {
ans += C(p - 1, j - 1) * qpow(j, MOD - 2) % MOD *
calc(p - j, s - i * j, i - 1) % MOD;
}
}
ans = ans % MOD;
ans = ans * qpow(C(s - r + p - 1, p - 1), MOD - 2) % MOD;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
long long inv[5105], C[5105][5105], s, r, p;
long long QuickPow(long long x, long long up) {
long long base = x, ans = 1;
while (up) {
if (up & 1) ans *= base, ans %= MOD;
base *= base;
base %= MOD;
up >>= 1;
}
return ans;
}
int main() {
scanf("%lld %lld %lld", &p, &s, &r);
C[0][0] = 1;
for (long long i = 1; i <= 5100; ++i) {
C[i][0] = 1;
for (long long j = 1; j <= i; ++j)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
inv[1] = 1;
for (long long i = 2; i <= 5100; ++i)
inv[i] = MOD - (MOD / i) * inv[MOD % i] % MOD;
long long ans = 0;
for (long long i = r; i <= s; ++i) {
if (i * p < s) continue;
for (long long j = 1; j <= p; ++j) {
if (j * i > s || (p - j) * (i - 1) + i * j < s) continue;
if (j == p && j * i == s)
ans += inv[j], ans %= MOD;
else if (j != p) {
long long tot = 0, rev = -1;
for (long long k = 0; k <= p - j && k * i <= s - i * j; ++k) {
rev = -rev;
tot += C[p - j][k] * C[s - i * j + p - j - 1 - k * i][p - j - 1] %
MOD * rev;
tot %= MOD;
tot += MOD;
tot %= MOD;
}
ans += tot * inv[j] % MOD * C[p - 1][j - 1] % MOD;
ans %= MOD;
}
}
}
long long inved = QuickPow(C[s - r + p - 1][p - 1], MOD - 2);
printf("%lld", ans * inved % MOD);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, mod = 998244353;
int inv[N], fac[N];
int ksm(int b, int n) {
int res = 1;
while (n) {
if (n & 1) res = 1ll * res * b % mod;
b = 1ll * b * b % mod;
n >>= 1;
}
return res;
}
void init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[n] = ksm(fac[n], mod - 2);
for (int i = n - 1; i >= 0; --i) inv[i] = 1ll * (i + 1) * inv[i + 1] % mod;
}
int C(int n, int m) {
if (n < m || n < 0 || m < 0) return 0;
return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}
int calc(int n, int m, int lim) {
if (n == 0) return 1;
if (n < 0) return 0;
int ans = 0;
for (int i = 0; i <= m; ++i) {
int tmp = 1ll * C(n - lim * i + m - 1, m - 1) * C(m, i) % mod;
if (i & 1)
ans = (ans + mod - tmp) % mod;
else
ans = (ans + tmp) % mod;
}
return ans;
}
signed main() {
int p, s, r, ans = 0;
cin >> p >> s >> r;
init(1e5);
for (int i = r; i <= s; ++i)
for (int j = 1; j <= p; ++j) {
if (i * j + (p - j) * (i - 1) < s) continue;
int tmp = 1ll * calc(s - j * i, p - j, i) * C(p - 1, j - 1) % mod;
ans = (ans + 1ll * tmp * ksm(j, mod - 2)) % mod;
}
cout << 1ll * ans * ksm(C(s - r + p - 1, p - 1), mod - 2) % mod;
}
|
#include <bits/stdc++.h>
using namespace std;
const int _ = 1e2;
const int maxn = 5e5 + _;
const int mod = 998244353;
inline int ad(int x, int y) { return x >= mod - y ? x - mod + y : x + y; }
inline int re(int x, int y) { return x < y ? x - y + mod : x - y; }
inline int mu(int x, int y) { return (long long)x * y % mod; }
inline int qp(int x, long long y) {
int r = 1;
while (y) {
if (y & 1) r = mu(r, x);
x = mu(x, x);
y >>= 1;
}
return r;
}
inline int iv(int x) { return qp(x, mod - 2); }
inline int dv(int x, int y) { return mu(x, qp(y, mod - 2)); }
inline int gcd(int x, int y) { return x ? gcd(y % x, x) : y; }
int fac[maxn], fac_inv[maxn];
int C(int n, int m) { return mu(fac[n], mu(fac_inv[m], fac_inv[n - m])); }
void yu() {
fac[0] = 1;
for (int i = 1; i < maxn; i++) fac[i] = mu(fac[i - 1], i);
fac_inv[maxn - 1] = iv(fac[maxn - 1]);
for (int i = maxn - 2; i >= 0; i--) fac_inv[i] = mu(fac_inv[i + 1], i + 1);
}
int p, s, r;
int h(int i) { return C(i + p - 1, p - 1); }
int main() {
yu();
scanf("%d%d%d", &p, &s, &r);
int f0 = 0;
for (int i = 0; i <= p && i * r <= s; i++) {
int gi = mu(C(p, i), h(s - i * r));
if (i & 1)
f0 = re(f0, gi);
else
f0 = ad(f0, gi);
}
printf("%d\n", dv(re(h(s), f0), mu(h(s - r), p)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
const long long mod = 998244353;
const long long maxn = 1e2 + 10;
const long long maxm = 5e3 + 105;
long long c[maxm][maxm];
long long inv[maxm], p, s, l, ans;
inline long long C(long long x, long long y) {
if (x < 0 || y < 0 || x > y) return 0;
return c[x][y];
}
inline long long calc(long long x, long long y, long long z) {
if (y == 0) return 1;
if (y < 0) return 0;
long long res = 0;
for (long long i = 0; i <= x; i++)
res = (res + ((i & 1) ? 998244352 : 1) * C(i, x) % mod *
C(x - 1, y - i * z + x - 1) % mod) %
mod;
return res;
}
inline long long ksm(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;
}
signed main() {
p = read(), s = read(), l = read();
c[0][0] = inv[1] = 1;
for (long long i = 1; i < maxm; i++) c[0][i] = 1;
for (long long i = 1; i < maxm; i++)
for (long long j = i; j < maxm; j++)
c[i][j] = (c[i - 1][j - 1] + c[i][j - 1]) % mod;
for (long long i = 2; i < maxm; i++)
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
for (long long i = l; i <= s; i++)
for (long long j = 1; j <= p; j++) {
if (i * j + (i - 1) * (p - j) < s) continue;
ans = (ans +
calc(p - j, s - i * j, i) * c[j - 1][p - 1] % mod * inv[j] % mod) %
mod;
}
printf("%lld\n",
(ans * ksm(c[p - 1][s - l + p - 1], mod - 2) % mod + mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inv2 = (998244353 + 1) / 2;
long long a[1000005], d, b[1000005], c[1000005], ans;
long long f[1000005], nf[1000005], inv[1000005];
int n, r, s;
long long pow_(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % 998244353;
x = x * x % 998244353;
y >>= 1;
}
return res;
}
long long C(long long x, long long y) {
return f[x] * nf[y] % 998244353 * nf[x - y] % 998244353;
}
long long calc(long long n, long long b, long long sum) {
if (sum < 0) return 0;
if (n == 0) return (sum == 0);
if (b == 0) return 0;
long long res = 0;
for (int i = 0; i <= min(n, sum / b); i++) {
if (i & 1)
(res -= C(n, i) * C(sum - i * b + n - 1, n - 1) % 998244353) %= 998244353;
else
(res += C(n, i) * C(sum - i * b + n - 1, n - 1)) %= 998244353;
}
return (res + 998244353) % 998244353;
}
int main() {
inv[1] = 1;
for (int i = 2; i < 1000005; i++)
inv[i] = 998244353 - (998244353 / i) * inv[998244353 % i] % 998244353;
f[0] = nf[0] = 1;
for (int i = 1; i < 1000005; i++)
f[i] = f[i - 1] * i % 998244353, nf[i] = nf[i - 1] * inv[i] % 998244353;
scanf("%d%d%d", &n, &s, &r);
if (s == 0) {
printf("%lld\n", inv[n]);
return 0;
}
for (int i = r; i <= s; i++) {
for (int j = 1; j <= n; j++) {
long long ret = calc(n - j, i, s - j * i) * C(n - 1, j - 1) % 998244353;
(ans += ret * inv[j]) %= 998244353;
}
}
ans = ans * pow_(calc(n, s + 1, s - r), 998244353 - 2) % 998244353;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const int MAXN = 10005;
long long fac[MAXN];
long long ifac[MAXN];
long long raise(long long a, long long p) {
if (p == 0) return 1;
long long cur = raise(a, p / 2) % MOD;
cur = (cur * cur) % MOD;
if (p % 2)
return (cur * a) % MOD;
else
return cur;
}
void prec() {
fac[0] = 1;
for (long long i = 1; i < MAXN; ++i) {
fac[i] = (fac[i - 1] * i) % MOD;
}
for (long long i = 0; i < MAXN; ++i) ifac[i] = raise(fac[i], MOD - 2);
}
long long choose(long long N, long long K) {
long long res = fac[N];
res *= ifac[K];
res %= MOD;
res *= ifac[N - K];
res %= MOD;
return (res + MOD) % MOD;
}
long long sab(long long P, long long S, long long R) {
if (P < 0 || S < 0) return 0;
if (P == 0 && S == 0)
return 1;
else if (P == 0)
return 0;
long long res = 0;
for (int i = 0; i <= min(P, S / (R + 1)); ++i) {
long long cur = 1;
if (i % 2) cur = -1;
cur *= choose(P, i);
cur %= MOD;
cur = (cur + MOD) % MOD;
cur *= choose(S - i * (R + 1) + P - 1, P - 1);
cur %= MOD;
cur = (cur + MOD) % MOD;
res += cur;
res %= MOD;
res = (res + MOD) % MOD;
}
return res;
}
int main() {
prec();
long long P, S, R;
cin >> P >> S >> R;
if (P == 1) {
cout << 1;
return 0;
}
long long res = 0;
long long Q = 0;
for (int i = R; i <= S; ++i) {
Q += choose(P - 2 + S - i, P - 2);
Q %= MOD;
Q = (Q + MOD) % MOD;
if (i == 0) {
if (S == 0) {
res += raise(P, MOD - 2);
res %= MOD;
res = (res + MOD) % MOD;
}
continue;
}
for (int j = 0; j <= P - 1; ++j) {
long long cur = choose(P - 1, j);
cur *= raise(j + 1, MOD - 2);
cur %= MOD;
cur = (cur + MOD) % MOD;
cur *= sab(P - (j + 1), S - (j + 1) * i, i - 1);
cur %= MOD;
cur = (cur + MOD) % MOD;
res += cur;
res %= MOD;
res = (res + MOD) % MOD;
}
}
res *= raise(Q, MOD - 2);
res %= MOD;
cout << (res + MOD) % MOD;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5210;
const long long mod = 998244353;
long long C[maxn][maxn];
long long f(int n, int m, int x) {
long long ans = 0;
if (!m) return (n == 0 && x > 0);
for (int i = 0, s = 1; i <= m; i++, s *= -1) {
if (n - i * x < 0) break;
ans += s * (C[m][i] * C[n - i * x + m - 1][m - 1] % mod),
(ans += mod) %= mod;
}
return ans;
}
long long poww(long long a, int b) {
long long res = 1;
while (b) {
if (b & 1) res *= a, res %= mod;
a *= a, a %= mod;
b >>= 1;
}
return res;
}
int main() {
for (int i = 0; i <= 5200; i++)
for (int j = 0; j <= i; j++)
C[i][j] = (j == 0 || j == i) ? 1 : (C[i - 1][j - 1] + C[i - 1][j]) % mod;
int r, p, s;
cin >> p >> s >> r;
long long ans = 0;
if (p == 1) {
puts("1");
return 0;
}
if (s == 0 && r == 0) {
printf("%lld\n", poww(p, mod - 2));
return 0;
}
for (int x = r; x <= s; x++) {
for (int i = 1; i <= p; i++) {
if (i * x > s) break;
ans += C[p - 1][i - 1] * f(s - i * x, p - i, x) % mod * poww(i, mod - 2) %
mod;
ans %= mod;
}
}
cout << ans * poww(C[s - r + p - 1][p - 1], mod - 2) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 10005, P = 998244353;
long long power(long long a, int b) {
long long ans = 1;
for (; b; a = a * a % P, b >>= 1)
if (b & 1) ans = ans * a % P;
return ans;
}
int fac[N], ref[N];
int main() {
int p, s, r;
scanf("%d%d%d", &p, &s, &r);
if (r == 0) {
printf("%d\n", (int)power(p, P - 2));
return 0;
}
fac[0] = 1;
for (int i = 1; i <= p + s; ++i) fac[i] = (long long)fac[i - 1] * i % P;
ref[p + s] = power(fac[p + s], P - 2);
for (int i = p + s; i >= 1; --i) ref[i - 1] = (long long)ref[i] * i % P;
int ans = 0;
for (int i = 1; i <= s / r && i <= p; ++i) {
int tmp = (long long)fac[s - i * r + p - 1] * fac[p - 1] % P * fac[s - r] %
P * ref[s - i * r] % P * ref[s - r + p - 1] % P * ref[i] % P *
ref[p - i] % P;
if (i & 1)
ans = (ans + tmp) % P;
else
ans = (ans + P - tmp) % P;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = 0;
long long x = 0, flag = 1;
while (!isdigit(ch)) {
ch = getchar();
if (ch == '-') flag = -1;
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * flag;
}
const long long mo = 998244353;
long long ksm(long long x, long long k) {
long long ans = 1;
while (k) {
if (k & 1) ans = (ans * x) % mo;
k >>= 1;
x = (x * x) % mo;
}
return ans;
}
long long fac[220000], vac[220000];
long long inv(long long x) { return ksm(x, mo - 2); }
long long c(long long n, long long m) {
return (fac[n] * ((vac[m] * vac[n - m]) % mo)) % mo;
}
int main() {
long long n = read(), s = read(), r = read(), ans = 0;
if (n == 1) {
printf("1");
return 0;
}
fac[0] = vac[0] = 1;
for (long long i = 1; i <= 200000; i++)
fac[i] = (fac[i - 1] * i) % mo, vac[i] = (vac[i - 1] * inv(i)) % mo;
for (long long o = r; o <= s; o++)
for (long long i = 1; i <= n && i * o <= s; i++) {
long long m = n - i, v = s - i * o, x = 0;
for (long long k = 0, flag = 1; k <= m && v - k * o >= 0;
k++, flag = -flag)
x = (x + flag * c(m, k) * c(v - k * o + m - 1, m - 1)) % mo;
if (!m && !v) x = 1;
ans = (ans + ((inv(i) * ((c(n - 1, i - 1) * x) % mo)) % mo)) % mo;
}
ans = (ans * inv(c(s - r + n - 1, n - 1))) % mo;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 110;
const int N = 5500;
const int MOD = 998244353;
inline int add(int u, int v) {
u += v;
if (u >= MOD) u -= MOD;
return u;
}
inline int sub(int u, int v) {
u -= v;
if (u < 0) u += MOD;
return u;
}
inline int mul(int u, int v) { return (long long)u * v % MOD; }
inline int power(int u, int v) {
int res = 1;
while (v) {
if (v & 1) res = mul(res, u);
u = mul(u, u);
v >>= 1;
}
return res;
}
inline int inv(int u) { return power(u, MOD - 2); }
int p, s, r;
int c[N][N];
void init() {
for (int i = 0; i < N; i++) {
for (int j = 0; j <= i; j++) {
if (j == i || j == 0)
c[i][j] = 1;
else
c[i][j] = add(c[i - 1][j], c[i - 1][j - 1]);
}
}
}
int getC(int n, int k) {
if (n < 0) return 0;
if (k > n || k < 0) return 0;
return c[n][k];
}
int get(int n, int sum, int lim) {
if (n == 0) {
if (sum == 0)
return 1;
else
return 0;
}
int res = 0;
for (int i = 0; i <= n; i++) {
int sumNow = sum - lim * i;
if (sumNow < 0) break;
int foo = getC(n, i);
foo = mul(foo, getC(sumNow + n - 1, n - 1));
if (i & 1) {
res = sub(res, foo);
} else {
res = add(res, foo);
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> p >> s >> r;
init();
int tot = getC(s - r + p - 1, p - 1);
int res = 0;
for (int i = r; i <= s; i++) {
for (int j = 1; j * i <= s && j <= p; j++) {
int foo = get(p - j, s - i * j, i);
foo = mul(foo, getC(p - 1, j - 1));
res = add(res, mul(foo, inv(j)));
}
}
cout << mul(res, inv(tot)) << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 6000, Mod = 998244353;
int n, Mins, Sums;
int Add(int x, int y) {
x += y;
return x >= Mod ? x - Mod : x;
}
int Sub(int x, int y) {
x -= y;
return x < 0 ? x + Mod : x;
}
int Quick_pow(int x, int po) {
int Ans = 1;
for (; po; po >>= 1, x = 1ll * x * x % Mod)
if (po & 1) Ans = 1ll * Ans * x % Mod;
return Ans;
}
int Inverse(int x) { return Quick_pow(x, Mod - 2); }
int Fac[MAXN + 5], Inv[MAXN + 5];
void Init() {
Fac[0] = 1;
for (int i = 1; i <= MAXN; i++) Fac[i] = 1ll * Fac[i - 1] * i % Mod;
Inv[MAXN] = Inverse(Fac[MAXN]);
for (int i = MAXN; i >= 1; i--) Inv[i - 1] = 1ll * Inv[i] * i % Mod;
}
int C(int n, int m) {
if (n < 0 || m < 0 || n - m < 0) return 0;
return 1ll * Fac[n] * Inv[m] % Mod * Inv[n - m] % Mod;
}
int Calc(int n, int m, int lim) {
int Ans = 0;
for (int i = 0; i <= m && i * lim <= n; i++)
Ans = Add(Ans, 1ll * (i & 1 ? Mod - 1 : 1) * C(m, i) % Mod *
C(n - i * lim + m - 1, m - 1) % Mod);
return Ans;
}
signed main() {
Init();
scanf("%d %d %d", &n, &Sums, &Mins);
if (n == 1) return printf("1") & 0;
int Ans = 0;
for (int i = Mins; i <= Sums; i++)
for (int j = 1; j <= n; j++) {
if (j * i > Sums && (n - j) * (i - 1) + j * i < Sums) continue;
if (j == n) {
if (j * i == Sums) Ans = Add(Ans, Inverse(j));
continue;
}
Ans = Add(Ans, 1ll * C(n - 1, j - 1) * Calc(Sums - i * j, n - j, i) %
Mod * Inverse(j) % Mod);
}
printf("%d\n", 1ll * Ans * Inverse(C(Sums - Mins + n - 1, n - 1)) % Mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void chkmin(T &a, T b) {
a < b ? a : a = b;
}
template <typename T>
inline void chkmax(T &a, T b) {
a < b ? a = b : a;
}
namespace fast_IO {
inline int read_int() {
register int ret = 0, f = 1;
register char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ret = (ret << 1) + (ret << 3) + int(c - 48);
c = getchar();
}
return ret * f;
}
} // namespace fast_IO
using namespace fast_IO;
int P, S, R;
long long dbinom[5105][105];
inline long long fast_power(long long x, long long k) {
long long res = 1;
while (k) {
if (k & 1) res *= x, res %= 998244353;
x *= x, x %= 998244353, k >>= 1;
}
return res;
}
inline long long inv(long long x) { return fast_power(x, 998244353 - 2); }
inline void init() {
P = read_int(), S = read_int(), R = read_int();
for (register int i = 0; i <= 5100; i++) dbinom[i][0] = 1;
for (register int i = 0; i <= 5100; i++)
for (register int j = 1; j <= i && j <= 100; j++)
dbinom[i][j] = (dbinom[i - 1][j - 1] + dbinom[i - 1][j]) % 998244353;
}
long long sum1, sum2;
inline long long calc(int n, int m, int x) {
long long res = 0;
for (register int i = 0; i <= m && i * x <= n; i++) {
long long tmp =
1ll * dbinom[m][i] * dbinom[n - x * i + m - 1][m - 1] % 998244353;
res += (i & 1) ? -tmp : tmp;
}
return (res % 998244353 + 998244353) % 998244353;
}
inline void dp() {
if (P == 1) {
puts("1");
return;
}
for (register int x = R; x <= S; x++) {
if (x * P < S) continue;
for (register int i = 1; i <= P; i++) {
if (i * x > S || (P - i) * (x - 1) + i * x < S) continue;
if (i == P) {
(sum2 += (i * x == S ? inv(i) : 0)) %= 998244353;
continue;
}
(sum2 += 1ll * dbinom[P - 1][i - 1] * calc(S - i * x, P - i, x) %
998244353 * inv(i)) %= 998244353;
}
}
sum1 = dbinom[S - R + P - 1][P - 1];
printf("%lld\n", 1ll * sum2 * inv(sum1) % 998244353);
}
int main() {
init();
dp();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 10 * 1000 + 7;
const int M = 100 + 7;
int fact[N], rfact[N];
int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
if (a < 0) a += MOD;
return a;
}
int mul(int a, int b) { return (a * 1ll * b) % MOD; }
int binpow(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
b >>= 1;
}
return res;
}
int cnk(int n, int k) {
if (n == k) return 1;
if (k < 0 || k > n) return 0;
return mul(fact[n], mul(rfact[k], rfact[n - k]));
}
int g(int s, int p, int m) {
int res = 0;
for (int i = 0; i < int(p + 1); i++)
res = add(res, mul(i & 1 ? MOD - 1 : 1,
mul(cnk(p, i), cnk(s + p - 1 - i * (m + 1), p - 1))));
return res;
}
int inv(int x) { return mul(rfact[x], fact[x - 1]); }
int main() {
fact[0] = 1;
for (int i = 1; i < N; ++i) fact[i] = mul(fact[i - 1], i);
rfact[N - 1] = binpow(fact[N - 1], MOD - 2);
for (int i = N - 2; i >= 0; --i) rfact[i] = mul(rfact[i + 1], i + 1);
int p, s, r;
scanf("%d%d%d", &p, &s, &r);
int Q = cnk(s - r + p - 1, p - 1);
int P = 0;
for (int t = r; t <= s; ++t)
for (int q = 1; q <= p; ++q)
P = add(P,
mul(mul(cnk(p - 1, q - 1), inv(q)), g(s - q * t, p - q, t - 1)));
printf("%d\n", mul(P, binpow(Q, MOD - 2)));
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 998244353, maxn = 100005;
int p, s, r, ans, all;
int fac[maxn], nfac[maxn], inv[maxn], mul[2];
inline int C(int n, int m) {
return n < m ? 0 : 1ll * fac[n] * nfac[m] % mod * nfac[n - m] % mod;
}
int ksm(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % mod;
a = 1ll * a * a % mod, b >>= 1;
}
return res;
}
int calc(int ps, int ss, int lim) {
if (ps == 0) return ss == 0;
int res = 0;
for (int i = 0; i <= ps && i * lim <= ss; i++)
res = (res + 1ll * mul[i & 1] * C(ps, i) % mod *
C(ss - i * lim + ps - 1, ps - 1) % mod) %
mod;
return res;
}
int main() {
fac[0] = fac[1] = nfac[0] = nfac[1] = inv[1] = mul[0] = 1, mul[1] = mod - 1;
for (int i = 2; i <= 100000; i++)
fac[i] = 1ll * fac[i - 1] * i % mod,
inv[i] = mod - 1ll * (mod / i) * inv[mod % i] % mod,
nfac[i] = 1ll * nfac[i - 1] * inv[i] % mod;
scanf("%d%d%d", &p, &s, &r);
for (int i = r; i <= s; i++)
for (int j = 1; j <= p && j * i <= s; j++)
ans = (ans + 1ll * C(p - 1, j - 1) * calc(p - j, s - j * i, i) % mod *
inv[j] % mod) %
mod;
all = C(s - r + p - 1, p - 1);
printf("%d\n", 1ll * ans * ksm(all, mod - 2) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, sum, mn, ans, p = 998244353, c[5111][5111];
long long ksm(long long x, long long y) {
long long xlh = 1;
while (y) {
if (y & 1) xlh = xlh * x % p;
x = x * x % p;
y /= 2;
}
return xlh;
}
void solve(long long x, long long sy) {
long long i, j, xlh, fa, zo = 0, now, hh, ha;
for (i = 0; i <= n; i++) {
if (x * i > sy) break;
hh = sy - x * i;
now = c[n][i];
ha = n - i;
fa = 0;
for (j = 0; j <= ha; j++) {
if (j * x > hh) break;
if (hh - j * x + ha - 1 < 0)
xlh = 1;
else
xlh = c[ha][j] * c[hh - j * x + ha - 1][ha - 1] % p;
if (j % 2 == 0)
fa = (fa + xlh) % p;
else
fa = (fa - xlh + p) % p;
}
zo = (zo + now * fa % p * ksm(i + 1, p - 2) % p) % p;
}
ans = (ans + zo) % p;
}
int main() {
long long i, j;
for (i = 0; i <= 5110; i++) c[i][0] = 1;
for (i = 1; i <= 5110; i++)
for (j = 1; j <= i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % p;
scanf("%lld%lld%lld", &n, &sum, &mn);
n--;
for (i = mn; i <= sum; i++) {
solve(i, sum - i);
}
n++;
printf("%lld", ans * ksm(c[sum - mn + n - 1][n - 1], p - 2) % p);
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
const long long N = 10050;
const long long M = 998244353;
long long fat[N], inv[N];
long long C(long long n, long long k) {
if (k > n) return 0;
return mod(fat[n] * mod(inv[k] * inv[n - k], M), M);
}
long long Inv[N];
void init() {
fat[0] = inv[0] = 1;
for (long long i = 1; i < N; i++) {
fat[i] = (1LL * fat[i - 1] * i) % M;
}
inv[N - 1] = exp(fat[N - 1], M - 2, M);
for (long long i = N - 2; i >= 0; i--) {
inv[i] = (inv[i + 1] * (i + 1)) % M;
if (i) {
Inv[i] = fat[i - 1] * inv[i] % M;
assert(Inv[i] * i % M == 1);
}
}
}
long long stars(long long n, long long m) {
if (m < 0) return 0;
assert(n >= 0);
if (m == 0) return 1;
return C(n + m - 1, n - 1);
}
long long stars_with_upper(long long n, long long m, long long mx) {
long long res = 0;
if (n * mx < m) return 0;
for (long long cnt = 0; cnt <= n; cnt++) {
long long cur = (long long)C(n, cnt) * stars(n, m - cnt * mx) % M;
if (cnt & 1)
res = (res - cur);
else
res = (res + cur);
if (res < 0) res += M;
if (res >= M) res -= M;
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
init();
long long n, m, r;
cin >> n >> m >> r;
long long tot = 0, good = 0;
long long R = r;
n--;
for (; r <= m; r++) {
tot += stars(n, m - r);
if (tot >= M) tot -= M;
for (long long cnt = 0; (cnt + 1) * r <= m and cnt <= n; cnt++) {
long long cur = Inv[(cnt + 1)] * C(n, cnt) % M *
stars_with_upper(n - cnt, m - (cnt + 1) * r, r) % M;
good += cur;
if (good >= M) good -= M;
}
}
r = R;
assert(tot == stars(n + 1, m - r));
long long res = mod(good * exp(tot, M - 2, M), M);
cout << res << "\n";
}
|
#include <bits/stdc++.h>
const int N = 5110, M = 998244353;
int p, r, s, i, j, x;
long long c[N][N], inv[N], ans;
void Uzi() {
for (i = 0; i < N; i++) {
c[i][0] = 1;
for (j = 1; j <= i; j++) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % M;
}
inv[1] = 1;
for (i = 2; i < N; i++) inv[i] = (M - M / i) * inv[M % i] % M;
}
void init() { scanf("%d%d%d", &p, &s, &r); }
long long C(int x, int y) {
if (x == y) return 1;
if (x < y || x < 0 || y < 0) return 0;
return c[x][y];
}
long long ksm(long long x, int p) {
long long s = 1;
while (p) {
if (p & 1) s = s * x % M;
p >>= 1;
x = x * x % M;
}
return s;
}
long long Inv(long long x) { return ksm(x, M - 2); }
void work() {
for (x = r; x <= s; x++)
for (i = 1; i <= p; i++)
for (j = 0; i + j <= p; j++) {
ans = (ans + c[p - 1][i - 1] *
((j % 2 ? -1 : 1) * c[p - i][j] *
C(s - i * x - j * x + p - i - 1, p - i - 1) % M) %
M * inv[i]) %
M;
}
ans = (ans + M) * Inv(c[s - r + p - 1][p - 1]) % M;
printf("%lld", ans);
}
int main() {
Uzi();
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
const int md = 998244353;
inline int add(int a, int b) {
a += b;
if (a >= md) a -= md;
return a;
}
inline int sub(int a, int b) {
a -= b;
if (a < 0) a += md;
return a;
}
inline int mul(int a, int b) { return (long long)a * b % md; }
inline int po(int a, int b) {
int r = 1;
while (b) {
if (b & 1) r = mul(r, a);
a = mul(a, a);
b >>= 1;
}
return r;
}
inline int inv(int a) { return po(a, md - 2); }
inline int di(int a, int b) { return mul(a, inv(b)); }
const int N = 100;
const int V = 5000;
int fact[N + V + 1], factinv[N + V + 1];
int n, s, t;
void fact_init() {
fact[0] = factinv[0] = 1;
for (int i = 1; i <= N + V; ++i) {
fact[i] = mul(fact[i - 1], i);
factinv[i] = inv(fact[i]);
}
}
inline int nCr(int n, int r) {
return mul(fact[n], mul(factinv[r], factinv[n - r]));
}
int get(int sum, int amt, int bound) {
if (!amt) return !sum;
int res = 0;
for (int i = 0; i <= amt && bound * i <= sum; ++i) {
int r = mul(nCr(amt, i), nCr(sum - bound * i + amt - 1, amt - 1));
if (i & 1) r = sub(0, r);
res = add(res, r);
}
return res;
}
int main() {
fact_init();
scanf("%d%d%d", &n, &s, &t);
int ans = 0;
int den = 0;
for (int i = t; i <= s; ++i) {
int r = 0;
for (int j = 1; j <= n && s >= i * j; ++j)
r = add(r, di(mul(get(s - i * j, n - j, i), nCr(n - 1, j - 1)), j));
ans = add(ans, r);
if (n - 2 >= 0)
den = add(den, nCr(n - 2 + s - i, n - 2));
else
den = add(den, !(s - i));
}
ans = di(ans, den);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const long long N = 2e5 + 7, mod = 998244353;
typedef long long aN[N];
aN ny, jc, njc;
long long readll() {
long long x = 0, w = 1;
int c = getchar();
for (; c < '0' || c > '9'; c - '-' || (w = -w), c = getchar())
;
for (; c >= '0' && c <= '9'; x = x * 10 + (c ^ 48), c = getchar())
;
return x * w;
}
int readchar(int l = '0', int r = 'z') {
int c = getchar();
for (; c < l || c > r; c = getchar())
;
return c;
}
long long C(long long n, long long m) {
return n < 0 || n > m ? 0 : jc[m] * njc[n] % mod * njc[m - n] % mod;
}
long long nC(long long n, long long m) {
return n < 0 || n > m ? 0 : njc[m] * jc[n] % mod * jc[m - n] % mod;
}
long long calc(long long n, long long m, long long r) {
if (!n) return !m;
long long sum = 0;
for (register long long i = 0; i <= n; i++) {
if (i * r > m) break;
sum = (sum + (i & 1 ? mod - 1 : 1) * C(i, n) % mod *
C(n - 1, m - i * r + n - 1)) %
mod;
}
return sum;
}
int main() {
long long p = readll(), s = readll(), r = readll(), sum = 0;
ny[1] = jc[0] = jc[1] = njc[0] = njc[1] = 1;
for (register long long i = 2; i <= 6500; i++)
jc[i] = jc[i - 1] * i % mod,
njc[i] = njc[i - 1] * (ny[i] = (mod - mod / i) * ny[mod % i] % mod) % mod;
for (register long long i = r; i <= s; i++)
for (register long long j = 1; j <= p; j++) {
if (i * j > s) break;
sum = (sum + ny[j] * C(j - 1, p - 1) % mod * calc(p - j, s - i * j, i)) %
mod;
}
printf("%lld\n", sum * nC(p - 1, s - r + p - 1) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void proc_status() {
ifstream t("/proc/self/status");
cerr << string(istreambuf_iterator<char>(t), istreambuf_iterator<char>())
<< endl;
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline T read() {
register T sum(0), fg(1);
register char ch(getchar());
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fg = -1;
for (; isdigit(ch); ch = getchar()) sum = sum * 10 - '0' + ch;
return sum * fg;
}
const int MOD = 998244353;
namespace MATH {
const int N = (int)1e4;
inline int fpm(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = (long long)x * x % MOD)
if (y & 1) res = (long long)res * x % MOD;
return res;
}
int fac[N + 5], ifac[N + 5];
inline int C(int n, int m) {
return n < m ? 0 : (long long)fac[n] * ifac[n - m] % MOD * ifac[m] % MOD;
}
inline void init() {
fac[0] = 1;
for (int i = 1; i <= N; ++i) fac[i] = (long long)fac[i - 1] * i % MOD;
ifac[N] = fpm(fac[N], MOD - 2);
for (int i = N - 1; i >= 0; --i)
ifac[i] = (long long)ifac[i + 1] * (i + 1) % MOD;
}
} // namespace MATH
using MATH::C;
using MATH::fpm;
int n, s, r;
inline void input() { n = read<int>(), s = read<int>(), r = read<int>(); }
inline int div_into(int N, int M) {
return N == 0 ? 1 : (M == 0 ? 0 : C(N + M - 1, M - 1));
}
inline void solve() {
int sum = 0, ans = 0;
for (int k = r; k <= s; ++k) {
(sum += div_into(s - k, n - 1)) %= MOD;
for (int t = 0; t <= n - 1 && k * (t + 1) <= s; ++t) {
const int N = n - 1 - t, S = s - k * (t + 1);
int res = 0;
for (int i = 0; i <= N; ++i)
if (S >= k * i)
(res += (long long)(i & 1 ? -1 : +1) * C(N, i) *
div_into(S - k * i, N) % MOD) %= MOD;
(ans += (long long)res * C(n - 1, t) % MOD * fpm(t + 1, MOD - 2) % MOD) %=
MOD;
}
}
ans = (long long)ans * fpm(sum, MOD - 2) % MOD;
printf("%d\n", (ans + MOD) % MOD);
}
int main() {
MATH::init();
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e4 + 5, inf = 998244353;
long long n, k, i, j;
long long in[N], f[N];
inline long long expo(long long n, long long k, long long p = inf) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
inline long long inv(long long a, long long p = inf) {
return expo(a, p - 2, p);
}
inline long long cc(long long a, long long b) {
if (a < b || b < 0) return 0;
return f[a] * in[b] % inf * in[a - b] % inf;
}
void fac() {
long long i;
f[0] = 1;
for (i = 1; i < N; i++) f[i] = f[i - 1] * i % inf;
in[N - 1] = inv(f[N - 1]);
for (i = N - 1; i > 0; i--) in[i - 1] = i * in[i] % inf;
}
long long util(long long num, long long rem, long long mx) {
if (num == 0) return (rem == 0);
if (mx < 0 || rem < 0) return 0;
long long ans = 0;
for (long long j = 0; j <= num; j++) {
long long distribute = rem - (mx + 1) * j;
long long ways = cc(num, j) * cc(num + distribute - 1, num - 1) % inf;
if (j & 1)
ans -= ways;
else
ans += ways;
}
return ans % inf;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long i, j, a, b, ans = 0, s, r, n;
fac();
cin >> n >> s >> r;
for (i = r; i < s + 1; i++)
for (j = 1; j < n + 1; j++)
ans +=
util(n - j, s - j * i, i - 1) * cc(n - 1, j - 1) % inf * inv(j) % inf;
ans = (ans % inf + inf) % inf;
long long total = inv(cc(s - r + n - 1, n - 1)) % inf;
cout << ans * total % inf;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-9;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 60;
const int mods = 998244353;
const int MAXN = 300005;
const int MX = 300000;
const int G = 3;
const int Gi = (mods + 1) / G;
const int INF = 0x3f3f3f3f;
namespace FastIO {
constexpr int SIZE = (1 << 21) + 1;
int num = 0, f;
char ibuf[SIZE], obuf[SIZE], que[65], *iS, *iT, *oS = obuf,
*oT = obuf + SIZE - 1, c;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char c) {
*oS++ = c;
if (oS == oT) flush();
}
inline void getc(char &c) {
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
(c != '0' && c != '1') && c != EOF;
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
;
}
inline void reads(char *st) {
char c;
int n = 0;
getc(st[++n]);
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c == '0' || c == '1';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
st[++n] = c;
}
template <class I>
inline void read(I &x) {
for (f = 1, c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
x = (x << 3) + (x << 1) + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (x < 0) putc('-'), x = -x;
if (!x) putc('0');
while (x) que[++num] = x % 10 + 48, x /= 10;
while (num) putc(que[num--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_Flusher_;
} // namespace FastIO
using FastIO ::print;
using FastIO ::putc;
using FastIO ::read;
using FastIO ::reads;
int fac[MAXN], inv[MAXN], Inv[MAXN], n, S, R, ans = 0;
int upd(int x, int y) { return x + y >= mods ? x + y - mods : x + y; }
int quick_pow(int x, int y) {
int ret = 1;
for (; y; y >>= 1) {
if (y & 1) ret = 1ll * ret * x % mods;
x = 1ll * x * x % mods;
}
return ret;
}
int C(int x, int y) {
return (y < 0 || x < y) ? 0
: 1ll * fac[x] * inv[y] % mods * inv[x - y] % mods;
}
void Init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % mods;
inv[n] = quick_pow(fac[n], mods - 2);
for (int i = n - 1; i >= 0; --i) inv[i] = 1ll * inv[i + 1] * (i + 1) % mods;
Inv[0] = 1;
for (int i = 1; i <= n; ++i) Inv[i] = 1ll * inv[i] * fac[i - 1] % mods;
}
signed main() {
Init(10000);
read(n), read(S), read(R);
for (int i = R; i <= S; ++i) {
for (int j = 0; j <= n - 1; ++j) {
int x = S - i * (j + 1), y = n - 1 - j, t = 0;
if (x < 0) continue;
if (y) {
for (int k = 0; k <= y; ++k)
if (k & 1)
t = upd(t,
mods - 1ll * C(y, k) * C(x - k * i + y - 1, y - 1) % mods);
else
t = upd(t, 1ll * C(y, k) * C(x - k * i + y - 1, y - 1) % mods);
} else
t = (x == 0);
ans = upd(ans, 1ll * C(n - 1, j) * t % mods * Inv[j + 1] % mods);
}
}
print(1ll * ans * inv[S - R + n - 1] % mods * fac[n - 1] % mods * fac[S - R] %
mods);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long p, s, r;
long long fac[10005];
long long qpow(long long x, long long y) {
long long sum = 1;
while (y) {
if (y & 1) {
sum = sum * x % mod;
}
x = x * x % mod;
y >>= 1;
}
return sum;
}
long long ny(int x) { return qpow(x, mod - 2); }
long long C(long long n, long long m) {
if (n < m || n < 0 || m < 0) return 0;
return fac[n] * ny(fac[m]) % mod * ny(fac[n - m]) % mod;
}
long long f(long long n, long long m, long long lim) {
if (n == 0) return 1;
if (n < 0) return 0;
long long sum = 0;
for (long long i = 0; i <= m; i++) {
long long t = (i & 1) ? (mod - 1ll) : 1ll;
sum = (sum + t * C(m, i) % mod * C(n - i * lim + m - 1ll, m - 1ll) % mod) %
mod;
}
return sum;
}
int main() {
scanf("%d%d%d", &p, &s, &r);
fac[0] = 1;
for (long long i = 1; i <= 10000; i++) {
fac[i] = fac[i - 1] * i % mod;
}
long long ans = 0;
for (long long i = r; i <= s; i++) {
for (long long j = 1; j <= p; j++) {
if ((p - j) * (i - 1) + j * i < s) continue;
ans =
(ans + f(s - i * j, p - j, i) * C(p - 1, j - 1) % mod * ny(j) % mod) %
mod;
}
}
printf("%lld", ans * ny(C(s - r + p - 1, p - 1)) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10000 + 10, mod = 998244353;
int rd() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * w;
}
int fpow(int a, int b) {
int an = 1;
while (b) {
if (b & 1) an = 1ll * an * a % mod;
a = 1ll * a * a % mod, b >>= 1;
}
return an;
}
int ginv(int a) { return fpow(a, mod - 2); }
int n, k, m, fac[N], iac[N], inv[N];
int C(int a, int b) {
return b < 0 || a < b ? 0 : 1ll * fac[a] * iac[b] % mod * iac[a - b] % mod;
}
int wk(int a, int b) { return !a && !b ? 1 : C(a + b - 1, b - 1); }
int main() {
fac[0] = 1;
for (int i = 1; i <= N - 10; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
iac[N - 10] = ginv(fac[N - 10]);
for (int i = N - 10; i; --i) iac[i - 1] = 1ll * iac[i] * i % mod;
inv[0] = 1;
for (int i = 1; i <= N - 10; ++i) inv[i] = 1ll * iac[i] * fac[i - 1] % mod;
n = rd(), m = rd(), k = rd();
int ans = 0, dt = 0;
while (k <= m) {
dt = (dt + wk(m - k, n - 1)) % mod;
for (int i = 0; i < n; ++i) {
int sm = 0, lm = n - 1 - i;
for (int j = 0; j <= lm; ++j) {
int dx = 1ll * C(lm, j) * wk(m - k * (i + j + 1), lm) % mod;
sm = (sm + ((j & 1) ? mod - dx : dx)) % mod;
}
sm = 1ll * sm * C(n - 1, i) % mod;
ans = (ans + 1ll * sm * inv[i + 1] % mod) % mod;
}
++k;
}
ans = 1ll * ans * ginv(dt) % mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (typename vector<T>::const_iterator vi = v.begin(); vi != v.end(); ++vi) {
if (vi != v.begin()) os << ", ";
os << *vi;
}
os << "}";
return os;
}
const int MAX_CHOOSE = 5200;
const int MOD = 998244353;
long long mod_inv(long long a, long long m = MOD) {
return a == 1 ? 1 : m - mod_inv(m % a, a) * m / a;
}
vector<int> choose[MAX_CHOOSE];
int mod_add(int a, int b) {
int sum = a + b;
return sum < MOD ? sum : sum - MOD;
}
void precompute_choose() {
for (int n = 0; n < MAX_CHOOSE; n++) {
choose[n].assign(n + 1, 0);
choose[n][0] = choose[n][n] = 1;
for (int r = 1; r < n; r++)
choose[n][r] = mod_add(choose[n - 1][r], choose[n - 1][r - 1]);
}
}
int ways_to_distribute(int score, int players) {
if (score == 0) return 1;
if (players == 0) return 0;
return choose[score + players - 1][score];
}
vector<int> new_counts;
void add_one(vector<int> &counts, int me) {
new_counts.resize(counts.size());
int sum = 0;
for (int i = 0; i < (int)counts.size(); i++) {
sum += counts[i];
if (i >= me) sum -= counts[i - me];
if (sum >= MOD)
sum -= MOD;
else if (sum < 0)
sum += MOD;
new_counts[i] = sum;
}
swap(counts, new_counts);
}
int main() {
precompute_choose();
int P, S, R;
cin >> P >> S >> R;
if (P == 1) {
cout << 1 << '\n';
return 0;
}
if (S == 0) {
cout << mod_inv(P) << '\n';
return 0;
}
long long total = 0, denominator = 0;
for (int me = R; me <= S; me++) {
long long ways = ways_to_distribute(S - me, P - 1);
denominator = (denominator + ways) % MOD;
if (me > S - me) {
total = (total + ways) % MOD;
continue;
}
if (me * P < S) continue;
int max_same = S / me;
assert(max_same >= 2 && max_same <= P);
vector<int> counts(S - me + 1, 0);
counts[0] = 1;
for (int i = 0; i < P - max_same; i++) add_one(counts, me);
for (int same = max_same; same > 0; same--) {
long long less_than = counts[S - same * me];
total =
(total + less_than * choose[P - 1][same - 1] % MOD * mod_inv(same)) %
MOD;
add_one(counts, me);
}
}
total %= MOD;
total = total * mod_inv(denominator) % MOD;
cout << total << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <class T>
ostream& prnt(ostream& out, T v) {
out << v.size() << '\n';
for (auto e : v) out << e << ' ';
return out;
}
template <class T>
ostream& operator<<(ostream& out, vector<T> v) {
return prnt(out, v);
}
template <class T>
ostream& operator<<(ostream& out, set<T> v) {
return prnt(out, v);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, map<T1, T2> v) {
return prnt(out, v);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
return out << '(' << p.first << ' ' << p.second << ')';
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
const long long N = 2 * 5010;
const long long MOD = 998244353;
long long n, fact[N];
long long powMod(long long base, long long exp) {
if (exp == 0) return 1;
long long tmp = powMod(base, exp / 2);
tmp = (1LL * tmp * tmp) % MOD;
if (exp % 2) tmp = (tmp * base) % MOD;
return tmp;
}
long long invMod(long long a) { return powMod(a, MOD - 2); }
long long comb(long long n, long long k) {
return (1LL * fact[n] * invMod((1LL * fact[k] * fact[n - k]) % MOD)) % MOD;
}
long long stars_bars(long long n, long long s) {
if (s < 0) return 0;
if (n < 0) return 0;
if (s == 0 && n == 0) return 1;
return comb(n + s - 1, s);
}
long long stars_bars_bound(long long n, long long s, long long limit) {
long long mul = 1;
long long ret = 0;
for (long long i = 0; i <= n; i++) {
ret += (mul * comb(n, i) * stars_bars(n, s - i * limit)) % MOD;
mul *= -1;
ret %= MOD;
}
return ret;
}
void pre() {
fact[0] = 1;
for (long long i = 1; i < N; i++) fact[i] = (1LL * i * fact[i - 1]) % MOD;
}
int main() {
ios_base::sync_with_stdio(false);
pre();
long long p, s, r;
cin >> p >> s >> r;
long long ans = 0, tot = 0;
tot = stars_bars(p, s - r) % MOD;
for (long long i = 1; i <= p; i++) {
for (long long j = r; j <= s; j++) {
if (s >= i * j) {
ans = (ans +
comb(p - 1, i - 1) *
(MOD + (stars_bars_bound(p - i, s - i * j, j) * invMod(i)) %
MOD)) %
MOD;
}
}
}
cerr << "ans, tot"
<< " ->",
debug_out(ans, tot);
cout << (ans * invMod(tot)) % MOD;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
long long inv[5110], fac[5110], s_inv[5110];
void prepare() {
fac[0] = inv[0] = s_inv[0] = 1;
inv[1] = s_inv[1] = fac[1] = 1;
for (long long i = (2); i <= (5100); ++i) {
inv[i] = (MOD - MOD / i) * inv[MOD % i] % MOD;
s_inv[i] = s_inv[i - 1] * inv[i] % MOD;
fac[i] = fac[i - 1] * i % MOD;
}
}
long long c(long long n, long long k) {
if (n == k) return 1;
if (k > n || k < 0) return 0;
return fac[n] * s_inv[k] % MOD * s_inv[n - k] % MOD;
}
long long g(long long s, long long p, long long m) {
long long ret = 0, sign = -1;
for (long long i = (0); i <= (p); ++i) {
sign *= -1;
ret =
(ret + sign * c(p, i) % MOD * c(s - i * (m + 1) + p - 1, p - 1) % MOD) %
MOD;
}
return ret;
}
long long power(long long x, long long y) {
long long ret = 1;
while (y > 0) {
if (y & 1) ret = ret * x % MOD;
x = x * x % MOD;
y >>= 1;
}
return ret;
}
int main() {
prepare();
long long p, s, r;
scanf("%lld %lld %lld", &p, &s, &r);
long long P = 0, Q = c(s - r + p - 1, p - 1);
for (long long t = (r); t <= (s); ++t)
for (long long q = 1; q * t <= s && q <= p; ++q) {
P = (P +
c(p - 1, q - 1) * g(s - q * t, p - q, t - 1) % MOD * inv[q] % MOD) %
MOD;
}
printf("%lld\n", P * power(Q, MOD - 2) % MOD);
return 0;
}
|
#include <bits/stdc++.h>
inline int gi() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
inline int pow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = 1ll * ret * x % 998244353;
x = 1ll * x * x % 998244353;
y >>= 1;
}
return ret;
}
int CC[5110][5110];
inline int C(int n, int m) {
if (n < m || n < 0 || m < 0) return 0;
return CC[n][m];
}
inline int solve(int n, int m, int lim) {
if (n == 0) return 1;
if (n < 0) return 0;
int ans = 0;
for (int i = 0; i <= m; ++i)
ans = (ans + 1ll * ((i & 1) ? 998244352 : 1) * C(m, i) % 998244353 *
C(n - lim * i + m - 1, m - 1)) %
998244353;
return ans;
}
int inv[101];
int main() {
CC[0][0] = 1;
for (int i = 1; i <= 5109; ++i) {
CC[i][0] = 1;
for (int j = 1; j <= i; ++j)
CC[i][j] = (CC[i - 1][j] + CC[i - 1][j - 1]) % 998244353;
}
int p = gi(), s = gi(), r = gi();
int ans = 0;
inv[1] = 1;
for (int i = 2; i <= p; ++i)
inv[i] = 998244353 - 1ll * (998244353 / i) * inv[998244353 % i] % 998244353;
for (int x = r; x <= s; ++x)
for (int i = 1; i <= p; ++i) {
if ((p - i) * (x - 1) + i * x < s) continue;
ans = (ans + 1ll * C(p - 1, i - 1) * solve(s - i * x, p - i, x) %
998244353 * inv[i]) %
998244353;
}
printf("%d\n",
1ll * ans * pow(C(s - r + p - 1, p - 1), 998244353 - 2) % 998244353);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MOD = 998244353;
const int MAXN = 100;
const int MAXSUM = 5000;
const int MAXFAC = MAXSUM + MAXN - 1;
void inc(int &a, int b) {
if ((a += b) >= MOD) a -= MOD;
}
void dec(int &a, int b) { inc(a, MOD - b); }
int pw(int x, int n) {
int ret = 1;
while (true) {
if (n & 1) ret = (long long)ret * x % MOD;
if ((n >>= 1) == 0) return ret;
x = (long long)x * x % MOD;
}
}
int n, sum, lbound;
int inv[MAXFAC + 1];
int fac[MAXFAC + 1];
int ifac[MAXFAC + 1];
int C(int a, int b) {
if (b < 0 || b > a) return 0;
return (long long)fac[a] * ifac[b] % MOD * ifac[a - b] % MOD;
}
int distribute(int a, int b) {
if (b == 0) return a == 0 ? 1 : 0;
return C(a + b - 1, b - 1);
}
int solve() {
inv[1] = 1;
for (int i = (2); i <= (MAXFAC); ++i)
inv[i] = (long long)(MOD - MOD / i) * inv[MOD % i] % MOD;
fac[0] = 1;
for (int i = (1); i <= (MAXFAC); ++i)
fac[i] = (long long)fac[i - 1] * i % MOD;
ifac[0] = 1;
for (int i = (1); i <= (MAXFAC); ++i)
ifac[i] = (long long)ifac[i - 1] * inv[i] % MOD;
int num = 0;
for (int me = (lbound); me <= (sum); ++me) {
for (int neq = 0; neq <= n - 1 && (1 + neq) * me <= sum; ++neq) {
int remscore = sum - (1 + neq) * me, remplayers = n - 1 - neq;
int ways = 0;
for (int nerr = 0; nerr <= remplayers && nerr * me <= remscore; ++nerr) {
int cur = (long long)C(remplayers, nerr) *
distribute(remscore - nerr * me, remplayers) % MOD;
if (nerr % 2 == 0)
inc(ways, cur);
else
dec(ways, cur);
}
ways = (long long)ways * C(n - 1, neq) % MOD;
inc(num, (long long)ways * inv[1 + neq] % MOD);
}
}
int den = distribute(sum - lbound, n);
return (long long)num * pw(den, MOD - 2) % MOD;
}
void run() {
scanf("%d%d%d", &n, &sum, &lbound);
printf("%d\n", solve());
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, s, m, P, Q;
long long f[5505], inv[5505];
inline long long POW(long long a, long long b = 998244353 - 2,
long long ans = 1) {
for (; b; b >>= 1, a = a * a % 998244353)
if (b & 1) ans = ans * a % 998244353;
return ans;
}
inline long long C(long long n, long long m) {
return n < m ? 0 : f[n] * inv[m] % 998244353 * inv[n - m] % 998244353;
}
void init(long long n) {
f[0] = inv[0] = 1;
for (long long i = 1; i <= n; i++)
f[i] = f[i - 1] * i % 998244353, inv[i] = POW(f[i]);
}
inline long long cal(long long n, long long s, long long lim) {
if (s == 0) return 1;
long long ans = C(s + n - 1, n - 1);
for (long long now, i = 1; i <= n and n + s - 1 - lim * i >= 0; i++)
now = C(n, i) * C(n + s - 1 - lim * i, n - 1) % 998244353,
(i & 1) ? ans -= now : ans += now;
return (ans % 998244353 + 998244353) % 998244353;
}
signed main() {
cin >> n >> s >> m;
init(5505 - 5);
Q = C(n + s - m - 1, n - 1);
for (long long now = m; now <= s; now++)
for (long long x = 1; x <= n and x * now <= s; x++)
if ((n - x) * (now - 1) + x * now >= s)
(P += cal(n - x, s - x * now, now) * POW(x) % 998244353 *
C(n - 1, x - 1)) %= 998244353;
cout << P * POW(Q) % 998244353;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
void add(long long &a, long long b) { a = (a + mod + b) % mod; }
long long mult(long long a, long long b) { return (a * b) % mod; }
long long combos[6010][105];
int p, s, r;
long long sbars(int nstars, int places) {
if (places == 0) {
if (nstars == 0) return 1LL;
return 0LL;
}
if (nstars == 0) return 1LL;
int tt = nstars + places - 1;
return combos[tt][places - 1];
}
void createcombos() {
combos[0][0] = 1LL;
combos[1][0] = 1;
combos[1][1] = 1;
for (int i = 2; i < 6010; i++) {
combos[i][0] = 1;
for (int j = 1; j < 105; j++) {
combos[i][j] = combos[i - 1][j - 1];
add(combos[i][j], combos[i - 1][j]);
}
}
}
long long modpow(long long u, int p) {
if (p == 0) return 1LL;
if (p % 2 == 0) {
long long tmp = modpow(u, p / 2);
return (tmp * tmp) % mod;
}
long long tmp = modpow(u, p - 1);
return (tmp * u) % mod;
}
long long inv(long long u) { return modpow(u, mod - 2); }
long long iv[5010];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> p >> s >> r;
createcombos();
for (int i = 1; i <= 5000; i++) {
iv[i] = inv(i);
}
int numleft = 0;
long long tp = 0LL;
long long bt = 0LL;
long long csum = 0LL;
for (int i = r; i <= s; i++) {
numleft = s - i;
add(bt, sbars(numleft, p - 1));
for (int j = 0; j <= p - 1; j++) {
long long cv = 0LL;
numleft = s - i - j * i;
if (numleft < 0) continue;
cv = sbars(numleft, p - j - 1);
cv = mult(cv, combos[p - 1][j]);
for (int k = 1; k <= p - j - 1; k++) {
long long sv = 0LL;
numleft = s - i - j * i - k * i;
if (numleft < 0) continue;
sv = sbars(numleft, p - j - 1);
sv = mult(sv, combos[p - j - 1][k]);
sv = mult(sv, combos[p - 1][j]);
if (k % 2 == 1) {
add(cv, 0 - sv);
} else
add(cv, sv);
}
add(csum, cv);
add(tp, mult(cv, iv[j + 1]));
}
}
long long ans = mult(tp, inv(bt));
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const long long inv2 = (998244353 + 1) / 2;
long long a[1000005], d, b[1000005], c[1000005], ans;
long long f[1000005], nf[1000005], inv[1000005];
int n, r, s;
long long pow_(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % 998244353;
x = x * x % 998244353;
y >>= 1;
}
return res;
}
long long C(long long x, long long y) {
return f[x] * nf[y] % 998244353 * nf[x - y] % 998244353;
}
long long calc(long long n, long long b, long long sum) {
if (sum < 0) return 0;
if (n == 0) return (sum == 0);
if (b == 0) return 0;
long long res = 0;
for (int i = 0; i <= min(n, sum / b); i++) {
if (i & 1)
(res -= C(n, i) * C(sum - i * b + n - 1, n - 1) % 998244353) %= 998244353;
else
(res += C(n, i) * C(sum - i * b + n - 1, n - 1)) %= 998244353;
}
return (res + 998244353) % 998244353;
}
int main() {
inv[1] = 1;
for (int i = 2; i < 1000005; i++)
inv[i] = 998244353 - (998244353 / i) * inv[998244353 % i] % 998244353;
f[0] = nf[0] = 1;
for (int i = 1; i < 1000005; i++)
f[i] = f[i - 1] * i % 998244353, nf[i] = nf[i - 1] * inv[i] % 998244353;
scanf("%d%d%d", &n, &s, &r);
if (s == 0) {
printf("%lld\n", inv[n]);
return 0;
}
for (int i = r; i <= s; i++) {
for (int j = 1; j <= n; j++) {
long long ret = calc(n - j, i, s - j * i) * C(n - 1, j - 1) % 998244353;
(ans += ret * inv[j]) %= 998244353;
}
}
ans = ans * pow_(calc(n, s + 1, s - r), 998244353 - 2) % 998244353;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110, X = 5010, P = 998244353;
void exGcd(int a, int b, int& x, int& y) {
if (!b) {
x = 1;
y = 0;
return;
}
exGcd(b, a % b, y, x);
y -= a / b * x;
}
int inv(int a) {
int x, y;
exGcd(a, P, x, y);
return x < 0 ? x + P : x;
}
int mpow(int x, int k) {
int ret = 1;
while (k) {
if (k & 1) ret = ret * (long long)x % P;
x = x * (long long)x % P;
k >>= 1;
}
return ret;
}
struct Simple {
int n;
vector<int> fac, ifac, inv;
void build(int n) {
this->n = n;
fac.resize(n + 1);
ifac.resize(n + 1);
inv.resize(n + 1);
fac[0] = 1;
for (int x = 1; x <= n; ++x) fac[x] = fac[x - 1] * (long long)x % P;
inv[1] = 1;
for (int x = 2; x <= n; ++x)
inv[x] = -(P / x) * (long long)inv[P % x] % P + P;
ifac[0] = 1;
for (int x = 1; x <= n; ++x) ifac[x] = ifac[x - 1] * (long long)inv[x] % P;
}
Simple() { build(1); }
void check(int k) {
int nn = n;
if (k > nn) {
while (k > nn) nn <<= 1;
build(nn);
}
}
int gfac(int k) {
check(k);
return fac[k];
}
int gifac(int k) {
check(k);
return ifac[k];
}
int ginv(int k) {
check(k);
return inv[k];
}
int binom(int n, int m) {
if (m < 0 || m > n) return 0;
return gfac(n) * (long long)gifac(m) % P * gifac(n - m) % P;
}
} simp;
int n, x, r;
int main() {
scanf("%d%d%d", &n, &x, &r);
if (x == 0 || n == 1) {
printf("%d\n", inv(n));
return 0;
}
int ans = 0, cnt = simp.binom(x - r + n - 1, n - 1);
r = max(1, r);
for (int b = r; b <= x; ++b) {
for (int m = 1; m < n; ++m) {
if (b * m > x) break;
int k = x - b * m;
int res = 0;
for (int i = 0; i * b <= k; ++i)
res =
(res + ((i & 1) ? (P - 1) : 1) * (long long)simp.binom(n - m, i) %
P * simp.binom(n - m + (k - i * b) - 1, n - m - 1) % P) %
P;
ans =
(ans + res * (long long)simp.ginv(m) % P * simp.binom(n - 1, m - 1)) %
P;
}
if (b * n == x) ans = (ans + simp.ginv(n)) % P;
}
printf("%d\n", int(ans * (long long)inv(cnt) % P));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int p, s, r, fac[10005], ifac[10005];
int Pow(int x, int k) {
int ret = 1;
while (k) {
if (k & 1) ret = 1ll * ret * x % mod;
k >>= 1;
x = 1ll * x * x % mod;
}
return ret;
}
int C(int n, int m) {
if (n < m) return 0;
return 1ll * fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}
int f(int sum, int n, int lim) {
if (!n && sum == 0) return 1;
if (lim < 0) return 0;
if (sum == 0) return 1;
if (!n) return 0;
int ans = 0;
for (int i = 0, coef = 1; i * (lim + 1) <= sum && i <= n;
i++, coef = mod - coef)
ans = (ans +
1ll * coef * C(n, i) % mod * C(sum - i * (lim + 1) + n - 1, n - 1)) %
mod;
return ans;
}
int main() {
scanf("%d%d%d", &p, &s, &r);
if (p == 1) puts("1"), exit(0);
fac[0] = 1;
for (int i = 1; i <= 10000; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
ifac[10000] = Pow(fac[10000], mod - 2);
for (int i = 9999; ~i; i--) ifac[i] = 1ll * ifac[i + 1] * (i + 1) % mod;
int ans = 0, tot = 0;
for (int i = r; i <= s; i++) {
for (int j = 0; i * (j + 1) <= s && j < p; j++) {
ans = (ans + 1ll * C(p - 1, j) * f(s - i * (j + 1), p - j - 1, i - 1) %
mod * Pow(j + 1, mod - 2)) %
mod;
}
}
for (int i = r; i <= s; i++) tot = (tot + C(s - i + p - 2, p - 2)) % mod;
ans = 1ll * ans * Pow(tot, mod - 2) % mod;
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
namespace my_std {
const long long inf = 0x3f3f3f3f;
const long long inff = 1e15;
inline long long read() {
long long sum = 0, f = 1;
char ch = 0;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
sum = (sum << 1) + (sum << 3) + (ch ^ 48);
ch = getchar();
}
return sum * f;
}
inline void write(long long x) {
if (x < 0) {
x = -x;
putchar('-');
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
putchar('\n');
}
inline void writesp(long long x) {
write(x);
putchar(' ');
}
} // namespace my_std
using namespace my_std;
const long long N = 5500, mod = 998244353;
long long p, r, s, mul[N], inv[N], c[N][N], ans;
inline long long ksmod(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = (ans * a) % mod;
}
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
inline long long C(long long n, long long m) {
if (m > n || m < 0 || n < 0) return 0;
long long res = inv[m] * inv[n - m] % mod;
res = res * mul[n] % mod;
return res;
}
inline void init() {
mul[0] = inv[0] = 1;
for (long long i = 1; i <= p + s; i++) mul[i] = (mul[i - 1] * i) % mod;
inv[p + s] = ksmod(mul[p + s], mod - 2);
for (long long i = p + s - 1; i; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
}
inline long long f(long long s, long long p, long long m) {
if (s == 0 && p == 0) return 1;
long long ans = 0, tmp = 1;
for (register long long i = (0); i <= (p); i++) {
if (s + p - 1 - i * (m + 1) < 0) break;
ans = (ans + tmp * C(p, i) % mod * C(s + p - 1 - i * (m + 1), p - 1) % mod +
mod) %
mod;
tmp *= -1;
}
return ans;
}
int main(void) {
p = read(), s = read(), r = read();
init();
for (register long long t = (r); t <= (s); t++)
for (register long long q = (1); q <= (p); q++)
ans = (ans + (C(p - 1, q - 1) * ksmod(q, mod - 2)) % mod *
f(s - q * t, p - q, t - 1)) %
mod;
ans = (ans * ksmod(C(s - r + p - 1, p - 1), mod - 2)) % mod;
writeln(ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
inline long long qpow(long long a, long long b = 998244353 - 2) {
long long res = 1;
for (; b; b >>= 1, a = a * a % 998244353)
if (b & 1) res = res * a % 998244353;
return res;
}
inline void add(long long& a, long long b) {
a += b;
if (a >= 998244353) a -= 998244353;
}
long long fac[1000005], inv[1000005];
void prework(long long n) {
fac[0] = 1;
for (register long long i = (1); i <= (n); ++i)
fac[i] = fac[i - 1] * i % 998244353;
inv[n] = qpow(fac[n]);
for (register long long i = (n - 1); i >= (0); --i)
inv[i] = inv[i + 1] * (i + 1) % 998244353;
}
inline long long C(long long n, long long m) {
return fac[n] * inv[m] % 998244353 * inv[n - m] % 998244353;
}
long long p, s, r, res;
long long calc(long long n, long long m, long long x) {
long long res = 0;
for (register long long i = (0); i <= (min(m, n / x)); ++i)
res += ((i & 1) ? 998244353 - 1 : 1) *
(C(m, i) * C(n - x * i + m - 1, m - 1) % 998244353) % 998244353,
res %= 998244353;
return res;
}
signed main() {
prework(1e6);
p = read(), s = read(), r = read();
if (p == 1) {
puts("1");
return 0;
}
for (register long long x = (r); x <= (s); ++x) {
if (x * p < s) continue;
for (register long long i = (1); i <= (p); ++i) {
if (i * x > s || i * x + (p - i) * (x - 1) < s) continue;
if (i == p)
res += (i * x == s) * qpow(i) % 998244353;
else
res += C(p - 1, i - 1) * calc(s - i * x, p - i, x) % 998244353 *
qpow(i) % 998244353;
res %= 998244353;
}
}
cout << res * qpow(C(s - r + p - 1, p - 1)) % 998244353;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353, inv[10010], fac[10010], infac[10010];
long long C(long long n, long long m) {
if (n < m || n < 0 || m < 0) return 0;
return fac[n] * infac[m] % mod * infac[n - m] % mod;
}
long long f(long long n, long long s, long long a) {
if (!s) return 1;
if (s < 0 || n * (a - 1) < s) return 0;
long long sum = 0;
for (long long i = 0; i <= n; i++)
sum =
(sum + (i & 1 ? -1 : 1) * C(n, i) % mod * C(s - i * a + n - 1, n - 1)) %
mod;
return (sum + mod) % mod;
}
long long kuai(long long a, long long b) {
long long c = 1;
for (; b; b >>= 1) {
if (b & 1) c = a * c % mod;
a = a * a % mod;
}
return c;
}
int main() {
long long p, s, r;
scanf("%lld%lld%lld", &p, &s, &r);
inv[1] = fac[0] = fac[1] = infac[0] = infac[1] = 1;
for (long long i = 2; i <= 10000; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - (mod / i) * inv[mod % i] % mod;
infac[i] = infac[i - 1] * inv[i] % mod;
}
long long ans = 0;
for (long long i = 1; i <= p; i++)
for (long long j = r; j <= s; j++)
if (i * j + (p - i) * (j - 1) >= s)
ans = (ans + C(p - 1, i - 1) * inv[i] % mod * f(p - i, s - i * j, j)) %
mod;
printf("%lld", ans * kuai(C(s - r + p - 1, p - 1), mod - 2) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6, mod = 998244353;
int n, s, r, sl, fh, res, fac[1000010], ifc[1000010];
int rd() {
sl = 0;
fh = 1;
char ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') fh = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') sl = sl * 10 + ch - '0', ch = getchar();
return sl * fh;
}
int _pow(int k, int i) {
int t = 1;
for (; i; i >>= 1, k = 1ll * k * k % mod)
if (i & 1) t = 1ll * t * k % mod;
return t;
}
int C(int x, int y) { return 1ll * fac[x] * ifc[y] % mod * ifc[x - y] % mod; }
int main() {
n = rd();
s = rd();
r = rd();
res = 0;
fac[0] = 1;
for (int i = 1; i <= N; ++i) fac[i] = 1ll * i * fac[i - 1] % mod;
ifc[N] = _pow(fac[N], mod - 2);
for (int i = N; i; --i) ifc[i - 1] = 1ll * i * ifc[i] % mod;
for (int x = 1, i = 1; i <= n && i * r <= s; ++i, x = -x)
res = (res + 1ll * x * C(n, i) * C(s - i * r + n - 1, n - 1)) % mod;
res = 1ll * (res + mod) * _pow(n, mod - 2) % mod;
printf("%lld\n", 1ll * res * _pow(C(s - r + n - 1, n - 1), mod - 2) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
long long inv[10000 + 5], fac_inv[10000 + 5], fac[10000 + 5];
void initialize() {
long long i;
inv[1] = 1;
for (i = 2; i <= 10000; i++)
inv[i] = (998244353 - 998244353 / i) * inv[998244353 % i] % 998244353;
fac[0] = fac[1] = 1;
for (i = 2; i <= 10000; i++) fac[i] = i * fac[i - 1] % 998244353;
fac_inv[0] = fac_inv[1] = 1;
for (i = 2; i <= 10000; i++) fac_inv[i] = inv[i] * fac_inv[i - 1] % 998244353;
}
long long ncr(long long n, long long r) {
if (n < 0 || r < 0) return 0;
if (n < r) return 0;
return (fac[n] * fac_inv[r] % 998244353) * fac_inv[n - r] % 998244353;
}
long long solve(long long sc, long long n, long long s) {
if (s < 0) return 0;
if (n == 0 && s == 0) return 1LL;
long long ret = ncr(s + n - 1, n - 1);
for (long long i = 1; i <= n; ++i) {
long long kk = ncr(s - i * sc + n - 1, n - 1);
kk *= ncr(n, i);
kk %= 998244353;
if (i & 1)
ret -= kk;
else
ret += kk;
ret += 998244353;
ret %= 998244353;
}
return ret;
}
int _runtimeTerror_() {
long long p, s, r, i;
cin >> p >> s >> r;
long long ans = 0;
for (i = r; i <= s; ++i) {
for (long long j = 1; j <= p; ++j) {
long long fuck = solve(i, p - j, s - i * j);
ans += fuck * power(j, 998244353 - 2, 998244353) % 998244353 *
ncr(p - 1, j - 1) % 998244353;
ans %= 998244353;
}
}
long long tt = ncr(s - r + p - 1, p - 1);
cout << ans * power(tt, 998244353 - 2, 998244353) % 998244353 << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
initialize();
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void in(T &x) {
x = 0;
short f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + (c ^ '0'), c = getchar();
x *= f;
}
template <typename T, typename... Args>
inline void in(T &x, Args &...args) {
in(x);
in(args...);
}
template <class T>
inline void out(T x, const char c = '\n') {
static short st[30];
short m = 0;
if (x < 0) putchar('-'), x = -x;
do st[++m] = x % 10, x /= 10;
while (x);
while (m) putchar(st[m--] | '0');
putchar(c);
}
template <typename T, typename... Args>
inline void out(const T &x, const Args &...args) {
out(x, ' ');
out(args...);
}
template <class T>
inline void print(T a[], int n) {
if (n <= 0) return;
for (register int i = 0; i < n; ++i) out(a[i], ' ');
putchar('\n');
}
namespace i207M {
const int md = 998244353;
int qpow(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = (long long)a * a % md)
if (b & 1) res = (long long)res * a % md;
return res;
}
inline int inv(int v) { return qpow(v, md - 2); }
int P, S, R;
int fac[10005], ifac[10005];
void prework() {
fac[0] = 1;
for (register int i = 1; i <= 10000; ++i)
fac[i] = (long long)fac[i - 1] * i % md;
ifac[10000] = inv(fac[10000]);
for (register int i = 10000; i >= 1; --i)
ifac[i - 1] = (long long)ifac[i] * i % md;
}
inline int c(int n, int m) {
if (n < m) return 0;
return (long long)fac[n] * ifac[m] % md * ifac[n - m] % md;
}
inline int fen(int n, int m) {
if (n == 0 && m == 0) return 1;
return c(n + m - 1, m - 1);
}
inline int calc(int s, int p, int m) {
if (p == 0) return s == 0;
if (m < 0) return 0;
int ans = 0;
for (register int i = 0; i <= p && s - i * (m + 1) >= 0; ++i) {
int t = (long long)c(p, i) * fen(s - i * (m + 1), p) % md;
if (i & 1)
ans = (ans - t + md) % md;
else
ans = (ans + t) % md;
}
return ans;
}
signed main() {
prework();
in(P), in(S), in(R);
int ans = 0;
for (register int v = R; v <= S; ++v)
for (register int t = 1; t <= P && t * v <= S; ++t) {
ans = (ans + (long long)c(P - 1, t - 1) * calc(S - t * v, P - t, v - 1) %
md * inv(t)) %
md;
}
ans = (long long)ans * inv(fen(S - R, P)) % md;
out(ans);
return 0;
}
} // namespace i207M
signed main() {
i207M::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 10005;
const int BASE = 998244353;
int fact[MAX], ifact[MAX], inv[MAX];
int Power(int x, int y) {
if (!y) return 1;
int tmp = Power(x, y / 2);
if (y % 2) return (1LL * (1LL * tmp * tmp) % BASE * x) % BASE;
return (1LL * tmp * tmp) % BASE;
}
void Preprocess() {
fact[0] = 1;
for (int i = 1; i <= 10000; ++i) fact[i] = (1LL * fact[i - 1] * i) % BASE;
ifact[10000] = Power(fact[10000], BASE - 2);
for (int i = 10000 - 1; i >= 0; --i)
ifact[i] = (1LL * ifact[i + 1] * (i + 1)) % BASE;
for (int i = 1; i <= 10000; ++i) inv[i] = Power(i, BASE - 2);
}
int Comb(int k, int n) {
if (k > n) return 0;
return (1LL * (1LL * fact[n] * ifact[k]) % BASE * ifact[n - k]) % BASE;
}
int Calc(int n, int sum, int d) {
if (!n) {
if (!sum) return 1;
return 0;
}
int res = 0;
for (int i = 0; i <= n; ++i) {
int numGroup = Comb(i, n);
int numWay = 0;
if (sum >= i * (d + 1)) {
int remain = sum - i * (d + 1);
numWay = Comb(n - 1, remain + n - 1);
}
if (i % 2 == 0)
res = (res + 1LL * numGroup * numWay % BASE) % BASE;
else
res = (res - 1LL * numGroup * numWay % BASE + BASE) % BASE;
}
return res;
}
int Solve(int n, int sum, int d) {
int P = 0;
for (int i = 1; i <= n; ++i) {
int A = 0;
for (int j = d; j * i <= sum; ++j)
A = (A + Calc(n - i, sum - j * i, j - 1)) % BASE;
A = (1LL * A * inv[i]) % BASE;
P = (P + 1LL * A * Comb(i - 1, n - 1) % BASE) % BASE;
}
int Q = Comb(n - 1, sum - d + n - 1);
return 1LL * Power(Q, BASE - 2) * P % BASE;
}
int main() {
int n, sum, lim;
Preprocess();
cin >> n >> sum >> lim;
cout << Solve(n, sum, lim);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5205, mod = 998244353;
int n, s, r, inv[N], ans, C[N][N];
int ksm(int x, int y) {
int s = 1;
for (; y; y >>= 1, x = (long long)x * x % mod)
if (y & 1) s = (long long)s * x % mod;
return s;
}
void upd(int &x, int y) {
x += y;
x -= x >= mod ? mod : 0;
}
int calc(int n, int m, int lim) {
if (n == 0) return m == 0;
int res = 0;
for (int i = 0, op = 1; i <= n && i * lim <= m; i++, op = mod - op)
upd(res,
(long long)op * C[m - i * lim + n - 1][n - 1] % mod * C[n][i] % mod);
return res;
}
int main() {
scanf("%d%d%d", &n, &s, &r);
for (int i = (0); i <= (s + n); i++) C[i][0] = 1;
for (int i = (1); i <= (s + n); i++)
for (int j = (1); j <= (i); j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
inv[0] = inv[1] = 1;
for (int i = (2); i <= (n); i++)
inv[i] = (long long)inv[mod % i] * (mod - mod / i) % mod;
for (int i = (r); i <= (s); i++)
for (int j = 1, k = i, t; j <= n && k <= s; j++, k += i)
upd(ans, (long long)calc(n - j, s - k, i) * C[n - 1][j - 1] % mod *
inv[j] % mod);
ans = (long long)ans * ksm(C[s - r + n - 1][n - 1], mod - 2) % mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
long long powM(long long a, int t = mod - 2) {
long long ret = 1;
while (t) {
if (t & 1) ret = ret * a % mod;
a = a * a % mod;
t >>= 1;
}
return ret;
}
long long fac[10500], ifac[10500], inv[10500];
long long C(int n, int m) { return fac[n] * ifac[n - m] % mod * ifac[m] % mod; }
void Init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
ifac[n] = powM(fac[n]);
for (int i = n; i; i--) ifac[i - 1] = ifac[i] * i % mod;
for (int i = 1; i <= n; i++) inv[i] = ifac[i] * fac[i - 1] % mod;
}
long long S(int n, int m, int c) {
if (!n) return !m;
long long ret = 0;
for (int i = 0; i <= n && m - i * c + n > 0; i++) {
int sav = C(n, i) * C(m - (c + 1) * i + n - 1, n - 1) % mod;
ret += (i & 1) ? -sav : sav;
}
return ret % mod;
}
int main() {
int p, r, s;
scanf("%d%d%d", &p, &s, &r);
Init(s + r + p);
long long ans = 0;
for (int k = r; k <= s; k++)
for (int t = 1; t <= p && t * k <= s; t++)
ans =
(ans + inv[t] * C(p - 1, t - 1) % mod * S(p - t, s - t * k, k - 1)) %
mod;
printf("%lld", ans * powM(C(s - r + p - 1, p - 1)) % mod);
return 0;
}
|
#include <bits/stdc++.h>
namespace my_std {
using namespace std;
const long long INF = 0x7fffffff;
inline long long read() {
long long sum = 0, f = 0;
char c = getchar();
while (!isdigit(c)) {
f |= (c == '-');
c = getchar();
}
while (isdigit(c)) {
sum = (sum << 1) + (sum << 3) + (c ^ 48);
c = getchar();
}
return f ? -sum : sum;
}
void write(long long k) {
if (k < 0) putchar('-'), k = -k;
if (k >= 10) write(k / 10);
putchar(k % 10 + '0');
}
inline void chkmax(long long &x, long long y) {
if (x < y) x = y;
}
inline void chkmin(long long &x, long long y) {
if (x > y) x = y;
}
} // namespace my_std
using namespace my_std;
const long long N = 100010;
const long long mod = 998244353;
long long s, r, p, fac[N], _fac[N];
inline long long quick_pow(long long x, long long k) {
long long res = 1;
while (k) {
if (k & 1) res = res * x % mod;
k >>= 1;
x = x * x % mod;
}
return res;
}
inline long long inv(long long x) { return quick_pow(x, mod - 2); }
inline void pre(long long n) {
fac[0] = _fac[0] = 1;
for (register long long i = (1); i <= (n); i++) fac[i] = fac[i - 1] * i % mod;
for (register long long i = (1); i <= (n); i++) _fac[i] = inv(fac[i]);
}
inline long long C(long long n, long long m) {
if (n < m || m < 0) return 0;
return fac[n] % mod * _fac[m] % mod * _fac[n - m] % mod;
}
inline void inc(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
inline void dec(long long &x, long long y) {
x -= y;
if (x < 0) x += mod;
}
inline long long ABS(long long x) { return (x % mod + mod) % mod; }
inline long long solve(long long n, long long m, long long s) {
long long sum = 0;
for (register long long i = (0); i <= (m); i++) {
if (i * s > n) break;
long long res = ABS(C(m, i) * C(n - i * s - 1 + m, m - 1));
i & 1 ? dec(sum, res) : inc(sum, res);
}
return ABS(sum);
}
signed main() {
p = read(), s = read(), r = read();
pre(10000);
long long ans = 0;
for (register long long k = (r); k <= (s); k++) {
if (k * p - s < 0) continue;
for (register long long i = (1); i <= (p); i++) {
if (i * k - s > 0) continue;
if ((k - 1) * (p - i) + i * k - s < 0) continue;
if (i != p)
inc(ans,
ABS(ABS(C(p - 1, i - 1) * solve(s - i * k, p - i, k)) * inv(i)));
else if (i * k == s)
inc(ans, ABS(inv(i)));
ans = ABS(ans);
}
}
write(ABS(ans * inv(C(s - r + p - 1, p - 1)))), putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 998244353;
const int N = 100005;
const double PI = acos(-1.0);
const double eps = 1e-9;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
string s = "/home/jslijin/jslijin/code/";
freopen((s + "code.in").c_str(), "r", stdin);
freopen((s + "code.out").c_str(), "w", stdout);
}
long long p, s, r, fac[50005], inv[50005], fac_inv[50005], cnt, x1 = 0, x2 = 0,
ans = 0;
inline long long C(long long n, long long m) {
if (n < 0 || m < 0 || n < m) return 0;
return fac[n] * fac_inv[m] % _p * fac_inv[n - m] % _p;
}
inline long long G(long long k, long long t, long long n) {
if (!t) return !n;
long long m = k ? ((t) < (n / k) ? (t) : (n / k)) : t, q = 1, ans = 0;
for (int p = (0); p <= (m); ++p)
ans += C(t, p) * q * C(t - 1 + n - k * p, t - 1) % _p, ans %= _p, q = -q;
return ans;
}
inline long long Pow(long long x, long long k) {
long long ans = 1;
for (; k; k >>= 1, (x *= x) %= _p)
if (k & 1) ans *= x, ans %= _p;
return ans;
}
int main() {
scanf("%lld%lld%lld", &p, &s, &r);
fac[0] = 1;
for (int i = (1); i <= (50000); ++i) fac[i] = fac[i - 1] * i % _p;
inv[1] = 1;
for (int i = (2); i <= (50000); ++i)
inv[i] = (_p - _p / i) * inv[_p % i] % _p;
fac_inv[0] = 1;
for (int i = (1); i <= (50000); ++i)
fac_inv[i] = fac_inv[i - 1] * inv[i] % _p;
cnt = C(p - 1 + s - r, p - 1);
for (int k = (r); k <= (s); ++k) x1 += G(k, p - 1, s - k), x1 %= _p;
for (int k = (r); k <= (s); ++k) {
long long m = k ? ((p - 1) < (s / k - 1) ? (p - 1) : (s / k - 1)) : p - 1;
for (int t = (1); t <= (m); ++t)
x2 += G(k, p - t - 1, s - (t + 1) * k) * fac[p - 1] % _p *
fac_inv[t + 1] % _p * fac_inv[p - t - 1] % _p,
x2 %= _p;
}
ans = (x1 + x2) % _p * Pow(cnt, _p - 2) % _p;
printf("%lld\n", (ans + _p) % _p);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &t) {
t = 0;
char c = getchar();
int f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') {
t = (t << 3) + (t << 1) + c - '0';
c = getchar();
}
t *= f;
}
template <typename T, typename... Args>
inline void read(T &t, Args &...args) {
read(t);
read(args...);
}
template <typename T>
inline void write(T x) {
if (x < 0) {
x = -x;
putchar('-');
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
int mul(int a, int b) { return 1ll * a * b % 998244353; }
int dec(int a, int b) { return a >= b ? a - b : a + 998244353 - b; }
int add(int a, int b) { return a + b >= 998244353 ? a + b - 998244353 : a + b; }
int qkpow(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = mul(a, a))
if (b & 1) res = mul(res, a);
return res;
}
int inv(int a) { return qkpow(a, 998244353 - 2); }
int p, s, r, ans, fac[5205], ifac[5205];
int binom(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return mul(fac[a], mul(ifac[b], ifac[a - b]));
}
int Solve(int n, int m, int lim) {
if (n == 0) return 1;
if (n < 0) return 0;
int res = 0;
for (register int i = 0, tmp; i <= m; ++i)
tmp = mul(binom(m, i), binom(n - i * lim + m - 1, m - 1)),
res = (i & 1 ? dec(res, tmp) : add(res, tmp));
return res;
}
signed main() {
read(p, s, r);
int up = 5100;
fac[0] = 1;
for (register int i = 1; i <= up; ++i) fac[i] = mul(fac[i - 1], i);
ifac[up] = inv(fac[up]);
for (register int i = up; i; --i) ifac[i - 1] = mul(ifac[i], i);
for (register int x = r; x <= s; ++x)
for (register int i = 1; i <= p; ++i)
if ((p - i) * (x - 1) + i * x >= s)
ans = add(ans, mul(Solve(s - i * x, p - i, x),
mul(binom(p - 1, i - 1), mul(ifac[i], fac[i - 1]))));
write(mul(ans, inv(binom(s - r + p - 1, p - 1)))), putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool inverse = false;
const int mod = 998244353;
int fac[10005];
int inv[10005];
int fpow(int a, int p) {
int res = 1;
while (p) {
if (p & 1) res = (long long)res * a % mod;
p >>= 1;
a = (long long)a * a % mod;
}
return res;
}
int c(int n, int k) {
int res = (long long)fac[n] * inv[k] % mod;
res = (long long)res * inv[n - k] % mod;
return res;
}
int func(int n, int s) {
if (n == 0 && s == 0) return 1;
return c(n + s - 1, s);
}
int g(int n, int s, int k) {
int res = func(n, s);
int mm = -1;
for (int i = 1; i * k <= s && i <= n; i++) {
res = (res + (long long)mm * c(n, i) * func(n, s - i * k)) % mod;
if (res < 0) {
res += mod;
}
mm = -1 * mm;
}
return res;
}
int main() {
fac[0] = 1;
for (int i = 1; i < 10005; i++) {
fac[i] = (long long)i * fac[i - 1] % mod;
}
for (int i = 0; i < 10005; i++) {
inv[i] = fpow(fac[i], mod - 2);
}
int p, s, r;
cin >> p >> s >> r;
int res = 0;
for (int i = r; i <= s; i++) {
for (int j = 0; j <= p - 1; j++) {
if ((j + 1) * i > s) break;
int tmp = c(p - 1, j);
tmp = (long long)tmp * g(p - j - 1, s - (j + 1) * i, i) % mod;
res = (res + (long long)tmp * fpow(j + 1, mod - 2)) % mod;
}
}
res = (long long)res * fpow(func(p, s - r), mod - 2) % mod;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
int64_t imax(const int64_t a, const int64_t b) { return std::max(a, b); }
int64_t imin(const int64_t a, const int64_t b) { return std::min(a, b); }
std::vector<int> irange(const int begin, const int end) {
std::vector<int> ret;
for (int i = begin; i <= end; i++) {
ret.push_back(i);
}
return ret;
}
template <typename T>
void printvec(const std::vector<T>& vec) {
for (int i = 0; i < vec.size(); i++) {
std::cout << vec[i] << " ";
}
std::cout << std::endl;
}
int64_t cal_mod(const int64_t n, const int64_t mod) {
if (mod <= 0) {
return n;
} else if (0 <= n) {
return n % mod;
} else {
int64_t tmp = (-n) / mod + 1;
return (n + tmp * mod) % mod;
}
}
int64_t pow_mod(int64_t x, int64_t n, const int64_t mod) {
int64_t ret = 1;
while (n > 0) {
if (n & 1) {
ret = cal_mod(ret * x, mod);
}
x = cal_mod(x * x, mod);
n = (n >> 1);
}
return ret;
}
class Combi_Num {
public:
int64_t mod;
std::vector<int64_t> factorial, factorial_inv, inv;
Combi_Num() {}
Combi_Num(const int n, const int64_t mod_in) {
mod = mod_in;
factorial.resize(n + 1, 0);
factorial_inv.resize(n + 1, 0);
inv.resize(n + 1, 0);
factorial[0] = 1;
factorial_inv[0] = 1;
inv[0] = 1;
for (int i = 1; i <= n; i++) {
factorial[i] = (factorial[i - 1] * i) % mod;
inv[i] = pow_mod(i, mod - 2, mod);
factorial_inv[i] = (factorial_inv[i - 1] * inv[i]) % mod;
}
}
int64_t combi(const int n, const int r) const {
return (factorial[n] * ((factorial_inv[r] * factorial_inv[n - r]) % mod)) %
mod;
}
int64_t perm(const int n, const int r) const {
return (factorial[n] * factorial_inv[n - r]) % mod;
}
int64_t separate(const int n, const int r, const int m) const {
if (n < r * m) {
return 0;
}
if (0 < m) {
return separate(n - r * m, r, 0);
}
if (n == 0) {
return 1;
}
if (r == 0) {
return 0;
}
return combi(n + r - 1, r - 1);
}
};
int p, s, r;
const int MOD = 998244353;
int main(int argc, char** argv) {
std::cout << std::fixed << std::setprecision(15);
std::cin >> p >> s >> r;
Combi_Num cn(1e4, MOD);
int64_t P = 0;
for (int64_t i = ((int64_t)r); i <= ((int64_t)s); i++) {
for (int64_t j = ((int64_t)1); j <= ((int64_t)p); j++) {
if (i * j > s) {
break;
}
int64_t num = 0;
for (int64_t k = ((int64_t)0); k <= ((int64_t)p - j); k++) {
if (i * (j + k) > s) {
break;
}
int sgn = (k % 2 == 0) ? 1 : -1;
num +=
cn.combi(p - j, k) * cn.separate(s - i * j - i * k, p - j, 0) * sgn;
num = cal_mod(num, MOD);
}
num *= cn.combi(p - 1, j - 1);
num %= MOD;
P += (num * cn.inv[j]) % MOD;
P %= MOD;
}
}
int64_t Q = cn.separate(s - r, p, 0);
int64_t ret = P * pow_mod(Q, MOD - 2, MOD);
std::cout << ret % MOD << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long p, s, r, ans, fac[10000], inv[10000];
int c[6005][6005];
long long kp(long long a, long long b) {
if (!b) return 1;
long long c = kp(a, b >> 1);
c = (c * c) % mod;
if (b & 1) c = (c * a) % mod;
return c;
}
void prework(int x) {
for (int i = 0; i <= x; i++) {
c[i][0] = 1;
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 <= x; i++) fac[i] = fac[i - 1] * i % mod;
long long invv = kp(fac[x], mod - 2);
for (int i = x; i; i--)
inv[i] = invv * fac[i - 1] % mod, invv = invv * i % mod;
}
int main() {
scanf("%lld%lld%lld", &p, &s, &r);
prework(6000);
for (int i = r; i <= s; i++) {
for (int j = 1; j <= p; j++)
if (!(i * j > s || (p - j) * (i - 1) + j * i < s)) {
if (j == p) {
if (i * j == s) ans = (ans + kp(p, mod - 2)) % mod;
} else {
long long t = 0;
for (long long k = 0, bo = 1, boo = -1;
k <= p - j && k * i <= s - j * i; k++, bo = bo * boo)
t = ((t +
bo * c[p - j][k] * c[s - (k + j) * i + p - j - 1][p - j - 1] %
mod +
mod) %
mod +
mod) %
mod;
ans = (ans + t * c[p - 1][j - 1] % mod * inv[j] % mod) % mod;
}
}
}
ans = ans * kp(c[s - r + p - 1][p - 1], mod - 2) % mod;
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
int C[5103][5103], S, R, P, inv[5003];
int poww(int a, int b) {
int tms = 1;
while (b) {
if (b & 1) tms = 1ll * tms * a % MOD;
a = 1ll * a * a % MOD;
b >>= 1;
}
return tms;
}
int calc(int p, int s, int l) {
if (!p) return !s;
int sum = 0;
for (int j = 0; j <= p && j * l <= s; ++j)
sum = (sum + (j & 1 ? MOD - 1ll : 1ll) * C[p][j] % MOD *
C[s - j * l + p - 1][p - 1]) %
MOD;
return sum;
}
int main() {
cin >> P >> S >> R;
for (int i = 0; i <= S + P; ++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;
}
inv[1] = 1;
for (int i = 2; i <= P; ++i)
inv[i] = MOD - 1ll * (MOD / i) * inv[MOD % i] % MOD;
int sum = 0;
for (int i = R; i <= S; ++i)
for (int j = 1; j * i <= S && j <= P; ++j)
sum = (sum +
1ll * calc(P - j, S - j * i, i) * C[P - 1][j - 1] % MOD * inv[j]) %
MOD;
cout << 1ll * sum * poww(C[S - R + P - 1][P - 1], MOD - 2) % MOD;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 5001;
int ans;
int ni[101];
int a[N * 2], nia[N * 2], f[N + 10];
int n, r, s;
long long calc(long long x, long long y) {
long long z = 1;
while (y) {
if (y & 1) z = z * x % mod;
x = x * x % mod, y /= 2;
}
return z;
}
long long CC(int x, int y) {
return y < 0 || x < y ? 0 : 1ll * a[x] * nia[y] % mod * nia[x - y] % mod;
}
int add(int x, int y) {
x += y;
return x >= mod ? x - mod : x;
}
int sub(int x, int y) {
x -= y;
return x < 0 ? x + mod : x;
}
int mul(int x, int y) { return 1ll * x * y % mod; }
int main() {
scanf("%d %d %d", &n, &s, &r);
a[0] = 1;
for (int i = 1; i < N * 2; i++) a[i] = 1ll * a[i - 1] * i % mod;
nia[N * 2 - 1] = calc(a[N * 2 - 1], mod - 2);
for (int i = N * 2 - 2; i >= 0; i--)
nia[i] = 1ll * nia[i + 1] * (i + 1) % mod;
ni[0] = ni[1] = 1;
for (int i = 2; i <= n; i++)
ni[i] = 1ll * ni[mod % i] * (mod - mod / i) % mod;
for (int i = 1; i * r <= s && i <= n; i++) {
if (i & 1)
ans = add(ans, mul(CC(n, i), CC(s - i * r + n - 1, n - 1)));
else
ans = sub(ans, mul(CC(n, i), CC(s - i * r + n - 1, n - 1)));
}
ans = mul(ans, ni[n]);
long long all = CC(s - r + n - 1, n - 1);
printf("%lld\n", ans * calc(all, mod - 2) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-8;
long long comb[5201][5201], p, s, r;
long long fastPow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long calc(long long p, long long up, long long sum) {
if (p == 0) return sum == 0;
long long ans = 0;
for (int i = 0; i <= p; i++) {
if (i * up > sum) break;
if (i & 1)
ans = (ans - comb[p][i] * comb[sum - i * up + p - 1][p - 1] % mod + mod) %
mod;
else
ans = (ans + comb[p][i] * comb[sum - i * up + p - 1][p - 1] % mod) % mod;
}
return ans;
}
int main() {
for (int i = 0; i <= 5200; i++)
for (int j = comb[i][0] = 1; j <= i; j++)
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % mod;
int up = 4, tar = 6, tmp = 0;
for (int i = 0; i < up; i++) {
for (int j = 0; j < up; j++) {
for (int k = 0; k < up; k++)
if (i + j + k == tar) tmp++;
}
}
scanf("%lld%lld%lld", &p, &s, &r);
if (p == 1) {
puts("1");
} else if (s == 0) {
printf("%d\n", fastPow(p, mod - 2));
} else {
long long Q = 0, P = 0;
for (int i = r; i <= s; i++) {
Q = (Q + comb[s - i + p - 2][p - 2]) % mod;
for (int j = 0; j < p && j * i + i <= s; j++) {
long long cnt1 = comb[p - 1][j];
long long cnt2 = calc(p - j - 1, i, s - (j * i + i));
P = (P + cnt1 * cnt2 % mod * fastPow(j + 1, mod - 2) % mod) % mod;
}
}
printf("%lld\n", P * fastPow(Q, mod - 2) % mod);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct md {
int v;
md(int _v = 0) { v = _v; }
void operator+=(md a) { v = (0LL + v + a.v) % 998244353; }
void operator-=(md a) { v = (0LL + v - a.v + 998244353) % 998244353; }
void operator*=(md a) { v = (1LL * v * a.v) % 998244353; }
};
md operator+(md a, md b) { return (0LL + a.v + b.v) % 998244353; }
md operator-(md a, md b) { return (0LL + a.v - b.v + 998244353) % 998244353; }
md operator*(md a, md b) { return (1LL * a.v * b.v) % 998244353; }
md bigmod(md b, long long i) {
md r(1);
for (int j = (29); j >= (0); j--) {
r *= r;
if ((i >> j) & 1) r *= b;
}
return r;
}
md fac[6005], inv[6005];
md ncr(int n, int r) { return fac[n] * inv[r] * inv[n - r]; }
int main() {
int p, r, s;
scanf("%d %d %d", &p, &s, &r);
fac[0] = inv[0] = 1;
for (int i = (1); i <= (6000); i++) {
fac[i] = fac[i - 1] * i;
inv[i] = bigmod(fac[i], 998244353 - 2);
}
md ans = 0;
for (int i = (r); i <= (s); i++) {
for (int j = (0); j <= (p - 1); j++) {
md cnt = 0;
for (int k = (0); k <= (p - 1 - j); k++) {
if (s < (j + k + 1) * i) break;
md v;
if (s == (j + k + 1) * i && p - 1 - j == 0) {
v = 1;
} else {
v = ncr(p - 1 - j, k) *
ncr(s - (j + k + 1) * i + (p - 1 - j - 1), p - 1 - j - 1);
}
if (~k & 1)
cnt += v;
else
cnt -= v;
}
cnt *= ncr(p - 1, j);
ans += cnt * bigmod(j + 1, 998244353 - 2);
}
}
ans *= bigmod(ncr(s - r + p - 1, p - 1), 998244353 - 2);
printf("%d\n", ans.v);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 998244353;
int p, r, s, n;
long long fac[6010], inv[6010];
long long pw(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 n, int m) {
if (m < 0 || m > n) {
return 0;
}
return fac[n] * inv[m] % Mod * inv[n - m] % Mod;
}
long long ni(int n) { return fac[n - 1] * inv[n] % Mod; }
int main() {
scanf("%d%d%d", &p, &s, &r);
if (p == 1) {
puts("1");
return 0;
}
n = p + s;
fac[0] = 1;
for (int i = 1; i <= n; i++) {
fac[i] = fac[i - 1] * i % Mod;
}
inv[n] = pw(fac[n], Mod - 2);
for (int i = n - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % Mod;
}
if (!s) {
cout << ni(n) << endl;
return 0;
}
long long ans = 0;
for (int i = r; i <= s; i++) {
for (int j = 1; j <= p && s - j * i >= 0; j++) {
long long res = 0;
if (s == i * j) {
ans = (ans + c(p - 1, j - 1) % Mod * ni(j)) % Mod;
continue;
}
for (int k = 0; k <= p - j; k++) {
long long now =
c(s - (j + k) * i + p - j - 1, p - j - 1) * c(p - j, k) % Mod;
if (k & 1) {
res = (res - now + Mod) % Mod;
} else {
res = (res + now) % Mod;
}
}
ans = (ans + res * c(p - 1, j - 1) % Mod * ni(j)) % Mod;
}
}
cout << ans * pw(c(s - r + p - 1, p - 1), Mod - 2) % Mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 200100;
const long long INF = 2000000100;
const long long MOD = 998244353;
long long P, R, S;
long long ans;
struct pt {
long long x, y;
pt(long long x0, long long y0) { x = x0, y = y0; }
pt operator*(long long n) { return pt(x * n, y * n); }
pt operator+(pt p) { return pt(x + p.x, y + p.y); }
pt operator-(pt p) { return pt(x - p.x, y - p.y); }
};
long long gcd(long long a, long long b, pt pa, pt pb) {
if (b == 1) return pb.x;
return gcd(b, a % b, pb, pa - (pb * (a / b)));
}
long long inv(long long a) {
return (gcd(MOD, a, pt(0, 1), pt(1, 0)) + MOD) % MOD;
}
long long conv(long long a, long long b) { return ((a % MOD) * inv(b)) % MOD; }
long long comb[6000][110];
void makecomb() {
for (long long i = 0; i < 5500; i++) {
comb[i][0] = 1;
}
for (long long k = 1; k < 105; k++) {
for (long long i = 1; i < 5500; i++) {
comb[i][k] = (comb[i - 1][k - 1] + comb[i - 1][k]) % MOD;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> P >> S >> R;
makecomb();
ans = 0;
for (long long r = R; r <= S; r++) {
for (long long m = 1; m < P && m * r <= S; m++) {
long long a = 0;
long long s = 1;
for (long long i = 0; i <= P - m && S - m * r - i * r >= 0; i++) {
a = ((a + s * comb[P - m][i] *
comb[S - m * r + P - m - 1 - i * r][P - m - 1]) %
MOD +
MOD) %
MOD;
s *= -1;
}
ans += conv(a * comb[P - 1][m - 1], m);
}
if (P * r == S) ans += conv(1, P);
}
ans %= MOD;
ans *= inv(comb[S - R + P - 1][P - 1]);
ans %= MOD;
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, P, Q, sum, low, p[100005];
int inline mul(int A, int B) { return (1ll * A * B) % 998244353; }
void inline add(int &A, int B) {
A += B;
if (A >= 998244353) A -= 998244353;
}
void inline sub(int &A, int B) {
A -= B;
if (A < 0) A += 998244353;
}
int Pow(int A, int B) {
if (B == 0) return 1;
int x = Pow(A, B / 2);
x = mul(x, x);
if (B % 2) x = mul(x, A);
return x;
}
int C(int nn, int kk) {
if (nn < 0 || nn < kk || kk < 0) return 0;
int ans = Pow(mul(p[kk], p[nn - kk]), 998244353 - 2);
ans = mul(ans, p[nn]);
return ans;
}
int candy(int nn, int kk) {
if (nn < 0 || kk < 0) return 0;
if (nn == 0) return 1;
return C(nn + kk - 1, kk - 1);
}
int solve(int m, int k, int upper) {
upper++;
int ans = 0;
for (int i = 0; i <= k; i++)
if (i % 2 == 0)
add(ans, mul(C(k, i), candy(m - upper * i, k)));
else
sub(ans, mul(C(k, i), candy(m - upper * i, k)));
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> sum >> low;
p[0] = 1;
for (int i = 1; i <= 100000; i++) p[i] = mul(p[i - 1], i);
Q = candy(sum - low, n);
for (int i = low; i <= sum; i++)
for (int j = 1; j <= n; j++) {
if (sum - j * i < 0) break;
int x1 = mul(C(n - 1, j - 1), solve(sum - i * j, n - j, i - 1));
add(P, mul(x1, Pow(j, 998244353 - 2)));
}
int res = mul(P, Pow(Q, 998244353 - 2));
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
void upd(int &x, int y) { x = x + y < 998244353 ? x + y : x + y - 998244353; }
int dp[100 + 5][5100 + 5];
long long qp(long long a, int k) {
long long ans = 1;
while (k) {
if (k & 1) ans = ans * a % 998244353;
a = a * a % 998244353;
k >>= 1;
}
return ans;
}
void solve(int N, int S, int upp) {
S += N;
dp[0][0] = 1;
for (int p = 1; p <= N; p++)
for (int s = 1; s <= S; s++) {
dp[p][s] = dp[p][s - 1];
upd(dp[p][s], dp[p - 1][s - 1]);
if (s - upp - 1 >= 0) upd(dp[p][s], 998244353 - dp[p - 1][s - upp - 1]);
}
}
long long fac[5100 + 5], inv[5100 + 5], ifac[5100 + 5];
long long C(long long n, long long m) {
return fac[n] * ifac[m] % 998244353 * ifac[n - m] % 998244353;
}
int main() {
fac[0] = ifac[0] = 1;
inv[1] = 1;
for (int i = 1; i <= 5100; i++) fac[i] = fac[i - 1] * i % 998244353;
for (int i = 2; i <= 5100; i++)
inv[i] = inv[998244353 % i] * (998244353 - 998244353 / i) % 998244353;
for (int i = 1; i <= 5100; i++) ifac[i] = ifac[i - 1] * inv[i] % 998244353;
int p, s, r;
scanf("%d%d%d", &p, &s, &r);
int ans = 0;
for (int i = r; i <= s; i++) {
if (i > s - i) {
if (p == 1)
upd(ans, s - i == 0);
else
upd(ans, C(s - i + p - 2, p - 2));
continue;
}
solve(p - 1, s - i, i);
for (int num = 0; num <= p - 1 && num * i <= s - i; num++) {
long long tmp = dp[p - 1 - num][s - i - num * i + p - 1 - num] *
qp(num + 1, 998244353 - 2) % 998244353;
tmp = tmp * C(p - 1, num) % 998244353;
upd(ans, tmp);
}
}
ans = ans * qp(C(s - r + p - 1, p - 1), 998244353 - 2) % 998244353;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
ll modpow(ll x, ll p, ll mod) {
ll res = 1LL;
for (; p; p >>= 1, (x *= x) %= mod)
if (p & 1) (res *= x) %= mod;
return res;
}
template <ll mod>
struct Mint {
ll x;
Mint(ll x = 0) : x((x %= mod) < 0 ? x + mod : x) {}
Mint& operator+=(Mint rhs) {
if ((x += rhs.x) >= mod) x -= mod;
return *this;
}
Mint& operator-=(Mint rhs) { return *this += mod - rhs.x; }
Mint& operator*=(Mint rhs) {
(x *= rhs.x) %= mod;
return *this;
}
Mint& operator/=(Mint rhs) { return *this *= modpow(rhs.x, mod - 2, mod); }
Mint power(ll p) const { return Mint(modpow(x, p, mod)); }
bool operator==(Mint rhs) const { return x == rhs.x; }
bool operator<(Mint rhs) const { return x < rhs.x; }
friend Mint operator+(Mint lhs, Mint rhs) { return lhs += rhs; }
friend Mint operator-(Mint lhs, Mint rhs) { return lhs -= rhs; }
friend Mint operator*(Mint lhs, Mint rhs) { return lhs *= rhs; }
friend Mint operator/(Mint lhs, Mint rhs) { return lhs /= rhs; }
friend ostream& operator<<(ostream& out, Mint a) { return out << a.x; }
friend istream& operator>>(istream& in, Mint& a) {
ll x;
in >> x;
a = Mint(x);
return in;
}
};
constexpr ll mod = 998244353;
using mint = Mint<mod>;
void advance(vector<mint>& dp, int n, int sum, int ub) {
for (int i = 0; i < n; ++i) {
for (int y = sum - ub; y >= 0; --y) {
dp[y + ub] -= dp[y];
}
for (int y = 1; y <= sum; ++y) {
dp[y] += dp[y - 1];
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int p, s, r;
cin >> p >> s >> r;
if (p == 1) {
cout << 1 << '\n';
exit(0);
}
if (r == 0) {
cout << 1 / mint(p) << '\n';
exit(0);
}
const int maxfact = s + p;
vector<mint> f(maxfact + 1, 1), inv(maxfact + 1, 1);
for (int x = 1; x <= maxfact; ++x) {
f[x] = x * f[x - 1], inv[x] = 1 / f[x];
}
auto C = [&f, &inv](int n, int k) {
if (k == 0) return mint(1);
return k > n ? 0 : f[n] * inv[k] * inv[n - k];
};
auto solve = [&C](int n, int sum, int ub) {
mint res = C(n - 1 + sum, sum);
for (int k = 1, sgn = -1; k <= min(n, sum / ub); ++k, sgn *= -1) {
mint cur = 0;
int remaining = sum - k * ub;
for (int x = 0; x <= remaining; ++x) {
cur += C(x + k - 1, x) * C(remaining - x + (n - k - 1), remaining - x);
}
res += sgn * C(n, k) * cur;
}
return res;
};
mint total = 0;
for (int x = r; x <= s; ++x) {
total += C(p - 2 + s - x, p - 2);
}
vector<mint> coef(p);
for (int k = 0; k < p; ++k) coef[k] = 1 / total / (k + 1);
mint res = 0;
constexpr int magic = 200;
for (int k = 0; k < p; ++k) {
for (int x = max(r, magic); x * (k + 1) <= s; ++x) {
res += C(p - 1, k) * solve(p - 1 - k, s - (k + 1) * x, x) * coef[k];
}
}
for (int x = r; x < magic && x <= s; ++x) {
int max_big = min(p, s / x);
vector<mint> dp(s + 1, 0);
dp[0] = 1;
advance(dp, p - max_big, s, x);
for (int k = max_big - 1; k >= 0; --k) {
res += C(p - 1, k) * dp[s - (k + 1) * x] * coef[k];
advance(dp, 1, s, x);
}
}
cout << res << '\n';
exit(0);
}
|
#include <bits/stdc++.h>
const int inf = 1e9;
int fact[10005], inv[10005];
int po(int b, int e) {
int p = 1;
while (e) {
if (e % 2 == 1) p = 1LL * p * b % 998244353;
b = 1LL * b * b % 998244353;
e = e / 2;
}
return p;
}
int comb(int n, int k) {
if (n < k) return 0;
int p = fact[n];
p = 1LL * p * inv[k] % 998244353;
p = 1LL * p * inv[n - k] % 998244353;
return p;
}
int cinv(int num) { return po(num, 998244353 - 2); }
int calc(int sum, int nr, int maxi) {
if (sum == 0 && nr == 0) return 1;
if (nr == 0) return 0;
if (maxi < 0) return 0;
int i, ans = 0;
for (i = 0; i <= nr; i++) {
if (i * (maxi + 1) > sum) break;
if (i % 2 == 0)
ans = (1LL * ans +
1LL * comb(nr, i) *
comb(sum - i * (maxi + 1) % 998244353 + nr - 1, nr - 1)) %
998244353;
else
ans = (1LL * ans -
1LL * comb(nr, i) * comb(sum - i * (maxi + 1) + nr - 1, nr - 1) %
998244353 +
998244353) %
998244353;
}
return ans;
}
int main() {
int p, s, r;
scanf("%d%d%d", &p, &s, &r);
int i;
fact[0] = 1;
for (i = 1; i <= 10000; i++) fact[i] = 1LL * fact[i - 1] * i % 998244353;
inv[10000] = po(fact[10000], 998244353 - 2);
for (i = 9999; i >= 0; i--) inv[i] = 1LL * inv[i + 1] * (i + 1) % 998244353;
int scor, cntm, sum = 0;
for (scor = r; scor <= s; scor++) {
for (cntm = 1; cntm <= p; cntm++) {
if (cntm * scor > s) break;
int aux = comb(p - 1, cntm - 1);
aux = 1LL * aux * cinv(cntm) % 998244353;
aux = 1LL * aux * calc(s - scor * cntm, p - cntm, scor - 1) % 998244353;
sum = (1LL * sum + aux) % 998244353;
}
}
sum = 1LL * sum * po(comb(s - r + p - 1, p - 1), 998244353 - 2) % 998244353;
printf("%d\n", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
int mul(long long a, long long b) { return (a * b) % MOD; }
int fpow(int x, int y) {
int ret = 1, base = x;
for (int i = 0; (y >> i); i++) {
if ((y >> i) & 1) ret = mul(ret, base);
base = mul(base, base);
}
return ret;
}
const int P = 110, S = 5010;
int c[S + P][P];
int calc(int s, int p) {
if (s < 0) return 0;
if (p == 0) return s == 0;
return c[s + p - 1][p - 1];
}
int calc2(int s, int p, int m) {
if (m < 0) return s == 0 and p == 0;
int excl = 0;
for (int i = 1; i <= p; i++) {
int cur = mul(c[p][i], calc(s - i * (m + 1), p));
if (i & 1) {
excl += cur;
excl %= MOD;
} else {
excl = (MOD + excl - cur) % MOD;
excl %= MOD;
}
}
return (MOD + calc(s, p) - excl) % MOD;
}
int inv(int x) { return fpow(x, MOD - 2); }
int inverse[P];
int main() {
for (int i = 1; i < P; i++) inverse[i] = inv(i);
c[0][0] = 1;
for (int i = 1; i < S + P; i++) {
c[i][0] = 1;
for (int j = 1; j < P; j++) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MOD;
}
int p, s, r;
scanf("%d %d %d", &p, &s, &r);
int ans = 0;
if (r == 0 and s == 0) {
printf("%d\n", inverse[p]);
return 0;
}
int itotalways = inv(calc(s - r, p));
for (int x = r; x <= s; x++) {
for (int t = 0; t <= p - 1 and (t + 1) * x <= s; t++) {
int rs = s - (t + 1) * x;
int rp = p - (t + 1);
int ways = mul(c[p - 1][t], calc2(rs, rp, x - 1));
int cur = mul(ways, itotalways);
cur = mul(cur, inverse[t + 1]);
ans += cur;
ans %= MOD;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char Buff[(1 << 18)], *_S = Buff, *_T = Buff;
template <typename T>
T read(void) {
T f = 1, num = 0;
char c = (_S == _T && (_T = (_S = Buff) + fread(Buff, 1, (1 << 18), stdin),
_S == _T)
? EOF
: *_S++);
while (!isdigit(c)) {
if (c == '-') f = -f;
c = (_S == _T &&
(_T = (_S = Buff) + fread(Buff, 1, (1 << 18), stdin), _S == _T)
? EOF
: *_S++);
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + (c ^ 48);
c = (_S == _T &&
(_T = (_S = Buff) + fread(Buff, 1, (1 << 18), stdin), _S == _T)
? EOF
: *_S++);
}
return f * num;
}
long long fac[5105], inv[5105];
long long power(long long a, long long x) {
long long ans = 1;
while (x) {
if (x & 1) ans = ans * a % 998244353;
a = a * a % 998244353;
x >>= 1;
}
return ans;
}
inline long long C(int n, int m) {
return n < m || n < 0 || m < 0
? 0
: fac[n] * inv[m] % 998244353 * inv[n - m] % 998244353;
}
long long solve(int n, int m, int lim) {
if (n == 0) return 1;
long long sum = 0;
for (register int i = 0; i <= m; i++)
sum = (sum + ((i & 1) ? -1 : 1) * C(m, i) % 998244353 *
C(n - i * lim + m - 1, m - 1) % 998244353) %
998244353;
return (sum % 998244353 + 998244353) % 998244353;
}
int main() {
fac[0] = inv[0] = 1;
for (register int i = 1; i < 5105; i++) fac[i] = fac[i - 1] * i % 998244353;
inv[5105 - 1] = power(fac[5105 - 1], 998244353 - 2);
for (register int i = 5105 - 2; i; i--)
inv[i] = inv[i + 1] * (i + 1) % 998244353;
int p = read<int>(), s = read<int>(), r = read<int>();
long long answer = 0;
for (register int x = r; x <= s; x++)
for (register int i = 1; i <= p; i++)
if (i * x + (p - i) * (x - 1) >= s && i * x <= s)
answer = (answer + solve(s - i * x, p - i, x) * C(p - 1, i - 1) %
998244353 * power(i, 998244353 - 2)) %
998244353;
printf("%lld\n",
answer * power(C(s - r + p - 1, p - 1), 998244353 - 2) % 998244353);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
int fac[5135], inv[5135];
void initfac(int n) {
fac[0] = inv[0] = 1;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
fac[i] = (long long)fac[i - 1] * i % 998244353;
inv[i] = fastPow(fac[i], 998244353 - 2);
}
}
int C(int n, int m) {
if (m < 0) return 0;
if (n < m) return 0;
return (long long)fac[n] * inv[m] % 998244353 * inv[n - m] % 998244353;
}
int cal(int n, int m, int lim) {
if (m == 0) {
return n == 0;
}
int ans = 0;
for (int i = 0; i <= m; i++) {
int z = (long long)C(m, i) * C(n - i * lim + m - 1, m - 1) % 998244353;
if (i % 2 == 0)
addmod(ans, z);
else
addmod(ans, 998244353 - z);
}
return ans;
}
int dp[5135];
void fmain(int tid) {
int p, s, r;
cin >> p >> s >> r;
initfac(5135 - 1);
for (int x = r; x <= s; x++) {
for (int i = 1; x * i <= s && i <= p; i++) {
int z = (long long)cal(s - i * x, p - i, x) * C(p - 1, i - 1) % 998244353;
addmod(dp[i], z);
}
}
int all = C(s - r + p - 1, p - 1), ans = 0;
all = fastPow(all, 998244353 - 2);
for (int(i) = 1; (i) <= (int)(p); (i)++) {
addmod(ans, (long long)dp[i] * all % 998244353 * fastPow(i, 998244353 - 2) %
998244353);
}
printf("%d\n", ans);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 6010, mod = 998244353;
int n, s, r, res, fac[N], Invfac[N], inv[N];
int C(int n, int m) {
if (m > n) return 0;
return 1LL * fac[n] * Invfac[m] % mod * Invfac[n - m] % mod;
}
int ksm(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = 1LL * ans * a % mod;
a = 1LL * a * a % mod;
b >>= 1;
}
return ans;
}
int Solve(int p, int s, int m) {
if (p == 0) return (s == 0);
int ans = 0, t = -1;
for (int i = 0; i <= p; i++) {
t = -t;
if (s - i * (m + 1) >= 0)
ans = (ans +
1LL * t * C(p, i) % mod * C(s - i * (m + 1) + p - 1, p - 1) % mod +
mod) %
mod;
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &s, &r);
fac[0] = Invfac[0] = inv[1] = 1;
for (int i = 1; i <= s + n; i++) {
fac[i] = 1LL * fac[i - 1] * i % mod;
if (i > 1) inv[i] = (mod - 1LL * mod / i * inv[mod % i] % mod) % mod;
}
Invfac[s + n] = ksm(fac[s + n], mod - 2);
for (int i = s + n - 1; i >= 1; i--)
Invfac[i] = 1LL * Invfac[i + 1] * (i + 1) % mod;
for (int t = r; t <= s; t++) {
for (int i = 1; i <= n; i++) {
if (s - i * t >= 0) {
res = (res + 1LL * C(n - 1, i - 1) * inv[i] % mod *
Solve(n - i, s - i * t, t - 1)) %
mod;
}
}
}
res = 1LL * res * ksm(C(s - r + n - 1, n - 1), mod - 2) % mod;
printf("%d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int mod = 998244353;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
int fac[N], inv[N], ifac[N], ans, p, s, r;
int C(int n, int m) {
if (m < 0 || n < m) return 0;
return 1ll * fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}
int invC(int n, int m) {
if (m < 0 || n < m) return 0;
return 1ll * ifac[n] * fac[m] % mod * fac[n - m] % mod;
}
int cal(int x, int y) {
if (!y) return x == 0;
return C(x + y - 1, y - 1);
}
int main() {
fac[0] = inv[1] = ifac[0] = 1;
for (int i = 1; i < N; i++) {
fac[i] = 1ll * fac[i - 1] * i % mod;
if (i > 1) inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
ifac[i] = 1ll * ifac[i - 1] * inv[i] % mod;
}
cin >> p >> s >> r;
for (int i = r; i <= s; i++) {
for (int j = 1; j <= p; j++) {
for (int k = 0; k <= p - j; k++)
ans = (ans + 1ll * C(p - 1, j - 1) * inv[j] % mod * C(p - j, k) % mod *
((k & 1) ? mod - 1 : 1) % mod *
cal(s - j * i - k * i, p - j)) %
mod;
}
}
ans = 1ll * ans * invC(s - r + p - 1, p - 1) % mod;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, N = 5500, mod = 998244353;
int r, p, s, ans;
int C[N][N];
int read() {
int ret = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 0;
c = getchar();
}
while (isdigit(c)) ret = ret * 10 + (c ^ 48), c = getchar();
return f ? ret : -ret;
}
int qpow(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = (long long)x * x % mod)
if (y & 1) res = (long long)res * x % mod;
return res;
}
int up(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
}
int upm(int x) { return x >= mod ? x - mod : x; }
void initC() {
for (int i = 0; i < N; ++i) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; ++j) C[i][j] = upm(C[i - 1][j] + C[i - 1][j - 1]);
}
}
int solve(int n, int k, int s) {
if (!n) return !s;
int res = 0;
for (int i = 0; i <= n && i * (k + 1) <= s; ++i)
up(res, (long long)(i & 1 ? -1 : 1) * C[n + s - i * (k + 1) - 1][n - 1] *
C[n][i] % mod);
return res;
}
int main() {
initC();
scanf("%d%d%d", &p, &s, &r);
for (int i = r; i <= s; ++i)
for (int j = 1; j <= p && i * j <= s; ++j)
up(ans, (long long)qpow(j, mod - 2) * solve(p - j, i - 1, s - i * j) %
mod * C[p - 1][j - 1] % mod);
printf("%d\n", (long long)ans * qpow(C[p + s - r - 1][p - 1], mod - 2) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 5e3 + 200;
int p, s, r;
long long c[N][N];
long long ans;
void init() {
c[0][0] = 1;
for (int i = 1; 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]) % mod;
}
}
long long KSM(long long a, long long b) {
long long ret = 1LL;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
long long C(int n, int m) {
if (n < 0 || m < 0 || n < m) return 0;
return c[n][m];
}
long long calc(long long s, long long p, long long m) {
if (p == 0 && s == 0) return 1;
long long ret = 0;
for (int i = 0, sign = 1; i <= p; i++) {
ret += sign * (C(p, i) * C(s + p - 1 - i * (m + 1), p - 1) % mod) % mod;
ret = (ret + mod) % mod;
sign *= -1;
}
return ret;
}
int main() {
init();
scanf("%d%d%d", &p, &s, &r);
for (int x = r; x <= s; x++)
for (int k = 1; k <= p; k++) {
(ans += ((C(p - 1, k - 1) * KSM(k, mod - 2) % mod) *
calc(s - k * x, p - k, x - 1)) %
mod) %= mod;
}
ans *= KSM(C(s + p - 1 - r, p - 1), mod - 2);
ans %= mod;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int add(int _a, int _b) {
_a = (_a + 998244353) % 998244353;
_b = (_b + 998244353) % 998244353;
return (_a + _b) % 998244353;
}
inline int mul(int _a, int _b) {
_a = (_a + 998244353) % 998244353;
_b = (_b + 998244353) % 998244353;
return ((long long int)((long long int)_a * (long long int)_b)) % 998244353;
}
inline int bigMod(int v, int p) {
if (p == 0) {
return 1;
}
int ret = bigMod(v, p / 2) % 998244353;
if (p % 2 == 0) {
return mul(ret, ret);
} else {
return mul(ret, mul(ret, v));
}
}
int fac[2 * 100010], invFac[2 * 100010], inv[2 * 100010];
void pre() {
int i, j;
for (i = 1, fac[0] = invFac[0] = 1; i < 2 * 100010 - 2; i++) {
fac[i] = mul(fac[i - 1], i);
inv[i] = bigMod(i, 998244353 - 2);
invFac[i] = mul(invFac[i - 1], inv[i]);
}
}
int p, s, r;
int comb(int n, int k) {
if (k > n) {
return 0;
}
return mul(fac[n], mul(invFac[k], invFac[n - k]));
}
void input() {
int i, j;
scanf("%d %d %d", &p, &s, &r);
}
void solve() {
int i, j, ret, sol = 0, k, a, b;
for (i = r; i <= s; i++) {
for (j = 0; j <= p - 1 && i * (j + 1) <= s; j++) {
for (k = 0; k <= p - 1 - j && i * (j + 1 + k) <= s; k++) {
ret = comb(p - 1, j);
ret = mul(ret, inv[j + 1]);
if (k % 2 == 1) {
ret = mul(ret, -1);
}
ret = mul(ret, comb(p - 1 - j, k));
a = p - 1 - j + s - i * (j + 1 + k) - 1, b = s - i * (j + 1 + k);
if (p - 1 - j == 0) {
if (i * (j + 1 + k) != s) {
ret = mul(ret, 0);
}
} else {
ret = mul(ret, comb(a, b));
}
sol = add(sol, ret);
}
}
}
sol = mul(sol, bigMod(comb(s - r + p - 1, p - 1), 998244353 - 2));
printf("%d", sol);
puts("");
}
int main() {
pre();
input();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 6000;
int fac[N], fav[N];
int a[N];
int qpow(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = 1ll * ans * x % mod;
x = 1ll * x * x % mod;
y /= 2;
}
return ans;
}
void init() {
fac[0] = 1;
for (int i = 1; i < N; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
fav[N - 1] = qpow(fac[N - 1], mod - 2);
for (int i = N - 2; i >= 0; i--) fav[i] = 1ll * fav[i + 1] * (i + 1) % mod;
}
int C(int n, int m) {
if (n == m) return 1;
if (n < 0 || m < 0 || n < m) return 0;
return 1ll * fac[n] * fav[m] % mod * fav[n - m] % mod;
}
int main() {
init();
int p, s, r;
scanf("%d%d%d", &p, &s, &r);
int ans = 0;
for (int i = r; i <= s; i++) {
for (int j = 1; j <= p; j++) {
if (j * i > s) break;
int tmp = 0;
int inv = 1ll * qpow(j, mod - 2) * C(p - 1, j - 1) % mod;
for (int k = 0, d = 1; k <= p - j; k++, d *= -1) {
tmp =
(tmp + 1ll * d * C(p - j, k) *
C(s - i * j + (p - j) - 1 - k * (i), p - j - 1) % mod) %
mod;
tmp = (tmp + mod) % mod;
}
ans = (ans + 1ll * tmp * inv % mod) % mod;
}
}
ans = 1ll * ans * qpow(C(s - r + p - 1, p - 1), mod - 2) % mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod7 = 998244353;
inline long long add(long long v1, long long v2, long long mod = mod7) {
v1 += v2;
if (v1 >= mod) v1 -= mod;
if (v1 < 0) v1 += mod;
return v1;
}
inline long long mul(long long v1, long long v2, long long mod = mod7) {
return v1 * v2 % mod;
}
inline long long mypow(long long v, long long t, long long mod = mod7) {
long long res = 1;
while (t) {
if (t & 1) res = res * v % mod;
v = v * v % mod;
t >>= 1;
}
return res;
}
inline void bye() {
puts("");
exit(0);
}
const int N = 10101;
long long fac[N], ifac[N];
long long re[N];
int n, s, r;
void init() { scanf("%d %d %d", &n, &s, &r); }
void build() {
fac[0] = 1;
for (int i = 1; i < N; i++) fac[i] = mul(fac[i - 1], i);
ifac[N - 1] = mypow(fac[N - 1], mod7 - 2);
for (int i = N - 2; i >= 0; i--) ifac[i] = mul(ifac[i + 1], i + 1);
for (int i = 1; i < N; i++) re[i] = mypow(i, mod7 - 2);
}
long long C(int v1, int v2) {
if (v1 < v2) return 0LL;
if (v1 < 0 || v2 < 0) return 0LL;
long long res = mul(fac[v1], mul(ifac[v2], ifac[v1 - v2]));
return res;
}
long long val(int a, int b, int c) {
if (b == 0) {
if (c) {
return 1LL;
} else {
return a ? 0LL : 1LL;
}
}
if (a == 0) return 0LL;
long long res = 0, d = 1;
for (int i = 0; i <= a; i++) {
long long v = mul(C(a, i), C(b - c * i + a - 1, a - 1));
v = mul(v, d);
res = add(res, v);
d = -d;
}
return res;
}
void solve() {
long long an = 0;
for (int i = r; i <= s; i++) {
for (int j = 1; j * i <= s && j <= n; j++) {
long long v = val(n - j, s - j * i, i);
v = mul(v, mul(re[j], C(n - 1, j - 1)));
an = add(an, v);
}
}
an = mul(an, mypow(C(n - 1 + s - r, s - r), mod7 - 2));
printf("%lld\n", an);
}
int main() {
init();
build();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10005, mod = 998244353;
int fac[N], ni[N], inv[N], n, r, S, ans, P;
int qm(int x) { return x >= mod ? x - mod : x; }
int ksm(int x, int y) {
int re = 1;
for (; y; y >>= 1, x = 1LL * x * x % mod)
if (y & 1) re = 1LL * re * x % mod;
return re;
}
int C(int d, int u) {
if (d < 0 || u < 0) return 0;
return 1LL * fac[d] * ni[u] % mod * ni[d - u] % mod;
}
int f(int n, int m, int lim) {
if (n == 0 && m == 0) return 1;
int re = 0;
for (register int i = 0; i <= m; ++i) {
int kl = 1LL * C(m, i) * C(n - (lim + 1) * i + m - 1, m - 1) % mod;
if (i & 1)
re = qm(re - kl + mod);
else
re = qm(re + kl);
}
return re;
}
int main() {
scanf("%d%d%d", &n, &S, &r);
if (n == 1) {
puts("1");
return 0;
}
fac[0] = 1;
for (register int i = 1; i <= n + S; ++i) fac[i] = 1LL * fac[i - 1] * i % mod;
ni[n + S] = ksm(fac[n + S], mod - 2);
for (register int i = n + S - 1; i >= 0; --i)
ni[i] = 1LL * ni[i + 1] * (i + 1) % mod;
inv[0] = inv[1] = 1;
for (register int i = 2; i <= n; ++i)
inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod;
for (register int i = r; i <= S; ++i) {
for (register int j = 1; i * j <= S && j <= n; ++j) {
int kl = 1LL * C(n - 1, j - 1) * f(S - i * j, n - j, i - 1) % mod;
ans = qm(ans + 1LL * kl * inv[j] % mod);
}
P = qm(P + C(S - i + n - 2, n - 2));
}
printf("%lld\n", 1LL * ans * ksm(P, mod - 2) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
const long long N = 10050;
const long long M = 998244353;
long long fat[N], inv[N];
long long C(long long n, long long k) {
if (k > n) return 0;
return mod(fat[n] * mod(inv[k] * inv[n - k], M), M);
}
long long Inv[N];
void init() {
fat[0] = inv[0] = 1;
for (long long i = 1; i < N; i++) {
fat[i] = (1LL * fat[i - 1] * i) % M;
}
inv[N - 1] = exp(fat[N - 1], M - 2, M);
for (long long i = N - 2; i >= 0; i--) {
inv[i] = (inv[i + 1] * (i + 1)) % M;
if (i) {
Inv[i] = fat[i - 1] * inv[i] % M;
assert(Inv[i] * i % M == 1);
}
}
}
long long stars(long long n, long long m) {
if (m < 0) return 0;
assert(n >= 0);
if (m == 0) return 1;
return C(n + m - 1, n - 1);
}
long long stars_with_upper(long long n, long long m, long long mx) {
long long res = 0;
if (n * (mx - 1) < m) return 0;
for (long long cnt = 0; cnt <= n; cnt++) {
long long cur = (long long)C(n, cnt) * stars(n, m - cnt * mx) % M;
if (cnt & 1)
res = (res - cur);
else
res = (res + cur);
if (res < 0) res += M;
if (res >= M) res -= M;
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
init();
long long n, m, r;
cin >> n >> m >> r;
long long tot = 0, good = 0;
long long R = r;
n--;
for (; r <= m; r++) {
tot += stars(n, m - r);
if (tot >= M) tot -= M;
for (long long cnt = 0; (cnt + 1) * r <= m and cnt <= n; cnt++) {
long long cur = Inv[(cnt + 1)] * C(n, cnt) % M *
stars_with_upper(n - cnt, m - (cnt + 1) * r, r) % M;
good += cur;
if (good >= M) good -= M;
}
}
r = R;
assert(tot == stars(n + 1, m - r));
long long res = mod(good * exp(tot, M - 2, M), M);
cout << res << "\n";
}
|
#include <bits/stdc++.h>
const long long inf = 0x3f3f3f3f3f3f3f3LL;
const long long mod = 998244353;
using namespace std;
template <class T>
void smin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void smax(T& a, T val) {
if (a < val) a = val;
}
template <typename T>
inline std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
bool first = true;
os << "[";
for (auto i : v) {
if (!first) os << ", ";
os << i;
first = false;
}
return os << "]";
}
const long long N = 5 * 1e3 + 110;
long long NCR[N][N];
long long p, s, r;
long long nCr(long long n, long long r) {
if (n < r or r < 0 or n < 0) return 0;
return NCR[n][r];
}
long long solve(long long score, long long cnt) {
if (s - cnt * score < 0) return 0;
if (p - cnt == 0) return (score * cnt) == s;
if (cnt == 0) return 0;
long long ans = 0;
for (long long i = 0, flag = 1; i <= p - cnt; ++i, flag *= -1) {
long long tt = flag * nCr(p - cnt, i);
if (tt < 0) tt += mod;
tt %= mod;
long long tt2 = nCr(s - score * cnt - i * score + p - cnt - 1, p - cnt - 1);
ans += tt * tt2 % mod;
ans %= mod;
}
ans %= mod;
return ans;
}
long long power(long long a, long long b, long long m = mod) {
if (b < 0) b += m - 1;
long long r = 1;
while (b) {
if (b & 1) r = (r * a) % m;
a = (a * a) % m;
b >>= 1;
}
return r;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> p >> s >> r;
for (long long i = 0; i <= 5100; ++i) {
for (long long j = 0; j <= i; ++j) {
if (j == 0 or j == i) {
NCR[i][j] = 1;
} else {
NCR[i][j] = NCR[i - 1][j - 1] + NCR[i - 1][j];
if (NCR[i][j] >= mod) NCR[i][j] -= mod;
}
}
}
assert(s - r + p - 1 >= p - 1);
long long den = nCr(s - r + p - 1, p - 1);
long long ans = 0;
for (long long score = r; score <= s; ++score) {
for (long long cnt = 1; cnt <= p; ++cnt) {
long long tmp = solve(score, cnt);
tmp = tmp * nCr(p - 1, cnt - 1) % mod;
tmp = tmp * power(cnt, -1) % mod;
ans += tmp;
if (ans < 0) ans += mod;
ans %= mod;
}
}
ans = (ans * power(den, -1)) % mod;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5505;
long long s, r, p, ans, mod = 998244353, c[N][N];
long long ksm(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
}
return ans;
}
long long f(long long s, long long p, long long m) {
if (!s) return 1;
long long ans = 0, tmp = 0;
for (long long i = 0; i <= p; i++) {
if (s - i * m + p - 1 < p - 1)
tmp = 0;
else
tmp = c[p][i] % mod * c[s - i * m + p - 1][p - 1] % mod;
if (i & 1)
ans = (ans - tmp + mod) % mod;
else
ans = (ans + tmp) % mod;
}
return ans;
}
int main() {
scanf("%lld%lld%lld", &p, &s, &r);
c[0][0] = 1;
for (long long i = 1; i <= s + p; i++) {
c[i][0] = 1;
for (long long j = 1; j <= i && j <= p; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
for (long long i = r; i <= s; i++) {
for (long long j = 1; j <= p; j++) {
if ((p - j) * (i - 1) + i * j < s || s - i * j < 0) continue;
ans = (ans + c[p - 1][j - 1] * f(s - i * j, p - j, i) % mod *
ksm(j, mod - 2) % mod) %
mod;
}
}
printf("%lld", ans * ksm(c[s - r + p - 1][p - 1], mod - 2) % mod);
}
|
#include <bits/stdc++.h>
using namespace std;
int p, s, r, M = 998244353;
long long iv[5100], f1[5100], f2[5100], ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
iv[1] = f1[0] = f1[1] = f2[0] = f2[1] = 1;
for (int i = 2; i < 5100; ++i) {
iv[i] = (M - M / i) * iv[M % i] % M;
f1[i] = f1[i - 1] * i % M;
f2[i] = f2[i - 1] * iv[i] % M;
}
cin >> p >> s >> r;
if (p <= 1) {
cout << 1;
return 0;
}
for (int i = 1; i <= p && s - r * i >= 0; ++i)
ans += (i & 1 ? 1 : -1) * f1[s - r * i + p - 1] * f2[s - r * i] % M *
f2[i] % M * f2[p - i] % M;
ans = (ans % M + M) * f1[p - 1] % M * f1[s - r] % M * f2[s - r + p - 1] % M;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void cmax(int &x, const int &y) { x = x > y ? x : y; }
void cmin(int &x, const int &y) { x = x < y ? x : y; }
template <class T>
istream &operator>>(istream &in, vector<T> &V) {
for (auto &x : V) in >> x;
return in;
}
template <class T>
ostream &operator<<(ostream &out, const vector<T> &V) {
for (auto x : V) out << x << ' ';
return out;
}
template <class T>
void sort(vector<T> &V) {
sort(V.begin(), V.end());
}
template <class T>
void reverse(vector<T> &V) {
reverse(V.begin(), V.end());
}
template <class T>
int SZ(const vector<T> &V) {
return (int)V.size();
}
void debug() { cerr << "whxorz" << '\n'; }
int n, s, r;
const int N = 5105;
const int P = 998244353;
int mul(const int &x, const int &y) { return 1ll * x * y % P; }
int add(const int &x, const int &y) {
if (x + y >= P) {
return x + y - P;
} else {
return x + y;
}
}
int sub(const int &x, const int &y) {
if (x - y < 0) {
return x - y + P;
} else {
return x - y;
}
}
int qpow(int x, int y) {
if (y < 0) {
y += P - 1;
}
int res = 1;
while (y) {
if (y & 1) {
res = mul(res, x);
}
x = mul(x, x);
y >>= 1;
}
return res;
}
int C[N][105];
int inv[N];
int calc(int n, int s, int mx) {
if (n == 0) {
return s == 0;
} else {
int ans = 0, op = 1;
for (int i = 0; i <= n && i * mx <= s; i++, op = P - op) {
int result = mul(C[s - i * mx + n - 1][n - 1], C[n][i]);
ans = add(ans, mul(result, op));
}
return ans;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> s >> r;
for (int i = 0; i < N; i++) {
C[i][0] = 1;
for (int j = 1; j <= min(i, 104); j++) {
C[i][j] = add(C[i - 1][j - 1], C[i - 1][j]);
}
}
for (int i = 1; i < N; i++) {
inv[i] = qpow(i, -1);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = r; j <= s; j++) {
if (s < i * j) {
continue;
} else {
ans = add(ans,
mul(mul(C[n - 1][i - 1], calc(n - i, s - i * j, j)), inv[i]));
}
}
}
int ways = C[s - r + n - 1][n - 1];
ans = mul(ans, qpow(ways, -1));
cout << ans << '\n';
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.