text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
template <typename T>
inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
namespace ModCalculator {
int MOD;
inline void Inc(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
inline void Dec(int &x, int y) {
x -= y;
if (x < 0) x += MOD;
}
inline int Add(int x, int y) {
Inc(x, y);
return x;
}
inline int Sub(int x, int y) {
Dec(x, y);
return x;
}
inline int Mul(int x, int y) { return 1LL * x * y % MOD; }
inline int ksm(int x, int k) {
int ret = 1;
for (; k; k >>= 1) {
if (k & 1) ret = Mul(ret, x);
x = Mul(x, x);
}
return ret;
}
inline int Inv(int x) { return ksm(x, MOD - 2); }
} // namespace ModCalculator
using namespace ModCalculator;
int N, D;
int inv[MAXN], dp[MAXN][11][MAXN];
int DP(int n, int d, int k) {
k = min(k, n - 1);
if (n == 1) return (d == 0 || d == D - 1);
if (!k) return 0;
if (~dp[n][d][k]) return dp[n][d][k];
int ret = DP(n, d, k - 1);
int son = DP(k, D - 1, k), C = 1;
for (int i = 1; i <= d && i * k < n; ++i) {
C = Mul(C, Mul(son + i - 1, inv[i]));
Inc(ret, Mul(C, DP(n - i * k, d - i, k - 1)));
}
return dp[n][d][k] = ret;
}
void solve() {
read(N);
read(D);
read(MOD);
if (N <= 2) {
puts("1");
return;
}
inv[0] = inv[1] = 1;
for (int i = 2; i <= N; ++i) {
inv[i] = Mul(MOD - MOD / i, inv[MOD % i]);
}
memset(dp, -1, sizeof(dp));
int ans = DP(N, D, (N - 1) / 2);
if (N % 2 == 0) {
int half = DP(N / 2, D - 1, N / 2 - 1);
Inc(ans, Mul(Mul(half, half + 1), inv[2]));
}
printf("%d\n", ans);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1E3 + 5, M = 11;
int n, d;
long long dp[N][M][N], inv[M] = {1}, ans, mo;
inline void upd(long long &x, long long y) {
x += y;
if (x >= mo) x -= mo;
}
long long Pow(long long a, int b = mo - 2) {
long long res = 1;
for (; b; b >>= 1, a = a * a % mo)
if (b & 1) res = res * a % mo;
return res;
}
long long C(int n, int m) {
long long res = inv[m];
for (int i = n - m + 1; i <= n; ++i) res = res * i % mo;
return res;
}
long long f(int i, int j, int k) {
if (dp[i][j][k] != -1) return dp[i][j][k];
if (i == 1) return !j || j == d - 1;
if (i > j * k + 1) return 0;
long long res = f(i, j, k - 1);
for (int t = 1; t * k < i && t <= j; ++t)
upd(res,
f(i - t * k, j - t, k - 1) * C(f(k, d - 1, k - 1) + t - 1, t) % mo);
return dp[i][j][k] = res;
}
int main() {
scanf("%d%d%lld", &n, &d, &mo);
if (n == 1) return 0 * printf("1\n");
if ((n - 2) % (d - 1)) return 0 * printf("0\n");
memset(dp, -1, sizeof dp);
for (long long i = 1, j = 1; i <= d; ++i) {
j = j * i % mo;
inv[i] = Pow(j);
}
ans = f(n, d, n >> 1);
if (n & 1)
;
else
ans -= C(f(n / 2, d - 1, n / 2 - 1), 2);
printf("%lld\n", (ans % mo + mo) % mo);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
template <class T>
bool ckmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
const int N = 1005;
int fac[N], ifc[N], n, d, mod, f[N][12][N], ans;
inline int add(int x, int y) { return (x += y) >= mod ? x - mod : x; }
inline int sub(int x, int y) { return (x -= y) < 0 ? x + mod : x; }
inline int qpow(int n, int k) {
int res = 1;
for (; k; k >>= 1, n = (long long)n * n % mod)
if (k & 1) res = (long long)res * n % mod;
return res;
}
inline void init(const int &n = N - 1) {
fac[0] = 1;
for (int i = 1, iend = n; i <= iend; ++i)
fac[i] = (long long)i * fac[i - 1] % mod;
ifc[n] = qpow(fac[n], mod - 2);
for (int i = n - 1, iend = 0; i >= iend; --i)
ifc[i] = (long long)(i + 1) * ifc[i + 1] % mod;
}
inline int comb(int n, int m) {
int res = ifc[m];
for (int i = 0, iend = m - 1; i <= iend; ++i)
res = (long long)res * (n - i) % mod;
return res;
}
signed main() {
n = read(), d = read(), mod = read();
init();
if (n == 1) return puts("1"), 0;
if (n == 2) return puts("1"), 0;
for (int i = 0, iend = n; i <= iend; ++i) f[1][0][i] = 1;
for (int i = 2, iend = n; i <= iend; ++i) {
for (int j = 1, jend = min(i - 1, d); j <= jend; ++j) {
for (int k = 1, kend = n; k <= kend; ++k) {
f[i][j][k] = f[i][j][k - 1];
for (int l = 1, lend = j; l <= lend; ++l) {
if (i - l * k < 0) break;
if (k > 1)
f[i][j][k] =
add(f[i][j][k], (long long)f[i - l * k][j - l][k - 1] *
comb(f[k][d - 1][k - 1] + l - 1, l) % mod);
else
f[i][j][k] =
add(f[i][j][k], (long long)f[i - l * k][j - l][k - 1] *
comb(f[k][0][k - 1] + l - 1, l) % mod);
}
}
}
}
ans = f[n][d][n / 2];
if (n % 2 == 0) ans = sub(ans, comb(f[n / 2][d - 1][n / 2 - 1], 2));
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
const long long M = 10, N = 1e3;
long long g[M + 10], f[M + 10], n, d, Mo, ff[N + 10][M + 10][N + 10];
inline long long ksm(long long a, long long b) {
long long ans = 1;
for (a %= Mo; b; b >>= 1, a = 1LL * a * a % Mo)
if (b & 1) ans = 1LL * ans * a % Mo;
return ans;
}
inline long long read() {
long long x = 0, k = 1;
char c = getchar();
for (; c < 48 || c > 57; c = getchar()) k ^= (c == '-');
for (; c >= 48 && c <= 57; c = getchar()) x = x * 10 + (c ^ 48);
return k ? x : -x;
}
inline long long getC(long long n, long long m) {
long long ans = 1;
for (long long i = n - m + 1; i <= n; i++) ans = ans * i % Mo;
return ans * g[m] % Mo;
}
signed main() {
n = read(), d = read(), Mo = read();
f[0] = f[1] = g[0] = 1;
for (long long i = 2; i <= M; i++) f[i] = 1LL * f[i - 1] * i % Mo;
g[M] = ksm(f[M], Mo - 2);
for (long long i = M - 1; i >= 1; i--) g[i] = g[i + 1] * (i + 1) % Mo;
if (n <= 2) {
printf("1\n");
return 0;
}
for (long long i = 0; i <= n; i++) ff[1][0][i] = 1;
for (long long i = 2; i <= n; i++)
for (long long j = 1; j <= std::min(i - 1, d); j++)
for (long long k = 1; k <= n; k++) {
ff[i][j][k] = ff[i][j][k - 1];
for (long long t = 1; i - t * k > 0 && j >= t; t++) {
long long gg = 0;
if (k != 1) gg = d - 1;
ff[i][j][k] =
(ff[i][j][k] + ff[i - t * k][j - t][k - 1] *
(getC(ff[k][gg][k - 1] + t - 1, t)) % Mo) %
Mo;
}
}
if (n % 2 == 0)
ff[n][d][n / 2] =
(ff[n][d][n / 2] - getC(ff[n / 2][d - 1][n / 2 - 1], 2) + Mo) % Mo;
printf("%lld\n", ff[n][d][n / 2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, M = 11;
int dp[N][N][M], inv[N], n, m, mod;
void Add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
void Pre() {
inv[0] = inv[1] = 1;
for (int i = 2; i <= n; i++)
inv[i] = mod - 1ll * mod / i * inv[mod % i] % mod;
memset(dp, -1, sizeof dp);
}
int DFS(int tot, int mxs, int deg) {
mxs = min(mxs, tot - 1);
int &pt = dp[tot][mxs][deg];
if (~pt) return pt;
if (tot == 1) return pt = (!deg || deg == m - 1);
if (!mxs) return pt = 0;
int ret = DFS(tot, mxs - 1, deg), tmp = DFS(mxs, mxs, m - 1);
for (int i = 1, t = 1; i * mxs < tot && i <= deg; i++) {
t = 1ll * t * (tmp + i - 1) % mod * inv[i] % mod;
Add(ret, 1ll * t * DFS(tot - i * mxs, mxs - 1, deg - i) % mod);
}
return pt = ret;
}
int main() {
scanf("%d%d%d", &n, &m, &mod), Pre();
if (n <= 2)
printf("1");
else {
int ans = DFS(n, (n - 1) / 2, m);
if (n % 2 == 0) {
int tmp = DFS(n / 2, n / 2 - 1, m - 1);
Add(ans, 1ll * tmp * (tmp + 1) % mod * inv[2] % mod);
}
printf("%d", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[1010][11][1010];
long long ine[11];
int n, d;
long long mod;
long long ans = 0;
long long C(long long x, long long y) {
long long re = 1;
int i;
for (i = x - y + 1; i <= x; i++) {
(re *= i % mod) %= mod;
}
for (i = 1; i <= y; i++) {
(re *= ine[i]) %= mod;
}
return re;
}
int main() {
int i, j, k, l;
scanf("%d%d%lld", &n, &d, &mod);
if (n <= 2) {
printf("1\n");
return 0;
}
ine[0] = ine[1] = 1;
for (i = 2; i <= 10; i++) {
ine[i] = (mod - mod / i) * ine[mod % i] % mod;
}
for (i = 0; i <= n; i++) {
f[1][0][i] = 1;
f[1][d - 1][i] = 1;
}
for (i = 2; i <= n; i++) {
for (j = 1; j <= d && j < i; j++) {
for (k = 1; k <= n; k++) {
f[i][j][k] = f[i][j][k - 1];
for (l = 1; l <= j && l * k < i; l++) {
if (f[k][d - 1][k - 1]) {
(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) {
ans = f[n][d][n / 2];
} else {
ans = (f[n][d][n / 2 - 1] + C(f[n / 2][d - 1][n / 2 - 1] + 1, 2)) % mod;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
namespace my_std {
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
inline T rnd(T l, T r) {
return uniform_int_distribution<T>(l, r)(rng);
}
template <typename T>
inline void read(T& t) {
t = 0;
char f = 0, ch = getchar();
double d = 0.1;
while (ch > '9' || ch < '0') f |= (ch == '-'), ch = getchar();
while (ch <= '9' && ch >= '0') t = t * 10 + ch - 48, ch = getchar();
if (ch == '.') {
ch = getchar();
while (ch <= '9' && ch >= '0') t += d * (ch ^ 48), d *= 0.1, ch = getchar();
}
t = (f ? -t : t);
}
template <typename T, typename... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
void file() {}
} // namespace my_std
using namespace my_std;
int n, d;
long long mod;
long long dp[1010][15][1010];
long long inv[15];
long long dfs(int i, int j, int k) {
k = min(k, n - 1);
if (dp[i][j][k] != -1) return dp[i][j][k];
if (i == 1) return j == 0 || j == d - 1;
if (!k) return 0;
long long ret = dfs(i, j, k - 1), s = dfs(k, d - 1, k - 1), cur = 1;
for (int t = (1); t <= (j); t++) {
if (t * k >= i) break;
long long c = dfs(i - t * k, j - t, k - 1);
cur = cur * (s + t - 1) % mod * inv[t] % mod;
ret = (ret + c * cur % mod) % mod;
}
return dp[i][j][k] = ret;
}
int main() {
file();
read(n, d, mod);
if (n <= 2) return puts("1"), 0;
inv[1] = 1;
for (int i = (2); i <= (d); i++)
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
memset(dp, -1, sizeof(dp));
long long ans = dfs(n, d, n / 2);
if (n % 2 == 0) {
long long s = dfs(n / 2, d - 1, n / 2 - 1);
ans = (ans - (s * (s - 1) / 2) % mod + mod) % mod;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[1010][11][1010], n, d, Mod, ans, iv[1010];
inline int Pow(int x, int y) {
int rs = 1;
while (y) {
if (y & 1) rs = rs * 1ll * x % Mod;
x = x * 1ll * x % Mod, y /= 2;
}
return (rs);
}
inline int Dfs(int n, int m, int h) {
if (n == 1 || n == 0) {
if (m == 0 && n == 1) return (1);
if (n == 1 && (m == d - 1 || m == d)) return (1);
return (0);
}
if (m * h + 1 < n) return (0);
if (f[n][m][h] != -1) return (f[n][m][h]);
f[n][m][h] = Dfs(n, m, h - 1);
int nm2 = Dfs(h, d - 1, h - 1), nw = nm2;
for (int i = 1; i * h < n && i <= m; i++) {
int nm1 = Dfs(n - h * i, m - i, h - 1);
f[n][m][h] = (f[n][m][h] + nm1 * 1ll * nm2 % Mod) % Mod;
nm2 = nm2 * 1ll * (nw + i) % Mod * iv[i + 1] % Mod;
}
return (f[n][m][h]);
}
int main() {
scanf("%d%d%d", &n, &d, &Mod);
iv[0] = 1;
for (int i = 1; i <= d; i++) iv[i] = Pow(i, Mod - 2);
memset(f, -1, sizeof(f));
ans = Dfs(n, d, (n - 1) / 2);
if (n % 2 == 0) {
int tp = Dfs(n / 2, d - 1, n / 2);
ans = ((ans + tp * 1ll * (tp - 1) / 2 % Mod) % Mod + tp) % Mod;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <class t, size_t n>
ostream& operator<<(ostream& os, const array<t, n>& first) {
return os << vc<t>(first.begin(), first.end());
}
template <ll i, class T>
void print_tuple(ostream&, const T&) {}
template <ll i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
if (i) os << ",";
os << get<i>(t);
print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
os << "{";
print_tuple<0, tuple<Args...>, Args...>(os, t);
return os << "}";
}
template <class t>
void print(t x, ll suc = 1) {
cout << x;
if (suc == 1) cout << "\n";
if (suc == 2) cout << " ";
}
ll read() {
ll i;
cin >> i;
return i;
}
vi readvi(ll n, ll off = 0) {
vi v(n);
for (ll i = ll(0); i < ll(n); i++) v[i] = read() + off;
return v;
}
template <class T>
void print(const vector<T>& v, ll suc = 1) {
for (ll i = ll(0); i < ll(v.size()); i++)
print(v[i], i == ll(v.size()) - 1 ? suc : 2);
}
string readString() {
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T& t) {
return t * t;
}
void yes(bool ex = true) {
cout << "Yes"
<< "\n";
if (ex) exit(0);
}
void no(bool ex = true) {
cout << "No"
<< "\n";
if (ex) exit(0);
}
void possible(bool ex = true) {
cout << "Possible"
<< "\n";
if (ex) exit(0);
}
void impossible(bool ex = true) {
cout << "Impossible"
<< "\n";
if (ex) exit(0);
}
constexpr ll ten(ll n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
ll topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
ll topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
ll botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
ll botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
ll popcount(signed t) { return __builtin_popcount(t); }
ll popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(ll i) { return i && (i & -i) == i; }
ll mask(ll i) { return (ll(1) << i) - 1; }
template <class t>
bool inc(t first, t second, t c) {
return first <= second && second <= c;
}
template <class t>
void mkuni(vc<t>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
static random_device rd;
static mt19937_64 gen(rd());
return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
ll lwb(const vc<t>& v, const t& first) {
return lower_bound(v.begin(), v.end(), first) - v.begin();
}
using uint = unsigned;
using ull = unsigned long long;
struct modinfo {
uint mod, root;
};
template <modinfo const& ref>
struct modular {
static constexpr uint const& mod = ref.mod;
static modular root() { return modular(ref.root); }
uint v;
modular(ll vv = 0) { s(vv % mod + mod); }
modular& s(uint vv) {
v = vv < mod ? vv : vv - mod;
return *this;
}
modular operator-() const { return modular() - *this; }
modular& operator+=(const modular& rhs) { return s(v + rhs.v); }
modular& operator-=(const modular& rhs) { return s(v + mod - rhs.v); }
modular& operator*=(const modular& rhs) {
v = ull(v) * rhs.v % mod;
return *this;
}
modular& operator/=(const modular& rhs) { return *this *= rhs.inv(); }
modular operator+(const modular& rhs) const { return modular(*this) += rhs; }
modular operator-(const modular& rhs) const { return modular(*this) -= rhs; }
modular operator*(const modular& rhs) const { return modular(*this) *= rhs; }
modular operator/(const modular& rhs) const { return modular(*this) /= rhs; }
modular pow(ll n) const {
modular res(1), x(*this);
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
modular inv() const { return pow(mod - 2); }
friend modular operator+(ll x, const modular& y) { return modular(x) + y; }
friend modular operator-(ll x, const modular& y) { return modular(x) - y; }
friend modular operator*(ll x, const modular& y) { return modular(x) * y; }
friend modular operator/(ll x, const modular& y) { return modular(x) / y; }
friend ostream& operator<<(ostream& os, const modular& m) {
return os << m.v;
}
friend istream& operator>>(istream& is, modular& m) {
ll x;
is >> x;
m = modular(x);
return is;
}
bool operator<(const modular& r) const { return v < r.v; }
bool operator==(const modular& r) const { return v == r.v; }
bool operator!=(const modular& r) const { return v != r.v; }
explicit operator bool() const { return v; }
};
modinfo base{1, 0};
using mint = modular<base>;
const ll vmax = 5010;
mint fact[vmax], finv[vmax], invs[vmax];
void initfact() {
fact[0] = 1;
for (ll i = ll(1); i < ll(vmax); i++) {
fact[i] = fact[i - 1] * i;
}
finv[vmax - 1] = fact[vmax - 1].inv();
for (ll i = vmax - 2; i >= 0; i--) {
finv[i] = finv[i + 1] * (i + 1);
}
for (ll i = vmax - 1; i >= 1; i--) {
invs[i] = finv[i] * fact[i - 1];
}
}
mint choose(ll n, ll k) { return fact[n] * finv[n - k] * finv[k]; }
mint binom(ll first, ll second) {
return fact[first + second] * finv[first] * finv[second];
}
mint catalan(ll n) {
return binom(n, n) - (n - 1 >= 0 ? binom(n - 1, n + 1) : 0);
}
mint work[11][1010];
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
ll n, d;
cin >> n >> d;
cin >> base.mod;
initfact();
if (n <= 2) {
cout << 1 << endl;
return 0;
}
work[0][0] = 1;
mint ans;
for (ll i = ll(1); i < ll(n + 1); i++) {
if (i * 2 >= n) {
ans += work[d][n - 1];
}
mint w = (i == 1 ? 1 : work[d - 1][i - 1]);
for (ll j = ll(d) - 1; j >= ll(0); j--) {
mint z = 1;
for (ll add = ll(1); add < ll(d - j + 1); add++) {
z *= (w + add - 1);
z *= invs[add];
for (ll k = ll(0); k < ll(n - add * i + 1); k++)
work[j + add][k + add * i] += work[j][k] * z;
}
}
if (i * 2 == n) {
ans += w * (w + 1) / 2;
}
if (i * 2 >= n) break;
}
cout << ans << endl;
}
|
#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;
int n, m, mod, f[1010][11][1010], inv[12];
void U(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int cal(int n, int d, int k) {
k = min(k, n - 1);
if (~f[n][d][k]) return f[n][d][k];
if (n == 1) return d == m - 1 || !d;
if (!k) return 0;
int res = cal(n, d, k - 1), t = cal(k, m - 1, k - 1), s = 1;
for (int i = 1; i <= d && i * k < n; ++i) {
s = (long long)s * (t + i - 1) % mod * inv[i] % mod;
U(res, (long long)s * cal(n - i * k, d - i, k - 1) % mod);
}
return f[n][d][k] = res;
}
int main() {
cin >> n >> m >> mod;
if (n == 1) return puts("1"), 0;
inv[1] = 1;
for (int i = 2; i < 12; ++i)
inv[i] = (long long)(mod - mod / i) * inv[mod % i] % mod;
memset(f, -1, sizeof f);
int ans = cal(n, m, n - 1 >> 1);
if (n % 2 == 0) {
long long e = cal(n / 2, m - 1, n - 1 >> 1);
U(ans, e * (e + 1) / 2 % mod);
}
cout << ans << endl;
}
|
#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 = dfs(a, b, c - 1), x = dfs(c, d - 1, c - 1), y = 1;
ok[a][b][c] = 1;
for (register int i = 1; i <= b && i * c < a; ++i) {
y = (long long)y * (x + i - 1) % p;
res = (res + (long long)dfs(a - i * c, b - i, c - 1) * y % p * iv[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;
inline int read() {
char c = getchar();
int x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
int mod;
struct modint {
int x;
modint(int o = 0) { x = o; }
modint &operator=(int o) { return x = o, *this; }
modint &operator+=(modint o) {
return x = x + o.x >= mod ? x + o.x - mod : x + o.x, *this;
}
modint &operator-=(modint o) {
return x = x - o.x < 0 ? x - o.x + mod : x - o.x, *this;
}
modint &operator*=(modint o) { return x = 1ll * x * o.x % mod, *this; }
modint &operator^=(int b) {
modint a = *this, c = 1;
for (; b; b >>= 1, a *= a)
if (b & 1) c *= a;
return x = c.x, *this;
}
modint &operator/=(modint o) { return *this *= o ^= mod - 2; }
modint &operator+=(int o) {
return x = x + o >= mod ? x + o - mod : x + o, *this;
}
modint &operator-=(int o) {
return x = x - o < 0 ? x - o + mod : x - o, *this;
}
modint &operator*=(int o) { return x = 1ll * x * o % mod, *this; }
modint &operator/=(int o) { return *this *= ((modint(o)) ^= mod - 2); }
template <class I>
friend modint operator+(modint a, I b) {
return a += b;
}
template <class I>
friend modint operator-(modint a, I b) {
return a -= b;
}
template <class I>
friend modint operator*(modint a, I b) {
return a *= b;
}
template <class I>
friend modint operator/(modint a, I b) {
return a /= b;
}
friend modint operator^(modint a, int b) { return a ^= b; }
friend bool operator==(modint a, int b) { return a.x == b; }
friend bool operator!=(modint a, int b) { return a.x != b; }
bool operator!() { return !x; }
modint operator-() { return x ? mod - x : 0; }
};
modint fac[2005], inv[2005];
inline void prework(int n) {
fac[0] = 1;
for (register int i = (1); i <= (n); ++i) fac[i] = fac[i - 1] * i;
inv[n] = modint(1) / fac[n];
for (register int i = (n - 1); i >= (0); --i) inv[i] = inv[i + 1] * (i + 1);
}
inline modint C(modint n, int m) {
if (m > n.x) return 0;
modint res = 1;
for (register int i = (n.x - m + 1); i <= (n.x); ++i) res *= i;
return res * inv[m];
}
int n, d;
modint f[2005][13][2005];
signed main() {
n = read(), d = read(), mod = read();
if (n == 1 || n == 2) {
puts("1");
return 0;
}
prework(2000);
for (register int i = (0); i <= (n); ++i) f[1][0][i] = 1;
for (register int i = (2); i <= (n); ++i)
for (register int j = (1); j <= (min(d, i - 1)); ++j)
for (register int k = (1); k <= (n); ++k) {
f[i][j][k] = f[i][j][k - 1];
for (register int t = (1); t <= (j); ++t) {
if (i >= t * k && k >= 1) {
if (k > 1)
f[i][j][k] +=
f[i - t * k][j - t][k - 1] * C(f[k][d - 1][k - 1] + t - 1, t);
else
f[i][j][k] +=
f[i - t * k][j - t][k - 1] * C(f[k][0][k - 1] + t - 1, t);
}
}
}
if (n & 1)
cout << f[n][d][n / 2].x;
else
cout << (f[n][d][n / 2] - C(f[n / 2][d - 1][n / 2 - 1], 2)).x;
return 0;
}
|
#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;
}
if ((n - 2) % (d - 1) != 0) {
puts("0");
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;
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; l++) {
f = f * ((k == 1 ? 1 : cs[k - 1][d - 1][k]) + l - 1) % mod * iv[l] %
mod;
addm(dp[i][j][k], (long long)cs[i - l * k][j - l][k] * f % mod);
}
cs[i][j][k + 1] = addm2(cs[i][j][k], dp[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;
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;
const int N = 1010;
int n, d, mod, g[N][11], f[N][11], ans, q[N], t;
int Pow(int a, int b) {
if (b == 0) return 1;
int ret = Pow(a, b / 2);
ret = 1LL * ret * ret % mod;
if (b & 1) ret = 1LL * ret * a % mod;
return ret;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) {
cout << 1 << endl;
return 0;
}
if ((n - 2) % (d - 1) != 0) {
cout << 0 << endl;
return 0;
}
g[1][0] = 1;
for (int i = 1; i <= n / 2; i++) {
if (i == 1)
t = 1;
else
t = g[i][d - 1];
q[0] = 1;
for (int k = 1; k <= d; k++)
q[k] = 1LL * q[k - 1] * (t++) % mod * Pow(k, mod - 2) % mod;
memcpy(f, g, sizeof(f));
for (int k = 1; k * i < n; k++)
for (int j = 1; j + k * i <= n; j++)
for (int p = 0; p + k <= d; p++) {
f[j + k * i][p + k] =
(f[j + k * i][p + k] + 1LL * g[j][p] * q[k]) % mod;
}
memcpy(g, f, sizeof(f));
}
ans = g[n][d];
if (n % 2 == 0) {
ans = (ans - 1LL * (g[n / 2][d - 1] - 1) * g[n / 2][d - 1] % mod *
Pow(2, mod - 2)) %
mod;
}
ans = (ans + mod) % mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1017, D = 12;
int n, d, mod;
long long dp[N][N][D], chs[N][N];
long long f[N][D];
long long fac[N];
int po(int x, int y) {
if (y == 0) return 1;
long long ans = po(x, y / 2);
ans *= ans;
ans %= mod;
if (y % 2) {
ans *= x;
ans %= mod;
}
return ans;
}
int main() {
cin >> n >> d >> mod;
if (n == 1) {
cout << 1;
return 0;
}
chs[0][0] = 1;
for (int i = 1; i <= n + d; i++) {
for (int j = 0; j <= n + d; j++) {
chs[i][j] = chs[i - 1][j];
if (j) {
chs[i][j] += chs[i - 1][j - 1];
}
chs[i][j] %= mod;
}
}
fac[0] = 1;
for (int i = 1; i <= d; i++) {
fac[i] = fac[i - 1] * i;
fac[i] %= mod;
}
dp[1][0][d - 1] = 1;
dp[1][0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int k = 0; k <= d; k++) {
for (int j = 1; j <= n; j++) {
dp[i][j][k] = dp[i][j - 1][k];
for (int q = 1; q <= k && q * j <= i; q++) {
dp[i][j][k] += 1ll * dp[i - q * j][j - 1][k - q] * f[j][q];
dp[i][j][k] %= mod;
}
}
}
for (int r = 0; r <= d; r++) {
f[i][r] = po(fac[r], mod - 2);
for (int l = dp[i][i - 1][d - 1]; l < dp[i][i - 1][d - 1] + r; l++) {
f[i][r] *= l;
f[i][r] %= mod;
}
}
}
long long ans = dp[n][n - n / 2 - 1][d];
if (n % 2 == 0) {
ans += (dp[n / 2][n / 2 - 1][d - 1] + 1) * dp[n / 2][n / 2 - 1][d - 1] / 2;
}
ans %= mod;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10, D = 10 + 2, L = 20;
int B;
long long inv[L];
long long dp[2][N][D];
long long com(long long n, long long m) {
n %= B;
if (m < 0 || n < m) return 0;
long long ret = n;
for (int i = 1; i < m; ++i) ret = ret * (n - i) % B * inv[i + 1] % B;
return ret;
}
int main() {
int n, d;
scanf("%d%d%d", &n, &d, &B);
if (n <= 2) {
puts("1");
return 0;
}
inv[0] = 0, inv[1] = 1;
for (int i = 2; i <= d; ++i) inv[i] = inv[B % i] * (B - B / i) % B;
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)[N][D] = dp[k - 1 & 1], (&g)[N][D] = 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) % B) %
B;
}
}
long long ans = dp[n0 & 1][n][d];
if (n + 1 & 1) ans = (ans + com(dp[n0 & 1][n >> 1][d - 1] + 1, 2)) % B;
printf("%d\n", (int)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char ch = getchar();
int f = 1;
while (!isdigit(ch)) {
if (ch == '-') f *= -1;
ch = getchar();
};
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
int n, d, mod;
inline int mul(int x, int y) { return 1ll * x * y % mod; }
int add(int x, int y) { return x + y >= mod ? x + y - mod : x + y; }
int sub(int x, int y) { return x - y < 0 ? x - y + mod : x - y; }
int sq(int x) { return 1ll * x * x % mod; }
int pow(int a, int b) {
return b == 0 ? 1 : (b & 1 ? mul(a, sq(pow(a, b / 2))) : sq(pow(a, b / 2)));
}
int dp[1010][505][15], inv[15];
int main() {
read(n);
read(d);
read(mod);
if (n <= 2) {
cout << 1 << endl;
return 0;
}
for (int i = 1; i < 15; i++) {
inv[i] = pow(i, mod - 2);
}
dp[1][0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n / 2; j++) {
for (int k = 0; k <= d; k++) {
if (j == 0)
dp[i][j][k] = (i == 1 && k == 0);
else
dp[i][j][k] = add(dp[i][j][k], dp[i][j - 1][k]);
if (j != 0) {
int cu = 1;
for (int t = 1; t <= k && t * j < i; t++) {
if (j != 1) cu = mul(cu, mul(dp[j][j - 1][d - 1] + t - 1, inv[t]));
dp[i][j][k] =
add(dp[i][j][k], mul(dp[i - t * j][j - 1][k - t], cu));
}
}
}
}
}
int ans = dp[n][(n - 1) / 2][d];
if (n % 2 == 0) {
ans = add(ans, mul((mod + 1) / 2, mul(dp[n / 2][n / 2 - 1][d - 1] + 1,
dp[n / 2][n / 2 - 1][d - 1])));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = x * 10 + (c ^ 48), c = getchar();
}
using namespace std;
int n, d, P;
inline void ADD(int &a, long long b) {
a += b;
if (a >= P) a -= P;
}
int f[1010][12][1010];
inline int quickpow(int x, int k) {
int res = 1;
while (k) {
if (k & 1) res = 1ll * res * x % P;
x = 1ll * x * x % P;
k >>= 1;
}
return res;
}
int jie[1010], jieni[1010];
inline void init() {
jie[0] = jieni[0] = 1;
const int up = 100;
for (int i = 1; i <= up; ++i) jie[i] = 1ll * jie[i - 1] * i % P;
jieni[up] = quickpow(jie[up], P - 2);
for (int i = up - 1; i; --i) jieni[i] = 1ll * jieni[i + 1] * (i + 1) % P;
}
inline int get_c(int n, int m) {
if (m > n) return 0;
int tmp = 1;
for (int i = n - m + 1; i <= n; ++i) tmp = 1ll * tmp * i % P;
tmp = 1ll * tmp * jieni[m] % P;
return tmp;
}
int main() {
read(n), read(d), read(P);
if (n == 2) {
puts("1");
return 0;
}
if (n == 1) {
puts("1");
return 0;
}
init();
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 <= j; ++t)
if (i - t * k >= 0) {
f[i][j][k] =
(f[i][j][k] + 1ll * f[i - t * k][j - t][min(k - 1, i - t * k)] *
get_c(f[k][d - 1][k] + t - 1, t)) %
P;
} else
break;
}
}
}
int ans = f[n][d][n >> 1];
if (!(n & 1)) ans = (ans - get_c(f[n >> 1][d - 1][(n >> 1)], 2) + P) % P;
printf("%d\n", (ans % P + P) % P);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, d, mod;
long long f[N][15], inv[15];
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) return puts("1"), 0;
f[0][0] = 1;
f[0][d - 1] = 1;
inv[1] = 1;
for (int i = 2; i <= d + 1; i++) {
long long t = i, x = mod - 2, &res = inv[i];
res = 1;
for (; x; x >>= 1, t = t * t % mod)
if (x & 1) res = res * t % mod;
}
for (int sub = 1; 2 * sub <= n; sub++)
for (int size = n; size >= 0; size--)
for (int deg = d; deg >= 0; deg--) {
long long t = f[sub - 1][d - 1];
for (int cnt = 1; cnt + deg <= d && cnt * sub + size < n; cnt++)
(f[cnt * sub + size][cnt + deg] += f[size][deg] * t) %= mod,
t = t * (f[sub - 1][d - 1] + cnt) % mod * inv[cnt + 1] % mod;
}
printf("%d\n",
(int)((f[n - 1][d] + mod -
(n % 2 ? 0
: f[n / 2 - 1][d - 1] * (f[n / 2 - 1][d - 1] - 1 + mod) %
mod * inv[2] % mod)) %
mod));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1ll << 50;
const int maxn = 1005;
const int maxd = 15;
int n, d;
long long f[maxn], inc[maxn];
long long mod, g[maxn][maxn][maxd];
long long QuickPow(long long p, long long k) {
long long res = 1ll;
p %= mod;
for (; k; k >>= 1, (p *= p) %= mod)
if (k & 1) (res *= p) %= mod;
return res;
}
int main() {
scanf("%d %d %lld", &n, &d, &mod);
if (n <= 2) {
puts("1");
return 0;
}
for (int i = 1; i <= n; i++) inc[i] = QuickPow(i, mod - 2);
f[1] = g[0][0][0] = 1ll;
for (int i = 0; i <= d; i++) g[1][i][i] = 1ll;
for (int i = 2; i <= n / 2; i++) {
f[i] = g[i - 1][i - 1][d - 1];
for (int k = 0; k <= d; k++)
for (int j = 0; j <= n; j++)
if (g[i - 1][j][k]) {
long long cur = g[i - 1][j][k];
for (int l = 0; j + l * i <= n && l + k <= d; l++) {
(g[i][j + l * i][l + k] += cur) %= mod;
(cur *= (f[i] + l) * inc[l + 1] % mod) %= mod;
}
}
}
if (n & 1)
printf("%lld", g[n / 2][n - 1][d]);
else {
long long ans = g[n / 2 - 1][n - 1][d], cur = f[n / 2];
(ans += (cur + 1) * cur % mod * inc[2]) %= mod;
printf("%lld", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
static const long long MAXN = 1005;
static const long long MAXD = 11;
static const long long MAX_MODULUS = 1e9 + 7;
template <typename T>
inline T min(const T a, const T b) {
return a < b ? a : b;
}
long long n, d, mod;
inline long long fpow(long long base, long long exp) {
long long ans = 1;
for (; exp; exp >>= 1) {
if (exp & 1) (ans *= base) %= mod;
base = (long long)base * base % mod;
}
return ans;
}
inline long long _inv(const long long x) { return fpow(x, mod - 2); }
long long inv[MAXD];
inline void calc_inversions() {
for (long long i = 1; i < MAXD; ++i) inv[i] = _inv(i);
}
inline long long binom_2(const long long x) {
return (long long)x * (x - 1) % mod * inv[2] % mod;
}
long long f[MAXN][MAXD][MAXN] = {{{0}}};
signed main() {
scanf("%I64d%I64d%I64d", &n, &d, &mod);
if (n <= 2) {
puts("1");
return 0;
}
calc_inversions();
for (long long i = 0; i <= n; ++i) f[0][0][i] = 1;
for (long long i = 1; i <= n; ++i)
for (long long j = 1; j <= d; ++j)
for (long long k = 1; k <= min(i, (n + 1) / 2); ++k) {
long long binom_begin = (k == 1 ? 1 : f[k - 1][d - 1][k - 1]);
long long binom_val = 1;
for (long long t = 0; t <= i / k && t <= j; ++t) {
f[i][j][k] =
((long long)f[i][j][k] +
binom_val * f[i - k * t][j - t][min(i - k * t, k - 1)]) %
mod;
binom_val =
(long long)binom_val * (binom_begin + t) % mod * inv[t + 1] % mod;
}
}
long long ans =
(f[n - 1][d][(n - 1) / 2] +
((n & 1) ? 0 : binom_2(f[n / 2 - 1][d - 1][(n - 1) / 2] + 1))) %
mod;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, D = 15;
int n, d, P;
int f[N][D][N], iv[D];
int qpow(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = 1ll * a * a % P) b & 1 && (res = 1ll * res * a % P);
return res;
}
int main() {
scanf("%d%d%d", &n, &d, &P);
for (int i = 1; i <= d; i++) iv[i] = qpow(i, P - 2);
if (n <= 2) return puts("1"), 0;
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= d && j < i; j++)
for (int k = 1; k <= n; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int s = 1, C = 1; s <= j && k * s <= i; s++)
C = 1ll * C * (f[k][k > 1 ? d - 1 : 0][k - 1] + s - 1) % P * iv[s] %
P,
f[i][j][k] =
(f[i][j][k] + 1ll * f[i - k * s][j - s][k - 1] * C % P) % P;
}
if (n & 1) return printf("%d\n", f[n][d][n / 2]), 0;
int ans = f[n / 2][d - 1][n / 2 - 1];
ans = (1ll * ans * (ans + 1) / 2 % P + f[n][d][n / 2 - 1]) % P;
return printf("%d\n", ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[1005][12][1005], bo[1005][12][1005], fac[100], inv[100], mod;
int n, m;
long long kp(long long a, long long b) {
if (!b) return 1;
long long c = kp(a, b / 2);
c = (c * c) % mod;
if (b & 1) c = (c * a) % mod;
return c;
}
long long c(long long x, long long y) {
if (x < y) return 0;
long long ans = 1;
for (long long i = 0; i < y; i++) ans = (ans * (x - i)) % mod;
ans = (ans * inv[y]) % mod;
return ans;
}
long long find(int x, int y, int z) {
if (bo[x][y][z]) return f[x][y][z];
if (z <= 0) return 0;
bo[x][y][z] = 1;
f[x][y][z] = find(x, y, z - 1);
for (int i = 1; i <= min(x / z, y); i++)
if (z != 1)
f[x][y][z] = (f[x][y][z] + find(x - i * z, y - i, z - 1) *
c(find(z, m - 1, z - 1) + i - 1, i)) %
mod;
else
f[x][y][z] = (f[x][y][z] + find(x - i * z, y - i, z - 1)) % mod;
return f[x][y][z];
}
int main() {
scanf("%d%d%lld", &n, &m, &mod);
for (int i = 0; i <= n; i++) bo[1][0][i] = f[1][0][i] = 1;
fac[0] = inv[0] = 1;
for (long long i = 1; i <= 15; i++) fac[i] = (fac[i - 1] * i) % mod;
inv[15] = kp(fac[15], mod - 2);
for (long long i = 14; i; i--) inv[i] = (inv[i + 1] * (i + 1)) % mod;
if (n <= 2)
puts("1");
else {
if (n & 1)
printf("%lld", find(n, m, n >> 1));
else
printf("%lld", (find(n, m, n >> 1) -
c(find(n >> 1, m - 1, (n >> 1) - 1), 2) + mod) %
mod);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, D, MOD, inv[11], f[1010][11], tmp[11];
namespace {
int Add(int x, int y) { return (x += y) >= MOD ? x - MOD : x; }
int Mul(int x, int y) { return 1LL * x * y % MOD; }
} // namespace
int main(void) {
scanf("%d%d%d", &n, &D, &MOD);
inv[1] = 1;
for (int i = 2; i <= D; i++) inv[i] = Mul(inv[MOD % i], Add(MOD, -MOD / i));
f[1][0] = f[1][D - 1] = 1;
for (int k = 1; k <= n / 2; k++) {
if (f[k][D - 1]) {
int x = f[k][D - 1];
tmp[0] = 1;
for (int i = 1; i <= D; i++)
tmp[i] = Mul(tmp[i - 1], Mul(inv[i], (i + x - 1)));
for (int i = n - k; i >= 0; i--)
for (int j = 0; j < D; j++)
if (f[i][j])
for (int p = 1; i + p * k <= n && j + p <= D; p++)
f[i + p * k][j + p] =
Add(f[i + p * k][j + p], Mul(f[i][j], tmp[p]));
}
}
int Ans = Add(f[n][0], f[n][D]);
if (~n & 1) {
int x = f[n / 2][D - 1];
Ans = Add(Ans, MOD - Mul(Mul(x, x - 1), inv[2]));
}
cout << Ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
int n, d;
long long p;
long long ifac[1010], f[1010][15][1010];
long long inv(long long x) {
long long y = p - 2, v = 1;
while (y) {
if (y & 1) v = v * x % p;
x = x * x % p, y >>= 1;
}
return v;
}
long long C(int n, int m) {
long long v = ifac[m];
while (m--) v = v * (n--) % p;
return v;
}
void init() {
ifac[0] = 1;
for (int i = 1; i <= d; ++i) ifac[i] = ifac[i - 1] * i % p;
ifac[d] = inv(ifac[d]);
for (int i = d - 1; i; --i) ifac[i] = ifac[i + 1] * (i + 1) % p;
}
int main() {
read(n), read(d), read(p), init();
if (n <= 2) {
puts("1");
return 0;
}
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 * k <= i && t <= j; ++t) {
if (k == 1)
f[i][j][k] = (f[i][j][k] + f[i - t * k][j - t][k - 1]) % p;
else
f[i][j][k] =
(f[i][j][k] + f[i - t * k][j - t][k - 1] *
C(f[k][d - 1][k - 1] + t - 1, t) % p) %
p;
}
}
}
}
printf("%lld", (f[n][d][n / 2] -
((n & 1) ? 0 : C(f[n / 2][d - 1][n / 2 - 1], 2)) + p) %
p);
return 0;
}
|
#include <bits/stdc++.h>
using std::max;
using std::min;
const int MAX_N = 1000 + 3, MAX_D = 10 + 3;
int n, d, modu, dp[MAX_N][MAX_D][MAX_N];
int inv[MAX_N];
inline long long mod_pow(long long a, int b) {
long long res = 1;
while (b) {
if (b & 1) (res *= a) %= modu;
(a *= a) %= modu;
b >>= 1;
}
return res;
}
int main() {
scanf("%d%d%d", &n, &d, &modu);
if (n <= 2) return puts("1"), 0;
for (int i = 1; i < n; ++i) inv[i] = mod_pow(i, modu - 2);
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; ++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) {
c = (long long)c * (++r) % modu * inv[t] % modu;
(dp[i][j][k] +=
(long long)dp[i - t * k][j - t][min(k - 1, i - t * k - 1)] * c %
modu) %= modu;
}
}
long long ans = dp[n][d][(n + 1) / 2 - 1];
if (n % 2 == 0)
ans += (long long)(dp[n / 2][d - 1][n / 2 - 1]) *
(dp[n / 2][d - 1][n / 2 - 1] + 1) / 2;
ans %= modu;
std::cout << ans << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, mod, f[1025][1025][11];
int inv[1025], v[1025];
long long power(long long a, long long b) {
if (!b) return 1;
if (b & 1) return power(a, b ^ 1) * a % mod;
long long t = power(a, b >> 1);
return t * t % mod;
}
inline void update(int& a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
cin >> n >> d >> mod;
if (n <= 2)
cout << 1 << endl;
else {
for (register int i = 1; i <= 1000; i++) inv[i] = power(i, mod - 2);
v[1] = f[0][0][0] = 1;
for (register int i = 0; i <= d; i++) f[1][i][i] = 1;
for (register int i = 2; i * 2 <= n; i++) {
v[i] = f[i - 1][i - 1][d - 1];
for (register int j = 0; j <= d; j++)
for (register int k = 0; k <= n; k++)
if (f[i - 1][k][j]) {
int res = f[i - 1][k][j];
for (int x = 0; res && x * i <= n - k && x <= d - j; x++) {
update(f[i][k + x * i][x + j], res);
res = res * 1ll * (v[i] + x) % mod * inv[x + 1] % mod;
}
}
}
if (n & 1)
cout << f[n >> 1][n - 1][d] << endl;
else
cout << (f[(n >> 1) - 1][n - 1][d] +
1ll * (v[n >> 1] + 1) * v[n >> 1] % mod * inv[2] % mod) %
mod
<< endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
int n, d, mod;
long long f[N][12][N >> 1], inv[N];
void add(long long &x, long long y) { x = (x + y) % mod; }
void prework(int n) {
inv[0] = 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] = inv[i - 1] * inv[i] % mod;
}
long long C(long long n, long long m) {
if (n < m) return 0;
long long ret = 1;
for (int i = n - m + 1; i <= n; i++) ret = ret * i % mod;
return ret * inv[m] % mod;
}
int main() {
cin >> n >> d >> mod;
if (n <= 2) return puts("1"), 0;
prework(N - 10);
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 <= min(i / k, j); t++)
add(f[i][j][k], f[i - t * k][j - t][k - 1] *
C(f[k][d - 1][k - 1] + t - 1, t) % mod);
}
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) + mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void in(T &x) {
x = 0;
short f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + (c ^ '0'), c = getchar();
x *= f;
}
template <class T>
inline void out(T x, const char c = '\n') {
static short st[30];
short m = 0;
if (x < 0) putchar('-'), x = -x;
do st[++m] = x % 10, x /= 10;
while (x);
while (m) putchar(st[m--] | '0');
putchar(c);
}
template <class T, class... Args>
inline void in(T &x, Args &...args) {
in(x);
in(args...);
}
template <class T, class... Args>
inline void out(const T &x, const Args &...args) {
out(x, ' ');
out(args...);
}
template <class T>
inline void prt(T a[], int n) {
for (register int i = 0; i < n; ++i) out(a[i], ' ');
putchar('\n');
}
template <class T>
inline void clr(T a[], int n) {
memset(a, 0, sizeof(T) * n);
}
template <class T>
inline void clr(T *a, T *b) {
memset(a, 0, sizeof(T) * (b - a));
}
template <class T>
inline bool ckmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
inline bool ckmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
namespace MOD_CALC {
int md;
inline int add(const int a, const int b) {
return a + b >= md ? a + b - md : a + b;
}
inline int sub(const int a, const int b) {
return a - b < 0 ? a - b + md : a - b;
}
inline int mul(const int a, const int b) { return (long long)a * b % md; }
inline void inc(int &a, const int b) { (a += b) >= md ? a -= md : 0; }
inline void dec(int &a, const int b) { (a -= b) < 0 ? a += md : 0; }
inline int qpow(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = mul(a, a))
if (b & 1) r = mul(r, a);
return r;
}
inline int mdinv(const int a) { return qpow(a, md - 2); }
} // namespace MOD_CALC
using namespace MOD_CALC;
namespace i207M {
int n, d;
int f[1005][11][1005];
int g[1005][1005];
int ifac[1005];
inline int C(int n, int m) {
if (n < m) return 0;
int r = ifac[m];
for (register int i = 0; i < m; ++i) r = mul(r, n - i);
return r;
}
signed main() {
in(n, d, md);
if (n <= 2) {
out(1);
return 0;
}
ifac[0] = 1;
for (register int i = 1; i <= n; ++i) ifac[i] = mul(ifac[i - 1], mdinv(i));
f[1][0][0] = 1;
for (register int i = 1; i <= n; ++i) g[1][i] = 1;
for (register int i = 2; i <= n; ++i) {
for (register int j = 1; j <= d; ++j)
for (register int k = 1; k < i; ++k) {
int &r = f[i][j][k];
r = f[i][j][k - 1];
for (register int h = 1; h <= j && h * k < i; ++h)
inc(r, mul(f[i - h * k][j - h][min(k - 1, i - h * k - 1)], g[k][h]));
}
for (register int j = 1; j <= d; ++j)
g[i][j] = C(f[i][d - 1][i - 1] + j - 1, j);
}
int ans = f[n][d][n / 2];
if (~n & 1)
dec(ans, (long long)f[n / 2][d - 1][n / 2 - 1] *
(f[n / 2][d - 1][n / 2 - 1] - 1) / 2 % md);
out(ans);
return 0;
}
} // namespace i207M
signed main() {
i207M::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const int D = 15;
int dp[N];
int n, d, mod;
int dp2[2][N][D];
int fres = 1;
int fact[N], inv[N];
inline int fastpower(int num, int po) {
fres = 1;
while (po > 0) {
if (po & 1) fres = (long long)fres * num % mod;
po >>= 1;
num = (long long)num * num % mod;
}
return fres;
}
int gret;
inline int get(int a, int k) {
if (k == 0) return 1;
gret = 1;
for (int i = a + k - 1; i >= a; i--) gret = (long long)gret * i % mod;
return (long long)gret * inv[k] % mod;
}
vector<int> good;
vector<vector<int> > val;
void solve(int i, int d) {
for (int j = 0; j < i; j++)
for (int e = 0; e <= d; e++) dp2[((int)good.size()) & 1][j][e] = 0;
dp2[((int)good.size()) & 1][0][0] = 1;
for (int Cur, Nxt, j = (int)good.size() - 1; j >= 0; j--) {
Cur = (j & 1);
Nxt = (Cur ^ 1);
for (int s = 0; s < i; s++) {
for (int e = 0; e <= d; e++) {
dp2[Cur][s][e] = 0;
for (int take = 0; good[j] * take <= s && take <= e; take++) {
dp2[Cur][s][e] += (long long)val[j][take] *
dp2[Nxt][s - good[j] * take][e - take] % mod;
if (dp2[Cur][s][e] >= mod) dp2[Cur][s][e] -= mod;
}
}
}
}
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n == 1 || d == 2) {
cout << 1 << endl;
return 0;
}
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = (long long)i * fact[i - 1] % mod;
inv[i] = fastpower(fact[i], mod - 2);
}
dp[1] = 1;
good.push_back(1);
val.push_back(vector<int>(d + 1, 1));
for (int i = 2; i <= n / 2; i++) {
solve(i, d - 1);
dp[i] = dp2[0][i - 1][d - 1];
if (dp[i] > 0) {
good.push_back(i);
val.push_back(vector<int>(d + 1));
for (int l = 0; l <= d; l++) {
val.back()[l] = get(dp[i], l);
}
}
}
int ans = 0;
if (n % 2 == 0) {
ans += get(dp[n / 2], 2);
}
if (good.back() * 2 == n) good.pop_back();
solve(n, d);
ans += dp2[0][n - 1][d];
if (ans >= mod) ans -= mod;
cout << ans << endl;
return 0;
}
|
#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("%lld", ans);
return 0;
}
} // namespace Miracle
signed main() {
Miracle::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
long long mod;
long long quick_mod(long long x, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = ans * x % mod;
x = x * x % mod;
n >>= 1;
}
return ans;
}
long long dp[maxn][12][maxn], inv[maxn];
int main() {
int n, d;
scanf("%d%d%lld", &n, &d, &mod);
for (int i = 1; i < maxn; i++) inv[i] = quick_mod(i, mod - 2);
dp[1][0][0] = 1, 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; k++) {
dp[i][j][k] = dp[i][j][k - 1];
long long r = dp[k][d - 1][k - 1] - 1, c = 1;
for (int t = 1; t * k < i && t <= j; t++) {
c = c * (++r) % mod * inv[t] % mod;
dp[i][j][k] +=
dp[i - t * k][j - t][min(k - 1, i - t * k - 1)] * c % mod;
dp[i][j][k] %= mod;
}
}
long long ans = dp[n][d][(n + 1) / 2 - 1];
if (n % 2 == 0) {
long long tmp = dp[n / 2][d - 1][n / 2 - 1];
ans = ans + (tmp + 1) * tmp % mod * inv[2] % mod;
}
ans %= mod;
if (n <= 2) ans = 1;
printf("%lld\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];
ans = (ans - 1ll * t * (t - 1) / 2 % mod + mod) % mod;
}
printf("%d\n", ans);
}
|
#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 ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
inline void print(int x) {
if (x < 0) putchar('-'), x = ~x + 1;
if (x >= 10) print(x / 10);
putchar((x % 10) | 48);
}
int n, d, mod;
int f[1010][15][1010];
int ifac[10010];
int C(int x, int y) {
if (x < y) return 0;
int res = 1;
for (int i = 1; i <= y; ++i) res = 1ll * res * (x - i + 1) % mod;
res = 1ll * res * ifac[y] % mod;
return res;
}
int qpow(int x, int k) {
int res = 1;
while (k) {
if (k & 1) res = 1ll * res * x % mod;
x = 1ll * x * x % mod;
k >>= 1;
}
return res;
}
int main() {
n = read(), d = read(), mod = read();
int s = 1;
for (int i = 1; i <= n; ++i) {
s = 1ll * s * i % mod;
ifac[i] = qpow(s, mod - 2);
}
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 <= j; ++t) {
if (t * k > i) break;
if (k > 1)
(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] += 1ll * f[i - t * k][j - t][k - 1] *
C(f[k][0][k - 1] + t - 1, t) % mod) %= mod;
}
}
}
}
if (n <= 2) {
printf("1\n");
return 0;
}
if (n & 1) {
printf("%d\n", f[n][d][n / 2]);
} else {
printf(
"%d\n",
(f[n][d][n / 2] - 1ll * C(f[n / 2][d - 1][n / 2 - 1], 2) + mod) % mod);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 5;
long long dp[N][11], inv[11], ans;
int n, d, Mod;
long long Pow(long long a, int x) {
long long res = 1;
while (x) {
if (x & 1) (res *= a) %= Mod;
(a *= a) %= Mod;
x >>= 1;
}
return res;
}
int main() {
scanf("%d%d%d", &n, &d, &Mod);
if (n <= 2) return puts("1");
inv[0] = 1;
for (int i = 2; i <= d; i++) inv[i] = Pow(i, Mod - 2);
dp[0][d - 1] = dp[0][0] = 1;
for (int i = 1; i <= n / 2; i++) {
for (int j = n; j >= 0; j--) {
for (int k = 0; k < d; k++) {
if (!dp[j][k]) continue;
long long tmp = dp[i - 1][d - 1], tmp1 = dp[i - 1][d - 1];
for (int l = 1; l * i + j < n && k + l <= d; l++) {
(dp[i * l + j][l + k] += tmp * dp[j][k]) %= Mod;
(tmp *= inv[l + 1] * (tmp1 + l) % Mod) %= Mod;
}
}
}
}
ans = (dp[n - 1][d] + Mod) % Mod;
if (~n & 1)
(ans -=
dp[n / 2 - 1][d - 1] * (dp[n / 2 - 1][d - 1] - 1) % Mod * inv[2] % Mod -
Mod) %= Mod;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace my_std {
const long long inf = 0x3f3f3f3f;
const long long inff = 1e15;
inline long long read() {
long long sum = 0, f = 1;
char ch = 0;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
sum = (sum << 1) + (sum << 3) + (ch ^ 48);
ch = getchar();
}
return sum * f;
}
inline void write(long long x) {
if (x < 0) {
x = -x;
putchar('-');
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
putchar('\n');
}
inline void writesp(long long x) {
write(x);
putchar(' ');
}
} // namespace my_std
using namespace my_std;
const long long N = 1050;
long long n, d, mod, f[N][20][N], inv[20], mul[20];
inline long long ksmod(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = (ans * a) % mod;
}
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
inline long long C(long long n, long long m, long long ans = 1) {
if (m > n || m < 0 || n < 0) return 0;
for (register long long i = (1); i <= (m); i++) ans = ans * (n - i + 1) % mod;
ans = ans * inv[m] % mod;
return ans;
}
inline void init() {
mul[0] = inv[0] = 1;
for (long long i = 1; i <= 10; i++) mul[i] = (mul[i - 1] * i) % mod;
inv[10] = ksmod(mul[10], mod - 2);
for (long long i = 10 - 1; i; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
}
int main(void) {
n = read(), d = read(), mod = read();
if (n == 1 || n == 2) {
puts("1");
return 0;
}
init();
for (register long long i = (0); i <= (n); i++) f[1][0][i] = 1;
for (register long long i = (2); i <= (n); i++)
for (long long j = 1; j < i && j <= d; j++)
for (register long long k = (1); k <= (n); k++) {
f[i][j][k] = f[i][j][k - 1];
for (long long t = 1; t * k < i && t <= j; t++) {
if (k != 1)
f[i][j][k] =
(f[i][j][k] + 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] + f[i - t * k][j - t][k - 1] *
C(f[k][0][k - 1] + t - 1, t) % mod) %
mod;
}
}
long long ans = f[n][d][n / 2];
if (!(n & 1)) ans = (ans - C(f[n / 2][d - 1][n / 2], 2) + mod) % mod;
writeln(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1111;
const int M = 12;
int n, d, mod, f[N], g[N];
int qpow(int x, int y) {
int res = 1;
for (; y; x = 1ll * x * x % mod, y >>= 1)
if (y & 1) res = 1ll * res * x % mod;
return res;
}
int ny(int x) { return qpow(x, mod - 2); }
int dp[M][N], ans;
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) return puts("1"), 0;
dp[0][0] = 1;
for (int i = (1), iE = (n / 2); i <= iE; i++) {
if (i == 1)
f[i] = 1;
else
f[i] = dp[d - 1][i - 1];
g[0] = 1;
for (int t = (1), tE = (d); t <= tE; t++)
g[t] = 1ll * g[t - 1] * (f[i] + t - 1) % mod * ny(t) % mod;
for (int t = (d), tE = (1); t >= tE; t--)
for (int p = (1), pE = (t); p <= pE; p++)
for (int j = (i * p), jE = (n); j <= jE; j++)
(dp[t][j] += 1ll * g[p] * dp[t - p][j - i * p] % mod) %= mod;
}
int ans = dp[d][n - 1];
if (n % 2 == 0)
(ans += mod - 1ll * dp[d - 1][n / 2 - 1] * (dp[d - 1][n / 2 - 1] - 1) / 2 %
mod) %= mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
int mod;
template <class T>
T fexp(T x, int e) {
T ans(1);
for (; e > 0; e /= 2) {
if (e & 1) ans = ans * x;
x = x * x;
}
return ans;
}
struct modBase {
modBase(int v = 0) : val((v % mod + mod) % mod) {}
int val;
modBase operator*(modBase o) { return (long long)val * o.val % mod; }
modBase operator/(modBase o) { return *this * fexp(o, mod - 2); }
modBase operator+(modBase o) { return modBase((val + o.val) % mod); }
};
int d;
const int ms = 1010;
modBase ifat[ms];
bool visit[ms][ms][22];
modBase memo[ms][ms][22];
modBase trans(int on, int sum, int rest) {
if (rest == 0) return sum == 0 ? modBase(1) : modBase(0);
if (sum < 0 || on == 0) return modBase(0);
modBase &ans = memo[on][sum][rest];
if (visit[on][sum][rest]) return ans;
visit[on][sum][rest] = true;
ans = 0;
modBase cur(1);
modBase ha = on == 1 ? modBase(1) : trans(on - 1, on - 1, d - 1);
for (int i = 0; i <= rest && cur.val; i++) {
ans = ans + ifat[i] * cur * trans(on - 1, sum - on * i, rest - i);
cur = cur * ha;
ha = ha + 1;
}
return ans;
}
modBase haha(modBase x) { return x * (x + 1) / 2; }
modBase dp(int n) {
if (n == 1 || n == 2)
return modBase(1);
else
return trans((n - 1) / 2, n - 1, d) +
((n - 2) % 2 == 0 ? haha(trans(n / 2 - 1, n / 2 - 1, d - 1))
: modBase(0));
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n;
std::cin >> n >> d >> mod;
ifat[0] = 1;
for (int i = 1; i < ms; i++) {
ifat[i] = ifat[i - 1] * fexp(modBase(i), mod - 2);
}
std::cout << dp(n).val % mod << '\n';
}
|
#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; 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;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int MAXN = 1005;
const int INF = 0x3f3f3f3f;
inline int read() {
int f = 1, x = 0;
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 ^ 48);
c = getchar();
}
return x * f;
}
int fac[MAXN], inv[MAXN], n, d, mods;
int upd(int x, int y) { return x + y >= mods ? x + y - mods : x + y; }
int quick_pow(int x, int y) {
int ret = 1;
for (; y; y >>= 1) {
if (y & 1) ret = 1ll * ret * x % mods;
x = 1ll * x * x % mods;
}
return ret;
}
int C(int x, int y) {
if (x < y) return 0;
int ans = 1;
for (int i = 1; i <= y; i++)
ans = 1ll * ans * (x - i + 1) % mods * inv[i] % mods;
return ans;
}
void Init(int n) {
for (int i = 0; i <= n; i++) inv[i] = quick_pow(i, mods - 2);
}
int f[MAXN][11][MAXN];
signed main() {
n = read(), d = read(), mods = read(), Init(d);
if (n <= 2) {
puts("1\n");
return 0;
}
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= d; j++)
for (int p = 1; p <= n; p++) {
f[i][j][p] = f[i][j][p - 1];
for (int k = 1; k <= j && k * p < i; k++)
f[i][j][p] =
upd(f[i][j][p],
1ll * f[i - k * p][j - k][p - 1] *
C(f[p][(p == 1 ? 0 : d - 1)][p - 1] + k - 1, k) % mods);
}
if (n & 1)
printf("%d\n", f[n][d][n / 2]);
else
printf("%d\n", upd(f[n][d][n / 2], mods - C(f[n / 2][d - 1][n / 2], 2)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1005, M = 20;
long long n, d, Mod, ans = 0;
long long dp[N][M][N], f[M], g[M];
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long Power(long long base, long long power, long long Mod) {
long long result = 1;
while (power > 0) {
if (power & 1) result = result * base % Mod;
power >>= 1;
base = (base * base) % Mod;
}
return result;
}
inline 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] = Power(f[n], Mod - 2, Mod);
for (long long i = n - 1; i; i--) g[i] = g[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 = 1; i <= m; i++) ans = ans * (n - i + 1) % Mod;
return ans * g[m] % Mod;
}
signed main() {
n = read(), d = read(), Mod = read();
Init();
if (n <= 2) {
printf("1\n");
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\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
long long n, d, mod, dp[maxn][11], pd[maxn][11], t[11];
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[0][0] = 1;
for (int i = 1; i <= n / 2; ++i)
if ((i - 1) % (d - 1) == 0) {
long long f = (i == 1) ? 1 : dp[i - 1][d - 1];
for (int j = 0; j < n; ++j) memset(pd[j], 0, (d + 1) * sizeof pd[0][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 = 0; l < n; ++l)
if (l + k * i < n)
pd[l + k * i][j + k] =
(pd[l + k * i][j + k] + dp[l][j] * t[k]) % mod;
for (int j = 0; j < n; ++j)
memcpy(dp[j], pd[j], (d + 1) * sizeof pd[0][0]);
}
long long 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;
return ret < 0 ? ret + mod : ret;
}
int main() {
cin >> n >> d >> mod;
cout << ((n <= 2) ? 1 : solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, d, p;
long long fac[1005], ifac[1005];
long long f[1005][15][1005];
inline long long fastPow(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1, a = a * a % p)
if (b & 1) ans = ans * a % p;
return ans;
}
inline long long C(long long x, long long y) {
if (x < y) return 0;
long long ans = 1;
for (long long i = x; i >= x - y + 1; i--) ans = ans * i % p;
return ans * ifac[y] % p;
}
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
if (ch == -1) return 0;
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
signed main() {
n = read(), d = read(), p = read(), fac[0] = ifac[0] = 1;
if (n <= 2) {
puts("1");
return 0;
}
for (long long i = 1; i <= d; i++)
fac[i] = fac[i - 1] * i % p, ifac[i] = fastPow(fac[i], p - 2);
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 l = 1; l <= j; l++)
if (i - k * l >= 0 && j - l >= 0 && k - 1 >= 0)
if (k > 1)
f[i][j][k] =
(f[i][j][k] + f[i - k * l][j - l][k - 1] *
C(f[k][d - 1][k - 1] + l - 1, l) % p) %
p;
else
f[i][j][k] = (f[i][j][k] + f[i - k * l][j - l][k - 1] *
C(f[k][0][k - 1] + l - 1, l) % p) %
p;
}
cout << ((n & 1)
? f[n][d][n / 2]
: (f[n][d][n / 2] - C(f[n / 2][d - 1][n / 2 - 1], 2) + p) % p)
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010, D = 15;
int i, j, k, l, n, m, d, P, ans, t;
int f[N][D], Jc[D], Jc_[D], inv[D], tmp[D];
int ksm(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;
}
void pre(int n) {
int i;
Jc[0] = Jc_[0] = 1;
for (i = 1; i <= n; i++) Jc[i] = (long long)Jc[i - 1] * i % P;
Jc_[n] = ksm(Jc[n], P - 2);
for (i = n - 1; i; i--) Jc_[i] = (long long)Jc_[i + 1] * (i + 1) % P;
for (i = 1; i <= n; i++) inv[i] = (long long)Jc_[i] * Jc[i - 1] % P;
}
int main() {
scanf("%d%d%d", &n, &d, &P);
pre(d);
f[1][0] = 1;
f[1][d - 1] = 1;
for (k = 1; k <= n / 2; k++)
if (f[k][d - 1]) {
m = f[k][d - 1];
tmp[0] = 1;
for (l = 1; l <= d; l++)
tmp[l] = (long long)tmp[l - 1] * (l + m - 1) % P * inv[l] % P;
for (i = n - k; i; i--)
for (j = 0; j < d; j++)
if (f[i][j])
for (l = 1; i + l * k <= n && j + l <= d; l++)
f[i + l * k][j + l] =
((long long)f[i][j] * tmp[l] + f[i + l * k][j + l]) % P;
}
ans = (f[n][d] + f[n][0]) % P;
if (!(n & 1)) {
t = f[n / 2][d - 1];
ans = (ans + P - (long long)t * (t - 1) / 2 % P) % P;
}
printf("%d\n", ans);
}
|
#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 - 1], 2) + mod) % mod;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int D = 15;
int n, d;
long long mod, f[N][N][D], fact[2 * N], inv[2 * N], ifact[2 * N];
int power(int a, int n) {
int result = 1;
while (n > 0) {
if (n & 1) result = (1LL * result * a) % mod;
a = (1LL * a * a) % mod;
n /= 2;
}
return result;
}
int main() {
cin >> n >> d >> mod;
if (n <= 2) {
cout << 1 << endl;
return 0;
}
fact[0] = inv[0] = ifact[0] = 1;
for (int i = 1; i < 2 * N; ++i) {
fact[i] = (fact[i - 1] * i) % mod;
inv[i] = power(i, mod - 2);
ifact[i] = (ifact[i - 1] * inv[i]) % mod;
}
for (int i = 0; i <= n; ++i) {
f[1][i][0] = 1;
if (i > 0) f[2][i][1] = 1;
}
for (int i = 3; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
for (int x = 1; x <= d; ++x) {
long long& current = f[i][j][x];
if (x > i) continue;
if (j == 1) {
if (i == x + 1) {
current = 1;
}
continue;
}
current = (current + f[i][j - 1][x]) % mod;
long long up = 1;
for (int y = 1; y <= x; ++y) {
if (i <= y * j) continue;
up = (up * (f[j][j][d - 1] + y - 1)) % mod;
current =
(current + f[i - y * j][j - 1][x - y] * up % mod * ifact[y]) %
mod;
}
}
}
}
long long result = f[n][(n - 1) / 2][d];
if (n % 2 == 0) {
long long current;
current = f[n / 2][n / 2 - 1][d - 1];
current = (1LL * current * (current + 1) % mod * inv[2]) % mod;
result = (result + current) % mod;
}
cout << result << endl;
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
inline bool MIN(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool MAX(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
using namespace std;
int n, d, mod;
int inv[1010];
int f[1010][1010][12], g[1010][1010];
int get_C(int m, int n) {
if (n > m) return 0;
int res = 1;
for (int i = m; i > m - n; --i) res = (long long)res * i % mod;
return (long long)res * inv[n] % mod;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) {
printf("1\n");
return 0;
}
inv[0] = inv[1] = 1;
for (int i = 2; i < 1010; ++i)
inv[i] = (long long)inv[mod % i] * (mod - mod / i) % mod;
for (int i = 2; i < 1010; ++i) inv[i] = (long long)inv[i] * inv[i - 1] % mod;
f[1][0][0] = f[1][0][d - 1] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < i; ++j) {
for (int k = 1; k <= d; ++k) {
f[i][j][k] = f[i][j - 1][k];
for (int c = 1; c <= k && i - c * j > 0; ++c) {
(f[i][j][k] +=
(long long)f[i - c * j][min(j - 1, i - c * j - 1)][k - c] * g[j][c] %
mod) %= mod;
}
}
}
for (int c = 1; c <= d; ++c) {
g[i][c] = get_C(f[i][i - 1][d - 1] + c - 1, c);
}
}
int ans = f[n][(n + 1) / 2 - 1][d];
if (!(n & 1))
(ans += (long long)f[n / 2][n / 2 - 1][d - 1] *
(f[n / 2][n / 2 - 1][d - 1] + 1) % mod * inv[2] % mod) %= mod;
printf("%d\n", ans);
return 0;
}
|
#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 j = 0; j <= d; j++) {
for (int k = 0; k <= n / 2; k++) {
f[1][j][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 (i == t * k + 1 && j != t) {
continue;
}
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;
const long long maxn = 1e3 + 7;
const long long maxm = 20;
long long read() {
long long res = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') f = -1, c = getchar();
while (isdigit(c)) res = (res << 1) + (res << 3) + c - 48, c = getchar();
return res * f;
}
long long n, d, mod;
long long f[maxn][maxm][maxn];
long long pow(long long x, long long n, long long mod) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long F[maxn], g[maxn];
long long C(long long n, long long m) {
if (n < m) return 0;
int ans = 1;
for (int i = 1; i <= m; i++) ans = ans * (n - i + 1) % mod;
return ans * g[m] % mod;
}
void init() {
int n = 10;
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, mod);
for (int i = n - 1; i; i--) g[i] = g[i + 1] * (i + 1) % mod;
}
int main() {
n = read(), d = read(), mod = read();
init();
if (n <= 2) {
puts("1");
return 0;
}
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(i - 1, d); j++) {
for (long long k = 1; k <= n; k++) {
f[i][j][k] = f[i][j][k - 1];
for (long long t = 1; i - t * k > 0 && j - t >= 0; t++) {
if (k != 1)
f[i][j][k] =
(f[i][j][k] + 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] + f[i - t * k][j - t][k - 1] *
C(f[k][0][k - 1] + t - 1, t) % mod) %
mod;
}
}
}
}
long long ans = f[n][d][n / 2];
if (!(n & 1)) ans = (ans - 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 void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void readc(char &x) {
char c;
while (((c = getchar()) == ' ') || c == '\n')
;
x = c;
}
int mod;
int n, d, i, j, k, p, f[1005][505][11], fac[1005], inv[1005], first[1005];
int c(int x, int y) {
int s = 1, i;
for (((i)) = (1); ((i)) <= ((y)); ((i))++) {
s = 1ll * s * (x - i + 1) % mod * inv[i] % mod;
}
return s;
}
int main() {
read(n);
read(d);
read(mod);
fac[0] = fac[1] = first[0] = first[1] = inv[1] = 1;
for ((i) = (2); (i) <= (1000); (i)++) {
fac[i] = 1ll * fac[i - 1] * i % mod;
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
first[i] = 1ll * first[i - 1] * inv[i] % mod;
}
if (n <= 2) {
puts("1");
return 0;
}
for ((i) = (0); (i) <= (n / 2); (i)++) {
f[1][i][0] = 1;
}
f[1][0][d - 1] = 1;
for ((i) = (2); (i) <= (n); (i)++) {
for (((j)) = (1); ((j)) <= ((n / 2)); ((j))++) {
for (((k)) = (1); ((k)) <= ((min(i - 1, d))); ((k))++) {
f[i][j][k] = f[i][j - 1][k];
for (p = 1; p * j <= i && p <= k; p++) {
f[i][j][k] = (f[i][j][k] + 1ll * f[i - p * j][j - 1][k - p] *
c(f[j][j - 1][d - 1] + p - 1, p)) %
mod;
}
}
}
}
if (n & 1) {
cout << f[n][n / 2][d] << endl;
} else {
cout << (f[n][n / 2][d] - c(f[n / 2][n / 2 - 1][d - 1], 2) + mod) % mod
<< endl;
}
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) memset(pd[j], 0, sizeof dp[j]);
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) memcpy(dp[j], pd[j], sizeof dp[j]);
}
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;
bool home = 1;
signed realMain();
signed main() {
home = 0;
if (home) {
freopen("tony_stark", "r", stdin);
} else {
ios::sync_with_stdio(0);
cin.tie(0);
}
realMain();
}
long long mod;
long long add(long long a, long long b) {
a += b;
if (a >= mod) return a - mod;
if (a < 0) return a + mod;
return a;
}
long long mul(long long a, long long b) { return a * (long long)b % mod; }
long long pw(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) r = mul(r, a);
a = mul(a, a);
b /= 2;
}
return r;
}
long long dv(long long a, long long b) { return mul(a, pw(b, mod - 2)); }
void baga(long long &a, long long x) { a = add(a, x); }
const long long N = 1234 + 7;
const long long D = 10 + 7;
long long fact[N], ifact[N], dp[N][D][N];
long long comb(long long n, long long k) {
assert(k < D);
long long ret = ifact[k];
for (long long i = n - k + 1; i <= n; i++) ret = mul(ret, i);
return ret;
}
signed realMain() {
long long n, wanda;
cin >> n >> wanda >> mod;
if (n <= 2) {
cout << "1\n";
return 0;
}
fact[0] = 1;
for (long long i = 1; i < N; i++) fact[i] = mul(fact[i - 1], i);
ifact[N - 1] = dv(1, fact[N - 1]);
for (long long i = N - 2; i >= 0; i--) ifact[i] = mul(ifact[i + 1], i + 1);
{ dp[1][0][0] = dp[1][wanda - 1][0] = 1; }
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j <= wanda; j++) {
for (long long k = 1; k <= n; k++) {
baga(dp[i][j][k], dp[i][j][k - 1]);
for (long long t = 1; t <= j && t * k <= i; t++) {
baga(dp[i][j][k], mul(dp[i - t * k][j - t][k - 1],
comb(dp[k][wanda - 1][k - 1] + t - 1, t)));
}
}
}
}
long long ret = dp[n][wanda][(n - 1) / 2];
if (n % 2 == 0) {
ret = add(ret, comb(dp[n / 2][wanda - 1][n / 2 - 1] + 1, 2));
}
cout << ret << "\n";
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;
}
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 main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> d >> mod;
dp[0][0][0] = 1;
for (int i = 1; i < 1002; i++)
for (int j = 0; j <= d; j++)
cs[0][j][i] = (cs[0][j][i - 1] + dp[0][j][i - 1]) % mod;
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; l++) {
f = f * ((k == 1 ? 1 : cs[k - 1][d - 1][k]) + l - 1) % mod *
inv(l, mod) % mod;
addm(dp[i][j][k], (long long)cs[i - l * k][j - l][k] * f % mod);
}
cs[i][j][k + 1] = (cs[i][j][k] + dp[i][j][k]) % mod;
}
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;
int N, D, mod;
int exp(int x, int n) {
int ret = 1;
while (n) {
if (n & 1) ret = 1LL * ret * x % mod;
x = 1LL * x * x % mod;
n >>= 1;
}
return ret;
}
int inv(int x) { return exp(x, mod - 2); }
int fact[12], invf[12];
int dp1(int n);
int cc2[1010][1010][12];
int dp2(int n, int k, int d) {
if (n == 0 && d == 0) return 1;
if (k == 0) return 0;
int &ret = cc2[n][k][d];
if (ret != -1) return ret;
ret = 0;
int tmp = 1;
for (int i = 0; i <= min(d, n / k); i++) {
ret += 1LL * tmp * invf[i] % mod * dp2(n - k * i, k - 1, d - i) % mod;
ret %= mod;
tmp = 1LL * tmp * (dp1(k) + i) % mod;
}
return ret;
}
int cc1[1010];
int dp1(int n) {
int &ret = cc1[n];
if (ret != -1) return ret;
if (n == 0) return ret = 0;
if (n == 1) return ret = 1;
return ret = dp2(n - 1, n - 1, D - 1);
}
int main() {
cin >> N >> D >> mod;
fact[0] = 1;
for (int i = 1; i < 12; i++) {
fact[i] = 1LL * fact[i - 1] * i % mod;
}
for (int i = 0; i < 12; i++) {
invf[i] = inv(fact[i]);
}
if (N == 1) {
printf("1");
return 0;
}
memset(cc1, -1, sizeof(cc1));
memset(cc2, -1, sizeof(cc2));
if (N % 2)
printf("%d", dp2(N - 1, (N - 1) / 2, D));
else {
int ans = dp2(N - 1, (N - 1) / 2, D);
ans += 1LL * (dp1(N / 2) + 1) * dp1(N / 2) / 2 % mod;
ans %= mod;
printf("%d", ans);
}
}
|
#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 <= i; 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;
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[0][0] = 1;
for (i = 1; i <= (n >> 1); i++) {
for (j = n - i; j >= 0; 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][d - 1];
}
ans = f[n - 1][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 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;
const int N = 400000;
int a[N], t[N], type[N], us[N];
int main() {
ios::sync_with_stdio(0);
int n, w, k;
cin >> n >> w >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> t[i];
}
int r = -1;
int curr_time = 0;
int earn = 0;
set<pair<int, int> > half, full;
int ans = 0;
for (int i = 0; i < n; i++) {
r = max(r, i - 1);
while (r < n - 1) {
r++;
int temp = curr_time;
vector<pair<int, int> > pers_full, pers_half, pers_type;
half.insert(make_pair(t[r], r));
pers_half.push_back(make_pair(+1, r));
pers_type.push_back(make_pair(r, type[r]));
type[r] = 0;
curr_time += (t[r] + 1) / 2;
if (half.size() > w) {
auto p = *half.begin();
curr_time -= (p.first + 1) / 2;
half.erase(half.find(p));
pers_half.push_back(make_pair(-1, p.second));
curr_time += p.first;
full.insert(p);
pers_full.push_back(make_pair(+1, p.second));
pers_type.push_back(make_pair(p.second, type[p.second]));
type[p.second] = 1;
}
if (curr_time > k) {
while (pers_full.size()) {
auto p = pers_full.back();
pers_full.pop_back();
if (p.first == -1)
full.insert(make_pair(t[p.second], p.second));
else
full.erase(make_pair(t[p.second], p.second));
}
while (pers_half.size()) {
auto p = pers_half.back();
pers_half.pop_back();
if (p.first == -1)
half.insert(make_pair(t[p.second], p.second));
else
half.erase(make_pair(t[p.second], p.second));
}
while (pers_type.size()) {
auto p = pers_type.back();
pers_type.pop_back();
type[p.first] = p.second;
}
curr_time = temp;
r--;
break;
} else {
earn += a[r];
us[r] = 1;
}
}
ans = max(earn, ans);
if (us[i] == 1) {
if (type[i] == 0) {
half.erase(make_pair(t[i], i));
curr_time -= (t[i] + 1) / 2;
} else {
full.erase(make_pair(t[i], i));
curr_time -= t[i];
}
earn -= a[i];
us[i] = 0;
while (full.size() && half.size() < w) {
auto p = *full.rbegin();
full.erase(full.find(p));
half.insert(p);
curr_time -= p.first;
curr_time += (p.first + 1) / 2;
type[p.second] = 0;
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
const int inf = 1e9;
int p[MAXN], t[MAXN];
int n, w, k, l = 0, r = 0, t0 = 0, ans = 0, s = 0;
multiset<int> a;
multiset<int> b;
multiset<int>::iterator iter;
long long int max(long long int a, long long int b) {
if (a > b)
return a;
else
return b;
}
void init() {
scanf("%d %d %d", &n, &w, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &t[i]);
}
}
void solve() {
while (r < n) {
a.insert(t[r]);
t0 += (t[r] + 1) / 2;
if (a.size() > w) {
b.insert(*(a.begin()));
t0 += *(a.begin()) / 2;
a.erase(a.begin());
}
s += p[r++];
while (l <= r && t0 > k) {
if (t[l] >= *(a.begin())) {
a.erase(a.find(t[l]));
t0 -= (t[l] + 1) / 2;
if (b.size()) {
iter = b.end();
iter--;
a.insert(*iter);
t0 -= *iter / 2;
b.erase(iter);
}
} else {
b.erase(b.find(t[l]));
t0 -= t[l];
}
s -= p[l++];
}
ans = max(ans, s);
}
}
int main() {
init();
solve();
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int w, n, k, a[200001], t[200001], pr[200001];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> w >> k;
for (long long int i = 1; i <= n; ++i) cin >> t[i], pr[i] = pr[i - 1] + t[i];
for (long long int i = 1; i <= n; ++i) cin >> a[i];
set<pair<long long int, long long int> > ms, ms2;
long long int cur = 0, ps = 1;
vector<pair<long long int, long long int> > ans;
for (long long int i = 1; i <= n; ++i) {
if (!ms.empty() && ms.find(make_pair(a[i - 1], i - 1)) != ms.end()) {
if (ms.size() < w) {
cur -= ((a[i - 1] + 1) / 2);
ms.erase(make_pair(a[i - 1], i - 1));
} else {
cur -= ((a[i - 1] + 1) / 2);
ms.erase(make_pair(a[i - 1], i - 1));
if (!ms2.empty()) {
auto it = ms2.end();
it--;
pair<long long int, long long int> pt = *it;
cur += ((pt.first + 1) / 2);
cur -= pt.first;
ms.insert(pt);
ms2.erase(it);
}
}
} else {
ms2.erase(make_pair(a[i - 1], i - 1));
cur -= a[i - 1];
}
bool fl = 0;
while (ps <= n) {
if (ms.empty() || ms.size() < w) {
if (cur + (a[ps] + 1) / 2 <= k) {
cur += ((a[ps] + 1) / 2);
ms.insert(make_pair(a[ps], ps));
ps++;
} else
fl = 1;
} else {
auto it = ms.begin();
if (a[ps] <= (*it).first) {
if (cur + a[ps] <= k) {
cur += a[ps];
ms2.insert(make_pair(a[ps], ps));
ps++;
} else
fl = 1;
} else {
pair<long long int, long long int> temp = (*it);
long long int v = (*it).first;
if (cur + (a[ps] + 1) / 2 + v - (v + 1) / 2 <= k) {
cur = cur + (a[ps] + 1) / 2 + v - (v + 1) / 2;
ms.insert(make_pair(a[ps], ps));
ms.erase(ms.begin());
ms2.insert(temp);
ps++;
} else
fl = 1;
}
}
if (fl) break;
}
ans.push_back(make_pair(i, ps - 1));
}
long long int fans = 0;
for (pair<long long int, long long int> xp : ans)
fans = max(fans, pr[xp.second] - pr[xp.first - 1]);
cout << fans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 2e5 + 20;
int n, w, k, a[N], t[N], part[N], p = -1, ans, sum1, sum2;
multiset<int> s1, s2;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> w >> k;
for (int i = 0; i < n; i++) cin >> a[i], part[i + 1] = part[i] + a[i];
for (int i = 0; i < n; i++) cin >> t[i];
for (int i = 0; i < n; i++) {
p = max(p, i - 1);
while (p < n && sum1 - sum2 <= k) {
p++;
sum1 += t[p];
if ((int)s1.size() == w && t[p] / 2 <= *s1.begin())
s2.insert(t[p] / 2);
else {
s1.insert(t[p] / 2);
sum2 += t[p] / 2;
if ((int)s1.size() > w) {
int val = *s1.begin();
sum2 -= val;
s2.insert(val);
s1.erase(s1.begin());
}
}
}
ans = max(ans, part[p] - part[i]);
if (p <= i) continue;
{
sum1 -= t[i];
if (s2.find(t[i] / 2) != s2.end())
s2.erase(s2.find(t[i] / 2));
else {
sum2 -= t[i] / 2;
s1.erase(s1.find(t[i] / 2));
if ((int)s2.size()) {
int val = *s2.rbegin();
sum2 += val, s1.insert(val), s2.erase(s2.find(val));
}
}
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int a[MAXN], t[MAXN];
multiset<int> full, part;
int main() {
int n, w, k;
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] += a[i - 1];
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
int res = 0;
for (int l = 1, r = 0; l <= n; l++) {
while (k >= 0 && r <= n)
if ((++r) <= n) {
k -= (t[r] + 1) / 2;
part.insert(t[r]);
while ((int)part.size() > w) {
k += (*part.begin() + 1) / 2;
k -= *part.begin();
full.insert(*part.begin());
part.erase(part.begin());
}
}
res = max(res, a[r - 1] - a[l - 1]);
if (full.find(t[l]) != full.end()) {
full.erase(full.find(t[l]));
k += t[l];
} else {
part.erase(part.find(t[l]));
k += (t[l] + 1) / 2;
while ((int)part.size() < w && !full.empty()) {
k += *(--full.end());
k -= (*(--full.end()) + 1) / 2;
part.insert(*(--full.end()));
full.erase(--full.end());
}
}
}
return 0 * printf("%d", res);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200005], t[200005];
multiset<int> min_set, max_set;
int main() {
int n, total_time, w, ans = 0, temp_ans = 0, priv_range_time = 0, curr_time;
cin >> n >> w >> total_time;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> t[i];
for (int start = 0, end = 0; start < n; start++) {
curr_time = priv_range_time;
while (end < n) {
if (min_set.size() < w)
curr_time += (t[end] + 1) >> 1;
else if (t[end] > (*min_set.begin()))
curr_time += ((t[end] + 1) >> 1) + ((*min_set.begin()) >> 1);
else
curr_time += t[end];
if (curr_time > total_time) {
ans = max(ans, temp_ans);
break;
}
if (min_set.size() < w)
min_set.insert(t[end]);
else if (t[end] > (*min_set.begin())) {
max_set.insert(*min_set.begin());
min_set.erase(min_set.begin());
min_set.insert(t[end]);
} else
max_set.insert(t[end]);
temp_ans += a[end];
priv_range_time = curr_time;
end++;
}
if (end <= start) {
end = start + 1;
continue;
}
if (end == n) {
ans = max(ans, temp_ans);
break;
}
if (t[start] < (*min_set.begin())) {
max_set.erase(max_set.find(t[start]));
priv_range_time -= t[start];
} else {
min_set.erase(min_set.find(t[start]));
priv_range_time -= (t[start] + 1) >> 1;
if (max_set.size()) {
auto it = max_set.end();
it--;
min_set.insert(*it);
priv_range_time -= ((*it) >> 1);
max_set.erase(it);
}
}
temp_ans -= a[start];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct classcomp {
bool operator()(const pair<int, int>& a, const pair<int, int>& b) const {
if (a.first == b.first) a.second < b.second;
return a.first > b.first;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, w, k;
cin >> n >> w >> k;
vector<int> p(n), t(n);
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < n; i++) cin >> t[i];
set<pair<int, int> > half;
set<pair<int, int> > full;
int i = 0, j = 0;
long long int ans = 0;
long long int curr = 0;
int now = 0;
int many = w;
while (j < n) {
while (now <= k) {
if (j >= n) break;
if (half.size() < w) {
half.insert(pair<int, int>(t[j], j));
now += ((t[j] + 1) / 2);
} else if ((*half.begin()).first < t[j]) {
pair<int, int> aux = *(half.begin());
now -= ((aux.first + 1) / 2);
now += aux.first;
now += ((t[j] + 1) / 2);
full.insert(aux);
half.erase(*(half.begin()));
half.insert(pair<int, int>(t[j], j));
} else {
full.insert(pair<int, int>(t[j], j));
now += t[j];
}
curr += p[j];
if (now <= k) ans = max(curr, ans);
j++;
}
while (now > k) {
if (half.find(pair<int, int>(t[i], i)) != half.end()) {
half.erase(pair<int, int>(t[i], i));
now -= ((t[i] + 1) / 2);
if (!full.empty()) {
pair<int, int> aux = (*full.rbegin());
now -= aux.first;
now += (aux.first + 1) / 2;
half.insert(aux);
full.erase(aux);
}
} else {
full.erase(pair<int, int>(t[i], i));
now -= t[i];
}
curr -= p[i];
if (now <= k) ans = max(curr, ans);
i++;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int belong[N];
int a[N], t[N];
priority_queue<pair<int, int> > q, p;
long long all_q, all_p;
int q_cnt, p_cnt;
int w, n, k;
void _flush() {
while (!q.empty() && belong[q.top().second] != 2) q.pop();
while (!p.empty() && belong[p.top().second] != 1) p.pop();
}
void flush_v(int x) {
if (belong[x] == 1) all_p -= t[x], p_cnt--;
if (belong[x] == 2) all_q -= (t[x] + 1) / 2, q_cnt--;
}
void insert_p(int x) {
flush_v(x);
p.push(make_pair(t[x], x));
all_p += t[x];
belong[x] = 1;
p_cnt++;
}
void insert_q(int x) {
flush_v(x);
q.push(make_pair(-t[x], x));
all_q += (t[x] + 1) / 2;
belong[x] = 2;
q_cnt++;
}
void update() {
_flush();
while (p_cnt && (q_cnt < w || -q.top().first < p.top().first)) {
if (q_cnt < w) {
insert_q(p.top().second);
} else {
int x = q.top().second;
int y = p.top().second;
insert_q(y);
insert_p(x);
}
_flush();
}
}
int main() {
scanf("%d %d %d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
long long ans = 0, all = 0;
int r = n;
for (int i = n; i >= 1; i--) {
insert_p(i);
all += a[i];
update();
while (all_p + all_q > k) {
all -= a[r];
flush_v(r);
belong[r] = 0;
update();
r--;
}
ans = max(ans, all);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dim = 10000;
struct aib {
int whole = 0;
int data[dim + 11];
int zrs(int x) { return (x ^ (x - 1)) & x; }
void add(int pos, int x) {
whole += x;
while (pos <= dim) {
data[pos] += x;
pos += zrs(pos);
}
}
int sum(int x) {
int ans = 0;
while (x > 0) {
ans += data[x];
x -= zrs(x);
}
return x;
}
int cb(int x) {
int ans = 0;
for (int step = 1 << 14; step > 0; step >>= 1)
if (ans + step <= dim)
if (data[ans + step] <= x) ans += step, x -= data[ans];
return ans;
}
int first() { return cb(0) + 1; }
int last() { return cb(whole - 1) + 1; }
};
int n, w, k, i, l, r;
int a[200011], t[200011];
aib full, half;
int sum_a, sum_t;
int ans;
void balance_add() {
while (full.whole > 0 && half.whole > 0 && full.last() > half.first()) {
int tm = half.first();
int tm2 = full.last();
full.add(tm, +1);
sum_t += tm;
half.add(tm, -1);
sum_t -= (tm + 1) / 2;
full.add(tm2, -1);
sum_t -= tm2;
half.add(tm2, +1);
sum_t += (tm2 + 1) / 2;
}
}
void balance() {
while (full.whole > 0 && half.whole < w) {
int tm = full.last();
full.add(tm, -1);
sum_t -= tm;
half.add(tm, +1);
sum_t += (tm + 1) / 2;
}
}
int main() {
scanf("%d%d%d", &n, &w, &k);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &t[i]);
l = 1;
for (r = 1; r <= n; r++) {
sum_a += a[r];
sum_t += t[r];
full.add(t[r], +1);
balance_add();
balance();
while (l <= r && sum_t > k) {
int tm = t[l];
if (tm <= full.last()) {
full.add(tm, -1);
sum_a -= a[l];
sum_t -= t[l];
} else {
half.add(tm, -1);
sum_a -= a[l];
sum_t -= (t[l] + 1) / 2;
}
l++;
balance();
}
ans = max(ans, sum_a);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long inf = numeric_limits<long long>::max() / 2;
const long double eps = 1e-9;
const long double pi = acos(-1);
template <typename T>
inline bool mineq(T& a, T b) {
return (a > b) ? (a = b, 1) : 0;
}
template <typename T>
inline bool maxeq(T& a, T b) {
return (a < b) ? (a = b, 1) : 0;
}
inline void solve(), read();
const string file = "";
int main() {
if (file != "") {
freopen((file + ".in").c_str(), "r", stdin);
freopen((file + ".out").c_str(), "w", stdout);
}
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
read();
solve();
return 0;
}
long long n, w, k;
vector<long long> a, t;
set<pair<long long, long long> > half, full;
inline void solve() {
long long ans = 0;
long long sum = 0;
long long dur = 0;
long long j = 0;
for (long long i = 0; i < n; i++) {
while (j < n && (long long)((half).size()) < w &&
dur + (t[j] + 1) / 2 <= k) {
half.insert({t[j], j});
dur += (t[j] + 1) / 2;
sum += a[j];
++j;
}
while (j < n && dur <= k) {
long long t1 = t[j];
long long t2 =
(t[j] + 1) / 2 + half.begin()->first - (half.begin()->first + 1) / 2;
if (dur + t1 > k && dur + t2 > k) {
break;
}
if (t1 < t2) {
full.insert({t[j], j});
dur += t[j];
sum += a[j];
} else {
full.insert(*half.begin());
dur += t2;
sum += a[j];
half.erase(half.begin());
half.insert({t[j], j});
}
++j;
}
maxeq(ans, sum);
if (full.count({t[i], i})) {
full.erase({t[i], i});
dur -= t[i];
sum -= a[i];
} else if (half.count({t[i], i})) {
half.erase({t[i], i});
dur -= (t[i] + 1) / 2;
sum -= a[i];
if (!full.empty()) {
half.insert(*full.rbegin());
dur -= full.rbegin()->first - (full.rbegin()->first + 1) / 2;
full.erase(*full.rbegin());
}
}
}
cout << ans << "\n";
}
inline void read() {
cin >> n >> w >> k;
a.resize(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
t.resize(n);
for (long long i = 0; i < n; i++) {
cin >> t[i];
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, k;
int t[200010], a[200010];
int partly(int x) { return (x % 2 ? x / 2 + 1 : x / 2); }
void solve() {
scanf("%d %d %d", &n, &w, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &t[i]);
}
int i = 1, j = 1;
long long ans = 0, cans = 0, time = 0;
set<pair<int, int>> S, oS;
auto insert = [&](int i) {
time += partly(t[i]);
cans += a[i];
S.insert({t[i], i});
if (S.size() > w) {
int er = S.begin()->second;
time -= partly(t[er]);
time += t[er];
S.erase({t[er], er});
oS.insert({t[er], er});
}
};
auto erase = [&](int i) {
cans -= a[i];
if (S.find({t[i], i}) != S.end()) {
time -= partly(t[i]);
S.erase({t[i], i});
if (oS.size() > 0) {
int er = oS.rbegin()->second;
oS.erase({t[er], er});
time -= t[er];
time += partly(t[er]);
S.insert({t[er], er});
}
} else {
time -= t[i];
oS.erase({t[i], i});
}
};
for (i = 1; i <= n; ++i) {
j = max(j, i);
while (j <= n && time <= k) {
insert(j);
++j;
}
if (time > k) {
--j;
erase(j);
}
ans = max(ans, cans);
if (j > i) erase(i);
}
cout << ans << "\n";
}
void reset() {}
int main() {
int k = 1;
for (; k <= 1; ++k) {
reset();
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
const int N = 1e6 + 10;
int n, w, k;
int a[N], t[N];
pair<int, int> r[N];
set<pair<int, int> > s;
set<pair<int, int>, greater<pair<int, int> > > res;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= n; ++i)
scanf("%d", t + i), r[i] = pair<int, int>(t[i] / 2, i);
int now = 1, c = 0, p = 0, ans = 0;
for (int i = 1; i <= n; ++i) {
while (now <= n && c < k) {
c += t[now] - r[now].first;
p += a[now];
s.insert(r[now]);
if (s.size() == w + 1) {
c += s.begin()->first;
res.insert(*s.begin());
s.erase(s.begin());
}
if (c <= k) ans = max(ans, p);
++now;
}
if (res.count(r[i])) res.erase(r[i]);
if (s.count(r[i])) {
s.erase(r[i]), c -= t[i] - r[i].first;
if (res.size()) {
c -= res.begin()->first;
s.insert(*res.begin()), res.erase(res.begin());
}
} else
c -= t[i];
p -= a[i];
if (c <= k) ans = max(ans, p);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int st[201010], qt[201010];
void upd(int b, int l, int r, int p, int v) {
if (p < l || r < p) return;
if (l == r) {
st[b] += (p / 2) * v;
qt[b] += v;
return;
}
int fe = b << 1, fd = fe | 1, mid = (l + r) >> 1;
upd(fe, l, mid, p, v), upd(fd, mid + 1, r, p, v);
st[b] = st[fe] + st[fd];
qt[b] = qt[fe] + qt[fd];
}
int get(int b, int l, int r, int k) {
if (!k) return 0;
if (k >= qt[b]) return st[b];
if (l == r) return (l / 2) * k;
int fe = b << 1, fd = fe | 1, mid = (l + r) >> 1;
int dir = min(k, qt[fd]);
return get(fe, l, mid, k - dir) + get(fd, mid + 1, r, dir);
}
int n, k, tot, vet[201010], t[201010], ans;
int main() {
scanf("%d%d%d", &n, &k, &tot);
for (int(i) = (0); (i) < (n); (i)++) scanf("%d", vet + i);
for (int(i) = (0); (i) < (n); (i)++) scanf("%d", t + i);
int q = 0, tt = 0, cur = 0;
for (int(i) = (n - 1); (i) >= (0); (i)--) {
upd(1, 0, 10101, t[i], 1);
tt += t[i];
cur += vet[i];
while (tt - get(1, 0, 10101, k) > tot) {
tt -= t[i + q];
upd(1, 0, 10101, t[i + q], -1);
cur -= vet[i + q];
q--;
}
ans = max(ans, cur);
q++;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > half, full;
const int N = 2e5 + 100;
int a[N], t[N];
int main() {
int n, w, k, ans, curt, j, p;
cin >> n >> w >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> t[i];
j = ans = curt = p = 0;
for (int i = 0; i < n;) {
while (i < n && curt < k) {
if (half.size() < w) {
curt += (t[i] + 1) / 2;
half.insert({t[i], i});
} else if ((*half.begin()).first < t[i]) {
curt -= ((*half.begin()).first + 1) / 2;
curt += (*half.begin()).first;
full.insert(*half.begin());
half.erase(*half.begin());
curt += (t[i] + 1) / 2;
half.insert({t[i], i});
} else {
curt += t[i];
full.insert({t[i], i});
}
p += a[i++];
if (curt <= k) ans = max(ans, p);
}
while (j < i && curt >= k) {
if (half.count({t[j], j})) {
curt -= (t[j] + 1) / 2;
half.erase({t[j], j});
if (full.size()) {
pair<int, int> top = *full.rbegin();
curt -= top.first;
curt += (top.first + 1) / 2;
half.insert(top);
full.erase(top);
}
} else {
curt -= t[j];
full.erase({t[j], j});
}
p -= a[j++];
if (curt <= k) ans = max(ans, p);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007LL;
long long base = 37;
long long large = 1000000000000000000LL;
int main() {
int n, w, k;
cin >> n >> w >> k;
vector<int> a(n, 0);
vector<int> t(n, 0);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> t[i];
set<pair<int, int> > full, part;
int r = 0;
int ti = 0;
int ans = 0;
int sum = 0;
for (int l = 0; l < n; l++) {
r = max(r, l);
while (r < n) {
if (w > (int)part.size()) {
if (ti + (t[r] + 1) / 2 > k) break;
part.insert(pair<int, int>(t[r], r));
ti += (t[r] + 1) / 2;
sum += a[r];
while (full.size() > 0) {
set<pair<int, int> >::iterator it = part.begin();
set<pair<int, int> >::iterator it2 = full.end();
it2--;
if (it2->first > it->first) {
ti -= (it2->first);
ti += (it2->first + 1) / 2;
ti += (it->first);
ti -= (it->first + 1) / 2;
pair<int, int> u = *it;
pair<int, int> v = *it2;
part.erase(it);
full.erase(it2);
full.insert(u);
part.insert(v);
} else {
break;
}
}
} else {
set<pair<int, int> >::iterator it = part.begin();
if (t[r] > it->first) {
int temp = it->first;
if (ti - (temp + 1) / 2 + temp + (t[r] + 1) / 2 <= k) {
full.insert(*it);
part.erase(it);
part.insert(pair<int, int>(t[r], r));
sum += a[r];
ti = ti - (temp + 1) / 2 + temp + (t[r] + 1) / 2;
} else {
break;
}
} else {
if (ti + t[r] <= k) {
ti += t[r];
sum += a[r];
full.insert(pair<int, int>(t[r], r));
} else {
break;
}
}
}
r++;
}
ans = max(ans, sum);
bool er = false;
if (!er) {
if (part.erase(pair<int, int>(t[l], l))) {
er = true;
sum -= a[l];
ti -= (t[l] + 1) / 2;
}
}
if (!er) {
if (full.erase(pair<int, int>(t[l], l))) {
er = true;
sum -= a[l];
ti -= t[l];
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pleasure[200010];
int t[200010];
class compare {
public:
bool operator()(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) {
return a.first < b.first;
}
return a.second > b.second;
}
};
class compare2 {
public:
bool operator()(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) {
return a.first > b.first;
}
return a.second > b.second;
}
};
int main(void) {
int n, w, k;
priority_queue<pair<int, int>, vector<pair<int, int> >, compare> unused;
priority_queue<pair<int, int>, vector<pair<int, int> >, compare2> used;
scanf("%d", &n);
scanf("%d", &w);
scanf("%d", &k);
for (int i = 0; i < n; i++) {
scanf("%d", &pleasure[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &t[i]);
}
long long maxP = 0;
long long curP = 0;
int st_idx = 0;
int t_left = k;
int partial = w;
map<int, int> is_inside;
for (int i = 0; i < n; i++) {
curP += pleasure[i];
t_left -= t[i];
unused.push(pair<int, int>(t[i], i));
while (!unused.empty()) {
pair<int, int> top = unused.top();
if (top.second < st_idx) {
unused.pop();
} else
break;
}
while (!used.empty()) {
pair<int, int> top = used.top();
if (top.second < st_idx) {
used.pop();
} else
break;
}
if (partial == 0) {
while (!unused.empty()) {
pair<int, int> top_unused = unused.top();
pair<int, int> top_used = used.top();
if (top_unused.first > top_used.first &&
is_inside[top_used.second] == 1) {
unused.pop();
used.pop();
unused.push(top_used);
used.push(top_unused);
t_left -= (top_used.first) / 2;
t_left += (top_unused.first) / 2;
is_inside[top_used.second] = 0;
is_inside[top_unused.second] = 1;
} else
break;
}
} else {
while (partial && !unused.empty()) {
pair<int, int> top = unused.top();
unused.pop();
if (top.second < st_idx) continue;
partial--;
used.push(top);
t_left += top.first / 2;
is_inside[top.second] = 1;
}
}
while (t_left < 0) {
curP -= pleasure[st_idx];
if (is_inside[st_idx] == 1) {
t_left += (t[st_idx] + 1) / 2;
partial++;
while (partial && !unused.empty()) {
pair<int, int> top = unused.top();
unused.pop();
if (top.second < st_idx) continue;
used.push(top);
t_left += (top.first) / 2;
is_inside[top.second] = 1;
partial--;
}
} else {
t_left += t[st_idx];
}
st_idx++;
}
maxP = max(maxP, curP);
}
cout << maxP << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
long long arr[maxn], t[maxn];
int n, k, w;
set<pair<long long, long long> > active;
set<pair<long long, long long> > unused;
long long sum = 0;
long long tot = 0;
void add(int ind) {
tot += arr[ind];
if (((int)((active).size())) == w) {
if (active.begin()->first < t[ind]) {
unused.insert(pair<long long, long long>(active.begin()->first,
active.begin()->second));
sum -= (active.begin()->first) / 2;
if (active.begin()->first % 2 == 1) --sum;
sum += active.begin()->first;
active.erase(active.begin());
sum += t[ind] / 2;
if (t[ind] % 2) ++sum;
active.insert(pair<long long, long long>(t[ind], ind));
} else {
sum += t[ind];
unused.insert(pair<long long, long long>(t[ind], ind));
}
} else {
active.insert(pair<long long, long long>(t[ind], ind));
sum += t[ind] / 2;
if (t[ind] % 2) ++sum;
}
}
void remove(int ind) {
tot -= arr[ind];
if (active.find(pair<long long, long long>(t[ind], ind)) != active.end()) {
sum -= t[ind] / 2;
if (t[ind] % 2) --sum;
active.erase(pair<long long, long long>(t[ind], ind));
if (((int)((unused).size())) > 0) {
pair<long long, long long> b = *unused.rbegin();
sum -= b.first;
sum += b.first / 2;
if (b.first % 2) ++sum;
active.insert(b);
unused.erase(b);
}
} else {
sum -= t[ind];
unused.erase(pair<long long, long long>(t[ind], ind));
active.erase(pair<long long, long long>(t[ind], ind));
}
}
long long getAns() {
int l = 0, r = 0;
long long ans = 0;
while (r < n) {
add(r);
while (sum > k && l <= r) {
remove(l);
++l;
}
ans = max(ans, tot);
++r;
}
return ans;
}
int main() {
scanf("%d %d %d", &n, &w, &k);
for (int i = 0; i < n; ++i) {
scanf("%lld", &arr[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%lld", &t[i]);
}
cout << getAns() << "\n";
}
|
#include <bits/stdc++.h>
const int N = 200200;
const int MX = 10010;
using namespace std;
int n;
int w;
int k;
int a[N];
int t[N];
pair<int, int> p[4 * MX + 44];
void upd(int x, int l, int r, int g, int y) {
if (l == r) {
p[x].first += y;
p[x].second += l * y;
return;
}
int m = (l + r) / 2;
if (g <= m)
upd(x * 2, l, m, g, y);
else
upd(x * 2 + 1, m + 1, r, g, y);
p[x].first = p[x * 2].first + p[x * 2 + 1].first;
p[x].second = p[x * 2].second + p[x * 2 + 1].second;
}
int get(int x, int l, int r, int need) {
if (l == r) return l * min(need, p[x].first);
int m = (l + r) / 2;
if (p[x * 2 + 1].first <= need)
return get(x * 2, l, m, need - p[x * 2 + 1].first) + p[x * 2 + 1].second;
else
return get(x * 2 + 1, m + 1, r, need);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> w >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (int i = 1; i <= n; i++) cin >> t[i];
int j = n;
int s = 0;
int ans = 0;
for (int i = n; i >= 1; i--) {
s += t[i];
upd(1, 1, MX, t[i] / 2, 1);
while (s - get(1, 1, MX, w) > k) {
upd(1, 1, MX, t[j] / 2, -1);
s -= t[j];
j--;
}
ans = max(ans, a[j] - a[i - 1]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, k, a[200005], t[200005], ans;
multiset<int> part, full;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
ans = 0;
for (int i = 1; i <= n; ++i) a[i] += a[i - 1];
for (int l = 1, r = 0; l <= n; ++l) {
while (k >= 0 && r <= n) {
++r;
if (r > n) break;
k -= (t[r] + 1) / 2;
part.insert(t[r]);
while ((int)part.size() > w) {
k += (*part.begin() + 1) / 2;
k -= *part.begin();
full.insert(*part.begin());
part.erase(part.begin());
}
}
ans = max(ans, a[r - 1] - a[l - 1]);
if (full.find(t[l]) != full.end()) {
full.erase(full.find(t[l]));
k += t[l];
} else {
part.erase(part.find(t[l]));
k += (t[l] + 1) / 2;
while ((int)part.size() < w && !full.empty()) {
k += *(--full.end());
k -= (*(--full.end()) + 1) / 2;
part.insert(*(--full.end()));
full.erase(--full.end());
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using int_t = long long int;
constexpr int_t inf = 1000000000000000000;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int_t n;
int_t w;
int_t k;
std::cin >> n >> w >> k;
std::vector<int_t> a(n);
for (int_t& ai : a) {
std::cin >> ai;
}
std::vector<int_t> t(n);
for (int_t& ti : t) {
std::cin >> ti;
}
int_t result = 0;
int_t left = 0;
int_t right = 0;
int_t time = 0;
int_t pleasure = 0;
std::set<std::pair<int_t, int_t>> part;
std::set<std::pair<int_t, int_t>> full;
while (right < n) {
while (time <= k && right < n) {
if (part.size() < w) {
part.emplace(t[right], right);
time += (t[right] + 1) / 2;
} else if (part.begin()->first < t[right]) {
time -= (part.begin()->first + 1) / 2;
time += part.begin()->first;
full.emplace(*part.begin());
part.erase(part.begin());
part.emplace(t[right], right);
time += (t[right] + 1) / 2;
} else {
full.emplace(t[right], right);
time += t[right];
}
pleasure += a[right];
if (time <= k) {
result = std::max(result, pleasure);
}
++right;
}
while (time > k) {
auto iter = part.find(std::make_pair(t[left], left));
if (iter != part.end()) {
time -= (t[left] + 1) / 2;
part.erase(iter);
if (!full.empty()) {
time -= full.rbegin()->first;
time += (full.rbegin()->first + 1) / 2;
part.emplace(*full.rbegin());
full.erase(std::prev(full.end()));
}
} else {
time -= t[left];
full.erase(std::make_pair(t[left], left));
}
pleasure -= a[left];
if (time <= k) {
result = std::max(result, pleasure);
}
++left;
}
}
std::cout << result << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int a[maxn], t[maxn], n, w, k, ple = 0, tme = 0, res = 0, cur = 1;
set<pair<int, int> > half, full;
bitset<maxn> is_half;
void find_nxt() {
while (cur <= n) {
if ((int)half.size() < w) {
if (tme + t[cur] / 2 + t[cur] % 2 > k) break;
tme += (t[cur] / 2 + t[cur] % 2);
half.insert({t[cur], cur}), is_half[cur] = 1;
} else {
if (half.begin()->first < t[cur]) {
if (tme + half.begin()->first / 2 + t[cur] / 2 + t[cur] % 2 > k) break;
tme = tme + half.begin()->first / 2 + t[cur] / 2 + t[cur] % 2;
is_half[half.begin()->second] = 0;
full.insert(*half.begin()), half.erase(half.begin()),
half.insert({t[cur], cur}), is_half[cur] = 1;
} else {
if (tme + t[cur] > k) break;
tme += t[cur];
full.insert({t[cur], cur});
}
}
ple += a[cur], ++cur;
}
}
void solve() {
find_nxt();
res = ple;
for (int i = 2; i <= n; ++i) {
if (cur > i - 1) {
ple -= a[i - 1];
if (!is_half[i - 1])
tme -= t[i - 1], full.erase({t[i - 1], i - 1});
else {
half.erase({t[i - 1], i - 1}), tme -= (t[i - 1] / 2 + t[i - 1] % 2);
if (!full.empty()) {
int mi = full.rbegin()->second;
full.erase({t[mi], mi}), half.insert({t[mi], mi}), tme -= (t[mi] / 2),
is_half[mi] = 1;
}
}
} else
ple = tme = res = 0, cur = i, full.clear(), half.clear();
find_nxt(), res = max(res, ple);
}
cout << res;
}
void enter() {
ios_base::sync_with_stdio(), cin.tie(0), cout.tie(0);
cin >> n >> w >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> t[i];
}
int main() {
enter();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int pleasure[200005], sum_pleasure[200005], t[200005], sum_t[200005], w;
struct node {
int count, sum;
node *left, *right;
node(int count, int sum, node *left, node *right)
: count(count), sum(sum), left(left), right(right) {}
node *insert(int l, int r, int w, int val);
};
node *null = new node(0, 0, NULL, NULL);
node *node::insert(int l, int r, int w, int val) {
if (l <= w && w <= r) {
if (l == r) return new node(this->count + 1, this->sum + val, null, null);
int mid = (l + r) / 2;
return new node(this->count + 1, this->sum + val,
this->left->insert(l, mid, w, val),
this->right->insert(mid + 1, r, w, val));
}
return this;
}
int query(node *x, node *y, int a, int b, int req) {
if (a == b) {
if (x->count - y->count >= req)
return a * req;
else
return x->sum - y->sum;
}
int mid = (a + b) / 2;
if (x->right->count - y->right->count >= req)
return query(x->right, y->right, mid + 1, b, req);
else
return x->right->sum - y->right->sum +
query(x->left, y->left, a, mid,
req - (x->right->count - y->right->count));
}
node *root[200005];
int getceil(int x, int y) {
if (x % y)
return (x / y) + 1;
else
return x / y;
}
int total_time(int l, int r) {
return sum_t[r] - sum_t[l - 1] - query(root[r], root[l - 1], 1, 10000, w);
}
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
int i, j, n, k, x, y, ans = 0, lo, mid, hi;
cin >> n >> w >> k;
for (i = 1; i <= n; i++) {
cin >> pleasure[i];
sum_pleasure[i] = sum_pleasure[i - 1] + pleasure[i];
}
for (i = 1; i <= n; i++) {
cin >> t[i];
sum_t[i] = sum_t[i - 1] + t[i];
}
null->left = null->right = null;
root[0] = null;
for (i = 1; i <= n; i++)
root[i] = root[i - 1]->insert(1, 10000, t[i] - getceil(t[i], 2),
t[i] - getceil(t[i], 2));
for (i = 1; i <= n; i++) {
lo = i;
hi = n + 1;
if (total_time(i, lo) > k) continue;
while (hi - lo > 1) {
mid = (lo + hi) / 2;
if (total_time(i, mid) <= k)
lo = mid;
else
hi = mid;
}
ans = max(ans, sum_pleasure[lo] - sum_pleasure[i - 1]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, k, a[200200], cc[200200];
pair<int, int> tree[4 * 10010 + 44];
void update(int x, int l, int r, int g, int y) {
if (l == r) {
tree[x].first += y;
tree[x].second += l * y;
return;
}
int m = (l + r) / 2;
if (g <= m)
update(x * 2, l, m, g, y);
else
update(x * 2 + 1, m + 1, r, g, y);
tree[x].first = tree[x * 2].first + tree[x * 2 + 1].first;
tree[x].second = tree[x * 2].second + tree[x * 2 + 1].second;
}
int sum(int x, int l, int r, int need) {
if (l == r) return l * min(need, tree[x].second);
int m = (l + r) / 2;
if (tree[x * 2 + 1].first <= need)
return sum(x * 2, l, m, need - tree[x * 2 + 1].first) +
tree[x * 2 + 1].second;
else
return sum(x * 2 + 1, m + 1, r, need);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> w >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (int i = 1; i <= n; i++) cin >> cc[i];
int j = n, s = 0, cnt = 0;
for (int i = n; i >= 1; i--) {
s += cc[i];
update(1, 1, 10010, cc[i] / 2, 1);
while (s - sum(1, 1, 10010, w) > k) {
update(1, 1, 10010, cc[j] / 2, -1);
s -= cc[j];
j--;
}
cnt = max(cnt, a[j] - a[i - 1]);
}
cout << cnt << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 2e5 + 5;
int w, n, k, a[MaxN], t[MaxN];
int l = 1, r, now, ans, cost;
multiset<int> al, hf;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> w >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> t[i];
for (; r <= n; ans = max(ans, now)) {
cost += (t[++r] + 1) >> 1;
hf.insert(t[r]);
now += a[r];
if (hf.size() > size_t(w)) {
cost += *hf.begin() / 2;
al.insert(*hf.begin());
hf.erase(hf.begin());
}
for (; l <= r && cost > k; now -= a[l++]) {
if (t[l] >= *hf.begin()) {
cost -= (t[l] + 1) / 2;
hf.erase(hf.find(t[l]));
if (!al.empty()) {
cost -= *al.rbegin() / 2;
hf.insert(*al.rbegin());
al.erase(--al.end());
}
} else {
cost -= t[l];
al.erase(al.find(t[l]));
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int n, w, k;
int a[MAXN], t[MAXN];
multiset<int> q1, q2;
int ans;
int upt(int tt) {
if (tt % 2 == 0) {
return tt / 2;
} else
return tt / 2 + 1;
}
int main(int argc, const char* argv[]) {
cin >> n >> w >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> t[i];
}
int ct = 0;
int ca = 0;
int cw = 0;
int l = 1, r = 1;
while (1) {
if (cw < w) {
ct += upt(t[r]);
q1.insert(t[r]);
ca += a[r];
r++;
cw++;
} else {
auto it = q1.begin();
int tt = *it;
if (tt < t[r]) {
q1.erase(it);
q1.insert(t[r]);
ct += upt(t[r]);
ct += tt / 2;
ca += a[r];
q2.insert(tt);
} else {
q2.insert(t[r]);
ct += t[r];
ca += a[r];
}
r++;
}
while (ct > k) {
int tt = t[l];
if (q2.count(tt) != 0) {
auto it = q2.find(tt);
q2.erase(it);
ct -= tt;
ca -= a[l];
} else {
auto it = q1.find(tt);
q1.erase(it);
ct -= upt(tt);
ca -= a[l];
if (!q2.empty()) {
auto it = q2.end();
it--;
int ttt = *it;
q2.erase(it);
q1.insert(ttt);
ct -= ttt / 2;
cw++;
}
cw--;
}
l++;
}
ans = max(ans, ca);
if (r == n + 1) {
break;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000 * 1000 * 1000 + 7;
const long long INF = 1e9 + 100;
const long long LINF = 1e18 + 100;
long long n, w, k;
long long a[200100], t[200100];
long long ps[200100];
set<pair<long long, long long> > s;
set<pair<long long, long long> > ns;
long long ans;
int32_t main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> w >> k;
for (long long i = (0); i < (n); i++) {
cin >> a[i];
ps[i + 1] = ps[i] + a[i];
}
for (long long i = (0); i < (n); i++) cin >> t[i];
;
;
long long r = 0;
long long cur = 0;
for (long long l = (0); l < (n); l++) {
while (r < n) {
if ((long long)s.size() < w) {
if (cur + (t[r] + 1) / 2 <= k) {
s.insert({t[r], r});
cur += (t[r] + 1) / 2;
r++;
} else
break;
} else {
if (s.begin()->first >= t[r]) {
if (cur + t[r] <= k) {
ns.insert({t[r], r});
cur += t[r];
r++;
} else
break;
} else {
long long mt = s.begin()->first;
if (cur + mt / 2 + (t[r] + 1) / 2 <= k) {
ns.insert(*s.begin());
s.erase(s.begin());
s.insert({t[r], r});
cur += (t[r] + 1) / 2 + mt / 2;
r++;
} else
break;
}
}
}
ans = max(ans, ps[r] - ps[l]);
if (l == r) {
r++;
continue;
}
if (s.count({t[l], l})) {
s.erase({t[l], l});
cur -= (t[l] + 1) / 2;
if (ns.size()) {
auto it = ns.end();
it--;
s.insert(*it);
cur -= it->first / 2;
ns.erase(it);
}
} else {
cur -= t[l];
ns.erase({t[l], l});
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
multiset<int> S, s;
multiset<int>::iterator it;
int t[N], p[N];
int n, k, w, mi, sum, ans;
void insert(int r) {
if (mi < w) {
s.insert(p[r]);
sum += (p[r] + 1) / 2;
mi++;
return;
}
it = s.begin();
if (*it < p[r]) {
sum -= (*it + 1) / 2;
sum += *it;
S.insert(*it);
s.erase(s.find(*it));
s.insert(p[r]);
sum += (p[r] + 1) / 2;
return;
}
S.insert(p[r]);
sum += p[r];
}
void del(int l) {
it = s.begin();
if (*it <= p[l]) {
sum -= (p[l] + 1) / 2;
s.erase(s.find(p[l]));
if (S.empty()) {
mi--;
return;
}
it = S.end();
it--;
S.erase(S.find(*it));
s.insert(*it);
sum -= *it;
sum += (*it + 1) / 2;
return;
}
sum -= p[l];
S.erase(S.find(p[l]));
}
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]), t[i] += t[i - 1];
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int l = 1, r = 1; r <= n; r++) {
insert(r);
while (sum > k) del(l++);
ans = max(ans, t[r] - t[l - 1]);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 2e5 + 10;
int v[N];
int t[N];
int u[N];
int n, w, k;
class TreeArray {
public:
long long a[N];
TreeArray() { memset((a), (0), sizeof(a)); }
int lowbit(int x) { return x & -x; }
void add(int x, long long y) {
while (x < N) {
a[x] += y;
x += lowbit(x);
}
}
long long sum(int x) {
long long ret = 0;
while (x) {
ret += a[x];
x -= lowbit(x);
}
return ret;
}
} ta1, ta2, ta3;
int getT(int w, int tot) {
w = min(w, tot);
int l = 1, r = N - 2;
int k = 0;
int ks = 0;
while (l <= r) {
int mid = (l + r) / 2;
int low = ta1.sum(mid);
if (low <= tot - w)
k = mid, l = mid + 1;
else
r = mid - 1;
}
ks = ta1.sum(k);
int ret = ta2.sum(k) + ta3.sum(N - 2) - ta3.sum(k + 1);
int cnt = ta1.sum(k + 1) - ta1.sum(k);
int per = cnt == 0 ? 0 : (ta2.sum(k + 1) - ta2.sum(k)) / cnt;
if (ks <= tot - w) {
int o = tot - w - ks;
ret += o * per + (cnt - o) * ((per + 1) / 2);
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &t[i]);
u[i] = t[i];
}
sort(u, u + n);
int p = 0;
long long ans = 0;
long long res = 0;
for (int i = 0; i < n; i++) {
while (p < n) {
int o = lower_bound(u, u + n, t[p]) - u + 1;
ta1.add(o, 1);
ta2.add(o, t[p]);
ta3.add(o, (t[p] + 1) / 2);
if (getT(w, p - i + 1) <= k)
ans += v[p++];
else {
ta1.add(o, -1);
ta2.add(o, -t[p]);
ta3.add(o, -(t[p] + 1) / 2);
break;
}
}
res = max(res, ans);
ans -= v[i];
int o = lower_bound(u, u + n, t[i]) - u + 1;
ta1.add(o, -1);
ta2.add(o, -t[i]);
ta3.add(o, -(t[i] + 1) / 2);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 5;
long long n, sum, sum2, w, k, a[maxn], ti[maxn], ans;
set<pair<long long, long long>> s;
set<pair<long long, long long>, greater<pair<long long, long long>>> s1;
bool mrk[maxn];
void f16_62() {
while (s1.size()) {
long long sz = s.size();
if (sz < w) {
pair<long long, long long> p = (*s1.begin());
s1.erase(p);
sum2 = sum2 - ti[p.second];
s.insert(p);
mrk[p.second] = 1;
sum2 += (ti[p.second] + 1ll) / 2ll;
continue;
}
pair<long long, long long> p = (*s1.begin());
pair<long long, long long> p2 = (*s.begin());
if (p2.first < p.first) {
s1.erase(p);
s.erase(p2);
sum2 = sum2 - (((ti[p2.second] + 1ll) / 2ll) + ti[p.second]);
sum2 = sum2 + (ti[p2.second] + ((ti[p.second] + 1ll) / 2ll));
s1.insert(p2);
s.insert(p);
mrk[p.second] = 1;
mrk[p2.second] = 0;
} else
break;
}
}
void aDd(long long i) {
sum += a[i];
sum2 += ti[i];
long long x = ti[i] / 2ll;
pair<long long, long long> p = {x, i};
s1.insert(p);
if (i > n)
cout << "i"
<< " : " << i << "\n";
if (i < 0)
cout << "i"
<< " : " << i << "\n";
f16_62();
if (sum2 <= k) ans = max(ans, sum);
}
void dLt(long long i) {
long long x = ti[i] / 2ll;
pair<long long, long long> p = {x, i};
sum -= a[i];
if (mrk[i]) {
s.erase(p);
sum2 -= ((ti[i] + 1ll) / 2ll);
mrk[i] = 0;
} else {
s1.erase(p);
sum2 -= ti[i];
}
f16_62();
if (sum2 <= k) ans = max(ans, sum);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> w >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> ti[i];
aDd(0);
long long p1 = 0, p2 = 1;
while (p1 < n) {
if (sum2 > k) {
dLt(p1);
p1++;
continue;
}
ans = max(ans, sum);
if (p1 == p2) {
aDd(p1);
p2++;
continue;
}
while ((p2 < n) && (sum2 <= k)) {
ans = max(ans, sum);
aDd(p2);
p2++;
}
dLt(p1);
p1++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long a, b;
bool operator<(const edge &P) const {
if (b == P.b) return a < P.a;
return b < P.b;
}
};
int a[200000], b[200000];
set<edge> hal, ful;
set<edge>::iterator it;
edge gr;
int main() {
int i, j, k, l, m, n, w, tot;
scanf("%d%d%d", &n, &w, &tot);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
j = 1;
long long ans = 0, cal = 0, time = 0;
for (int i = 1; i <= n; i++) {
gr.a = i;
gr.b = b[i];
hal.insert(gr);
cal += a[i];
time += (b[i] + 1) / 2;
if (hal.size() > w) {
it = hal.begin();
hal.erase(*it);
ful.insert(*it);
time += b[(it)->a];
time -= (b[(it)->a] + 1) / 2;
}
while (time > tot && j <= i) {
gr.a = j;
gr.b = b[j];
if (hal.find(gr) != hal.end()) {
hal.erase(gr);
time -= (b[j] + 1) / 2;
cal -= a[j];
if (ful.size()) {
it = ful.end();
it--;
ful.erase(*it);
time -= b[it->a];
time += (b[it->a] + 1) / 2;
hal.insert(*it);
}
} else if (ful.find(gr) != ful.end()) {
ful.erase(gr);
time -= gr.b;
cal -= a[gr.a];
}
j++;
}
ans = max(ans, cal);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
inline void up(int& x, int y) {
if (y > x) x = y;
}
int n, w, k, a[N], t[N], ans;
struct HeapA {
priority_queue<int> A, B;
int size() { return A.size() - B.size(); }
void update() {
while (B.size() && A.top() == B.top()) A.pop(), B.pop();
}
void push(int x) { A.push(x); }
void del(int x) { B.push(x); }
void pop() {
update();
A.pop();
}
int top() {
update();
return A.top();
}
} A;
struct Heap {
priority_queue<int, vector<int>, greater<int> > A, B;
int size() { return A.size() - B.size(); }
void update() {
while (B.size() && A.top() == B.top()) A.pop(), B.pop();
}
void push(int x) { A.push(x); }
void del(int x) { B.push(x); }
void pop() {
update();
A.pop();
}
int top() {
update();
return A.top();
}
} B;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (register int i = (1); i <= (n); ++i) scanf("%d", &a[i]);
for (register int i = (1); i <= (n); ++i) scanf("%d", &t[i]);
for (int i = n, j = n, sum = 0, st = 0; i >= 1; --i) {
st += t[i];
if (B.size() == w && t[i] / 2 > B.top())
st += B.top(), A.push(B.top()), B.pop();
if (B.size() < w)
B.push(t[i] / 2), st -= t[i] / 2;
else
A.push(t[i] / 2);
sum += a[i];
while (st > k) {
sum -= a[j];
st -= t[j];
if (t[j] / 2 >= B.top())
B.del(t[j] / 2), st += t[j] / 2;
else
A.del(t[j] / 2);
if (B.size() < w && A.size()) B.push(A.top()), st -= A.top(), A.pop();
--j;
}
up(ans, sum);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int a[N + 100], t[N + 100], vis[N + 100];
set<pair<int, int> > st1, st2;
int main() {
int n, w, k;
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
for (int i = 1; i <= n; i++) {
scanf("%d", t + i);
}
int cur = 0, l = 1, r = 1, cnt = 0, total = 0, ans = 0;
while (r <= n) {
while (cur <= k && r <= n) {
if (cnt < w) {
cnt++;
vis[r] = 1;
cur += (t[r] + 1) / 2;
vis[r] = 1;
st1.insert(make_pair(t[r], r));
} else {
auto it = *st1.begin();
if (it.first < t[r]) {
vis[it.second] = 2;
vis[r] = 1;
cur -= (it.first + 1) / 2;
cur += it.first;
cur += (t[r] + 1) / 2;
st1.erase(it);
st2.insert(it);
st1.insert(make_pair(t[r], r));
} else {
st2.insert(make_pair(t[r], r));
cur += t[r];
vis[r] = 2;
}
}
total += a[r];
if (cur <= k) {
ans = max(ans, total);
}
r++;
}
while (cur > k) {
if (vis[l] == 1) {
cnt--;
st1.erase(make_pair(t[l], l));
cur -= (t[l] + 1) / 2;
if (!st2.empty()) {
auto it = *st2.rbegin();
vis[it.second] = 1;
cur -= t[it.second];
cur += (t[it.second] + 1) / 2;
cnt++;
st2.erase(it);
st1.insert(it);
}
} else {
st2.erase(make_pair(t[l], l));
cur -= t[l];
}
total -= a[l];
l++;
if (cur <= k) {
ans = max(ans, total);
}
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, n, m, total, k, b, a, c, op, maxi, modu = 1000000007, mini, mij, ls,
ld, ul, first, second, im, timp;
pair<int, int> v[200005];
int in[200005];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q1;
priority_queue<pair<int, int> > q2;
void update() {
while (a < m && q2.size()) {
if (q2.top().second < j) {
q2.pop();
continue;
}
a++;
q1.push(q2.top());
timp -= q2.top().first / 2;
in[q2.top().second] = 1;
q2.pop();
}
while (q1.size() && q2.size() && q2.top().first > q1.top().first) {
if (q2.top().second < j) {
q2.pop();
continue;
}
if (q1.top().second < j) {
q1.pop();
continue;
}
timp = timp - q2.top().first / 2 + q1.top().first / 2;
in[q2.top().second] = 1;
in[q1.top().second] = 0;
pair<int, int> a1 = q1.top(), a2 = q2.top();
q1.pop();
q2.pop();
q1.push(a2);
q2.push(a1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
for (i = 1; i <= n; i++) cin >> v[i].first;
for (i = 1; i <= n; i++) cin >> v[i].second;
j = 1;
for (i = 1; i <= n; i++) {
q2.push({v[i].second, i});
total += v[i].first;
timp += v[i].second;
update();
while (timp > k) {
if (in[j]) {
timp -= (v[j].second + 1) / 2;
a--;
} else
timp -= v[j].second;
update();
total -= v[j].first;
j++;
}
maxi = max(maxi, total);
}
cout << maxi;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
multiset<int> S;
multiset<int> notS;
multiset<int>::iterator it;
int N, W, K, A[200001], T[200001], Ans;
int main(void) {
int i, left = 1, right = 0, tot = 0, val = 0;
scanf("%d %d %d", &N, &W, &K);
for (i = 1; i <= N; i++) scanf("%d", &A[i]);
for (i = 1; i <= N; i++) scanf("%d", &T[i]);
while (1) {
if (tot <= K) {
Ans = max(Ans, val);
if (right == N) break;
right++;
if (S.size() < W) {
S.insert(T[right]);
tot += (T[right] + 1) / 2;
} else {
it = S.begin();
if ((*it) < T[right]) {
tot += (T[right] + 1) / 2 - ((*it) + 1) / 2 + (*it);
notS.insert((*it));
S.erase(it);
S.insert(T[right]);
} else {
notS.insert(T[right]);
tot += T[right];
}
}
val += A[right];
} else {
it = S.find(T[left]);
if (it != S.end()) {
S.erase(it);
tot -= (T[left] + 1) / 2;
if (!notS.empty()) {
it = notS.end();
it--;
S.insert((*it));
tot += (*it + 1) / 2 - (*it);
notS.erase(it);
}
} else {
it = notS.find(T[left]);
notS.erase(it);
tot -= T[left];
}
val -= A[left];
left++;
}
}
printf("%d", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int64_t n, w, k, Time = 0, sum = 0, res = 0, a[200005], t[200005], type[200005];
set<pair<int, int> > half, full;
bool Check(int x, int i) {
if (half.size() < w && Time + (t[i] + 1) / 2 <= k) {
Time += (t[i] + 1) / 2;
sum += a[i];
type[i] = 2;
half.insert(pair<int, int>(t[i], i));
return true;
}
if (half.size() > 0) {
pair<int, int> tmp = *half.begin();
if (tmp.first < t[i] &&
Time - (tmp.first + 1) / 2 + tmp.first + (t[i] + 1) / 2 <= k) {
type[tmp.second] = 1;
full.insert(tmp);
half.erase(half.begin());
Time += -(tmp.first + 1) / 2 + tmp.first + (t[i] + 1) / 2;
sum += a[i];
half.insert(pair<int, int>(t[i], i));
type[i] = 2;
return true;
}
}
if (Time + t[i] <= k) {
Time += t[i];
sum += a[i];
type[i] = 1;
full.insert(pair<int, int>(t[i], i));
return true;
}
return false;
}
int main() {
cin >> n >> w >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> t[i];
int r = 1;
for (int l = 1; l <= n; l++) {
r = max(r, l);
while (r <= n && Check(l, r) == true) r++;
res = max(res, sum);
if (l < r) {
if (type[l] == 1) {
Time -= t[l];
full.erase(full.find(pair<int, int>(t[l], l)));
} else {
Time -= (t[l] + 1) / 2;
if (half.size() > 0) {
half.erase(half.find(pair<int, int>(t[l], l)));
if (full.size() > 0) {
pair<int, int> tmp = *full.rbegin();
full.erase(full.find(*full.rbegin()));
Time += (tmp.first + 1) / 2 - tmp.first;
type[tmp.second] = 2;
half.insert(tmp);
}
}
}
sum -= a[l];
}
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long a, b;
bool operator<(const edge &P) const {
if (b == P.b) return a < P.a;
return b < P.b;
}
};
int a[200004], b[200004];
set<edge> hal, ful;
set<edge>::iterator it;
edge gr;
int main() {
int i, j, k, l, m, n, w, tot;
scanf("%d%d%d", &n, &w, &tot);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
j = 1;
long long ans = 0, cal = 0, time = 0;
for (int i = 1; i <= n; i++) {
gr.a = i;
gr.b = b[i];
hal.insert(gr);
cal += a[i];
time += (b[i] + 1) / 2;
if (hal.size() > w) {
it = hal.begin();
hal.erase(*it);
ful.insert(*it);
time += b[(it)->a];
time -= (b[(it)->a] + 1) / 2;
}
while (time > tot && j <= i) {
gr.a = j;
gr.b = b[j];
if (hal.find(gr) != hal.end()) {
hal.erase(gr);
time -= (b[j] + 1) / 2;
cal -= a[j];
if (ful.size()) {
it = ful.end();
it--;
ful.erase(*it);
time -= b[it->a];
time += (b[it->a] + 1) / 2;
hal.insert(*it);
}
} else if (ful.find(gr) != ful.end()) {
ful.erase(gr);
time -= gr.b;
cal -= a[gr.a];
}
j++;
}
ans = max(ans, cal);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
multiset<int> s1, s2;
int n, w, k;
int a[N], t[N];
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
int time = 0, num = 0, sum = 0, ans = 0;
int l = 1, r = 1;
while (r <= n) {
s1.insert(t[r]);
time += (t[r] + 1) / 2;
if (s1.size() > w) {
s2.insert(*(s1.begin()));
time += *(s1.begin()) / 2;
s1.erase(s1.begin());
}
sum += a[r++];
while (l <= r && time > k) {
if (t[l] >= *(s1.begin())) {
s1.erase(s1.find(t[l]));
time -= (t[l] + 1) / 2;
if (s2.size()) {
multiset<int>::iterator it = s2.end();
it--;
s1.insert(*it);
time -= *it / 2;
s2.erase(it);
}
} else {
s2.erase(s2.find(t[l]));
time -= t[l];
}
sum -= a[l++];
}
ans = max(ans, sum);
}
printf("%d", 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 - '0', ch = getchar();
return x * f;
}
multiset<int> s, t;
multiset<int>::iterator p;
int n, m, k, a[200010], b[200010];
int main() {
n = read();
m = read();
k = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) b[i] = read();
int l = 1, r = 1, ans = 0, st = 0, ss = 0;
while (r <= n) {
s.insert(b[r]);
st += (b[r] + 1) / 2;
if (s.size() > m) {
t.insert(*s.begin());
st += (*s.begin()) / 2;
s.erase(s.begin());
}
ss += a[r++];
while (l <= r && st > k) {
if (b[l] >= *s.begin()) {
s.erase(s.find(b[l]));
st -= (b[l] + 1) / 2;
if (t.size()) {
p = t.end();
p--;
s.insert(*p);
t.erase(p);
st -= *p / 2;
}
} else {
t.erase(t.find(b[l]));
st -= b[l];
}
ss -= a[l++];
}
ans = max(ans, ss);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, w, k;
vector<int> p, v;
int leftPtr = 0;
int rightPtr = -1;
multiset<int, greater<int> > bestSong;
multiset<int, greater<int> > restSong;
int ans = 0;
int pleasure = 0;
inline void balance() {
while (!restSong.empty() && bestSong.size() < w) {
int add = *restSong.begin();
bestSong.insert(add);
restSong.erase(restSong.begin());
ans -= add;
}
}
inline void add(int song) {
ans += song;
song = song / 2;
restSong.insert(song);
if (!bestSong.empty() && song > *bestSong.rbegin()) {
int add = *bestSong.rbegin();
restSong.insert(add);
bestSong.erase(bestSong.find(add));
ans += add;
}
balance();
}
inline void del(int song) {
ans -= song;
song = song / 2;
if (bestSong.find(song) != bestSong.end()) {
bestSong.erase(bestSong.find(song));
ans += song;
balance();
} else {
restSong.erase(restSong.find(song));
}
}
void out() {}
inline void incLeft() {
pleasure -= p[leftPtr];
del(v[leftPtr]);
leftPtr++;
out();
}
inline void incRight() {
rightPtr++;
pleasure += p[rightPtr];
add(v[rightPtr]);
out();
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> w >> k;
p.resize(n);
v.resize(n);
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < n; i++) cin >> v[i];
int res = 0;
for (int i = 0; i < n; i++) {
if (i != 0) incLeft();
while (rightPtr + 1 < n && ans <= k) incRight();
int cur = pleasure;
if (ans > k) cur -= p[rightPtr];
res = max(res, cur);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
priority_queue<pair<int, int> > q2;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q1;
int a[maxn], t[maxn], vis[maxn], w, d, ans, m1, m2;
long long k, s1, s2;
void add(int x) {
pair<int, int> u, v;
d += a[x];
if (m1 < w) {
q1.push(pair<int, int>(t[x], x));
s1 += (t[x] + 1) / 2;
vis[x] = 1;
m1++;
} else {
q2.push(pair<int, int>(t[x], x));
vis[x] = 2;
s2 += t[x];
m2++;
while (vis[(q2.top()).second] == 3) q2.pop();
while (vis[(q1.top()).second] == 3) q1.pop();
if ((q2.top()).first > (q1.top()).first) {
u = q2.top();
q2.pop();
v = q1.top();
q1.pop();
q1.push(u);
q2.push(v);
s1 += (t[u.second] + 1) / 2 - (t[v.second] + 1) / 2;
s2 += t[v.second] - t[u.second];
vis[u.second] = 1;
vis[v.second] = 2;
}
}
}
void del(int x) {
if (vis[x] == 1) {
s1 -= (t[x] + 1) / 2;
if (m2) {
while (vis[(q2.top()).second] == 3) q2.pop();
pair<int, int> u;
u = q2.top();
q2.pop();
m2--;
s2 -= t[u.second];
q1.push(u);
s1 += (t[u.second] + 1) / 2;
vis[u.second] = 1;
} else
m1--;
}
if (vis[x] == 2) {
m2--;
s2 -= t[x];
}
vis[x] = 3;
d -= a[x];
}
int main() {
int n, i, j;
scanf("%d%d%I64d", &n, &w, &k);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) scanf("%d", &t[i]);
j = 0;
for (i = 0; i < n; i++) {
add(i);
while (s1 + s2 > k && j <= i) del(j++);
ans = max(ans, d);
}
printf("%d\n", ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.