text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n;
long long k, sum[100009][49], mn[100009][49];
int nxt[100009][49];
pair<long long, long long> ch(long long x) {
pair<long long, long long> ret;
ret.first = 1e9;
for (long long j = 1, i = 0; j <= k; j *= 2, i++) {
if (j & k) {
ret.first = min(ret.first, mn[x][i]);
ret.second += sum[x][i];
x = nxt[x][i];
}
}
return ret;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> nxt[i][0];
for (int i = 0; i < n; i++) {
cin >> sum[i][0];
mn[i][0] = sum[i][0];
}
for (int j = 1; j < 34; j++) {
for (int i = 0; i < n; i++) {
nxt[i][j] = nxt[nxt[i][j - 1]][j - 1];
sum[i][j] = sum[i][j - 1] + sum[nxt[i][j - 1]][j - 1];
mn[i][j] = min(mn[i][j - 1], mn[nxt[i][j - 1]][j - 1]);
}
}
for (int i = 0; i < n; i++) {
pair<long long, long long> p = ch(i);
cout << p.second << " " << p.first << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int MAXN = 100100;
const int MAXP = 35;
int to[MAXP][MAXN];
int mini[MAXP][MAXN];
long long sum[MAXP][MAXN];
int N;
long long K;
int main() {
ios::sync_with_stdio(false);
cin >> N >> K;
for (int i = (0); i < (N); i++) cin >> to[0][i];
for (int i = (0); i < (N); i++) {
cin >> mini[0][i];
sum[0][i] = mini[0][i];
}
int P = 0;
while ((1LL << P) < K) {
P++;
for (int i = (0); i < (N); i++) {
to[P][i] = to[P - 1][to[P - 1][i]];
sum[P][i] = sum[P - 1][i] + sum[P - 1][to[P - 1][i]];
mini[P][i] = min(mini[P - 1][i], mini[P - 1][to[P - 1][i]]);
}
assert(P < MAXP);
}
for (int i = (0); i < (N); i++) {
int c = i;
long long csum = 0;
int cmin = 1e9;
for (int p = (0); p < (P + 1); p++)
if ((K >> p) & 1) {
csum += sum[p][c];
cmin = min(cmin, mini[p][c]);
c = to[p][c];
}
cout << csum << " " << cmin << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[44][100050], g[44][100050], n;
long long h[44][100050], K;
int main() {
scanf("%d%lld", &n, &K);
int i, x, j;
for (i = 1; i <= n; i++) {
scanf("%d", &f[0][i]);
f[0][i]++;
}
for (i = 1; i <= n; i++) {
scanf("%d", &x);
g[0][i] = h[0][i] = x;
}
for (i = 1; (1ll << i) <= K; i++) {
for (j = 1; j <= n; j++) {
f[i][j] = f[i - 1][f[i - 1][j]];
g[i][j] = min(g[i - 1][j], g[i - 1][f[i - 1][j]]);
h[i][j] = h[i - 1][j] + h[i - 1][f[i - 1][j]];
}
}
for (i = 1; i <= n; i++) {
long long t = K;
int x = i;
int ans1 = 1 << 30;
long long ans2 = 0;
for (j = 0; j <= 40; j++) {
if (t & (1ll << j)) {
ans1 = min(ans1, g[j][x]);
ans2 += h[j][x];
x = f[j][x];
}
}
printf("%lld %d\n", ans2, ans1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
const int MAXLOGK = 36;
int N;
long long K;
int F[MAXN][MAXLOGK];
long long W[MAXN][MAXLOGK];
long long sum[MAXN][MAXLOGK];
int cur[MAXN];
long long ans[MAXN][2];
int main() {
ios::sync_with_stdio(0);
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> F[i][0];
for (int i = 0; i < N; i++) {
cin >> W[i][0];
sum[i][0] = W[i][0];
}
for (int j = 1; j < MAXLOGK; j++)
for (int i = 0; i < N; i++) {
F[i][j] = F[F[i][j - 1]][j - 1];
W[i][j] = min(W[i][j - 1], W[F[i][j - 1]][j - 1]);
sum[i][j] = sum[i][j - 1] + sum[F[i][j - 1]][j - 1];
}
for (int i = 0; i < N; i++) cur[i] = i, ans[i][1] = 1 << 30;
for (int j = MAXLOGK - 1; j >= 0; j--)
if ((K & (1LL << j)))
for (int i = 0; i < N; i++) {
ans[i][0] += sum[cur[i]][j];
ans[i][1] = min(ans[i][1], W[cur[i]][j]);
cur[i] = F[cur[i]][j];
}
for (int i = 0; i < N; i++) cout << ans[i][0] << " " << ans[i][1] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
const long long INF = 0x7fffffffffffffff;
template <typename A, typename B>
ostream &operator<<(ostream &s, const pair<A, B> &p) {
return s << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &c) {
s << "[ ";
for (auto it : c) s << it << " ";
s << "]";
return s;
}
template <typename T>
ostream &operator<<(ostream &o, const set<T> &st) {
o << "{";
for (auto it = st.begin(); it != st.end(); it++)
o << (it == st.begin() ? "" : ", ") << *it;
return o << "}";
}
template <typename T1, typename T2>
ostream &operator<<(ostream &o, const map<T1, T2> &make_pair) {
o << "{";
for (auto it = make_pair.begin(); it != make_pair.end(); it++) {
o << (it == make_pair.begin() ? "" : ", ") << it->first << ":"
<< it->second;
}
o << "}";
return o;
}
int n;
long long k;
int mn[100005][40], nxt[100005][40];
long long sum[100005][40];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) scanf("%d", &nxt[i][0]);
for (int i = 0; i < n; i++) scanf("%lld", &sum[i][0]), mn[i][0] = sum[i][0];
for (int i = 1; i < 40; i++) {
for (int j = 0; j < n; j++) {
nxt[j][i] = nxt[nxt[j][i - 1]][i - 1];
sum[j][i] = sum[j][i - 1] + sum[nxt[j][i - 1]][i - 1];
mn[j][i] = min(mn[j][i - 1], mn[nxt[j][i - 1]][i - 1]);
}
}
for (int i = 0; i < n; i++) {
long long kk = k;
int m = 1e9;
long long s = 0;
int cur = i;
for (int j = 39; kk; j--)
if ((1LL << j) <= kk) {
kk -= (1LL << j);
s += sum[cur][j];
m = min(m, mn[cur][j]);
cur = nxt[cur][j];
}
assert(kk == 0);
printf("%lld %d\n", s, m);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long k, fa[100010][35], sum[100010][35], mi[100010][35];
void init() {
for (int j = 1; j < 35; j++)
for (register int i = 1; i <= n; i++) {
fa[i][j] = fa[fa[i][j - 1]][j - 1];
sum[i][j] = sum[i][j - 1] + sum[fa[i][j - 1]][j - 1];
mi[i][j] = min(mi[i][j - 1], mi[fa[i][j - 1]][j - 1]);
}
}
int main() {
cin >> n >> k;
for (register int i = 1; i <= n; i++) cin >> fa[i][0], fa[i][0]++;
for (register int i = 1; i <= n; i++) cin >> sum[i][0], mi[i][0] = sum[i][0];
init();
for (int i = 1; i <= n; i++) {
long long ans1 = 0, ans2 = 1000000000000000000;
for (register int j = 0, x = i; j < 35; j++)
if ((1ll << j) & k)
ans1 += sum[x][j], ans2 = min(ans2, mi[x][j]), x = fa[x][j];
cout << ans1 << " " << ans2 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 1e5 + 7, MOD = 1e9 + 7, INF = 1e10, N = 5000 + 7;
long long n, k, cur, dp[maxN][50], d[maxN][50], sum[maxN][50], f[maxN], g[maxN],
c[50], mini, ss;
vector<long long> q;
bool v[50], help, vis[maxN];
void dfs(int s) {
vis[s] = true;
if (!vis[f[s]]) dfs(f[s]);
q.push_back(s);
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
c[0] = 1;
for (long long i = 1; i <= 34; i++) c[i] = (long long)c[i - 1] * (long long)2;
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> f[i], f[i]++;
for (long long i = 1; i <= n; i++) cin >> g[i];
for (long long i = 1; i <= n; i++) {
if (!vis[i]) help = false, dfs(i);
}
reverse(q.begin(), q.end());
for (long long i = 1; i <= n; i++)
dp[i][0] = f[i], d[i][0] = g[i], sum[i][0] = g[i];
for (long long j = 1; j <= 34; j++) {
for (int i = n - 1; i >= 0; i--)
dp[q[i]][j] = dp[dp[q[i]][j - 1]][j - 1],
sum[q[i]][j] = sum[q[i]][j - 1] + sum[dp[q[i]][j - 1]][j - 1],
d[q[i]][j] = min(d[q[i]][j - 1], d[dp[q[i]][j - 1]][j - 1]);
}
for (int i = 34; i >= 0; i--) {
if (k >= c[i]) v[i] = true, k -= c[i];
}
for (long long i = 1; i <= n; i++) {
mini = INF;
ss = 0;
cur = i;
for (int j = 34; j >= 0; j--) {
if (v[j]) {
ss += sum[cur][j];
mini = min(mini, d[cur][j]);
cur = dp[cur][j];
}
}
cout << ss << " " << mini << "\n";
}
return cout << "\n", 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LIM = 1e+5 + 100;
const int MAX_PW = 34;
int f[LIM];
int w[LIM];
int _min[LIM][MAX_PW];
long long sum[LIM][MAX_PW];
int to[LIM][MAX_PW];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
long long k;
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] = _min[i][0] = w[i];
to[i][0] = f[i];
}
for (int pw = 1; pw < MAX_PW; ++pw) {
for (int i = 0; i < LIM; ++i) {
_min[i][pw] = min(_min[i][pw - 1], _min[to[i][pw - 1]][pw - 1]);
sum[i][pw] = sum[i][pw - 1] + sum[to[i][pw - 1]][pw - 1];
to[i][pw] = to[to[i][pw - 1]][pw - 1];
}
}
for (int i = 0; i < n; ++i) {
int min_ans = 1e+9;
long long sum_ans = 0;
int cur = i;
for (int pw = MAX_PW; pw >= 0; --pw)
if ((k >> pw) & 1) {
min_ans = min(min_ans, _min[cur][pw]);
sum_ans += sum[cur][pw];
cur = to[cur][pw];
}
cout << sum_ans << " " << min_ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
long long dp1[35][maxn], dp2[35][maxn], fa[35][maxn];
long long n, k;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> fa[0][i];
for (int i = 0; i < n; i++) {
cin >> dp1[0][i];
dp2[0][i] = dp1[0][i];
}
for (int i = 1; (1LL << i) <= k; i++) {
for (int j = 0; j < n; j++) {
dp1[i][j] = dp1[i - 1][j] + dp1[i - 1][fa[i - 1][j]];
dp2[i][j] = min(dp2[i - 1][j], dp2[i - 1][fa[i - 1][j]]);
fa[i][j] = fa[i - 1][fa[i - 1][j]];
}
}
for (int i = 0; i < n; i++) {
int u = i;
long long sum = 0, Min = 0x7f7f7f7f7f;
for (int j = 0; j < 35; j++) {
if (k >> j & 1) {
sum += dp1[j][u];
Min = min(Min, dp2[j][u]);
u = fa[j][u];
}
}
cout << sum << " " << Min << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int f[N][42], w[N][42];
long long sum[N][42], k, q, s, m;
int main() {
int n, i, j, x, a;
cin >> n >> k;
for (i = 0; i < n; ++i) cin >> f[i][0];
for (i = 0; i < n; ++i) cin >> w[i][0], sum[i][0] = w[i][0];
for (i = 1; i <= 40; ++i)
for (j = 0; j < n; ++j) {
f[j][i] = f[f[j][i - 1]][i - 1];
w[j][i] = min(w[j][i - 1], w[f[j][i - 1]][i - 1]);
sum[j][i] = sum[j][i - 1] + sum[f[j][i - 1]][i - 1];
}
for (i = 0; i < n; ++i) {
x = i;
s = w[i][0];
m = 0;
for (j = 0; j <= 41; ++j)
if (k & (1LL << j)) {
m += sum[x][j];
s = min(s, (long long)w[x][j]);
x = f[x][j];
}
cout << m << " " << s << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int mmin[100010][50];
long long sum[100010][50];
int son[100010][50];
long long poww[50];
void pre() {
poww[0] = 1;
for (int i = 1; i <= 40; i++) poww[i] = poww[i - 1] << 1;
}
long long n, k;
long long SUM;
int MMIN;
void solve(int h, long long k) {
SUM = 0, MMIN = 0;
MMIN = 2e9;
for (int i = 40; i >= 0; i--)
if (poww[i] <= k)
MMIN = min(MMIN, mmin[h][i]), SUM += sum[h][i], k -= poww[i],
h = son[h][i];
}
long long read() {
long long sum = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch <= '9' && ch >= '0') sum = sum * 10 + ch - '0', ch = getchar();
return sum;
}
int main() {
pre();
n = read(), k = read();
for (int i = 0; i < n; i++) son[i][0] = read();
for (int i = 0; i < n; i++) mmin[i][0] = sum[i][0] = read();
for (int i = 1; i <= 40; i++)
for (int j = 0; j < n; j++) {
son[j][i] = son[son[j][i - 1]][i - 1];
sum[j][i] = sum[son[j][i - 1]][i - 1] + sum[j][i - 1];
mmin[j][i] = min(mmin[j][i - 1], mmin[son[j][i - 1]][i - 1]);
}
for (int i = 0; i < n; i++) {
solve(i, k);
cout << SUM << " " << MMIN << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e15 + 6;
const int MAX_N = 1e5 + 6;
const long long MAX_K = 1e10 + 5;
const int MAX_P = 40;
struct Node {
int to;
long long len;
long long min;
} node[MAX_P][MAX_N];
int binary[MAX_P];
Node MP(int _to, long long _len, long long _min) {
Node tmp;
tmp.to = _to;
tmp.len = _len;
tmp.min = _min;
return tmp;
}
pair<long long, long long> query(int id, long long k) {
memset(binary, 0, sizeof(binary));
int i = 0;
while (k > 0) {
binary[i++] = k % 2;
k /= 2;
}
pair<long long, long long> ret = make_pair(0, INF);
for (int x = MAX_P - 1; x >= 0; x--) {
if (binary[x] == 1) {
ret = make_pair(ret.first + node[x][id].len,
min(ret.second, node[x][id].min));
id = node[x][id].to;
}
}
return ret;
}
int main() {
int n;
long long k;
while (scanf("%d %I64d", &n, &k) != EOF) {
for (int x = 0; n > x; x++) {
scanf("%d", &node[0][x].to);
}
for (int x = 0; n > x; x++) {
scanf("%d", &node[0][x].len);
node[0][x].min = node[0][x].len;
}
for (int i = 1; MAX_P > i; i++) {
for (int j = 0; n > j; j++) {
int tmp = node[i - 1][j].to;
node[i][j] =
MP(node[i - 1][tmp].to, node[i - 1][j].len + node[i - 1][tmp].len,
min(node[i - 1][j].min, node[i - 1][tmp].min));
}
}
for (int x = 0; n > x; x++) {
pair<long long, long long> ret = query(x, k);
printf("%I64d %I64d\n", ret.first, ret.second);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, p[200010][40];
long long k, ans1, ans2, sum[200010][40], Min[200010][40];
void init() {
for (int i = 1; i < 35; i++)
for (int j = 0; j < n; j++)
p[j][i] = p[p[j][i - 1]][i - 1],
Min[j][i] = min(Min[j][i - 1], Min[p[j][i - 1]][i - 1]),
sum[j][i] = sum[j][i - 1] + sum[p[j][i - 1]][i - 1];
}
void query(int x, long long y) {
ans1 = 0;
ans2 = (long long)10e10;
long long k;
int z = x;
for (int i = 34; i >= 0; i--) {
k = 1LL << i;
if (y >= k) {
y -= k;
ans1 += sum[z][i];
ans2 = min(Min[z][i], ans2);
z = p[z][i];
}
}
}
int main() {
cin >> n >> k;
int x;
for (int i = 0; i < n; i++) scanf("%d", &p[i][0]);
for (int i = 0; i < n; i++) scanf("%I64d", &sum[i][0]), Min[i][0] = sum[i][0];
init();
for (int i = 0; i < n; i++) query(i, k), printf("%I64d %I64d\n", ans1, ans2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxpow = 40;
int BiggestPower(long long x) {
int ans = 0;
while (x > 1) {
x = (x >> 1);
++ans;
}
return ans;
}
int main() {
int n;
cin >> n;
long long k;
cin >> k;
int to[n];
int w[n];
for (int i = 0; i < n; ++i) {
cin >> to[i];
}
for (int i = 0; i < n; ++i) {
cin >> w[i];
}
int to_pow[n][maxpow];
long long sum_w[n][maxpow];
int min_w[n][maxpow];
for (int i = 0; i < n; ++i) {
to_pow[i][0] = to[i];
sum_w[i][0] = w[i];
min_w[i][0] = w[i];
}
for (int d = 1; d < maxpow; ++d) {
for (int i = 0; i < n; i++) {
to_pow[i][d] = to_pow[to_pow[i][d - 1]][d - 1];
sum_w[i][d] = sum_w[i][d - 1] + sum_w[to_pow[i][d - 1]][d - 1];
min_w[i][d] = min(min_w[i][d - 1], min_w[to_pow[i][d - 1]][d - 1]);
}
}
int to_pow_ans[n];
long long sum_w_ans[n];
int min_w_ans[n];
for (int i = 0; i < n; i++) {
to_pow_ans[i] = i;
sum_w_ans[i] = 0;
min_w_ans[i] = 1e+9;
}
while (k > 0) {
int d = BiggestPower(k);
long long p = 1;
p = (p << d);
k -= p;
for (int i = 0; i < n; i++) {
sum_w_ans[i] += sum_w[to_pow_ans[i]][d];
min_w_ans[i] = min(min_w_ans[i], min_w[to_pow_ans[i]][d]);
to_pow_ans[i] = to_pow[to_pow_ans[i]][d];
}
}
for (int i = 0; i < n; i++) {
cout << sum_w_ans[i] << " " << min_w_ans[i] << endl;
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long double eps = 1e-7;
const int N = 1e5 + 10;
long long dp[N][36], mn[N][36], sum[N][36];
long long n, k;
pair<long long, long long> mnAndSum(int node) {
long long sum1 = 0, mn1 = 2e18, k1 = k;
for (long long i = 34; i >= 0; i--)
if ((1LL << i) <= k1)
k1 -= (1LL << i), mn1 = min(mn1, mn[node][i]), sum1 += sum[node][i],
node = dp[node][i];
return {sum1, mn1};
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
memset(dp, -1, sizeof dp);
for (long long i = 0; i < n; i++) {
long long next;
cin >> next;
dp[i][0] = next;
}
for (long long i = 0; i < n; i++) {
long long cost;
cin >> cost;
mn[i][0] = cost;
sum[i][0] = cost;
}
for (long long i = 1; i <= 34; i++) {
for (long long j = 0; j < n; j++) {
if (dp[j][i - 1] != -1) {
dp[j][i] = dp[dp[j][i - 1]][i - 1];
mn[j][i] = min(mn[j][i - 1], mn[dp[j][i - 1]][i - 1]);
sum[j][i] = sum[j][i - 1] + sum[dp[j][i - 1]][i - 1];
}
}
}
for (long long i = 0; i < n; i++) {
pair<long long, long long> ans = mnAndSum(i);
cout << ans.first << " " << ans.second << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[100005][40], g[100005][40], h[100005][40];
long long n, m, x, ans1, ans2;
inline long long read() {
long long x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - 48;
return x;
}
int main() {
n = read();
m = read();
for (long long i = 0; i < n; i++) f[i][0] = read();
for (long long i = 0; i < n; i++) g[i][0] = h[i][0] = read();
for (long long i = 1; i <= 35; i++)
for (long long j = 0; 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 (long long i = 0; i < n; i++) {
ans2 = 1e10;
ans1 = 0;
x = i;
for (long long tmp = m, p = 0; tmp; tmp /= 2, p++)
if (tmp % 2) {
ans1 += g[x][p];
ans2 = min(ans2, h[x][p]);
x = f[x][p];
}
printf("%I64d %I64d\n", ans1, ans2);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX1 = 1e5 + 1, MAX2 = 34;
int n, v[MAX1][MAX2], m[MAX1][MAX2], anm, now;
long long k, s[MAX1][MAX2], ans;
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> v[i][0];
for (int i = 0; i < n; ++i) cin >> s[i][0], m[i][0] = s[i][0];
for (int j = 1; j < MAX2; ++j)
for (int i = 0; i < n; ++i) {
v[i][j] = v[v[i][j - 1]][j - 1];
s[i][j] = s[i][j - 1] + s[v[i][j - 1]][j - 1];
m[i][j] = min(m[i][j - 1], m[v[i][j - 1]][j - 1]);
}
for (int i = 0; i < n; ++i) {
ans = 0, anm = 1e9, now = i;
for (int j = MAX2 - 1; j >= 0; --j)
if ((k >> j) & 1) {
ans += s[now][j];
anm = min(anm, m[now][j]);
now = v[now][j];
}
cout << ans << " " << anm << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const int LOGMAXN = 40;
const int INF = 1e9;
int f[MAXN];
int c[MAXN];
long long s[MAXN][LOGMAXN];
long long mn[MAXN][LOGMAXN];
int p[MAXN][LOGMAXN];
int main() {
ios::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 >> f[i];
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++) p[i][1] = f[i], s[i][1] = mn[i][1] = c[i];
for (int i = 2; i <= LOGMAXN; i++)
for (int j = 0; j < n; j++) {
p[j][i] = p[p[j][i - 1]][i - 1];
s[j][i] = s[j][i - 1] + s[p[j][i - 1]][i - 1];
mn[j][i] = min(mn[j][i - 1], mn[p[j][i - 1]][i - 1]);
}
for (int i = 0; i < n; i++) {
int x = i;
long long m1 = INF, s1 = 0LL;
for (int j = LOGMAXN - 1; j >= 0; j--)
if ((1LL << j) & k) {
j++;
s1 += 1LL * s[x][j];
m1 = min(m1, mn[x][j]);
x = p[x][j];
j--;
}
cout << s1 << " " << m1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
long long sm[N][35];
int mn[N][35], go[N][35];
void query(int node, long long k) {
long long sum;
int m, p;
sum = 0;
m = INT_MAX;
for (int i = 0; i < 35; i++) {
if (k & (1ll << i)) {
sum += sm[node][i];
m = min(m, mn[node][i]);
node = go[node][i];
}
}
cout << sum << " " << m << "\n";
}
int main() {
ios::sync_with_stdio(0);
long long n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> go[i][0];
}
for (int i = 0; i < n; i++) {
cin >> sm[i][0];
mn[i][0] = sm[i][0];
}
for (int i = 1; i < 35; i++) {
for (int j = 0; j < n; j++) {
go[j][i] = go[go[j][i - 1]][i - 1];
sm[j][i] = sm[j][i - 1] + sm[go[j][i - 1]][i - 1];
mn[j][i] = min(mn[j][i - 1], mn[go[j][i - 1]][i - 1]);
}
}
for (int i = 0; i < n; i++) {
query(i, k);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int n;
long long k;
int f[MAXN][50];
long long sum[MAXN][50];
int m[MAXN][50];
int main() {
cin >> n >> k;
for (int i = 0; i <= n - 1; i++) {
scanf("%d", &f[i][0]);
}
for (int i = 0; i <= n - 1; i++) {
scanf("%lld", &sum[i][0]);
m[i][0] = sum[i][0];
}
for (int i = 1; i <= log2(k); i++) {
for (int j = 0; j <= n - 1; j++) {
f[j][i] = f[f[j][i - 1]][i - 1];
sum[j][i] = sum[j][i - 1] + sum[f[j][i - 1]][i - 1];
m[j][i] = min(m[j][i - 1], m[f[j][i - 1]][i - 1]);
}
}
for (int point = 0; point <= n - 1; point++) {
int curPos = point;
long long s = 0;
int mn = (1 << 30);
for (int i = 0; (1LL << i) <= k; i++) {
if ((1LL << i) & k) {
s += sum[curPos][i];
mn = min(mn, m[curPos][i]);
curPos = f[curPos][i];
}
}
printf("%lld %d\n", s, mn);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[101000][40], Min[101000][40];
long long sum[101000][40], pow2[40];
int main() {
pow2[0] = 1;
for (int i = 1; i < 40; i++) pow2[i] = pow2[i - 1] << 1;
int n, x;
long long k;
cin >> n >> k;
memset(dp, 0, sizeof(dp));
memset(Min, 0x3f3f3f3f, sizeof(Min));
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
x++;
dp[i][0] = x;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
Min[i][0] = sum[i][0] = x;
}
for (int i = 1; i < 40; i++)
for (int j = 1; j <= n; j++) {
dp[j][i] = dp[dp[j][i - 1]][i - 1];
sum[j][i] = sum[j][i - 1] + sum[dp[j][i - 1]][i - 1];
Min[j][i] = min(Min[j][i - 1], Min[dp[j][i - 1]][i - 1]);
}
for (int i = 1; i <= n; i++) {
long long ans = 0, mint = 0x3f3f3f3f;
for (int p = 40, x = i; p >= 0; p--)
if (pow2[p] & k) {
ans += sum[x][p];
mint = min(mint, (long long)Min[x][p]);
x = dp[x][p];
}
printf("%I64d %I64d\n", ans, mint);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
const int Log = 40;
int f[N][Log];
long long sumw[N][Log];
int minw[N][Log];
int main() {
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 >> sumw[i][0];
minw[i][0] = sumw[i][0];
}
for (int i = 1; i < Log; i++)
for (int j = 0; j < n; j++) {
f[j][i] = f[f[j][i - 1]][i - 1];
sumw[j][i] = sumw[j][i - 1] + sumw[f[j][i - 1]][i - 1];
minw[j][i] = min(minw[j][i - 1], minw[f[j][i - 1]][i - 1]);
}
for (int i = 0; i < n; i++) {
long long res_sumw = 0;
int res_minw = 1e9 + 1;
int v = i;
for (int j = 0; j < Log; j++)
if ((k >> j) & 1) {
res_sumw += sumw[v][j];
res_minw = min(res_minw, minw[v][j]);
v = f[v][j];
}
cout << res_sumw << " " << res_minw << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void test_case() {
long long n, i, j, k;
cin >> n >> k;
vector<long long> p(n);
vector<long long> w(n);
const long long LOGN = log2(k) + 5;
for (i = 0; i < n; i++) {
cin >> p[i];
}
for (i = 0; i < n; i++) {
cin >> w[i];
}
vector<vector<long long>> sparse(n, vector<long long>(LOGN, -1));
vector<vector<pair<long long, long long>>> sparse2(
n, vector<pair<long long, long long>>(LOGN, {0, INT_MAX}));
for (i = 0; i < n; i++) {
sparse[i][0] = p[i];
sparse2[i][0] = {w[i], w[i]};
}
for (j = 1; j < LOGN; j++) {
for (i = 0; i < n; i++) {
assert(sparse[i][j - 1] != -1);
sparse[i][j] = sparse[sparse[i][j - 1]][j - 1];
sparse2[i][j].first =
sparse2[i][j - 1].first + sparse2[sparse[i][j - 1]][j - 1].first;
sparse2[i][j].second = min(sparse2[i][j - 1].second,
sparse2[sparse[i][j - 1]][j - 1].second);
}
}
for (i = 0; i < n; i++) {
long long cnt = k;
long long su = 0;
long long mn = INT_MAX;
long long u = i;
for (j = LOGN - 1; j >= 0; j--) {
if (cnt - (1LL << j) >= 0) {
cnt -= (1LL << j);
su += sparse2[u][j].first;
mn = min(mn, sparse2[u][j].second);
u = sparse[u][j];
}
}
assert(cnt == 0);
cout << su << " " << mn << "\n";
}
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t;
t = 1;
while (t--) {
test_case();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int wnext[34 + 1][(int)1e5 + 1];
int64_t wsum[34 + 1][(int)1e5 + 1];
int64_t wmin[34 + 1][(int)1e5 + 1];
int main() {
int n;
int64_t k;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> wnext[0][i];
wnext[0][i] += 1;
}
for (int i = 1; i <= n; ++i) {
cin >> wsum[0][i];
wmin[0][i] = wsum[0][i];
}
for (int l = 1; l <= 34; ++l) {
for (int i = 1; i <= n; ++i) {
int mid = wnext[l - 1][i];
wnext[l][i] = wnext[l - 1][mid];
wsum[l][i] = wsum[l - 1][i] + wsum[l - 1][mid];
wmin[l][i] = min(wmin[l - 1][i], wmin[l - 1][mid]);
}
}
for (int i = 1; i <= n; ++i) {
int pos = i;
int64_t ws = wsum[0][pos], wm = wmin[0][pos];
pos = wnext[0][pos];
int64_t left = k - 1;
while (left) {
for (int l = 34; l >= 0; --l) {
if ((1ll << l) <= left) {
ws += wsum[l][pos];
wm = min(wm, wmin[l][pos]);
pos = wnext[l][pos];
left -= (1ll << l);
break;
}
}
}
cout << ws << " " << wm << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int anc[100001][41], minn[100001][41];
long long sum[100001][41];
int n;
long long k;
vector<int> need;
long long mypow(int x) {
long long ret = 1;
for (int i = 1; i <= x; i++) ret *= 2;
return ret;
}
int main() {
int i, j;
scanf("%d%I64d", &n, &k);
for (i = 0; i <= n - 1; i++) scanf("%d", &anc[i][0]);
for (i = 0; i <= n - 1; i++) {
scanf("%d", &minn[i][0]);
sum[i][0] = minn[i][0];
}
for (j = 1; j <= 40; j++)
for (i = 0; i <= n - 1; i++) {
anc[i][j] = anc[anc[i][j - 1]][j - 1];
sum[i][j] = sum[i][j - 1] + sum[anc[i][j - 1]][j - 1];
minn[i][j] = min(minn[i][j - 1], minn[anc[i][j - 1]][j - 1]);
}
long long t = k;
int u = 0;
while (mypow(u) <= t) u++;
u--;
while (t != 0) {
need.push_back(u);
t -= mypow(u);
while (u >= 0 && mypow(u) > t) u--;
}
for (i = 0; i <= n - 1; i++) {
long long ans1 = 0, ans2 = 1000000000000000000;
int p = i;
for (j = 0; j < need.size(); j++) {
ans1 += sum[p][need[j]];
ans2 = min(ans2, ((long long)minn[p][need[j]]));
p = anc[p][need[j]];
}
printf("%I64d %I64d\n", ans1, ans2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000 * 1000 * 1000;
const long long inf64 = 1ll * inf * inf;
const int LOG = 50;
const int N = 100005;
int f[LOG][N];
int MN[LOG][N];
int n;
long long SUM[LOG][N];
long long k;
bool solve() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> f[0][i];
}
for (int i = 0; i < n; i++) {
cin >> SUM[0][i];
MN[0][i] = SUM[0][i];
}
for (int i = 1; i < LOG; i++) {
for (int j = 0; j < n; j++) {
f[i][j] = f[i - 1][f[i - 1][j]];
}
}
for (int i = 1; i < LOG; i++) {
for (int j = 0; j < n; j++) {
MN[i][j] = min(MN[i - 1][j], MN[i - 1][f[i - 1][j]]);
SUM[i][j] = SUM[i - 1][j] + SUM[i - 1][f[i - 1][j]];
}
}
for (int i = 0; i < n; i++) {
int v = i;
long long _sum = 0;
int _min = inf;
for (int j = 0; j < LOG; j++) {
if ((1ll << j) & k) {
_sum += SUM[j][v];
_min = min(_min, MN[j][v]);
v = f[j][v];
}
}
cout << _sum << ' ' << _min << '\n';
}
return true;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, k;
const int N = 100 * 1000;
long long int f[N], w[N], sum[N], mini[N], to[N], tsum[N], tmini[N], tto[N];
void sol(long long int p) {
if (p == 1) return;
sol(p / 2);
for (int i = 0; i < n; i++) {
tsum[i] = sum[i];
tmini[i] = mini[i];
tto[i] = to[i];
}
for (int i = 0; i < n; i++) {
sum[i] += tsum[tto[i]];
mini[i] = min(tmini[i], tmini[tto[i]]);
to[i] = tto[tto[i]];
}
if (p % 2 == 1) {
for (int i = 0; i < n; i++) {
sum[i] += w[to[i]];
mini[i] = min(mini[i], w[to[i]]);
to[i] = f[to[i]];
}
}
}
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] = w[i];
mini[i] = w[i];
to[i] = f[i];
}
sol(k);
for (int i = 0; i < n; i++) cout << sum[i] << ' ' << mini[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sum[100004][35];
long long mi[100004][35];
long long pos[100004][35];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, x, t, m, y, z, k;
cin >> n >> k;
vector<long long> dest;
for (int i = 0; i < n; i++) {
cin >> pos[i][0];
}
for (int i = 0; i < n; i++) {
cin >> sum[i][0];
mi[i][0] = sum[i][0];
}
for (int j = 1; j < 35; j++) {
for (int i = 0; i < n; i++) {
sum[i][j] = sum[i][j - 1] + sum[pos[i][j - 1]][j - 1];
mi[i][j] = min(mi[i][j - 1], mi[pos[i][j - 1]][j - 1]);
pos[i][j] = pos[pos[i][j - 1]][j - 1];
}
}
for (int i = 0; i < n; i++) {
long long curr = i;
long long sumz = 0;
long long minz = (1ll << 60) - 1;
for (int j = 0; j < 35; j++) {
if ((k >> j) & 1) {
minz = min(minz, mi[curr][j]);
sumz += sum[curr][j];
curr = pos[curr][j];
}
}
cout << sumz << " " << minz << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long up[100005][40][3];
int main() {
long long(n), (k);
scanf("%lld%lld", &(n), &(k));
;
for (long long i = 0; i < (100005); i++)
for (long long j = 0; j < (40); j++)
for (long long k = 0; k < (3); k++) up[i][j][k] = 0;
vector<pair<long long, long long> > par(n);
for (long long i = 0; i < (n); i++) {
long long(a);
scanf("%lld", &(a));
;
par[i].first = a;
}
for (long long i = 0; i < (n); i++) {
long long(a);
scanf("%lld", &(a));
;
par[i].second = a;
}
for (long long i = 0; i < (n); i++) {
up[i][0][0] = par[i].first;
up[i][0][1] = par[i].second;
up[i][0][2] = par[i].second;
}
for (long long j = 1; j < (40); j++) {
for (long long i = 0; i < (n); i++) {
up[i][j][0] = up[up[i][j - 1][0]][j - 1][0];
up[i][j][1] = min(up[up[i][j - 1][0]][j - 1][1], up[i][j - 1][1]);
up[i][j][2] = up[up[i][j - 1][0]][j - 1][2] + up[i][j - 1][2];
}
}
long long c = 1;
for (long long i = 0; i < (n); i++) {
long long ans1 = 0, ans2 = (long long)1e18;
long long rem = k, t = i;
for (long long j = 39; j >= (0); j--) {
if ((c << j) <= rem) {
ans1 += up[t][j][2];
ans2 = min(ans2, up[t][j][1]);
t = up[t][j][0];
rem -= (c << j);
}
}
printf("%lld %lld\n", ans1, ans2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
long long s[N][40], m[N][40], a1, a2;
int p[N][40];
int n;
bitset<40> k;
int main() {
scanf("%d%I64d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &p[i][0]);
for (int i = 0; i < n; i++) {
scanf("%I64d", &m[i][0]);
s[i][0] = m[i][0];
}
for (int _ = 0; _ < 39; _++)
for (int i = 0; i < n; i++) {
p[i][_ + 1] = p[p[i][_]][_];
s[i][_ + 1] = s[i][_] + s[p[i][_]][_];
m[i][_ + 1] = (m[i][_]) < (m[p[i][_]][_]) ? (m[i][_]) : (m[p[i][_]][_]);
}
for (int i = 0; i < n; i++) {
a2 = 100000000000000;
a1 = 0;
int cur = i;
for (int _ = 0; _ < 40; _++)
if (k[_]) {
a1 += s[cur][_];
a2 = (a2) < (m[cur][_]) ? (a2) : (m[cur][_]);
cur = p[cur][_];
}
printf("%I64d %I64d\n", a1, a2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
const int sizeTree = 1 << 19;
const int INF = 1e9;
long long tMin[sizeTree], tSum[sizeTree];
int n;
long long k;
int f[N], w[N];
vector<int> topSort;
int used[N];
int num[N];
int length[N], numCycle[N], start[N], _end[N];
int cntCycle;
int size;
int p[N][20], mn[N][20];
long long sum[N][20];
long long getMin(int v, int tl, int tr, int l, int r) {
if (l > r) return INF;
if (tl == l && tr == r) return tMin[v];
int tm = (tl + tr) / 2;
return min(getMin(2 * v, tl, tm, l, min(r, tm)),
getMin(2 * v + 1, tm + 1, tr, max(l, tm + 1), r));
}
long long getSum(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r) return tSum[v];
int tm = (tl + tr) / 2;
return getSum(2 * v, tl, tm, l, min(r, tm)) +
getSum(2 * v + 1, tm + 1, tr, max(l, tm + 1), r);
}
void assign(int v, int tl, int tr, int pos, int value) {
if (tl == tr) {
tSum[v] = value;
tMin[v] = value;
return;
}
int tm = (tl + tr) / 2;
if (pos <= tm)
assign(2 * v, tl, tm, pos, value);
else
assign(2 * v + 1, tm + 1, tr, pos, value);
tSum[v] = tSum[2 * v] + tSum[2 * v + 1];
tMin[v] = min(tMin[2 * v], tMin[2 * v + 1]);
}
void dfs(int v) {
used[v] = 1;
if (used[f[v]] == 1) {
int s = v;
start[cntCycle] = v;
length[cntCycle] = 0;
do {
num[s] = size;
assign(1, 0, n - 1, num[s], w[s]);
numCycle[s] = cntCycle;
length[cntCycle]++;
s = f[s];
size++;
} while (s != v);
cntCycle++;
}
if (used[f[v]] == 0) dfs(f[v]);
used[v] = 2;
}
void up(int v) {
used[v] = 1;
if (used[f[v]] == 0 && numCycle[f[v]] == -1) up(f[v]);
p[v][0] = f[v];
sum[v][0] = w[v];
mn[v][0] = w[v];
for (int i = 1; i < 20; ++i) {
if (p[v][i - 1] != -1) {
p[v][i] = p[p[v][i - 1]][i - 1];
mn[v][i] = min(mn[p[v][i - 1]][i - 1], mn[v][i - 1]);
sum[v][i] = sum[p[v][i - 1]][i - 1] + sum[v][i - 1];
} else {
p[v][i] = -1;
mn[v][i] = INF;
sum[v][i] = 0;
}
}
}
pair<long long, long long> get2(int& v, long long& k) {
pair<long long, int> ans(0, INF);
for (int i = 19; i >= 0; --i) {
if ((1 << i) <= k && p[v][i] != -1) {
ans.first += sum[v][i];
ans.second = min(ans.second, mn[v][i]);
v = p[v][i];
k -= (1 << i);
}
}
return ans;
}
pair<long long, long long> get(int i, long long k) {
long long sum = 0;
long long mn = INF;
int p = numCycle[i];
int v = start[p];
int tmpk = k;
if (k > length[p]) {
tmpk = k % length[p];
sum = (k / length[p]) * getSum(1, 0, n - 1, num[v], num[v] + length[p] - 1);
mn = getMin(1, 0, n - 1, num[v], num[v] + length[p] - 1);
}
if (num[i] + tmpk - 1 <= num[v] + length[p] - 1) {
sum += getSum(1, 0, n - 1, num[i], num[i] + tmpk - 1);
mn = min(mn, getMin(1, 0, n - 1, num[i], num[i] + tmpk - 1));
} else {
int l1 = num[i], r1 = num[v] + length[p] - 1;
int l2 = num[v], r2 = num[v] + tmpk - (num[v] + length[p] - num[i]) - 1;
sum += getSum(1, 0, n - 1, l1, r1);
sum += getSum(1, 0, n - 1, l2, r2);
mn = min(mn, getMin(1, 0, n - 1, l1, r1));
mn = min(mn, getMin(1, 0, n - 1, l2, r2));
}
return make_pair(sum, mn);
}
int main() {
memset(numCycle, -1, sizeof(numCycle));
memset(p, -1, sizeof(p));
for (int i = 0; i < 20; ++i) {
for (int j = 0; j < N; ++j) mn[j][i] = INF;
}
scanf("%d%I64d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &f[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &w[i]);
}
size = 0;
for (int i = 0; i < n; ++i) {
if (used[i] == 0) dfs(i);
}
memset(used, 0, sizeof(used));
for (int i = 0; i < n; ++i) {
if (used[i] == 0 && numCycle[i] == -1) up(i);
}
for (int i = 0; i < n; ++i) {
long long sum = 0;
int mn = INF;
if (numCycle[i] == -1) {
long long tmpk = k;
int v = i;
pair<long long, int> a = get2(v, tmpk);
if (tmpk > 0) {
pair<long long, long long> b = get(v, tmpk);
a.first += b.first;
a.second = min((int)b.second, a.second);
}
sum = a.first;
mn = a.second;
} else {
pair<long long, long long> a = get(i, k);
sum = a.first;
mn = a.second;
}
printf("%I64d %d\n", sum, mn);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, n, i, j, k, x, y, z, ans, l, r, mid, m, s;
long long dp[100001][36], dp2[100001][36], dp3[100001][36];
void build() {
for (i = 1; i <= 35; i++)
for (j = 0; j < n; j++) dp[j][i] = dp[dp[j][i - 1]][i - 1];
for (i = 1; i <= 35; i++)
for (j = 0; j < n; j++)
dp2[j][i] = min(dp2[dp[j][i - 1]][i - 1], dp2[j][i - 1]);
for (i = 1; i <= 35; i++)
for (j = 0; j < n; j++)
dp3[j][i] = dp3[dp[j][i - 1]][i - 1] + dp3[j][i - 1];
}
int main() {
ios::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> x;
dp[i][0] = x;
}
for (i = 0; i < n; i++) {
cin >> x;
dp2[i][0] = dp3[i][0] = x;
}
build();
for (i = 0; i < n; i++) {
x = i;
y = 1e18;
z = 0;
for (j = 35; j >= 0; j--)
if (k & (1LL << j)) {
y = min(dp2[x][j], y);
z += dp3[x][j];
x = dp[x][j];
}
cout << z << " " << y << "\n";
}
}
|
#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++) {
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]);
to[j][i] = to[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 long long MAXN = 1e5 + 5;
const long long mod = 1e9 + 7;
long long n, k;
struct node {
long long to, sum, mn;
};
node a[100010], ans[100010];
void solve() {
while (k) {
if (k & 1) {
vector<node> tmp(n);
for (long long i = 0; i <= n - 1; ++i) {
tmp[i] = {a[ans[i].to].to, a[ans[i].to].sum + ans[i].sum,
min(a[ans[i].to].mn, ans[i].mn)};
}
for (long long i = 0; i <= n - 1; ++i) ans[i] = tmp[i];
}
vector<node> tmp(n);
for (long long i = 0; i <= n - 1; ++i) {
tmp[i] = {a[a[i].to].to, a[a[i].to].sum + a[i].sum,
min(a[a[i].to].mn, a[i].mn)};
}
for (long long i = 0; i <= n - 1; ++i) a[i] = tmp[i];
k >>= 1;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = 0; i <= n - 1; ++i) cin >> a[i].to;
for (long long i = 0; i <= n - 1; ++i) {
cin >> a[i].mn;
a[i].sum = a[i].mn;
ans[i] = a[i];
}
k--;
solve();
for (long long i = 0; i <= n - 1; ++i)
cout << ans[i].sum << " " << ans[i].mn << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 123456789987654321;
long long int N, K;
vector<long long int> F, W;
vector<vector<long long int> > par, minw, sumw;
int main() {
scanf("%I64d %I64d", &N, &K);
F = W = vector<long long int>(N);
for (int i = 0; i < N; i++) {
scanf("%I64d", &F[i]);
}
for (int i = 0; i < N; i++) {
scanf("%I64d", &W[i]);
}
par = minw = sumw =
vector<vector<long long int> >(35, vector<long long int>(N, -1));
for (int i = 0; i < 35; i++) {
for (int j = 0; j < N; j++) {
if (i == 0) {
par[i][j] = F[j];
minw[i][j] = W[j];
sumw[i][j] = W[j];
} else {
if (par[i - 1][j] == -1) continue;
par[i][j] = par[i - 1][par[i - 1][j]];
minw[i][j] = min(minw[i - 1][j], minw[i - 1][par[i - 1][j]]);
sumw[i][j] = sumw[i - 1][j] + sumw[i - 1][par[i - 1][j]];
}
}
}
for (int i = 0; i < N; i++) {
int now = i;
long long int sum = 0, mini = inf;
for (int j = 35; j--;) {
if ((((long long int)1 << j) & K)) {
sum += sumw[j][now];
mini = min(mini, minw[j][now]);
now = par[j][now];
}
}
printf("%I64d %I64d\n", sum, mini);
}
}
|
#include <bits/stdc++.h>
const long long INF = 4e18L + 1;
const int IINF = 2e9 + 1;
const int limit = 1048576;
using namespace std;
const long long LOG = 35;
vector<vector<long long> > s_val, m_val, next_vert;
long long s, m;
void solve(long long v, long long len, long long scanned) {
for (long long i = (long long)scanned; i < (long long)LOG; i++) {
if (len & (1ll << i)) {
if (0) cout << "i " << i << " len " << len << " s " << s << endl;
s += s_val[v][i];
m = min(m, m_val[v][i]);
solve(next_vert[v][i], len, i + 1);
return;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
long long n, k;
cin >> n >> k;
s_val.resize(n, vector<long long>(LOG)),
m_val.resize(n, vector<long long>(LOG)),
next_vert.resize(n, vector<long long>(LOG));
for (auto& arr : next_vert) {
cin >> arr[0];
}
for (auto& arr : s_val) {
cin >> arr[0];
}
m_val = s_val;
for (long long i = (long long)1; i < (long long)LOG; i++) {
for (long long v = (long long)0; v < (long long)n; v++) {
int w = next_vert[v][i - 1];
next_vert[v][i] = next_vert[w][i - 1];
s_val[v][i] = s_val[v][i - 1] + s_val[w][i - 1];
m_val[v][i] = min(m_val[v][i - 1], m_val[w][i - 1]);
if (0)
cout << "v " << v << " i " << i << " s_val " << s_val[v][i] << endl;
}
}
for (long long v = (long long)0; v < (long long)n; v++) {
s = 0, m = INF;
solve(v, k, 0);
cout << s << " " << m << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const int LOGMAX = 36;
int N, log_K;
long long K;
int f[MAX], w[MAX];
int P[LOGMAX][MAX], M[LOGMAX][MAX];
long long S[LOGMAX][MAX];
long long sum_query(int k) {
long long sum = 0;
for (int i = int(log_K); i >= int(0); i--) {
if (K & (1LL << i)) {
sum += S[i][k];
k = P[i][k];
}
}
return sum;
}
int min_query(int k) {
int minn = (int)1e9;
for (int i = int(log_K); i >= int(0); i--) {
if (K & (1LL << i)) {
minn = min(minn, M[i][k]);
k = P[i][k];
}
}
return minn;
}
int main() {
scanf("%d %lld", &N, &K);
for (int i = int(0); i < int(N); i++) {
scanf("%d", f + i);
}
for (int i = int(0); i < int(N); i++) {
scanf("%d", w + i);
}
log_K = 63 - __builtin_clzll(K);
memset(M, 0x7F, sizeof M);
memset(P, -1, sizeof P);
for (int i = int(0); i < int(N); i++) {
P[0][i] = f[i];
M[0][i] = w[i];
S[0][i] = w[i];
}
for (int i = int(1); i < int(LOGMAX); i++) {
for (int j = int(0); j < int(N); j++) {
if (P[i - 1][j] != -1) {
P[i][j] = P[i - 1][P[i - 1][j]];
M[i][j] = min(M[i - 1][j], M[i - 1][P[i - 1][j]]);
S[i][j] = S[i - 1][j] + S[i - 1][P[i - 1][j]];
}
}
}
for (int i = int(0); i < int(N); i++) {
printf("%lld %d\n", sum_query(i), min_query(i));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m[100005][34], go[100005][34];
long long sum[100005][34];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
long long n, k;
cin >> n >> k;
vector<int> next(n), w(n);
for (auto &i : next) cin >> i;
for (auto &i : w) cin >> i;
for (int u = 0; u < n; ++u) {
m[u][0] = w[u];
sum[u][0] = w[u];
go[u][0] = next[u];
}
for (int i = 1; i < 34; ++i)
for (int u = 0; u < n; ++u) {
int v = go[u][i - 1];
m[u][i] = min(m[u][i - 1], m[v][i - 1]);
sum[u][i] = sum[u][i - 1] + sum[v][i - 1];
go[u][i] = go[v][i - 1];
}
for (int i = 0; i < n; ++i) {
long long s = 0, tk = k;
int mn = numeric_limits<int>::max(), u = i;
for (int j = 33; j >= 0; --j)
if (tk - (1LL << j) >= 0) {
tk -= 1LL << j;
s += sum[u][j];
mn = min(mn, m[u][j]);
u = go[u][j];
}
cout << s << " " << mn << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, f[100010], w[100010], c;
long long k;
int dp1[36][200010];
long long dp2[36][200010];
int dp3[36][200010];
void init() {
for (int i = 1; i < 35; i++) {
for (int j = 0; j < n; j++) {
dp1[i][j] = dp1[i - 1][dp1[i - 1][j]];
dp2[i][j] = dp2[i - 1][j] + dp2[i - 1][dp1[i - 1][j]];
dp3[i][j] = min(dp3[i - 1][j], dp3[i - 1][dp1[i - 1][j]]);
}
}
}
bool v[200010];
long long W[200010];
long long M[200010];
long long binaryLift(int cur, long long& mini) {
long long logi = 0;
long long K = k;
for (; (1LL << logi) <= K; logi++)
;
logi--;
long long tw = 0LL;
for (long long i = logi; i >= 0; i--) {
if (K - (1LL << i) >= 0LL) {
K -= (1LL << i);
tw += dp2[i][cur];
mini = min(mini, (long long)dp3[i][cur]);
cur = dp1[i][cur];
}
}
return tw;
}
int main() {
scanf("%d %I64d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &f[i]);
for (int i = 0; i < n; i++) scanf("%d", &w[i]);
for (int i = 0; i < n; i++) {
int next = f[i];
dp1[0][i] = next;
dp2[0][i] = w[i];
dp3[0][i] = w[i];
}
init();
for (int i = 0; i < n; i++) {
M[i] = w[i];
W[i] = binaryLift(i, M[i]);
}
for (int i = 0; i < n; i++) printf("%I64d %I64d\n", W[i], M[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005 + 10;
long long fa[N][36];
long long son[N][36];
long long minn[N][36];
long long n, k;
void sovle(long long u) {
long long ans = 0, Min = 1e18;
long long K = k;
for (long long i = 35; i >= 0; i--) {
if ((1ll << i) <= K) {
ans += fa[u][i];
Min = min(Min, minn[u][i]);
u = son[u][i];
K -= (1ll << i);
}
}
printf("%lld %lld\n", ans, Min);
}
signed main() {
scanf("%lld%lld", &n, &k);
for (long long i = 0; i < n; i++) scanf("%lld", &son[i][0]);
for (long long i = 0; i < n; i++) {
scanf("%lld", &fa[i][0]);
minn[i][0] = fa[i][0];
}
for (long long j = 1; j <= 35; j++) {
for (long long i = 0; i < n; i++) {
son[i][j] = son[son[i][j - 1]][j - 1];
fa[i][j] = fa[i][j - 1] + fa[son[i][j - 1]][j - 1];
minn[i][j] = min(minn[i][j - 1], minn[son[i][j - 1]][j - 1]);
}
}
for (long long i = 0; i < n; i++) {
sovle(i);
}
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[_];
long long ret_sum[_], ret_minw[_];
bool vis[_];
struct Status {
int to[LOG];
long long sumw[LOG];
int minw[LOG];
} S[_];
void dfs(int u) {
if (vis[u]) return;
vis[u] = true;
S[u].to[0] = e[u];
S[u].sumw[0] = w[u];
S[u].minw[0] = w[u];
dfs(e[u]);
}
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) dfs(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) {
ret_minw[i] = inf;
long long d = k;
int u = i;
for (long long j = (long long)(Log)-1; j >= 0; --j)
if ((d >> j) & 1) {
ret_sum[i] += S[u].sumw[j];
cmin(ret_minw[i], S[u].minw[j]);
d -= 1LL << j;
u = S[u].to[j];
}
}
for (long long i = 0; i < (long long)(n); ++i) WR(ret_sum[i], ret_minw[i]);
}
void generate_test_case() { exit(0); }
int main() {
_main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
const long long inf64 = 1e18;
const long long MOD = inf + 7;
const long long N = 1e5 + 5;
const long long LG = 35;
long long mn[N][LG];
long long sum[N][LG];
long long par[N][LG];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (long long i = 0; i < N; i++)
for (long long j = 0; j < LG; j++) mn[i][j] = LLONG_MAX;
long long n, k;
cin >> n >> k;
long long p[n], w[n];
for (long long i = 0; i < n; i++) {
cin >> p[i];
}
for (long long i = 0; i < n; i++) {
cin >> w[i];
mn[i][0] = w[i];
sum[i][0] = w[i];
par[i][0] = p[i];
}
for (long long i = 1; i < LG; i++) {
for (long long j = 0; j < n; j++) {
par[j][i] = par[par[j][i - 1]][i - 1];
sum[j][i] += sum[par[j][i - 1]][i - 1] + sum[j][i - 1];
mn[j][i] = min(mn[par[j][i - 1]][i - 1], mn[j][i - 1]);
}
}
for (long long i = 0; i < n; i++) {
long long res = 0, mini = LLONG_MAX;
long long node = i;
for (long long j = 0; j < LG; j++) {
if (k >> j & 1) {
res += sum[node][j];
mini = min(mini, mn[node][j]);
node = par[node][j];
}
}
cout << res << " " << mini << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const ll MOD = 998244353;
const int INF = (ll)1e9 + 7;
const ll INFLL = (ll)1e18;
template <class t>
using vvector = vector<vector<t>>;
template <class t>
using vvvector = vector<vector<vector<t>>>;
template <class t>
using priority_queuer = priority_queue<t, vector<t>, greater<t>>;
template <class t, class u>
bool chmax(t &a, u b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class t, class u>
bool chmin(t &a, u b) {
if (a > b) {
a = b;
return true;
}
return false;
}
namespace templates {
ll modpow(ll x, ll b, ll mod = MOD) {
ll res = 1;
while (b) {
if (b & 1) res = res * x % mod;
x = x * x % mod;
b >>= 1;
}
return res;
}
ll modinv(ll x) { return modpow(x, MOD - 2); }
bool was_output = false;
template <class t>
void output(t a) {
if (was_output) cout << " ";
cout << a;
was_output = true;
}
void outendl() {
was_output = false;
cout << endl;
}
ll in() {
ll res;
cin >> res;
return res;
}
template <class t>
istream &operator>>(istream &is, vector<t> &x) {
for (auto &i : x) is >> i;
return is;
}
template <class t, class u>
istream &operator>>(istream &is, pair<t, u> &x) {
is >> x.first >> x.second;
return is;
}
template <class t>
t in() {
t res;
cin >> res;
return res;
}
template <class t>
void out(t x) {
cout << x;
}
template <class t>
vector<t> sorted(
vector<t> line,
function<bool(t, t)> comp = [](t a, t b) { return a < b; }) {
sort(line.begin(), line.end(), comp);
return line;
}
template <class t>
vector<t> reversed(vector<t> line) {
reverse(line.begin(), line.end());
return line;
}
} // namespace templates
using namespace templates;
void func() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n = in();
ll k = in();
vector<int> nexts(n);
vector<ll> weights(n);
for (auto &i : (nexts)) i = in();
for (auto &i : (weights)) i = in();
vvector<pll> mins_dp(n, vector<pll>(40, {-1, -1}));
vvector<pll> sums_dp(n, vector<pll>(40, {-1, -1}));
function<pll(int p, int k)> mins =
(function<pll(int p, int k)>)[&](int p, int k)->pll {
if (k == 0) {
return {nexts[p], weights[p]};
}
pll &it = mins_dp[p][k];
if (it.first != -1) return it;
pll res1 = mins(p, k - 1);
pll res2 = mins(res1.first, k - 1);
it.first = res2.first;
it.second = min(res1.second, res2.second);
return it;
};
function<pll(int p, int k)> sums =
(function<pll(int p, int k)>)[&](int p, int k)->pll {
if (k == 0) {
return {nexts[p], weights[p]};
}
pll &it = sums_dp[p][k];
if (it.first != -1) return it;
pll res1 = sums(p, k - 1);
pll res2 = sums(res1.first, k - 1);
it.first = res2.first;
it.second = res1.second + res2.second;
return it;
};
function<ll(int p)> culc_mins = (function<ll(int p)>)[&](int p)->ll {
ll res = INFLL;
for (int i = (40) * (strlen("") != 0); i < (int)(strlen("") ?: (40)); ++i) {
if ((1ll << (i)) & k) {
pll current = mins(p, i);
chmin(res, current.second);
p = current.first;
}
}
return res;
};
function<ll(int p)> culc_sums = (function<ll(int p)>)[&](int p)->ll {
ll res = 0;
for (int i = (39) * (strlen("") != 0); i < (int)(strlen("") ?: (39)); ++i) {
if ((1ll << (i)) & k) {
pll current = sums(p, i);
res += current.second;
p = current.first;
}
}
return res;
};
for (int i = (n) * (strlen("") != 0); i < (int)(strlen("") ?: (n)); ++i) {
cout << culc_sums(i) << " " << culc_mins(i) << "\n";
}
}
int main() {
func();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10, MAXL = 40;
const long long INF = 4e18;
int n;
long long m;
int maxl;
int pai[MAXN][MAXL];
long long lessy[MAXN][MAXL];
long long sum[MAXN][MAXL];
void build() {
maxl = log2(m) + 1;
for (int l = 1; l <= maxl; l++) {
for (int i = 0; i < n; i++) {
pai[i][l] = pai[pai[i][l - 1]][l - 1];
sum[i][l] = sum[pai[i][l - 1]][l - 1] + sum[i][l - 1];
lessy[i][l] = min(lessy[pai[i][l - 1]][l - 1], lessy[i][l - 1]);
}
}
}
int main() {
scanf("%d %lld", &n, &m);
for (int i = 0, a; i < n; i++) scanf("%d", &a), pai[i][0] = a;
long long b;
for (int i = 0, b; i < n; i++) scanf("%lld", &b), lessy[i][0] = sum[i][0] = b;
build();
for (int i = 0; i < n; i++) {
long long jump = m;
int cur = i;
long long lessy0 = INF, sum0 = 0;
for (int l = maxl; jump && l >= 0; l--) {
if ((1LL << l) <= jump) {
lessy0 = min(lessy0, lessy[cur][l]);
sum0 += sum[cur][l];
cur = pai[cur][l];
jump -= (1LL << l);
}
}
printf("%lld %lld\n", sum0, lessy0);
}
}
|
#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() {
ios::sync_with_stdio("false");
cin >> 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);
cout << si << " " << mi << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch = getchar();
int x = 0;
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x;
}
const int maxn = 1e5 + 5, maxl = 40, inf = 1e9;
int N, x, mn, f[maxn][maxl], v[maxn][maxl];
long long w[maxn][maxl], K, sm;
int main() {
scanf("%d%lld", &N, &K);
for (int i = 1; i <= N; ++i) f[i][0] = read() + 1;
for (int i = 1; i <= N; ++i) w[i][0] = v[i][0] = read();
for (int i = 1; i < maxl; ++i)
for (int j = 1; j <= N; ++j) {
f[j][i] = f[f[j][i - 1]][i - 1];
w[j][i] = w[f[j][i - 1]][i - 1] + w[j][i - 1];
v[j][i] = min(v[f[j][i - 1]][i - 1], v[j][i - 1]);
}
for (int i = 1; i <= N; ++i) {
x = i, mn = inf, sm = 0;
for (int j = 0; j < maxl; ++j)
if (K & (1LL << j)) {
sm += w[x][j];
mn = min(mn, v[x][j]);
x = f[x][j];
}
printf("%lld %d\n", sm, mn);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int par[40][100010];
long long cst[100010];
long long mn[40][100010];
long long sum[40][100010];
int main() {
int n;
long long m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> par[0][i];
for (int i = 0; i < n; i++) cin >> cst[i];
for (int i = 0; i < n; i++) sum[0][i] = mn[0][i] = cst[i];
for (int i = 1; i < 40; i++) {
for (int j = 0; j < n; j++) {
par[i][j] = par[i - 1][par[i - 1][j]];
mn[i][j] = min(mn[i - 1][j], mn[i - 1][par[i - 1][j]]);
sum[i][j] = sum[i - 1][j] + sum[i - 1][par[i - 1][j]];
}
}
for (int i = 0; i < n; i++) {
long long t = m, now = i, r = 0;
long long ans1 = 100000000, ans2 = 0;
while (t > 0) {
if (t % 2) {
ans2 += sum[r][now];
ans1 = min(ans1, mn[r][now]);
now = par[r][now];
}
r++;
t /= 2;
}
cout << ans2 << " " << ans1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int OO = (int)2e9;
const double eps = 1e-9;
int daysInMonths[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int di[] = {-1, 0, 1, 0};
int dj[] = {0, 1, 0, -1};
long long k, j, w, dp[100002][35], sum[100002][35], mn[100002][35];
int out[100002], weight[100002], n;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
scanf("%d%I64d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &out[i]);
dp[i][0] = out[i];
}
for (int i = 0; i < n; i++) {
scanf("%d", &weight[i]);
sum[i][0] = weight[i];
mn[i][0] = weight[i];
}
for (int k = 1; k <= 34; k++) {
for (int u = 0; u < n; u++) {
dp[u][k] = dp[dp[u][k - 1]][k - 1];
sum[u][k] = sum[u][k - 1] + sum[dp[u][k - 1]][k - 1];
mn[u][k] = min(mn[u][k - 1], mn[dp[u][k - 1]][k - 1]);
}
}
for (int i = 0; i < n; i++) {
long long s = 0;
long long m = 1e18;
long long rem = k;
int u = i;
for (int k = 34; k >= 0; k--) {
if (rem >= (1LL << k)) {
s += sum[u][k];
m = min(m, mn[u][k]);
rem -= (1LL << k);
u = dp[u][k];
}
}
printf("%I64d %d\n", s, m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
long long k;
int w[N], f[N], cur[N], anw[N], tw[N], tf[N];
long long s[N], ans[N], ts[N];
int main() {
scanf("%d%I64d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", f + i), cur[i] = i;
for (int i = 0; i < n; i++) {
scanf("%d", w + i);
anw[i] = 1e9 + 7;
s[i] = w[i];
ans[i] = 0;
}
for (long long mask = 1; mask <= k; mask <<= 1) {
if (mask & k) {
for (int i = 0; i < n; i++) {
ans[i] += s[cur[i]];
anw[i] = min(anw[i], w[cur[i]]);
cur[i] = f[cur[i]];
}
}
for (int i = 0; i < n; i++) {
tw[i] = min(w[i], w[f[i]]);
ts[i] = s[i] + s[f[i]];
tf[i] = f[f[i]];
}
for (int i = 0; i < n; i++) {
w[i] = tw[i];
s[i] = ts[i];
f[i] = tf[i];
}
}
for (int i = 0; i < n; i++) {
printf("%I64d %d\n", ans[i], anw[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 100005;
int n, m, x, y, f[M], we[M];
long long k, dp[40][M], w[40][M], mn[40][M];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> f[i];
dp[0][i] = f[i];
}
for (int i = 0; i < n; i++) {
cin >> we[i];
w[0][i] = we[i];
mn[0][i] = we[i];
}
for (int k = 1; k < 40; k++)
for (int u = 0; u < n; u++) {
dp[k][u] = dp[k - 1][dp[k - 1][u]];
w[k][u] = w[k - 1][u] + w[k - 1][dp[k - 1][u]];
mn[k][u] = min(mn[k - 1][u], mn[k - 1][dp[k - 1][u]]);
}
for (int i = 0; i < n; i++) {
long long sum = 0, mnn = 2e18, t = i;
for (int j = 0; j < 40; j++) {
if (k & (1LL << j)) {
sum += w[j][t];
mnn = min(mnn, mn[j][t]);
t = dp[j][t];
}
}
cout << sum << " " << mnn << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e18 + 7, mod = 1e9 + 7;
const long long N = 1e5 + 5;
struct node {
long long end, mx, tol;
} sparse[100005][34];
long long n, k, nxt[N], dist_loop[N], loop[N], lst[N], w[N];
bool vis[N];
signed main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> nxt[i];
++nxt[i];
}
for (long long i = 1; i <= n; i++) cin >> w[i];
for (long long i = 1; i <= n; i++) {
sparse[i][0].end = nxt[i];
sparse[i][0].mx = w[i];
sparse[i][0].tol = w[i];
}
for (long long i = 1; i <= 33; i++) {
for (long long j = 1; j <= n; j++) {
sparse[j][i].end = sparse[sparse[j][i - 1].end][i - 1].end;
sparse[j][i].mx =
min(sparse[j][i - 1].mx, sparse[sparse[j][i - 1].end][i - 1].mx);
sparse[j][i].tol =
sparse[j][i - 1].tol + sparse[sparse[j][i - 1].end][i - 1].tol;
}
}
for (long long i = 1; i <= n; i++) {
node ans;
ans.end = i;
ans.tol = 0;
ans.mx = oo;
for (long long j = 33; j >= 0; j--) {
if (k & (1LL << j)) {
ans.mx = min(ans.mx, sparse[ans.end][j].mx);
ans.tol += sparse[ans.end][j].tol;
ans.end = sparse[ans.end][j].end;
}
}
cout << ans.tol << " " << ans.mx << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (long long)(ch - '0');
ch = getchar();
}
return x * f;
}
long long f[100009][37], minn[100009][37], sum[100009][37];
long long n, m, k, cnt, ans;
int main() {
n = read(), k = read();
for (int i = 0; i < n; i++) f[i][0] = read();
for (int i = 0; i < n; i++) minn[i][0] = read(), sum[i][0] = minn[i][0];
for (int j = 1; j <= 36; j++)
for (int i = 0; i < n; i++) {
f[i][j] = f[f[i][j - 1]][j - 1];
sum[i][j] = sum[f[i][j - 1]][j - 1] + sum[i][j - 1];
minn[i][j] = min(minn[i][j - 1], minn[f[i][j - 1]][j - 1]);
}
for (int i = 0; i < n; i++) {
long long now = i, mn = 0x3f3f3f3f;
ans = 0;
for (int j = 36; j >= 0; j--) {
if ((1LL << j) & k) {
ans += sum[now][j];
mn = min(mn, minn[now][j]);
now = f[now][j];
}
}
printf(i == n - 1 ? "%lld %lld" : "%lld %lld\n", ans, mn);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long k;
long long f[34][100001];
int g[34][100001];
int h[34][100001];
int main() {
scanf("%d%lld", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &g[0][i]), g[0][i]++;
for (int i = 1; i <= n; i++) scanf("%d", &h[0][i]), f[0][i] = h[0][i];
for (int i = 1; i <= 33; i++)
for (int j = 1; j <= n; j++) {
f[i][j] = f[i - 1][j] + f[i - 1][g[i - 1][j]];
g[i][j] = g[i - 1][g[i - 1][j]];
h[i][j] = min(h[i - 1][j], h[i - 1][g[i - 1][j]]);
}
for (int i = 1; i <= n; i++) {
int now = i;
long long ans1 = 0;
int ans2 = 1000000001;
for (int j = 33; j >= 0; j--)
if (k >> j & 1)
ans1 += f[j][now], ans2 = min(ans2, h[j][now]), now = g[j][now];
printf("%lld %d\n", ans1, ans2);
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int init() {
int now = 0, ju = 1;
char c;
bool flag = false;
while (1) {
c = getchar();
if (c == '-')
ju = -1;
else if (c >= '0' && c <= '9') {
now = now * 10 + c - '0';
flag = true;
} else if (flag)
return now * ju;
}
}
inline long long llinit() {
long long now = 0, ju = 1;
char c;
bool flag = false;
while (1) {
c = getchar();
if (c == '-')
ju = -1;
else if (c >= '0' && c <= '9') {
now = now * 10 + c - '0';
flag = true;
} else if (flag)
return now * ju;
}
}
long long k, sum[100005][42], mn[100005][42];
int n, f[100005][42];
void calc() {
for (int j = 1; j <= 40; j++) {
for (int i = 0; i < n; i++) {
f[i][j] = f[f[i][j - 1]][j - 1];
sum[i][j] = sum[f[i][j - 1]][j - 1] + sum[i][j - 1];
mn[i][j] = min(mn[f[i][j - 1]][j - 1], mn[i][j - 1]);
}
}
}
pair<long long, long long> query(int now) {
long long ret = 0x7f7f7f7f;
long long res = 0;
for (int i = 40; i >= 0; i--) {
if ((1LL << i) & k) {
ret = min(ret, mn[now][i]);
res = res + sum[now][i];
now = f[now][i];
}
}
return make_pair(res, ret);
}
int main() {
n = init();
k = llinit();
for (int i = 0; i < n; i++) {
f[i][0] = init();
}
for (int i = 0; i < n; i++) {
sum[i][0] = mn[i][0] = llinit();
}
calc();
pair<long long, long long> tmp;
for (int i = 0; i < n; i++) {
tmp = query(i);
printf("%I64d %I64d\n", tmp.first, tmp.second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long data, Min, N;
} fat[100010][45];
long long head[100010], ver[200010], edge[200010], Next[200010], tot = 0;
void add(long long x, long long y, long long z) {
ver[++tot] = y;
edge[tot] = z;
Next[tot] = head[x];
head[x] = tot;
}
long long t;
void bfs(long long h) {
queue<long long> q;
q.push(h);
while (!q.empty()) {
long long x = q.front();
q.pop();
if (fat[x][0].data != -1) continue;
for (long long i = head[x]; i; i = Next[i]) {
long long y = ver[i];
fat[x][0].data = y;
fat[x][0].Min = fat[x][0].N = edge[i];
q.push(y);
}
}
}
int main() {
long long n, m, i, j, k;
scanf("%lld%lld", &n, &m);
long long a[100010];
t = (long long)(log(m) / log(2)) + 1;
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
for (int i = 0; i < n; i++) {
scanf("%lld", &j);
add(i, a[i], j);
}
for (int i = 0; i < n; i++) fat[i][0].data = -1;
for (int i = 0; i < n; i++)
if (fat[i][0].data == -1) bfs(i);
for (int j = 1; j <= t; j++)
for (int i = 0; i < n; i++) {
fat[i][j].data = fat[fat[i][j - 1].data][j - 1].data;
fat[i][j].Min =
min(fat[fat[i][j - 1].data][j - 1].Min, fat[i][j - 1].Min);
fat[i][j].N = fat[i][j - 1].N + fat[fat[i][j - 1].data][j - 1].N;
}
for (int i = 0; i < n; i++) {
long long temp = m, hh = i, ans = -1, h = 0;
for (int j = t; j >= 0; j--) {
if (pow(2, j) <= temp) {
temp -= pow(2, j);
h += fat[hh][j].N;
if (ans != -1)
ans = min(ans, fat[hh][j].Min);
else
ans = fat[hh][j].Min;
hh = fat[hh][j].data;
}
}
printf("%lld %lld\n", h, ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int inf = 1e9;
const long long mod = 1000000007;
long long f[maxn], w[maxn];
long long a1[maxn], a2[maxn];
int cur[maxn];
long long sm[maxn][40], mi[maxn][40], nxt[maxn][40];
int main() {
long long n, k;
scanf("%I64d%I64d", &n, &k);
for (int i = 0; i < n; i++) scanf("%I64d", &f[i]);
for (int i = 0; i < n; i++) scanf("%I64d", &w[i]);
for (int i = 0; i < n; i++) {
sm[i][0] = w[i];
mi[i][0] = w[i];
nxt[i][0] = f[i];
cur[i] = i;
}
memset(a1, 0, sizeof(a1));
memset(a2, 0x3f, sizeof(a2));
for (long long _ = 1;; _++) {
for (int i = 0; i < n; i++) {
if (k & 1) {
a1[i] += sm[cur[i]][_ - 1];
a2[i] = min(a2[i], mi[cur[i]][_ - 1]);
cur[i] = nxt[cur[i]][_ - 1];
}
int la = nxt[i][_ - 1];
sm[i][_] = sm[i][_ - 1] + sm[la][_ - 1];
mi[i][_] = min(mi[i][_ - 1], mi[la][_ - 1]);
nxt[i][_] = nxt[la][_ - 1];
}
k >>= (long long)1;
if (!k) break;
}
for (int i = 0; i < n; i++) cout << a1[i] << ' ' << a2[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxk = 36;
long long n, k, i, j, f, w, curk, s, m, curi, maxik;
pair<int, pair<long long, long long> > otv[100010][maxk], cur1, cur2;
long long inf = 1000000007;
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
int main() {
scanf("%I64d %I64d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%I64d", &f);
otv[i][0].first = f;
}
for (i = 0; i < n; i++) {
scanf("%I64d", &w);
otv[i][0].second = make_pair((w), (w));
}
maxik = 0;
curk = k;
while (curk > 0) {
maxik++;
curk = curk >> 1;
}
maxik = maxik + 1;
for (j = 1; j < maxik; j++)
for (i = 0; i < n; i++) {
cur1 = otv[i][j - 1];
cur2 = otv[cur1.first][j - 1];
otv[i][j].second.first = cur1.second.first + cur2.second.first;
otv[i][j].second.second = min(cur1.second.second, cur2.second.second);
otv[i][j].first = cur2.first;
}
for (i = 0; i < n; i++) {
curi = i;
curk = k;
s = 0;
m = inf;
for (j = maxik - 1; j >= 0; j--) {
if (curk <= 0) break;
if (curk < (1ll << j)) continue;
s += otv[curi][j].second.first;
m = min(m, otv[curi][j].second.second);
curi = otv[curi][j].first;
curk = (curk - (1ll << j));
}
printf("%I64d %I64d\n", s, m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, dp[N][45];
long long minn[N][45], sum[N][45];
long long k;
void solve(int xx) {
int x = xx;
long long ret = 0;
for (int i = 0; i <= 40; ++i) {
if ((k >> i) & 1) {
ret += sum[x][i];
x = dp[x][i];
}
}
printf("%lld ", ret);
ret = 1000000000000;
x = xx;
for (int i = 0; i <= 40; ++i) {
if ((k >> i) & 1) {
ret = min(ret, minn[x][i]);
x = dp[x][i];
}
}
printf("%lld\n", ret);
}
int main() {
scanf("%d%lld", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &dp[i][0]);
++dp[i][0];
}
for (int i = 1; i <= n; ++i) {
scanf("%lld", &sum[i][0]);
minn[i][0] = sum[i][0];
}
for (int j = 1; j <= 40; ++j) {
for (int i = 1; i <= n; ++i) {
dp[i][j] = dp[dp[i][j - 1]][j - 1];
}
}
for (int j = 1; j <= 40; ++j) {
for (int i = 1; i <= n; ++i) {
sum[i][j] = sum[i][j - 1] + sum[dp[i][j - 1]][j - 1];
}
}
for (int j = 1; j <= 40; ++j) {
for (int i = 1; i <= n; ++i) {
minn[i][j] = min(minn[i][j - 1], minn[dp[i][j - 1]][j - 1]);
}
}
for (int i = 1; i <= n; ++i) solve(i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
vector<vector<long long> > hopp(40, vector<long long>(n)),
wsum(40, vector<long long>(n)), minw(40, vector<long long>(n));
for (auto &x : hopp[0]) cin >> x;
for (auto &x : wsum[0]) cin >> x;
for (int i = (0); i < int(n); ++i) minw[0][i] = wsum[0][i];
for (int i = (1); i < int(40); ++i)
for (int j = (0); j < int(n); ++j) hopp[i][j] = hopp[i - 1][hopp[i - 1][j]];
for (int i = (1); i < int(40); ++i)
for (int j = (0); j < int(n); ++j)
wsum[i][j] = wsum[i - 1][j] + wsum[i - 1][hopp[i - 1][j]];
for (int i = (1); i < int(40); ++i)
for (int j = (0); j < int(n); ++j)
minw[i][j] = min(minw[i - 1][j], minw[i - 1][hopp[i - 1][j]]);
auto sum = [&](int v, long long l) {
long long res = 0;
int i = 0;
while (l) {
if (l & 1) {
res += wsum[i][v];
v = hopp[i][v];
}
l /= 2;
i++;
}
return res;
};
auto mn = [&](int v, long long l) {
long long res = 1e9;
int i = 0;
while (l) {
if (l & 1) {
res = min(res, minw[i][v]);
v = hopp[i][v];
}
l /= 2;
i++;
}
return res;
};
for (int i = (0); i < int(n); ++i)
cout << sum(i, k) << ' ' << mn(i, k) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, k;
cin >> n >> k;
long long a[n], b[n];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> b[i];
pair<pair<long long, long long>, long long> dp[n + 1][40];
for (long long i = 0; i < n; i++) {
dp[i][0] = {{b[i], b[i]}, a[i]};
}
for (long long j = 1; j <= 38; j++) {
for (long long i = 0; i < n; i++) {
pair<pair<long long, long long>, long long> pp =
dp[dp[i][j - 1].second][j - 1];
dp[i][j] = {{dp[i][j - 1].first.first + pp.first.first,
min(pp.first.second, dp[i][j - 1].first.second)},
pp.second};
}
}
for (long long i = 0; i < n; i++) {
long long sum = 0, minn = 1e12, c = 0, curr = i;
for (long long j = 38; j >= 0; j--) {
if (c + (1LL << j) <= k) {
c += (1LL << j);
sum += dp[curr][j].first.first;
minn = min(dp[curr][j].first.second, minn);
curr = dp[curr][j].second;
}
}
cout << sum << " " << minn << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
clock_t clk = clock();
long long int i, j, k;
void solve(void);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int t = 1;
while (t--) solve();
return 0;
}
long long int n;
long long int f[100005], w[100005];
long long int dp[50][100005][3];
void solve() {
cin >> n >> k;
for (i = 0; i <= n - 1; ++i) cin >> f[i];
for (i = 0; i <= n - 1; ++i) cin >> w[i];
for (i = 0; i <= n - 1; ++i) {
dp[0][i][0] = f[i];
dp[0][i][1] = w[i];
dp[0][i][2] = w[i];
}
for (j = 1; j <= 35; ++j)
for (i = 0; i <= n - 1; ++i) {
long long int next = dp[j - 1][i][0];
dp[j][i][0] = dp[j - 1][next][0];
dp[j][i][1] = dp[j - 1][i][1] + dp[j - 1][next][1];
dp[j][i][2] =
((dp[j - 1][i][2]) < (dp[j - 1][next][2]) ? (dp[j - 1][i][2])
: (dp[j - 1][next][2]));
}
vector<long long int> v;
while (k > 0) {
long long int t = log2(k);
v.push_back(t);
k -= ((long long int)1 << t);
}
for (i = 0; i <= n - 1; ++i) {
long long int next = dp[v[0]][i][0];
long long int sum = dp[v[0]][i][1];
long long int min = dp[v[0]][i][2];
for (j = 1; j <= (int)v.size() - 1; ++j) {
sum += dp[v[j]][next][1];
min = ((min) < (dp[v[j]][next][2]) ? (min) : (dp[v[j]][next][2]));
next = dp[v[j]][next][0];
}
cout << sum << " " << min << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
void _r(const int& x) { scanf("%d", &x); }
void _r(const long long& x) { scanf("%I64d", &x); }
void _r(const char* x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(const T& head, const U&... tail) {
_r(head);
R(tail...);
}
void _w(const char x) { putchar(x); }
void _w(const char* x) { printf("%s", x); }
void _w(const int x) { printf("%d", x); }
void _w(const long long x) { printf("%I64d", x); }
void _w(const double x) { printf("%.6f", x); }
void W() {}
template <class T, class... U>
void W(const T& head, const U&... tail) {
_w(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
const long long mod = 1e9 + 7;
long long fp1(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans *= a;
b >>= 1;
a *= a;
}
return ans;
}
long long fp2(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
b >>= 1;
a = a * a % mod;
}
return ans;
}
long long Read() {
long long res = 0, flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
res = res * 10 + ch - '0';
ch = getchar();
}
return res * flag;
}
const int N = 1e5 + 5;
int to[N][40], mi[N][40];
long long sum[N][40];
int son[N], w[N];
void ST(int n, long long k) {
for (int i = (1); i <= (n); i++)
to[i][0] = son[i], sum[i][0] = w[i], mi[i][0] = w[i];
for (int j = 1; (1LL << j) <= k; j++) {
for (int i = 1; i <= n; i++) {
to[i][j] = to[to[i][j - 1]][j - 1];
sum[i][j] = sum[i][j - 1] + sum[to[i][j - 1]][j - 1];
mi[i][j] = min(mi[i][j - 1], mi[to[i][j - 1]][j - 1]);
}
}
}
long long ans1[N];
int ans2[N], nt[N];
void solve(int n, long long k) {
memset(ans2, 0x3f3f3f3f, sizeof ans2);
for (int i = (1); i <= (n); i++) nt[i] = i;
for (int i = 40; i >= 0; i--) {
if (k & (1LL << i)) {
for (int j = (1); j <= (n); j++) {
ans1[j] += sum[nt[j]][i];
ans2[j] = min(ans2[j], mi[nt[j]][i]);
nt[j] = to[nt[j]][i];
}
}
}
}
int main() {
int n;
long long k;
R(n, k);
for (int i = (1); i <= (n); i++) {
R(son[i]);
son[i]++;
}
for (int i = (1); i <= (n); i++) R(w[i]);
ST(n, k);
solve(n, k);
for (int i = (1); i <= (n); i++) {
W(ans1[i], ans2[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, to[100005], mi[100005][35], v[100005], ppow[40];
long long ans, bz[100005][35], s[100005][35], sum, minn, step;
inline long long read() {
long long ret = 0, ff = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') ff = -1;
ch = getchar();
}
while (isdigit(ch)) {
ret = (ret << 3) + (ret << 1) + (ch ^ 48);
ch = getchar();
}
return ret * ff;
}
void solve(long long x) {
minn = (1e18), sum = 0, step = 0;
for (int i = 34; i >= 0; i--) {
if (step + ppow[i] <= m) {
sum += s[x][i];
minn = min(minn, mi[x][i]);
step += ppow[i];
x = bz[x][i];
}
}
}
int main() {
ppow[0] = 1;
for (int i = 1; i <= 34; i++) ppow[i] = ppow[i - 1] * 2;
n = read(), m = read();
for (int i = 0; i < n; i++) to[i] = read(), bz[i][0] = to[i];
for (int i = 0; i < n; i++) v[i] = read(), mi[i][0] = v[i], s[i][0] = v[i];
for (int k = 1; k <= 34; k++)
for (int i = 0; i < n; i++) {
bz[i][k] = bz[bz[i][k - 1]][k - 1];
mi[i][k] = min(mi[i][k - 1], mi[bz[i][k - 1]][k - 1]);
s[i][k] = s[i][k - 1] + s[bz[i][k - 1]][k - 1];
}
for (int i = 0; i < n; i++) {
solve(i);
printf("%lld %lld\n", sum, minn);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 5;
const int maxLOG = 35;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long sq(long long x) { return (x * x) % MOD; }
long long modP(long long a, long long b) {
return (!b ? 1 : (sq(modP(a, b / 2)) * (b % 2 ? a : 1)) % MOD);
}
long long nxt[maxN][maxLOG], sum[maxN][maxLOG], mn[maxN][maxLOG];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, inp;
cin >> n;
long long k;
cin >> k;
for (int i = 0; i < n; i++) {
cin >> inp;
nxt[i][0] = inp;
}
for (int i = 0; i < n; i++) {
cin >> inp;
sum[i][0] = inp;
mn[i][0] = inp;
}
for (int i = 1; i < maxLOG; i++) {
for (int v = 0; v < n; v++) {
nxt[v][i] = nxt[nxt[v][i - 1]][i - 1];
}
}
for (int i = 1; i < maxLOG; i++) {
for (int v = 0; v < n; v++) {
sum[v][i] = sum[v][i - 1] + sum[nxt[v][i - 1]][i - 1];
mn[v][i] = min(mn[v][i - 1], mn[nxt[v][i - 1]][i - 1]);
}
}
for (int v = 0; v < n; v++) {
long long u = v;
long long s = 0;
long long m = INF;
for (long long i = maxLOG - 1; i > -1; i--) {
if ((k >> i) % 2 == 1) {
s += sum[u][i];
m = min(m, mn[u][i]);
u = nxt[u][i];
}
}
cout << s << " " << m << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long k;
const int N = 100005;
int out[N], w[N], dp[N][40];
long long sum[N][40], mn[N][40];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> out[i];
dp[i][0] = out[i];
}
for (int i = 0; i < n; ++i) {
cin >> w[i];
sum[i][0] = w[i];
mn[i][0] = w[i];
}
for (int k = 1; k < 40; ++k) {
for (int u = 0; u < n; ++u) {
dp[u][k] = dp[dp[u][k - 1]][k - 1];
sum[u][k] = sum[u][k - 1] + sum[dp[u][k - 1]][k - 1];
mn[u][k] = min(mn[u][k - 1], mn[dp[u][k - 1]][k - 1]);
}
}
for (int i = 0; i < n; ++i) {
long long si = 0;
int cur = i;
long long rem = k;
long long mi = 1e18;
for (long long p = 39; p >= 0; --p) {
if ((1ll << p) <= rem) {
rem -= (1ll << p);
mi = min(mi, mn[cur][p]);
si += sum[cur][p];
cur = dp[cur][p];
}
}
cout << si << ' ' << mi << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100001, logmax = 35;
int n, f[logmax][nmax], r[logmax][nmax];
long long s[logmax][nmax], k;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> f[0][i];
for (int i = 0; i < n; i++) cin >> r[0][i], s[0][i] = r[0][i];
for (int i = 1; i < logmax; i++)
for (int j = 0; j < n; j++) {
f[i][j] = f[i - 1][f[i - 1][j]];
r[i][j] = min(r[i - 1][j], r[i - 1][f[i - 1][j]]);
s[i][j] = s[i - 1][j] + s[i - 1][f[i - 1][j]];
}
for (int ii = 0; ii < n; ii++) {
long long L = 0;
int R = 1000000000;
int x = ii;
for (int i = 0; i < logmax; i++)
if ((k >> i) & 1) {
L += s[i][x];
R = min(R, r[i][x]);
x = f[i][x];
}
cout << L << " " << R << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
const int M = 34;
int to[M][N + 5];
int mn[M][N + 5];
long long sum[M][N + 5];
int T1[N + 5], T2[N + 5];
int M1[N + 5], M2[N + 5];
long long S1[N + 5], S2[N + 5];
int main() {
ios_base::sync_with_stdio(0);
int n;
long long k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> to[0][i];
for (int i = 0; i < n; i++) {
cin >> sum[0][i];
mn[0][i] = sum[0][i];
}
for (int i = 1; i < M; i++) {
for (int j = 0; j < n; j++) {
to[i][j] = to[i - 1][to[i - 1][j]];
mn[i][j] = min(mn[i - 1][j], mn[i - 1][to[i - 1][j]]);
sum[i][j] = sum[i - 1][j] + sum[i - 1][to[i - 1][j]];
}
}
vector<int> B;
for (int i = 0; i < M; i++)
if ((k & (1LL << i)) != 0) B.push_back(i);
for (int i = 0; i < n; i++) {
T1[i] = to[B[0]][i];
M1[i] = mn[B[0]][i];
S1[i] = sum[B[0]][i];
}
for (int i = 1; i < B.size(); i++) {
for (int j = 0; j < n; j++) {
T2[j] = to[B[i]][T1[j]];
M2[j] = min(M1[j], mn[B[i]][T1[j]]);
S2[j] = S1[j] + sum[B[i]][T1[j]];
}
for (int j = 0; j < n; j++) {
T1[j] = T2[j];
M1[j] = M2[j];
S1[j] = S2[j];
}
}
for (int i = 0; i < n; i++) cout << S1[i] << " " << M1[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, LOGN = 50;
int dp[LOGN][N];
long long dp2[LOGN][N];
long long dp3[LOGN][N];
int n;
long long k;
void solve(int u) {
long long tmp = k;
long long ans = 0;
long long ans2 = 1e18;
for (int i = LOGN; i >= 0; i--) {
if (((long long)1 << (long long)i) <= tmp) {
tmp -= ((long long)1 << (long long)i);
ans += dp2[i][u];
ans2 = min(ans2, dp3[i][u]);
u = dp[i][u];
}
}
printf("%I64d %I64d\n", ans, ans2);
}
int main() {
scanf("%d%I64d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &dp[0][i]);
}
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
dp2[0][i] = a;
dp3[0][i] = a;
}
for (int j = 1; ((long long)1 << (long long)j) <= k; j++) {
for (int i = 0; i < n; i++) {
dp[j][i] = dp[j - 1][dp[j - 1][i]];
dp2[j][i] = dp2[j - 1][dp[j - 1][i]] + dp2[j - 1][i];
dp3[j][i] = min(dp3[j - 1][dp[j - 1][i]], dp3[j - 1][i]);
}
}
for (int i = 0; i < n; i++) {
solve(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int to;
long long sumW;
int minW;
};
vector<node> mul(const vector<node>& a, const vector<node>& b) {
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;
int N;
long long K;
int to[100005];
long long W[100005];
int pa[100005][35];
long long st1[100005][35], st2[100005][35];
long long ans1[100005], ans2[100005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> K;
for (int i = 0; i <= N - 1; i++) cin >> to[i];
for (int i = 0; i <= N - 1; i++) {
cin >> W[i];
pa[i][0] = to[i];
st1[i][0] = W[i];
st2[i][0] = W[i];
}
long long ln = 2;
int lg = 1;
int mxlg = 0;
while (ln <= K) {
mxlg++;
for (int i = 0; i <= N - 1; i++) {
pa[i][lg] = pa[pa[i][lg - 1]][lg - 1];
st1[i][lg] = st1[i][lg - 1] + st1[pa[i][lg - 1]][lg - 1];
st2[i][lg] = min(st2[i][lg - 1], st2[pa[i][lg - 1]][lg - 1]);
}
ln <<= 1;
lg++;
}
for (int i = 0; i <= N - 1; i++) {
ans1[i] = 0;
ans2[i] = (1LL << 60);
int u = i;
for (int b = mxlg; b >= 0; b--) {
if (K & (1LL << b)) {
ans1[i] += st1[u][b];
ans2[i] = min(ans2[i], st2[u][b]);
u = pa[u][b];
}
}
}
for (int i = 0; i <= N - 1; i++) {
cout << ans1[i] << ' ' << ans2[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kN = 100 * 1000;
const int kLog = 35;
int f[kN];
long long w[kN];
int up[kN][kLog];
long long mn[kN][kLog];
long long sum[kN][kLog];
int main() {
std::ios_base::sync_with_stdio(false);
int n;
long long k;
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) {
up[i][0] = f[i];
mn[i][0] = sum[i][0] = w[i];
}
for (int h = 1; h < kLog; ++h) {
for (int i = 0; i < n; ++i) {
mn[i][h] = min(mn[i][h - 1], mn[up[i][h - 1]][h - 1]);
sum[i][h] = sum[i][h - 1] + sum[up[i][h - 1]][h - 1];
up[i][h] = up[up[i][h - 1]][h - 1];
}
}
for (int i = 0; i < n; ++i) {
long long sum_ = 0;
long long mn_ = 1e9;
int u = i;
for (int b = 0; b < kLog; ++b) {
if (k & (1LL << b)) {
sum_ += sum[u][b];
mn_ = min(mn_, mn[u][b]);
u = up[u][b];
}
}
cout << sum_ << ' ' << mn_ << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[100001][50], sum, w[100001][50], s[100001][50];
int main() {
long long i, j, k, x, m, n;
cin >> n >> k;
for (i = 0; i <= n - 1; i++) cin >> f[i][0];
for (i = 0; i <= n - 1; i++) {
cin >> w[i][0];
s[i][0] = w[i][0];
}
for (j = 1; j <= 45; j++)
for (i = 0; i <= n - 1; i++) {
f[i][j] = f[f[i][j - 1]][j - 1];
w[i][j] = min(w[i][j - 1], w[f[i][j - 1]][j - 1]);
s[i][j] = s[i][j - 1] + s[f[i][j - 1]][j - 1];
}
for (i = 0; i <= n - 1; i++) {
m = w[i][0];
x = i;
sum = 0;
for (j = 0; j <= 45; j++) {
if (k & 1LL << j) {
sum += s[x][j];
m = min(m, w[x][j]);
x = f[x][j];
}
}
cout << sum << " " << m << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
long long v[N], to[N], k;
int f[N][40];
long long sum[N][40], mi[N][40];
void solve(int g) {
long long res = 0, mmin = 1e9 + 7;
for (int i = 34; i >= 0; --i) {
if (k & (1ll << i)) {
res += sum[g][i], mmin = min(mmin, mi[g][i]);
g = f[g][i];
}
}
printf("%I64d %I64d\n", res, mmin);
}
int main() {
int x;
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("%I64d", &v[i]);
sum[i][0] = v[i], mi[i][0] = v[i];
}
for (int i = 1; i <= 34; ++i) {
for (int j = 0; j < n; ++j) {
int tt = f[j][i - 1];
f[j][i] = f[tt][i - 1];
sum[j][i] = sum[tt][i - 1] + sum[j][i - 1];
mi[j][i] = min(mi[j][i - 1], mi[tt][i - 1]);
}
}
for (int i = 0; i < n; ++i) solve(i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LG = 40;
const int N = 1e5 + 5;
const int W = 1e8 + 5;
int n, par[N][LG], mn[N][LG];
long long k, sum[N][LG];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> par[i][0];
}
for (int i = 0; i < n; i++) {
cin >> sum[i][0];
mn[i][0] = sum[i][0];
}
for (int j = 1; 1LL << j <= k; 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];
mn[i][j] = min(mn[i][j - 1], mn[par[i][j - 1]][j - 1]);
}
}
for (int i = 0; i < n; i++) {
int v = i, m = W;
long long s = 0, x = k;
int j = 0;
while (x) {
if (x & 1) {
s += sum[v][j];
m = min(m, mn[v][j]);
v = par[v][j];
}
j++;
x >>= 1;
}
cout << s << ' ' << m << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long minn[100010][40], f[100010][40], son[100010][40], n, k;
void solve(int x) {
long long ans = 0, minnn = 1e18;
long long s = k;
for (int i = 35; i >= 0; i--) {
if ((1ll << (1ll * i)) <= s) {
ans += f[x][i];
minnn = min(minnn, minn[x][i]);
x = son[x][i];
s -= (1ll << (1ll * i));
}
}
cout << ans << " " << minnn << endl;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> son[i][0];
for (int i = 0; i < n; i++) {
cin >> f[i][0];
minn[i][0] = f[i][0];
}
for (int i = 1; i <= 35; i++)
for (int j = 0; j < n; j++) {
son[j][i] = son[son[j][i - 1]][i - 1];
f[j][i] = f[j][i - 1] + f[son[j][i - 1]][i - 1];
minn[j][i] = min(minn[j][i - 1], minn[son[j][i - 1]][i - 1]);
}
for (int i = 0; i < n; i++) solve(i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 10, LG = 35;
long long mn[LG + 10][N], sum[LG + 10][N];
int par[LG + 10][N];
pair<long long, long long> get(int ind, long long k) {
pair<long long, long long> ans(0,
(1000LL * 1000 * 1000 * 1000 * 1000 * 1000));
for (int i = 0; i <= LG; i++)
if (k & (1LL << i)) {
ans.first += sum[i][ind];
ans.second = min(ans.second, mn[i][ind]);
ind = par[i][ind];
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
int n;
long long k;
cin >> n >> k;
for (int i = 0; i <= n - 1; i++) cin >> par[0][i];
for (int i = 0; i <= n - 1; i++) {
cin >> sum[0][i];
mn[0][i] = sum[0][i];
}
for (int i = 1; i <= LG; i++)
for (int j = 0; j <= n - 1; j++) {
par[i][j] = par[i - 1][par[i - 1][j]];
mn[i][j] = min(mn[i - 1][j], mn[i - 1][par[i - 1][j]]);
sum[i][j] = sum[i - 1][j] + sum[i - 1][par[i - 1][j]];
}
for (int i = 0; i <= n - 1; i++) {
pair<long long, long long> ans = get(i, k);
cout << ans.first << " " << ans.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long INFL = 2e18;
const int N = 1e5, LOG = 35;
const long long K = 1e10;
int n;
long long k;
int m[N + 5][LOG + 5], p[N + 5][LOG + 5];
long long s[N + 5][LOG + 5];
void qr(int u, long long k) {
int Min = 1e9;
long long S = 0;
for (int i = (LOG), _b = (0); i >= _b; --i)
if ((k - (1LL << i)) >= 0) {
k -= (1LL << i);
S += s[u][i];
Min = min(Min, m[u][i]);
u = p[u][i];
}
cout << S << ' ' << Min << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = (1), _b = (n); i <= _b; ++i) {
int tmp;
cin >> tmp;
p[i][0] = tmp + 1;
}
for (int i = (1), _b = (n); i <= _b; ++i) {
int tmp;
cin >> tmp;
m[i][0] = s[i][0] = tmp;
}
for (int j = (1), _b = (LOG); j <= _b; ++j)
for (int i = (1), _b = (n); i <= _b; ++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 = (1), _b = (n); i <= _b; ++i) qr(i, k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
using Matrix = vector<vector<T>>;
template <typename T>
Matrix<T> matrix(int R, int C, T x = T()) {
return Matrix<T>(R, vector<T>(C, x));
}
struct S {
ll sum;
int min;
};
S operator+(S a, S b) { return {a.sum + b.sum, min(a.min, b.min)}; }
S& operator+=(S& a, S b) { return a = a + b; }
struct SparseTable {
Matrix<int> images;
Matrix<S> data;
SparseTable(int n, int maxjump, vector<int> direct_images,
vector<int> weights) {
images = matrix<int>(maxjump + 1, n);
images[0] = direct_images;
data = matrix<S>(maxjump + 1, n);
for (auto i = 0; i < n; i++) data[0][i] = {weights[i], weights[i]};
for (auto k = 1; k <= maxjump; k++)
for (auto i = 0; i < n; i++) {
images[k][i] = images[k - 1][images[k - 1][i]];
data[k][i] = data[k - 1][i] + data[k - 1][images[k - 1][i]];
}
}
S query(int n, ll k) {
auto result = S{0LL, numeric_limits<int>::max()};
for (auto i = 0; k > 0; i++)
if (k & 1LL << i) {
result += data[i][n];
n = images[i][n];
k -= 1LL << i;
}
return result;
}
};
int main() {
int n;
ll k;
scanf("%d %lld", &n, &k);
auto images = vector<int>(n);
for (auto& x : images) scanf("%d", &x);
auto weights = vector<int>(n);
for (auto& x : weights) scanf("%d", &x);
auto table = SparseTable(n, 40, images, weights);
for (auto i = 0; i < n; i++) {
auto answer = table.query(i, k);
printf("%lld %d\n", answer.sum, answer.min);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long k;
int mi[100007];
int dp[40][100007];
long long sum[40][100007];
int mini[40][100007];
long long si[100007];
void func() {
for (int i = 1; i < 40; i++)
for (int j = 0; j < n; j++) dp[i][j] = dp[i - 1][dp[i - 1][j]];
for (int i = 1; i < 40; i++)
for (int j = 0; j < n; j++) {
sum[i][j] = sum[i - 1][j] + sum[i - 1][dp[i - 1][j]];
mini[i][j] = min(mini[i - 1][j], mini[i - 1][dp[i - 1][j]]);
}
for (int i = 0; i < n; i++) {
mi[i] = INT_MAX;
long long temp = k;
int j = i;
while (temp) {
long long t = log2(temp);
si[i] += sum[t][j];
mi[i] = min(mi[i], mini[t][j]);
j = dp[t][j];
temp -= (1LL << t);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0, f; i < n; i++) {
cin >> f;
dp[0][i] = f;
}
for (int i = 0, w; i < n; i++) {
cin >> w;
sum[0][i] = w;
mini[0][i] = w;
}
func();
for (int i = 0; i < n; i++) cout << si[i] << " " << mi[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[35][100005];
long long int par[35][100005];
long long int mi[35][100005];
long long int a[100005];
long long int b[100005];
vector<long long int> bt;
int main() {
long long int n, k;
cin >> n >> k;
for (long long int i = 0; i < n; i++) scanf("%lld", a + i);
for (long long int i = 0; i < n; i++) scanf("%lld", b + i);
for (long long int i = 0; i < n; i++) par[0][i] = a[i];
for (long long int i = 1; i < 35; i++) {
for (long long int j = 0; j < n; j++) par[i][j] = par[i - 1][par[i - 1][j]];
}
for (long long int i = 0; i < n; i++) dp[0][i] = b[i], mi[0][i] = b[i];
for (long long int i = 1; i < 35; i++) {
for (long long int j = 0; j < n; j++) {
dp[i][j] = dp[i - 1][j] + dp[i - 1][par[i - 1][j]];
mi[i][j] = min(mi[i - 1][j], mi[i - 1][par[i - 1][j]]);
}
}
for (long long int j = 0; j < 35; j++) {
if (k & (1LL << j)) bt.push_back(j);
}
for (long long int i = 0; i < n; i++) {
long long int ver = i;
long long int dist = 0;
long long int mii = 1e18 + 5;
for (auto j : bt) {
dist += dp[j][ver];
mii = min(mii, mi[j][ver]);
ver = par[j][ver];
}
printf("%lld %lld\n", dist, mii);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N(100005);
const long long inf((long long)1 << 60);
int n;
long long k, minn[35], ver[N][35], edge1[N][35], edge2[N][35];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i(1); i <= n; ++i) cin >> ver[i][0], ++ver[i][0];
for (int i(1); i <= n; ++i) {
cin >> edge1[i][0];
edge2[i][0] = edge1[i][0];
}
for (int i(1); i <= 34; ++i) {
for (int j(1); j <= n; ++j) {
ver[j][i] = ver[ver[j][i - 1]][i - 1];
edge1[j][i] = edge1[ver[j][i - 1]][i - 1] + edge1[j][i - 1];
edge2[j][i] = ((edge2[ver[j][i - 1]][i - 1]) < (edge2[j][i - 1])
? (edge2[ver[j][i - 1]][i - 1])
: (edge2[j][i - 1]));
}
}
minn[0] = 1;
for (int i(1); i <= 34; ++i) minn[i] = minn[i - 1] << 1;
for (int i(1); i <= n; ++i) {
int now(i);
long long step(k), ans1(0), ans2(inf);
for (int i(34); i >= 0; --i) {
if (step >= minn[i]) {
step -= minn[i];
ans1 += edge1[now][i];
ans2 = ((ans2) < (edge2[now][i]) ? (ans2) : (edge2[now][i]));
now = ver[now][i];
}
}
cout << ans1 << " " << ans2 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 35;
int n;
long long len, ans1, ans2, k, pred[50][100000 + 100], mn[50][100000 + 100],
suma[50][100000 + 100];
void init_() {
for (int i = 1; i <= MX; i++)
for (int j = 0; j < n; j++) {
pred[i][j] = pred[i - 1][pred[i - 1][j]];
suma[i][j] = suma[i - 1][pred[i - 1][j]] + suma[i - 1][j];
mn[i][j] = min(mn[i - 1][j], mn[i - 1][pred[i - 1][j]]);
}
}
void solve(int x, long long y) {
for (int i = len; i >= 0; i--) {
if (1LL << i <= y) {
ans1 += suma[i][x];
ans2 = min(ans2, mn[i][x]);
x = pred[i][x];
y -= 1LL << i;
}
}
}
int main() {
cin >> n >> k;
len = log2(k);
for (int i = 1; i <= n; i++) scanf("%lld", &pred[0][i - 1]);
for (int i = 1; i <= n; i++) {
scanf("%lld", &suma[0][i - 1]);
mn[0][i - 1] = suma[0][i - 1];
}
init_();
for (int i = 0; i < n; i++) {
ans1 = 0;
ans2 = 1e12;
solve(i, k);
printf("%lld %lld\n", ans1, ans2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
register int ans = 0, flag = 1;
register char c = getchar();
for (; c > '9' || c < '0'; c = getchar())
if (c == '-') flag = -1;
for (; c >= '0' && c <= '9'; c = getchar()) ans = ans * 10 - '0' + c;
return ans * flag;
}
inline long long rdll() {
register long long ans = 0, flag = 1;
register char c = getchar();
for (; c > '9' || c < '0'; c = getchar())
if (c == '-') flag = -1;
for (; c >= '0' && c <= '9'; c = getchar()) ans = ans * 10 - '0' + c;
return ans * flag;
}
const int MAXN = 1e5 + 10;
const int MAXLOGN = 50;
long long LOGN;
int to[MAXN], val[MAXN];
long long pt[MAXLOGN];
int n;
long long k;
int f[MAXN][MAXLOGN + 1];
long long m[MAXN][MAXLOGN + 1];
long long s[MAXN][MAXLOGN + 1];
int main() {
n = rd();
k = rdll();
LOGN = 35;
for (register int i = 1; i <= n; ++i) {
to[i] = rd() + 1;
f[i][0] = to[i];
}
for (register int i = 1; i <= n; ++i) {
val[i] = rd();
m[i][0] = val[i];
s[i][0] = val[i];
}
pt[0] = 1;
for (register int j = 1; j <= LOGN; ++j) {
pt[j] = pt[j - 1] * 2;
for (register int i = 1; i <= n; ++i) {
f[i][j] = f[f[i][j - 1]][j - 1];
m[i][j] = min(m[f[i][j - 1]][j - 1], m[i][j - 1]);
s[i][j] = s[f[i][j - 1]][j - 1] + s[i][j - 1];
}
}
for (register int i = 1; i <= n; ++i) {
long long t = k;
long long x = i;
long long ans = INT_MAX;
long long sum = 0;
for (register int j = LOGN; j >= 0; --j) {
if (pt[j] <= t) {
t -= pt[j];
sum += s[x][j];
ans = min(ans, m[x][j]);
x = f[x][j];
}
}
printf("%lld %lld\n", sum, ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 1;
const double eps = 1e-9;
const int MAXN = 1e5 + 1;
const int LOG = 34;
int n;
long long k;
int m[MAXN], w[MAXN];
int lca[LOG][MAXN];
long long sum[LOG][MAXN];
int mi[LOG][MAXN];
pair<long long, int> f(int a) {
long long l = k;
pair<long long, int> ret;
ret.second = inf;
for (int i = LOG - 1; i >= 0; i--) {
if (((long long)1 << i) <= (long long)l) {
ret.first = (long long)ret.first + (long long)sum[i][a];
ret.second = min(ret.second, mi[i][a]);
a = lca[i][a];
l -= ((long long)1 << i);
}
}
return ret;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> m[i];
}
for (int i = 0; i < n; i++) {
cin >> w[i];
lca[0][i] = m[i];
sum[0][i] = w[i];
mi[0][i] = w[i];
}
for (int i = 1; i < LOG; i++) {
for (int j = 0; j < n; j++) {
lca[i][j] = lca[i - 1][lca[i - 1][j]];
sum[i][j] =
(long long)sum[i - 1][j] + (long long)sum[i - 1][lca[i - 1][j]];
mi[i][j] = min(mi[i - 1][j], mi[i - 1][lca[i - 1][j]]);
}
}
for (int i = 0; i < n; i++) {
pair<long long, int> curr = f(i);
cout << curr.first << " " << curr.second << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
long long w[N], k, Mn[35][N], Sm[35][N];
int fa[35][N], n;
int main() {
scanf("%d%lld", &n, &k);
for (register int i = (1); i <= (n); ++i) scanf("%d", &fa[0][i]), fa[0][i]++;
for (register int i = (1); i <= (n); ++i)
scanf("%lld", w + i), Mn[0][i] = Sm[0][i] = w[i];
for (register int i = (1); i <= (34); ++i)
for (register int j = (1); j <= (n); ++j)
fa[i][j] = fa[i - 1][fa[i - 1][j]],
Mn[i][j] = min(Mn[i - 1][j], Mn[i - 1][fa[i - 1][j]]),
Sm[i][j] = Sm[i - 1][j] + Sm[i - 1][fa[i - 1][j]];
for (register int i = (1); i <= (n); ++i) {
long long s = k - 1, ret = w[i], Met = w[i], p = fa[0][i];
for (register int i = 0; s; s >>= 1, ++i)
if (s & 1) ret += Sm[i][p], Met = min(Met, Mn[i][p]), p = fa[i][p];
printf("%lld %lld\n", ret, Met);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
const int LOG = 34;
long long weight[MAX][LOG], mn[MAX][LOG], dp[MAX][LOG];
long long w[MAX], f[MAX];
pair<long long, long long> query(int x, long long k) {
pair<long long, long long> ans(0, LLONG_MAX);
for (int i = LOG - 1; i >= 0; --i) {
if ((k >> i) & 1ll) {
ans.first += weight[x][i];
ans.second = min(ans.second, mn[x][i]);
x = dp[x][i];
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long k;
int n;
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) {
weight[i][0] = w[i];
mn[i][0] = w[i];
dp[i][0] = f[i];
}
for (int j = 0; j < LOG - 1; ++j) {
for (int i = 0; i < n; ++i) {
dp[i][j + 1] = dp[dp[i][j]][j];
weight[i][j + 1] = weight[i][j] + weight[dp[i][j]][j];
mn[i][j + 1] = min(mn[i][j], mn[dp[i][j]][j]);
}
}
for (int i = 0; i < n; ++i) {
pair<long long, long long> ans = query(i, k);
cout << ans.first << ' ' << ans.second << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
long long qpow(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
struct graph {
int head[maxn], nxt[maxn << 1], to[maxn << 1], w[maxn << 1], sz;
void init() { memset(head, -1, sizeof(head)); }
graph() { init(); }
void push(int a, int b, int c) {
nxt[sz] = head[a], to[sz] = b, w[sz] = c, head[a] = sz++;
}
int& operator[](const int a) { return to[a]; }
};
long long dist[maxn][40], fi[maxn][40], mi[maxn][40];
int to[maxn], w[maxn];
int main() {
int n;
long long k;
cin >> n >> k;
for (int i = 0; i < n; ++i) scanf("%d", &to[i]);
for (int i = 0; i < n; ++i) {
scanf("%d", &w[i]);
dist[i][0] = w[i];
mi[i][0] = w[i];
fi[i][0] = to[i];
}
for (int i = 1; i <= 39; ++i) {
for (int j = 0; j < n; ++j) {
dist[j][i] = dist[j][i - 1] + dist[fi[j][i - 1]][i - 1];
fi[j][i] = fi[fi[j][i - 1]][i - 1];
mi[j][i] = min(mi[j][i - 1], mi[fi[j][i - 1]][i - 1]);
}
}
for (int i = 0; i < n; ++i) {
long long mix = 1e18;
long long ans = 0;
long long res = k;
int now = i;
for (int j = 39; j >= 0; --j) {
if (res >= (1ll << j)) {
ans += dist[now][j];
mix = min(mix, mi[now][j]);
now = fi[now][j];
res -= (1ll << j);
}
}
printf("%lld %lld\n", ans, mix);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 | '0');
}
inline void wln(long long x) {
write(x);
puts("");
}
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
inline int Min(int x, int y) { return x > y ? y : x; }
long long to[300000], f[100005][60], v[300000], w[100005][60], sum[100005][59],
ppp[59];
int main() {
long long n = read(), k = read();
ppp[0] = 1;
for (int i = 1; i <= 46; ++i) ppp[i] = ppp[i - 1] * 2;
for (long long i = 0; i < n; ++i) to[i] = read(), f[i][0] = to[i];
for (long long i = 0; i < n; ++i)
v[i] = read(), w[i][0] = v[i], sum[i][0] = v[i];
for (long long i = 1; i <= 46; ++i)
for (long long j = 0; j < n; ++j)
f[j][i] = f[f[j][i - 1]][i - 1],
w[j][i] = Min(w[j][i - 1], w[f[j][i - 1]][i - 1]),
sum[j][i] = (long long)sum[j][i - 1] + sum[f[j][i - 1]][i - 1];
for (long long i = 0; i < n; ++i) {
long long now = k, p = 210000000000000000, x = i, q = 0;
for (long long i = 46; i >= 0; --i)
if (now >= ppp[i]) {
now -= ppp[i];
p = Min(p, w[x][i]);
q += sum[x][i];
x = f[x][i];
if (now == 0) break;
}
printf("%lld %lld\n", q, p);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long k;
int n;
struct ans {
long long sum;
int m;
int dest;
};
ans a[40][100005];
int main() {
scanf("%d %lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[0][i].dest);
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[0][i].m);
a[0][i].sum = a[0][i].m;
}
for (int i = 1; i <= 39; i++) {
for (int j = 0; j < n; j++) {
a[i][j].dest = a[i - 1][a[i - 1][j].dest].dest;
a[i][j].sum = a[i - 1][j].sum + a[i - 1][a[i - 1][j].dest].sum;
a[i][j].m = min(a[i - 1][j].m, a[i - 1][a[i - 1][j].dest].m);
}
}
for (int i = 0; i < n; i++) {
int dest = i;
long long sum = 0;
int m = 199999999;
for (int j = 0; j <= 39; j++) {
if (!((1LL << j) & k)) continue;
sum += a[j][dest].sum;
m = min(m, a[j][dest].m);
dest = a[j][dest].dest;
}
printf("%lld %d\n", sum, m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, fa[100010][40], mn[100010][40];
long long k, s[100010][40];
void work(int x) {
long long si = 0;
int mi = 1e9;
for (int i = 35; i >= 0; i--) {
if ((1LL << i) & k) {
si += s[x][i];
mi = min(mi, mn[x][i]);
x = fa[x][i];
}
}
printf("%I64d %d\n", si, mi);
}
int main() {
scanf("%d%I64d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &fa[i][0]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &mn[i][0]);
s[i][0] = mn[i][0];
}
for (int i = 1; i <= 35; i++) {
for (int j = 0; j < n; j++) {
fa[j][i] = fa[fa[j][i - 1]][i - 1];
s[j][i] = s[j][i - 1] + s[fa[j][i - 1]][i - 1];
mn[j][i] = min(mn[j][i - 1], mn[fa[j][i - 1]][i - 1]);
}
}
for (int i = 0; i < n; i++) {
work(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LOG = 40;
const int MAXN = 101000;
int n;
int p[MAXN];
int w[MAXN];
int go[LOG][MAXN];
long long sm[LOG][MAXN];
long long mn[LOG][MAXN];
long long k;
int main() {
scanf("%d%lld", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", p + i);
for (int i = 0; i < n; ++i) scanf("%d", w + i);
for (int i = 0; i < n; ++i) {
go[0][i] = p[i];
sm[0][i] = w[i];
mn[0][i] = w[i];
}
for (int i = 1; i < LOG; ++i) {
for (int j = 0; j < n; ++j) {
go[i][j] = go[i - 1][go[i - 1][j]];
sm[i][j] = sm[i - 1][j] + sm[i - 1][go[i - 1][j]];
mn[i][j] = min(mn[i - 1][j], mn[i - 1][go[i - 1][j]]);
}
}
for (int i = 0; i < n; ++i) {
long long mni = 1e9;
long long sum = 0;
long long nk = k;
int now = i;
for (int j = LOG - 1; j >= 0; --j) {
if ((1ll << j) <= nk) {
nk -= (1ll << j);
sum += sm[j][now];
mni = min(mni, mn[j][now]);
now = go[j][now];
}
}
printf("%lld %lld\n", sum, mni);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int child[N], w[N];
long long dp[N][35][3], ans[N][2];
void pre(int n) {
for (int i = 0; i < n; i++) {
dp[i][0][0] = w[i];
dp[i][0][2] = w[i];
dp[i][0][1] = child[i];
}
for (int j = 1; j < 35; j++) {
for (int i = 0; i < n; i++) {
dp[i][j][1] = dp[dp[i][j - 1][1]][j - 1][1];
dp[i][j][0] = dp[i][j - 1][0] + dp[dp[i][j - 1][1]][j - 1][0];
dp[i][j][2] = min(dp[i][j - 1][2], dp[dp[i][j - 1][1]][j - 1][2]);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
long long k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> child[i];
for (int i = 0; i < n; i++) cin >> w[i];
pre(n);
int pt;
for (int i = 0; i < n; i++) {
pt = i;
ans[i][1] = 1000000007ULL;
for (long long j = 0; (1LL << j) <= k; j++) {
if ((1LL << j) & k) {
ans[i][0] += dp[pt][j][0];
ans[i][1] = min(ans[i][1], dp[pt][j][2]);
pt = dp[pt][j][1];
}
}
}
for (int i = 0; i < n; i++) cout << ans[i][0] << " " << ans[i][1] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 7 + 1e9;
const int inf = 1e9;
const int N = 1e5 + 5;
const int level = 40;
int in[N], w[N], to[N][level], _min[N][level];
long long sum[N][level];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
long long k;
cin >> n >> k;
for (int i = 0; i < (n); i++) {
cin >> in[i];
to[i][0] = in[i];
}
for (int i = 0; i < (n); i++) {
cin >> w[i];
_min[i][0] = w[i];
sum[i][0] = w[i];
}
for (int j = 1; j < (level); j++) {
for (int i = 0; i < (n); i++) {
to[i][j] = to[to[i][j - 1]][j - 1];
_min[i][j] = min(_min[i][j - 1], _min[to[i][j - 1]][j - 1]);
sum[i][j] = sum[i][j - 1] + sum[to[i][j - 1]][j - 1];
}
}
for (int i = 0; i < (n); i++) {
long long s = 0;
int m = 1e9;
int cur = i;
long long cnt = k;
for (long long j = 39; j >= 0; --j) {
if ((1ll << j) <= cnt) {
cnt -= (1ll << j);
s += sum[cur][j];
m = min(m, _min[cur][j]);
cur = to[cur][j];
}
}
cout << s << " " << m << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int K = 40;
int n;
long long k;
int nx[K][N];
long long sum[K][N];
int mn[K][N];
int a[N];
int go[50], len = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> nx[0][i];
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) sum[0][i] = mn[0][i] = a[i];
for (int step = 1; step <= 35; ++step) {
for (int i = 0; i < n; ++i) {
nx[step][i] = nx[step - 1][nx[step - 1][i]];
sum[step][i] = sum[step - 1][nx[step - 1][i]] + sum[step - 1][i];
mn[step][i] = min(mn[step - 1][nx[step - 1][i]], mn[step - 1][i]);
}
}
for (int jump = 35; jump >= 0; --jump) {
if ((1ll << jump) <= k) {
k -= (1ll << jump);
go[++len] = jump;
}
}
for (int i = 0; i < n; ++i) {
long long s = 0;
int m = 1000000000;
int v = i;
for (int it = 1; it <= len; ++it) {
s += sum[go[it]][v];
m = min(m, mn[go[it]][v]);
v = nx[go[it]][v];
}
cout << s << " " << m << 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;
typedef struct node {
int p;
long long int w;
int m;
node(){};
} node;
int main() {
int N;
long long int K;
cin >> N >> K;
int p[N];
int w[N];
for (int i = 0; i < N; i++) scanf("%d", p + i);
for (int j = 0; j < N; j++) scanf("%d", w + j);
node dp[35][N];
for (int i = 0; i < 35; i++) {
for (int j = 0; j < N; j++) {
if (i == 0) {
dp[i][j].p = p[j];
dp[i][j].w = w[j];
dp[i][j].m = w[j];
} else {
dp[i][j].p = dp[i - 1][dp[i - 1][j].p].p;
dp[i][j].w = dp[i - 1][j].w + dp[i - 1][dp[i - 1][j].p].w;
dp[i][j].m = min(dp[i - 1][j].m, dp[i - 1][dp[i - 1][j].p].m);
}
}
}
for (int i = 0; i < N; i++) {
long long int wt = 0, minm = 2e18;
int x = i;
for (int j = 0; j < 35; j++) {
long long int bit = (long long)1 << j;
if (K & bit) {
wt += dp[j][x].w;
minm = min(minm, (long long)dp[j][x].m);
x = dp[j][x].p;
}
}
cout << wt << " " << minm << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long up[100010][35], upsum[100010][35], upmin[100010][35];
long long n, k;
void build() {
for (int k = 1; k <= 34; k++)
for (int j = 0; j < n; j++) up[j][k] = up[up[j][k - 1]][k - 1];
for (int k = 1; k <= 34; k++)
for (int j = 0; j < n; j++)
upsum[j][k] = upsum[up[j][k - 1]][k - 1] + upsum[j][k - 1];
for (int k = 1; k <= 34; k++)
for (int j = 0; j < n; j++)
upmin[j][k] = min(upmin[up[j][k - 1]][k - 1], upmin[j][k - 1]);
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0, a; i < n; i++) {
cin >> a;
up[i][0] = a;
}
for (int i = 0, a; i < n; i++) {
cin >> a;
upmin[i][0] = upsum[i][0] = a;
}
build();
for (int i = 0; i < n; i++) {
long long x = i;
long long sum = 0, minn = 1e9;
for (int j = 34; j >= 0; j--) {
if ((1LL << j) & k) {
sum += upsum[x][j];
minn = min(minn, upmin[x][j]);
x = up[x][j];
}
}
cout << sum << " " << minn << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct st {
long long cur;
long long len;
int mini;
int dest;
};
int n;
long long k;
vector<st> to[100100];
st res[100100];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> res[i].dest;
for (int i = 0; i < n; i++) cin >> res[i].len;
for (int i = 0; i < n; i++) {
res[i].mini = res[i].len;
res[i].cur = 1LL;
to[i].push_back(res[i]);
}
while (res[0].cur < k) {
int s = to[0].size() - 1;
if (res[0].cur + to[0][s].cur > k) {
for (int i = 0; i < n; i++) to[i].pop_back();
continue;
}
for (int i = 0; i < n; i++) {
res[i].cur += to[i][s].cur;
res[i].len += to[res[i].dest][s].len;
res[i].mini = min(res[i].mini, to[res[i].dest][s].mini);
res[i].dest = to[res[i].dest][s].dest;
}
if (res[0].cur == 2 * to[0][s].cur) {
for (int i = 0; i < n; i++) to[i].push_back(res[i]);
}
}
for (int i = 0; i < n; i++) cout << res[i].len << " " << res[i].mini << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const long double PI = acosl((long double)-1.0);
const long long LINF = 1e18;
const int MOD = 1000000007;
const int LOG = 34;
const int MAXN = 200005;
int n;
long long k;
int f[LOG][MAXN];
int used[MAXN];
int c[MAXN];
int w[MAXN];
long long s[LOG][MAXN];
int mn[LOG][MAXN];
void init() {
scanf("%d%I64d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &f[0][i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &w[i]);
}
}
void solve() {
init();
for (int i = 0; i < n; i++) {
s[0][i] = w[i];
mn[0][i] = w[i];
}
for (int h = 1; h < LOG; h++) {
for (int i = 0; i <= n; i++) {
f[h][i] = f[h - 1][f[h - 1][i]];
s[h][i] = s[h - 1][i] + s[h - 1][f[h - 1][i]];
mn[h][i] = min(mn[h - 1][i], mn[h - 1][f[h - 1][i]]);
}
}
for (int i = 0; i < n; i++) {
int v = i;
long long sum = 0;
int m = ((int)(1e9) + 1337);
for (int h = 0; (1LL << h) <= k; h++) {
if (k & (1LL << h)) {
sum += s[h][v];
m = min(mn[h][v], m);
v = f[h][v];
}
}
printf("%I64d %d\n", sum, m);
}
}
void precalc() {}
int main() {
srand(707);
precalc();
int tests = 1;
for (int i = 1; i <= tests; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 100, P = 1e9 + 7, INF = 2e9 + 100;
const double ESP = 1. / 10000000000.;
struct aaa {
long long p, val, minl;
aaa() { p = val = minl = 0; }
};
aaa spr[36][N];
long long n, k, a;
void build() {
for (int i = 1; i <= 35; i++) {
for (int j = 1; j <= n; j++) {
spr[i][j].p = spr[i - 1][spr[i - 1][j].p].p;
spr[i][j].val = spr[i - 1][spr[i - 1][j].p].val + spr[i - 1][j].val;
spr[i][j].minl =
min(spr[i - 1][j].minl, spr[i - 1][spr[i - 1][j].p].minl);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a;
spr[0][i].p = a + 1;
}
for (int i = 1; i <= n; i++) {
cin >> a;
spr[0][i].val = a;
spr[0][i].minl = a;
}
build();
for (int i = 1; i <= n; i++) {
long long kk = k;
long long v = i;
long long minl = INF;
long long sum = 0;
for (int j = 35; j >= 0; j--) {
if (kk - ((long long)1 << (long long)j) >= 0) {
minl = min(minl, spr[j][v].minl);
sum += spr[j][v].val;
v = spr[j][v].p;
kk -= ((long long)1 << (long long)j);
}
}
cout << sum << ' ' << minl << endl;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.