text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
long long n, d, mod, ans, f[20], g[20], dp[1010][20][1010];
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 << 3) + (x << 1) + (c ^ '0');
c = getchar();
}
return x * f;
}
long long Pow(long long x, long long k) {
long long res = mod != 1;
x %= mod;
while (k) {
if (k & 1) res = res * x % mod;
x = x * x % mod;
k >>= 1;
}
return res;
}
long long C(long long n, long long m) {
if (n < m) return 0;
long long res = 1;
for (long long i = 1; i <= m; i++) res = res * (n - i + 1) % mod;
return res * g[m] % mod;
}
int main() {
n = read();
d = read();
mod = read();
f[0] = g[0] = 1;
for (long long i = 1; i <= 10; i++) f[i] = f[i - 1] * i % mod;
g[10] = Pow(f[10], mod - 2);
for (long long i = 9; i; i--) g[i] = g[i + 1] * (i + 1) % mod;
if (n <= 2) {
puts("1");
return 0;
}
for (long long i = 0; i <= n; i++) dp[1][0][i] = 1;
for (long long i = 2; i <= n; i++)
for (long long j = 1; j <= min(i - 1, d); j++)
for (long long k = 1; k <= n; k++) {
dp[i][j][k] = dp[i][j][k - 1];
for (long long t = 1; i - t * k > 0 && j - t >= 0; t++) {
if (k != 1)
dp[i][j][k] =
(dp[i][j][k] + dp[i - t * k][j - t][k - 1] *
C(dp[k][d - 1][k - 1] + t - 1, t) % mod) %
mod;
else
dp[i][j][k] =
(dp[i][j][k] + dp[i - t * k][j - t][k - 1] *
C(dp[k][0][k - 1] + t - 1, t) % mod) %
mod;
}
}
if (n & 1)
ans = dp[n][d][n / 2];
else
ans = (dp[n][d][n / 2] - C(dp[n / 2][d - 1][n / 2 - 1], 2) + mod) % mod;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
return os << "(" << v.first << ", " << v.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (int i = int(0); i <= int((static_cast<int>((v).size())) - 1); ++i) {
if (i) os << ", ";
os << v[i];
}
return os << "]";
}
template <class T>
bool setmax(T& _a, T _b) {
if (_b > _a) {
_a = _b;
return true;
}
return false;
}
template <class T>
bool setmin(T& _a, T _b) {
if (_b < _a) {
_a = _b;
return true;
}
return false;
}
template <class T>
T gcd(T _a, T _b) {
return _b == 0 ? _a : gcd(_b, _a % _b);
}
const int N = 1010;
const int D = 11;
long long f[N][D][N];
long long inv[D];
int main() {
int n, d;
long long mod;
cin >> n >> d >> mod;
const auto power = [mod](long long a, long long b) {
long long c = 1;
for (; b > 0; b >>= 1, a = a * a % mod)
if (b & 1) c = c * a % mod;
return c;
};
for (int i = int(1); i <= int(D - 1); ++i) inv[i] = power(i, mod - 2);
memset(f, 0, sizeof(f));
for (int j = int(0); j <= int(d); ++j)
for (int k = int(0); k <= int(n); ++k) f[1][j][k] = 1;
for (int i = int(2); i <= int(n); ++i)
for (int j = int(0); j <= int(d); ++j)
for (int k = int(1); k <= int(n); ++k) {
long long cur = 1, p = f[k][d - 1][k - 1];
long long ans = 0;
for (int t = int(0); t <= int(min(j, (i - 1) / k)); ++t) {
if (i - t * k != 1 || (i - t * k == 1 && j == t)) {
ans += f[i - t * k][j - t][k - 1] * cur;
}
(cur *= p + t) %= mod;
(cur *= inv[t + 1]) %= mod;
}
f[i][j][k] = ans % mod;
}
long long ans = f[n][d][(n - 1) / 2];
if (n % 2 == 0) {
long long tmp = f[n / 2][d - 1][n / 2 - 1];
(ans += tmp * (tmp + 1) / 2) %= mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1100], n, d, mo, num[1100][11], A[1100], w[11], B[11][11], nI[11];
int quick(int k1, int k2) {
int k3 = 1;
while (k2) {
if (k2 & 1) k3 = 1ll * k3 * k1 % mo;
k2 >>= 1;
k1 = 1ll * k1 * k1 % mo;
}
return k3;
}
int main() {
scanf("%d%d%d", &n, &d, &mo);
nI[0] = 1;
for (int i = 1; i <= d; i++) nI[i] = 1ll * nI[i - 1] * quick(i, mo - 2) % mo;
dp[1] = 1;
num[1][0] = 1;
B[0][0] = 1;
for (int i = 1; i <= d; i++)
for (int j = 1; j <= i; j++)
for (int k = 1; k <= i; k++) B[i][j] = (B[i][j] + B[i - k][j - 1]) % mo;
for (int i = 1; i <= n / 2; i++) {
dp[i] = num[i][d - 1];
int pre = 1;
if (i == 1) dp[i]++;
if (i * 2 == n) continue;
if (dp[i] == 0) continue;
memset(w, 0x00, sizeof w);
for (int j = 1; j <= d; j++) {
pre = 1ll * pre * (dp[i] - j + 1) % mo;
for (int k = j; k <= d; k++)
w[k] = (w[k] + 1ll * pre * nI[j] % mo * B[k][j]) % mo;
}
for (int a = d; a; a--) {
for (int b = 1, si = i; b <= a; b++, si += i)
for (int k = si + 1; k <= n; k++)
num[k][a] = (num[k][a] + 1ll * w[b] * num[k - si][a - b]) % mo;
}
}
int ans = 0;
if (n % 2 == 0) ans = 1ll * dp[n / 2] * (dp[n / 2] + 1) % mo * nI[2] % mo;
ans = (ans + num[n][d]) % mo;
if (n == 1) ans = (ans + 1) % mo;
cout << (ans + mo) % mo << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000000 + 7;
int addm(int& a, int b) {
return (a += b) < mod ? (a < 0 ? a += mod : a) : a -= mod;
}
int addm2(int a, int b) { return addm(a, b); }
template <class T, class U>
bool smin(T& a, U b) {
return a > b ? (a = b, 1) : 0;
}
template <class T, class U>
bool smax(T& a, U b) {
return a < b ? (a = b, 1) : 0;
}
int n, d, dp[1001][11][1001], cs[1001][11][1002];
int a, b, g;
void gcd(int m, int n) {
if (n == 0) {
a = 1;
b = 0;
g = m;
return;
}
gcd(n, m % n);
int t = a - b * (m / n);
a = b;
b = t;
}
int inv(int a, int mod) {
gcd(mod, a);
return g > 0 ? b : -b;
}
int iv[1001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> d >> mod;
dp[0][0][0] = 1;
for (int i = 1; i <= 1000; i++) iv[i] = inv(i, mod);
for (int i = 1; i < 1002; i++)
for (int j = 0; j <= d; j++)
cs[0][j][i] = addm2(cs[0][j][i - 1], dp[0][j][i - 1]);
for (int i = 1; i < n; i++)
for (int j = 1; j <= d; j++)
for (int k = 1; k < n; k++) {
long long f = 1;
for (int l = 1; l * k <= i && l <= j && (k == 1 || cs[k - 1][d - 1][k]);
l++) {
f = f * ((k == 1 ? 1 : cs[k - 1][d - 1][k]) + l - 1) % mod * iv[l] %
mod;
if (cs[i - l * k][j - l][k])
addm(cs[i][j][k + 1], (long long)cs[i - l * k][j - l][k] * f % mod);
}
addm(cs[i][j][k + 1], cs[i][j][k]);
}
int ans = cs[n - 1][d][(n + 1) / 2];
addm(ans, cs[n - 1][0][(n + 1) / 2]);
if (n % 2 == 0) {
long long v = cs[n / 2 - 1][d - 1][n / 2] + cs[n / 2 - 1][0][n / 2];
addm(ans, v * (v + 1) / 2 % mod);
}
if (ans < 0) ans += mod;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
const int N = 1010;
int n, d, mod, f[N][20][N], fac[20], Inv[20];
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 C(int n, int m) {
if (m > n) return 0;
int ans = 1;
for (int i = n - m + 1; i <= n; i++) ans = 1LL * ans * i % mod;
ans = 1LL * ans * Inv[m] % mod;
return ans;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n == 1 || n == 2) {
puts("1");
return 0;
}
fac[0] = Inv[0] = 1;
for (int i = 1; i <= d; i++) fac[i] = 1LL * fac[i - 1] * i % mod;
Inv[d] = ksm(fac[d], mod - 2);
for (int i = d - 1; i >= 1; i--) Inv[i] = 1LL * Inv[i + 1] * (i + 1) % mod;
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= std::min(d, i - 1); j++) {
for (int k = 1; k <= n; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t <= j; t++) {
if (i >= t * k && j >= t && k - 1 >= 0) {
if (k > 1)
f[i][j][k] =
(f[i][j][k] + 1LL * f[i - t * k][j - t][k - 1] *
C(f[k][d - 1][k - 1] + t - 1, t) % mod) %
mod;
else {
f[i][j][k] =
(f[i][j][k] + 1LL * f[i - t * k][j - t][k - 1] *
C(f[k][0][k - 1] + t - 1, t) % mod) %
mod;
}
}
}
}
}
}
int res;
if (n & 1)
res = f[n][d][n / 2];
else
res = (f[n][d][n / 2] - C(f[n / 2][d - 1][n / 2 - 1], 2) + mod) % mod;
printf("%d", res);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e3 + 100;
const int D = 12;
int n;
int d;
int mod;
void init() {
std::cin >> n;
std::cin >> d;
std::cin >> mod;
}
int inverse(int x, int mod) {
if (x == 1) {
return 1;
} else {
return (long long)(mod - mod / x) * inverse(mod % x, mod) % mod;
}
}
int comb(int r, int k) {
static int inv[D];
int result = 1;
for (int i = 1; i <= k; i++) {
result = (long long)result * (r - i + 1) % mod;
if (inv[i] == 0) {
inv[i] = inverse(i, mod);
}
result = (long long)result * inv[i] % mod;
}
return result;
}
void update(int &x, int y) { x = (x + y) % mod; }
void work() {
if (n <= 2) {
std::cout << 1 % mod << std::endl;
return;
}
static int f[N][D][N];
std::memset(f, 0, sizeof(f));
f[1][0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= d; j++) {
for (int k = 0; k <= n / 2; k++) {
if (k > 0) {
update(f[i][j][k], f[i][j][k - 1]);
for (int t = 1; t * k < i && t <= j; t++) {
if (k == 1) {
update(f[i][j][k], f[i - t * k][j - t][k - 1]);
} else {
update(f[i][j][k], (long long)f[i - t * k][j - t][k - 1] *
comb(f[k][d - 1][k - 1] + t - 1, t) % mod);
}
}
}
}
}
}
int answer = f[n][d][(n - 1) / 2];
if (n % 2 == 0) {
answer += comb(f[n / 2][d - 1][n / 2 - 1] + 1, 2);
answer %= mod;
}
std::cout << answer << std::endl;
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d;
long long mod, dp[1005][25][1005], f[1005], g[1005], ans;
long long Pow(long long a, long long b) {
long long rec = 1;
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) rec = a * rec % mod;
return rec;
}
int C(int n, int m) {
if (n < m) return 0;
long long ans = 1;
for (int i = 1; i <= m; i++) ans = ans * (long long)(n - i + 1) % mod;
return ans * g[m] % mod;
}
int main() {
scanf("%d%d%lld", &n, &d, &mod);
f[0] = g[0] = 1;
for (int i = 1; i <= n; i++) f[i] = f[i - 1] * i % mod;
g[n] = Pow(f[n], mod - 2);
for (int i = n - 1; i; i--) g[i] = g[i + 1] * (i + 1) % mod;
if (n <= 2) return puts("1"), 0;
for (int i = 0; i <= n; i++) dp[1][0][i] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= min(i - 1, d); j++)
for (int k = 1; k <= n; k++) {
dp[i][j][k] = dp[i][j][k - 1];
for (int t = 1; i - t * k > 0 && j - t >= 0; t++)
if (k != 1)
dp[i][j][k] =
(dp[i][j][k] + dp[i - t * k][j - t][k - 1] *
C(dp[k][d - 1][k - 1] + t - 1, t)) %
mod;
else
dp[i][j][k] =
(dp[i][j][k] + dp[i - t * k][j - t][k - 1] *
C(dp[k][0][k - 1] + t - 1, t) % mod) %
mod;
}
if (n & 1)
ans = dp[n][d][n / 2];
else
ans = (dp[n][d][n / 2] - C(dp[n / 2][d - 1][n / 2 - 1], 2) + mod) % mod;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, Md, f2[1010][1010][11], ny[1010], f[1010];
int Quick(int a, int b) {
int Now = a, ret = 1;
for (; b; b >>= 1, Now = 1LL * Now * Now % Md)
if (b & 1) ret = 1LL * ret * Now % Md;
return ret;
}
int main() {
cin >> n >> d >> Md;
if (n <= 2) {
printf("1");
return 0;
}
for (int i = 1; i <= 1000; i++) ny[i] = Quick(i, Md - 2);
f[1] = 1;
f2[0][0][0] = 1;
for (int(W) = (0); (W) <= (d); (W)++) f2[1][W][W] = 1;
for (int i = 2; i * 2 <= n; i++) {
f[i] = f2[i - 1][i - 1][d - 1];
for (int(k) = (0); (k) <= (d); (k)++)
for (int(j) = (0); (j) <= (n); (j)++)
if (f2[i - 1][j][k]) {
int Now = f2[i - 1][j][k];
for (int l = 0; j + l * i <= n && l + k <= d && Now; l++) {
f2[i][j + l * i][l + k] += Now;
if (f2[i][j + l * i][l + k] >= Md) f2[i][j + l * i][l + k] -= Md;
Now = 1LL * Now * (f[i] + l) % Md * ny[l + 1] % Md;
}
}
}
if (n & 1)
printf("%d\n", f2[n >> 1][n - 1][d]);
else {
int ans = f2[(n >> 1) - 1][n - 1][d], Now = f[n >> 1];
Now = 1LL * (Now + 1) * Now % Md * ny[2] % Md;
ans = (ans + Now) % Md;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1009;
int f[maxn][12][maxn / 2], n, d, mod;
int inv[maxn], fac[maxn];
inline void pls(int &x, int y) { x = (x + y >= mod ? x + y - mod : x + y); }
inline int dec(int &x, int y) { return (x - y < 0 ? x - y + mod : x - y); }
void init() {
inv[1] = 1;
for (int i = 2; i < maxn; i++)
inv[i] = (long long)(mod - mod / i) * inv[mod % i] % mod;
for (int i = 2; i < maxn; i++) inv[i] = (long long)inv[i - 1] * inv[i] % mod;
}
inline int C(int n, int m) {
if (m > n) return 0;
int res = 1;
for (int i = n - m + 1; i <= n; i++) res = (long long)res * i % mod;
return (long long)res * inv[m] % mod;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) {
puts("1");
return 0;
}
init();
for (int i = 0; i <= n / 2; i++) f[1][0][i] = 1;
f[1][d - 1][0] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= min(d, i - 1); j++)
for (int k = 1; k <= n / 2; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t * k <= i && t <= j; t++)
pls(f[i][j][k], (long long)f[i - t * k][j - t][k - 1] *
C(f[k][d - 1][k - 1] + t - 1, t) % mod);
}
if (n & 1)
printf("%d", f[n][d][n / 2]);
else
printf("%d", dec(f[n][d][n / 2], C(f[n / 2][d - 1][n / 2 - 1], 2)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1111;
const int D = 11;
int n, mod, d;
int f[N][D][N], g[N][D], iv[N];
template <typename T>
inline void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
inline void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
inline void read(T &x) {
T f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
inline int power(int a, int n) {
int res = 1, b = a;
while (n > 0) {
if (n & 1) res = 1ll * res * b % mod;
b = 1ll * b * b % mod;
n >>= 1;
}
return res;
}
inline int inv(int x) { return power(x, mod - 2); }
inline void add(int &x, int y) {
x += y;
while (x >= mod) x -= mod;
}
inline void sub(int &x, int y) {
x -= y;
if (x < 0) x += mod;
}
int main() {
read(n);
read(d);
read(mod);
for (int i = 0; i <= n; ++i) f[1][0][i] = 1;
for (int i = 1; i <= d; ++i) g[1][i] = 1;
for (int i = 1; i <= d; ++i) iv[i] = inv(i);
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= d; ++j) {
for (int k = 1; k < i; ++k)
for (int l = 1; l <= j && l * k <= i; ++l)
add(f[i][j][k], 1ll * f[i - l * k][j - l][k - 1] * g[k][l] % mod);
for (int k = 1; k <= n; ++k) add(f[i][j][k], f[i][j][k - 1]);
}
g[i][1] = f[i][d - 1][n];
for (int j = 2; j <= d; ++j)
g[i][j] =
1ll * g[i][j - 1] * (f[i][d - 1][n] + j - 1) % mod * iv[j] % mod;
}
int ans = 0;
if (n <= 2)
ans = 1;
else
ans = f[n][d][n >> 1];
if (n > 2 && (n % 2 == 0))
sub(ans, 1ll * (f[n / 2][d - 1][n / 2] - 1) * f[n / 2][d - 1][n / 2] % mod *
iv[2] % mod);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int maxd = 11;
long long n, d, mod, dp[maxn][maxd], pd[maxn][maxd], f, t[maxd];
inline long long ksm(long long x, long long n) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * x % mod;
n >>= 1;
x = x * x % mod;
}
return ret;
}
inline long long solve() {
dp[1][0] = 1;
for (int i = 1; i <= n / 2; ++i)
if ((i - 1) % (d - 1) == 0) {
f = (i == 1) ? 1 : dp[i][d - 1];
for (int j = 1; j <= n; ++j)
for (int k = 0; k <= d; ++k) pd[j][k] = 0;
t[0] = 1;
for (int j = 1; j <= d; ++j)
t[j] = t[j - 1] * (f + j - 1) % mod * ksm(j, mod - 2) % mod;
for (int j = 0; j <= d; ++j)
for (int k = 0; k <= d; ++k)
if (j + k <= d)
for (int l = 1; l <= n; ++l)
if (l + i * k <= n)
pd[l + i * k][j + k] =
(pd[l + i * k][j + k] + dp[l][j] * t[k]) % mod;
for (int j = 0; j <= n; ++j)
for (int k = 0; k <= d; ++k) dp[j][k] = pd[j][k];
}
long long ret = dp[n][d];
if (n % 2 == 0)
ret = ((ret - dp[n / 2][d - 1] * (dp[n / 2][d - 1] - 1) / 2) % mod + mod) %
mod;
return ret;
}
int main() {
scanf("%I64d%I64d%I64d", &n, &d, &mod);
printf("%I64d\n", n <= 2 ? 1 : solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1002, D = 12;
int n, d, mod, inv, C[D], dp[D][N], res[D][N];
long long pow(long long x, long long y, long long mod) {
return (!y ? 1 : pow(x * x % mod, y / 2, mod) * (y & 1 ? x : 1)) % mod;
}
int main() {
cin >> n >> d >> mod;
dp[0][1] = 1;
inv = mod / 2 + 1;
if (n < 3) return cout << 1, 0;
for (int i = 1; i < (n + 1) / 2; i++) {
int num = max(dp[d - 1][i], int(i == 1));
C[0] = 1;
for (int i = 1; i < D; i++)
C[i] = 1ll * C[i - 1] * pow(i, mod - 2, mod) % mod * (num + i - 1) % mod;
for (int j = n - i; j >= 1; j--)
for (int k = 1; k * i + j <= n; k++)
for (int o = 0; o < d + 1; o++)
if (o + k < D)
dp[o + k][j + k * i] =
(dp[o + k][j + k * i] + 1ll * dp[o][j] * C[k] % mod) % mod;
}
cout << (dp[d][n] +
((n + 1) & 1) * (1ll * dp[d - 1][n / 2] * (dp[d - 1][n / 2] + 1) %
mod * inv % mod)) %
mod;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int maxd = 11;
long long n, d, mod, dp[maxn][maxd], pd[maxn][maxd], f, t[maxd];
inline long long ksm(long long x, long long n) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * x % mod;
n >>= 1;
x = x * x % mod;
}
return ret;
}
inline long long solve() {
dp[1][0] = 1;
for (int i = 1; i <= n / 2; ++i) {
f = (i == 1) ? 1 : dp[i][d - 1];
for (int j = 1; j <= n; ++j)
for (int k = 0; k <= d; ++k) pd[j][k] = 0;
t[0] = 1;
for (int j = 1; j <= d; ++j)
t[j] = t[j - 1] * (f + j - 1) % mod * ksm(j, mod - 2) % mod;
for (int j = 0; j <= d; ++j)
for (int k = 0; k <= d; ++k)
if (j + k <= d)
for (int l = 1; l <= n; ++l)
if (l + i * k <= n)
pd[l + i * k][j + k] =
(pd[l + i * k][j + k] + dp[l][j] * t[k]) % mod;
for (int j = 0; j <= n; ++j)
for (int k = 0; k <= d; ++k) dp[j][k] = pd[j][k];
}
long long ret = dp[n][d];
if (n % 2 == 0)
ret = ((ret - dp[n / 2][d - 1] * (dp[n / 2][d - 1] - 1) / 2) % mod + mod) %
mod;
return ret;
}
int main() {
scanf("%I64d%I64d%I64d", &n, &d, &mod);
if (n <= 2)
puts("1");
else
printf("%I64d\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e3 + 5;
long long int dp[M][12][M], inv[M], n, d, mod;
long long int pw(long long int a, long long int b) {
if (b == 0) return 1ll;
long long int p = pw(a, b / 2ll);
if (b % 2ll)
return p * p % mod * a % mod;
else
return p * p % mod;
}
int main() {
cin >> n >> d >> mod;
for (long long int i = 1; i <= n; i++) inv[i] = pw(i, mod - 2ll);
dp[1][0][0] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= d; j++)
for (int k = (i - 1) / j; k <= i - 1; k++) {
dp[i][j][k] = dp[i][j][k - 1];
long long int cur = 1, buf = dp[k][d - 1][k - 1];
for (int t = 1; t <= j && t * k <= i - 1; t++) {
cur = cur * buf++ % mod * inv[t] % mod;
(dp[i][j][k] += dp[i - t * k][j - t][min(k - 1, i - t * k - 1)] *
(cur + (k == 1))) %= mod;
}
}
long long int ans = dp[n][d][(n - 1) / 2];
if (n % 2 == 0)
(ans += dp[n / 2][d - 1][n / 2 - 1] * (dp[n / 2][d - 1][n / 2 - 1] + 1) %
mod * inv[2]) %= mod;
cout << (n <= 2 ? 1 : ans) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1111;
int inv[11], dp[MAXN][11][MAXN], n, D, MOD;
inline int Fpw(int x, int K, int MOD) {
int ret = 1;
for (; K; K >>= 1) {
if (K & 1) ret = (long long)ret * x % MOD;
x = (long long)x * x % MOD;
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &D, &MOD);
for (int i = 1; i <= D; ++i) inv[i] = Fpw(i, MOD - 2, MOD);
dp[1][D - 1][0] = 1;
dp[1][0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= D; ++j)
for (int k = 1; k <= n; ++k) {
dp[i][j][k] = dp[i][j][k - 1];
if (!dp[k][D - 1][k - 1] || i == 1) continue;
int tmp = 1;
for (int t = 1; t <= j && t * k <= i; ++t) {
tmp = (long long)tmp * (dp[k][D - 1][k - 1] + t - 1) % MOD * inv[t] %
MOD;
dp[i][j][k] =
((long long)tmp * dp[i - t * k][j - t][k - 1] + dp[i][j][k]) %
MOD;
}
}
}
int ans = 0;
if (n & 1)
ans = dp[n][D][n / 2];
else {
int tmp = dp[n / 2][D - 1][n / 2 - 1];
ans = (dp[n][D][n / 2 - 1] + (long long)tmp * (tmp + 1) / 2) % MOD;
}
if (n == 1) ans = 1;
if (ans < 0) ans += MOD;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, mod, ans, tr[15];
int f[1005], inv[15];
int g[15][1005];
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n == 1) return puts("1"), 0;
for (int i = (int)(0); i <= (int)(d); i++) g[i][i] = 1;
f[1] = inv[0] = inv[1] = 1;
for (int i = (int)(2); i <= (int)(d); i++)
inv[i] = 1ll * inv[mod % i] * (mod - mod / i) % mod;
for (int i = (int)(2); i <= (int)(n / 2); i++) {
f[i] = g[d - 1][i - 1];
tr[0] = 1;
for (int j = (int)(1); j <= (int)(d); j++)
tr[j] = 1ll * tr[j - 1] * inv[j] % mod * (f[i] + j - 1) % mod;
for (int j = (int)(d); j >= (int)(0); j--)
for (int k = (int)(1); k <= (int)(d - j); k++)
for (int l = (int)(0); l <= (int)(n - k * i); l++)
g[j + k][l + k * i] =
(g[j + k][l + k * i] + 1ll * g[j][l] * tr[k]) % mod;
if (i == (n - 1) / 2) ans = g[d][n - 1];
}
if (n % 2 == 0) ans = (ans + 1ll * f[n / 2] * (f[n / 2] + 1) / 2) % mod;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, d, mod, f[1100][11], jc[11];
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - 48;
ch = getchar();
}
return x * f;
}
inline long long ksm(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 % mod;
}
int main() {
n = read();
d = read();
mod = read();
if (n <= 2) {
cout << 1;
return 0;
}
f[1][d - 1] = f[1][0] = jc[1] = 1;
for (int i = 2; i <= d; i++) jc[i] = jc[i - 1] * i;
for (int i = 2; i <= d; i++) jc[i] = ksm(jc[i], mod - 2);
for (int k = 1; k <= n / 2; k++) {
if (!f[k][d - 1]) continue;
long long tmp = f[k][d - 1], cs = 0;
for (int i = n; i >= k + 1; i--) {
for (int j = 1; j <= d; j++) {
tmp = f[k][d - 1];
cs = 0;
for (int t = 1; t <= j && t * k <= i; t++) {
if (t != 1) tmp *= (++cs + f[k][d - 1]), tmp %= mod;
f[i][j] += (f[i - k * t][j - t] * tmp % mod) * jc[t] % mod;
f[i][j] %= mod;
}
}
}
}
if (n % 2)
cout << f[n][d] % mod;
else {
f[n][d] -= f[n / 2][d - 1] * (f[n / 2][d - 1] - 1) % mod * jc[2] % mod;
cout << (f[n][d] + mod) % mod;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000000 + 7;
int addm(int& a, int b) {
return (a += b) < mod ? (a < 0 ? a += mod : a) : a -= mod;
}
int addm2(int a, int b) { return addm(a, b); }
template <class T, class U>
bool smin(T& a, U b) {
return a > b ? (a = b, 1) : 0;
}
template <class T, class U>
bool smax(T& a, U b) {
return a < b ? (a = b, 1) : 0;
}
int n, d, dp[1001][11][1001], cs[1001][11][1002];
int a, b, g;
void gcd(int m, int n) {
if (n == 0) {
a = 1;
b = 0;
g = m;
return;
}
gcd(n, m % n);
int t = a - b * (m / n);
a = b;
b = t;
}
int inv(int a, int mod) {
gcd(mod, a);
return g > 0 ? b : -b;
}
int iv[1001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> d >> mod;
dp[0][0][0] = 1;
for (int i = 1; i <= 1000; i++) iv[i] = inv(i, mod);
for (int i = 1; i < 1002; i++)
for (int j = 0; j <= d; j++)
cs[0][j][i] = addm2(cs[0][j][i - 1], dp[0][j][i - 1]);
for (int i = 1; i < n; i++)
for (int j = 1; j <= d; j++)
for (int k = 1; k < n; k++) {
long long f = 1;
for (int l = 1; l * k <= i && l <= j && (k == 1 || cs[k - 1][d - 1][k]);
l++) {
f = f * ((k == 1 ? 1 : cs[k - 1][d - 1][k]) + l - 1) % mod * iv[l] %
mod;
addm(cs[i][j][k + 1], (long long)cs[i - l * k][j - l][k] * f % mod);
}
addm(cs[i][j][k + 1], cs[i][j][k]);
}
int ans = cs[n - 1][d][(n + 1) / 2];
addm(ans, cs[n - 1][0][(n + 1) / 2]);
if (n % 2 == 0) {
long long v = cs[n / 2 - 1][d - 1][n / 2] + cs[n / 2 - 1][0][n / 2];
addm(ans, v * (v + 1) / 2 % mod);
}
if (ans < 0) ans += mod;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, d, P, inv[15], f[1100][15][1100];
long long C(long long n, long long m) {
long long res = 1;
for (long long i = n; i > n - m; i--) res = res * i % P;
for (long long j = 1; j <= m; j++) res = res * inv[j] % P;
return res;
}
signed main() {
scanf("%lld %lld %lld", &n, &d, &P);
if (n <= 2) return puts("1"), 0;
inv[1] = 1;
for (long long i = 2; i <= d; i++) inv[i] = (P - P / i) * inv[P % i] % P;
for (long long i = 0; i <= n; i++) f[1][0][i] = 1;
for (long long i = 2; i <= n; i++)
for (long long j = 1; j <= min(d, i - 1); j++)
for (long long k = 1; k <= n; k++) {
f[i][j][k] = f[i][j][k - 1];
for (long long t = 1; t <= j && k * t <= i; t++) {
if (k == 1)
(f[i][j][k] +=
f[i - t * k][j - t][k - 1] * C(f[k][0][k - 1] + t - 1, t)) %= P;
else
(f[i][j][k] += f[i - t * k][j - t][k - 1] *
C(f[k][d - 1][k - 1] + t - 1, t)) %= P;
}
}
if (n & 1)
printf("%lld\n", f[n][d][n / 2]);
else
printf("%lld\n",
(f[n][d][n / 2] - C(f[n / 2][d - 1][n / 2 - 1], 2) + P) % P);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Mod, inv[1005];
inline void add(int &x, int y) {
if ((x += y) >= Mod) x -= Mod;
if (x < 0) x += Mod;
}
inline int fp(int a, int k) {
int res = 1;
while (k) {
if (k & 1) res = 1LL * res * a % Mod;
a = 1LL * a * a % Mod;
k >>= 1;
}
return res;
}
int dp[1005][15];
int main() {
int n, d;
scanf("%d%d%d", &n, &d, &Mod);
if (n <= 2) return 0 * printf("1");
for (int i = 1; i <= n; i++) inv[i] = fp(i, Mod - 2);
dp[1][0] = 1;
int res = 0;
for (int k = 1; k <= n; k++)
for (int i = n; i >= 2; i--)
for (int j = d; j >= 1; j--) {
int sum = 0, now = 1, cnt = (k > 1 ? dp[k][d - 1] : 1);
for (int t = 0; t <= j && t * k < i; t++) {
add(sum, 1LL * now * dp[i - t * k][j - t] % Mod);
now = 1LL * now * (cnt + t) % Mod * inv[t + 1] % Mod;
}
dp[i][j] = sum;
if (k == n / 2 && i == n && j == d) add(res, dp[i][j]);
}
if (n % 2 == 0)
add(res, -1LL * dp[n / 2][d - 1] * (dp[n / 2][d - 1] - 1) / 2 % Mod);
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const int D = 11;
int mod;
long long mul(long long a, long long b) { return (a * b) % mod; }
long long bin_pow(long long b, long long p) {
long long res = 1;
for (long long j = 1, pw = b; j <= p; j <<= 1, pw = mul(pw, pw))
if (p & j) res = mul(res, pw);
return res;
}
long long inv(long long x) { return bin_pow(x, mod - 2); }
long long nCr(long long n, long long r) {
long long res = 1;
for (int i = 0; i < r; i++) {
res = mul(res, mul(n - i, inv(i + 1)));
}
return res;
}
long long dp[N][N][D];
long long ct[N][D];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, d;
cin >> n >> d >> mod;
if (n <= 2) return cout << "1\n", 0;
fill(ct[1], ct[1] + D, 1);
for (int i = 0; i < N; i++) dp[1][i][0] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 0; k <= d; k++) {
dp[i][j][k] = dp[i][j - 1][k];
for (int cnt = 1; cnt <= k && cnt * j < i; cnt++) {
dp[i][j][k] += dp[i - cnt * j][j - 1][k - cnt] * ct[j][cnt];
dp[i][j][k] %= mod;
}
}
}
ct[i][0] = 1;
ct[i][1] = dp[i][i - 1][d - 1];
for (int j = 2; j <= d; j++) {
ct[i][j] = nCr(ct[i][1] + j - 1, j);
}
}
long long ans = dp[n][(n - 1) / 2][d];
if (n % 2 == 0) {
long long x = dp[n / 2][(n / 2) - 1][d - 1];
ans += x;
ans += mul(mul(x, x - 1), inv(2));
}
cout << ans % mod << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, modulo;
int inv[99];
const int N(1111);
int dp[N][N][15];
int f(int i, int j, int k) {
if (dp[i][j][k] != -1) {
return dp[i][j][k];
} else if (i == 0 && j == 0 && k == 0) {
return 1;
} else if (j == 0) {
return 0;
} else if (dp[i][j][k] != -1) {
return dp[i][j][k];
} else {
int& res(dp[i][j][k]);
res = 0;
int x(j == 1 ? 1 : f(j - 1, j - 1, d));
int lst(1);
for (int o(0); o * j <= i && o <= k; o++) {
res = (res + (long long)f(i - o * j, j - 1, k - o) * lst) % modulo;
lst = (long long)lst * (x + o + modulo) % modulo * inv[o + 1] % modulo;
}
return res;
}
}
int pw(int x, int n) {
int res(1);
while (n) {
if (n & 1) {
res = (long long)res * x % modulo;
}
x = (long long)x * x % modulo;
n /= 2;
}
return res;
}
int main() {
scanf("%d%d%d", &n, &d, &modulo);
d--;
if (d == 1 || n <= 2) {
printf("1\n");
return 0;
}
for (int i(1); i <= d + 1; i++) {
inv[i] = pw(i, modulo - 2);
}
memset(dp, -1, sizeof(dp));
dp[0][0][0] = 1;
f(n - 1, n - 1, d + 1);
for (int i(0); i <= n - 1; i++) {
f(i, i, d + 1);
f(i, i, d);
}
int ans(dp[n - 1][n - 1][d + 1]);
dp[0][0][d] = 0;
for (int i(1); i <= n - i; i++) {
ans =
(ans -
(long long)dp[i - 1][i - 1][d] * dp[n - i - 1][n - i - 1][d] % modulo +
modulo) %
modulo;
}
if (n % 2 == 0) {
ans = (ans + (long long)(dp[n / 2 - 1][n / 2 - 1][d]) *
(dp[n / 2 - 1][n / 2 - 1][d] + 1) / 2) %
modulo;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, maxn = 15;
int n, d, mod;
long long ans, fac[maxn], inv[maxn], f[N][maxn][N];
long long fpow(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 % mod;
}
inline long long C(int n, int m) {
if (n < m || n < 0 || m < 0) {
return 0;
}
long long res = 1;
for (int i = n; i >= n - m + 1; i--) {
res = (res * i) % mod;
}
return (res * inv[m]) % mod;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) {
printf("1\n");
return 0;
}
fac[0] = inv[0] = 1;
for (int i = 1; i <= d; i++) {
fac[i] = (fac[i - 1] * i) % mod;
inv[i] = fpow(fac[i], mod - 2);
}
for (int k = 0; k <= n / 2; k++) {
f[1][0][k] = 1;
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= min(i - 1, d); j++) {
for (int k = 1; k <= n / 2; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t <= j && t * k < i; t++) {
if (k == 1) {
f[i][j][k] = (f[i][j][k] + C(f[k][0][k - 1] + t - 1, t) *
f[i - t * k][j - t][k - 1] % mod) %
mod;
} else {
f[i][j][k] = (f[i][j][k] + C(f[k][d - 1][k - 1] + t - 1, t) *
f[i - t * k][j - t][k - 1] % mod) %
mod;
}
}
}
}
}
if (n & 1) {
ans = f[n][d][n / 2];
} else {
ans = (f[n][d][n / 2] - C(f[n / 2][d - 1][n / 2 - 1], 2) + mod) % mod;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const long long N = 1010;
long long n, d, mod, f[N][11][N >> 1], fac[N], inv[N];
inline long long fpow(long long x, long long p) {
long long ans = 1;
for (; p; p >>= 1, x = x * x % mod)
if (p & 1) ans = ans * x % mod;
return ans;
}
inline void initfac(long long n) {
fac[0] = 1;
for (long long i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i % mod;
inv[n] = fpow(fac[n], mod - 2);
for (long long i = n - 1; ~i; --i) inv[i] = inv[i + 1] * (i + 1) % mod;
}
inline long long C(long long n, long long m) {
if (n < m) return 0;
long long ans = 1;
for (long long i = n; i >= n - m + 1; --i) ans = ans * i % mod;
return ans * inv[m] % mod;
}
signed main() {
n = read();
d = read();
mod = read();
if (n <= 2) return puts("1") & 0;
initfac(N - 10);
for (long long i = 0; i <= n / 2; ++i) f[1][0][i] = 1;
f[1][d - 1][0] = 1;
for (long long i = 2; i <= n; ++i) {
for (long long j = 1; j <= min(d, i - 1); ++j) {
for (long long k = 1; k <= n / 2; ++k) {
f[i][j][k] = f[i][j][k - 1];
for (long long l = 1; l * k <= i && l <= j; ++l) {
f[i][j][k] =
(f[i][j][k] + f[i - l * k][j - l][k - 1] *
C(f[k][d - 1][k - 1] + l - 1, l) % mod) %
mod;
}
}
}
}
if (n & 1) return printf("%lld", f[n][d][n / 2]) & 0;
return printf(
"%lld",
(f[n][d][n / 2] - C(f[n / 2][d - 1][n / 2 - 1], 2) + mod) % mod) &
0;
}
|
#include <bits/stdc++.h>
int md;
int vv[10 + 1];
void init() {
int i;
for (i = 1; i <= 10; i++)
vv[i] = i == 1 ? 1 : (long long)vv[i - md % i] * (md / i + 1) % md;
}
int main() {
static int dp[1000 + 1], dq[1000 + 1];
int n, d, i, j, k, ans;
scanf("%d%d%d", &n, &d, &md), init();
if (n == 1 || d == 2) {
printf("1\n");
return 0;
}
if ((n - 1) % (d - 1) != 1) {
printf("0\n");
return 0;
}
dp[1] = 1, dq[1] = 1;
for (i = 1; i * 2 < n; i++) {
int x = dp[i];
if (i % (d - 1) != 1 || x == 0) continue;
for (j = n / 2 - 1; j > 0; j--) {
int y = dp[j], z = 1, k_ = (j - 2) % (d - 1) + 1;
for (k = 1; (j + i * k) * 2 <= n && k_ + k < d && z != 0; k++) {
z = (long long)z * (x + k - 1) % md * vv[k] % md;
dp[j + i * k] = (dp[j + i * k] + (long long)y * z) % md;
}
}
for (j = n - 1; j > 0; j--) {
int y = dq[j], z = 1, k_ = (j - 2) % (d - 1) + 1;
for (k = 1; j + i * k <= n &&
(k_ + k < d || k_ + k == d && j + i * k == n) && z != 0;
k++) {
z = (long long)z * (x + k - 1) % md * vv[k] % md;
dq[j + i * k] = (dq[j + i * k] + (long long)y * z) % md;
}
}
}
ans = dq[n];
if (n % 2 == 0 && n / 2 % (d - 1) == 1)
ans = (ans + (long long)dp[n / 2] * (dp[n / 2] + 1) % md * vv[2]) % md;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, mod;
int f[1010][11][1010], g[1010][11], iv[11];
inline int add(int a, int b) {
if ((a += b) >= mod) 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 main() {
scanf("%d%d%d", &n, &d, &mod);
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
for (int i = 1; i <= d; i++) g[1][i] = 1;
for (int i = 1; i <= d; i++) iv[i] = power(i, mod - 2);
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= d; j++) {
for (int k = 1; k < i; k++) {
for (int l = 1; l <= j && l * k <= i; l++) {
f[i][j][k] =
add(f[i][j][k], mult(f[i - l * k][j - l][k - 1], g[k][l]));
}
}
for (int k = 1; k <= n; k++) f[i][j][k] = add(f[i][j][k], f[i][j][k - 1]);
}
g[i][1] = f[i][d - 1][n];
for (int j = 2; j <= d; j++)
g[i][j] = mult(mult(g[i][j - 1], (f[i][d - 1][n] + j - 1)), iv[j]);
}
int ans;
if (n <= 2)
ans = 1;
else
ans = f[n][d][n / 2];
if (n > 2 && !(n & 1))
ans = (ans -
mult(mult((f[n / 2][d - 1][n / 2] - 1), f[n / 2][d - 1][n / 2]),
iv[2]) +
mod) %
mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
int n, m, mod;
int inv[maxn], f[maxn][12][maxn >> 1];
inline void read(int &k) {
int f = 1;
k = 0;
char c = getchar();
while (c < '0' || c > '9') c == '-' && (f = -1), c = getchar();
while (c <= '9' && c >= '0') k = k * 10 + c - '0', c = getchar();
k *= f;
}
inline int power(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) ans = 1ll * ans * a % mod;
return ans;
}
int main() {
read(n);
read(m);
read(mod);
if (n <= 2) return puts("1"), 0;
for (int i = 1; i <= n; i++) inv[i] = power(i, mod - 2);
for (int i = 0; i <= n / 2; i++) f[1][0][i] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 1; k <= n / 2; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int l = 1, tmp = 1; l <= j && k * l <= i; l++) {
tmp = 1ll * tmp * (f[k][(k == 1) ? 0 : m - 1][k - 1] + l - 1) % mod *
inv[l] % mod;
f[i][j][k] =
(f[i][j][k] + 1ll * f[i - k * l][j - l][k - 1] * tmp) % mod;
}
}
}
}
int ans = f[n][m][n >> 1];
if ((n & 1) == 0) {
int t = f[n >> 1][m - 1][(n >> 1) - 1];
ans = (ans - 1ll * t * (t - 1) / 2 % mod + mod) % mod;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline void rd(int &x) {
char ch;
x = 0;
bool fl = false;
while (!isdigit(ch = getchar())) (ch == '-') && (fl = true);
for (x = (ch ^ '0'); isdigit(ch = getchar()); x = x * 10 + (ch ^ '0'))
;
(fl == true) && (x = -x);
}
namespace Miracle {
const int N = 1005;
int mod, n, d;
int f[N][11][N];
int jie[11], inv[11];
int qm(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (long long)ret * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return ret;
}
int dp(int i, int j, int k) {
if (f[i][j][k] != -1) return f[i][j][k];
if (i == 1) {
if (j == 0)
return f[i][j][k] = 1;
else if (k == 0)
return f[i][j][k] = 1;
return f[i][j][k] = 0;
}
if (i == 0) {
if (k == 0 && j == 0)
return f[i][j][k] = 1;
else
return f[i][j][k] = 0;
}
if (j > i - 1) return f[i][j][k] = 0;
if (i > 1 && k == 0) return f[i][j][k] = 0;
int C = 1;
int ret = 0;
int tmp = dp(k, d - 1, k - 1);
for (register int m = 0; m <= j && m * k <= i - 1; ++m) {
ret = (ret +
(long long)dp(i - m * k, j - m, k - 1) * C % mod * inv[m] % mod) %
mod;
C = (long long)C * (tmp - 1 + m + 1) % mod;
}
return f[i][j][k] = ret;
}
int main() {
rd(n);
rd(d);
rd(mod);
if (n <= 2) {
puts("1");
return 0;
}
memset(f, -1, sizeof f);
jie[0] = 1;
for (register int i = 1; i <= 10; ++i)
jie[i] = (long long)jie[i - 1] * i % mod;
inv[10] = qm(jie[10], mod - 2);
for (register int i = 9; i >= 0; --i)
inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
long long ans = 0;
ans = (ans + dp(n, d, (n - 1) / 2));
if (n % 2 == 0) {
long long tmp = 0;
tmp = dp(n / 2, d - 1, n / 2 - 1);
ans = (ans + (tmp * (tmp + 1) / 2 % mod)) % mod;
}
printf("%I64d", ans);
return 0;
}
} // namespace Miracle
signed main() {
Miracle::main();
return 0;
}
|
#include <bits/stdc++.h>
int f[1005][11][1005], g[1005][11], ine[11], n, d, mo;
int inv(int x) {
int i = 1, y = mo - 2;
for (; y; y >>= 1, x = 1ll * x * x % mo)
if (y & 1) i = 1ll * i * x % mo;
return i;
}
int main() {
scanf("%d%d%d\n", &n, &d, &mo);
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
for (int i = 1; i <= d; i++) g[1][i] = 1;
for (int i = 1; i <= d; i++) ine[i] = inv(i);
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= d; j++) {
for (int k = 1; k < i; k++)
for (int l = 1; l <= j && l * k <= i; l++)
f[i][j][k] =
(f[i][j][k] + 1ll * f[i - l * k][j - l][k - 1] * g[k][l]) % mo;
for (int k = 1; k <= n; k++)
f[i][j][k] = (f[i][j][k] + f[i][j][k - 1]) % mo;
}
g[i][1] = f[i][d - 1][n];
for (int j = 2; j <= d; j++)
g[i][j] = 1ll * g[i][j - 1] * (f[i][d - 1][n] + j - 1) % mo * ine[j] % mo;
}
int ans;
if (n <= 2)
ans = 1;
else
ans = f[n][d][n / 2];
if (n > 2 && !(n & 1))
ans = (ans -
1ll * (f[n / 2][d - 1][n / 2] - 1) * f[n / 2][d - 1][n / 2] % mo *
ine[2] % mo +
mo) %
mo;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
int mod, inv[10 + 1], dp[1000 + 1], d[1000 + 1][1000 + 1][10 + 1];
inline int lgput(int a, int n) {
int r = 1;
while (n) {
if (n % 2) r = 1LL * r * a % mod;
n /= 2;
a = 1LL * a * a % mod;
}
return r;
}
int main() {
int n, D;
fscanf(stdin, "%d%d%d", &n, &D, &mod);
if (D == 2 || n <= 2) {
fprintf(stdout, "1\n");
return 0;
}
for (int i = 1; i <= D; i++) inv[i] = lgput(i, mod - 2);
for (int j = 0; j <= n; j++) d[1][j][0] = 1;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int g = 0; g <= D; g++) {
d[i][j][g] = d[i][j - 1][g];
int r = 1;
for (int p = 1; p <= g && i - p * j > 0; p++) {
r = 1LL * r * (dp[j] + p - 1) % mod * inv[p] % mod;
d[i][j][g] =
(d[i][j][g] + 1LL * r * d[i - p * j][j - 1][g - p]) % mod;
}
}
}
dp[i] = d[i][n][D - 1];
}
int ans = d[n][(n - 1) / 2][D];
if (n % 2 == 0)
ans = (ans + 1LL * d[n / 2][n][D - 1] * (d[n / 2][n][D - 1] + 1) / 2) % mod;
fprintf(stdout, "%d\n", ans);
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int N = 1005;
int P;
inline int Pow(int a, int b) {
int c = 1;
for (; b; b >>= 1, a = a * 1ll * a % P)
if (b & 1) c = c * 1ll * a % P;
return c;
}
inline void add(int &a, int b) {
a += b;
if (a >= P) a -= P;
}
inline void dec(int &a, int b) {
a -= b;
if (a < 0) a += P;
}
int n, d;
int fac[N], inv[N];
int f[N][11];
int ji(int a, int b) {
int res = 1;
for (int i = (int)0; i <= (int)b - 1; i++) res = res * 1ll * (a + i) % P;
return res;
}
int main() {
scanf("%d%d%d", &n, &d, &P);
if (n <= 2) {
printf("1");
return 0;
}
fac[0] = 1;
for (int i = (int)1; i <= (int)n; i++) fac[i] = fac[i - 1] * 1ll * i % P;
inv[n] = Pow(fac[n], P - 2);
for (int i = (int)n - 1; i >= (int)0; i--)
inv[i] = inv[i + 1] * 1ll * (i + 1) % P;
for (int k = (int)0; k <= (int)d; k++) f[1 + k][k] = 1;
for (int i = (int)1; i <= (int)(n - 1) / 2; i++) {
int way = f[i][d - 1];
for (int j = (int)n; j >= (int)1; j--)
for (int k = (int)0; k <= (int)d - 1; k++)
if (f[j][k]) {
int rest = n - j;
int dd = way;
for (int use = (int)1; use <= (int)rest / i; use++) {
if (k + use > d) break;
add(f[j + use * i][k + use],
(f[j][k] * 1ll * dd % P) * 1ll * inv[use] % P);
dd = dd * 1ll * (way + use) % P;
}
}
}
if (n % 2 == 0) {
int ans = f[n / 2][d - 1];
add(ans, (f[n / 2][d - 1] * 1ll * (f[n / 2][d - 1] - 1) / 2) % P);
add(ans, f[n][d]);
printf("%d\n", ans);
} else {
printf("%d\n", f[n][d]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int t = 1, sum = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') t = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') sum = sum * 10 + ch - '0', ch = getchar();
return t * sum;
}
const int Max = 1e3 + 10;
int g[Max], f[Max][15], inv[Max], n, d, mod, ans;
void get_ready() {
inv[0] = inv[1] = true;
int i;
for (i = 2; i <= n; i++) inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod;
for (i = 1; i <= n; i++) inv[i] = 1LL * inv[i - 1] * inv[i] % mod;
}
inline void up(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
void solve() {
int i, j, k, l, w;
g[1] = 1;
f[0][0] = 1;
for (i = 1; i <= n / 2; i++) {
for (j = n - i; ~j; j--)
for (k = 0; k < d; k++)
if (f[j][k])
for (w = 1, l = 1; k + l <= d && j + i * l <= n; l++)
w = 1LL * w * (g[i] + l - 1) % mod,
up(f[j + i * l][k + l], 1LL * f[j][k] * w % mod * inv[l] % mod);
g[i + 1] = f[i][d - 1];
}
ans = f[n - 1][d];
if (!(n & 1)) up(ans, mod - 1LL * g[n >> 1] * (g[n >> 1] - 1) / 2 % mod);
printf("%d\n", ans);
}
int main() {
n = read();
d = read();
mod = read();
if (n <= 2) return printf("1\n"), 0;
if ((n - 2) % (d - 1) != 0) return printf("0\n"), 0;
get_ready();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
int mod, d;
int dp[1005][12][1005];
int inv[20];
void fmain() {
scanf("%d%d%d", &n, &d, &mod);
dp[1][0][0] = 1;
dp[1][d - 1][0] = 1;
inv[0] = 1;
for (int(i) = 1; (i) <= (int)(15); (i)++) inv[i] = fastPow(i, mod - 2, mod);
if (n <= 2) {
puts("1");
return;
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= d; j++) {
for (int k = 1; k < i; k++) {
dp[i][j][k] = dp[i][j][k - 1];
int r = dp[k][d - 1][k - 1] - 1, c = 1;
for (int t = 1; t * k < i && t <= j; t++) {
int z = dp[i - t * k][j - t][min(k - 1, i - t * k - 1)];
c = (long long)c * (++r) % mod * inv[t] % mod;
addmod(dp[i][j][k], (long long)z * c % mod, mod);
}
}
}
}
int ans = dp[n][d][(n + 1) / 2 - 1];
if (n % 2 == 0) {
addmod(ans,
(long long)dp[n / 2][d - 1][n / 2 - 1] *
(dp[n / 2][d - 1][n / 2 - 1] + 1) / 2 % mod,
mod);
}
printf("%d\n", ans);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, d, mod, dp[((long long)1010)][((long long)1010)][((long long)11)],
tvn[((long long)11)];
long long tavan(long long x, long long y) {
long long res = 1;
while (y) {
res *= (y % 2) ? x : 1;
res %= mod;
x *= x;
x %= mod;
y /= 2;
}
return res;
}
long long C(long long x, long long y) {
if (x < y) return 0;
long long res = 1;
for (long long i = x; i > x - y; i--) res *= i, res %= mod;
for (long long i = 1; i <= y; i++) res *= tvn[i], res %= mod;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> d >> mod;
for (int i = 1; i < ((long long)11); i++) tvn[i] = tavan(i, mod - 2);
if (n <= 2) return cout << "1\n", 0;
dp[1][0][d - 1] = dp[1][0][0] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= i - 1; j++)
for (int k = 1; k <= d; k++) {
dp[i][j][k] = dp[i][j - 1][k];
for (int p = 1; p * j <= i - 1 && p <= k; p++)
if (i - p * j != 1 || min(j - 1, i - p * j - 1) != 0 ||
k - p != d - 1)
dp[i][j][k] += (dp[i - p * j][min(j - 1, i - p * j - 1)][k - p] *
C(dp[j][j - 1][d - 1] + p - 1, p)) %
mod,
dp[i][j][k] %= mod;
}
long long res = dp[n][n / 2][d];
if (n % 2 == 0)
res -= C(dp[n / 2][n / 2 - 1][d - 1], 2), res %= mod, res += mod,
res %= mod;
cout << res << "\n";
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char c;
inline void read(long long& a) {
a = 0;
do c = getchar();
while (c < '0' || c > '9');
while (c <= '9' && c >= '0') a = (a << 3) + (a << 1) + c - '0', c = getchar();
}
long long n, d, Mod, F[1001], G[11][1001], Rev[10];
inline long long C(long long x, long long y) {
long long r = Rev[y];
for (long long i = x; i < x + y; i++) r = r * i % Mod;
return r;
}
int main() {
read(n), read(d), read(Mod);
if (n == 1) return puts("1"), 0;
if ((n - 2) % (d - 1)) return puts("0"), 0;
n = (n - 2) / (d - 1);
Rev[0] = Rev[1] = 1;
for (int i = 2; i <= d; i++) Rev[i] = (Mod - Mod / i) * Rev[Mod % i] % Mod;
for (int i = 2; i <= d; i++) Rev[i] = Rev[i] * Rev[i - 1] % Mod;
F[0] = 1;
for (int i = 0; i <= d; i++) G[i][0] = 1;
for (int i = 1; i <= n >> 1; i++) {
F[i] = G[d - 1][i - 1];
if (i + i < n)
for (int j = d; j; j--)
for (int l = i; l <= n; l++)
for (int k = 1; k <= j && i * k <= l; k++)
G[j][l] = (G[j][l] + G[j - k][l - i * k] * C(F[i], k)) % Mod;
}
cout << (G[d][n - 1] + (n & 1 ? 0 : C(F[n >> 1], 2))) % Mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 7;
const int D = 12;
int MOD;
int f[N][D], g[N];
int n, d, rev[N];
int power(int a, int n) {
int ret = 1;
for (int i = 1; i <= n; i <<= 1) {
if (n & i) {
ret = 1LL * ret * a % MOD;
}
a = 1LL * a * a % MOD;
}
return ret;
}
void add(int &a, int b) {
if ((a += b) >= MOD) {
a -= MOD;
}
}
int comb(int n, int m) {
assert(n <= MOD && m <= MOD);
int ret = 1;
for (int i = 1; i <= m; i++) {
ret = 1LL * ret * ((n - i + 1 + MOD) % MOD) % MOD;
ret = 1LL * ret * rev[i] % MOD;
}
return ret;
}
int main() {
scanf("%d %d %d", &n, &d, &MOD);
if (n <= 2) {
printf("1\n");
return 0;
}
rev[0] = 1;
for (int i = 1; i <= d; i++) {
rev[i] = power(i, MOD - 2) % MOD;
}
f[1][0] = 1;
for (int i = 1; i <= n / 2; i++) {
if (i == 1) {
g[1] = 1;
} else {
g[i] = f[i][d - 1];
}
if (g[i] == 0) continue;
if ((i - 1) % (d - 1) != 0) assert(g[i] == 0);
for (int j = n; j >= 1; j--) {
for (int k = 0; k <= d; k++) {
if (f[j][k] == 0) {
continue;
}
for (int l = 1; k + l <= d && j + l * i <= n; l++) {
add(f[j + l * i][k + l], 1LL * f[j][k] * comb(g[i] + l - 1, l) % MOD);
}
}
}
}
int ans = f[n][d];
if (n % 2 == 0) {
ans += MOD - comb(f[n / 2][d - 1], 2);
ans %= MOD;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1026;
std::map<std::pair<long long, long long>, long long> M;
long long MOD;
long long qpow(long long a, long long p) {
long long ans = 1;
while (p > 0) {
if (p & 1) ans = (ans * a) % MOD;
a = a * a % MOD;
p >>= 1;
}
return ans;
}
int N, D;
long long dp[MAXN][11][MAXN];
long long inv[200];
long long C(long long n, long long k) {
std::map<std::pair<long long, long long>, long long>::iterator it =
M.find(std::pair<long long, long long>(n, k));
if (it != M.end()) return it->second;
n %= MOD;
long long ans = 1;
for (long long i = 0; i < k; i++) {
ans = (ans * (n - i + MOD)) % MOD;
}
ans = ans * inv[k] % MOD;
return M[std::pair<long long, long long>(n, k)] = ans;
}
int main() {
std::cin >> N >> D >> MOD;
if (N == 1) {
puts("1");
return 0;
}
inv[0] = 1;
for (int i = 1; i <= 20; i++) {
inv[i] = inv[i - 1] * qpow(i, MOD - 2) % MOD;
}
for (int i = 0; i <= N; i++) {
dp[1][D - 1][i] = 1;
dp[1][0][i] = 1;
}
for (int i = 2; i <= N; i++) {
for (int j = 1; j <= D; j++) {
for (int k = 1; k <= N; k++) {
dp[i][j][k] = dp[i][j][k - 1];
for (int t = 1; t * k <= i && t <= j; t++) {
dp[i][j][k] += dp[i - k * t][j - t][k - 1] *
C(dp[k][D - 1][k - 1] + t - 1, t) % MOD;
if (dp[i][j][k] >= MOD) dp[i][j][k] -= MOD;
}
}
}
}
long long ans = dp[N][D][(N + 1) / 2 - 1];
long long x = dp[N / 2][D - 1][N / 2 - 1];
if (N % 2 == 0) ans += (x * x % MOD + x) % MOD * inv[2] % MOD;
ans %= MOD;
std::cout << ans << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1000, MAXD = 20;
int n, d, 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 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[MAXD + 5], Inv[MAXD + 5];
void Init() {
Fac[0] = 1;
for (int i = 1; i <= MAXD; i++) Fac[i] = 1ll * Fac[i - 1] * i % Mod;
Inv[MAXD] = Inverse(Fac[MAXD]);
for (int i = MAXD; i >= 1; i--) Inv[i - 1] = 1ll * Inv[i] * i % Mod;
}
int C(int n, int m) {
int Ans = 1;
for (int i = n; i >= n - m + 1; i--) Ans = 1ll * Ans * i % Mod;
return 1ll * Ans * Inv[m] % Mod;
}
int dp[MAXN + 5][MAXD + 1][MAXN / 2 + 5];
int dfs(int Sz, int nowd, int MaxSz) {
if (dp[Sz][nowd][MaxSz] != -1) return dp[Sz][nowd][MaxSz];
if (Sz == 1) return dp[Sz][nowd][MaxSz] = nowd == 0;
if (MaxSz == 1) return dp[Sz][nowd][MaxSz] = Sz == nowd + 1;
if (!nowd || !MaxSz || nowd >= Sz) return dp[Sz][nowd][MaxSz] = 0;
int Ans = 0;
for (int t = 0; t * MaxSz < Sz && t <= nowd; t++)
Ans = Add(Ans, 1ll * C(dfs(MaxSz, d - 1, MaxSz - 1) + t - 1, t) *
dfs(Sz - t * MaxSz, nowd - t, MaxSz - 1) % Mod);
return dp[Sz][nowd][MaxSz] = Ans;
}
int main() {
scanf("%d %d %d", &n, &d, &Mod);
if (n == 1 || n == 2) return printf("1\n") & 0;
Init();
memset(dp, -1, sizeof(dp));
if (n & 1)
printf("%d\n", dfs(n, d, n / 2));
else
printf("%d\n", Sub(dfs(n, d, n / 2), C(dfs(n / 2, d - 1, n / 2 - 1), 2)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, mod;
inline int mul(int x, int y) { return (long long)x * y % mod; }
inline void add(int &x, int y) {
y += x;
x = y >= mod ? y - mod : y;
}
inline int inc(int x, int y) {
x += y;
return x >= mod ? x - mod : x;
}
inline int qpow(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = mul(x, x))
if (y & 1) res = mul(res, x);
return res;
}
const int maxn = 1005;
int f[maxn][12][maxn >> 1], inv[maxn];
int main() {
cin >> n >> m >> mod;
if (n <= 2) return puts("1"), 0;
for (int i = 1; i <= n; i++) inv[i] = qpow(i, mod - 2);
for (int i = 0; i <= n / 2; i++) f[1][0][i] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = 1; k <= n / 2; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int l = 1, coef = 1; l <= j && k * l <= i; l++) {
coef =
mul(coef, mul(f[k][k == 1 ? 0 : m - 1][k - 1] + l - 1, inv[l]));
add(f[i][j][k], mul(f[i - l * k][j - l][k - 1], coef));
}
}
int ans = f[n][m][n >> 1];
if (!(n & 1)) {
int v = f[n >> 1][m - 1][(n >> 1) - 1];
add(ans, mod - (long long)v * (v - 1) / 2ll % mod);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
const int MAXD = 22;
int n, d, mod;
long long dp[MAXN][MAXD][MAXN], inv[MAXD];
long long quick_pow(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;
}
long long DFS(int n, int m, int k) {
k = min(k, n - 1);
long long& ret = dp[n][m][k];
if (~ret) return ret;
if ((n == 1 && m == 0) || (n == 1 && m == d - 1)) return ret = 1;
if (n == 1 || k == 0) return ret = 0;
ret = DFS(n, m, k - 1);
long long t = DFS(k, d - 1, k), tmp = 1;
for (int i = 1; i * k < n && i <= m; ++i) {
tmp = tmp * (i + t - 1) % mod * inv[i] % mod;
ret = (ret + tmp * DFS(n - i * k, m - i, k - 1)) % mod;
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
inv[0] = inv[1] = 1;
for (int i = 2; i < MAXD; ++i) inv[i] = quick_pow(i, mod - 2);
memset(dp, -1, sizeof(dp));
if (n == 1 || n == 2) {
puts("1");
return 0;
}
if ((n - 2) % (d - 1)) {
puts("0");
return 0;
}
long long ans = DFS(n, d, n / 2);
if (n % 2 == 0) {
long long b = DFS(n / 2, d - 1, n / 2);
ans = ((ans - (b - 1) * b / 2) % mod + mod) % mod;
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
bool f = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = 1;
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
if (f) x = -x;
}
template <typename F>
inline void write(F x, char ed = '\n') {
static short st[30];
short tp = 0;
if (x < 0) putchar('-'), x = -x;
do st[++tp] = x % 10, x /= 10;
while (x);
while (tp) putchar('0' | st[tp--]);
putchar(ed);
}
template <typename T>
inline void Mx(T &x, T y) {
x < y && (x = y);
}
template <typename T>
inline void Mn(T &x, T y) {
x > y && (x = y);
}
const int N = 1050;
int n, d, P;
long long inv[N], dp[N];
long long C(long long n, int m) {
long long res = inv[m];
while (m) res = res * n % P, --n, --m;
return res;
}
long long f[12][N][N];
int main() {
read(n), read(d), read(P);
if (n == 1 || n == 2) return write(1), 0;
inv[0] = inv[1] = dp[1] = 1;
for (int i = 2; i <= d; i++) inv[i] = (P - P / i) * inv[P % i] % P;
for (int i = 2; i <= d; i++) inv[i] = inv[i - 1] * inv[i] % P;
for (int i = 0; i <= n; i++) f[0][1][i] = 1;
for (int i = 2; i <= n; i++) {
int lim = min(d, i - 1);
for (int j = 1; j <= lim; j++) {
f[j][i][1] = i == j + 1;
for (int k = 2; k + k <= n; k++) {
f[j][i][k] = f[j][i][k - 1];
for (int t = 1; t <= j && t * k < i; t++)
f[j][i][k] = (f[j][i][k] +
f[j - t][i - t * k][k - 1] * C(dp[k] + t - 1, t) % P) %
P;
}
}
dp[i] = f[d - 1][i][i - 1];
}
long long ans = 0;
if (n & 1)
ans = f[d][n][n / 2];
else
ans = (f[d][n][n / 2 - 1] + C(dp[n / 2] + 1, 2)) % P;
write(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
char c = getchar();
long long flag = 1, ans = 0;
while (c < '0' || c > '9') {
if (c == '-') flag = -flag;
c = getchar();
}
while (c >= '0' && c <= '9') {
ans = ans * 10 + c - '0';
c = getchar();
}
return ans * flag;
}
const long long MAXN = 1005;
long long dp[MAXN][12][MAXN], inv[MAXN], fac[MAXN];
long long n, d, mod;
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) ? (a + mod - b) : (a - b);
}
inline long long mul(long long a, long long b) { return a * b % mod; }
long long qpow(long long b, long long k) {
long long ans = 1;
while (k) {
if (k & 1) ans = mul(ans, b);
b = mul(b, b);
k >>= 1;
}
return ans;
}
void init() {
fac[0] = 1;
for (long long i = 1; i <= n; ++i) fac[i] = mul(fac[i - 1], i);
inv[n] = qpow(fac[n], mod - 2);
for (long long i = n - 1; i + 1; --i) inv[i] = mul(inv[i + 1], i + 1);
}
long long C(long long n, long long m) {
if (n < 0 || m < 0 || n < m) return 0;
long long ans = 1;
for (long long i = 0; i < m; ++i) ans = mul(ans, (n - i));
return mul(ans, inv[m]);
}
int main() {
n = read(), d = read(), mod = read();
if (n <= 2) {
puts("1");
return 0;
}
init();
for (long long i = 0; i <= n; ++i) dp[1][0][i] = 1ll;
for (long long i = 2; i <= n; ++i)
for (long long j = 1; j <= min(d, i - 1); ++j)
for (long long k = 1; k <= n; ++k) {
dp[i][j][k] = dp[i][j][k - 1];
for (long long t = 1; t <= j && t * k <= i; ++t)
dp[i][j][k] =
add(dp[i][j][k],
mul(C(dp[k][(k > 1) ? (d - 1) : 0][k - 1] + t - 1, t),
dp[i - t * k][j - t][k - 1]));
}
long long ans = dp[n][d][n / 2];
if (!(n & 1)) ans = sub(ans, C(dp[n / 2][d - 1][n / 2 - 1], 2));
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fac[1010], inv[1010], mod;
int ksm(int a, int b = mod - 2) {
int r = 1;
for (; b; b >>= 1) {
if (b & 1) r = 1ll * r * a % mod;
a = 1ll * a * a % mod;
}
return r;
}
int C(int a, int b) {
int r = inv[b];
for (b--; b >= 0; b--) r = 1ll * r * (a - b) % mod;
return r;
}
int f[1010][12][1010];
int main() {
int n, d;
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) {
puts("1");
return 0;
}
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[n] = ksm(fac[n]);
for (int i = n - 1; i >= 0; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= min(d, i - 1); j++)
for (int k = 1; k <= n; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t * k <= i && t <= j; t++)
f[i][j][k] =
(f[i][j][k] +
1ll * f[i - t * k][j - t][k - 1] *
(k == 1 ? 1 : C(f[k][d - 1][k - 1] + t - 1, t)) % mod) %
mod;
}
printf("%d\n", (f[n][d][n / 2] -
((n & 1) ? 0 : C(f[n / 2][d - 1][n / 2 - 1], 2)) + mod) %
mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010, M = 15;
int n, d, mod, f[N][M][N], inv[M], ans;
void upd(int &x, int y) {
x += y;
x -= x >= mod ? mod : 0;
}
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;
}
int C(int n, int m) {
int mi = 1;
for (int i = (n - m + 1); i <= (n); i++) mi = (long long)mi * i % mod;
return (long long)mi * inv[m] % mod;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) return puts("1"), 0;
inv[0] = 1;
for (int i = (1); i <= (d); i++) inv[i] = inv[i - 1] * i;
inv[d] = ksm(inv[d], mod - 2);
for (int i = d - 1; i; i--) inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
for (int i = (0); i <= (n); i++) f[1][0][i] = 1;
for (int i = (2); i <= (n); i++)
for (int j = (1); j <= (min(i - 1, d)); j++)
for (int k = (1); k <= (n); k++) {
upd(f[i][j][k], f[i][j][k - 1]);
for (int t = 1; t <= j && t * k < i; t++) {
if (k > 1)
upd(f[i][j][k], (long long)f[i - t * k][j - t][k - 1] *
C(f[k][d - 1][k - 1] + t - 1, t) % mod);
else
upd(f[i][j][k], (long long)f[i - t * k][j - t][k - 1] *
C(f[k][0][k - 1] + t - 1, t) % mod);
}
}
upd(ans, f[n][d][n / 2]);
if (!(n & 1)) upd(ans, mod - C(f[n / 2][d - 1][n / 2], 2));
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
void chkmax(T& x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
void chkmin(T& x, U y) {
if (y < x) x = y;
}
const int MAXN = 1111;
int N, D, MOD;
int dp[12][MAXN];
int r[MAXN], C[MAXN];
int main() {
cin >> N >> D >> MOD;
r[1] = 1;
for (int i = 2; i < MAXN; i++) {
r[i] = (long long)(MOD - r[MOD % i]) * (MOD / i) % MOD;
}
if (D == 2) {
puts("1");
return 0;
}
int M = N / 2;
D--, dp[D][1] = dp[D + 1][1] = 1;
dp[0][1] = 1;
for (int i = 1; i <= M; i++) {
int cur = dp[D][i];
C[0] = 1;
for (int k = 1; k <= D + 1; k++)
C[k] = (long long)C[k - 1] * (cur + k - 1) % MOD * r[k] % MOD;
for (int k = D + 1; k > 0; k--) {
for (int j = N; j > i; j--) {
for (int l = k - 1; l >= 0; l--) {
if (j >= i * (k - l))
dp[k][j] =
(dp[k][j] + (long long)dp[l][j - i * (k - l)] * C[k - l]) % MOD;
}
}
}
}
int ans = dp[D + 1][N];
if (N + 1 & 1)
ans =
(ans + (long long)(MOD - dp[D][M]) * (dp[D][M] - 1) % MOD * r[2]) % MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int 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 << 3) + (x << 1) + (c ^ '0'), c = getchar();
return x * f;
}
const int N = 1e3 + 5, M = 15;
int mod;
inline int inc(int x, int y) {
x += y - mod;
return x + (x >> 31 & mod);
}
inline int del(int x, int y) {
x -= y;
return x + (x >> 31 & mod);
}
inline int mul(int x, int y) { return 1ll * x * y % mod; }
inline void Inc(int &x, int y) { x = inc(x, y); }
inline void Del(int &x, int y) { x = del(x, y); }
inline void Mul(int &x, int y) { x = mul(x, y); }
inline long long Pow(long long x, int k) {
long long res = 1;
while (k) {
if (k & 1) res = res * x % mod;
k >>= 1;
x = x * x % mod;
}
return res;
}
bool st;
int fac[M], inv[M];
inline void init(int n) {
fac[0] = inv[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[n] = Pow(fac[n], mod - 2);
for (int i = n - 1; i >= 1; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
}
int n, d, f[N][M][N];
inline int C(int n, int m) {
if (n < m) return 0;
int res = 1;
for (int i = n - m + 1; i <= n; i++) res = 1ll * res * i % mod;
return 1ll * res * inv[m] % mod;
}
bool ed;
int main() {
n = read(), d = read(), mod = read();
const int m = n / 2;
if (n <= 2) return puts("1"), 0;
init(10);
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
f[1][d - 1][0] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= min(i - 1, d); j++)
for (int k = 1; k <= m; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t <= j && i - t * k > 0; t++)
Inc(f[i][j][k], mul(f[i - t * k][j - t][k - 1],
C(f[k][d - 1][k - 1] + t - 1, t)));
}
if (n & 1)
printf("%d\n", f[n][d][m]);
else
printf("%d\n", del(f[n][d][m], C(f[m][d - 1][m - 1], 2)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int 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 << 3) + (x << 1) + (c ^ '0'), c = getchar();
return x * f;
}
const int N = 1e3 + 5, M = 15;
int mod;
inline int inc(int x, int y) {
x += y - mod;
return x + (x >> 31 & mod);
}
inline int del(int x, int y) {
x -= y;
return x + (x >> 31 & mod);
}
inline int mul(int x, int y) { return 1ll * x * y % mod; }
inline void Inc(int &x, int y) { x = inc(x, y); }
inline void Del(int &x, int y) { x = del(x, y); }
inline void Mul(int &x, int y) { x = mul(x, y); }
inline long long Pow(long long x, int k) {
long long res = 1;
while (k) {
if (k & 1) res = res * x % mod;
k >>= 1;
x = x * x % mod;
}
return res;
}
bool st;
int fac[M], inv[M];
inline void init(int n) {
fac[0] = inv[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[n] = Pow(fac[n], mod - 2);
for (int i = n - 1; i >= 1; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
}
int n, d, f[N][M][N];
inline int C(int n, int m) {
if (n < m) return 0;
long long res = 1;
for (int i = n; i >= n - m + 1; i--) res = res * i % mod;
return res * inv[m] % mod;
}
bool ed;
int main() {
n = read(), d = read(), mod = read();
if (n <= 2) return puts("1"), 0;
init(10);
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= min(i - 1, d); j++)
for (int k = 1; k <= n; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t <= j && i - t * k > 0; t++)
if (k ^ 1)
Inc(f[i][j][k], mul(f[i - t * k][j - t][k - 1],
C(f[k][d - 1][k - 1] + t - 1, t)));
else
Inc(f[i][j][k],
mul(f[i - t * k][j - t][k - 1], C(f[k][0][k - 1] + t - 1, t)));
}
int ans = 0;
if (n & 1)
ans = f[n][d][n / 2];
else
ans = del(f[n][d][n / 2], C(f[n / 2][d - 1][n / 2 - 1], 2));
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 1010;
long long dp[N][20], pd[N][20], f[N], t[20];
int n, d;
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) {
puts("1");
return 0;
}
if ((n - 2) % (d - 1) != 0) {
puts("0");
return 0;
}
dp[0][0] = 1;
for (int i = 1; i < n / 2 + 1; i++)
if ((i - 1) % (d - 1) == 0) {
if (i == 1)
f[i] = 1;
else
f[i] = dp[i - 1][d - 1];
t[0] = 1;
for (int j = 1; j < d + 1; j++) {
t[j] = t[j - 1] * (f[i] + j - 1) % mod * powmod(j, mod - 2) % mod;
}
for (int p = 0; p < n + 1; p++)
for (int q = 0; q < d + 1; q++) pd[p][q] = 0;
for (int r = 0; r < d + 1; r++)
for (int q = 0; q < d + 1; q++)
if (r + q <= d)
for (int p = 0; p < n + 1; p++)
if (p + q * i <= n) {
pd[p + q * i][r + q] =
(pd[p + q * i][r + q] + dp[p][r] * t[q]) % mod;
}
for (int p = 0; p < n + 1; p++)
for (int q = 0; q < d + 1; q++)
if (pd[p][q]) {
dp[p][q] = pd[p][q];
}
}
int ret = dp[n - 1][d];
if (n % 2 == 0) {
ret = (ret - dp[n / 2 - 1][d - 1] * (dp[n / 2 - 1][d - 1] - 1) / 2) % mod;
if (ret < 0) ret += mod;
}
printf("%d\n", ret);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005, maxd = 15;
int f[maxn][maxd], g[maxn][maxd], t[maxn];
int n, d, p, q;
int fpm(int a, int b, int p) {
int res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % p;
a = 1ll * a * a % p;
b >>= 1;
}
return res;
}
int main() {
scanf("%d%d%d", &n, &d, &p);
if (n <= 2) {
puts("1");
return 0;
}
if ((n - 2) % (d - 1)) {
puts("0");
return 0;
}
f[0][0] = 1;
for (int i = 1; i <= (n / 2); i++)
if ((i - 1) % (d - 1) == 0) {
q = (i == 1) ? 1 : f[i - 1][d - 1];
t[0] = 1;
for (int j = 1; j <= d; j++)
t[j] = 1ll * t[j - 1] * (q + j - 1) % p * fpm(j, p - 2, p) % p;
for (int j = 0; j <= n; j++)
for (int k = 0; k <= d; k++) g[j][k] = 0;
for (int j = 0; j <= d; j++)
for (int k = 0; j + k <= d; k++)
for (int l = 0; l + k * i <= n; l++)
g[l + k * i][j + k] =
(1ll * f[l][j] * t[k] + g[l + k * i][j + k]) % p;
for (int j = 0; j <= n; j++)
for (int k = 0; k <= d; k++) f[j][k] = g[j][k];
}
int res = f[n - 1][d];
if (n % 2 == 0) {
q = f[n / 2 - 1][d - 1];
q = 1ll * q * (q - 1) % p * fpm(2, p - 2, p) % p;
res = ((res - q) % p + p) % p;
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mxn = 1006;
const int mxd = 11;
int n, d;
ll MOD;
ll f[mxn][mxd];
int inv[mxd];
int ifac[mxd];
int comb(int a, int b) {
ll re = ifac[b];
for (int i = 0; i < b; ++i) (re *= a - i) %= MOD;
return re;
}
int main() {
cin >> n >> d >> MOD;
if (n == 1 || n == 2) {
cout << 1 % MOD << endl;
return 0;
}
ifac[0] = inv[1] = ifac[1] = 1;
for (int i = 2; i < mxd; ++i) {
inv[i] = (ll)MOD / i * (MOD - inv[MOD % i]) % MOD;
ifac[i] = (ll)ifac[i - 1] * inv[i] % MOD;
}
f[1][0] = 1;
for (int i = 1; i * 2 < n; ++i)
if ((i - 1) % (d - 1) == 0) {
int w = (i == 1 ? 1 : f[i][d - 1]);
for (int j = n; j >= i + 1; --j)
for (int k = d; k >= 1; --k)
for (int u = k - 1; u >= 0 && j - i * (k - u) >= 1; --u)
(f[j][k] += f[j - i * (k - u)][u] * comb(w + k - u - 1, k - u)) %=
MOD;
}
ll ans = f[n][d];
if (n % 2 == 0) ans += comb(f[n / 2][d - 1] + 1, 2);
cout << (ans % MOD + MOD) % MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, d, P, dp[N][11][N], ans;
inline void upd(int &x, int y) { ((x += y) >= P) && (x -= P); }
int ksm(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % P)
if (b & 1) ans = 1ll * ans * a % P;
return ans;
}
inline int C(int n, int k) {
if (n < k || k < 0) return 0;
int ans = 1, inv = 1;
for (int i = (1); i <= (k); ++i)
ans = 1ll * ans * (n - i + 1) % P, inv = 1ll * inv * i % P;
return 1ll * ans * ksm(inv, P - 2) % P;
}
int main() {
scanf("%d%d%d", &n, &d, &P);
if (n == 1) return puts("1"), 0;
dp[1][0][0] = dp[1][d - 1][0] = 1;
for (int i = (2); i <= (n); ++i)
for (int j = (1); j <= (d); ++j)
for (int k = (1); k <= (i - 1); ++k) {
if (k) upd(dp[i][j][k], dp[i][j][k - 1]);
for (int l = (1); l <= (j); ++l) {
if (l * k + 1 > i) break;
upd(dp[i][j][k], 1ll *
dp[i - l * k][j - l][min(k - 1, i - l * k - 1)] *
C(dp[k][d - 1][k - 1] + l - 1, l) % P);
}
}
ans = dp[n][d][(n - 1) / 2];
if (!(n & 1)) upd(ans, C(dp[n / 2][d - 1][n / 2 - 1] + 1, 2));
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1007, D = 11, C = 20;
int M, dd, mod;
int dp[N][N][D];
int rev[C];
long long power(int a, int b) {
if (b == 0) return 1;
long long res = power(a, b / 2);
res *= res, res %= mod;
if (b & 1) res *= a, res %= mod;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> M >> dd >> mod;
if (M <= 2) return cout << 1 << endl, 0;
if (dd == 2) return cout << 1 << endl, 0;
if ((M - 2) % (dd - 1) != 0) return cout << 0 << endl, 0;
int n = (M - 2) / (dd - 1);
for (int i = 0; i < C; i++) rev[i] = power(i, mod - 2);
for (int i = 0; i <= dd; i++) {
dp[1][0][i] = 1;
for (int j = 1; j < N; j++) dp[1][j][i] = 1;
}
for (int a = 2; a <= n; a++)
for (int x = 1; x < N; x++)
for (int d = 1; d < D; d++) {
dp[a][x][d] = dp[a][x - 1][d];
long long comb = dp[x][x - 1][dd - 1], t = dp[x][x - 1][dd - 1];
for (int c = 1; c * x < a && d >= c; c++) {
long long way = dp[a - c * x][x - 1][d - c];
way *= comb;
way %= mod;
dp[a][x][d] += way, dp[a][x][d] %= mod;
comb *= (c + t) % mod, comb %= mod, comb *= rev[c + 1], comb %= mod;
}
}
long long t1 = dp[n][(n - 1) / 2][dd];
if (n & 1) return cout << t1 << endl, 0;
long long t2 = (1LL * dp[n / 2][n / 2 - 1][dd - 1] *
(dp[n / 2][n / 2 - 1][dd - 1] + 1) % mod) *
rev[2] % mod;
t1 += t2, t1 %= mod;
cout << t1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1000;
const int gmax = 10;
int mod;
int t[nmax + 1];
int inv[gmax + 1];
int d[nmax + 1][gmax + 1][nmax + 1];
inline int C(int x, int y) {
int ans = 1;
for (int i = x - y + 1; i <= x; ++i) ans = 1LL * ans * i % mod;
return 1LL * ans * inv[y] % mod;
}
int lgput(int b, int p) {
int ans = 1;
while (p > 0) {
if (p & 1) ans = 1LL * ans * b % mod;
b = 1LL * b * b % mod;
p >>= 1;
}
return ans;
}
int main() {
int n, g;
fscanf(stdin, "%d%d%d", &n, &g, &mod);
if (n == 1 || n == 2) {
fprintf(stdout, "1\n");
return 0;
}
int fct = 1;
inv[0] = 1;
for (int i = 1; i <= n; ++i) {
fct = 1LL * fct * i % mod;
inv[i] = lgput(fct, mod - 2);
}
t[1] = 1;
for (int i = 0; i <= n; ++i) d[0][0][i] = d[1][g - 1][i] = 1;
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= g; ++j) {
for (int mx = 1; mx <= n; ++mx) {
d[i][j][mx] = (d[i][j][mx] + d[i][j][mx - 1]) % mod;
if (j * mx + 1 == i) {
d[i][j][mx] = (d[i][j][mx] + C(t[mx] + j - 1, j)) % mod;
}
for (int x = 1; x < j && x * mx <= i; ++x) {
d[i][j][mx] = (d[i][j][mx] + 1LL * d[i - x * mx][j - x][mx - 1] *
C(t[mx] + x - 1, x)) %
mod;
}
}
}
t[i] = d[i][g - 1][n];
}
int ans = 0;
if (n % 2 == 0) {
ans += 1LL * (t[n / 2] + 1) * t[n / 2] % mod * inv[2] % mod;
}
ans = (ans + d[n][g][(n - 1) / 2]) % mod;
fprintf(stdout, "%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1005;
long long n, d, mod;
long long f[N][11][N / 2];
long long inv[11];
long long ksm(long long a, long long x) {
long long ans = 1;
while (x) {
if (x % 2 == 1) ans = ans * a % mod;
a = a * a % mod;
x /= 2;
}
return ans % mod;
}
void pre() {
long long tmp = 1;
for (long long i = 1; i <= d; i++) {
tmp = tmp * i;
inv[i] = ksm(tmp, mod - 2);
}
}
long long C(long long m, long long n) {
long long ans = 1;
for (long long i = m; i >= m - n + 1; i--) ans = (ans * i) % mod;
ans = (ans * inv[n]) % mod;
return ans;
}
int main() {
cin >> n >> d >> mod;
if (n <= 2) {
cout << 1;
return 0;
}
pre();
for (long long i = 0; i <= n / 2; i++) f[1][0][i] = 1;
for (long long i = 2; i <= n; i++) {
for (long long j = 1; j <= min(i - 1, d); j++) {
for (long long k = 1; k <= n / 2; k++) {
f[i][j][k] = f[i][j][k - 1];
for (long long t = 1; t <= min((i - 1) / k, j); t++) {
long long tmp = (k == 1) ? 0 : d - 1;
f[i][j][k] = (f[i][j][k] + f[i - t * k][j - t][k - 1] *
C(f[k][tmp][k - 1] + t - 1, t) % mod) %
mod;
}
}
}
}
long long ans = f[n][d][n / 2];
if (n % 2 == 0) ans = (ans + mod - C(f[n / 2][d - 1][n / 2], 2)) % mod;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int p, f[1005][11][505], iv[15], inv[15];
int c(int n, int m) {
int res = 1;
for (int i = n; i > n - m; i--) res = 1ll * res * i % p;
return 1ll * res * inv[m] % p;
}
int main() {
int n, d;
scanf("%d%d%d", &n, &d, &p);
if (n == 1) {
puts("1");
return 0;
}
inv[0] = inv[1] = iv[1] = 1;
for (int i = 2; i <= d; i++)
iv[i] = p - 1ll * (p / i) * iv[p % i] % p,
inv[i] = 1ll * inv[i - 1] * iv[i] % p;
for (int i = 0; i <= n / 2; i++) f[1][0][i] = f[1][d - 1][i] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= d; j++)
for (int k = 1; k <= n / 2; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t <= j; t++)
if (i > t * k)
f[i][j][k] = (f[i][j][k] + 1ll * f[i - t * k][j - t][k - 1] *
c(f[k][d - 1][k - 1] + t - 1, t)) %
p;
}
int res = f[n][d][n / 2];
if (!(n & 1)) res = (res - c(f[n / 2][d - 1][n / 2 - 1], 2) + p) % p;
printf("%d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1009;
int f[N][12][N / 2], n, d, mod;
int inv[N], fac[N];
inline void Plus(int &x, int y) { x = (x + y >= mod ? x + y - mod : x + y); }
inline int mins(int &x, int y) { return (x - y < 0 ? x - y + mod : x - y); }
void Init() {
inv[0] = inv[1] = fac[1] = 1;
for (int i = 2; i < N; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
for (int i = 2; i < N; i++)
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
for (int i = 2; i < N; i++) inv[i] = 1ll * inv[i - 1] * inv[i] % mod;
}
inline int C(int n, int m) {
if (m > n) return 0;
int res = 1;
for (int i = n - m + 1; i <= n; i++) res = 1ll * res * i % mod;
return 1ll * res * inv[m] % mod;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) return puts("1"), 0;
Init();
for (int i = 0; i <= n / 2; i++) f[1][0][i] = 1;
f[1][d - 1][0] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= min(d, i - 1); j++)
for (int k = 1; k <= n / 2; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t * k <= i && t <= j; t++)
Plus(f[i][j][k], 1ll * f[i - t * k][j - t][k - 1] *
C(f[k][d - 1][k - 1] + t - 1, t) % mod);
}
if (n & 1)
printf("%d", f[n][d][n / 2]);
else
printf("%d", mins(f[n][d][n / 2], C(f[n / 2][d - 1][n / 2 - 1], 2)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1005;
const int MaxD = 11;
int n, d, mod;
int inv[MaxN];
int f[MaxN][MaxD][MaxN];
int main() {
cin >> n >> d >> mod;
if (n <= 2) {
puts("1");
return 0;
}
inv[1] = 1;
for (int i = 2; i <= n; ++i)
inv[i] = (long long)(mod - mod / i) * inv[mod % i] % mod;
f[1][0 + 0][0] = 1;
f[1][d - 1][0] = 1;
for (int i = 2; i <= n; ++i)
for (int j = 1; j <= d; ++j)
for (int k = 1; k < i; ++k) {
f[i][j][k] = f[i][j][k - 1];
int coe = 1;
int now = f[k][d - 1][k - 1] - 1;
for (int t = 1; t * k < i && t <= j; ++t) {
coe = (long long)coe * ++now % mod * inv[t] % mod;
f[i][j][k] += (long long)coe *
f[i - t * k][j - t][min(k - 1, i - t * k - 1)] % mod;
if (f[i][j][k] >= mod) f[i][j][k] -= mod;
}
}
int res = f[n][d][(n + 1) / 2 - 1];
if (~n & 1) {
int l = f[n / 2][d - 1][n / 2 - 1];
res = (res + (long long)l * (l + 1) / 2) % mod;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10, D = 15;
int n, d, mod;
int dp[D][N][N];
int ifac[N];
void Add(int &x, int y) {
if ((x += y) >= mod && (x -= mod))
;
}
int binom(int n, int m) {
n %= mod;
if (n < m) return 0;
int pro = 1;
for (int i = n; i >= n - m + 1; i--) pro = 1ll * pro * i % mod;
pro = 1ll * pro * ifac[m] % mod;
return pro;
}
int DP(int g, int n, int k) {
if (dp[g][n][k] != -1) return dp[g][n][k];
int &res = dp[g][n][k];
if (n == 1) return res = (g % (d - 1) == 0);
if (g == 0) return res = (n == 1);
if (k == 0) return 0;
res = 0;
Add(res, DP(g, n, k - 1));
if ((k - 1) % (d - 1)) return res;
int f = DP(d - 1, k, k - 1);
for (int i = 1; i <= g; i++) {
if (i * k >= n) break;
Add(res, 1ll * DP(g - i, n - k * i, k - 1) * binom(f + i - 1, i) % mod);
}
return res;
}
void quit(int x) { printf("%d\n", x), exit(0); }
void initmath(int n) {
ifac[0] = ifac[1] = 1;
for (int i = 2; i <= n; i++)
ifac[i] = 1ll * (mod - mod / i) * ifac[mod % i] % mod;
for (int i = 1; i <= n; i++) ifac[i] = 1ll * ifac[i - 1] * ifac[i] % mod;
return;
}
int calc(int g, int n, int k) {
if (n == 1 || n == 2) return 1;
if (n < g + 1) return 0;
if ((n - g - 1) % (d - 1) != 0) return 0;
return DP(g, n, k);
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d%d%d", &n, &d, &mod);
if (n == 1 || n == 2) quit(1);
if (n < d + 1) quit(0);
if ((n - d - 1) % (d - 1) != 0) quit(0);
initmath(d);
if (n & 1) quit(DP(d, n, n / 2));
int ans = DP(d, n, n / 2);
ans = (ans - binom(DP(d - 1, n / 2, n / 2), 2) + mod) % mod;
quit(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 10;
const int MAXD = 15;
int n, d, MOD;
int phi;
void add(int& x, int y) { ((x += y) >= MOD) && (x -= MOD); }
int mul(int x, int y) { return x * 1ll * y % MOD; }
bool read() {
if (scanf("%d%d%d", &n, &d, &MOD) < 3) {
return false;
}
return true;
}
int dp[MAXD][MAXN][MAXN];
int mpow(int a, int p) {
int res = 1;
for (; p > 0; a = mul(a, a), p >>= 1) {
if (p & 1) {
res = mul(res, a);
}
}
return res;
}
int inv[MAXD];
void precalc() {
for (int i = 1; i < MAXD; ++i) {
inv[i] = mpow(i, MOD - 2);
assert(mul(i, inv[i]) == 1);
}
}
int solve() {
if (n <= 2) {
return 1;
}
int ans = 0;
memset(dp, 0, sizeof dp);
for (int last = 0; last < (int)n + 1; ++last) {
dp[0][0][last] = 1;
}
for (int sum = 0; sum <= n; ++sum) {
for (int sons = 1; sons <= d; ++sons) {
for (int cur = 1; cur <= n; ++cur) {
add(dp[sons][sum][cur], dp[sons][sum][cur - 1]);
if (cur * 2 > n) {
continue;
}
int A = cur == 1 ? 1 : dp[d - 1][cur - 1][n];
int B = 1;
int C = A / B;
for (int cnt_cur = 1; sum - cnt_cur * cur >= 0 && sons - cnt_cur >= 0;
++cnt_cur) {
int aux = mul(dp[sons - cnt_cur][sum - cnt_cur * cur][cur - 1], C);
add(dp[sons][sum][cur], aux);
if (sons == d && sum == n - 1) {
if ((n - cur) * 2 > n) {
add(ans, aux);
}
}
add(A, 1);
add(B, 1);
C = mul(C, A);
C = mul(C, inv[B]);
}
}
}
}
for (int left_________________ = d - 1; left_________________ <= n - 2;
++left_________________) {
int right_______________ = n - 2 - left_________________;
if (right_______________ < d - 1 ||
left_________________ > right_______________) {
continue;
}
if ((left_________________ + 1) * 2 > n ||
(right_______________ + 1) * 2 > n) {
continue;
}
int cur_ans = mul(dp[d - 1][left_________________][n],
dp[d - 1][right_______________][n]);
if (left_________________ == right_______________) {
cur_ans = mul(dp[d - 1][left_________________][n],
dp[d - 1][left_________________][n] + 1);
cur_ans = mul(cur_ans, inv[2]);
}
add(ans, cur_ans);
}
return ans;
}
int main() {
while (read()) {
precalc();
printf("%d\n", solve());
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
using namespace std;
namespace ywy {
int p;
unsigned char bv[1001][1001][11];
long long f[1001][1001][11];
int d;
inline long long mi(int a, int b) {
long long ans = 1, tmp = a;
while (b) {
if (b & 1) ans = (ans * tmp) % p;
tmp = (tmp * tmp) % p;
b >>= 1;
}
return (ans);
}
long long ny[1001];
long long dp(int sz, int mx, int dk) {
if (bv[sz][mx][dk]) return (f[sz][mx][dk]);
bv[sz][mx][dk] = 1;
if (sz == 1) {
return (f[sz][mx][dk] = (dk == 0));
}
if (!dk || !mx || dk >= sz) return (f[sz][mx][dk] = 0);
if (mx == 1) {
return (f[sz][mx][dk] = (sz == dk + 1));
}
long long ans = dp(sz, mx - 1, dk);
long long h = dp(mx, mx, d - 1);
if (!h) return (f[sz][mx][dk] = ans);
long long ji = 1;
for (register int i = 1; i <= dk && i * mx < sz; i++) {
ji *= ny[i];
ji %= p;
ji *= (h + i - 1);
ji %= p;
ans = (ans + dp(sz - i * mx, mx - 1, dk - i) * ji) % p;
}
return (f[sz][mx][dk] = ans);
}
void ywymain() {
int n;
cin >> n >> d >> p;
for (register int i = 1; i <= d; i++) ny[i] = mi(i, p - 2);
if (n <= 2) {
cout << 1 << endl;
return;
}
if (n & 1) {
cout << dp(n, n / 2, d) << endl;
return;
}
long long cjr = dp(n / 2, n / 2 - 1, d - 1);
cjr = ((cjr + 1) * cjr) / 2;
cjr %= p;
cjr %= p;
cjr += dp(n, n / 2 - 1, d);
cjr %= p;
cout << cjr << endl;
}
} // namespace ywy
signed main() {
ywy::ywymain();
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool cmax(T &x, T y) {
return y > x ? x = y, 1 : 0;
}
template <class T>
bool cmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
const int N = 1005, M = 15;
int n, m, mod, f[N][M][N], ifac[M], fac[M];
int kpow(int a, int k) {
int res = 1;
for (; k; k >>= 1, a = 1ll * a * a % mod)
if (k & 1) res = 1ll * res * a % mod;
return res;
}
int C(int n, int m) {
int res = 1;
for (int i = 0; i < m; ++i) res = 1ll * res * (n - i) % mod;
return 1ll * res * ifac[m] % mod;
}
int F(int n, int d, int mx) {
if (!d || !mx || n == 1) return n == 1 && !d;
if (~f[n][d][mx]) return f[n][d][mx];
f[n][d][mx] = F(n, d, mx - 1);
for (int i = 1; i <= min(n - 1, d) && i * mx < n; ++i)
(f[n][d][mx] += 1ll * F(n - i * mx, d - i, mx - 1) *
C((mx == 1 ? 1 : F(mx, m - 1, mx)) + i - 1, i) % mod) %=
mod;
return f[n][d][mx];
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> mod;
if (n <= 2) {
cout << 1 << endl;
return 0;
}
fac[0] = 1;
for (int i = 1; i <= m; ++i) fac[i] = 1ll * i * fac[i - 1] % mod;
ifac[m] = kpow(fac[m], mod - 2);
for (int i = m - 1; i >= 0; --i) ifac[i] = 1ll * ifac[i + 1] * (i + 1) % mod;
memset(f, -1, sizeof f);
if (n & 1)
cout << F(n, m, n / 2) << endl;
else {
cout << (F(n, m, n / 2) + mod - C(F(n / 2, m - 1, n / 2 - 1), 2)) % mod
<< endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1009;
int f[N][12][N / 2], n, d, mod;
int inv[N], fac[N];
inline void Plus(int &x, int y) { x = (x + y >= mod ? x + y - mod : x + y); }
inline int mins(int &x, int y) { return (x - y < 0 ? x - y + mod : x - y); }
void Init() {
inv[1] = 1;
for (int i = 2; i < N; i++)
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
for (int i = 2; i < N; i++) inv[i] = 1ll * inv[i - 1] * inv[i] % mod;
}
inline int C(int n, int m) {
if (m > n) return 0;
int res = 1;
for (int i = n - m + 1; i <= n; i++) res = 1ll * res * i % mod;
return 1ll * res * inv[m] % mod;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) return puts("1"), 0;
Init();
for (int i = 0; i <= n / 2; i++) f[1][0][i] = 1;
f[1][d - 1][0] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= min(d, i - 1); j++)
for (int k = 1; k <= n / 2; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t * k <= i && t <= j; t++)
Plus(f[i][j][k], 1ll * f[i - t * k][j - t][k - 1] *
C(f[k][d - 1][k - 1] + t - 1, t) % mod);
}
if (n & 1)
printf("%d", f[n][d][n / 2]);
else
printf("%d", mins(f[n][d][n / 2], C(f[n / 2][d - 1][n / 2 - 1], 2)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
const int maxD = 12;
int mod;
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)); }
int f[maxn][maxD][maxn];
int inv[maxD];
int C(int x, int l) {
int ret = 1;
for (int i = 1; i <= l; i++) ret = mu(ret, mu(inv[i], x)), x = re(x, 1);
return ret;
}
int main() {
int n, D;
scanf("%d%d%d", &n, &D, &mod);
if (n <= 2) {
puts("1");
return 0;
}
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
for (int i = 1; i <= D; i++) inv[i] = iv(i), f[i + 1][i][1] = 1;
for (int k = 2; k < n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= D; j++) {
f[i][j][k] = ad(f[i][j][k], f[i][j][k - 1]);
for (int l = 1; l <= j && i > l * k; l++)
f[i][j][k] = ad(f[i][j][k], mu(f[i - l * k][j - l][k - 1],
C(f[k][D - 1][k - 1] + l - 1, l)));
}
printf("%d\n",
re(f[n][D][n / 2], ((n & 1) ? 0 : C(f[n / 2][D - 1][n / 2], 2))));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1E3 + 10, MAXD = 10 + 2;
int MOD;
long long inv[20];
long long dp[2][MAXN][MAXD];
long long Com(long long n, long long m) {
n %= MOD;
if (m < 0 || n < m) return 0;
long long ret = n;
for (int i = 1; i < m; ++i) ret = ret * (n - i) % MOD * inv[i + 1] % MOD;
return ret;
}
int main() {
int n, d;
scanf("%d%d%d", &n, &d, &MOD);
if (n <= 2) {
puts("1");
return 0;
}
inv[0] = 0, inv[1] = 1;
for (int i = 2; i <= d; ++i) inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
int n0 = n - 1 >> 1;
for (int i = 0; i <= d; ++i) dp[1][i + 1][i] = 1;
for (int k = 2; k <= n0; ++k) {
long long(&f)[MAXN][MAXD] = dp[k - 1 & 1], (&g)[MAXN][MAXD] = dp[k & 1];
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= d; ++j) {
g[i][j] = f[i][j];
for (int t = 1; t <= j && k * t < i; ++t)
g[i][j] = (g[i][j] +
f[i - k * t][j - t] * Com(f[k][d - 1] + t - 1, t) % MOD) %
MOD;
}
}
long long ans = dp[n0 & 1][n][d];
if (n + 1 & 1) ans = (ans + Com(dp[n0 & 1][n >> 1][d - 1] + 1, 2)) % MOD;
printf("%d\n", (int)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct sam {
int son[1057 << 1][26], pre[1057 << 1], dis[1057 << 1];
int Right[1057 << 1];
int p, np, q, nq, lst, cnt;
int lth;
char read_s[1057];
void insert(int x) {
dis[np = ++cnt] = dis[p = lst] + 1;
Right[np] = 1, lst = np;
for (; p && !son[p][x]; p = pre[p]) son[p][x] = np;
if (!p) return pre[np] = 1, void();
q = son[p][x];
if (dis[q] == dis[p] + 1)
return pre[np] = q, void();
else {
dis[nq = ++cnt] = dis[p] + 1;
memcpy(son[nq], son[q], sizeof son[q]);
pre[nq] = pre[q];
pre[q] = pre[np] = nq;
for (; p && son[p][x] == q; p = pre[p]) son[p][x] = nq;
}
}
void build() {
lst = cnt = 1;
scanf("%s", read_s);
lth = strlen(read_s);
for (int i = 0; i < lth; ++i) insert(read_s[i] - 'a');
}
void build_() {
lst = cnt = 1;
scanf("%s", read_s);
lth = strlen(read_s);
for (int i = lth - 1; ~i; --i) insert(read_s[i] - 'a');
}
int s[1057 << 1], v[1057 << 1];
void sort() {
for (int i = 1; i <= cnt; ++i) ++v[dis[i]];
for (int i = 1; i <= lth; ++i) v[i] += v[i - 1];
for (int i = 1; i <= cnt; ++i) s[v[dis[i]]--] = i;
}
long long ans;
void DP() {
for (int i = cnt; i; --i) {
int now = s[i], fth = pre[now];
Right[fth] += Right[now];
ans += 1ll * (dis[now] - dis[fth]) * Right[now] * (lth - Right[now]);
}
}
} SAM;
int n, d, MOD;
const int MAXD = 15;
int dp[1057][1057][MAXD];
int Inv[1057];
inline void update(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
int qpow(int a, int b) {
int tmp = a, ret = 1;
for (; b; b >>= 1, tmp = 1LL * tmp * tmp % MOD) {
if (b & 1) ret = 1LL * ret * tmp % MOD;
}
return ret;
}
void Init() {
for (int i = 1; i <= 1000; i++) {
Inv[i] = qpow(i, MOD - 2);
}
}
int f[1057];
void Dodp() {
f[1] = 1;
dp[0][0][0] = 1;
for (int j = 0; j <= d; j++) {
dp[1][j][j] = 1;
}
for (int i = 2; i + i <= n; i++) {
f[i] = dp[i - 1][i - 1][d - 1];
for (int k = 0; k <= d; k++) {
for (int j = 0; j <= n; j++) {
if (dp[i - 1][j][k]) {
int tmp = dp[i - 1][j][k];
for (int use = 0; j + use * i <= n && use + k <= d && tmp; use++) {
update(dp[i][j + use * i][use + k], tmp);
tmp = 1LL * tmp * (f[i] + use) % MOD * Inv[use + 1] % MOD;
}
}
}
}
}
}
void Solve() {
if (n <= 2) {
puts("1");
return;
}
if (n & 1) {
printf("%d\n", dp[n >> 1][n - 1][d]);
} else {
int ans = dp[(n >> 1) - 1][n - 1][d], tmp = f[n >> 1];
tmp = 1LL * (tmp + 1) * tmp % MOD * Inv[2] % MOD;
ans = (ans + tmp) % MOD;
printf("%d\n", ans);
}
}
int main() {
scanf("%d%d%d", &n, &d, &MOD);
Init();
Dodp();
Solve();
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int data = 0, w = 1;
char ch = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9')
data = (data << 1) + (data << 3) + (ch ^ 48), ch = getchar();
return data * w;
}
int n, d, mod, f[1005][11][1005], g[1000005], inv[1000005];
int main() {
n = read(), d = read(), mod = read();
if (n == 1 || n == 2) {
puts("1");
return 0;
}
f[1][0][0] = g[1] = 1;
inv[0] = inv[1] = 1;
for (int i = 2; i <= n; i++)
inv[i] = 1ll * inv[mod % i] * (mod - mod / i) % mod;
for (int i = 2; i <= n; i++) inv[i] = 1ll * inv[i - 1] * inv[i] % mod;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= d; j++)
for (int k = 1; k <= i; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1, x = g[k]; t <= j && t * k + 1 <= i;
++t, x = 1ll * x * (g[k] + t - 1) % mod) {
f[i][j][k] = (f[i][j][k] +
1ll * f[i - t * k][j - t][min(k - 1, i - t * k - 1)] *
x % mod * inv[t] % mod) %
mod;
}
}
g[i] = f[i][d - 1][i - 1];
}
int ans = f[n][d][n / 2];
if (n % 2 == 0)
ans = (ans - 1ll * g[n / 2] * (g[n / 2] - 1) / 2 % mod + mod) % mod;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void Read(int &x) {
char c;
while (c = getchar(), c != EOF)
if (c >= '0' && c <= '9') {
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
ungetc(c, stdin);
return;
}
}
int n, d, MOD, f[1000 + 10][11], g[1000 + 10], inv[1000 + 10], ans;
int main() {
Read(n), Read(d), Read(MOD);
if (n <= 2) {
puts("1");
return 0;
}
if ((n - 2) % (d - 1)) {
puts("0");
return 0;
}
int i, j, p, q, w;
inv[0] = inv[1] = 1;
for (i = 2; i <= n; i++) inv[i] = 1ll * (MOD - MOD / i) * inv[MOD % i] % MOD;
for (i = 2; i <= n; i++) inv[i] = 1ll * inv[i] * inv[i - 1] % MOD;
g[1] = f[1][0] = 1;
for (i = 1; i <= (n >> 1); i++) {
for (j = n - i + 1; j >= 1; j--)
for (p = 0; p < d; p++)
if (f[j][p]) {
w = 1;
for (q = 1; p + q <= d && j + q * i <= n; q++) {
w = 1ll * w * (g[i] + q - 1) % MOD;
f[j + q * i][p + q] =
(f[j + q * i][p + q] + 1ll * w * inv[q] % MOD * f[j][p]) % MOD;
}
}
g[i + 1] = f[i + 1][d - 1];
}
ans = f[n][d];
if (!(n & 1))
ans = (ans + MOD - (1ll * g[n >> 1] * (g[n >> 1] - 1) / 2) % MOD) % MOD;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline void rd(int &x) {
char ch;
x = 0;
bool fl = false;
while (!isdigit(ch = getchar())) (ch == '-') && (fl = true);
for (x = (ch ^ '0'); isdigit(ch = getchar()); x = x * 10 + (ch ^ '0'))
;
(fl == true) && (x = -x);
}
namespace Miracle {
const int N = 1005;
int mod, n, d;
int f[N][11][N];
int jie[11], inv[11];
int qm(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (long long)ret * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return ret;
}
int dp(int i, int j, int k) {
if (f[i][j][k] != -1) return f[i][j][k];
if (i == 1) {
if (j == d - 1 || !j) return f[i][j][k] = 1;
return f[i][j][k] = 0;
}
if (i == 0) {
if (k == 0 && j == 0)
return f[i][j][k] = 1;
else
return f[i][j][k] = 0;
}
if (j > i - 1) return f[i][j][k] = 0;
if (i > 1 && k == 0) return f[i][j][k] = 0;
int C = 1;
int ret = 0;
int tmp = dp(k, d - 1, k - 1);
for (register int m = 0; m <= j && m * k <= i - 1; ++m) {
ret = (ret +
(long long)dp(i - m * k, j - m, k - 1) * C % mod * inv[m] % mod) %
mod;
C = (long long)C * (tmp - 1 + m + 1) % mod;
}
return f[i][j][k] = ret;
}
int main() {
rd(n);
rd(d);
rd(mod);
if (n <= 2) {
puts("1");
return 0;
}
memset(f, -1, sizeof f);
jie[0] = 1;
for (register int i = 1; i <= 10; ++i)
jie[i] = (long long)jie[i - 1] * i % mod;
inv[10] = qm(jie[10], mod - 2);
for (register int i = 9; i >= 0; --i)
inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
long long ans = 0;
ans = (ans + dp(n, d, (n - 1) / 2));
if (n % 2 == 0) {
long long tmp = 0;
tmp = dp(n / 2, d - 1, n / 2 - 1);
ans = (ans + (tmp * (tmp + 1) / 2 % mod)) % mod;
}
printf("%I64d", ans);
return 0;
}
} // namespace Miracle
signed main() {
Miracle::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int IN() {
int x = 0, f = 0, ch;
for (; (ch = getchar()) < '0' || ch > '9';) f = (ch == '-');
for (; ch >= '0' && ch <= '9'; (ch = getchar())) x = x * 10 + ch - '0';
return f ? -x : x;
}
int N, M, P, A[1005], B[1005][15], C[15];
int Pow(int a, int b) {
int ret = 1;
for (; b; b >>= 1, a = 1ll * a * a % P)
if (b & 1) ret = 1ll * ret * a % P;
return ret;
}
int main(int argc, char* argv[]) {
N = IN();
M = IN();
P = IN();
if (N <= 2) return puts("1"), 0;
B[0][0] = 1;
for (int i = 1, lim = N / 2; i <= lim; i++) {
if (i == 1)
A[i] = 1;
else
A[i] = B[i - 1][M - 1];
C[0] = 1;
for (int j = 1, lim = M; j <= lim; j++)
C[j] = 1ll * C[j - 1] * (A[i] + j - 1) % P * Pow(j, P - 2) % P;
for (int j = N, lim = 0; j >= lim; j--)
for (int k = M, lim = 0; k >= lim; k--)
if (B[j][k])
for (int t = 1, lim = M - k; t <= lim; t++) {
int x = j + t * i;
if (x <= N) B[x][k + t] = (B[x][k + t] + 1ll * B[j][k] * C[t]) % P;
}
}
int Ans = B[N - 1][M];
if (N % 2 == 0) {
int t = B[N / 2 - 1][M - 1];
Ans = (Ans - 1ll * t * (t - 1) / 2) % P;
}
cout << (Ans + P) % P << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, mo, inv[20], dp[1005][11][1005];
void ntr(int &x) { x = x >= mo ? x - mo : (x < 0 ? x + mo : x); }
void inc(int &x, int y) { x += y, ntr(x); }
long long qry(int x, int y) {
if (y == 0) return 1;
if (x == 0) return 0;
x = x + y - 1;
long long r = 1;
for (int i = 1; i <= y; i++) r = r * (x - i + 1) % mo;
return r * inv[y] % mo;
}
int ask(int n, int deg, int sz) {
if (n == 1) return deg == 0 || deg == d - 1;
if (sz == 0) return 0;
int &ans = dp[n][deg][sz];
if (ans != -1)
return ans;
else
ans = 0;
int tmp = ask(sz, d - 1, sz - 1);
for (int p = 0, f = 1; p <= deg && sz * p <= n - 1; ++p) {
inc(ans, ask(n - p * sz, deg - p, sz - 1) * qry(tmp, p) % mo);
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &d, &mo);
if (n < 2) return puts("1"), 0;
inv[1] = 1;
for (int i = 2; i <= 15; i++) inv[i] = 1ll * (mo - mo / i) * inv[mo % i] % mo;
inv[0] = 1;
for (int i = 1; i <= 15; i++) inv[i] = 1ll * inv[i] * inv[i - 1] % mo;
memset(dp, -1, sizeof(dp));
int ans;
if (n & 1)
ans = ask(n, d, n / 2);
else {
ans = ask(n, d, n / 2 - 1);
int tmp = ask(n / 2, d - 1, n / 2 - 1);
inc(ans, qry(tmp, 2));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, mo, ans;
int f[1005][12], inv[12], tmp[12];
int power(int x, int y) {
int s = 1;
for (; y; y /= 2, x = 1ll * x * x % mo)
if (y & 1) s = 1ll * s * x % mo;
return s;
}
int main() {
scanf("%d%d%d", &n, &d, &mo);
inv[0] = 1;
for (int i = 1; i <= d; i++) inv[i] = power(i, mo - 2);
f[1][0] = f[1][d - 1] = 1;
for (int k = 1; k <= n / 2; k++)
if (f[k][d - 1]) {
int m = f[k][d - 1];
tmp[0] = 1;
for (int l = 1; l <= d; l++)
tmp[l] = 1ll * tmp[l - 1] * (l + m - 1) % mo * inv[l] % mo;
for (int i = n - k; i; i--)
for (int j = 0; j < d; j++)
if (f[i][j])
for (int l = 1; i + l * k <= n && j + l <= d; l++)
f[i + l * k][j + l] =
(f[i + l * k][j + l] + 1ll * f[i][j] * tmp[l]) % mo;
}
ans = (f[n][d] + f[n][0]) % mo;
if (!(n & 1)) {
int tmp = f[n / 2][d - 1];
ans = (ans + mo - 1ll * tmp * (tmp - 1) / 2 % mo) % mo;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int d;
int num_leaf(int sz) {
if (sz == 1) {
return 1;
}
if (sz == 2) {
return 1;
}
sz--;
int cnt = d;
sz -= d;
if (sz < 0) {
return -1;
}
while (sz) {
if (sz < d - 1) {
return -1;
}
sz -= (d - 1);
cnt += (d - 1);
cnt--;
}
return cnt;
}
int lf[1002];
long long int dp[1002];
bool us[1002];
long long int tmp[1002][1002][11];
long long int tmp2[1002][1002][11];
long long int MOD;
bool us2[1002];
long long int dp2[1002];
long long int ppow(long long int i, long long int j) {
long long int res = 1;
while (j) {
if (j & 1LL) {
res *= i;
if (res >= MOD) res %= MOD;
}
j >>= 1LL;
i *= i;
if (i >= MOD) i %= MOD;
}
return res;
}
long long int sel(long long int val, int ch) {
val += ch - 1;
long long int up = 1;
long long int dw = 1;
for (int j = 0; j < ch; j++) {
up *= (val - j);
if (up >= MOD) up %= MOD;
dw *= (j + 1);
if (dw >= MOD) dw %= MOD;
}
up *= ppow(dw, MOD - 2);
if (up >= MOD) up %= MOD;
return up;
}
long long int ww[1002][11];
inline long long int dfs2(int sz) {
if (sz == 1) {
return 1;
}
if (us2[sz]) return dp2[sz];
us2[sz] = true;
dp2[sz] = 0;
tmp2[sz][0][0] = 1;
int deg = d - 1;
for (int add = 1; add <= sz - 1; add++) {
if ((add - 1) % deg) {
continue;
}
long long int way = dfs2(add);
for (int z = 0; z <= deg; z++) {
ww[sz][z] = sel(way, z);
}
for (int j = sz - 1 - add; j >= 0; j--) {
for (int k = deg - 1; k >= 0; k--) {
long long int bs = tmp2[sz][j][k];
for (int z = k + 1; z <= deg; z++) {
if ((z - k) * add + j > sz - 1) break;
tmp2[sz][(z - k) * add + j][z] += bs * ww[sz][z - k];
if (tmp2[sz][(z - k) * add + j][z] > MOD) {
tmp2[sz][(z - k) * add + j][z] %= MOD;
}
}
}
}
}
dp2[sz] = tmp2[sz][sz - 1][deg];
return dp2[sz];
}
inline long long int dfs(int sz) {
if (sz <= 1) {
return 1;
}
if (us[sz]) return dp[sz];
us[sz] = true;
int maxi = (sz - 1) / 2;
tmp[sz][0][0] = 1;
for (int add = 1; add <= maxi; add++) {
if (add > 2 && ((add - 1) % (d - 1))) continue;
for (int j = sz - 1 - add; j >= 0; j--) {
for (int k = d - 1; k >= 0; k--) {
long long int bs = tmp[sz][j][k];
long long int way = dfs2(add);
for (int z = k + 1; z <= d; z++) {
if ((z - k) * add + j > sz - 1) break;
tmp[sz][(z - k) * add + j][z] += bs * sel(way, z - k);
if (tmp[sz][(z - k) * add + j][z] > MOD) {
tmp[sz][(z - k) * add + j][z] %= MOD;
}
}
}
}
}
dp[sz] = tmp[sz][sz - 1][d];
return dp[sz];
}
int main() {
int n;
cin >> n >> d >> MOD;
for (int i = 0; i < 1002; i++) {
lf[i] = num_leaf(i);
}
long long int ans = dfs(n);
if (n % 2 == 0) {
long long int ans2 = dfs2(n / 2);
ans += sel(ans2, 2);
if (ans >= MOD) ans %= MOD;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, mod, inv[15], f[1005], comp[1005][15], dp[1005][15][1005],
g[1005][15];
inline void ch(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
inline int sel(int k, int u) {
if (~comp[k][u]) return comp[k][u];
int &ans = comp[k][u];
ans = 1;
k = f[k];
for (int i = 1; i <= u; i++) ans = (long long)ans * inv[i] % mod;
for (int i = k + u - 1; i >= k; i--) ans = (long long)ans * i % mod;
return ans;
}
inline int exp(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = (long long)ans * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return ans;
}
void solve(int n) {
memset(comp, -1, sizeof(comp));
f[1] = 1;
dp[1][0][0] = 1;
for (int k = 1; k <= n; k += d) {
int typ = (k - 1) / d + 1;
dp[1][0][typ] = 1;
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= d + 1; j++)
for (int k = 1; k <= n; k += d) {
int typ = (k - 1) / d + 1;
for (int u = 0; u <= j && u * k < i; u++)
ch(dp[i][j][typ],
(long long)dp[i - u * k][j - u][typ - 1] * sel(k, u) % mod);
}
if ((i - 1) % d == 0) f[i] = dp[i][d][(n - 1) / d];
}
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n == 1) {
puts("1");
return 0;
}
for (int i = 1; i <= d; i++) inv[i] = exp(i, mod - 2);
d--;
solve(n / 2);
int ans = 0;
if (n % 2 == 0) ch(ans, sel(n / 2, 2));
g[1][0] = 1;
for (int i = 1; i <= (n - 1) / 2; i++) {
if ((i - 1) % d != 0) continue;
for (int j = n; j > 1; j--)
for (int k = d + 1; ~k; k--)
for (int u = 1; u <= k && u * i <= j; u++)
ch(g[j][k], (long long)g[j - u * i][k - u] * sel(i, u) % mod);
}
ch(ans, g[n][d + 1]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2,Ofast,inline,unroll-all-loops,-ffast-math")
#pragma GCC target("avx,sse2,sse3,sse4,popcnt")
using namespace std;
int n, d;
long long f[1010][15][1010], g[1010][15], ifac[15], mod;
template <class T>
void read(T &x) {
char ch = x = 0;
bool fl = false;
while (!isdigit(ch)) fl |= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x = fl ? -x : x;
}
long long pw(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;
}
long long C(long long a, int b) {
long long ret = ifac[b];
for (int i = 1; i <= b; i++) ret = ret * (a - i + 1) % mod;
return ret;
}
int main() {
read(n), read(d), read(mod);
if (n <= 2) return puts("1"), 0;
ifac[0] = 1;
for (int i = 1; i <= d; i++) ifac[i] = ifac[i - 1] * pw(i, mod - 2) % mod;
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
for (int i = 1; i <= d; i++) g[1][i] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= d; j++) {
for (int k = 1; k <= n; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int l = 1; l <= min(j, i / k); l++)
f[i][j][k] =
(f[i][j][k] + f[i - l * k][j - l][k - 1] * g[k][l]) % mod;
}
}
for (int j = 1; j <= d; j++) g[i][j] = C(f[i][d - 1][n] + j - 1, j);
}
long long ans = f[n][d][n / 2];
if (~n & 1)
ans =
(ans - f[n / 2][d - 1][n / 2] * (f[n / 2][d - 1][n / 2] - 1) / 2 % mod +
mod) %
mod;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void R(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
void Redirect() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
int anc[5];
struct splay_node {
int num, maxx, ls, rs, fath;
bool lazy;
} p[5];
struct lct {
inline void _pushdown(int i) {
p[i].lazy ^= 1;
p[p[i].ls].lazy ^= 1;
p[p[i].rs].lazy ^= 1;
int t = p[i].ls;
p[i].ls = p[i].rs;
p[i].rs = t;
}
inline void _pushup(int i) {
p[i].maxx = max(max(p[p[i].ls].maxx, p[p[i].rs].maxx), p[i].num);
}
inline void _zig(int i) {
int j = p[i].fath, k;
k = p[j].fath;
if (k != 0 && j == p[k].ls)
p[k].ls = i;
else if (k != 0)
p[k].rs = i;
p[i].fath = k;
p[j].fath = i;
p[p[i].rs].fath = j;
p[j].ls = p[i].rs;
p[i].rs = j;
anc[i] = anc[j];
p[i].maxx = p[j].maxx;
_pushup(j);
}
inline void _zag(int i) {
int j = p[i].fath, k;
k = p[j].fath;
if (k != 0 && j == p[k].ls)
p[k].ls = i;
else if (k != 0)
p[k].rs = i;
p[i].fath = k;
p[j].fath = i;
p[p[i].ls].fath = j;
p[j].rs = p[i].ls;
p[i].ls = j;
anc[i] = anc[j];
p[i].maxx = p[j].maxx;
_pushup(j);
}
void _splay(int i) {
int j;
while (p[i].fath != 0) {
j = p[i].fath;
if (p[p[j].fath].lazy == true) _pushdown(p[j].fath);
if (p[j].lazy == true) _pushdown(j);
if (p[i].lazy == true) _pushdown(i);
if (p[j].fath == 0) {
if (i == p[j].ls)
_zig(i);
else
_zag(i);
} else if (j == p[p[j].fath].ls) {
if (i == p[j].ls)
_zig(j), _zig(i);
else
_zag(i), _zig(i);
} else {
if (i == p[j].rs)
_zag(j), _zag(i);
else
_zig(i), _zag(i);
}
}
}
int _find_max(int i) {
while (i != 0) {
if (p[i].lazy == true) _pushdown(i);
if (p[i].ls != 0 && p[i].maxx == p[p[i].ls].maxx)
i = p[i].ls;
else if (p[i].maxx == p[i].num)
return i;
else
i = p[i].rs;
}
return i;
}
void _access(int i) {
int j = 0;
while (i != 0) {
_splay(i);
if (p[i].lazy == true) _pushdown(i);
if (p[i].rs != 0) {
p[p[i].rs].fath = 0;
anc[p[i].rs] = i;
}
p[i].rs = j;
p[j].fath = i;
_pushup(i);
j = i;
i = anc[i];
}
}
void _setroot(int i) {
_access(i);
_splay(i);
p[i].lazy ^= 1;
}
} T;
int n, d, MOD;
const int MAXN = 1010;
const int MAXD = 11;
int dp[MAXN][MAXN][MAXD];
int Inv[MAXN];
inline void update(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
int qpow(int a, int b) {
int tmp = a, ret = 1;
for (; b; b >>= 1, tmp = 1LL * tmp * tmp % MOD) {
if (b & 1) ret = 1LL * ret * tmp % MOD;
}
return ret;
}
void Init() {
for (int i = 1; i <= 1000; i++) {
Inv[i] = qpow(i, MOD - 2);
}
}
int f[MAXN];
void DP() {
f[1] = 1;
dp[0][0][0] = 1;
for (int j = 0; j <= d; j += 1) {
dp[1][j][j] = 1;
}
for (int i = 2; 2 * i <= n; ++i) {
f[i] = dp[i - 1][i - 1][d - 1];
for (int k = 0; k <= d; k += 1) {
for (int j = 0; j <= n; j += 1) {
if (dp[i - 1][j][k]) {
long long temp = dp[i - 1][j][k];
for (int mt = 0; j + i * mt <= n && mt + k <= d && temp; ++mt) {
update(dp[i][j + i * mt][mt + k], temp);
temp = temp * (f[i] + mt) % MOD * Inv[mt + 1] % MOD;
}
}
}
}
}
}
void Solve() {
if (n < 3) {
cout << "1\n";
exit(0);
} else if (n % 2 == 1) {
cout << dp[n / 2][n - 1][d] << endl;
} else {
long long ans = dp[n / 2 - 1][n - 1][d];
long long naive = f[n / 2];
naive = (naive + 1) * naive % MOD * Inv[2] % MOD;
ans += naive;
ans %= MOD;
cout << ans << endl;
}
}
int main() {
R(n);
R(d);
R(MOD);
Init();
DP();
Solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
inline void umin(T &x, T y) {
x = x < y ? x : y;
}
template <class T>
inline void umax(T &x, T y) {
x = x > y ? x : y;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
const int N = 1234;
int n, d, mo, dp[N], f[N][N][11], inv[N];
int power(int a, int n) {
int res = 1;
while (n) {
if (n & 1) res = 1LL * res * a % mo;
a = 1LL * a * a % mo;
n >>= 1;
}
return res;
}
inline int calc(int tot, int c, int now) { return tot == 0 ? (c == 0) : now; }
inline void add(int &x, int y) { x = x + y < mo ? x + y : x + y - mo; }
int main() {
read(n);
read(d);
read(mo);
int mx = N - 1;
if (n == 1) {
puts("1");
return 0;
}
inv[1] = 1;
for (register int i = (2); i <= (N - 1); i++)
inv[i] = 1LL * (mo - mo / i) * inv[mo % i] % mo;
f[0][0][0] = 1;
for (register int i = (1); i <= (n); i++) {
dp[i] = f[i - 1][i - 1][d - 1];
if (i == 1) dp[i] = 1;
for (register int j = (0); j <= (n); j++)
for (register int k = (0); k <= (d); k++)
if (f[i - 1][j][k])
for (int c = 0, now = 1; k + c <= d && j + i * c <= n; c++) {
add(f[i][j + i * c][k + c],
1LL * f[i - 1][j][k] * calc(dp[i], c, now) % mo);
now = 1LL * now * (dp[i] + c) % mo * inv[c + 1] % mo;
}
}
printf("%d", ((n % 2 == 0 ? 1LL * (dp[n / 2] + 1) * dp[n / 2] / 2 % mo : 0) +
f[(n - 1) / 2][n - 1][d]) %
mo);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int M = 12;
long long MOD;
long long dp[N][M][N];
long long curCom[M];
long long inv2[M];
long long inv1[M];
inline long long mypow(long long a, long long b) {
int res = 1;
while (b) {
if (b & 1) {
res = ((long long)res * a) % MOD;
}
a = ((long long)a * a) % MOD;
b >>= 1;
}
return res;
}
inline long long cmb(long long a, long long b) {
long long d1, d2;
if (a < b) {
return 0;
}
d1 = 1;
d2 = inv2[b];
while (b) {
d1 = (long long)d1 * a % MOD;
b--;
a--;
}
return (long long)d1 * d2 % MOD;
}
void calCurCom(long long n, int m) {
memset(curCom, 0, sizeof(curCom));
if (n = 0) {
return;
}
int i, j;
long long d1, d2;
long long tmp = n + m - 1;
for (i = m; i >= 1; i--, tmp--) {
inv1[i] = mypow(tmp, MOD - 2);
}
d1 = d2 = 1;
}
int main() {
int n, d, i, j, k, l;
scanf("%d%d%lld", &n, &d, &MOD);
if (n <= 2) {
printf("1\n");
return 0;
}
long long tmp = 1;
inv1[0] = 1;
inv2[1] = 1;
for (i = 2; i <= d; i++) {
tmp = tmp * i;
inv2[i] = mypow(tmp, MOD - 2);
}
for (k = 0; k <= n; k++) {
dp[1][0][k] = 1;
}
for (i = 2; i <= d + 1; i++) {
for (k = 1; k <= n; k++) {
dp[i][i - 1][k] = 1;
}
}
for (i = 3; i <= n; i++) {
for (j = 1; j <= d && j < i - 1; j++) {
for (k = 2; k <= n - 1; k++) {
dp[i][j][k] = dp[i][j][k - 1];
for (l = 1; l <= j && l * k < i; l++) {
tmp = (long long)dp[i - k * l][j - l][k - 1] *
cmb(dp[k][d - 1][k - 1] + l - 1, l) % MOD;
dp[i][j][k] = ((long long)dp[i][j][k] + tmp) % MOD;
}
}
}
}
long long ans = 0;
ans = dp[n][d][(n + 1) / 2 - 1];
if ((n & 1) == 0) {
ans = ((long long)ans + cmb(dp[n / 2][d - 1][n / 2 - 1] + 1, 2)) % MOD;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, M = 12;
int n, d, P, f[N][M][N / 2], ifc[N];
int C(int n, int m) {
if (n < m) return 0;
int res = 1;
for (int i = n; i > n - m; --i) res = 1LL * res * i % P;
return 1LL * res * ifc[m] % P;
}
int main() {
scanf("%d%d%d", &n, &d, &P), ifc[1] = 1;
if (n <= 2) return puts("1"), 0;
for (int i = 2; i <= n; ++i) ifc[i] = 1LL * (P - P / i) * ifc[P % i] % P;
for (int i = 2; i <= n; ++i) ifc[i] = 1LL * ifc[i] * ifc[i - 1] % P;
for (int i = 0; i <= n / 2; ++i) f[1][0][i] = 1;
f[1][d - 1][0] = 1;
for (int i = 2; i <= n; ++i)
for (int j = 1; j <= min(d, i - 1); ++j)
for (int k = 1; k <= n / 2; ++k) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t * k <= i && t <= j; ++t)
(f[i][j][k] += 1LL * f[i - t * k][j - t][k - 1] *
C(f[k][d - 1][k - 1] + t - 1, t) % P) %= P;
}
if (n & 1)
printf("%d", f[n][d][n / 2]);
else
printf("%d", (f[n][d][n / 2] + P - C(f[n / 2][d - 1][n / 2 - 1], 2)) % P);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long P;
long long ine[1010];
int f[1010][11][1010];
long long DP(int n, int d, int k) {
k = min(k, n - 1);
if (f[n][d][k] != -1) return f[n][d][k];
if ((n == 1 && d == m - 1) || (n == 1 && !d)) return 1;
if (n == 1 || !k) return 0;
int j;
long long ret = DP(n, d, k - 1), t = DP(k, m - 1, k), tmp = 1;
for (j = 1; j * k < n && j <= d; j++) {
tmp = tmp * (t + j - 1) % P * ine[j] % P;
ret = (ret + tmp * DP(n - k * j, d - j, k - 1)) % P;
}
return f[n][d][k] = ret;
}
int main() {
scanf("%d%d%lld", &n, &m, &P);
if (n == 1 || n == 2) {
puts("1");
return 0;
}
if ((n - 2) % (m - 1) != 0) {
puts("0");
return 0;
}
int i;
ine[0] = ine[1] = 1;
for (i = 2; i <= n; i++) ine[i] = P - (P / i) * ine[P % i] % P;
memset(f, -1, sizeof(f));
long long ans = DP(n, m, (n - 1) / 2);
if (!(n & 1)) {
long long t = DP(n / 2, m - 1, n / 2 - 1);
ans = (ans + t * (t + 1) / 2) % P;
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e3 + 100;
const int D = 12;
int n;
int d;
int mod;
void init() {
std::cin >> n;
std::cin >> d;
std::cin >> mod;
}
int inverse(int x, int mod) {
if (x == 1) {
return 1;
} else {
return (long long)(mod - mod / x) * inverse(mod % x, mod) % mod;
}
}
int comb(int r, int k) {
static int inv[D];
int result = 1;
for (int i = 1; i <= k; i++) {
result = (long long)result * (r - i + 1) % mod;
if (inv[i] == 0) {
inv[i] = inverse(i, mod);
}
result = (long long)result * inv[i] % mod;
}
return result;
}
void update(int &x, int y) { x = (x + y) % mod; }
void work() {
if (n <= 2) {
std::cout << 1 % mod << std::endl;
return;
}
static int f[N][D][N];
std::memset(f, 0, sizeof(f));
f[1][0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= d; j++) {
for (int k = 0; k <= n / 2; k++) {
if (k > 0) {
update(f[i][j][k], f[i][j][k - 1]);
for (int t = 1; t * k < i && t <= j; t++) {
if (k == 1) {
update(f[i][j][k], f[i - t * k][j - t][k - 1]);
} else if (f[i - t * k][j - t][k - 1] != 0) {
update(f[i][j][k], (long long)f[i - t * k][j - t][k - 1] *
comb(f[k][d - 1][k - 1] + t - 1, t) % mod);
}
}
}
}
}
}
int answer = f[n][d][(n - 1) / 2];
if (n % 2 == 0) {
answer += comb(f[n / 2][d - 1][n / 2 - 1] + 1, 2);
answer %= mod;
}
std::cout << answer << std::endl;
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
char c = getchar();
long long tot = 1;
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
tot = -1;
c = getchar();
}
long long sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum * tot;
}
inline void wr(long long x) {
if (x < 0) {
putchar('-');
wr(-x);
return;
}
if (x >= 10) wr(x / 10);
putchar(x % 10 + '0');
}
inline void wrn(long long x) {
wr(x);
putchar('\n');
}
inline void wri(long long x) {
wr(x);
putchar(' ');
}
inline void wrn(long long x, long long y) {
wri(x);
wrn(y);
}
inline void wrn(long long a, long long b, long long c) {
wri(a);
wrn(b, c);
}
long long n, m, d, inv[500055], mod, ans;
long long f[1005][11][505];
inline void add(long long &x, long long k) {
x += k;
x -= (x >= mod) ? mod : 0;
x += (x < 0) ? mod : 0;
}
void init(long long x) {
inv[0] = inv[1] = 1;
for (long long i = (2); i <= (n); i++)
inv[i] = mod - 1LL * (mod / i) * inv[mod % i] % mod;
}
inline long long dp(long long n, long long d, long long k) {
k = min(k, n - 1);
if (f[n][d][k] != -1) return f[n][d][k];
if ((n == 1 && d == m - 1) || (n == 1 && !d)) return f[n][d][k] = 1;
if (n == 1 || !k) return f[n][d][k] = 0;
long long t = dp(k, m - 1, k);
f[n][d][k] = dp(n, d, k - 1);
long long num = 1;
for (long long i = (1); i <= (min((n - 1) / k, d)); i++) {
num = 1LL * num * (t + i - 1) % mod * inv[i] % mod;
add(f[n][d][k], dp(n - k * i, d - i, k - 1) * num % mod);
}
return f[n][d][k];
}
signed main() {
n = read();
m = read();
mod = read();
init(n);
if (n == 1 || n == 2) {
return puts("1"), 0;
}
if ((n - 2) % (m - 1) != 0) return puts("0"), 0;
;
memset(f, -1, sizeof(f));
ans = dp(n, m, (n - 1) / 2);
if (n % 2 == 0) {
long long t = dp(n / 2, m - 1, n / 2 - 1);
add(ans, 1LL * t * (t + 1) / 2 % mod);
}
wrn(ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int MAXN = 1110, LOG = 20;
long long n, m, k, d, x, y, t, a, b, mod;
long long dp[MAXN][MAXN][11];
long long F[MAXN];
long long I[MAXN];
long long inv[MAXN];
long long powmod(long long a, long long b) {
if (!b) return 1;
if (b & 1) return a * powmod(a * a % mod, b >> 1) % mod;
return powmod(a * a % mod, b >> 1);
}
long long C(long long n, long long r) {
if (r > n || r < 0) return 0;
if (n < MAXN) return (F[n] * I[r] % mod) * I[n - r] % mod;
long long res = 1;
r = min(r, n - r);
for (int i = 1; i <= r; i++) res = res * ((n - i + 1) * inv[i] % mod) % mod;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> d >> mod;
if (n <= 2 || d == 2) return cout << 1 << '\n', 0;
F[0] = inv[0] = 1;
for (int i = 1; i < MAXN; i++) F[i] = F[i - 1] * i % mod;
I[MAXN - 1] = powmod(F[MAXN - 1], mod - 2);
for (int i = MAXN - 1; i; i--) I[i - 1] = I[i] * i % mod;
for (int i = 1; i < MAXN - 1; i++) inv[i] = I[i] * F[i - 1] % mod;
for (int i = 0; i <= n; i++) dp[0][i][0] = dp[1][i][0] = dp[1][i][d - 1] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= d; k++) {
dp[i][j][k] = dp[i][j - 1][k];
for (int t = 1; t <= k; t++)
if (i - t * j > 0)
dp[i][j][k] += dp[i - t * j][j - 1][k - t] *
C(dp[j][n / 2][d - 1] + t - 1, t) % mod;
dp[i][j][k] %= mod;
}
long long ans = dp[n][n / 2 - 1][d];
if (n % 2 == 0) ans = (ans + C(dp[n / 2][n / 2][d - 1] + 1, 2)) % mod;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
long long n, d, Mod, ans, f[MAXN][12], g[MAXN], inv[MAXN];
int main() {
scanf("%lld%lld%lld", &n, &d, &Mod);
if (n <= 2) {
puts("1");
return 0;
}
if ((n - 2) % (d - 1)) {
puts("0");
return 0;
}
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 = 2; i <= n; ++i)
inv[i] = 1LL * inv[i] * inv[i - 1] % Mod;
g[1] = f[0][0] = 1;
for (register int i = 1; i <= (n >> 1); ++i) {
for (register int j = n - i; j >= 0; --j)
for (register int p = 0; p < d; ++p)
if (f[j][p]) {
register long long w = 1;
for (register int q = 1; p + q <= d && j + q * i <= n; ++q) {
(w *= g[i] + q - 1) %= Mod;
f[j + q * i][p + q] =
(f[j + q * i][p + q] + 1LL * w * inv[q] % Mod * f[j][p] % Mod) %
Mod;
}
}
g[i + 1] = f[i][d - 1];
}
ans = f[n - 1][d];
if (n & 1 ^ 1) (ans += Mod - (g[n >> 1] * (g[n >> 1] - 1) >> 1) % Mod) %= Mod;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int mod;
int read() {
char ch = getchar();
int x = 0, f = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = 10 * x + (ch - 48);
return x;
}
int ksm(int x, int k) {
int res = 1;
for (; k; k >>= 1) {
if (k & 1) res = 1ll * res * x % mod;
x = 1ll * x * x % mod;
}
return res;
}
int kss[100100];
int ks(int x) {
if (kss[x]) return kss[x];
return kss[x] = ksm(x, mod - 2);
}
int C(int n, int m) {
if (n < m) return 0;
int res = 1;
for (int i = 1; i <= m; i++)
res = 1ll * res * (n - i + 1) % mod * ks(i) % mod;
return res;
}
int f[1010][12][510];
int main() {
n = read();
m = read();
mod = read();
if (n <= 2) {
printf("1");
return 0;
}
for (int i = 0; i <= n / 2; i++) f[1][0][i] = 1;
f[1][m - 1][0] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = 1; k <= n / 2; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t * k < i && t <= j; t++)
f[i][j][k] =
(f[i][j][k] + 1ll * f[i - t * k][j - t][k - 1] *
C(f[k][m - 1][k - 1] + t - 1, t) % mod) %
mod;
}
if (n & 1)
printf("%d", f[n][m][n / 2]);
else
printf("%d",
(f[n][m][n / 2] - C(f[n / 2][m - 1][n / 2 - 1], 2) + mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005, maxd = 15;
int f[maxn], g[maxn][maxd][maxn], rfac[maxn], n, d, mo;
int pow(int a, int b) {
int tmp = 1;
for (; b; b >>= 1, a = a * 1ll * a % mo)
if (b & 1) tmp = tmp * 1ll * a % mo;
return tmp;
}
int main() {
cin >> n >> d >> mo;
if (n == 1) {
cout << 1 << endl;
return 0;
}
rfac[0] = 1;
for (int i = 1; i <= 1000; i++)
rfac[i] = rfac[i - 1] * 1ll * pow(i, mo - 2) % mo;
for (int i = 0; i <= n; i++) g[0][0][i] = 1;
for (int i = 1; i <= n; i++) {
if (i != 1)
f[i] = g[i - 1][d - 1][n];
else
f[i] = 1;
for (int dd = 1; dd <= d; dd++) {
for (int x = 1; x <= n / 2; x++) {
int v = f[x];
for (int k = 1, cv = 1; k <= dd && x * k <= i; k++) {
cv = cv * 1ll * (v + k - 1) % mo;
g[i][dd][x] = (g[i][dd][x] + g[i - x * k][dd - k][x - 1] * 1ll * cv %
mo * rfac[k] % mo) %
mo;
}
}
for (int x = 1; x <= n; x++)
g[i][dd][x] = (g[i][dd][x] + g[i][dd][x - 1]) % mo;
}
}
int ans = g[n - 1][d][(n - 1) / 2];
if (!(n & 1)) {
int v = f[n / 2];
ans = (ans + v * 1ll * (v + 1) % mo * rfac[2] % mo) % mo;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, d, ans = 0, mod, f[1010][20][1010], c[1010][20], inv[20];
long long qpow(long long a, long long b) {
long long ans = 1, k = a;
while (b) {
if (b & 1) ans = ans * k % mod;
k = k * k % mod;
b >>= 1;
}
return ans;
}
int main() {
scanf("%lld%lld%lld", &n, &d, &mod);
inv[0] = 1;
for (int i = 1; i <= n; i++) inv[i] = qpow(i, mod - 2);
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
for (int i = 1; i <= d; i++) c[1][i] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= d; j++) {
for (int k = 1; k < i; k++)
for (int l = 1; l <= j && l * k <= i; l++)
f[i][j][k] =
(f[i][j][k] + f[i - l * k][j - l][k - 1] * c[k][l]) % mod;
for (int k = 1; k <= n; k++)
f[i][j][k] = (f[i][j][k] + f[i][j][k - 1]) % mod;
}
c[i][1] = f[i][d - 1][n];
for (int j = 2; j <= d; j++)
c[i][j] = c[i][j - 1] * (f[i][d - 1][n] + j - 1) % mod * inv[j] % mod;
}
if (n <= 2)
ans = 1;
else
ans = f[n][d][n / 2];
if (n > 2 && !(n & 1))
ans = (ans -
(f[n / 2][d - 1][n / 2] - 1) * f[n / 2][d - 1][n / 2] % mod *
inv[2] % mod +
mod) %
mod;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, p, dp[1003][13][1003], jc[13], iv[13];
bool ok[1003][13][1003];
inline int qpow(int x, int y) {
int z = 1;
for (; y; y >>= 1, x = (long long)x * x % p)
if (y & 1) z = (long long)z * x % p;
return z;
}
inline int cbn(int x, int y) {
int z = 1;
for (register int i = x - y + 1; i <= x; ++i) z = (long long)z * i % p;
return z = (long long)z * iv[y] % p;
}
int dfs(int a, int b, int c) {
if (a == 1) return b == d - 1 || b == 0;
if (b == 0) return 0;
if (c == 0) return 0;
if (ok[a][b][c]) return dp[a][b][c];
int res = 0;
ok[a][b][c] = 1;
res = dfs(a, b, c - 1);
for (register int i = 1; i <= b && i * c < a; ++i)
res = (res + (long long)dfs(a - i * c, b - i, c - 1) *
cbn(dfs(c, d - 1, c - 1) + i - 1, i)) %
p;
return dp[a][b][c] = res;
}
int main() {
scanf("%d%d%d", &n, &d, &p);
if (n <= 2) {
puts("1");
return 0;
}
jc[0] = 1;
for (register int i = 1; i <= d; ++i) jc[i] = (long long)jc[i - 1] * i % p;
iv[d] = qpow(jc[d], p - 2);
for (register int i = d - 1; i >= 0; --i)
iv[i] = (long long)iv[i + 1] * (i + 1) % p;
int ans = dfs(n, d, n - 1 >> 1);
if (!(n & 1)) (ans += cbn(dfs(n >> 1, d - 1, (n >> 1) - 1) + 1, 2)) %= p;
if (ans < 0) ans += p;
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod;
void sadd(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int add(int a, int b) {
sadd(a, b);
return a;
}
int mul(int a, int b) { return (a * 1LL * b) % mod; }
void smul(int &a, int b) { a = mul(a, b); }
int fpow(int x, int n) {
if (n == 0) return 1;
int a = fpow(x, n >> 1);
smul(a, a);
if (n & 1) smul(a, x);
return a;
}
int rev(int x) { return fpow(x, mod - 2); }
int _div(int a, int b) { return mul(a, rev(b)); }
void sdiv(int &a, int b) { smul(a, rev(b)); }
const int N = 1005;
const int D = 11;
int n, d;
int dpTree[N][D];
int dpForestEq[D][N];
int dpForest[N][D][N];
int getTree(int v, int rd);
int getForest(int vs, int rs, int md);
int getForestEq(int cnt, int vone);
int C(int a, int b) {
int ans = 1;
for (int i = 0; i < b; i++) {
smul(ans, (a - i + mod) % mod);
sdiv(ans, i + 1);
}
42;
return ans;
}
int place(int cnt, int diff) { return C(cnt - 1, diff - 1); }
int getSplit(int k, int cnt) {
if (cnt == 0) return 1;
int ans = 0;
for (int diff = 1; diff <= min(cnt, k); diff++)
sadd(ans, mul(C(k, diff), place(cnt, diff)));
42;
return ans;
}
int getForestEq(int cnt, int vone) {
42;
int &ans = dpForestEq[cnt][vone];
if (ans != -1) return ans;
if (vone <= 0) return ans = 0;
int k = ((cnt == 0) ? 1 : getTree(vone, d - 1));
ans = getSplit(k, cnt);
42;
return ans;
}
int getForest(int vs, int rs, int md) {
42;
int &ans = dpForest[vs][rs][md];
if (ans != -1) return ans;
if (vs == 0 && rs == 0) return 1;
if (md == 0) return 0;
if (rs > vs) return 0;
if (rs * md < vs) return 0;
int curans = 0;
for (int cnt = 0; cnt * md <= vs && cnt <= rs; cnt++) {
sadd(curans,
mul(getForest(vs - cnt * md, rs - cnt, md - 1), getForestEq(cnt, md)));
}
42;
return ans = curans;
}
int getTree(int vs, int rd) {
42;
int &ans = dpTree[vs][rd];
if (ans != -1) return ans;
if (vs == 0) return 0;
ans = getForest(vs - 1, rd, (n - 1) / 2);
42;
return ans;
}
int main(int, char **) {
memset(dpForest, -1, sizeof dpForest);
memset(dpForestEq, -1, sizeof dpForestEq);
memset(dpTree, -1, sizeof dpTree);
scanf("%d%d%d", &n, &d, &mod);
dpTree[1][d] = 1;
dpTree[1][d - 1] = 1;
int ans = 0;
sadd(ans, getTree(n, d));
if (n % 2 == 0) sadd(ans, getForestEq(2, n / 2));
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10, D = 15;
int n, d, mod;
int dp[D][N][N];
int ifac[N];
void Add(int &x, int y) {
if ((x += y) >= mod && (x -= mod))
;
}
int binom(int n, int m) {
n %= mod;
if (n < m) return 0;
int pro = 1;
for (int i = n; i >= n - m + 1; i--) pro = 1ll * pro * i % mod;
pro = 1ll * pro * ifac[m] % mod;
return pro;
}
int DP(int g, int n, int k) {
if (dp[g][n][k] != -1) return dp[g][n][k];
int &res = dp[g][n][k];
if (n == 1) return res = 1;
if (k == 0 || g == 0) return res = (n == 1 && g == 0);
res = 0;
Add(res, DP(g, n, k - 1));
if ((k - 1) % (d - 1)) return res;
int f = DP(d - 1, k, k - 1);
for (int i = 1; i <= g; i++) {
if (i * k >= n) break;
Add(res, 1ll * DP(g - i, n - k * i, k - 1) * binom(f + i - 1, i) % mod);
}
return res;
}
void quit(int x) { printf("%d\n", x), exit(0); }
void initmath(int n) {
ifac[0] = ifac[1] = 1;
for (int i = 2; i <= n; i++)
ifac[i] = 1ll * (mod - mod / i) * ifac[mod % i] % mod;
for (int i = 1; i <= n; i++) ifac[i] = 1ll * ifac[i - 1] * ifac[i] % mod;
return;
}
int calc(int g, int n, int k) {
if (n == 1 || n == 2) return 1;
if (n < g + 1) return 0;
if ((n - g - 1) % (d - 1) != 0) return 0;
return DP(g, n, k);
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d%d%d", &n, &d, &mod);
if (n == 1 || n == 2) quit(1);
if (n < d + 1) quit(0);
if ((n - d - 1) % (d - 1) != 0) quit(0);
initmath(d);
if (n & 1) quit(calc(d, n, n / 2));
int ans = calc(d, n, n / 2);
ans = (ans - binom(calc(d - 1, n / 2, n / 2 - 1), 2) + mod) % mod;
quit(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, d, mod, inv[12], dp[1009][1009][12];
int pow(int a, int b) {
int p = 1;
for (int i = 0; (1 << i) <= b; i++) {
if (b & (1 << i)) p = (1LL * p * a) % mod;
a = (1LL * a * a) % mod;
}
return p;
}
int main() {
scanf("%d %d %d", &N, &d, &mod);
if (N <= 2) {
printf("1\n");
return 0;
}
for (int i = 0; i <= N; i++) dp[1][i][0] = dp[1][i][d - 1] = 1;
for (int i = 1; i <= 10; i++) inv[i] = pow(i, mod - 2);
for (int i = 1; i <= N; i++)
for (int k = 1; k <= d; k++) {
if ((i - k - 1) % (d - 1) != 0) continue;
for (int j = 1; j <= N; j++) {
dp[i][j][k] = dp[i][j - 1][k];
if (j > i) continue;
int val = dp[j][j][d - 1], curr = 1;
for (int p = 1; p <= k && j * p <= i; p++) {
curr = (1LL * curr * (val + p - 1)) % mod;
curr = (1LL * curr * inv[p]) % mod;
dp[i][j][k] = ((long long)dp[i][j][k] +
1LL * curr * dp[i - j * p][j - 1][k - p]) %
mod;
}
}
}
int ans = dp[N][N / 2][d];
if (N % 2 == 0) {
ans = dp[N][N / 2 - 1][d];
int val = dp[N / 2][N / 2][d - 1];
val = (1LL * val * (val + 1)) % mod;
val = (1LL * val * inv[2]) % mod;
ans += val;
if (ans >= mod) ans -= mod;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
long long f[1001][11][1001], p, v[20];
int n, d;
long long q(long long a, int t) {
long long x = 1;
while (t) {
if (t & 1) x = x * a % p;
a = a * a % p;
t >>= 1;
}
return x;
}
long long c(long long a, long long b) {
long long x = 1;
for (int i = a - b + 1; i <= a; i++) x = x * i % p;
for (int i = 1; i <= b; i++) x = x * v[i] % p;
return x;
}
long long ff(int i, int j, int k) {
if (k == 0) f[i][j][k] = 0;
if (i == 1 && j == 0 && k == 0) f[i][j][k] = 1;
if (i == j + 1 && k == 1) f[i][j][k] = 1;
if (f[i][j][k] != -1)
return f[i][j][k];
else
f[i][j][k] = 0;
for (int t = 0; t <= j && t * k <= i; t++) {
f[i][j][k] +=
ff(i - t * k, j - t, k - 1) * c(ff(k, d - 1, k - 1) + t - 1, t);
f[i][j][k] %= p;
}
return f[i][j][k];
}
int main() {
int i, j, k, t;
long long s, r;
scanf("%d%d%I64d", &n, &d, &p);
if (n <= 2) {
printf("1");
return 0;
}
if ((n - 2) % (d - 1)) {
printf("0");
return 0;
}
for (i = 1; i <= d; i++) v[i] = q(i, p - 2);
memset(f, 0xFF, sizeof(f));
s = ff(n, d, (n - 1) / 2);
r = ff(n / 2, d - 1, n / 2 - 1);
if (n % 2 == 0) s += r * (r + 1) / 2, s %= p;
printf("%I64d", s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
register long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return (f == 1) ? x : -x;
}
inline void file() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
long long ljc, n, D, f[1010][11][1010], _inv[1010], inv[1010], fac[1010];
inline long long getC(long long n, long long m) {
if (n < m) return 0;
long long _ = 1;
for (long long i = 0; i < m; i++) _ = _ * (n - i) % ljc;
_ = _ * _inv[m] % ljc;
return _;
}
inline void add(long long &a, const long long &b) {
a += b;
a %= ljc;
}
signed main() {
n = read(), D = read(), ljc = read();
if (n <= 2) {
puts("1");
return 0;
}
fac[0] = inv[0] = inv[1] = _inv[0] = 1;
for (long long i = 1; i <= 100; i++) fac[i] = fac[i - 1] * i % ljc;
for (long long i = 2; i <= 100; i++)
inv[i] = (ljc - inv[ljc % i] * (ljc / i) % ljc) % ljc;
for (long long i = 1; i <= 100; i++) _inv[i] = _inv[i - 1] * inv[i] % ljc;
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= D; j++) {
for (int k = 1; k <= n; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int l = 1; l <= j; l++) {
if (i < l * k) break;
if (k > 1)
add(f[i][j][k], f[i - l * k][j - l][k - 1] *
getC(f[k][D - 1][k - 1] + l - 1, l) % ljc);
else
add(f[i][j][k], f[i - l * k][j - l][k - 1] *
getC(f[k][0][k - 1] + l - 1, l) % ljc);
}
}
}
}
if (n & 1) {
cout << f[n][D][n / 2];
} else {
cout << (f[n][D][n / 2] - getC(f[n / 2][D - 1][n / 2 - 1], 2) + ljc) % ljc;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1010, D = 15;
long long n, d, mod;
long long dp[N][D][N];
long long fac[N];
long long qpow(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;
}
void sovle_fac() {
fac[0] = 1;
for (long long i = 1; i <= d + 3; i++) fac[i] = (fac[i - 1] * i) % mod;
for (long long i = 0; i <= d + 3; i++) fac[i] = qpow(fac[i], mod - 2) % mod;
}
long long C(long long a, long long b) {
if (b > a) return 0;
long long ret = 1;
for (int i = 1; i <= b; i++) ret = ret * (a - i + 1) % mod;
return ret * fac[b] % mod;
}
int main() {
scanf("%lld %lld %lld", &n, &d, &mod);
if (n <= 2) {
cout << 1;
return 0;
}
sovle_fac();
for (long long i = 0; i <= n; i++) dp[1][0][i] = 1;
for (long long i = 2; i <= n; i++) {
for (long long j = 1; j < i && j <= d; j++) {
for (long long k = 1; k <= n; k++) {
dp[i][j][k] = dp[i][j][k - 1];
for (long long t = 1; t <= j && t * k < i; t++) {
dp[i][j][k] +=
(dp[i - t * k][j - t][k - 1] *
C(dp[k][(k <= 1) ? (0) : (d - 1)][k - 1] + t - 1, t) % mod) %
mod;
dp[i][j][k] %= mod;
}
}
}
}
long long ans = dp[n][d][n / 2];
if (n % 2 == 0) {
ans = (ans - C(dp[n / 2][d - 1][(n / 2) + 1], 2) + mod) % mod;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
const int N = 1005;
int f[N][15][N], n, d, i, j, mo, k, l, inv[N];
inline int C(int x, int y) {
if (x < y) return 0;
register int ans = 1, i = 1;
for (; i <= y; ++i) ans = 1ll * ans * inv[i] % mo * (x - i + 1) % mo;
return ans;
}
int main() {
scanf("%d%d%d", &n, &d, &mo);
if (n <= 2) return puts("1"), 0;
for (i = 2, inv[1] = 1; i <= d; ++i)
inv[i] = 1ll * (mo - mo / i) * inv[mo % i] % mo;
for (i = 0; i <= n; ++i) f[1][0][i] = 1;
for (i = 2; i <= n; ++i)
for (j = 1; j < i && j <= d; ++j)
for (k = 1; k <= n; ++k) {
f[i][j][k] = f[i][j][k - 1];
for (l = 1; l * k < i && l <= j; ++l)
f[i][j][k] =
(f[i][j][k] + 1ll * f[i - k * l][j - l][k - 1] *
C(f[k][k > 1 ? d - 1 : 0][k - 1] + l - 1, l)) %
mo;
}
j = f[n][d][n >> 1];
if (!(n & 1)) j = (j + mo - C(f[n >> 1][d - 1][n >> 1], 2)) % mo;
return printf("%d\n", j), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, mod;
int sum(int a, int b) {
int s = a + b;
if (s >= mod) s -= mod;
return s;
}
int sub(int a, int b) {
int s = a - b;
if (s < 0) s += mod;
return s;
}
int mult(int a, int b) { return (1LL * a * b) % mod; }
int pw(int a, int b) {
if (b == 0) return 1;
if (b & 1) return mult(a, pw(a, b - 1));
int res = pw(a, b / 2);
return mult(res, res);
}
const int maxN = 1005;
const int maxD = 12;
int c[maxN][maxD];
int val[maxN];
int invfact[maxN];
int ways[maxN];
void init() {
for (int i = 0; i <= n; i++) {
val[i] = (d - 1) * i + 1;
}
for (int i = 0; i <= d; i++) {
invfact[i] = 1;
if (i > 0) {
invfact[i] = mult(invfact[i - 1], pw(i, mod - 2));
}
}
}
void calcC(int k) {
int mlt = 1;
c[k][0] = 1;
for (int i = 1; i <= d; i++) {
mlt = mult(mlt, ways[k] + i - 1);
c[k][i] = mult(mlt, invfact[i]);
}
}
int dp[maxN][maxN][maxD];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> d >> mod;
if (n <= 2) {
cout << 1;
return 0;
}
if ((n - 2) % (d - 1) != 0) {
cout << 0;
return 0;
}
int need = (n - 2) / (d - 1);
init();
ways[0] = 1;
for (int i = 0; i <= d; i++) {
dp[0][0][i] = 1;
}
for (int i = 1; i < need; i++) {
ways[i] = dp[i - 1][i - 1][d - 1];
calcC(i);
for (int have = 0; have < need; have++) {
for (int cnt = 0; cnt <= d; cnt++) {
for (int take = 0; take <= cnt && take * i <= have; take++) {
dp[i][have][cnt] =
sum(dp[i][have][cnt],
mult(dp[i - 1][have - take * i][cnt - take], c[i][take]));
}
}
}
}
int at_most = 0;
for (at_most = 0;; at_most++) {
if (1 + at_most * (d - 1) > n / 2) {
at_most--;
break;
}
}
int ans = dp[at_most][need - 1][d];
if (n % 2 == 0) {
for (int p = 0;; p++) {
if (1 + p * (d - 1) == n / 2) {
int all = ways[p];
ans = sub(ans, mult((mod + 1) / 2, mult(all, sub(all, 1))));
}
if (1 + p * (d - 1) > n / 2) break;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d;
long long int modulo;
int n2;
long long int eleva(long long int b, long long int e) {
if (e == 0) return 1;
if (e % 2 == 0) return eleva(b * b % modulo, e / 2);
return b * eleva(b * b % modulo, e / 2) % modulo;
}
long long int inverso(long long int x) { return eleva(x, modulo - 2); }
void anyade(long long int &a, long long int b) { a = (a + b) % modulo; }
bool puede(int n) {
if (n == 0) return false;
return (n - 1) % (d - 1) == 0;
}
long long int elecciones(int n, int ndown, int a);
long long int memmaner[1001];
int calcul[1001];
long long int maner(int n) {
if (n == 1) return 1;
long long int &mem = memmaner[n];
if (calcul[n]) return mem;
calcul[n] = 1;
mem = elecciones(n - 1, n - 1, d - 1);
return mem;
}
long long int memcombi[1001][11];
long long int calccombi[1001][11];
long long int combi(int n, int a) {
long long int &mem = memcombi[n][a];
if (calccombi[n][a]) return mem;
calccombi[n][a] = 1;
if (a == 0) {
mem = 1;
return mem;
}
if (not puede(n)) return mem;
long long int man = maner(n) - 1 + a;
long long int num = 1;
long long int div = 1;
for (int i = 1; i <= a; i++) {
num = num * (man - i + 1) % modulo;
div = div * i % modulo;
}
mem = num * inverso(div) % modulo;
return mem;
}
long long int memelecciones[1001][1001][11];
int calcelec[1001][1001][11];
long long int elecciones(int n, int ndown, int a) {
if (a == 0) return n == 0;
if (n == 0 or ndown == 0) return 0;
long long int &mem = memelecciones[n][ndown][a];
if (calcelec[n][ndown][a]) return mem;
calcelec[n][ndown][a] = 1;
for (int aa = 0, suma = 0; aa <= a and suma <= n; aa++, suma += ndown)
anyade(mem, combi(ndown, aa) *
elecciones(n - suma, min(n - suma, ndown - 1), a - aa));
return mem;
}
int main() {
cin >> n >> d >> modulo;
long long int sol = 0;
if (n % 2 == 0) anyade(sol, combi(n / 2, 2));
n2 = n / 2;
if (2 * n2 == n) n2--;
if (n == 1)
anyade(sol, 1);
else
anyade(sol, elecciones(n - 1, n2, d));
sol = ((sol % modulo) + modulo) % modulo;
cout << sol << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2005;
int n, d, mod, inv[MAXN], f[MAXN][15][MAXN];
inline int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
inline void Add(int &x, int y) { x += y, x >= mod && (x -= mod); }
inline void prepare() {
inv[1] = 1;
for (int i = 2; i < MAXN; i++)
inv[i] = mod - 1ll * mod / i * inv[mod % i] % mod;
for (int i = 2; i < MAXN; i++) inv[i] = 1ll * inv[i - 1] * inv[i] % mod;
}
inline int C(int n, int m) {
if (n < 0 || m < 0 || m > n) return 0;
int ans = 1;
for (int i = n - m + 1; i <= n; i++) ans = 1ll * ans * i % mod;
return 1ll * ans * inv[m] % mod;
}
inline void solve() {
if (n <= 2) {
puts("1");
return;
}
f[1][0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= d && j < i; j++) {
f[i][j][1] = (j == i - 1);
for (int k = 2; k <= i; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t * k <= i && t <= j; t++)
Add(f[i][j][k], 1ll * f[i - t * k][j - t][min(k - 1, i - t * k)] *
C(f[k][d - 1][k - 1] + t - 1, t) % mod);
}
}
int ans = f[n][d][n >> 1];
if ((n & 1) == 0) ans = (ans - C(f[n >> 1][d - 1][n >> 1], 2) + mod) % mod;
printf("%d\n", ans);
}
int main() {
n = read(), d = read(), mod = read();
prepare(), solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e3 + 5, M = 20;
long long n, d, mod, dp[N][M][N], f[M], g[M], ans;
long long mul(long long x, long long n, long long mod) {
long long ans = mod != 1;
for (x %= mod; n; n >>= 1, x = x * x % mod)
if (n & 1) ans = ans * x % mod;
return ans;
}
void init() {
long long n = 10;
f[0] = g[0] = 1;
for (long long i = 1; i <= n; i++) f[i] = f[i - 1] * i % mod;
g[n] = mul(f[n], mod - 2, mod);
for (long long i = n - 1; i; i--) g[i] = g[i + 1] * (i + 1) % mod;
}
long long C(long long n, long long m) {
if (n < m) return 0;
long long ans = 1;
for (long long i = 1; i <= m; i++) ans = ans * (n - i + 1) % mod;
return ans * g[m] % mod;
}
signed main() {
scanf("%lld%lld%lld", &n, &d, &mod), init();
if (n <= 2) puts("1"), exit(0);
for (long long i = 0; i <= n; i++) dp[1][0][i] = 1;
for (long long i = 2; i <= n; i++)
for (long long j = 1; j <= min(i - 1, d); j++)
for (long long k = 1; k <= n; k++) {
dp[i][j][k] = dp[i][j][k - 1];
for (long long t = 1; i - t * k > 0 && j - t >= 0; t++) {
if (k != 1)
dp[i][j][k] =
(dp[i][j][k] + dp[i - t * k][j - t][k - 1] *
C(dp[k][d - 1][k - 1] + t - 1, t) % mod) %
mod;
else
dp[i][j][k] =
(dp[i][j][k] + dp[i - t * k][j - t][k - 1] *
C(dp[k][0][k - 1] + t - 1, t) % mod) %
mod;
}
}
if (n & 1)
ans = dp[n][d][n / 2];
else
ans = (dp[n][d][n / 2] - C(dp[n / 2][d - 1][n / 2], 2) + mod) % mod;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 1010;
long long f[Maxn][11][Maxn], g[Maxn][Maxn];
long long n, K, Mod;
long long inv[Maxn];
void up(long long &x, long long y) { x = (x + y) % Mod; }
long long _min(long long x, long long y) { return x < y ? x : y; }
int main() {
long long i, j, k;
scanf("%I64d%I64d%I64d", &n, &K, &Mod);
if (n <= 2) {
printf("1\n");
return 0;
}
f[1][K - 1][0] = f[1][0][0] = 1;
inv[0] = inv[1] = 1;
for (i = 2; i <= n; i++) inv[i] = inv[Mod % i] * (Mod - Mod / i) % Mod;
for (i = 1; i <= n; i++) {
for (j = 1; j <= K; j++) {
for (k = 1; k < i; k++) {
up(f[i][j][k], f[i][j][k - 1]);
for (long long x = 1; x <= j && x * k < i; x++)
up(f[i][j][k],
f[i - x * k][j - x][_min(k - 1, i - x * k - 1)] * g[k][x]);
}
}
g[i][0] = 1;
for (j = 1; i * j <= n; j++) {
g[i][j] = g[i][j - 1] * (f[i][K - 1][i - 1] + j - 1) % Mod * inv[j] % Mod;
}
}
long long ans = f[n][K][(n - 1) / 2];
if (!(n & 1))
up(ans, f[n / 2][K - 1][n / 2 - 1] * (f[n / 2][K - 1][n / 2 - 1] + 1) %
Mod * inv[2]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const long long maxn = 1050;
const long long maxd = 11;
long long mod;
const long long inf = 1e9 + 500;
long long dp[maxn][maxd][maxn];
long long rev[15];
long long poww(long long a, long long b) {
if (b == 0) {
return 1;
}
long long v = poww(a, b / 2);
v = (v * v) % mod;
if (b & 1) {
return (v * a) % mod;
}
return v;
}
long long ent(long long n, long long k) {
if (n < k || k < 0) {
return 0;
}
long long ans = 1;
for (long long i = n; i > n - k; i--) {
ans *= i;
ans %= mod;
}
for (long long i = 2; i <= k; i++) {
ans *= rev[i];
ans %= mod;
}
return ans;
}
int main() {
long long n, d;
cin >> n >> d >> mod;
for (long long i = 1; i < 15; i++) {
rev[i] = poww(i, mod - 2);
}
if (n == 1) {
cout << 1;
return 0;
}
if (n == 2) {
cout << 1;
return 0;
}
dp[1][0][0] = 1;
dp[2][1][1] = 1;
for (long long x = 3; x <= n; x++) {
dp[x][1][x - 1] = dp[x - 1][d - 1][x - 2];
for (long long y = 2; y <= d; y++) {
if ((x - y - 1) % (d - 1) != 0) {
continue;
}
if (x - 1 == y) {
dp[x][y][1] = 1;
}
for (long long z = 2; z <= x - 1; z++) {
dp[x][y][z] += dp[x][y][z - 1];
for (long long i = 1; i <= y && x > z * i; i++) {
dp[x][y][z] += (dp[x - z * i][y - i][min(z - 1, x - z * i - 1)] *
ent(dp[z][d - 1][z - 1] + i - 1, i)) %
mod;
dp[x][y][z] %= mod;
}
}
}
}
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j <= d; j++) {
for (long long k = 0; k <= n; k++) {
if (dp[i][j][k] > 0) {
}
}
}
}
long long ans = 0;
if (n % 2 == 0) {
ans += dp[n][d][n / 2 - 1];
long long res = dp[n / 2][d - 1][n / 2 - 1];
res += ((res * (res - 1) / 2) % mod);
res %= mod;
ans += res;
ans %= mod;
cout << ans << endl;
} else {
cout << dp[n][d][n / 2];
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.