text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
long long n, k;
long long p[N], q[N], sparce_table[N][40], min_[N][40], ans[N][40];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < n; i++) cin >> q[i];
for (int i = 0; i < n; i++) {
sparce_table[i][0] = p[i];
ans[i][0] = min_[i][0] = q[i];
}
for (int i = 1; i < 40; i++) {
for (int j = 0; j < n; j++) {
sparce_table[j][i] = sparce_table[sparce_table[j][i - 1]][i - 1];
ans[j][i] = ans[j][i - 1] + ans[sparce_table[j][i - 1]][i - 1];
min_[j][i] = min(min_[j][i - 1], min_[sparce_table[j][i - 1]][i - 1]);
}
}
for (int i = 0; i < n; i++) {
int index = i;
long long counter = 0;
long long big = 1e18;
long long rem = k;
for (int ii = 39; ii >= 0; ii--) {
if ((1ll << ii) <= rem) {
rem -= (1ll << ii);
counter += ans[index][ii];
big = min(big, min_[index][ii]);
index = sparce_table[index][ii];
}
}
cout << counter << " " << big << endl;
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-4;
const long long mod = 1e9 + 7;
const unsigned long long mx = 133333331;
inline void RI(int &x) {
char c;
while ((c = getchar()) < '0' || c > '9')
;
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0';
}
int pre[100005][40];
int w[100005][40];
long long s[100005][40];
long long ans1;
int ans2;
void solve(int u, long long k) {
if (k == 0) {
return;
}
int t = 0;
while ((1LL << t) <= k) t++;
t--;
ans1 += s[u][t];
ans2 = min(ans2, w[u][t]);
solve(pre[u][t], k - (1LL << t));
}
int main() {
int n;
long long k;
while (cin >> n >> k) {
for (int i = 0; i < n; i++) scanf("%d", &pre[i][0]);
for (int i = 0; i < n; i++) scanf("%d", &w[i][0]), s[i][0] = w[i][0];
for (int i = 1; (1LL << i) <= k; i++) {
for (int j = 0; j < n; j++) {
pre[j][i] = pre[pre[j][i - 1]][i - 1];
w[j][i] = min(w[j][i - 1], w[pre[j][i - 1]][i - 1]);
s[j][i] = s[j][i - 1] + s[pre[j][i - 1]][i - 1];
}
}
for (int i = 0; i < n; i++) {
ans1 = 0;
ans2 = INF;
solve(i, k);
printf("%I64d %d\n", ans1, ans2);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000000 + 7;
const long long int N = 100000 + 6;
const long long int inf = 1e18 + 1e17;
long long int powm(long long int a, long long int b) {
a = a % mod;
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return (res % mod);
}
long long int modInverse(long long int a, long long int m) {
long long int m0 = m;
long long int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long int q = a / m;
long long int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long int p[37][N];
long long int sum[37][N];
long long int low[37][N];
void solve() {
long long int n, k;
cin >> n >> k;
memset(sum, 0, sizeof(sum));
for (int i = 0; i < n; i++) cin >> p[0][i];
for (int i = 0; i < n; i++) {
cin >> sum[0][i];
low[0][i] = sum[0][i];
}
for (int i = 1; i < 37; i++) {
for (int j = 0; j < n; j++) {
p[i][j] = p[i - 1][p[i - 1][j]];
low[i][j] = min(low[i - 1][j], low[i - 1][p[i - 1][j]]);
sum[i][j] = (sum[i - 1][j] + sum[i - 1][p[i - 1][j]]);
}
}
for (int i = 0; i < n; i++) {
long long int mi = inf;
long long int ss = 0;
long long int val = k;
long long int pos = i;
for (int j = 35; j >= 0; j--) {
if ((1ll << j) <= val) {
ss = ss + sum[j][pos];
mi = std::min(mi, low[j][pos]);
pos = p[j][pos];
val = val - (1ll << j);
}
}
cout << ss << ' ' << mi << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int Son[100010][50];
long long Ans[100010][50];
int Min[100010][50];
long long Solve1(int Cur, long long k) {
if (k == 0) return 0;
int xx = 0;
long long x = 1;
while (x <= k) xx++, x <<= 1;
xx--;
x >>= 1;
return Ans[Cur][xx] + Solve1(Son[Cur][xx], k - x);
}
int Solve2(int Cur, long long k) {
if (k == 0) return 2147483647;
int xx = 0;
long long x = 1;
while (x <= k) xx++, x <<= 1;
xx--;
x >>= 1;
return min(Min[Cur][xx], Solve2(Son[Cur][xx], k - x));
}
int main() {
int n;
long long k;
scanf("%d %I64d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &Son[i][0]);
for (int i = 0; i < n; i++) scanf("%I64d", &Ans[i][0]), Min[i][0] = Ans[i][0];
for (int t = 1; t <= 40; t++)
for (int i = 0; i < n; i++) Son[i][t] = Son[Son[i][t - 1]][t - 1];
for (int t = 1; t <= 40; t++)
for (int i = 0; i < n; i++)
Ans[i][t] = Ans[i][t - 1] + Ans[Son[i][t - 1]][t - 1];
for (int t = 1; t <= 40; t++)
for (int i = 0; i < n; i++)
Min[i][t] = min(Min[i][t - 1], Min[Son[i][t - 1]][t - 1]);
for (int i = 0; i < n; i++) printf("%I64d %d\n", Solve1(i, k), Solve2(i, k));
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long k;
scanf("%d %I64d", &n, &k);
int f[n];
long long w[n];
for (int i = 0; i < n; i++) scanf("%d", &f[i]);
for (int i = 0; i < n; i++) scanf("%I64d", &w[i]);
int anc[n][34];
long long sum[n][34], mn[n][34];
for (int i = 0; i < n; i++) {
anc[i][0] = f[i];
sum[i][0] = w[i];
mn[i][0] = w[i];
}
for (int i = 1; i < 34; i++) {
for (int j = 0; j < n; j++) {
anc[j][i] = anc[anc[j][i - 1]][i - 1];
sum[j][i] = sum[anc[j][i - 1]][i - 1] + sum[j][i - 1];
mn[j][i] = min(mn[anc[j][i - 1]][i - 1], mn[j][i - 1]);
}
}
for (int i = 0; i < n; i++) {
int ank = i;
long long csum = 0, cmn = 1001001001;
for (long long j = 34; j >= 0; j--) {
if (k & (1ll << j)) {
csum += sum[ank][j];
cmn = min(cmn, mn[ank][j]);
ank = anc[ank][j];
}
}
printf("%I64d %I64d\n", csum, cmn);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
const int LOGK = 41;
int par[LOGK][N];
long long sum[LOGK][N];
int mini[LOGK][N];
int main() {
int n;
long long k;
scanf("%d %lld", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &par[0][i]);
for (int i = 0; i < n; i++) scanf("%d", &sum[0][i]), mini[0][i] = sum[0][i];
for (int i = 1; i < LOGK; i++) {
for (int j = 0; j < n; j++) {
par[i][j] = par[i - 1][par[i - 1][j]];
sum[i][j] = sum[i - 1][j] + sum[i - 1][par[i - 1][j]];
mini[i][j] = min(mini[i - 1][j], mini[i - 1][par[i - 1][j]]);
}
}
for (int i = 0; i < n; i++) {
long long s = 0;
int m = 1000000000;
long long _k = k;
int cur = i;
for (int j = 0; _k; _k >>= 1, j++) {
if (_k & 1) {
s += sum[j][cur];
m = min(m, mini[j][cur]);
cur = par[j][cur];
}
}
printf("%lld %d\n", s, m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 7;
long long n, m, erzi[N][62], sum[N][62], mina[N][62], k;
long long get_power[62];
void read(long long &x) {
x = 0;
char ch = getchar();
long long pd = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') pd = -pd;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x = x * pd;
}
void write(const long long &x) {
long long tmp = x;
long long s = 0;
char g[10001];
if (tmp == 0) {
putchar('0');
return;
}
if (tmp < 0) {
tmp = -tmp;
putchar('-');
}
while (tmp > 0) {
g[s++] = tmp % 10 + '0';
tmp /= 10;
}
while (s > 0) {
putchar(g[--s]);
}
}
signed main() {
read(n);
read(k);
for (register long long i = 1; i <= n; ++i) {
read(erzi[i][0]);
erzi[i][0]++;
}
for (register long long i = 1; i <= n; ++i) {
read(sum[i][0]);
mina[i][0] = sum[i][0];
}
get_power[0] = 1;
for (register long long i = 1; i <= 60; ++i) {
get_power[i] = get_power[i - 1] << 1;
}
for (register long long i = 1; i <= 60; ++i) {
for (register long long j = 1; j <= n; ++j) {
erzi[j][i] = erzi[erzi[j][i - 1]][i - 1];
sum[j][i] = sum[erzi[j][i - 1]][i - 1] + sum[j][i - 1];
mina[j][i] = min(mina[erzi[j][i - 1]][i - 1], mina[j][i - 1]);
}
}
for (register long long i = 1; i <= n; ++i) {
long long ff = i, leave = k, get_sum = 0, get_min = 0x7fffffff;
for (register long long j = 60; j >= 0; --j) {
if (get_power[j] <= leave) {
leave -= get_power[j];
get_sum += sum[ff][j];
get_min = min(get_min, mina[ff][j]);
ff = erzi[ff][j];
}
}
write(get_sum);
putchar(' ');
write(get_min);
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long k;
const int N = 100000 + 10;
const int M = 35;
int f[N][M];
long long sum[N][M];
int mn[N][M];
int inf = 1e9;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> f[i][0];
for (int i = 0; i < n; i++) {
cin >> sum[i][0];
mn[i][0] = sum[i][0];
}
for (int j = 1; j < M; j++) {
for (int i = 0; i < n; i++) {
f[i][j] = f[f[i][j - 1]][j - 1];
sum[i][j] = sum[i][j - 1] + sum[f[i][j - 1]][j - 1];
mn[i][j] =
(mn[i][j - 1] < mn[f[i][j - 1]][j - 1] ? mn[i][j - 1]
: mn[f[i][j - 1]][j - 1]);
}
}
for (int i = 0; i < n; i++) {
long long t1 = k;
int t2 = 0, t3 = i;
long long sk = 0;
int mk = inf;
while (t1) {
if (t1 & 1) {
sk += sum[t3][t2];
mk = (mk < mn[t3][t2] ? mk : mn[t3][t2]);
t3 = f[t3][t2];
}
t1 >>= 1;
t2 += 1;
}
printf("%I64d %d\n", sk, mk);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const int maxp2 = 39;
int n;
long long int par[maxn][maxp2];
long long int sum[maxn][maxp2];
long long int minWeight[maxn][maxp2];
void init() {
for (int j = 1; j <= maxp2 - 1; j++) {
for (int i = 0; i <= n - 1; i++) {
par[i][j] = -1;
}
}
for (int j = 1; j <= maxp2 - 1; j++) {
for (int i = 0; i <= n - 1; i++) {
if (par[i][j - 1] != -1) {
par[i][j] = par[par[i][j - 1]][j - 1];
sum[i][j] = sum[i][j - 1] + sum[par[i][j - 1]][j - 1];
minWeight[i][j] =
min(minWeight[i][j - 1], minWeight[par[i][j - 1]][j - 1]);
}
}
}
}
void solve() {
long long int k;
scanf("%d", &n);
scanf("%lld", &k);
for (int i = 0; i <= n - 1; i++) {
int to;
scanf("%d", &to);
par[i][0] = to;
}
for (int i = 0; i <= n - 1; i++) {
int weight;
scanf("%d", &weight);
sum[i][0] = minWeight[i][0] = weight;
}
init();
for (int i = 0; i <= n - 1; i++) {
long long int s = 0, m = INT_MAX;
long long int left = k, curNode = i;
for (int j = maxp2 - 1; j >= 0; j--) {
if ((1ll << j) <= left) {
left -= (1ll << j);
s += sum[curNode][j];
m = min(m, minWeight[curNode][j]);
curNode = par[curNode][j];
}
}
printf("%lld %lld\n", s, m);
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int n;
long long k;
long long mi[N][50];
long long ans[N][50];
long long f[N][50];
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
int i, j;
for (i = 0; i < n; i++) {
cin >> f[i][0];
}
for (i = 0; i < n; i++) {
cin >> ans[i][0];
mi[i][0] = ans[i][0];
}
for (long long i = 1; i < 50; ++i) {
for (long long j = 0; j < n; ++j) {
long long nxt = f[j][i - 1];
f[j][i] = f[nxt][i - 1];
ans[j][i] = ans[j][i - 1] + ans[nxt][i - 1];
mi[j][i] = min(mi[j][i - 1], mi[nxt][i - 1]);
}
}
for (long long u = 0; u < n; ++u) {
long long s = 0, mx = 1e18, pos = u, x = k;
for (long long i = 49; i >= 0; i--)
if ((x >> i) & 1) {
s += ans[pos][i];
mx = min(mx, mi[pos][i]);
pos = f[pos][i];
}
cout << s << " " << mx << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int M = 2e6 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
long long w[N], k;
int f[N], nx[N][35], n;
long long sum[N][35], mn[N][35];
int main() {
scanf("%d", &n);
scanf("%lld", &k);
for (int i = 0; i < n; i++) scanf("%d", &f[i]);
for (int i = 0; i < n; i++) scanf("%lld", &w[i]);
for (int i = 0; i < n; i++)
nx[i][0] = f[i], sum[i][0] = w[i], mn[i][0] = w[i];
for (int j = 1; j < 35; j++) {
for (int i = 0; i < n; i++) {
nx[i][j] = nx[nx[i][j - 1]][j - 1];
mn[i][j] = min(mn[i][j - 1], mn[nx[i][j - 1]][j - 1]);
sum[i][j] = sum[i][j - 1] + sum[nx[i][j - 1]][j - 1];
}
}
for (int i = 0; i < n; i++) {
int now = i;
long long ans = 0, ret = k, minn = INF;
for (int j = 34; j >= 0; j--) {
if (ret - (1ll << j) >= 0) {
ret -= (1ll << j);
ans += sum[now][j];
minn = min(minn, mn[now][j]);
now = nx[now][j];
}
}
printf("%lld %lld\n", ans, minn);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr long long INF = 0x1fffffffffffffff;
constexpr int inf = 0x3fffffff;
constexpr double inf_l = 1e18;
constexpr long long MOD = 1000000007LL;
constexpr int mod = 1000000007;
vector<long long> f(100001), w(100001);
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> f[i];
for (int i = 0; i < n; ++i) cin >> w[i];
int limit = 0;
while (1LL << limit <= k) ++limit;
vector<vector<long long>> dps(limit + 1, vector<long long>(n, 0)),
dpm(limit + 1, vector<long long>(n, INF)),
dpto(limit + 1, vector<long long>(n, 0));
for (int i = 0; i < n; ++i) {
dps[0][i] = w[i];
dpm[0][i] = w[i];
dpto[0][i] = f[i];
}
for (int i = 1; i <= limit; ++i) {
for (int j = 0; j < n; ++j) {
dps[i][j] = dps[i - 1][j] + dps[i - 1][dpto[i - 1][j]];
dpm[i][j] = min(dpm[i - 1][j], dpm[i - 1][dpto[i - 1][j]]);
dpto[i][j] = dpto[i - 1][dpto[i - 1][j]];
}
}
vector<int> e;
for (int i = 0; 1LL << i <= k; ++i) {
if ((1LL << i) & k) {
e.emplace_back(i);
}
}
for (int i = 0; i < n; ++i) {
long long sum = 0, mn = INF;
int p = i;
for (int j = 0; j < e.size(); ++j) {
sum += dps[e[j]][p];
mn = min(mn, dpm[e[j]][p]);
p = dpto[e[j]][p];
}
cout << sum << ' ' << mn << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
long long K = 34;
vector<vector<long long> > f(K, vector<long long>(n)),
wsum(K, vector<long long>(n)), wmin(K, vector<long long>(n));
for (long long i = (0); i < (n); i++) cin >> f[0][i];
for (long long i = (0); i < (n); i++)
cin >> wsum[0][i], wmin[0][i] = wsum[0][i];
for (long long d = (0); d < (K - 1); d++)
for (long long i = (0); i < (n); i++) {
f[d + 1][i] = f[d][f[d][i]];
wmin[d + 1][i] = min(wmin[d][i], wmin[d][f[d][i]]);
wsum[d + 1][i] = wsum[d][i] + wsum[d][f[d][i]];
}
for (long long i = (0); i < (n); i++) {
long long csum = 0, cmin = INT_MAX, j = i;
for (long long d = (0); d < (K); d++)
if (k & (1LL << d)) {
csum += wsum[d][j];
cmin = min(cmin, wmin[d][j]);
j = f[d][j];
}
cout << csum << " " << cmin << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, min = INT_MAX;
long long sum = 0;
};
vector<int> t(int(1e5 + 9)), w(int(1e5 + 9));
vector<vector<node>> bs(40, vector<node>(int(1e5 + 9)));
void solve(int x, long long k) {
int min_ = INT_MAX;
long long sum = 0;
for (int i = 0; i < 35; i++) {
if (!(k & (1LL << i))) continue;
sum += bs[i][x].sum;
min_ = min(min_, bs[i][x].min);
x = bs[i][x].to;
}
cout << sum << " " << min_ << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
long long k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> t[i];
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = 0; i < n; i++) {
bs[0][i].to = t[i];
bs[0][i].sum = w[i];
bs[0][i].min = w[i];
}
for (int i = 1; i < 40; i++)
for (int j = 0; j < n; j++) {
bs[i][j].to = bs[i - 1][bs[i - 1][j].to].to;
bs[i][j].sum = bs[i - 1][j].sum + bs[i - 1][bs[i - 1][j].to].sum;
bs[i][j].min = min(bs[i - 1][j].min, bs[i - 1][bs[i - 1][j].to].min);
}
for (int i = 0; i < n; i++) solve(i, k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int to;
long long sumW;
int minW;
};
vector<node> mul(const vector<node>& b, const vector<node>& a) {
int n = a.size();
vector<node> ans(n);
for (int i = 0; i < n; ++i) {
ans[i].to = b[a[i].to].to;
ans[i].sumW = a[i].sumW + b[a[i].to].sumW;
ans[i].minW = min(a[i].minW, b[a[i].to].minW);
}
return ans;
}
int main() {
int n;
long long k;
cin >> n >> k;
vector<node> f(n);
for (int i = 0; i < n; ++i) cin >> f[i].to;
for (int i = 0; i < n; ++i) {
int w;
cin >> w;
f[i].sumW = f[i].minW = w;
}
vector<node> ans = f;
k--;
while (k) {
if (k & 1) ans = mul(ans, f);
f = mul(f, f);
k >>= 1;
}
for (int i = 0; i < n; ++i) cout << ans[i].sumW << " " << ans[i].minW << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[100010];
long long b[100010];
long long BZ[100010][40];
long long Min[100010][40];
long long Sum[100010][40];
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 0; i < n; ++i) scanf("%lld", &BZ[i][0]);
for (long long i = 0; i < n; ++i) {
scanf("%lld", &Min[i][0]);
Sum[i][0] = Min[i][0];
}
for (long long i = 1; i < 40; ++i) {
for (long long j = 0; j < n; ++j) {
BZ[j][i] = BZ[BZ[j][i - 1]][i - 1];
Min[j][i] = min(Min[j][i - 1], Min[BZ[j][i - 1]][i - 1]);
Sum[j][i] = Sum[j][i - 1] + Sum[BZ[j][i - 1]][i - 1];
}
}
for (long long i = 0; i < n; ++i) {
long long x = 0, y = 2147483647;
long long d = i;
long long kk = k;
for (long long j = 39; j >= 0; --j)
if (kk >= (1ll << j)) {
kk -= 1ll << j;
x += Sum[d][j];
y = min(y, Min[d][j]);
d = BZ[d][j];
}
printf("%lld %lld\n", x, y);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
struct Sum {
int min;
long long sum;
Sum() : min(INF), sum(0) {}
explicit Sum(int w) : min(w), sum(w) {}
Sum &operator+=(const Sum &that) {
amin(min, that.min);
sum += that.sum;
return *this;
}
};
int main() {
int n;
long long len;
while (~scanf("%d%lld", &n, &len)) {
vector<int> f(n);
for (int i = 0; i < n; ++i) scanf("%d", &f[i]);
vector<int> w(n);
for (int i = 0; i < n; ++i) scanf("%d", &w[i]);
vector<pair<int, Sum>> pow(n), npow(n);
for (int(i) = 0; (i) < (int)(n); ++(i)) pow[i] = {f[i], Sum(w[i])};
vector<pair<int, Sum>> ans(n);
for (int(i) = 0; (i) < (int)(n); ++(i)) ans[i] = {i, Sum()};
long long rem = len;
for (long long p = 1; rem > 0; p *= 2) {
if (rem & p) {
for (int(i) = 0; (i) < (int)(n); ++(i)) {
auto &x = pow[ans[i].first];
ans[i].first = x.first;
ans[i].second += x.second;
}
rem -= p;
}
npow = pow;
for (int(i) = 0; (i) < (int)(n); ++(i)) {
auto &x = pow[pow[i].first];
npow[i].first = x.first;
npow[i].second += x.second;
}
pow.swap(npow);
}
for (int(i) = 0; (i) < (int)(n); ++(i)) {
const Sum &sum = ans[i].second;
printf("%lld %d\n", sum.sum, sum.min);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int logN = 35;
long long nxt[N][logN], minVal[N][logN], sum[N][logN];
int n;
long long k;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> nxt[i][0];
}
for (int i = 0; i < n; ++i) {
cin >> minVal[i][0];
sum[i][0] = minVal[i][0];
}
for (int j = 1; j < logN; ++j) {
for (int i = 0; i < n; ++i) {
nxt[i][j] = nxt[nxt[i][j - 1]][j - 1];
minVal[i][j] = min(minVal[i][j - 1], minVal[nxt[i][j - 1]][j - 1]);
sum[i][j] = sum[i][j - 1] + sum[nxt[i][j - 1]][j - 1];
}
}
for (int i = 0; i < n; ++i) {
long long curPos = i, s = 0, minAns = INT_MAX;
for (int j = logN - 1; j >= 0; --j) {
if (((k >> j) & 1)) {
s += sum[curPos][j];
minAns = min(minAns, minVal[curPos][j]);
curPos = nxt[curPos][j];
}
}
cout << s << ' ' << minAns << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
using vint = vector<long long>;
using pint = pair<long long, long long>;
using vpint = vector<pint>;
template <typename A, typename B>
inline void chmin(A& a, B b) {
if (a > b) a = b;
}
template <typename A, typename B>
inline void chmax(A& a, B b) {
if (a < b) a = b;
}
template <class A, class B>
ostream& operator<<(ostream& ost, const pair<A, B>& p) {
ost << "{" << p.first << "," << p.second << "}";
return ost;
}
template <class T>
ostream& operator<<(ostream& ost, const vector<T>& v) {
ost << "{";
for (long long i = 0; i < v.size(); i++) {
if (i) ost << ",";
ost << v[i];
}
ost << "}";
return ost;
}
inline long long topbit(unsigned long long x) {
return x ? 63 - __builtin_clzll(x) : -1;
}
inline long long popcount(unsigned long long x) {
return __builtin_popcountll(x);
}
inline long long parity(unsigned long long x) { return __builtin_parity(x); }
const long long INF = 1001001001;
long long N, K;
long long F[111111], W[111111];
long long nex[40][111111];
long long sum[40][111111];
long long mi[40][111111];
signed main() {
scanf("%lld%lld", &N, &K);
for (long long i = 0; i < (N); i++) scanf("%lld", &F[i]);
for (long long i = 0; i < (N); i++) scanf("%lld", &W[i]);
for (long long i = 0; i < (N); i++) {
nex[0][i] = F[i];
sum[0][i] = mi[0][i] = W[i];
}
for (long long k = 0; k + 1 < 40; k++) {
for (long long i = 0; i < (N); i++) {
sum[k + 1][i] = sum[k][i] + sum[k][nex[k][i]];
mi[k + 1][i] = min(mi[k][i], mi[k][nex[k][i]]);
nex[k + 1][i] = nex[k][nex[k][i]];
}
}
for (long long i = 0; i < (N); i++) {
long long pos = i, s = 0, m = INF;
for (long long j = 0; j < (40); j++) {
if (K >> j & 1) {
s += sum[j][pos];
chmin(m, mi[j][pos]);
pos = nex[j][pos];
}
}
printf("%lld %lld\n", s, m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fa[100010][35], Min[100010][35];
long long w[100010][35], n, k;
long long Sum(int x, long long p) {
if (p == 0) return 0;
int t = 0;
long long sum = 1;
while (sum <= p) {
t++;
sum <<= 1;
}
t--;
sum >>= 1;
return w[x][t] + Sum(fa[x][t], p - sum);
}
int Minn(int x, long long p) {
if (p == 0) return 1e9;
int t = 0;
long long sum = 1;
while (sum <= p) {
t++;
sum <<= 1;
}
t--;
sum >>= 1;
return min(Min[x][t], Minn(fa[x][t], p - sum));
}
int main() {
scanf("%I64d%I64d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &fa[i][0]);
for (int i = 0; i < n; i++) scanf("%I64d", &w[i][0]), Min[i][0] = w[i][0];
for (int i = 1; i <= 34; i++)
for (int j = 0; j < n; j++) fa[j][i] = fa[fa[j][i - 1]][i - 1];
for (int i = 1; i <= 34; i++)
for (int j = 0; j < n; j++) w[j][i] = w[j][i - 1] + w[fa[j][i - 1]][i - 1];
for (int i = 1; i <= 34; i++)
for (int j = 0; j < n; j++)
Min[j][i] = min(Min[j][i - 1], Min[fa[j][i - 1]][i - 1]);
for (int i = 0; i < n; i++) printf("%I64d %d\n", Sum(i, k), Minn(i, k));
}
|
#include <bits/stdc++.h>
using namespace std;
struct V {
int p[35];
long long s[35];
long long m[35];
} v[100000];
int main() {
int n;
long long k;
scanf("%d%I64d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &v[i].p[0]);
for (int i = 0; i < n; i++) {
int w;
scanf("%d", &w);
v[i].m[0] = v[i].s[0] = w;
}
for (int j = 1; j < 35; j++) {
for (int i = 0; i < n; i++) {
V& cv = v[i];
cv.p[j] = v[cv.p[j - 1]].p[j - 1];
cv.s[j] = cv.s[j - 1] + v[cv.p[j - 1]].s[j - 1];
cv.m[j] = min(cv.m[j - 1], v[cv.p[j - 1]].m[j - 1]);
}
}
for (int i = 0; i < n; i++) {
int cur = i;
long long m = 0x1234567890123456LL;
long long s = 0;
for (int j = 0; j < 35; j++) {
if ((k & (1LL << j)) == 0) continue;
m = min(m, v[cur].m[j]);
s += v[cur].s[j];
cur = v[cur].p[j];
}
printf("%I64d %I64d\n", s, m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &FF) {
int RR = 1;
FF = 0;
char CH = getchar();
for (; !isdigit(CH); CH = getchar())
if (CH == '-') RR = -RR;
for (; isdigit(CH); CH = getchar()) FF = FF * 10 + CH - 48;
FF *= RR;
}
inline void file(string str) {
freopen((str + ".in").c_str(), "r", stdin);
freopen((str + ".out").c_str(), "w", stdout);
}
const int N = 1e5 + 10, Log = 40;
int son[N][Log + 1], n;
long long k, val[N][Log + 1], sb[N][Log + 1];
void solve(int x) {
long long pi = 1, ri = 0, minx = INT_MAX, res = 0;
for (long long i = 1; i <= 40; i++) pi *= 2;
for (int i = Log; i >= 0; i--, pi /= 2)
if (ri + pi <= k) {
minx = min(minx, sb[x][i]);
res += val[x][i];
x = son[x][i];
ri += pi;
}
printf("%lld %lld\n", res, minx);
}
int main() {
read(n), read(k);
for (int i = 1; i <= n; i++) read(son[i][0]), son[i][0] += 1;
for (int i = 1; i <= n; i++) read(val[i][0]), sb[i][0] = val[i][0];
for (int i = 1; i <= Log; i++)
for (int j = 1; j <= n; j++) {
son[j][i] = son[son[j][i - 1]][i - 1];
sb[j][i] = min(sb[j][i - 1], sb[son[j][i - 1]][i - 1]);
val[j][i] = val[j][i - 1] + val[son[j][i - 1]][i - 1];
}
for (int i = 1; i <= n; i++) solve(i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n;
long long k;
long long f[N][55], w[N][55], m[N][55];
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> f[i][0];
}
memset(m, 0x3f3f3f3f, sizeof m);
for (int i = 0; i < n; i++) {
cin >> w[i][0];
m[i][0] = w[i][0];
}
for (int i = 1; i < 34; i++) {
for (int j = 0; j < n; j++) {
f[j][i] = f[f[j][i - 1]][i - 1];
w[j][i] = w[j][i - 1] + w[f[j][i - 1]][i - 1];
m[j][i] = min(m[j][i - 1], m[f[j][i - 1]][i - 1]);
}
}
for (int G = 0; G < n; G++) {
long long MIN = 1e18, sum = 0;
int r = G;
for (int i = 0; i < 34; i++) {
if (k & (1ll << i)) {
MIN = min(MIN, m[r][i]);
sum += w[r][i];
r = f[r][i];
}
}
cout << sum << ' ' << MIN << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 10;
const double eps = 1e-9;
const long long inf = 1e18;
long long to[mx][40], par[mx];
long long mn[mx][40], sum[mx][40], w[mx], a[mx];
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", a + i);
}
for (int i = 0; i < n; i++) {
scanf("%lld", w + i);
}
for (int i = 0; i < n; i++) {
sum[i][0] = w[i];
mn[i][0] = w[i];
to[i][0] = a[i];
}
for (int lg = 1; lg < 35; lg++) {
for (int i = 0; i < n; i++) {
to[i][lg] = to[to[i][lg - 1]][lg - 1];
sum[i][lg] = sum[i][lg - 1] + sum[to[i][lg - 1]][lg - 1];
mn[i][lg] = min(mn[i][lg - 1], mn[to[i][lg - 1]][lg - 1]);
}
}
for (int i = 0; i < n; i++) {
int ii = i;
long long sumans = 0, mnn = inf;
for (int lg = 0; lg < 35; lg++) {
if (k & (1ll << lg)) {
mnn = min(mnn, 1ll * mn[ii][lg]);
sumans += sum[ii][lg];
ii = to[ii][lg];
}
}
printf("%lld %lld\n", sumans, mnn);
}
}
|
#include <bits/stdc++.h>
const int Inf = 2 * 1000 * 1000 * 1000;
long long LINF = (long long)4e18;
using namespace std;
const int nax = 1000 * 100 + 5;
const int LOGN = 60;
long long nt[LOGN][nax];
long long s[LOGN][nax];
long long mn[LOGN][nax];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> a(n);
vector<long long> vals(n);
for (auto &x : a) cin >> x;
for (auto &x : vals) cin >> x;
for (int i = 0; i < n; i++) {
nt[0][i] = a[i];
s[0][i] = vals[i];
mn[0][i] = vals[i];
}
for (int i = 1; i < LOGN; i++) {
for (int j = 0; j < n; j++) {
nt[i][j] = nt[i - 1][nt[i - 1][j]];
s[i][j] = s[i - 1][j] + s[i - 1][nt[i - 1][j]];
mn[i][j] = min(mn[i - 1][j], mn[i - 1][nt[i - 1][j]]);
}
}
for (int i = 0; i < n; i++) {
long long minval = 4e18;
long long sum = 0;
int v = i;
for (int j = 0; j < LOGN; j++) {
if (k & (1LL << j)) {
sum += s[j][v];
minval = min(minval, mn[j][v]);
v = nt[j][v];
}
}
cout << sum << ' ' << minval << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long i, i1, j, k, k1, t, n, m, res, flag[10], a, b, s;
long long f[100010], w[100010], jm[35][100010], sts[35][100010],
stm[35][100010];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> f[i];
f[i]++;
}
for (i = 1; i <= n; i++) {
cin >> w[i];
}
for (j = 1; j <= n; j++) {
jm[0][j] = f[j];
sts[0][j] = w[j];
stm[0][j] = w[j];
}
for (i = 1; i < 35; i++) {
for (j = 1; j <= n; j++) {
jm[i][j] = jm[i - 1][jm[i - 1][j]];
sts[i][j] = sts[i - 1][j] + sts[i - 1][jm[i - 1][j]];
stm[i][j] = min(stm[i - 1][j], stm[i - 1][jm[i - 1][j]]);
}
}
for (i = 1; i <= n; i++) {
a = 0;
b = (long long)1e18;
s = i;
for (j = 0; j < 35; j++) {
if ((k >> j) & 1) {
a += sts[j][s];
b = min(b, stm[j][s]);
s = jm[j][s];
}
}
cout << a << ' ' << b << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000009;
const long long INFL = 1e18 + 5LL;
const long double EPS = 1e-11;
const long long MOD = 998244353;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n, k;
cin >> n >> k;
vector<long long> f(n), w(n);
for (int i = 0; i < n; ++i) {
cin >> f[i];
}
for (int i = 0; i < n; ++i) {
cin >> w[i];
}
vector<long long> s(w), m(w), v(f);
for (int di = 44; di >= 0; --di) {
if ((k >> di) < 2LL) {
continue;
}
vector<long long> ns(s), nm(m), nv(v);
for (int i = 0; i < n; ++i) {
ns[i] += s[v[i]];
nm[i] = min(nm[i], m[v[i]]);
nv[i] = v[v[i]];
}
if ((k >> di) & 1) {
for (int i = 0; i < n; ++i) {
ns[i] += w[nv[i]];
nm[i] = min(nm[i], w[nv[i]]);
nv[i] = f[nv[i]];
}
}
s = ns;
m = nm;
v = nv;
}
for (int i = 0; i < n; ++i) {
cout << s[i] << " " << m[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
const double eps = 1e-9;
int ts, kk = 1;
int n, mx;
long long int p[3][40][100005], m, q;
int main() {
int i, j, k, t;
memset(p, -1, sizeof(p));
scanf("%d%lld", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d", &k);
p[0][0][i] = k;
}
for (i = 0; i < n; i++) {
scanf("%d", &k);
p[1][0][i] = k;
p[2][0][i] = k;
}
for (i = 1; (1LL << i) <= m; i++) {
for (j = 0; j < n; j++)
if (p[0][i - 1][j] != -1) {
k = p[0][i - 1][j];
p[0][i][j] = p[0][i - 1][k];
p[1][i][j] = p[1][i - 1][j] + p[1][i - 1][k];
p[2][i][j] = min(p[2][i - 1][j], p[2][i - 1][k]);
}
}
mx = i - 1;
for (j = 0; j < n; j++) {
q = m;
long long int r1, r2;
r1 = 0;
r2 = (LLONG_MAX / 10LL);
k = j;
for (i = mx; i > -1; i--) {
if ((1LL << i) <= q) {
q -= (1LL << i);
r1 += p[1][i][k];
r2 = min(r2, p[2][i][k]);
k = p[0][i][k];
}
}
printf("%lld %lld\n", r1, r2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 10000000000000;
const int MAXN = 100010;
const int MAXLOG = 50;
long long int par[MAXN][MAXLOG];
long long int ans[MAXN][MAXLOG];
long long int mini[MAXN][MAXLOG];
pair<long long int, long long int> solve(long long int a, long long int b) {
long long int ret1 = 0, ret2 = INF;
long long int now = a;
vector<long long int> bini;
while (b != 0) {
bini.push_back(b % 2);
b /= 2;
}
while (bini.size() != MAXLOG) bini.push_back(0);
for (int j = MAXLOG - 1; j >= 0; j--) {
if (bini[j] == 1) {
ret1 += ans[now][j];
ret2 = min(ret2, mini[now][j]);
now = par[now][j];
}
}
return make_pair(ret1, ret2);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios::sync_with_stdio(0);
cout.tie(0);
long long int n, k;
cin >> n >> k;
for (int j = 0; j < MAXLOG; j++) {
for (int i = 0; i < n; i++) {
mini[i][j] = INF;
}
}
for (int i = 0; i < n; i++) {
cin >> par[i][0];
}
for (int i = 0; i < n; i++) {
cin >> ans[i][0];
mini[i][0] = ans[i][0];
}
for (int j = 1; j < MAXLOG; j++) {
for (int i = 0; i < n; i++) {
par[i][j] = par[par[i][j - 1]][j - 1];
}
}
for (int j = 1; j < MAXLOG; j++) {
for (int i = 0; i < n; i++) {
ans[i][j] = ans[i][j - 1] + ans[par[i][j - 1]][j - 1];
}
}
for (int j = 1; j < MAXLOG; j++) {
for (int i = 0; i < n; i++) {
mini[i][j] = min(mini[i][j - 1], mini[par[i][j - 1]][j - 1]);
}
}
for (int i = 0; i < n; i++) {
pair<long long int, long long int> answer = solve(i, k);
cout << answer.first << ' ' << answer.second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, f[100005][35], m[100005][35], s[100005][35];
void build(bool x) {
for (int b = 1; b < 35; b++) {
for (int i = 0; i < n; i++) {
if (x)
m[i][b] = min(m[i][b - 1], m[f[i][b - 1]][b - 1]);
else
s[i][b] = s[i][b - 1] + s[f[i][b - 1]][b - 1];
}
}
}
long long query(long long l, long long len, bool x) {
long long a1 = 1e10, a2 = 0;
for (int b = 34; b >= 0; b--) {
long long z = (1LL) << b;
if (len >= z) {
if (x)
a1 = min(a1, m[l][b]);
else
a2 += s[l][b];
l = f[l][b];
len -= z;
}
}
return ((x) ? a1 : a2);
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> f[i][0];
for (int i = 0; i < n; i++) cin >> m[i][0], s[i][0] = m[i][0];
for (int b = 1; b < 35; b++)
for (int i = 0; i < n; i++) m[i][b] = 1e9;
for (int b = 1; b < 35; b++)
for (int i = 0; i < n; i++) f[i][b] = f[f[i][b - 1]][b - 1];
build(0), build(1);
for (int i = 0; i < n; i++)
cout << query(i, k, 0) << " " << query(i, k, 1) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> seg[2];
vector<int> ring_weight, ring_id;
void init(int n) {
for (int i = 0; i < int(2); i++) {
seg[i].resize(4 * n + 3);
}
}
void make(int node, int u, int v) {
if (u == v) {
seg[0][node] = seg[1][node] = ring_weight[u];
return;
}
int ls = (node << 1) | 1, rs = ls + 1, m = (u + v) >> 1;
make(ls, u, m);
make(rs, m + 1, v);
seg[0][node] = seg[0][ls] + seg[0][rs];
seg[1][node] = min(seg[1][ls], seg[1][rs]);
}
tuple<long long, int> read(int node, int u, int v, int first, int second) {
if (first > v || second < u) {
return make_pair(0, 1 << 30);
}
if (first <= u && v <= second) {
return make_pair(seg[0][node], seg[1][node]);
}
int ls = (node << 1) | 1, rs = ls + 1, m = (u + v) >> 1;
long long lx, rx;
int ly, ry;
tie(lx, ly) = read(ls, u, m, first, second);
tie(rx, ry) = read(rs, m + 1, v, first, second);
return make_pair(lx + rx, min(ly, ry));
}
vector<int> seen;
vector<int> ring_nodes;
vector<int> f, w;
vector<vector<int> > r, g;
int dfs(int u, int c) {
seen[u] = c;
if (seen[f[u]] == c) {
ring_id[u] = int((ring_nodes).size());
ring_nodes.push_back(u);
return (u == f[u] ? -1 : f[u]);
}
if (seen[f[u]] != -1) {
return -1;
}
int t = dfs(f[u], c);
if (t != -1) {
ring_id[u] = int((ring_nodes).size());
ring_nodes.push_back(u);
}
return (t == u ? -1 : t);
}
vector<tuple<long long, int> > ans;
vector<int> M, D;
vector<long long> W;
tuple<long long, int> get_ans(int id, long long h) {
long long first = 0;
int second = 1 << 30;
if (h >= int((ring_nodes).size())) {
first = h / int((ring_nodes).size()) * seg[0][0];
second = seg[1][0];
}
h %= int((ring_nodes).size());
if (h <= 0) {
return make_pair(first, second);
}
int jd = (id + h - 1 + int((ring_nodes).size())) % int((ring_nodes).size());
if (jd < id) {
long long tx;
int ty;
tie(tx, ty) = read(0, 0, int((ring_nodes).size()) - 1, id,
int((ring_nodes).size()) - 1);
first += tx;
second = min(second, ty);
tie(tx, ty) = read(0, 0, int((ring_nodes).size()) - 1, 0, jd);
first += tx;
second = min(second, ty);
} else {
long long tx;
int ty;
tie(tx, ty) = read(0, 0, int((ring_nodes).size()) - 1, id, jd);
first += tx;
second = min(second, ty);
}
return make_pair(first, second);
}
long long k;
vector<int> Q, to;
long long dp[3][20][100005];
void bfs() {
int fr = 0, bk = 0;
for (int i = 0; i < int(int((ring_nodes).size())); i++) {
M[ring_nodes[i]] = 1 << 30;
W[ring_nodes[i]] = 0;
D[ring_nodes[i]] = 0;
Q[bk++] = ring_nodes[i];
while (fr < bk) {
int u = Q[fr++];
if (D[u] < k) {
long long first;
int second;
tie(first, second) = get_ans(i, k - D[u]);
first += W[u];
second = min(second, M[u]);
ans[u] = make_pair(first, second);
} else {
to.push_back(u);
}
for (int j = 0; j < int(int((r[u]).size())); j++) {
int v = r[u][j];
if (ring_id[v] != -1) {
continue;
}
D[v] = D[u] + 1;
W[v] = W[u] + g[u][j];
M[v] = min(M[u], g[u][j]);
Q[bk++] = v;
dp[0][0][v] = u;
dp[1][0][v] = g[u][j];
dp[2][0][v] = g[u][j];
}
}
}
}
void solve(int u) {
ring_nodes.clear();
dfs(u, u);
if (int((ring_nodes).size()) == 0) {
return;
}
reverse((ring_nodes).begin(), (ring_nodes).end());
ring_weight.clear();
for (auto e : (ring_nodes)) {
ring_weight.push_back(w[e]);
}
init(int((ring_nodes).size()));
make(0, 0, int((ring_nodes).size()) - 1);
bfs();
}
tuple<long long, int> get(int u, int k, int l) {
long long first = 0;
int second = 1 << 30;
for (int i = l; i >= 0; i--) {
if (dp[0][i][u] == -1 || k < (1 << i)) {
continue;
}
first += dp[1][i][u];
second = min(dp[2][i][u], 1ll * second);
u = dp[0][i][u];
k -= 1 << i;
}
return make_pair(first, second);
}
int main() {
std::ios_base::sync_with_stdio(false);
int n;
cin >> n >> k;
seen.resize(n, -1);
f.resize(n);
w.resize(n);
r.resize(n);
g.resize(n);
M.resize(n);
W.resize(n);
D.resize(n);
Q.resize(n);
ans.resize(n);
ring_id.resize(n, -1);
for (int i = 0; i < int(n); i++) {
cin >> f[i];
}
for (int i = 0; i < int(n); i++) {
cin >> w[i];
}
for (int i = 0; i < int(n); i++) {
r[f[i]].push_back(i);
g[f[i]].push_back(w[i]);
}
memset(dp, -1, sizeof(dp));
for (int i = 0; i < int(n); i++) {
if (seen[i] == -1) {
solve(i);
}
}
if (int((to).size())) {
for (int i = 1; (1 << i) <= n; i++) {
for (int j = 0; j < int(n); j++) {
int t = dp[0][i - 1][j];
if (t != -1) {
dp[0][i][j] = dp[0][i - 1][t];
dp[1][i][j] = dp[1][i - 1][j] + dp[1][i - 1][t];
dp[2][i][j] = min(dp[2][i - 1][j], dp[2][i - 1][t]);
}
}
}
int l = 31 - __builtin_clz(k);
for (auto e : (to)) {
ans[e] = get(e, k, l);
}
}
for (auto a : (ans)) {
long long first;
int second;
tie(first, second) = a;
cout << first << " " << second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, ans[100001][51];
long long Min[100001][51], son[100001][51], er[41], num, l[41];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> son[i][0];
for (int i = 0; i < n; i++) {
cin >> ans[i][0];
Min[i][0] = ans[i][0];
}
for (int i = 1; i <= 40; i++) {
for (int j = 0; j < n; j++) {
son[j][i] = son[son[j][i - 1]][i - 1];
}
}
for (int i = 1; i <= 40; i++)
for (int j = 0; j < n; j++) {
Min[j][i] = min(Min[j][i - 1], Min[son[j][i - 1]][i - 1]);
ans[j][i] = ans[j][i - 1] + ans[son[j][i - 1]][i - 1];
}
er[0] = 1;
for (int i = 1; i <= 40; i++) er[i] = er[i - 1] * 2;
for (int i = 40; i >= 0; i--) {
if (k >= er[i]) {
num++;
l[num] = i;
k = k - er[i];
}
}
for (int i = 0; i < n; i++) {
long long x = i;
long long minn = 1000000000000;
long long anss = 0;
for (int j = 1; j <= num; j++) {
minn = min(minn, Min[x][l[j]]);
anss = anss + ans[x][l[j]];
x = son[x][l[j]];
}
cout << anss << " " << minn << endl;
}
}
|
#include <bits/stdc++.h>
typedef int iarrN[100003][35];
struct IO {
template <typename T>
inline IO operator>>(T &n) {
n = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9')
n = (n << 3) + (n << 1) + (c ^ 48), c = getchar();
return *this;
}
} cin;
constexpr int MX = 33, inf = 0x3f3f3f3f;
int N, son[100003][35], mnw[100003][35];
long long K, sw[100003][35];
void init() {
cin >> N >> K;
for (int i = 1; i <= N; ++i) cin >> son[i][0], ++son[i][0];
for (int i = 1; i <= N; ++i) cin >> mnw[i][0], sw[i][0] = mnw[i][0];
for (int j = 1; j <= MX; ++j)
for (int i = 1; i <= N; ++i) {
son[i][j] = son[son[i][j - 1]][j - 1];
sw[i][j] = sw[i][j - 1] + sw[son[i][j - 1]][j - 1];
mnw[i][j] = std::min(mnw[i][j - 1], mnw[son[i][j - 1]][j - 1]);
}
}
inline void query(int u) {
int ansmn = inf;
long long k = K, anss = 0;
for (int i = MX; i >= 0; --i)
if (k >= (1ll << i)) {
k -= 1ll << i;
anss += sw[u][i];
ansmn = std::min(ansmn, mnw[u][i]);
u = son[u][i];
}
printf("%I64d %d\n", anss, ansmn);
}
int main() {
init();
for (int i = 1; i <= N; ++i) query(i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[120000][40], h[120000][40], i, j, k, n, x, t;
long long m, s, g[120000][40];
int main() {
scanf("%d%I64d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &x), f[i][0] = ++x;
for (i = 1; i <= n; i++) scanf("%d", &x), g[i][0] = h[i][0] = x;
for (i = 1; (1LL << i) <= m; i++)
for (j = 1; j <= n; j++) {
f[j][i] = f[f[j][i - 1]][i - 1];
g[j][i] = g[j][i - 1] + g[f[j][i - 1]][i - 1];
h[j][i] = min(h[j][i - 1], h[f[j][i - 1]][i - 1]);
}
for (i = 1; i <= n; i++) {
k = i, s = 0, t = h[i][0];
for (j = 0; (1LL << j) <= m; j++)
if ((1LL << j) & m) s += g[k][j], t = min(t, h[k][j]), k = f[k][j];
printf("%I64d %d\n", s, t);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int sa_next[34][100010];
int sa_min[34][100010];
long long sa_sum[34][100010];
void Solve() {
int i, j, n, m;
long long k;
scanf("%d %I64d", &n, &k);
for (int _i = 0; _i < (n); _i++) scanf("%d", &((sa_next[0])[_i]));
for (i = 0; i < n; i++) {
scanf("%d", &(sa_min[0][i]));
sa_sum[0][i] = sa_min[0][i];
}
for (i = 1; i < 34; i++)
for (j = 0; j < n; j++) {
sa_next[i][j] = sa_next[i - 1][sa_next[i - 1][j]];
sa_min[i][j] = min(sa_min[i - 1][j], sa_min[i - 1][sa_next[i - 1][j]]);
sa_sum[i][j] = sa_sum[i - 1][j] + sa_sum[i - 1][sa_next[i - 1][j]];
}
for (i = 0; i < n; i++) {
long long v = 1ll << (34 - 1);
long long kk = k;
int mn = 1000000000;
long long sum = 0;
int u = i;
for (j = 34 - 1; j >= 0; j--, v >>= 1) {
if (v <= kk) {
kk -= v;
sum += sa_sum[j][u];
mn = min(mn, sa_min[j][u]);
u = sa_next[j][u];
}
}
printf("%I64d %d\n", sum, mn);
}
}
int main() {
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 100010, K = 50;
long long n, k, son[N][K], mis[N][K], mi[N][K];
long long getMis(long long c, long long x) {
if (!x) return x;
long long p = 0, dp = 1;
while (dp <= x) {
p++;
dp <<= 1;
}
p--;
dp >>= 1;
return mis[c][p] + getMis(son[c][p], x - dp);
}
long long getMi(long long c, long long x) {
if (!x) return 0x3f3f3f3f;
long long p = 0, dp = 1;
while (dp <= x) {
p++;
dp <<= 1;
}
p--;
dp >>= 1;
return min(mi[c][p], getMi(son[c][p], x - dp));
}
int main() {
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> son[i][0];
for (long long i = 0; i < n; i++) {
cin >> mis[i][0];
mi[i][0] = mis[i][0];
}
for (long long p = 1; p < K; p++) {
for (long long i = 0; i < n; i++) {
son[i][p] = son[son[i][p - 1]][p - 1];
}
}
for (long long p = 1; p < K; p++) {
for (long long i = 0; i < n; i++) {
mi[i][p] = min(mi[i][p - 1], mi[son[i][p - 1]][p - 1]);
mis[i][p] = mis[i][p - 1] + mis[son[i][p - 1]][p - 1];
}
}
for (long long i = 0; i < n; i++) {
cout << getMis(i, k) << ' ' << getMi(i, k) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct step {
long long to, len, min;
step(){};
step(pair<long, long> p) {
to = p.first;
len = p.second;
min = p.second;
}
};
long long n, k, l = 0;
vector<bool> used;
vector<pair<long long, long long> > g, ans;
vector<vector<step> > f;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
g.resize(n);
ans.resize(n);
used.resize(n, false);
for (long long i = 0; i < n; i++) cin >> g[i].first;
for (long long i = 0; i < n; i++) cin >> g[i].second;
while ((1ll << l) <= k) l++;
f.resize(l, vector<step>(n));
for (long long i = 0; i < l; i++) {
for (long long y = 0; y < n; y++) {
if (i == 0)
f[i][y] = step(g[y]);
else {
f[i][y].to = f[i - 1][f[i - 1][y].to].to;
f[i][y].len = f[i - 1][y].len + f[i - 1][f[i - 1][y].to].len;
f[i][y].min = min(f[i - 1][y].min, f[i - 1][f[i - 1][y].to].min);
}
}
}
for (long long i = 0; i < n; i++) {
long long kk = k, from = i, len = 0, mymin = 1e18, it = l;
while (kk > 0) {
if ((1ll << it) <= kk) {
kk -= (1ll << it);
len += f[it][from].len;
mymin = min(mymin, f[it][from].min);
from = f[it][from].to;
} else
it--;
}
ans[i] = {len, mymin};
}
for (long long i = 0; i < n; i++)
cout << ans[i].first << ' ' << ans[i].second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T lowbit(T x) {
return x & (-x);
}
const long long INF = 1e18;
const int MAXN = 1e5 + 5;
const int BIT = 35;
int nxt[MAXN][BIT];
long long cost[MAXN][BIT], min_cost[MAXN][BIT];
int main(void) {
int n;
long long k;
scanf("%d%lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &nxt[i][0]);
}
for (int i = 0; i < n; i++) {
scanf("%lld", &cost[i][0]);
min_cost[i][0] = cost[i][0];
}
for (int i = 1; i < BIT; i++) {
for (int j = 0; j < n; j++) {
nxt[j][i] = nxt[nxt[j][i - 1]][i - 1];
cost[j][i] = cost[j][i - 1] + cost[nxt[j][i - 1]][i - 1];
min_cost[j][i] = min(min_cost[j][i - 1], min_cost[nxt[j][i - 1]][i - 1]);
}
}
for (int i = 0; i < n; i++) {
long long s = 0, Min = INF;
int u = i;
for (int i = 0; i < BIT; i++) {
if ((k >> i) & 1) {
s += cost[u][i];
Min = min(Min, min_cost[u][i]);
u = nxt[u][i];
}
}
printf("%lld %lld\n", s, Min);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long dp1[100005][40], dp2[100005][40], dp3[100005][40];
long long ans1[100005], ans2[100005];
int main() {
scanf("%lld", &n);
scanf("%lld", &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &dp1[i][0]);
}
for (int i = 0; i < n; i++) {
ans2[i] = 2e10;
ans1[i] = 0;
scanf("%lld", &dp2[i][0]);
dp3[i][0] = dp2[i][0];
}
for (int i = 1; i <= 38; i++) {
for (int j = 0; j < n; j++) {
dp1[j][i] = dp1[dp1[j][i - 1]][i - 1];
dp2[j][i] = dp2[j][i - 1] + dp2[dp1[j][i - 1]][i - 1];
dp3[j][i] = min(dp3[j][i - 1], dp3[dp1[j][i - 1]][i - 1]);
}
}
for (int i = 0; i < n; i++) {
long long kk = k;
int u = i;
for (long long j = 38; j >= 0; j--) {
if ((kk - ((long long)1 << j)) >= 0) {
ans1[i] += dp2[u][j];
ans2[i] = min(ans2[i], dp3[u][j]);
kk -= ((long long)1 << j);
u = dp1[u][j];
}
}
}
for (int i = 0; i < n; i++) {
printf("%lld %lld\n", ans1[i], ans2[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, L = 40;
long long s[N][L], p[N][L], m[N][L];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> p[i][0];
}
for (int i = 0; i < n; i++) {
cin >> s[i][0];
m[i][0] = s[i][0];
}
for (int j = 1; j < L; j++) {
for (int i = 0; i < n; i++) {
p[i][j] = p[p[i][j - 1]][j - 1];
s[i][j] = s[i][j - 1] + s[p[i][j - 1]][j - 1];
m[i][j] = min(m[i][j - 1], m[p[i][j - 1]][j - 1]);
}
}
for (int i = 0; i < n; i++) {
long long sum = 0, mn = 1e18, u = i, x = k, c = 0;
while (x > 0) {
if (x & 1) {
sum += s[u][c];
mn = min(mn, m[u][c]);
u = p[u][c];
}
x >>= 1;
c++;
}
cout << sum << " " << mn << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
template <class T, class U>
inline T tmin(T a, U b) {
return (a < b) ? a : b;
}
template <class T, class U>
inline T tmax(T a, U b) {
return (a > b) ? a : b;
}
template <class T, class U>
inline void amax(T &a, U b) {
if (b > a) a = b;
}
template <class T, class U>
inline void amin(T &a, U b) {
if (b < a) a = b;
}
template <class T>
inline T tabs(T a) {
return (a > 0) ? a : -a;
}
template <class T>
T gcd(T a, T b) {
while (b != 0) {
T c = a;
a = b;
b = c % b;
}
return a;
}
const int N = 100005, D = 35;
int f[N][D], m[N][D];
long long s[N][D];
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(false);
int n;
long long k;
cin >> n >> k;
for (int i = (0); i < (n); ++i) cin >> f[i][0];
for (int i = (0); i < (n); ++i) {
cin >> m[i][0];
s[i][0] = m[i][0];
}
for (int d = (1); d < (D); ++d) {
for (int i = (0); i < (n); ++i) {
f[i][d] = f[f[i][d - 1]][d - 1];
s[i][d] = s[i][d - 1] + s[f[i][d - 1]][d - 1];
m[i][d] = tmin(m[i][d - 1], m[f[i][d - 1]][d - 1]);
}
}
for (int i = (0); i < (n); ++i) {
long long tot = 0, rem = k;
int mini = INT_MAX, cur = i;
for (int d = (D - 1); d > (-1); --d)
if (rem >= (1LL << d)) {
amin(mini, m[cur][d]);
tot += s[cur][d];
cur = f[cur][d];
rem -= 1LL << d;
}
printf("%lld %d\n", tot, mini);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<ll, ll>;
const int MAX{100010}, MAXK{50};
const ll MOD{1000000007}, oo{1LL << 62};
ll ps[MAX][MAXK], ms[MAX][MAXK], s[MAX][MAXK];
vector<ii> solve(int N, ll K, const vector<ll>& fs, const vector<ll>& cs) {
for (int i = 0; i < N; ++i) {
ps[i][1] = fs[i];
ms[i][1] = s[i][1] = cs[i];
}
for (int k = 2; k < MAXK; ++k) {
for (int i = 0; i < N; ++i) {
auto j = ps[i][k - 1];
ps[i][k] = ps[j][k - 1];
ms[i][k] = min(ms[i][k - 1], ms[j][k - 1]);
s[i][k] = s[i][k - 1] + s[j][k - 1];
}
}
vector<ii> ans(N, ii(0, oo));
vector<int> ns(N);
iota(ns.begin(), ns.end(), 0);
for (int k = 1; k < MAXK; ++k) {
ll mask = 1LL << (k - 1);
if (mask & K) {
for (int i = 0; i < N; ++i) {
auto j = ns[i];
ans[i].first += s[j][k];
ans[i].second = min(ans[i].second, ms[j][k]);
ns[i] = ps[j][k];
}
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
ll N, K;
cin >> N >> K;
vector<ll> fs(N), cs(N);
for (int i = 0; i < N; ++i) cin >> fs[i];
for (int i = 0; i < N; ++i) cin >> cs[i];
auto ans = solve(N, K, fs, cs);
for (auto [s, m] : ans) cout << s << ' ' << m << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100050;
const long long mod = 1e9 + 7;
long long inp1[MAXN], inp2, inp3, ans = 1;
long long n, k, st[MAXN][40], sum[MAXN][40], mn[MAXN][40], mi[40];
int main() {
mi[0] = 1;
for (long long i = 1; i <= 34; i++) mi[i] = mi[i - 1] << 1;
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n; i++) scanf("%lld", &inp1[i]);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &inp2);
sum[i][0] = mn[i][0] = inp2;
st[i][0] = inp1[i] + 1;
}
for (long long j = 1; j <= 34; j++) {
for (long long i = 1; i <= n; i++) {
st[i][j] = st[st[i][j - 1]][j - 1];
sum[i][j] = sum[i][j - 1] + sum[st[i][j - 1]][j - 1];
mn[i][j] = min(mn[i][j - 1], mn[st[i][j - 1]][j - 1]);
}
}
for (long long i = 1; i <= n; i++) {
long long now = i, tmp = k, ans1 = 0, ans2 = 1e12;
while (tmp > 0) {
long long pos = upper_bound(mi, mi + 35, tmp) - (mi + 1);
ans1 += sum[now][pos];
ans2 = min(ans2, mn[now][pos]);
now = st[now][pos];
tmp -= mi[pos];
}
printf("%lld %lld\n", ans1, ans2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, L = 40, mod = 0;
long long f[N][L], mn[N][L], sum[N][L];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; ++i) cin >> f[i][0];
for (long long i = 0; i < n; ++i) cin >> sum[i][0], mn[i][0] = sum[i][0];
for (long long g = 1; g < L; ++g)
for (long long v = 0; v < n; ++v)
f[v][g] = f[f[v][g - 1]][g - 1],
mn[v][g] = min(mn[v][g - 1], mn[f[v][g - 1]][g - 1]),
sum[v][g] = sum[v][g - 1] + sum[f[v][g - 1]][g - 1];
for (long long v = 0; v < n; ++v) {
long long mres = 1e18, sres = 0, cur = v;
for (long long i = L - 1; i >= 0; --i)
if (k >> i & 1) {
mres = min(mres, mn[cur][i]);
sres += sum[cur][i];
cur = f[cur][i];
}
cout << sres << ' ' << mres << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
}
void et() {
puts("-1");
exit(0);
}
int f[100005], w[100005];
int pa[100005][35], mi[100005][35];
long long ss[100005][35];
void fmain() {
scanf("%d%lld", &n, &lk);
for (int(i) = 0; (i) < (int)(n); (i)++) scanf("%d", f + i);
for (int(i) = 0; (i) < (int)(n); (i)++) scanf("%d", w + i);
for (int(i) = 0; (i) < (int)(n); (i)++) {
pa[i][0] = f[i];
mi[i][0] = w[i];
ss[i][0] = w[i];
}
for (int j = 1; j < 35; j++)
for (int i = 0; i < n; i++) {
pa[i][j] = pa[pa[i][j - 1]][j - 1];
mi[i][j] = min(mi[i][j - 1], mi[pa[i][j - 1]][j - 1]);
ss[i][j] = ss[i][j - 1] + ss[pa[i][j - 1]][j - 1];
}
for (int(i) = 0; (i) < (int)(n); (i)++) {
int a = (1 << 30);
long long b = 0, x = lk;
int pos = i;
for (int j = 34; j >= 0; j--) {
if ((1LL << j) <= x) {
x -= 1LL << j;
a = min(a, mi[pos][j]);
b += ss[pos][j];
pos = pa[pos][j];
}
}
printf("%lld %d\n", b, a);
}
}
int main() {
fmain();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, f[100005], w[100005], minimum[100005];
vector<int> GT[100005];
bool uz[100005], in[100005];
long long k, sum[100005];
void DFS(int u, int p, vector<int> &cycle, map<int, long long> &values,
long long S, int last, vector<int> &st, long long nCycle) {
sum[u] = S;
minimum[u] = values.begin()->first;
st.push_back(u);
long long newS;
if (nCycle == 0) last = 1;
int lastNode = (nCycle <= 0)
? st[last]
: ((last - 1 >= 0) ? cycle[last - 1] : cycle.back());
int newLast;
if (nCycle <= 0)
newLast = last + 1;
else {
newLast = last - 1;
if (newLast < 0) newLast += (int)cycle.size();
}
for (auto x : GT[u]) {
if (x == p) continue;
newS = S + w[x];
newS -= w[lastNode];
++values[w[x]];
if (--values[w[lastNode]] == 0) values.erase(w[lastNode]);
DFS(x, u, cycle, values, newS, newLast, st, nCycle - 1);
if (--values[w[x]] == 0) values.erase(w[x]);
++values[w[lastNode]];
}
st.pop_back();
}
void solve(int u) {
int x = u;
vector<int> st;
vector<int> cycle;
while (!uz[x]) {
st.push_back(x);
uz[x] = 1;
in[x] = 1;
x = f[x];
}
bool cycleFound = in[x];
for (auto x : st) in[x] = 0;
if (!cycleFound) return;
long long cycleSum = 0;
int y = x;
do {
cycle.push_back(y);
cycleSum += w[y];
y = f[y];
} while (y != x);
int n = (int)cycle.size();
int last = k % n;
if (last < 0) last += n;
map<int, long long> values;
long long sum = k / n * cycleSum;
if (k >= n) {
for (int i = 0; i < n; ++i) values[w[cycle[i]]] += k / n;
}
for (int i = 0; i < last; ++i) {
sum += w[cycle[i]];
++values[w[cycle[i]]];
}
for (int i = 0; i < n; ++i) {
vector<int> st;
DFS(cycle[i], ((i - 1 >= 0) ? cycle[i - 1] : cycle.back()), cycle, values,
sum, last, st, k);
sum += w[cycle[last]];
sum -= w[cycle[i]];
++values[w[cycle[last]]];
if (--values[w[cycle[i]]] == 0) values.erase(w[cycle[i]]);
if (++last >= n) last -= n;
}
}
int main() {
scanf("%d %I64d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &f[i]);
++f[i];
GT[f[i]].push_back(i);
}
for (int i = 1; i <= n; ++i) scanf("%d", &w[i]);
for (int i = 1; i <= n; ++i)
if (!uz[i]) solve(i);
for (int i = 1; i <= n; ++i) printf("%I64d %d\n", sum[i], minimum[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[100010];
long long b[100010];
long long BZ[100010][40];
long long Min[100010][40];
long long Sum[100010][40];
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 0; i < n; ++i) scanf("%lld", &BZ[i][0]);
for (long long i = 0; i < n; ++i) {
scanf("%lld", &Min[i][0]);
Sum[i][0] = Min[i][0];
}
for (long long i = 1; i < 40; ++i) {
for (long long j = 0; j < n; ++j) {
BZ[j][i] = BZ[BZ[j][i - 1]][i - 1];
Min[j][i] = min(Min[j][i - 1], Min[BZ[j][i - 1]][i - 1]);
Sum[j][i] = Sum[j][i - 1] + Sum[BZ[j][i - 1]][i - 1];
}
}
for (long long i = 0; i < n; ++i) {
long long x = 0, y = 2147483647;
long long d = i;
long long kk = k;
for (long long j = 39; j >= 0; --j)
if (kk >= (1ll << j)) {
kk -= 1ll << j;
x += Sum[d][j];
y = min(y, Min[d][j]);
d = BZ[d][j];
}
printf("%lld %lld\n", x, y);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[100010];
long long b[100010];
long long BZ[100010][40];
long long Min[100010][40];
long long Sum[100010][40];
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 0; i < n; ++i) scanf("%lld", &BZ[i][0]);
for (long long i = 0; i < n; ++i) {
scanf("%lld", &Min[i][0]);
Sum[i][0] = Min[i][0];
}
for (long long i = 1; i < 40; ++i) {
for (long long j = 0; j < n; ++j) {
BZ[j][i] = BZ[BZ[j][i - 1]][i - 1];
Min[j][i] = min(Min[j][i - 1], Min[BZ[j][i - 1]][i - 1]);
Sum[j][i] = Sum[j][i - 1] + Sum[BZ[j][i - 1]][i - 1];
}
}
for (long long i = 0; i < n; ++i) {
long long x = 0, y = 2147483647;
long long d = i;
long long kk = k;
for (long long j = 39; j >= 0; --j)
if (kk >= (1ll << j)) {
kk -= 1ll << j;
x += Sum[d][j];
y = min(y, Min[d][j]);
d = BZ[d][j];
}
printf("%lld %lld\n", x, y);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, siz = 1e5 + 5;
long long t, n, m, k, a[siz], mins[siz][40], sum[siz][40], to[siz][40];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> to[i][0], to[i][0]++;
for (long long i = 1; i <= n; i++) cin >> sum[i][0], mins[i][0] = sum[i][0];
for (long long i = 1; i < 40; i++) {
for (long long j = 1; j <= n; j++) {
to[j][i] = to[to[j][i - 1]][i - 1];
sum[j][i] = sum[j][i - 1] + sum[to[j][i - 1]][i - 1];
mins[j][i] = min(mins[j][i - 1], mins[to[j][i - 1]][i - 1]);
}
}
for (long long i = 1; i <= n; i++) {
long long u = i;
long long s = 0, mn = 1e9;
for (long long j = 39; j >= 0; j--) {
if (k & (1LL << j)) {
s += sum[u][j];
mn = min(mn, mins[u][j]);
u = to[u][j];
}
}
cout << s << " " << mn << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100, L = 40;
long long w[N], sum[N][L], to[N][L], MN[N][L], k;
int n, f[N];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> f[i];
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = 0; i < n; i++) {
sum[i][0] = w[i];
to[i][0] = f[i];
MN[i][0] = w[i];
}
for (int lg = 1; lg < L; lg++) {
for (int i = 0; i < n; i++) {
sum[i][lg] = sum[i][lg - 1] + sum[to[i][lg - 1]][lg - 1];
to[i][lg] = to[to[i][lg - 1]][lg - 1];
MN[i][lg] = min(MN[i][lg - 1], MN[to[i][lg - 1]][lg - 1]);
}
}
for (int i = 0; i < n; i++) {
long long Sum = 0, mn = 1ll << 62;
int kk = k, from = i;
for (int j = 0; j < L; j++)
if (k & (1ll << j)) {
Sum += sum[from][j];
mn = min(mn, MN[from][j]);
from = to[from][j];
}
cout << Sum << " " << mn << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double pi = 3.14159265358979323846264338327950288419716939937510;
const int inf = 0x3f3f3f3f;
const int mod = 1000000007;
const int mod2 = 1000000006;
const long long infll = 0x3f3f3f3f3f3f3f3fLL;
const int dx[8] = {0, 1, 0, -1, -1, 1, 1, -1};
const int dy[8] = {1, 0, -1, 0, 1, 1, -1, -1};
template <typename T>
inline bool RD(T& v) {
char c;
bool n;
while (c = getchar(), c != '-' && (c < '0' || c > '9'))
if (c == EOF) return false;
if (c == '-') {
n = true;
v = 0;
} else {
n = false;
v = c - '0';
}
while (c = getchar(), c >= '0' && c <= '9') v = (v << 3) + (v << 1) + c - '0';
if (n) v *= -1;
return true;
}
template <typename T>
inline bool RD(T& a, T& b) {
return RD(a) && RD(b);
}
template <typename T>
inline bool RD(T& a, T& b, T& c) {
return RD(a, b) && RD(c);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d) {
return RD(a, b, c) && RD(d);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d, T& e) {
return RD(a, b, c, d) && RD(e);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d, T& e, T& f) {
return RD(a, b, c, d, e) && RD(f);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d, T& e, T& f, T& g) {
return RD(a, b, c, d, e, f) && RD(g);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d, T& e, T& f, T& g, T& h) {
return RD(a, b, c, d, e, f, g) && RD(h);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d, T& e, T& f, T& g, T& h, T& i) {
return RD(a, b, c, d, e, f, g, h) && RD(i);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d, T& e, T& f, T& g, T& h, T& i, T& j) {
return RD(a, b, c, d, e, f, g, h, i) && RD(j);
}
inline int RD() {
int v;
RD(v);
return v;
}
static char _BUF_[1 << 15], *_HEAD_ = _BUF_, *_TAIL_ = _BUF_;
inline static char getchar_buffered() {
return _HEAD_ == _TAIL_ &&
(_TAIL_ = (_HEAD_ = _BUF_) + fread(_BUF_, 1, 1 << 15, stdin),
_HEAD_ == _TAIL_)
? EOF
: *_HEAD_++;
}
template <typename T>
inline bool RDB(T& v) {
char c;
bool n;
while (c = getchar_buffered(), c != '-' && (c < '0' || c > '9'))
if (c == EOF) return false;
if (c == '-') {
n = true;
v = 0;
} else {
n = false;
v = c - '0';
}
while (c = getchar_buffered() - '0', c >= 0 && c <= 9)
v = (v << 3) + (v << 1) + c;
if (n) v *= -1;
return true;
}
template <typename T>
inline bool RDB(T& a, T& b) {
return RDB(a) && RDB(b);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c) {
return RDB(a, b) && RDB(c);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d) {
return RDB(a, b, c) && RDB(d);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d, T& e) {
return RDB(a, b, c, d) && RDB(e);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d, T& e, T& f) {
return RDB(a, b, c, d, e) && RDB(f);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d, T& e, T& f, T& g) {
return RDB(a, b, c, d, e, f) && RDB(g);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d, T& e, T& f, T& g, T& h) {
return RDB(a, b, c, d, e, f, g) && RDB(h);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d, T& e, T& f, T& g, T& h, T& i) {
return RDB(a, b, c, d, e, f, g, h) && RDB(i);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d, T& e, T& f, T& g, T& h, T& i, T& j) {
return RDB(a, b, c, d, e, f, g, h, i) && RDB(j);
}
inline int RDB() {
int v;
RDB(v);
return v;
}
template <typename T>
inline void _WR(T a) {
if (a < 0) {
putchar('-');
a *= -1;
}
T t = a / 10;
if (t) _WR(t);
putchar(a - (t << 1) - (t << 3) + '0');
}
template <typename T>
inline void WR_(const T& a) {
_WR(a);
putchar(' ');
}
template <typename T>
inline void WR(const T& a) {
_WR(a);
putchar('\n');
}
template <typename T>
inline void _WR(const T& a, const T& b) {
WR_(a);
_WR(b);
}
template <typename T>
inline void WR_(const T& a, const T& b) {
WR_(a);
WR_(b);
}
template <typename T>
inline void WR(const T& a, const T& b) {
WR_(a);
WR(b);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c) {
WR_(a, b);
_WR(c);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c) {
WR_(a, b);
WR_(c);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c) {
WR_(a, b);
WR(c);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d) {
WR_(a, b, c);
_WR(d);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d) {
WR_(a, b, c);
WR_(d);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d) {
WR_(a, b, c);
WR(d);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d, const T& e) {
WR_(a, b, c, d);
_WR(e);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d, const T& e) {
WR_(a, b, c, d);
WR_(e);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d, const T& e) {
WR_(a, b, c, d);
WR(e);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f) {
WR_(a, b, c, d, e);
_WR(f);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f) {
WR_(a, b, c, d, e);
WR_(f);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f) {
WR_(a, b, c, d, e);
WR(f);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g) {
WR_(a, b, c, d, e, f);
_WR(g);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g) {
WR_(a, b, c, d, e, f);
WR_(g);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g) {
WR_(a, b, c, d, e, f);
WR(g);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h) {
WR_(a, b, c, d, e, f, g);
_WR(h);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h) {
WR_(a, b, c, d, e, f, g);
WR_(h);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h) {
WR_(a, b, c, d, e, f, g);
WR(h);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i) {
WR_(a, b, c, d, e, f, g, h);
_WR(i);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i) {
WR_(a, b, c, d, e, f, g, h);
WR_(i);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i) {
WR_(a, b, c, d, e, f, g, h);
WR(i);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i, const T& j) {
WR_(a, b, c, d, e, f, g, h, i);
_WR(j);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i, const T& j) {
WR_(a, b, c, d, e, f, g, h, i);
WR_(j);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i, const T& j) {
WR_(a, b, c, d, e, f, g, h, i);
WR(j);
}
template <typename A>
inline istream& IN(A& a) {
return std::cin >> a;
}
template <typename A, typename B>
inline istream& IN(A& a, B& b) {
return std::cin >> a >> b;
}
template <typename A, typename B, typename C>
inline istream& IN(A& a, B& b, C& c) {
return std::cin >> a >> b >> c;
}
template <typename A, typename B, typename C, typename D>
inline istream& IN(A& a, B& b, C& c, D& d) {
return std::cin >> a >> b >> c >> d;
}
template <typename A, typename B, typename C, typename D, typename E>
inline istream& IN(A& a, B& b, C& c, D& d, E& e) {
return std::cin >> a >> b >> c >> d >> e;
}
template <typename A, typename B, typename C, typename D, typename E,
typename F>
inline istream& IN(A& a, B& b, C& c, D& d, E& e, F& f) {
return std::cin >> a >> b >> c >> d >> e >> f;
}
template <typename A, typename B, typename C, typename D, typename E,
typename F, typename G>
inline istream& IN(A& a, B& b, C& c, D& d, E& e, F& f, G& g) {
return std::cin >> a >> b >> c >> d >> e >> f >> g;
}
template <typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H>
inline istream& IN(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h) {
return std::cin >> a >> b >> c >> d >> e >> f >> g >> h;
}
template <typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I>
inline istream& IN(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i) {
return std::cin >> a >> b >> c >> d >> e >> f >> g >> h >> i;
}
template <typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J>
inline istream& IN(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j) {
return std::cin >> a >> b >> c >> d >> e >> f >> g >> h >> i >> j;
}
inline std::ostream& OUT() { return std::cout << std::endl; }
template <typename T>
inline ostream& _OUT(const T& a) {
return std::cout << a;
}
template <typename T>
inline ostream& OUT_(const T& a) {
return std::cout << a << ' ';
}
template <typename T>
inline ostream& OUT(const T& a) {
return std::cout << a << std::endl;
}
template <typename T, typename U>
inline ostream& _OUT(const T& a, const U& b) {
return std::cout << a << " " << b;
}
template <typename T, typename U>
inline ostream& OUT_(const T& a, const U& b) {
return std::cout << a << " " << b << " ";
}
template <typename T, typename U>
inline ostream& OUT(const T& a, const U& b) {
return std::cout << a << " " << b << std::endl;
}
template <typename T, typename U, typename V>
inline ostream& _OUT(const T& a, const U& b, const V& c) {
OUT_(a, b);
return _OUT(c);
}
template <typename T, typename U, typename V>
inline ostream& OUT_(const T& a, const U& b, const V& c) {
OUT_(a, b);
return OUT_(c);
}
template <typename T, typename U, typename V>
inline ostream& OUT(const T& a, const U& b, const V& c) {
OUT_(a, b);
return OUT(c);
}
template <typename T, typename U, typename V, typename W>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d) {
OUT_(a, b, c);
return _OUT(d);
}
template <typename T, typename U, typename V, typename W>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d) {
OUT_(a, b, c);
return OUT_(d);
}
template <typename T, typename U, typename V, typename W>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d) {
OUT_(a, b, c);
return OUT(d);
}
template <typename T, typename U, typename V, typename W, typename X>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d,
const X& e) {
OUT_(a, b, c, d);
return _OUT(e);
}
template <typename T, typename U, typename V, typename W, typename X>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d,
const X& e) {
OUT_(a, b, c, d);
return OUT_(e);
}
template <typename T, typename U, typename V, typename W, typename X>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d,
const X& e) {
OUT_(a, b, c, d);
return OUT(e);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f) {
OUT_(a, b, c, d, e);
return _OUT(f);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f) {
OUT_(a, b, c, d, e);
return OUT_(f);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f) {
OUT_(a, b, c, d, e);
return OUT(f);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g) {
OUT_(a, b, c, d, e, f);
return _OUT(g);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g) {
OUT_(a, b, c, d, e, f);
return OUT_(g);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g) {
OUT_(a, b, c, d, e, f);
return OUT(g);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h) {
OUT_(a, b, c, d, e, f, g);
return _OUT(h);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h) {
OUT_(a, b, c, d, e, f, g);
return OUT_(h);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h) {
OUT_(a, b, c, d, e, f, g);
return OUT(h);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A, typename B>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h, const B& i) {
OUT_(a, b, c, d, e, f, g, h);
return _OUT(i);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A, typename B>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h, const B& i) {
OUT_(a, b, c, d, e, f, g, h);
return OUT_(i);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A, typename B>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h, const B& i) {
OUT_(a, b, c, d, e, f, g, h);
return OUT(i);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A, typename B, typename C>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h, const B& i,
const C& j) {
OUT_(a, b, c, d, e, f, g, h, i);
return _OUT(j);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A, typename B, typename C>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h, const B& i,
const C& j) {
OUT_(a, b, c, d, e, f, g, h, i);
return OUT_(j);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A, typename B, typename C>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h, const B& i,
const C& j) {
OUT_(a, b, c, d, e, f, g, h, i);
return OUT(j);
}
template <typename A>
inline void clr(A& a) {
a.clear();
}
template <typename A, typename B>
inline void clr(A& a, B& b) {
a.clear();
b.clear();
}
template <typename A, typename B, typename C>
inline void clr(A& a, B& b, C& c) {
a.clear();
b.clear();
c.clear();
}
template <typename A, typename B, typename C, typename D>
inline void clr(A& a, B& b, C& c, D& d) {
a.clear();
b.clear();
c.clear();
d.clear();
}
template <typename A, typename B, typename C, typename D, typename E>
inline void clr(A& a, B& b, C& c, D& d, E& e) {
a.clear();
b.clear();
c.clear();
d.clear();
e.clear();
}
template <typename A, typename B, typename C, typename D, typename E,
typename F>
inline void clr(A& a, B& b, C& c, D& d, E& e, F& f) {
a.clear();
b.clear();
c.clear();
d.clear();
e.clear();
f.clear();
}
inline long long madd(long long a, long long b,
const long long mod = 1000000007) {
long long ret = (a + b) % mod;
if (ret < 0) ret += mod;
return ret;
}
inline long long msub(long long a, long long b,
const long long mod = 1000000007) {
long long ret = (a - b) % mod;
if (ret < 0) ret += mod;
return ret;
}
inline long long mmul(long long a, long long b,
const long long mod = 1000000007) {
return a * b % mod;
}
inline long long mpow(long long x, long long k,
const long long mod = 1000000007) {
x %= mod;
long long ret = 1;
while (k > 0) {
if (k & 1) ret = ret * x % mod;
x = x * x % mod;
k >>= 1;
}
return ret;
}
template <typename T, typename U>
inline bool cmax(T& a, const U& b) {
return a < b ? a = b, true : false;
}
template <typename T, typename U>
inline bool cmin(T& a, const U& b) {
return a > b ? a = b, true : false;
}
template <typename T, typename U>
inline T cadd(T& a, const U& b, const int mod = 1000000007) {
a = (a * 1LL + b) % mod;
if (a < 0) a += mod;
return a;
}
template <typename T, typename U>
inline T csub(T& a, const U& b, const int mod = 1000000007) {
a = (a * 1LL - b) % mod;
if (a < 0) a += mod;
return a;
}
template <typename T, typename U>
inline T cmul(T& a, const U& b, const int mod = 1000000007) {
return a = (a * 1LL * b) % mod;
}
inline long long cpow(long long& x, long long k,
const long long mod = 1000000007) {
x %= mod;
long long ret = 1;
while (k > 0) {
if (k & 1) ret = ret * x % mod;
x = x * x % mod;
k >>= 1;
}
return x = ret;
}
template <typename T>
inline T clow(T& a, const int mod = 1000000007) {
while (a < 0) a += mod;
return a;
}
template <typename T>
inline T cup(T& a, const int mod = 1000000007) {
while (a >= mod) a -= mod;
return a;
}
template <typename T>
inline T cboth(T& a, const int mod = 1000000007) {
while (a < 0) a += mod;
while (a >= mod) a -= mod;
return a;
}
template <typename T>
inline T vlow(T a, const int mod = 1000000007) {
while (a < 0) a += mod;
return a;
}
template <typename T>
inline T vup(T a, const int mod = 1000000007) {
while (a >= mod) a -= mod;
return a;
}
template <typename T>
inline T vboth(T a, const int mod = 1000000007) {
while (a < 0) a += mod;
while (a >= mod) a -= mod;
return a;
}
template <typename T>
inline T max(const T& a, const T& b, const T& c) {
return std::max(std::max(a, b), c);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d) {
return std::max(max(a, b, c), d);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d, const T& e) {
return std::max(max(a, b, c, d), e);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f) {
return std::max(max(a, b, c, d, e), f);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g) {
return std::max(max(a, b, c, d, e, f), g);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h) {
return std::max(max(a, b, c, d, e, f, g), h);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i) {
return std::max(max(a, b, c, d, e, f, g, h), i);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i, const T& j) {
return std::max(max(a, b, c, d, e, f, g, h, i), j);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c) {
return std::min(std::min(a, b), c);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d) {
return std::min(min(a, b, c), d);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d, const T& e) {
return std::min(min(a, b, c, d), e);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f) {
return std::min(min(a, b, c, d, e), f);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g) {
return std::min(min(a, b, c, d, e, f), g);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h) {
return std::min(min(a, b, c, d, e, f, g), h);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i) {
return std::min(min(a, b, c, d, e, f, g, h), i);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i, const T& j) {
return std::min(min(a, b, c, d, e, f, g, h, i), j);
}
template <typename T>
inline T gcd(T a, T b) {
while (b != 0) {
T tmp = b;
b = a % b;
a = tmp;
}
return a;
}
template <typename T>
inline T egcd(T a, T b, T& x, T& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
T gcd = egcd(b, a % b, y, x);
y -= (a / b) * x;
return gcd;
}
template <typename T>
struct point {
T x, y;
point() {}
point(T xx, T yy) : x(xx), y(yy) {}
point(const point& B) : x(B.x), y(B.y) {}
bool operator==(const point& B) const { return x == B.x && y == B.y; }
bool operator!=(const point& B) const { return x != B.x || y != B.y; }
bool operator<(const point& B) const {
return x < B.x || x == B.x && y < B.y;
}
bool operator>(const point& B) const {
return x > B.x || x == B.x && y > B.y;
}
bool operator<=(const point& B) const {
return x < B.x || x == B.x && y <= B.y;
}
bool operator>=(const point& B) const {
return x > B.x || x == B.x && y >= B.y;
}
point& operator=(const point& B) {
x = B.x;
y = B.y;
return *this;
}
point operator+(const point& B) const { return point(x + B.x, y + B.y); }
point operator-(const point& B) const { return point(x - B.x, y - B.y); }
point& operator+=(const point& B) {
x += B.x;
y += B.y;
return *this;
}
point& operator-=(const point& B) {
x -= B.x;
y -= B.y;
return *this;
}
T operator*(const point& B) const { return x * B.x + y * B.y; }
T operator^(const point& B) const { return x * B.y - y * B.x; }
};
const int _ = (int)(1e5 + 10);
const int __ = (int)(1e6 + 10);
const int LOG = 50;
int Log;
long long n, k;
int e[_], w[_];
struct Status {
int to[LOG];
long long sumw[LOG];
int minw[LOG];
} S[_];
inline void _main() {
RDB(n, k);
{
for (long long _i_ = (long long)(0); _i_ < (long long)(n); ++_i_)
RDB((e)[_i_]);
};
{
for (long long _i_ = (long long)(0); _i_ < (long long)(n); ++_i_)
RDB((w)[_i_]);
};
while ((1LL << Log) <= k) ++Log;
for (long long i = 0; i < (long long)(n); ++i) {
S[i].to[0] = e[i];
S[i].sumw[0] = w[i];
S[i].minw[0] = w[i];
}
for (long long j = (long long)(1); j < (long long)(Log); ++j)
for (long long i = 0; i < (long long)(n); ++i) {
int mid = S[i].to[j - 1];
S[i].to[j] = S[mid].to[j - 1];
S[i].sumw[j] = S[i].sumw[j - 1] + S[mid].sumw[j - 1];
S[i].minw[j] = min(S[i].minw[j - 1], S[mid].minw[j - 1]);
}
for (long long i = 0; i < (long long)(n); ++i) {
long long ret_sumw = 0, ret_minw = inf;
long long d = k;
int u = i;
for (long long j = (long long)(Log)-1; j >= 0; --j)
if ((d >> j) & 1) {
ret_sumw += S[u].sumw[j];
cmin(ret_minw, S[u].minw[j]);
d -= 1LL << j;
u = S[u].to[j];
}
WR(ret_sumw, ret_minw);
}
}
void generate_test_case() { exit(0); }
int main() {
_main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long int next, sum, mn;
};
vector<node> operate(vector<node> a, vector<node> b) {
vector<node> res;
res.resize(b.size());
if (a.size() == 0) return b;
for (long long int i = 0; i < a.size(); i++) {
res[i].next = a[b[i].next].next;
res[i].sum = a[b[i].next].sum + b[i].sum;
res[i].mn = min(a[b[i].next].mn, b[i].mn);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, k;
cin >> n >> k;
vector<node> v;
v.resize(n);
for (long long int i = 0; i < n; i++) cin >> v[i].next;
for (long long int i = 0; i < n; i++) cin >> v[i].sum, v[i].mn = v[i].sum;
vector<node> ans;
while (k) {
if (k & 1) ans = operate(ans, v);
v = operate(v, v);
k >>= 1;
}
for (auto i : ans) cout << i.sum << " " << i.mn << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vc = vector<char>;
using vb = vector<bool>;
using vs = vector<string>;
using vll = vector<long long>;
using vp = vector<pair<int, int>>;
using vvi = vector<vector<int>>;
using vvc = vector<vector<char>>;
using vvll = vector<vector<long long>>;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T &a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int INF = 1001001001;
int to[40][100005], mn[40][100005];
ll cost[40][100005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
ll k;
cin >> n >> k;
for (int i = 0; i < (int)(n); i++) {
cin >> to[0][i];
}
for (int i = 0; i < (int)(n); i++) {
cin >> cost[0][i];
mn[0][i] = cost[0][i];
}
for (int t = 0; t < (int)(39); t++) {
for (int i = 0; i < (int)(n); i++) {
to[t + 1][i] = to[t][to[t][i]];
}
}
for (int t = 0; t < (int)(39); t++) {
for (int i = 0; i < (int)(n); i++) {
cost[t + 1][i] = cost[t][i] + cost[t][to[t][i]];
mn[t + 1][i] = min(mn[t][i], mn[t][to[t][i]]);
}
}
vll s(n);
vi m(n, INF);
for (int i = 0; i < (int)(n); i++) {
int now = i;
for (int j = 0; j < (int)(40); j++) {
if (k >> j & 1) {
s[i] += cost[j][now];
chmin(m[i], mn[j][now]);
now = to[j][now];
}
}
}
for (int i = 0; i < (int)(n); i++) cout << s[i] << " " << m[i] << endl;
}
|
#include <bits/stdc++.h>
long long read() {
static int ch;
static long long x;
while (isspace(ch = getchar())) {
}
x = ch ^ 48;
while (isdigit(ch = getchar())) x = (((x << 2) + x) << 1) + (ch ^ 48);
return x;
}
int af1[100010], af2[100010], af[100010], amin1[100010], amin2[100010],
amin[100010];
long long asum1[100010], asum2[100010], asum[100010];
int *f1 = af1, *f2 = af2, *min1 = amin1, *min2 = amin2;
long long *sum1 = asum1, *sum2 = asum2;
int main() {
const int n = read();
long long k = read();
for (int i = 0; i < n; ++i) {
f1[i] = read();
af[i] = i;
amin[i] = 0x7fffffff;
}
for (int i = 0; i < n; ++i) sum1[i] = min1[i] = read();
while (k) {
std::swap(f1, f2);
std::swap(min1, min2);
std::swap(sum1, sum2);
if (k & 1) {
for (int i = 0; i < n; ++i) {
amin[i] = std::min(amin[i], min2[af[i]]);
asum[i] += sum2[af[i]];
af[i] = f2[af[i]];
}
}
for (int i = 0; i < n; ++i) {
f1[i] = f2[f2[i]];
min1[i] = std::min(min2[i], min2[f2[i]]);
sum1[i] = sum2[i] + sum2[f2[i]];
}
k >>= 1;
}
for (int i = 0; i < n; ++i) {
printf("%lld %d\n", asum[i], amin[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
const long long maxn = 100100;
long long n, k;
long long fa[maxn][35][3];
long long lg[35], n2[35];
signed main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
fa[i][0][0] = x + 1;
}
for (long long i = 1; i <= n; i++) {
scanf("%lld", &fa[i][0][1]);
fa[i][0][2] = fa[i][0][1];
}
n2[0] = 1;
for (long long i = 1; i < 35; i++) {
lg[i] = lg[i - 1] + ((1 << lg[i - 1] == i));
n2[i] = n2[i - 1] << 1;
}
for (long long j = 1; j < 35; j++) {
for (long long i = 1; i <= n; i++) {
fa[i][j][0] = fa[fa[i][j - 1][0]][j - 1][0];
fa[i][j][1] = fa[fa[i][j - 1][0]][j - 1][1] + fa[i][j - 1][1];
fa[i][j][2] = std::min(fa[i][j - 1][2], fa[fa[i][j - 1][0]][j - 1][2]);
}
}
for (long long i = 1; i <= n; i++) {
long long now = i, val = k, ans1 = 0, ans2 = 100000000000000000;
for (long long j = 34; j >= 0; j--) {
if (val - n2[j] >= 0) {
val -= n2[j];
ans1 += fa[now][j][1];
ans2 = std::min(ans2, fa[now][j][2]);
now = fa[now][j][0];
}
}
printf("%lld %lld\n", ans1, ans2);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, mod = 1e9 + 7;
int n, v[N], w[N];
long long d;
struct node {
int c, mn;
long long sm;
node() {
c = 0, mn = 1e9;
sm = 0;
}
} dp[N][60];
int main() {
scanf("%d%lld", &n, &d);
for (int i = 0; i < n; i++) scanf("%d", &v[i]);
for (int i = 0; i < n; i++) scanf("%d", &w[i]);
for (int i = 0; i < n; i++)
dp[i][0].c = v[i], dp[i][0].mn = dp[i][0].sm = w[i];
for (int k = 1; k < 50; k++)
for (int i = 0; i < n; i++) {
dp[i][k].c = dp[dp[i][k - 1].c][k - 1].c;
dp[i][k].mn = min(dp[dp[i][k - 1].c][k - 1].mn, dp[i][k - 1].mn);
dp[i][k].sm = dp[dp[i][k - 1].c][k - 1].sm + dp[i][k - 1].sm;
}
for (int i = 0; i < n; i++) {
int id = i, mn = 1e9;
long long sm = 0;
for (int k = 49; k >= 0; k--) {
if (!(d & (1LL << k))) continue;
sm += dp[id][k].sm;
mn = min(mn, dp[id][k].mn);
id = dp[id][k].c;
}
cout << sm << " " << mn << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxp = 40;
const int maxn = 1e5 + 10;
const int inf = 0x3f3f3f3f;
int n, f[maxn], to[maxn][maxp];
long long k, s[maxn][maxp];
int w[maxn], minv[maxn][maxp];
long long si;
int mi;
void init() {
for (int i = 0; i < n; i++) {
to[i][0] = f[i];
minv[i][0] = s[i][0] = w[i];
}
for (long long j = 1; (1ll << j) <= k; j++) {
for (int i = 0; i < n; i++) {
to[i][j] = to[to[i][j - 1]][j - 1];
minv[i][j] = min(minv[i][j - 1], minv[to[i][j - 1]][j - 1]);
s[i][j] = s[i][j - 1] + s[to[i][j - 1]][j - 1];
}
}
}
inline int lowbit(int x) { return x & -x; }
void query(int u, long long k) {
mi = inf;
si = 0;
int cnt = 0;
while (k) {
while (!(k & 1)) {
k >>= 1;
cnt++;
}
mi = min(mi, minv[u][cnt]);
si += s[u][cnt];
u = to[u][cnt];
k ^= 1;
}
}
int main() {
scanf("%d%I64d", &n, &k);
for (int i = 0; i < n; i++) cin >> f[i];
for (int i = 0; i < n; i++) cin >> w[i];
init();
for (int i = 0; i < n; i++) {
query(i, k);
printf("%I64d %d\n", si, mi);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& num) {
char CH;
bool F = false;
for (CH = getchar(); CH < '0' || CH > '9'; F = CH == '-', CH = getchar())
;
for (num = 0; CH >= '0' && CH <= '9';
num = num * 10 + CH - '0', CH = getchar())
;
F && (num = -num);
}
int stk[70], tp;
template <class T>
inline void print(T p) {
if (!p) {
puts("0");
return;
}
tp = 0;
while (p) stk[++tp] = p % 10, p /= 10;
while (tp) putchar(stk[tp--] + '0');
putchar('\n');
}
const int maxn = 200005, maxm = 400005;
int g[maxn], v[maxm], nxt[maxm], eid;
int siz[maxn], son[maxn], top[maxn], f[maxn];
int st[maxn], ed[maxn], vid;
int n, m, x;
char op[10];
void add(int a, int b) {
v[eid] = b;
nxt[eid] = g[a];
g[a] = eid++;
}
struct Segtree {
int sumv[maxm], sam[maxm], l[maxm], r[maxm];
void update(int x) { sumv[x] = sumv[((x) << 1)] + sumv[(((x) << 1) | 1)]; }
void push(int x) {
if (sam[x] == -1) return;
sam[((x) << 1)] = sam[x];
sumv[((x) << 1)] = sam[x] * (r[((x) << 1)] - l[((x) << 1)] + 1);
sam[(((x) << 1) | 1)] = sam[x];
sumv[(((x) << 1) | 1)] =
sam[x] * (r[(((x) << 1) | 1)] - l[(((x) << 1) | 1)] + 1);
sam[x] = -1;
}
void change(int x, int L, int R, int val) {
if (R < l[x] || L > r[x]) return;
if (L <= l[x] && r[x] <= R) {
sam[x] = val;
sumv[x] = (r[x] - l[x] + 1) * val;
return;
}
push(x);
change(((x) << 1), L, R, val);
change((((x) << 1) | 1), L, R, val);
update(x);
}
int query(int x, int L, int R) {
if (R < l[x] || L > r[x]) return 0;
if (L <= l[x] && r[x] <= R) return sumv[x];
push(x);
return (query(((x) << 1), L, R) + query((((x) << 1) | 1), L, R));
}
void build(int x, int L, int R) {
l[x] = L;
r[x] = R;
sam[x] = -1;
if (L == R) return;
int mid = L + R >> 1;
build(((x) << 1), L, mid);
build((((x) << 1) | 1), mid + 1, R);
}
} seg;
void dfs(int u) {
siz[u] = 1;
for (int i = g[u]; ~i; i = nxt[i]) {
dfs(v[i]);
siz[u] += siz[v[i]];
if (siz[v[i]] > siz[son[u]]) son[u] = v[i];
}
}
void dfs2(int u, int rt) {
top[u] = rt;
st[u] = ++vid;
if (son[u]) dfs2(son[u], rt);
for (int i = g[u]; ~i; i = nxt[i])
if (v[i] != son[u]) dfs2(v[i], v[i]);
ed[u] = vid;
}
void solve(int x) {
int ans = 0;
while (x) {
ans += (st[x] - st[top[x]] + 1) - seg.query(1, st[top[x]], st[x]);
seg.change(1, st[top[x]], st[x], 1);
x = top[x];
x = f[x];
}
print(ans);
}
int fa[100005][40], w[100005], gmin[100005][40];
long long gsum[100005][40], k;
int main() {
read(n);
read(k);
for (int i = 0; i < n; ++i) read(fa[i][0]);
for (int i = 0; i < n; ++i) read(w[i]), gsum[i][0] = gmin[i][0] = w[i];
for (int j = 1; j < 40; ++j)
for (int i = 0; i < n; ++i) {
fa[i][j] = fa[fa[i][j - 1]][j - 1];
gsum[i][j] = gsum[i][j - 1] + gsum[fa[i][j - 1]][j - 1];
gmin[i][j] = min(gmin[i][j - 1], gmin[fa[i][j - 1]][j - 1]);
}
for (int i = 0; i < n; ++i) {
int x = i, mn = 0x7fffffff;
long long sum = 0;
for (int j = 39; ~j; --j)
if (k & (1LL << j)) {
sum += gsum[x][j];
mn = min(mn, gmin[x][j]);
x = fa[x][j];
}
print(sum);
print(mn);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
long long K;
int f[1 << 18];
long long c[1 << 18];
int j[1 << 18][35];
long long jc[1 << 18][35];
long long jmin[1 << 18][35];
long long ret[1 << 18][2];
int main() {
scanf("%d %lld", &N, &K);
for (int i = 0; i < N; i++) {
scanf("%d", &f[i]);
j[i][0] = f[i];
}
for (int i = 0; i < N; i++) {
scanf("%lld", &c[i]);
jc[i][0] = c[i];
jmin[i][0] = c[i];
}
for (int k = 1; k < 35; k++) {
for (int i = 0; i < N; i++) {
int mid = j[i][k - 1];
j[i][k] = j[mid][k - 1];
jc[i][k] = jc[i][k - 1] + jc[mid][k - 1];
jmin[i][k] = min(jmin[i][k - 1], jmin[mid][k - 1]);
}
}
for (int i = 0; i < N; i++) {
int u = i;
long long cost = 0;
long long mincost = 2e10;
for (int k = 0; k < 35; k++) {
if ((K & (1ULL << k)) != 0) {
cost += jc[u][k];
mincost = min(mincost, jmin[u][k]);
u = j[u][k];
}
}
ret[i][0] = cost;
ret[i][1] = mincost;
}
for (int i = 0; i < N; i++) {
printf("%lld %lld\n", ret[i][0], ret[i][1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& num) {
char CH;
bool F = false;
for (CH = getchar(); CH < '0' || CH > '9'; F = CH == '-', CH = getchar())
;
for (num = 0; CH >= '0' && CH <= '9';
num = num * 10 + CH - '0', CH = getchar())
;
F && (num = -num);
}
int stk[70], tp;
template <class T>
inline void print(T p) {
if (!p) {
puts("0");
return;
}
tp = 0;
while (p) stk[++tp] = p % 10, p /= 10;
while (tp) putchar(stk[tp--] + '0');
putchar('\n');
}
const int maxn = 200005, maxm = 400005;
int g[maxn], v[maxm], nxt[maxm], eid;
int siz[maxn], son[maxn], top[maxn], f[maxn];
int st[maxn], ed[maxn], vid;
int n, m, x;
char op[10];
void add(int a, int b) {
v[eid] = b;
nxt[eid] = g[a];
g[a] = eid++;
}
struct Segtree {
int sumv[maxm], sam[maxm], l[maxm], r[maxm];
void update(int x) { sumv[x] = sumv[((x) << 1)] + sumv[(((x) << 1) | 1)]; }
void push(int x) {
if (sam[x] == -1) return;
sam[((x) << 1)] = sam[x];
sumv[((x) << 1)] = sam[x] * (r[((x) << 1)] - l[((x) << 1)] + 1);
sam[(((x) << 1) | 1)] = sam[x];
sumv[(((x) << 1) | 1)] =
sam[x] * (r[(((x) << 1) | 1)] - l[(((x) << 1) | 1)] + 1);
sam[x] = -1;
}
void change(int x, int L, int R, int val) {
if (R < l[x] || L > r[x]) return;
if (L <= l[x] && r[x] <= R) {
sam[x] = val;
sumv[x] = (r[x] - l[x] + 1) * val;
return;
}
push(x);
change(((x) << 1), L, R, val);
change((((x) << 1) | 1), L, R, val);
update(x);
}
int query(int x, int L, int R) {
if (R < l[x] || L > r[x]) return 0;
if (L <= l[x] && r[x] <= R) return sumv[x];
push(x);
return (query(((x) << 1), L, R) + query((((x) << 1) | 1), L, R));
}
void build(int x, int L, int R) {
l[x] = L;
r[x] = R;
sam[x] = -1;
if (L == R) return;
int mid = L + R >> 1;
build(((x) << 1), L, mid);
build((((x) << 1) | 1), mid + 1, R);
}
} seg;
void dfs(int u) {
siz[u] = 1;
for (int i = g[u]; ~i; i = nxt[i]) {
dfs(v[i]);
siz[u] += siz[v[i]];
if (siz[v[i]] > siz[son[u]]) son[u] = v[i];
}
}
void dfs2(int u, int rt) {
top[u] = rt;
st[u] = ++vid;
if (son[u]) dfs2(son[u], rt);
for (int i = g[u]; ~i; i = nxt[i])
if (v[i] != son[u]) dfs2(v[i], v[i]);
ed[u] = vid;
}
void solve(int x) {
int ans = 0;
while (x) {
ans += (st[x] - st[top[x]] + 1) - seg.query(1, st[top[x]], st[x]);
seg.change(1, st[top[x]], st[x], 1);
x = top[x];
x = f[x];
}
print(ans);
}
int fa[100005][40], w[100005], gmin[100005][40];
long long gsum[100005][40], k;
int main() {
read(n);
read(k);
for (int i = 0; i < n; ++i) read(fa[i][0]);
for (int i = 0; i < n; ++i) read(w[i]), gsum[i][0] = gmin[i][0] = w[i];
for (int j = 1; j < 40; ++j)
for (int i = 0; i < n; ++i) {
fa[i][j] = fa[fa[i][j - 1]][j - 1];
gsum[i][j] = gsum[i][j - 1] + gsum[fa[i][j - 1]][j - 1];
gmin[i][j] = min(gmin[i][j - 1], gmin[fa[i][j - 1]][j - 1]);
}
for (int i = 0; i < n; ++i) {
int x = i, mn = 0x7fffffff;
long long sum = 0;
for (int j = 0; j < 40; ++j)
if (k & (1LL << j)) {
sum += gsum[x][j];
mn = min(mn, gmin[x][j]);
x = fa[x][j];
}
print(sum);
print(mn);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct __io_dev {
__io_dev(const bool& __fastio = false) {
if (__fastio) ios_base::sync_with_stdio(false), cin.tie(nullptr);
srand(time(nullptr));
if (!string("").empty())
freopen(
""
".in",
"r", stdin),
freopen(
""
".out",
"w", stdout);
}
~__io_dev() { fprintf(stderr, "%.6f ms\n", 1e3 * clock() / CLOCKS_PER_SEC); }
} __io(false);
const long long inf = (long long)1e+9 + 7ll;
const long long linf = (long long)1e+18 + 7ll;
const long double eps = (long double)1e-9;
const long double pi = acosl((long double)-1.0);
const int alph = 26;
const int maxs = 512l;
static char buff[(int)2e6 + 17];
long long __p[3] = {29ll, 31ll, 33ll};
long long __mod[3] = {inf, inf + 2ll, 14881337ll};
const int maxn = (int)1e5 + 17;
int n;
long long k;
int p[maxn][34];
long long sum[maxn][34], mn[maxn][34];
int main() {
scanf("%d %lld", &n, &k);
for (long long i = 0ll; i < (long long)n; ++i) scanf("%d", &p[i][0]);
for (long long i = 0ll; i < (long long)n; ++i)
scanf("%lld", &sum[i][0]), mn[i][0] = sum[i][0];
for (long long j = (long long)1; j < (long long)34; ++j)
for (long long i = 0ll; i < (long long)n; ++i) {
p[i][j] = p[p[i][j - 1]][j - 1];
sum[i][j] = sum[i][j - 1] + sum[p[i][j - 1]][j - 1];
mn[i][j] = min(mn[i][j - 1], mn[p[i][j - 1]][j - 1]);
}
for (long long i = 0ll; i < (long long)n; ++i) {
int v = i;
long long curk = k, ansmin = linf, anssum = 0ll;
for (int j = 33; j >= 0; --j)
if ((1ll << j) <= curk) {
ansmin = min(ansmin, mn[v][j]);
anssum += sum[v][j];
v = p[v][j];
curk -= (1ll << j);
}
printf("%lld %lld\n", anssum, ansmin);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, M = 47;
long long g[N][M], f[N][M], a[N][M], n, k;
signed main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i][0]);
a[i][0]++;
}
for (long long i = 1; i <= n; i++) {
scanf("%lld", &f[i][0]);
g[i][0] = f[i][0];
}
for (long long j = 1; j <= 45; j++) {
for (long long i = 1; i <= n; i++) {
long long s = a[i][j - 1];
a[i][j] = a[s][j - 1];
f[i][j] = f[i][j - 1] + f[s][j - 1];
g[i][j] = min(g[i][j - 1], g[s][j - 1]);
}
}
for (long long i = 1; i <= n; i++) {
long long res = 0, minx = 1ll << 45, now = i;
for (long long j = 45; j >= 0; j--) {
if ((k >> j) & 1LL) {
res += f[now][j];
minx = min(minx, g[now][j]);
now = a[now][j];
}
}
printf("%lld %lld\n", res, minx);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 1e5 + 5;
long long mini[35][MAXN];
long long sum[35][MAXN];
int P[35][MAXN];
long long POWER[50];
pair<long long, long long> go(int idx, long long k) {
if (!k) return make_pair(0, MOD);
int p = -1;
for (int i = 0; POWER[i] <= k and p == -1; i++)
if (k & POWER[i]) p = i;
pair<long long, long long> ret = {0, MOD};
ret.first += sum[p][idx];
ret.second = min(ret.second, mini[p][idx]);
pair<long long, long long> g = go(P[p][idx], k - POWER[p]);
ret.first += g.first;
ret.second = min(ret.second, g.second);
return ret;
}
int main() {
POWER[0] = 1;
for (int i = 1; i < 50; i++) POWER[i] = POWER[i - 1] << 1LL;
int n;
cin >> n;
long long k;
cin >> k;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
P[0][i] = x;
}
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
mini[0][i] = x;
sum[0][i] = x;
}
for (int i = 1; POWER[i] <= k; i++) {
for (int j = 0; j < n; j++) {
mini[i][j] = min(mini[i - 1][j], mini[i - 1][P[i - 1][j]]);
sum[i][j] = sum[i - 1][j] + sum[i - 1][P[i - 1][j]];
P[i][j] = P[i - 1][P[i - 1][j]];
}
}
for (int i = 0; i < n; i++) {
pair<long long, long long> ans = go(i, k);
printf("%lld %lld\n", ans.first, ans.second);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000000,102400000000")
const long long MOD = 998244353;
const int N = 1e5 + 15;
const int maxn = 1e5 + 15;
const int letter = 130;
const int INF = 2e9;
const double pi = acos(-1.0);
const double eps = 1e-6;
using namespace std;
inline int read() {
int 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;
}
int n, f[N][37], mn[N][37], maxm = 37;
long long k, sum[N][37];
int main() {
scanf("%d%I64d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &f[i][0]);
for (int i = 0; i < n; i++) scanf("%d", &mn[i][0]), sum[i][0] = mn[i][0];
for (int j = 1; j < maxm; j++)
for (int i = 0; i < n; i++) {
f[i][j] = f[f[i][j - 1]][j - 1];
sum[i][j] = sum[i][j - 1] + sum[f[i][j - 1]][j - 1];
mn[i][j] = min(mn[i][j - 1], mn[f[i][j - 1]][j - 1]);
}
for (int i = 0; i < n; i++) {
int min1 = INF, x = i;
long long ans = 0;
for (int j = maxm - 1; j >= 0; j--) {
if ((1ll << j) & k) {
min1 = min(min1, mn[x][j]);
ans += sum[x][j];
x = f[x][j];
}
}
printf("%I64d %d\n", ans, min1);
}
return 0;
}
|
#include <bits/stdc++.h>
template <typename A, typename B>
inline void umin(A &x, B y) {
if (x > y) x = y;
}
template <typename A, typename B>
inline void umax(A &x, B y) {
if (x < y) x = y;
}
const int N = 200005;
using namespace std;
long long k;
int n;
long long sum[N][35];
int f[N], w[N];
int to[N][35], val[N][35];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> to[i][0];
for (int i = 0; i < n; i++) {
cin >> val[i][0];
sum[i][0] = val[i][0];
}
for (int j = 0; j < 33; j++)
for (int i = 0; i < n; i++) {
to[i][j + 1] = to[to[i][j]][j];
sum[i][j + 1] = sum[i][j] + sum[to[i][j]][j];
val[i][j + 1] = min(val[i][j], val[to[i][j]][j]);
}
for (int i = 0; i < n; i++) {
int x = i;
long long s = 0, m = 1000000000;
for (int j = 33; j >= 0; j--) {
if (k & (1LL << j)) {
s += sum[x][j];
umin(m, val[x][j]);
x = to[x][j];
}
}
cout << s << " " << m << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T lowbit(T x) {
return x & (-x);
}
const long long INF = 1e18;
const int MAXN = 1e5 + 5;
const int BIT = 35;
int nxt[MAXN][BIT];
long long cost[MAXN][BIT], min_cost[MAXN][BIT];
int main(void) {
int n;
long long k;
scanf("%d%lld", &n, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < BIT; j++) {
min_cost[i][j] = INF;
}
}
for (int i = 0; i < n; i++) {
scanf("%d", &nxt[i][0]);
}
for (int i = 0; i < n; i++) {
scanf("%lld", &cost[i][0]);
min_cost[i][0] = cost[i][0];
}
for (int i = 1; i < BIT; i++) {
for (int j = 0; j < n; j++) {
nxt[j][i] = nxt[nxt[j][i - 1]][i - 1];
cost[j][i] = cost[j][i - 1] + cost[nxt[j][i - 1]][i - 1];
min_cost[j][i] = min(min_cost[j][i - 1], min_cost[nxt[j][i - 1]][i - 1]);
}
}
for (int i = 0; i < n; i++) {
long long s = 0, Min = INF;
int u = i;
for (int i = 0; i < BIT; i++) {
if ((k >> i) & 1) {
s += cost[u][i];
Min = min(Min, min_cost[u][i]);
u = nxt[u][i];
}
}
printf("%lld %lld\n", s, Min);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <class T>
void chmin(T &a, const T &b) noexcept {
if (b < a) a = b;
}
template <class T>
void chmax(T &a, const T &b) noexcept {
if (a < b) a = b;
}
void debug_out() { cout << "\n"; }
template <class T, class... Args>
void debug_out(const T &x, const Args &...args) {
cout << x << " ";
debug_out(args...);
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
ll n, m;
cin >> n >> m;
vector<int> a(n);
int k = 1;
while ((1LL << k) <= m) k++;
vector<vector<int> > par(k, vector<int>(n, -1));
vector<vector<ll> > sum_w(k, vector<ll>(n, 0));
vector<vector<ll> > min_w(k, vector<ll>(n, 1LL << 60));
for (int i = 0; i < (n); ++i) {
cin >> par[0][i];
}
for (int i = 0; i < (n); ++i) {
cin >> sum_w[0][i];
min_w[0][i] = sum_w[0][i];
}
for (int i = 0; i < (k - 1); ++i)
for (int v = 0; v < (n); ++v) {
if (par[i][v] < 0)
par[i + 1][v] = -1;
else {
par[i + 1][v] = par[i][par[i][v]];
sum_w[i + 1][v] = sum_w[i][v] + sum_w[i][par[i][v]];
min_w[i + 1][v] = min(min_w[i][v], min_w[i][par[i][v]]);
}
}
for (int i = 0; i < (n); ++i) {
int ind = i;
int tk = k - 1;
ll cur = 0;
ll s = 0, mini = 1LL << 60;
while (tk >= 0) {
if (cur == m) break;
if (cur + (1LL << tk) <= m) {
s += sum_w[tk][ind];
chmin(mini, min_w[tk][ind]);
ind = par[tk][ind];
cur += 1LL << tk;
}
tk--;
}
cout << s << " " << mini << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010, maxlog = 36;
int n;
long long k;
struct f {
long long sum;
int to, mn;
} dp[maxlog][maxn];
int main() {
scanf("%d %lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &dp[0][i].to);
}
for (int i = 0; i < n; i++) {
scanf("%d", &dp[0][i].mn);
dp[0][i].sum = dp[0][i].mn;
}
for (int i = 1; i < maxlog; i++) {
for (int j = 0; j < n; j++) {
dp[i][j].to = dp[i - 1][dp[i - 1][j].to].to;
dp[i][j].sum = dp[i - 1][j].sum + dp[i - 1][dp[i - 1][j].to].sum;
dp[i][j].mn = min(dp[i - 1][j].mn, dp[i - 1][dp[i - 1][j].to].mn);
}
}
for (int j = 0; j < n; j++) {
f r = {0ll, j, 1000000000};
for (int i = 0; i < maxlog; i++) {
if (k & (1ll << i)) {
r.sum += dp[i][r.to].sum;
r.mn = min(r.mn, dp[i][r.to].mn);
r.to = dp[i][r.to].to;
}
}
printf("%lld %d\n", r.sum, r.mn);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long NMAX = 100000, LOGK = 35;
long long S[LOGK][NMAX], M[LOGK][NMAX], D[LOGK][NMAX];
long long f[NMAX], w[NMAX];
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
for (int i = 0; i < n; i++) scanf("%lld", f + i);
for (int i = 0; i < n; i++) scanf("%lld", w + i);
for (int i = 0; i < n; i++) S[0][i] = M[0][i] = w[i];
for (int i = 0; i < n; i++) D[0][i] = f[i];
for (int i = 1; i < LOGK; i++)
for (int j = 0; j < n; j++) {
S[i][j] = S[i - 1][j] + S[i - 1][D[i - 1][j]];
M[i][j] = min(M[i - 1][j], M[i - 1][D[i - 1][j]]);
D[i][j] = D[i - 1][D[i - 1][j]];
}
for (int i = 0; i < n; i++) {
int it = i;
long long s = 0, m = 0x7fFFffFFffFFffFFLL;
for (int j = 0; j < LOGK; j++)
if (k & (1LL << j)) {
s += S[j][it];
m = min(m, M[j][it]);
it = D[j][it];
}
printf("%lld %lld\n", s, m);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-15;
const double pi = acos(-1.0);
const int inf = 1 << 30;
const long long Mod = 1000000007;
const int N = 1e5 + 5;
const int Log = 50;
long long Sum[N][Log];
long long Min[N][Log];
long long Par[N][Log];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
long long n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> Par[i][0];
}
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
Sum[i][0] = Min[i][0] = x;
}
for (int j = 1; j < Log; j++) {
for (int i = 0; i < n; i++) {
Par[i][j] = Par[Par[i][j - 1]][j - 1];
Sum[i][j] = Sum[i][j - 1] + Sum[Par[i][j - 1]][j - 1];
Min[i][j] = min(Min[i][j - 1], Min[Par[i][j - 1]][j - 1]);
}
}
for (long long i = 0; i < n; i++) {
long long s = 0;
long long Mn = Mod;
long long cur = i;
for (int j = 0; j < Log; j++) {
if (k & (1LL << j)) {
Mn = min(Mn, Min[cur][j]);
s += Sum[cur][j];
cur = Par[cur][j];
}
}
cout << s << ' ' << Mn << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fac[1010], inv[1010], mod;
int ksm(int a, int b = mod - 2) {
int r = 1;
for (; b; b >>= 1) {
if (b & 1) r = 1ll * r * a % mod;
a = 1ll * a * a % mod;
}
return r;
}
int C(int a, int b) {
int r = inv[b];
for (b--; b >= 0; b--) r = 1ll * r * (a - b) % mod;
return r;
}
int f[1010][12][1010];
int main() {
int n, d;
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) {
puts("1");
return 0;
}
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[n] = ksm(fac[n]);
for (int i = n - 1; i >= 0; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= min(d, i - 1); j++)
for (int k = 1; k <= n; k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1; t * k <= i && t <= j; t++)
f[i][j][k] =
(f[i][j][k] +
1ll * f[i - t * k][j - t][k - 1] *
(C(f[k][k == 1 ? 0 : d - 1][k - 1] + t - 1, t)) % mod) %
mod;
}
printf("%d\n", (f[n][d][n / 2] -
((n & 1) ? 0 : C(f[n / 2][d - 1][n / 2 - 1], 2)) + mod) %
mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int M = 12;
long long MOD;
long long dp[N][M][N];
long long curCom[M];
long long inv2[M];
inline long long mypow(long long a, long long b) {
int res = 1;
while (b) {
if (b & 1) {
res = ((long long)res * a) % MOD;
}
a = ((long long)a * a) % MOD;
b >>= 1;
}
return res;
}
inline long long cmb(long long a, long long b) {
long long d1, d2;
if (a < b) {
return 0;
}
d1 = 1;
d2 = inv2[b];
while (b) {
d1 = (long long)d1 * a % MOD;
b--;
a--;
}
return (long long)d1 * d2 % MOD;
}
bool calCurCom(long long n, int m) {
if (n == 0) {
return false;
}
int i;
long long mul = 1;
long long tmp = n;
for (i = 1; i <= m; i++, tmp++) {
mul = mul * tmp % MOD;
curCom[i] = mul * inv2[i] % MOD;
}
return true;
}
int main() {
int n, d, i, j, k, l, m;
scanf("%d%d%lld", &n, &d, &MOD);
if (n <= 2) {
printf("1\n");
return 0;
}
long long tmp = 1;
inv2[1] = 1;
for (i = 2; i <= d; i++) {
tmp = tmp * i;
inv2[i] = mypow(tmp, MOD - 2);
}
for (k = 0; k <= n; k++) {
dp[1][0][k] = 1;
}
for (i = 2; i <= d + 1; i++) {
for (k = 1; k <= n; k++) {
dp[i][i - 1][k] = 1;
}
}
for (i = 3; i <= n; i++) {
for (j = 1; j <= d && j < i - 1; j++) {
for (k = 2; k <= n - 1; k++) {
dp[i][j][k] = dp[i][j][k - 1];
if (calCurCom(dp[k][d - 1][k - 1], j)) {
for (l = 1; l <= j && l * k < i; l++) {
tmp = (long long)dp[i - k * l][j - l][k - 1] * curCom[l] % MOD;
dp[i][j][k] = ((long long)dp[i][j][k] + tmp) % MOD;
}
}
}
}
}
long long ans = 0;
ans = dp[n][d][(n + 1) / 2 - 1];
if ((n & 1) == 0) {
ans = ((long long)ans + cmb(dp[n / 2][d - 1][n / 2 - 1] + 1, 2)) % MOD;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int 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;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int mod, n, d;
inline int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
inline int sub(int a, int b) { return a >= b ? a - b : a - b + mod; }
inline int mul(int a, int b) { return 1ll * a * b % mod; }
inline int power(int a, int b) {
int res = 1;
for (; b; b >>= 1) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
}
return res;
}
int fac[N], ifac[N], f[N][12][N];
inline void prework(int n) {
fac[0] = fac[1] = ifac[0] = ifac[1] = 1;
for (int i = 2; i <= n; i++) fac[i] = mul(i, fac[i - 1]);
for (int i = 2; i <= n; i++) ifac[i] = mul(sub(mod, mod / i), ifac[mod % i]);
for (int i = 2; i <= n; i++) ifac[i] = mul(ifac[i], ifac[i - 1]);
}
inline int C(int n, int m) {
if (m > n) return 0;
int res = 1;
for (int i = n - m + 1; i <= n; i++) res = mul(res, i);
return mul(res, ifac[m]);
}
int main() {
cin >> n >> d >> mod;
if (n == 1 || n == 2) {
puts("1");
return 0;
}
prework(1000);
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 (i >= t * k && j >= t && k - 1 >= 0)
if (k > 1)
f[i][j][k] =
add(f[i][j][k], mul(f[i - t * k][j - t][k - 1],
C(f[k][d - 1][k - 1] + t - 1, t)));
else
f[i][j][k] = add(f[i][j][k], mul(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] << endl;
else
cout << sub(f[n][d][n / 2], C(f[n / 2][d - 1][n / 2 - 1], 2)) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long pinv[1111];
long long mod;
long long dp[1111][11][1111][2];
int D;
long long c(long long n, int r) {
if (n < r) return 0;
long long ret = 1;
for (int i = 1; i <= r; i++) {
ret = ret * n % mod;
ret = ret * pinv[i] % mod;
n--;
}
return ret;
}
long long f(int n, int sub, int sz, bool can_leaf) {
long long &ret = dp[n][sub][sz][can_leaf];
if (ret >= 0) return ret;
ret = 0;
if (n == 1) {
if (sub == 0) return ret = 1;
return ret = can_leaf;
}
if (sz == 0) return ret = 0;
ret += f(n, sub, sz - 1, can_leaf);
for (int t = 1;; t++) {
if (n > t * sz && sub >= t)
ret = (ret + f(n - t * sz, sub - t, sz - 1, false) *
c(f(sz, D - 1, sz - 1, true) + t - 1, t) % mod) %
mod;
else
break;
}
return ret;
}
int main() {
int n;
scanf("%d%d%lld", &n, &D, &mod);
memset(dp, -1, sizeof(dp));
pinv[1] = 1;
for (int i = 2; i <= 1000; i++) pinv[i] = mod - mod / i * pinv[mod % i] % mod;
long long ret = f(n, D, n % 2 ? n / 2 : n / 2 - 1, true);
if (n % 2 == 0)
ret = (ret + c(f(n / 2, D - 1, n / 2 - 1, true) + 1, 2)) % mod;
printf("%lld", ret);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010, D = 12;
int n, d, MOD;
long long dp[N][D][N], inv[D];
long long power(long long a, int b) {
long long res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % MOD;
a = 1ll * a * a % MOD;
b >>= 1;
}
return res;
}
int main() {
cin >> n >> d >> MOD;
if (n == 1) return puts("1"), 0;
for (int i = (1); i <= (d); ++i) inv[i] = power(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 <= (min(d, i - 1)); ++j) {
for (int k = (1); k <= (i - 1); ++k) {
dp[i][j][k] = dp[i][j][k - 1];
long long tmp = 1;
for (int t = 1; t <= j && k * t < i; ++t) {
tmp = 1ll * tmp * (dp[k][d - 1][k - 1] + t - 1) % MOD;
tmp = 1ll * tmp * inv[t] % MOD;
dp[i][j][k] = (dp[i][j][k] +
1ll * dp[i - k * t][j - t][min(k - 1, i - k * t - 1)] *
tmp % MOD) %
MOD;
}
}
}
}
long long ans = dp[n][d][(n - 1) >> 1];
if (!(n & 1)) {
long long t = dp[n >> 1][d - 1][(n >> 1) - 1];
(ans += 1ll * (t + 1) * t / 2 % MOD) %= MOD;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
mt19937 ggen;
int MOD;
inline int add(int a, int b, int m = MOD) {
int res = a + b;
if (res >= m) res -= m;
return res;
}
inline int sub(int a, int b, int m = MOD) {
int res = a - b;
if (res < 0) res += m;
return res;
}
inline int mul(int a, int b, int m = MOD) { return ((long long)(a)*b) % m; }
inline int binpow(int a, int p, int m = MOD) {
if (m == 1) return 0;
int res = 1;
while (p) {
if (p & 1) res = mul(res, a, m);
a = mul(a, a, m);
p >>= 1;
}
return res;
}
inline int obr(int a, int m = MOD) { return binpow(a, m - 2, m); }
int fact[1010];
int rfact[1010];
void precalc() {
fact[0] = rfact[0] = 1;
for (int i = 1; i < 1010; i++) {
fact[i] = mul(fact[i - 1], i);
rfact[i] = obr(fact[i]);
}
}
inline int comb(int n, int k) {
int res = rfact[k];
for (int i = 0; i < k; i++) {
res = mul(res, n);
n--;
}
return res;
}
int n, d;
int f[1010][11][1010];
int dyn(int sz, int pw, int ms) {
if (pw == 0) {
return sz == 1;
}
if (ms == 0) return 0;
if (ms == 1) return (sz - 1 == pw);
if (f[sz][pw][ms] != -1) return f[sz][pw][ms];
int res = dyn(sz, pw, ms - 1);
int tt = dyn(ms, d - 1, ms - 1);
for (int i = 1; i <= pw && sz > i * ms && tt; i++) {
int tres = dyn(sz - i * ms, pw - i, ms - 1);
res = add(res, mul(tres, comb(tt + i - 1, i)));
}
return f[sz][pw][ms] = res;
}
void solve() {
cin >> n >> d >> MOD;
precalc();
if (n <= 2) {
cout << 1;
return;
}
memset(f, -1, sizeof f);
int res = dyn(n, d, (n - 1) / 2);
if ((n & 1) == 0) {
res = add(res, comb(dyn(n / 2, d - 1, n / 2 - 1) + 1, 2));
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
ggen = mt19937(13);
solve();
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 n, d, mod;
long long dp[1111][11][1111], invx[11];
long long powermod(long long a, long long n, long long mod) {
long long ans = 1;
while (n) {
if (n & 1) ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
long long inv(long long a, long long mod) { return powermod(a, mod - 2, mod); }
int main() {
cin >> n >> d >> mod;
invx[1] = 1;
for (int i = 2; i < 11; i++) invx[i] = inv(i, mod) % mod;
if (n <= 2) {
puts("1");
return 0;
}
dp[1][0][0] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= d; j++) {
for (int k = (i - 1) / j; k <= i - 1; k++) {
dp[i][j][k] = dp[i][j][k - 1];
long long cur = 1, buf = dp[k][d - 1][k - 1];
for (int t = 1; t <= j && t * k <= i - 1; t++) {
cur = cur * buf++ % mod * invx[t] % mod;
dp[i][j][k] =
(dp[i][j][k] + dp[i - t * k][j - t][min(k - 1, i - t * k - 1)] *
(cur + (k == 1))) %
mod;
}
}
}
}
long long ans = dp[n][d][(n - 1) / 2];
if (n % 2 == 0)
ans = (ans + dp[n / 2][d - 1][n / 2 - 1] *
(dp[n / 2][d - 1][n / 2 - 1] + 1) % mod * invx[2]) %
mod;
cout << ans << endl;
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 - 1) / 2];
if (~n & 1)
inc(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;
using ll = long long;
using ld = long double;
const ld eps = 1e-8;
template <class U, class V>
ostream& operator<<(ostream& out, const pair<U, V>& u) {
return out << "(" << u.first << ", " << u.second << ")";
}
template <class Con, class = decltype(begin(declval<Con>()))>
typename enable_if<!is_same<Con, string>::value, ostream&>::type operator<<(
ostream& out, const Con& con) {
out << "{";
for (auto beg = con.begin(), it = beg; it != con.end(); ++it)
out << (it == beg ? "" : ", ") << *it;
return out << "}";
}
template <size_t i, class T>
ostream& print_tuple_utils(ostream& out, const T& tup) {
if constexpr (i == tuple_size<T>::value)
return out << ")";
else
return print_tuple_utils<i + 1, T>(out << (i ? ", " : "(") << get<i>(tup),
tup);
}
template <class... U>
ostream& operator<<(ostream& out, const tuple<U...>& u) {
return print_tuple_utils<0, tuple<U...>>(out, u);
}
int mod;
struct modint {
int x;
modint(int xx = 0) : x(xx) {}
modint(ll xx) : x((int)(xx % mod)) {}
friend inline modint operator+(modint u, const modint& v) { return u += v; }
modint& operator+=(const modint& o) {
if ((x += o.x) >= mod) x -= mod;
return *this;
}
friend inline modint operator-(modint u, const modint& v) { return u -= v; }
modint& operator-=(const modint& o) {
if ((x -= o.x) < 0) x += mod;
return *this;
}
friend inline modint operator*(modint u, const modint& v) { return u *= v; }
modint& operator*=(const modint& o) { return *this = modint(1ll * x * o.x); }
modint pow(ll exp, modint ans = 1) const {
modint base = *this;
for (; exp > 0; exp >>= 1, base *= base)
if (exp & 1) ans *= base;
return ans;
}
friend inline modint operator/(modint u, const modint& v) { return u /= v; }
modint& operator/=(const modint& o) { return *this = o.pow(mod - 2, *this); }
friend ostream& operator<<(ostream& out, const modint& u) {
return out << u.x;
}
};
using mint = modint;
const int maxn = 1024;
const int maxd = 16;
mint dp[maxn][maxd][maxn];
mint ifac[maxd];
void precal() {
ifac[0] = 1;
for (int i = (int)(1); i < (int)(maxd); ++i) ifac[i] = ifac[i - 1] / i;
}
int n, d;
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> d >> mod;
precal();
if (n == 1) {
cout << "1";
return 0;
}
dp[1][0][0] = 1;
dp[1][d - 1][0] = 1;
for (int treesize = (int)(2); treesize < (int)(n + 1); ++treesize) {
;
if (0)
cerr << "["
"treesize"
" = "
<< (treesize) << "] " << endl;
for (int root_deg = (int)(0); root_deg < (int)(d + 1); ++root_deg) {
for (int max_sub_size = (int)(1); max_sub_size < (int)(treesize);
++max_sub_size) {
;
if (0)
cerr << "["
"root_deg"
" = "
<< (root_deg) << "] "
<< "["
"max_sub_size"
" = "
<< (max_sub_size) << "] " << endl;
auto& cur = dp[treesize][root_deg][max_sub_size];
cur += dp[treesize][root_deg][max_sub_size - 1];
auto u =
max_sub_size > 1 ? dp[max_sub_size][d - 1][max_sub_size - 1] : 1;
if (0)
cerr << "["
"u"
" = "
<< (u) << "] " << endl;
mint cur_mul = 1;
for (int cur_sub = (int)(1); cur_sub < (int)(root_deg + 1); ++cur_sub) {
cur_mul *= (u + cur_sub - 1);
int new_size = treesize - cur_sub * max_sub_size;
if (new_size <= 0) break;
if (0)
cerr << "["
"new_size"
" = "
<< (new_size) << "] "
<< "["
"root_deg - cur_sub"
" = "
<< (root_deg - cur_sub) << "] " << endl;
auto comb = cur_mul * ifac[cur_sub];
auto rest =
dp[new_size][root_deg - cur_sub][min(new_size, max_sub_size) - 1];
if (0)
cerr << "["
"cur_sub"
" = "
<< (cur_sub) << "] "
<< "["
"comb.x"
" = "
<< (comb.x) << "] "
<< "["
"rest"
" = "
<< (rest) << "] " << endl;
cur += rest * comb;
}
if (0)
cerr << "["
"cur"
" = "
<< (cur) << "] " << endl;
}
}
}
auto ans = dp[n][d][(n - 1) / 2];
if (n % 2 == 0) {
auto t = dp[n / 2][d - 1][n / 2 - 1];
ans += t * (t + 1) * ifac[2];
}
cout << ans.x;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int f[maxn][11][505], rev[11];
int n, d, mod;
inline int power(int x, int p) {
int res = 1;
while (p) {
if (p & 1) res = 1ll * res * x % mod;
x = 1ll * x * x % mod;
p >>= 1;
}
return res;
}
inline int C(int n, int m) {
if (m < 0 || m > n) return 0;
int res = 1;
for (int i = (1); i <= (m); i++) res = 1ll * res * rev[i] % mod;
for (int i = (n - m + 1); i <= (n); i++) res = 1ll * res * i % mod;
return res;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n == 1) return puts("1"), 0;
for (int i = (1); i <= (d); i++) rev[i] = power(i, mod - 2);
for (int i = (0); i <= (n / 2); i++) f[1][d - 1][i] = f[1][0][i] = 1;
for (int i = (2); i <= (n); i++)
for (int j = (1); j <= (d); j++)
for (int k = (1); k <= (n / 2); k++) {
f[i][j][k] = f[i][j][k - 1];
for (int t = (1); t <= (j); t++)
if (i - t * k >= 1)
f[i][j][k] = (f[i][j][k] + 1ll * f[i - t * k][j - t][k - 1] *
C(f[k][d - 1][k - 1] + t - 1, t)) %
mod;
}
int ans = f[n][d][n / 2];
if (!(n & 1)) {
ans = (ans + mod - C(f[n / 2][d - 1][n / 2 - 1] + 1, 2)) % mod;
ans = (ans + f[n / 2][d - 1][n / 2 - 1]) % mod;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }
int read() {
int x = 0, w = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
return x * w;
}
const int N = 1010;
long long fac[N], inv[N], Mod, f[N][15][N];
int n, d;
long long power(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1, a = a * a % Mod)
if (b & 1) res = res * a % Mod;
return res;
}
long long C(long long n, long long m) {
if (n < m || m < 0) return 0;
long long res = inv[m];
for (m--; m >= 0; m--) res = res * (n - m) % Mod;
return res;
}
void init() {
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % Mod;
inv[n] = power(fac[n], Mod - 2);
for (int i = n - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % Mod;
}
int main() {
n = read(), d = read(), Mod = read();
if (n <= 2) {
printf("1");
return 0;
}
init();
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 cnt = 1; cnt * k <= i && cnt <= j; cnt++)
f[i][j][k] =
(f[i][j][k] +
f[i - cnt * k][j - cnt][k - 1] *
(k == 1 ? 1 : C(f[k][d - 1][k - 1] + cnt - 1, cnt)) % Mod) %
Mod;
}
printf("%lld\n", (f[n][d][n / 2] -
((n & 1) ? 0 : C(f[n / 2][d - 1][n / 2 - 1], 2)) + Mod) %
Mod);
}
|
#include <bits/stdc++.h>
using namespace std;
void Read(int &x) {
char c;
while (c = getchar(), c != EOF)
if (c >= '0' && c <= '9') {
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
ungetc(c, stdin);
return;
}
}
int n, d, MOD, f[1000 + 10][11], g[1000 + 10], inv[1000 + 10], ans;
int main() {
Read(n), Read(d), Read(MOD);
if (n <= 2) {
puts("1");
return 0;
}
if ((n - 2) % (d - 1)) {
puts("0");
return 0;
}
int i, j, p, q, w;
inv[0] = inv[1] = 1;
for (i = 2; i <= n; i++) inv[i] = 1ll * (MOD - MOD / i) * inv[MOD % i] % MOD;
for (i = 2; i <= n; i++) inv[i] = 1ll * inv[i] * inv[i - 1] % MOD;
g[1] = f[1][0] = 1;
for (i = 1; i <= ((n - 1) >> 1); i++) {
for (j = n - i + 1; j >= 1; j--)
for (p = 0; p < d; p++)
if (f[j][p]) {
w = 1;
for (q = 1; p + q <= d && j + q * i <= n; q++) {
w = 1ll * w * (g[i] + q - 1) % MOD;
f[j + q * i][p + q] =
(f[j + q * i][p + q] + 1ll * w * inv[q] % MOD * f[j][p]) % MOD;
}
}
g[i + 1] = f[i + 1][d - 1];
}
ans = f[n][d];
if (!(n & 1))
ans = (ans + g[n >> 1] + (1ll * g[n >> 1] * (g[n >> 1] - 1) / 2)) % MOD;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using uint = unsigned int;
template <class T>
using V = vector<T>;
template <class T>
using VV = vector<vector<T>>;
template <class T, class U>
void chmax(T& x, U y) {
if (x < y) x = y;
}
template <class T, class U>
void chmin(T& x, U y) {
if (y < x) x = y;
}
template <class T>
void mkuni(V<T>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
template <class S, class T>
ostream& operator<<(ostream& o, const pair<S, T>& p) {
return o << "(" << p.first << "," << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& vc) {
o << "{";
for (const T& v : vc) o << v << ",";
o << "}";
return o;
}
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
unsigned int mod = 1;
struct ModInt {
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
uint v;
ModInt() : v(0) {}
ModInt(ll _v) : v(normS(_v % mod + mod)) {}
explicit operator bool() const { return v != 0; }
static uint normS(const uint& x) { return (x < mod) ? x : x - mod; }
static ModInt make(const uint& x) {
ModInt m;
m.v = x;
return m;
}
ModInt operator+(const ModInt& b) const { return make(normS(v + b.v)); }
ModInt operator-(const ModInt& b) const { return make(normS(v + mod - b.v)); }
ModInt operator-() const { return make(normS(mod - v)); }
ModInt operator*(const ModInt& b) const { return make((ull)v * b.v % mod); }
ModInt operator/(const ModInt& b) const { return *this * b.inv(); }
ModInt& operator+=(const ModInt& b) { return *this = *this + b; }
ModInt& operator-=(const ModInt& b) { return *this = *this - b; }
ModInt& operator*=(const ModInt& b) { return *this = *this * b; }
ModInt& operator/=(const ModInt& b) { return *this = *this / b; }
ModInt& operator++(int) { return *this = *this + 1; }
ModInt& operator--(int) { return *this = *this - 1; }
ll extgcd(ll a, ll b, ll& x, ll& y) const {
ll p[] = {a, 1, 0}, q[] = {b, 0, 1};
while (*q) {
ll t = *p / *q;
for (int i = 0; i < int(3); i++) swap(p[i] -= t * q[i], q[i]);
}
if (p[0] < 0)
for (int i = 0; i < int(3); i++) p[i] = -p[i];
x = p[1], y = p[2];
return p[0];
}
ModInt inv() const {
ll x, y;
extgcd(v, mod, x, y);
return make(normS(x + mod));
}
ModInt pow(ll p) const {
if (p < 0) return inv().pow(-p);
ModInt a = 1;
ModInt x = *this;
while (p) {
if (p & 1) a *= x;
x *= x;
p >>= 1;
}
return a;
}
bool operator==(const ModInt& b) const { return v == b.v; }
bool operator!=(const ModInt& b) const { return v != b.v; }
friend istream& operator>>(istream& o, ModInt& x) {
ll tmp;
o >> tmp;
x = ModInt(tmp);
return o;
}
friend ostream& operator<<(ostream& o, const ModInt& x) { return o << x.v; }
};
using mint = ModInt;
V<mint> fact, ifact;
mint Choose(int a, int b) {
if (b < 0 || a < b) return 0;
return fact[a] * ifact[b] * ifact[a - b];
}
void InitFact(int N) {
fact.resize(N);
ifact.resize(N);
fact[0] = 1;
for (int i = 1; i <= int(N - 1); i++) fact[i] = fact[i - 1] * i;
ifact[N - 1] = fact[N - 1].inv();
for (int i = N - 2; i >= 0; i--) ifact[i] = ifact[i + 1] * (i + 1);
}
mint H(mint v, int k) {
mint res = 1;
for (int i = 0; i < int(k); i++) res *= v + i;
res *= ifact[k];
return res;
}
mint cur[1010][11], nxt[1010][11];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, D;
cin >> N >> D >> mod;
if (N <= 2) {
cout << 1 << endl;
return 0;
}
InitFact(100000);
cur[1][0] = 1;
for (int k = 1; k <= int((N - 1) / 2); k++) {
for (int s = 0; s < int(N + 1); s++)
for (int d = 0; d < int(D + 1); d++) {
nxt[s][d] = 0;
for (int dd = 0; dd < int(d + 1); dd++) {
int ps = s - dd * k;
if (ps < 0) break;
int pd = d - dd;
if (k > 1)
nxt[s][d] += cur[ps][pd] * H(cur[k][D - 1], dd);
else
nxt[s][d] += cur[ps][pd];
}
}
for (int s = 0; s < int(1010); s++)
for (int d = 0; d < int(11); d++) {
cur[s][d] = nxt[s][d];
nxt[s][d] = 0;
}
}
mint ans = cur[N][D];
if (N % 2 == 0) {
mint v = cur[N / 2][D - 1];
ans += H(v, 2);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod;
long long inv[20];
void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
long long binom(int n, int m) {
long long res = 1;
for (int i = 1; i <= m; i++) res = res * (n - i + 1) % mod * inv[i] % mod;
return res;
}
int dp[1000 + 5][12][1000 + 5], g[1000 + 5][12];
int main() {
int n, d;
scanf("%d%d%d", &n, &d, &mod);
inv[1] = 1;
for (int i = 2; i <= 15; i++) inv[i] = inv[mod % i] * (mod - mod / i) % mod;
if (n <= 2) return puts("1"), 0;
dp[1][0][0] = 1;
for (int j = 0; j <= d; j++) g[1][j] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= d; j++) {
for (int k = 1; k <= i - 1; k++)
for (int j2 = 0; j2 <= j; j2++) {
if (j2 * k >= i) break;
add(dp[i][j][k],
1ll * dp[i - j2 * k][j - j2][min(k - 1, i - j2 * k - 1)] *
g[k][j2] % mod);
}
for (int j = 0; j <= d; j++)
g[i][j] = binom(dp[i][d - 1][i - 1] + j - 1, j);
}
int ans = dp[n][d][n / 2];
if (n % 2 == 0)
ans = (ans + mod - binom(dp[n / 2][d - 1][n / 2 - 1], 2)) % mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
int P;
template <typename T1, typename T2>
void Inc(T1 &a, T2 b) {
a += b;
if (a >= P) a -= P;
}
template <typename T1, typename T2>
void Dec(T1 &a, T2 b) {
a -= b;
if (a < 0) a += P;
}
template <typename T1, typename T2>
T1 Add(T1 a, T2 b) {
a += b;
return a >= P ? a - P : a;
}
template <typename T1, typename T2>
T1 Sub(T1 a, T2 b) {
a -= b;
return a < 0 ? a + P : a;
}
long long ksm(long long a, long long b) {
long long ret = 1;
for (; b; b >>= 1, (a *= a) %= P)
if (b & 1) (ret *= a) %= P;
return ret;
}
int n, d;
long long f[MAXN][11][MAXN], inv[MAXN];
long long C2(long long x) { return x * (x - 1) / 2 % P; }
int main() {
scanf("%d%d%d", &n, &d, &P);
if (n <= 2) return puts("1"), 0;
for (int i = 0; i <= n; i++) f[1][0][i] = 1;
inv[1] = 1;
for (int i = 2; i <= d; i++) inv[i] = Sub(P, P / i) * inv[P % i] % P;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= d; j++)
for (int k = 1; k <= n; k++) {
f[i][j][k] = f[i][j][k - 1];
long long s = f[k][d - 1][k], C = 1;
if (k == 1) s = 1;
for (int m = 1; m * k <= i && m <= j; m++) {
C = C * (s + m - 1) % P * inv[m] % P;
Inc(f[i][j][k], f[i - m * k][j - m][k - 1] * C % P);
}
}
long long Ans = f[n][d][n / 2];
if (~n & 1) Dec(Ans, C2(f[n / 2][d - 1][n / 2]));
printf("%lld\n", Ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int mod;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 1010;
long long dp[N][20], pd[N][20], f[N], t[20];
int n, d;
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) {
puts("1");
return 0;
}
if ((n - 2) % (d - 1) != 0) {
puts("0");
return 0;
}
dp[0][0] = 1;
for (int i = 1; i < n / 2 + 1; i++)
if ((i - 1) % (d - 1) == 0) {
if (i == 1)
f[i] = 1;
else
f[i] = dp[i - 1][d - 1];
t[0] = 1;
for (int j = 1; j < d + 1; j++) {
t[j] = t[j - 1] * (f[i] + j - 1) % mod * powmod(j, mod - 2) % mod;
}
for (int p = 0; p < n + 1; p++)
for (int q = 0; q < d + 1; q++) pd[p][q] = 0;
for (int r = 0; r < d + 1; r++)
for (int q = 0; q < d + 1; q++)
if (r + q <= d)
for (int p = 0; p < n + 1; p++)
if (p + q * i <= n) {
pd[p + q * i][r + q] =
(pd[p + q * i][r + q] + dp[p][r] * t[q]) % mod;
}
for (int p = 0; p < n + 1; p++)
for (int q = 0; q < d + 1; q++)
if (pd[p][q]) {
dp[p][q] = pd[p][q];
}
}
int ret = dp[n - 1][d];
if (n % 2 == 0) {
ret = (ret - dp[n / 2 - 1][d - 1] * (dp[n / 2 - 1][d - 1] - 1) / 2) % mod;
if (ret < 0) ret += mod;
}
printf("%d\n", ret);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, MOD;
int f[1010][11];
int ans[1010];
int s[11];
int mo(int x) {
if (x >= MOD) return x - MOD;
return x;
}
int power(int x, int y) {
int ans = 1, t = x;
while (y) {
if (y % 2) ans = 1ll * ans * t % MOD;
t = 1ll * t * t % MOD;
y /= 2;
}
return ans;
}
int C(int x, int y) {
int sum = 1;
for (int i = 1; i <= y; i++)
sum = 1ll * sum * (x - i + 1) % MOD * power(i, MOD - 2) % MOD;
return sum;
}
int main() {
scanf("%d%d%d", &n, &m, &MOD);
if (n == 2) {
printf("1\n");
return 0;
}
ans[1] = 1;
f[0][0] = 1;
for (int i = 1; i < n; i++) {
if (i <= (n - 1) / 2) {
for (int j = 1; j <= m; j++) s[j] = C(ans[i] + j - 1, j);
for (int w = m; w; w--)
for (int j = w; j; j--)
for (int k = 0; k <= n - j * i; k++)
f[k + j * i][w] =
mo(f[k + j * i][w] + 1ll * f[k][w - j] * s[j] % MOD);
}
if (n % 2 == 0 && i == n / 2) {
for (int j = 1; j <= m; j++)
s[j] = 1ll * C(ans[i] + j - 1, j) * power(2, MOD - 2) % MOD;
for (int w = m; w; w--)
for (int j = w; j; j--)
for (int k = 0; k <= n - j * i; k++)
f[k + j * i][w] =
mo(f[k + j * i][w] + 1ll * f[k][w - j] * s[j] % MOD);
}
if (i == n - 1)
ans[i + 1] = f[i][m];
else
ans[i + 1] = f[i][m - 1];
}
if (n % 2 == 0)
ans[n] = mo(ans[n] + 1ll * ans[n / 2] * power(2, MOD - 2) % MOD);
printf("%d\n", ans[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1010, MAX_D = 12;
int n, d, mod, inv[MAX_D], dp[MAX_N][MAX_N][MAX_D];
bool vis[MAX_N][MAX_N][MAX_D];
int fpow(int bas, int tim) {
int ret = 1;
while (tim) {
if (tim & 1) ret = 1LL * ret * bas % mod;
bas = 1LL * bas * bas % mod;
tim >>= 1;
}
return ret;
}
int solve(int scale, int max_part, int cdeg) {
if (vis[scale][max_part][cdeg]) return dp[scale][max_part][cdeg];
vis[scale][max_part][cdeg] = true;
int &ret = dp[scale][max_part][cdeg];
if (scale == 1) return ret = (cdeg == 0);
if (cdeg == 0 || max_part == 0 || cdeg >= scale) return ret = 0;
if (max_part == 1) return ret = (scale == cdeg + 1);
ret = solve(scale, max_part - 1, cdeg);
int part = solve(max_part, max_part, d - 1);
if (part == 0) return ret;
int binomial = 1;
for (int i = 1; i <= cdeg && 1LL * i * max_part <= scale - 1; i++) {
binomial = 1LL * binomial * inv[i] % mod * (part + i - 1) % mod;
ret =
(0LL + ret +
1LL * binomial *
solve(scale - 1LL * i * max_part, max_part - 1, cdeg - i) % mod) %
mod;
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
for (int i = 1; i <= d; i++) inv[i] = fpow(i, mod - 2);
if (n <= 2) puts("1"), exit(0);
if (n & 1) printf("%d\n", solve(n, n >> 1, d)), exit(0);
int part = solve(n >> 1, (n >> 1) - 1, d - 1);
part = 1LL * part * (part + 1) % mod * inv[2] % mod;
part = (0LL + part + solve(n, (n >> 1) - 1, d)) % mod;
printf("%d\n", part);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e3 + 5, M = 20;
long long n, d, mod, dp[N][M][N], f[M], inv[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] = inv[0] = 1;
for (long long i = 1; i <= n; i++) f[i] = f[i - 1] * i % mod;
inv[n] = mul(f[n], mod - 2, mod);
for (long long i = n - 1; i; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
}
long long C(long long n, long long m) {
long long ans = 1;
for (long long i = 1; i <= m; i++) ans = ans * (n - i + 1) % mod;
return ans * inv[m] % mod;
}
signed main() {
scanf("%lld%lld%lld", &n, &d, &mod), init();
if (n <= 2) exit(0 * puts("1"));
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);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int maxd = 11, maxn = 1111;
long long P;
long long dp[maxn][maxn][maxd], t[maxn];
long long fact[maxn], tcaf[maxn];
long long deg(long long x, long long d) {
d %= P - 1;
if (d < 0) d += P - 1;
long long y = 1;
while (d) {
if (d & 1) y *= x, y %= P;
x *= x, x %= P;
d /= 2;
}
return y;
}
void add(long long &x, long long y) {
x += y;
x %= P;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n, d;
cin >> n >> d >> P;
if (n <= 2) {
cout << 1 << '\n';
return 0;
}
fact[0] = 1;
for (int i = 1; i <= (int)(n); ++i) fact[i] = fact[i - 1] * i % P;
for (int i = 0; i < (int)(n + 1); ++i) tcaf[i] = deg(fact[i], -1);
t[1] = 1;
dp[0][0][0] = 1;
for (int i = 1; i <= (int)(n); ++i) {
for (int k = 0; k < (int)(d + 1); ++k)
for (int q = 0; q < (int)(d - k + 1); ++q) {
long long w = 1;
for (int r = 0; r < (int)(q); ++r) w *= t[i] + r, w %= P;
w *= tcaf[q];
w %= P;
for (int s = 0; s < (int)(n + 1); ++s) {
int ss = s + q * i;
if (ss > n) break;
if (!dp[s][i - 1][k]) continue;
add(dp[ss][i][k + q], dp[s][i - 1][k] * w);
}
}
t[i + 1] = dp[i][i][d - 1];
}
long long ans = dp[n - 1][(n - 1) / 2][d];
if (n % 2 == 0) {
long long w = dp[n / 2 - 1][n / 2 - 1][d - 1];
add(ans, w * (w + 1) % P * (P + 1) / 2);
}
if (ans < 0) ans += P;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d, mod, f;
int bigmod(int v, int p) {
if (p == 0) return 1;
if (p == 1) return v;
if (p & 1) {
return 1LL * v * bigmod(v, p - 1) % mod;
}
int ret = bigmod(v, p / 2);
return 1LL * ret * ret % mod;
}
int dp[1001], dp2[1001][600][11];
long long inv[13];
int dp_func(int n);
int dp_func2(int n, int kto, int d) {
if (n == 0) return d == 0;
if (d == 0 || kto == 0) return 0;
if (dp2[n][kto][d] != -1) return dp2[n][kto][d];
long long ret = 0;
int g = dp_func(kto);
g--;
long long tmp = 1;
for (int i = 1; i <= d; i++) {
if (n < (i * kto)) break;
g++;
tmp = (tmp * g) % mod;
tmp = (tmp * inv[i]) % mod;
ret += 1LL * dp_func2(n - i * kto, kto - 1, d - i) * tmp % mod;
}
ret += dp_func2(n, kto - 1, d);
return dp2[n][kto][d] = ret % mod;
}
int dp_func(int n) {
if (n == 1) return 1;
if (dp[n] != -1) return dp[n];
int ret;
ret = dp_func2(n - 1, n - 1, d - 1);
return dp[n] = ret;
}
int main() {
int i, j, k, l, m;
int n;
scanf("%d%d%d", &n, &d, &mod);
if (n == 1 || n == 2) {
cout << 1 << endl;
return 0;
}
for (int i = 1; i <= 11; i++) {
inv[i] = bigmod(i, mod - 2);
}
memset(dp, -1, sizeof dp);
memset(dp2, -1, sizeof dp2);
int ans = dp_func2(n - 1, n / 2, d);
if (n % 2 == 0) {
long long dd = dp_func(n / 2);
dd = dd * (dd - 1);
dd /= 2;
dd %= mod;
ans -= dd;
if (ans < 0) ans += mod;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
const int kN = 1000 + 5;
int n, d, mod;
int f[kN][10 + 1][kN];
int g[kN];
inline void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
void exgcd(int a, int b, int &g, int &x, int &y) {
if (b == 0)
g = a, x = 1, y = 0;
else {
exgcd(b, a % b, g, y, x);
y -= x * (a / b);
}
}
int inv(int w) {
int g, x, y;
exgcd(w, mod, g, x, y);
return (x % mod + mod) % mod;
}
int Inv[10 + 1];
int work() {
if (n == 1) return 1;
if (n == 2) return 1;
for (int i = 1; i <= 10; ++i) Inv[i] = inv(i);
f[0][0][0] = 1;
g[1] = 1;
for (int j = 0; j + 1 <= n / 2; ++j) {
for (int cnt = 0; cnt <= d; ++cnt) {
for (int i = 0; i < n; ++i) {
if (f[j][cnt][i] == 0) continue;
int binom = 1;
add(f[j + 1][cnt][i], f[j][cnt][i]);
for (int k = 1; cnt + k <= d && i + (j + 1) * k < n; ++k) {
binom = binom * 1ll * (g[j + 1] + k - 1) % mod * Inv[k] % mod;
add(f[j + 1][cnt + k][i + (j + 1) * k],
f[j][cnt][i] * 1ll * binom % mod);
}
}
}
g[j + 2] = f[j + 1][d - 1][j + 1];
}
int ret = f[n / 2][d][n - 1];
if (n % 2 == 0) {
add(ret, mod - f[n / 2][d - 1][n / 2 - 1] * 1ll *
(f[n / 2][d - 1][n / 2 - 1] + mod - 1) % mod * Inv[2] %
mod);
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
printf("%d\n", work());
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
int p, n, d;
long long f[N][N], g[N][N], tmp[N], ans;
inline long long quick(long long x, int k) {
x %= p;
long long ans = 1;
for (; k; k >>= 1) {
if (k & 1) ans = ans * x % p;
x = x * x % p;
}
return ans;
}
int main() {
ios ::sync_with_stdio(false);
cin >> n >> d >> p;
int i, j, x, k, l;
if (n <= 2) return puts("1"), 0;
if ((n - 2) % (d - 1)) return puts("0"), 0;
f[0][0] = 1;
for (i = 1; i <= n / 2; ++i)
if ((i - 1) % (d - 1) == 0) {
x = ((i == 1) ? 1 : f[i - 1][d - 1]);
for (tmp[0] = 1, j = 1; j <= d; ++j)
tmp[j] = tmp[j - 1] * (x + j - 1) % p * quick(j, p - 2) % p;
memset(g, 0, sizeof(g));
for (l = 0; l <= d; ++l)
for (k = 0; k <= d; ++k)
if (l + k <= d)
for (x = 0; x <= n; ++x)
if (x + i * k <= n)
(g[x + i * k][l + k] += f[x][l] * tmp[k] % p) %= p;
for (x = 0; x <= n; ++x)
for (k = 0; k <= d; ++k)
if (g[x][k]) f[x][k] = g[x][k];
}
ans = f[n - 1][d];
if (n % 2 == 0)
(ans -= f[n / 2 - 1][d - 1] * (f[n / 2 - 1][d - 1] - 1) / 2 % p) %= p;
if (ans < 0) ans += p;
return printf("%d\n", ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, d, mod, inv[N], f[N][11][N];
int main() {
scanf("%d%d%d", &n, &d, &mod), inv[0] = inv[1] = 1;
if (n <= 2) return puts("1"), 0;
for (int i = 2; i < n; ++i)
inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod;
f[1][0][0] = f[1][d - 1][0] = 1;
for (int i = 2; i <= n; ++i)
for (int j = 1; j <= d; ++j)
for (int k = 1; k < i; ++k) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1, res = 1, p = f[k][d - 1][k - 1] - 1;
t * k < i && t <= j; ++t)
res = 1LL * res * (++p) % mod * inv[t] % mod,
(f[i][j][k] += 1LL * f[i - t * k][j - t][min(k - 1, i - t * k - 1)] *
res % mod) %= mod;
}
printf("%lld\n", (f[n][d][(n + 1) / 2 - 1] +
1LL * (1 - n % 2) * f[n / 2][d - 1][n / 2 - 1] *
(f[n / 2][d - 1][n / 2 - 1] + 1) / 2 % mod) %
mod);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d, mod, dp[1005][15][1005], inv[1005];
int pw(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) r = 1ll * r * a % mod;
return r;
}
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n <= 2) {
puts("1");
return 0;
}
for (int i = 1; i < n; i++) inv[i] = pw(i, mod - 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], c = 1;
for (int t = 1; t * k < i && t <= j; t++, r++) {
c = 1ll * c * r % mod * inv[t] % mod;
dp[i][j][k] =
(dp[i][j][k] +
1ll * dp[i - t * k][j - t][min(i - t * k - 1, k - 1)] * c) %
mod;
}
}
int ans = dp[n][d][(n + 1) / 2 - 1];
if (n % 2 == 0)
ans = (ans + 1ll * dp[n / 2][d - 1][n / 2 - 1] *
(dp[n / 2][d - 1][n / 2 - 1] + 1) / 2) %
mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void r1(T &x) {
x = 0;
char c(getchar());
int f(1);
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
x *= f;
}
const int maxn = 1000 + 5;
const int maxm = 25;
bool begin;
long long n, d, mod;
long long inv[maxm];
long long f[maxn][maxm][maxn >> 1];
bool end;
long long ksm(long long mi, long long x) {
long long res(1);
while (mi) {
if (mi & 1) res = res * x % mod;
mi >>= 1;
x = x * x % mod;
}
return res;
}
long long C(long long a, long long b) {
if (a < b) return 0;
long long res(a);
for (long long i = a - 1; i > a - b; --i) res = res * i % mod;
return res * inv[b] % mod;
}
signed main() {
long long i, j, k;
r1(n), r1(d), r1(mod);
if (n <= 2) return puts("1"), 0;
inv[10] = ksm(mod - 2, 3628800 % mod);
for (i = 9; i; --i) inv[i] = inv[i + 1] * (i + 1) % mod;
for (i = 0; i <= (n >> 1); ++i) f[1][0][i] = 1;
for (i = 2; i <= n; ++i) {
for (j = 1; j <= min(d, i - 1); ++j) {
for (k = 1; k <= (n / 2); ++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][0][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][d - 1][k - 1] + t - 1, t) % mod) %
mod;
}
}
}
}
long long ans(0);
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);
ans = (ans + mod) % mod;
}
printf("%lld\n", ans);
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 dp[i][j][k] = !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>
const int MAXN = 1000, MAXD = 10;
int n, d, Mod;
int Add(int x, int y) {
x += y;
return x >= Mod ? x - Mod : x;
}
int Sub(int x, int y) {
x -= y;
return x < 0 ? x + Mod : x;
}
int Quick_pow(int x, int po) {
int Ans = 1;
for (; po; po >>= 1, x = 1ll * x * x % Mod)
if (po & 1) Ans = 1ll * Ans * x % Mod;
return Ans;
}
int Inverse(int x) { return Quick_pow(x, Mod - 2); }
int Fac[MAXN + 5], Inv[MAXN + 5];
void Init() {
Fac[0] = 1;
for (int i = 1; i <= MAXN; i++) Fac[i] = 1ll * Fac[i - 1] * i % Mod;
Inv[MAXN] = Inverse(Fac[MAXN]);
for (int i = MAXN; i >= 1; i--) Inv[i - 1] = 1ll * Inv[i] * i % Mod;
}
int C(int n, int m) {
int Ans = 1;
for (int i = n; i >= n - m + 1; i--) Ans = 1ll * Ans * i % Mod;
return 1ll * Ans * Inv[m] % Mod;
}
int dp[MAXN + 5][MAXD + 1][MAXN / 2 + 5];
int dfs(int Sz, int nowd, int MaxSz) {
if (dp[Sz][nowd][MaxSz] != -1) return dp[Sz][nowd][MaxSz];
if (Sz == 1) return dp[Sz][nowd][MaxSz] = nowd == 0;
if (MaxSz == 1) return dp[Sz][nowd][MaxSz] = Sz == nowd + 1;
int Ans = 0;
for (int t = 0; t * MaxSz < Sz && t <= nowd; t++)
Ans = Add(Ans, 1ll * C(dfs(MaxSz, d - 1, MaxSz - 1) + t - 1, t) *
dfs(Sz - t * MaxSz, nowd - t, MaxSz - 1) % Mod);
return dp[Sz][nowd][MaxSz] = Ans;
}
int main() {
scanf("%d %d %d", &n, &d, &Mod);
if (n == 1 || n == 2) return printf("1\n") & 0;
Init();
memset(dp, -1, sizeof(dp));
if (n & 1)
printf("%d\n", dfs(n, d, n / 2));
else
printf("%d\n", Sub(dfs(n, d, n / 2), C(dfs(n / 2, d - 1, n / 2 - 1), 2)));
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.