text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> v[1000007];
int lvl[1000007];
int cnt[1000007];
int mndepth[1000007];
int noreturn[1000007];
void init(int vertex) {
int sz = v[vertex].size();
if (sz == 0) {
cnt[vertex] = 1;
mndepth[vertex] = lvl[vertex];
return;
}
mndepth[vertex] = 1000007;
for (int i = 0; i < sz; ++i) {
int h = v[vertex][i];
lvl[h] = lvl[vertex] + 1;
init(h);
if (mndepth[h] <= lvl[vertex] + k) {
cnt[vertex] += cnt[h];
mndepth[vertex] = min(mndepth[vertex], mndepth[h]);
}
}
}
void dfs(int vertex) {
int sz = v[vertex].size();
if (sz == 0) {
noreturn[vertex] = 1;
return;
}
for (int i = 0; i < sz; ++i) {
dfs(v[vertex][i]);
}
for (int i = 0; i < sz; ++i) {
int h = v[vertex][i];
int aux = cnt[vertex];
if (mndepth[h] <= lvl[vertex] + k) {
aux -= cnt[h];
}
noreturn[vertex] = max(noreturn[vertex], aux + noreturn[h]);
}
}
void input() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; ++i) {
int x;
scanf("%d", &x);
v[x].push_back(i);
}
}
void solve() {
init(1);
dfs(1);
printf("%d\n", noreturn[1]);
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0);
const long double log23 = 1.58496250072115618145373894394781;
const long double eps = 1e-8;
const long long INF = 1e18 + 239;
const long long prost = 239;
const int two = 2;
const int th = 3;
const long long MOD = 998244353;
const long long MOD2 = MOD * MOD;
const int BIG = 1e9 + 239;
const int alf = 26;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
const int dxo[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dyo[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int dig = 10;
const int day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int digarr[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
const int bt = 31;
template <typename T>
inline T gcd(T a, T b) {
while (a) {
b %= a;
swap(a, b);
}
return b;
}
template <typename T>
inline T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
inline bool is_down(char x) { return ('a' <= x && x <= 'z'); }
inline bool is_upper(char x) { return ('A' <= x && x <= 'Z'); }
inline bool is_digit(char x) { return ('0' <= x && x <= '9'); }
mt19937 rnd(239);
const int M = 1e6 + 239;
const int N = 2 * 1e3 + 239;
const int L = 20;
const int T = (1 << 18);
const int B = trunc(sqrt(M)) + 1;
const int X = 150;
int n, k, r, comp[M], dp[M];
vector<int> d[M];
bool used[M];
vector<int> v[M], u[M], in[M];
vector<int> tp;
void dfs_go(int p) {
used[p] = true;
for (int i : v[p])
if (!used[i]) dfs_go(i);
tp.push_back(p);
}
void dfs_back(int p) {
in[r].push_back(p);
if (d[p].empty()) dp[r]++;
used[p] = true;
comp[p] = r;
for (int i : u[p])
if (!used[i]) dfs_back(i);
}
int st[M];
void dfs_tree(int p, int h) {
st[h] = p;
for (int i : d[p]) dfs_tree(i, h + 1);
if (d[p].empty()) {
if (h < k)
v[p].push_back(0);
else
v[p].push_back(st[h - k]);
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i < n; i++) {
int p;
cin >> p;
d[p - 1].push_back(i);
v[p - 1].push_back(i);
}
dfs_tree(0, 0);
for (int i = 0; i < n; i++)
if (!used[i]) dfs_go(i);
for (int i = 0; i < n; i++)
for (int j : v[i]) u[j].push_back(i);
reverse(tp.begin(), tp.end());
memset(used, 0, sizeof(used));
r = 0;
for (int i = 0; i < n; i++) {
int x = tp[i];
if (!used[x]) {
dfs_back(x);
r++;
}
}
for (int i = r - 1; i >= 0; i--) {
int pl = 0;
for (int x : in[i])
for (int it : v[x]) {
if (comp[it] == i) continue;
pl = max(pl, dp[comp[it]]);
}
dp[i] += pl;
}
cout << dp[comp[0]];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
const int N = 1e6 + 5;
const int INF = 0x3f3f3f3f;
int head[N], nxt[N], ver[N], tot;
void add(int u, int v) { ver[++tot] = v, nxt[tot] = head[u], head[u] = tot; }
int dp[N], a[N], h[N], n, k;
void dfs(int u) {
h[u] = INF;
for (int i = head[u]; i; i = nxt[i]) {
int v = ver[i];
dfs(v);
cmin(h[u], h[v] + 1);
a[u] += a[v];
cmax(dp[u], dp[v] - a[v]);
}
dp[u] += a[u];
if (h[u] == INF) dp[u] = a[u] = 1, h[u] = 0;
if (h[u] >= k) a[u] = 0;
}
int main() {
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int fa;
cin >> fa;
add(fa, i);
}
dfs(1);
cout << dp[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 1000000;
int n, lim;
int par[MAXN];
vector<int> ch[MAXN];
int dleaf[MAXN];
int dp[MAXN];
void dfsinit(int at) {
dleaf[at] = ((int)(ch[at]).size()) == 0 ? 0 : INT_MAX;
dp[at] = ((int)(ch[at]).size()) == 0 ? 1 : 0;
for (int i = (0); i < (((int)(ch[at]).size())); ++i) {
int to = ch[at][i];
dfsinit(to);
dleaf[at] = min(dleaf[at], 1 + dleaf[to]);
if (dleaf[to] <= lim - 1) dp[at] += dp[to];
}
}
int dfsans(int at) {
int ret = dp[at];
for (int i = (0); i < (((int)(ch[at]).size())); ++i) {
int to = ch[at][i];
int cur = dp[at] + dfsans(to) - (dleaf[to] <= lim - 1 ? dp[to] : 0);
ret = max(ret, cur);
}
return ret;
}
int solve() {
for (int i = (0); i < (n); ++i)
if (par[i] != -1) ch[par[i]].push_back(i);
dfsinit(0);
return dfsans(0);
}
void run() {
scanf("%d%d", &n, &lim);
par[0] = -1;
for (int i = (1); i < (n); ++i) scanf("%d", &par[i]), --par[i];
printf("%d\n", solve());
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > adj;
vector<long long> util[2];
vector<long long> ht;
vector<long long> res;
long long n, k;
void dfs(long long r) {
if (adj[r].size() == 0) {
util[0][r] = ht[r] - k;
util[1][r] = 1;
return;
}
for (long long i = 0; i < adj[r].size(); i++) {
long long c = adj[r][i];
ht[c] = ht[r] + 1;
dfs(c);
if (util[0][c] <= ht[r]) {
util[0][r] = min(util[0][r], util[0][c]);
util[1][r] += util[1][c];
}
}
}
void solve(long long r) {
res[r] = 1;
for (long long i = 0; i < adj[r].size(); i++) {
long long c = adj[r][i];
solve(c);
if (util[0][c] <= ht[r]) {
res[r] = max(res[r], (util[1][r] - util[1][c]) + res[c]);
} else
res[r] = max(res[r], util[1][r] + res[c]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
adj.clear();
adj.resize(n);
ht.clear();
ht.resize(n, 0);
res.clear();
res.resize(n, 0);
util[0].resize(n, n + 5);
util[1].resize(n, 0);
for (long long i = 1; i < n; i++) {
long long p;
cin >> p;
p--;
adj[p].push_back(i);
}
dfs(0);
solve(0);
cout << res[0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> edge[1000000 + 10];
int deep[1000000 + 10], dp[1000000 + 10], low[1000000 + 10];
int ans[1000000 + 10];
void dfs(int rt, int first) {
deep[rt] = deep[first] + 1;
if (edge[rt].size() == 1 && rt != 1) {
low[rt] = deep[rt];
dp[rt] = 1;
return;
}
int minn = 1e9;
for (auto i : edge[rt]) {
if (i == first) continue;
dfs(i, rt);
if (deep[rt] + k >= low[i]) {
minn = min(minn, low[i]);
dp[rt] += dp[i];
}
}
low[rt] = minn;
}
void dfs1(int rt, int first) {
ans[rt] = dp[rt];
for (auto i : edge[rt]) {
if (i == first) continue;
int tmp = dp[i];
if (deep[rt] + k >= low[i]) {
dfs1(i, rt);
ans[rt] = max(ans[rt], dp[rt] - tmp + ans[i]);
} else {
dfs1(i, rt);
ans[rt] = max(ans[rt], dp[rt] + ans[i]);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = (2); i < (n + 1); i++) {
int x;
cin >> x;
edge[i].push_back(x);
edge[x].push_back(i);
}
dfs(1, 0);
dfs1(1, 0);
cout << ans[1] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long nr = 1e6 + 500;
inline long long read() {
long long ret = 0;
long long x = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') x = -1;
ch = getchar();
}
while (isdigit(ch)) {
ret = ret * 10 + ch - '0';
ch = getchar();
}
return ret * x;
}
long long fir[nr];
long long item = 0;
struct edge {
long long nxt, to, val;
} p[nr * 2];
void add(long long a, long long b, long long c) {
++item;
p[item].val = c;
p[item].to = b;
p[item].nxt = fir[a];
fir[a] = item;
}
long long leave[nr];
long long low[nr];
bool islve[nr];
long long n, k;
long long depth[nr];
void dfs1(long long now, long long fat) {
depth[now] = depth[fat] + 1;
if (islve[now]) {
low[now] = depth[now];
}
for (int tmp = fir[now]; tmp; tmp = p[tmp].nxt) {
long long v = p[tmp].to;
if (v == fat) continue;
dfs1(v, now);
low[now] = min(low[now], low[v]);
}
}
void dfs2(long long now, long long fat) {
if (islve[now]) {
leave[now] = 1;
}
for (int tmp = fir[now]; tmp; tmp = p[tmp].nxt) {
long long v = p[tmp].to;
if (v == fat) continue;
dfs2(v, now);
if (low[v] - depth[now] <= k) {
leave[now] += leave[v];
leave[v] = 0;
}
}
}
long long dfsans(long long now) {
long long maxx = 0;
for (int tmp = fir[now]; tmp; tmp = p[tmp].nxt) {
long long v = p[tmp].to;
maxx = max(maxx, dfsans(v));
}
return maxx + leave[now];
}
int main() {
n = read();
k = read();
memset(low, 999999, sizeof(low));
memset(islve, 1, sizeof(islve));
for (int i = 2; i <= n; i++) {
long long f = read();
add(f, i, 1);
islve[f] = 0;
}
dfs1(1, 0);
dfs2(1, 0);
cout << dfsans(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100;
vector<int> e[maxn];
int n, k;
int low[maxn], dp1[maxn], dp2[maxn], h[maxn];
void dfs(int u) {
if (e[u].size() == 0)
low[u] = h[u], dp1[u] = 1;
else
low[u] = n;
for (auto &v : e[u]) {
h[v] = h[u] + 1;
dfs(v);
if (low[v] - h[u] <= k) {
dp1[u] += dp1[v];
low[u] = min(low[u], low[v]);
dp2[u] = max(dp2[u], dp2[v] - dp1[v]);
} else
dp2[u] = max(dp2[u], dp2[v]);
}
dp2[u] += dp1[u];
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int v;
cin >> v;
e[v].push_back(i);
}
dfs(1);
cout << dp2[1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000100;
int N, K;
vector<int> child[MAXN];
int nfree[MAXN], npaid[MAXN], dep[MAXN];
void flood(int cloc) {
if (!child[cloc].size()) {
dep[cloc] = 0;
nfree[cloc] = 1;
npaid[cloc] = 0;
return;
}
int pbest = 0, ftot = 0;
dep[cloc] = 1e9;
for (int son : child[cloc]) {
flood(son);
dep[cloc] = min(dep[cloc], dep[son] + 1);
ftot += nfree[son];
pbest = max(pbest, npaid[son]);
}
npaid[cloc] = pbest;
if (dep[cloc] < K)
nfree[cloc] += ftot;
else
npaid[cloc] += ftot;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> N >> K;
for (int i = 1; i < N; i++) {
int a;
cin >> a;
a--;
child[a].push_back(i);
}
flood(0);
cout << nfree[0] + npaid[0] << "\n";
}
|
#include <bits/stdc++.h>
const int maxn = 1e6 + 5;
const int maxm = 2e6 + 5;
using namespace std;
int n, k;
int tot, head[maxn];
int a[maxn], b[maxn];
int ans;
struct edgenode {
int to, next;
} edge[maxm];
void addedge(int u, int v) {
edge[tot].to = v;
edge[tot].next = head[u];
head[u] = tot++;
}
void dfs1(int x) {
if (head[x] == -1) {
a[x] = 1;
b[x] = k;
return;
}
for (int i = head[x]; i != -1; i = edge[i].next) {
int v = edge[i].to;
dfs1(v);
if (b[v]) a[x] += a[v];
b[x] = max(b[x], b[v] - 1);
}
}
void dfs2(int x, int val) {
if (head[x] == -1) {
ans = max(ans, val + 1);
return;
}
for (int i = head[x]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (b[v])
dfs2(v, val + a[x] - a[v]);
else
dfs2(v, val + a[x]);
}
}
int main() {
memset(head, -1, sizeof head);
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
addedge(x, i);
}
dfs1(1);
dfs2(1, 0);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
struct graph {
int head[1000005], nxt[1000005], to[1000005], ecnt;
graph() {
ecnt = 0;
memset(head, 0, sizeof(head));
memset(nxt, 0, sizeof(nxt));
memset(to, 0, sizeof(to));
}
void adde(int u, int v) {
to[++ecnt] = v;
nxt[ecnt] = head[u];
head[u] = ecnt;
}
} t;
int dep[1000005], deg[1000005], dp[1000005], mn[1000005];
void dfs(int x) {
if (deg[x] == 0) {
mn[x] = dep[x];
dp[x] = 1;
return;
}
mn[x] = 0x3f3f3f3f;
for (int e = t.head[x]; e; e = t.nxt[e]) {
int y = t.to[e];
dep[y] = dep[x] + 1;
dfs(y);
mn[x] = min(mn[x], mn[y]);
if (mn[y] - dep[x] <= k) {
dp[x] += dp[y];
dp[y] = 0;
}
}
}
int mxsum(int x) {
int mx = 0;
for (int e = t.head[x]; e; e = t.nxt[e]) {
mx = max(mx, mxsum(t.to[e]));
}
return mx + dp[x];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
int fa;
scanf("%d", &fa);
t.adde(fa, i);
deg[fa]++;
}
dfs(1);
printf("%d\n", mxsum(1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int depth[N];
vector<int> g[N];
int k, n;
int minleaf[N];
bool leaf(int u) { return u != 1 and g[u].size() == 0; }
void dfs(int u, int d) {
depth[u] = d;
if (leaf(u))
minleaf[u] = d;
else
minleaf[u] = 0x3f3f3f3f;
for (int v : g[u]) {
dfs(v, d + 1);
minleaf[u] = min(minleaf[u], minleaf[v]);
}
}
int cnt[N];
void dfs2(int u) {
if (leaf(u)) {
cnt[u] = 1;
return;
}
for (int v : g[u]) dfs2(v);
if (minleaf[u] - depth[u] >= k) return;
for (int v : g[u]) cnt[u] += cnt[v];
}
int solve(int u) {
if (leaf(u)) return 1;
int sum = 0;
for (int v : g[u]) sum += cnt[v];
int ans = 0;
for (int v : g[u]) ans = max(ans, sum - cnt[v] + solve(v));
return ans;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
g[p].push_back(i);
}
dfs(1, 0);
dfs2(1);
printf("%d\n", solve(1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <typename T, typename U>
pair<T, U> operator+(const pair<T, U>& l, const std::pair<T, U>& r) {
return {l.first + r.first, l.second + r.second};
}
const long long int mod = 1e9 + 7;
const int maxn = 1000005;
vector<long long int> g[maxn];
long long int dp[maxn];
long long int n, k;
pair<long long int, long long int> dfs(long long int u, long long int d = 0) {
pair<long long int, long long int> now = {1e9, 0};
dp[u] = -1e9;
for (auto v : g[u]) {
pair<long long int, long long int> temp = dfs(v, d + 1);
if (temp.first <= d) {
now.first = min(now.first, temp.first);
now.second += temp.second;
dp[u] = max(dp[u], dp[v] - temp.second);
} else {
dp[u] = max(dp[u], dp[v]);
}
}
if (g[u].size() == 0) {
now = {d - k, 1};
dp[u] = 1;
} else {
dp[u] += now.second;
}
return now;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
for (long long int i = 1; i <= n - 1; i++) {
long long int p;
cin >> p;
g[p].push_back(i + 1);
}
dfs(1);
cout << dp[1] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
int n, k;
vector<int> kid[N];
int h[N];
int lst[N];
int cm[N];
void dfs(int v) {
if (!kid[v].size()) {
lst[v] = h[v];
return;
}
lst[v] = 1e9;
for (auto u : kid[v]) {
h[u] = h[v] + 1;
dfs(u);
lst[v] = min(lst[v], lst[u]);
}
}
void getcm(int v) {
if (!kid[v].size()) {
cm[v] = 1;
return;
}
for (auto u : kid[v]) {
getcm(u);
if (lst[u] - h[v] <= k) cm[v] += cm[u];
}
}
int dp[N];
void solve(int v) {
if (!kid[v].size()) {
dp[v] = 1;
return;
}
for (auto u : kid[v]) solve(u);
int s = 0;
for (auto u : kid[v])
if (lst[u] - h[v] <= k) s += cm[u];
for (auto u : kid[v])
if (lst[u] - h[v] <= k)
dp[v] = max(dp[v], s - cm[u] + dp[u]);
else
dp[v] = max(dp[v], s + dp[u]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
kid[p].push_back(i);
}
dfs(1);
getcm(1);
solve(1);
cout << dp[1];
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000050, INF = (int)1e9;
const int LOG_N = 20;
int root = 0;
int n, m, a, b;
int val[N];
vector<int> G[N];
int dp[2][N];
int up[N], down[N];
void get(int v) {
dp[0][v] = val[v];
for (int nxt : G[v]) {
get(nxt);
dp[0][v] += dp[0][nxt];
dp[1][v] = max(dp[1][v], dp[1][nxt]);
}
if (up[v] == -1) {
dp[1][v] = dp[1][v] + dp[0][v];
dp[0][v] = 0;
}
}
int dfs_val(int v, int p) {
if (G[v].size() == 0) {
down[v] = 0;
val[v] = 1;
} else {
down[v] = INF;
for (int nxt : G[v]) {
if (nxt != p) {
down[v] = min(down[v], dfs_val(nxt, v) + 1);
}
}
}
up[v] = (down[v] < m ? 1 : -1);
return down[v];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int x;
scanf("%d", &x);
x--;
G[x].push_back(i);
}
dfs_val(0, -1);
get(0);
cout << dp[0][0] + dp[1][0] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
vector<vector<long long> > g;
long long INF = (long long)1e9;
long long N, K;
long long res = 1;
vector<long long> path;
vector<long long> dp1;
vector<long long> dp2;
long long dfs(long long a) {
path.push_back(a);
long long ans = 0;
long long mx = 0;
long long base = 0;
for (long long i = 0; i < g[a].size(); i++) {
long long t = dfs(g[a][i]);
base += dp2[g[a][i]];
dp2[a] += dp2[g[a][i]];
mx = max(mx, t - dp2[g[a][i]]);
}
for (long long i = 0; i < g[a].size(); i++) {
dp1[a] += dp1[g[a][i]];
}
if (dp1[a] == 0) {
dp2[a] = 0;
}
ans = base + mx;
if ((long long)g[a].size() == 0) {
ans = 1;
long long t = (long long)path.size() - K - 1;
if (t >= 0) {
dp1[path[t]]--;
}
dp1[a]++;
dp2[a] = 1;
}
path.pop_back();
return ans;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> K;
g.resize(N);
dp1.resize(N, 0);
dp2.resize(N, 0);
long long a;
for (long long i = 0; i < N - 1; i++) {
cin >> a;
a--;
g[a].push_back(i + 1);
}
cout << dfs(0) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> child[1000001];
int par[1000001][20];
int dep[1000001];
int up[1000001];
int mnc[1000001];
void dfs(int x) {
mnc[x] = 9 * n;
if (child[x].empty()) mnc[x] = dep[x];
for (int i : child[x]) {
par[i][0] = x;
dep[i] = dep[x] + 1;
dfs(i);
mnc[x] = min(mnc[x], mnc[i]);
}
}
int getPar(int x, int t) {
t = max(t, 0);
for (int i = 20; i--;) {
if ((t >> i) & 1) x = par[x][i];
}
return x;
}
void dfs2(int x) {
if (child[x].empty()) {
up[x] = 1;
} else {
up[x] = (mnc[x] - k < dep[x]);
}
for (int i : child[x]) {
dfs2(i);
}
}
int dp1[1000001];
int dp2[1000001];
void dfs3(int x) {
if (child[x].empty()) {
dp1[x] = 1;
dp2[x] = 1;
} else {
int sum = 0, mx = 0;
for (int i : child[x]) {
dfs3(i);
sum += dp1[i];
mx = max(mx, dp2[i] - dp1[i]);
}
dp1[x] = up[x] ? sum : 0;
dp2[x] = sum + mx;
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; ++i) {
int p;
scanf("%d", &p);
child[p].push_back(i);
}
dfs(1);
for (int i = 1; i < 20; ++i) {
for (int j = 1; j <= n; ++j) {
par[j][i] = par[par[j][i - 1]][i - 1];
}
}
dfs2(1);
dfs3(1);
printf("%d\n", dp2[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int p[1000005];
int dp[1000005];
int cnt[1000005];
int ans[1000005];
vector<int> v[1000005];
void dfs0(int x) {
ans[x] = dp[x];
int tmp = 0;
for (auto y : v[x]) {
dfs0(y);
tmp = max(tmp, ans[y]);
}
ans[x] += tmp;
}
void dfs(int x) {
if (v[x].empty()) {
dp[x] = 1;
cnt[x] = k;
return;
}
int ma = 0;
for (auto y : v[x]) {
dfs(y);
ma = max(ma, cnt[y]);
if (cnt[y] >= 1) {
dp[x] += dp[y];
dp[y] = 0;
}
}
cnt[x] = max(0, ma - 1);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
scanf("%d", &p[i]);
v[p[i]].push_back(i);
}
dfs(1);
dfs0(1);
cout << ans[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int dp[N][2], d[N], n, k;
vector<int> adj[N];
int res;
void dfs(int u) {
if (adj[u].empty()) {
dp[u][0] = dp[u][1] = 1;
return;
}
d[u] = n + 1;
int mx = 0;
for (int v : adj[u]) {
dfs(v);
d[u] = min(d[u], d[v] + 1);
if (d[v] < k) {
dp[u][0] += dp[v][0];
dp[u][1] += dp[v][0];
mx = max(mx, dp[v][1] - dp[v][0]);
} else
mx = max(mx, dp[v][1]);
}
dp[u][1] += mx;
}
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
adj[p].push_back(i);
}
dfs(1);
cout << dp[1][1] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> child[1000001];
int dep[1000001];
int mnc[1000001];
void dfs(int x) {
mnc[x] = 9 * n;
if (child[x].empty()) mnc[x] = dep[x];
for (int i : child[x]) {
dep[i] = dep[x] + 1;
dfs(i);
mnc[x] = min(mnc[x], mnc[i]);
}
}
int dp1[1000001];
int dp2[1000001];
void dfs2(int x) {
if (child[x].empty()) {
dp1[x] = 1;
dp2[x] = 1;
} else {
int sum = 0, mx = 0;
for (int i : child[x]) {
dfs2(i);
sum += dp1[i];
mx = max(mx, dp2[i] - dp1[i]);
}
dp1[x] = mnc[x] - k < dep[x] ? sum : 0;
dp2[x] = sum + mx;
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; ++i) {
int p;
scanf("%d", &p);
child[p].push_back(i);
}
dfs(1);
dfs2(1);
printf("%d\n", dp2[1]);
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1000010;
struct graph {
int head[MAXN], nxt[MAXN << 1], to[MAXN << 1], tot;
void adde(int b, int e) {
nxt[++tot] = head[b];
to[head[b] = tot] = e;
}
} g1, g2, g3;
int *head, *nxt, *to;
void setg(graph* x) { head = x->head, nxt = x->nxt, to = x->to; }
int n, K;
int st[MAXN], top;
bool isl[MAXN];
void dfs(int u, int f = 0) {
st[++top] = u;
bool& hav = isl[u] = true;
for (int i = head[u]; i; i = nxt[i])
if (to[i] != f) {
hav = false;
dfs(to[i], u);
g2.adde(u, to[i]);
}
if (hav) g2.adde(u, st[std::max(top - K, 1)]);
--top;
}
bool ins[MAXN];
int dfn[MAXN], low[MAXN], t0t;
int val[MAXN], bel[MAXN], idx;
void tarjan(int u) {
dfn[u] = low[u] = ++t0t;
ins[st[++top] = u] = true;
for (int i = head[u]; i; i = nxt[i])
if (!dfn[to[i]]) {
tarjan(to[i]);
low[u] = std::min(low[u], low[to[i]]);
} else if (ins[to[i]])
low[u] = std::min(low[u], dfn[to[i]]);
if (low[u] == dfn[u]) {
int v;
++idx;
do ins[v = st[top--]] = false, val[bel[v] = idx] += isl[v];
while (v != u);
}
}
int ind[MAXN], dp[MAXN];
std::queue<int> q;
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n >> K;
for (int i = 2, t; i <= n; ++i) std::cin >> t, g1.adde(t, i);
setg(&g1);
dfs(1);
setg(&g2);
tarjan(1);
for (int u = 1; u <= n; ++u)
for (int i = head[u]; i; i = nxt[i])
if (bel[u] != bel[to[i]]) ++ind[bel[to[i]]], g3.adde(bel[u], bel[to[i]]);
setg(&g3);
q.push(bel[1]);
int ans = 0;
while (!q.empty()) {
int t = q.front();
q.pop();
dp[t] += val[t];
for (int i = head[t]; i; i = nxt[i]) {
if (!--ind[to[i]]) q.push(to[i]);
dp[to[i]] = std::max(dp[to[i]], dp[t]);
}
ans = std::max(ans, dp[t]);
}
std::cout << ans << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, k, fa[N], dep[N], Min[N];
vector<int> e[N];
void dfs(int x) {
Min[x] = (e[x].empty() ? 0 : 1e9);
for (int v : e[x]) {
dep[v] = dep[x] + 1;
dfs(v);
Min[x] = min(Min[x], Min[v] + 1);
}
}
bool vis[N];
int calc(int x, int res, vector<int> &a) {
if (Min[x] > res) return 0;
vis[x] = 1;
a.push_back(x);
int ans = (Min[x] == 0);
for (int v : e[x]) ans += calc(v, k - 1, a);
return ans;
}
int solve(int x) {
vector<int> a;
int ans = calc(x, k, a), Max = 0;
if (Min[x] > k) a.push_back(x);
for (int u : a)
for (int v : e[u])
if (!vis[v]) Max = max(Max, solve(v));
return ans + Max;
}
int main() {
scanf("%d%d", &n, &k);
if (n == 1) return puts("0"), 0;
for (int i = 2; i <= n; ++i) {
scanf("%d", &fa[i]);
e[fa[i]].push_back(i);
}
dfs(1);
printf("%d\n", solve(1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, deg[1000005], ar[1000005], jump[1000005], ans[1000005], br[1000005],
lr[22][1000005];
vector<int> vr[1000005];
void lca(), dfs1(int), dfs(int, int);
int fin(int);
queue<int> qr;
int main() {
scanf("%d %d", &n, &k);
for (int i = 2; i < n + 1; i++) {
int y;
scanf("%d", &y);
vr[y].push_back(i);
}
dfs(1, 0);
lca();
for (int i = 1; i < n + 1; i++) ans[i] = i;
dfs1(1);
for (int i = 1; i < n + 1; i++) {
br[i] = i;
if (deg[i] == 0) {
ar[ans[i]]++;
qr.push(i);
}
}
while (!qr.empty()) {
int p = qr.front();
qr.pop();
deg[lr[0][p]]--;
if (deg[lr[0][p]] == 0) {
qr.push(lr[0][p]);
}
int m = 0;
for (int i = 0; i < vr[p].size(); i++) {
m = max(m, ar[vr[p][i]]);
}
ar[p] += m;
}
cout << ar[1] << " ";
}
void lca() {
for (int j = 1; j < 22; j++)
for (int i = 1; i < n + 1; i++) {
lr[j][i] = lr[j - 1][lr[j - 1][i]];
}
}
int fin(int idx, int k) {
for (int i = 0; i < 22; i++) {
if (k & (1 << i)) {
idx = lr[i][idx];
}
}
if (idx == 0) idx = 1;
return idx;
}
int dr[1000005];
void dfs(int idx, int p) {
lr[0][idx] = p;
int v = 1e9;
for (int i = 0; i < vr[idx].size(); i++) {
if (vr[idx][i] == p) continue;
deg[idx]++;
dfs(vr[idx][i], idx);
v = min(v, dr[vr[idx][i]]);
}
dr[idx] += 1 + (v == 1e9 ? 0 : v);
}
void dfs1(int idx) {
ans[idx] = ans[fin(idx, max(0, k - (dr[idx] - 1)))];
for (int i = 0; i < vr[idx].size(); i++) dfs1(vr[idx][i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n;
int k;
int v[2 * N];
int x[2 * N];
int ct;
int al[N];
int dp[N][2];
int rk[N];
inline void add(int u, int V) {
v[++ct] = V;
x[ct] = al[u];
al[u] = ct;
}
inline void dfs1(int u) {
rk[u] = 0x3f3f3f3f;
for (int i = al[u]; i; i = x[i]) dfs1(v[i]), rk[u] = min(rk[u], rk[v[i]]);
rk[u] = (rk[u] == 0x3f3f3f3f) ? 0 : rk[u] + 1;
}
inline void dfs(int u) {
int son = 0;
int del = 0;
for (int i = al[u]; i; i = x[i]) {
son++;
dfs(v[i]);
if (rk[v[i]] >= k) {
del = max(del, dp[v[i]][1]);
} else
del = max(del, dp[v[i]][1] - dp[v[i]][0]), dp[u][0] += dp[v[i]][0];
}
if (son == 0)
dp[u][0] = dp[u][1] = 1;
else
dp[u][1] = dp[u][0] + del;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 2, f; i <= n; i++) scanf("%d", &f), add(f, i);
dfs1(1);
dfs(1);
printf("%d", dp[1][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 2;
int k, dp[N][3], minleaf[N], level[N];
vector<int> adj[N];
void dfs(int x) {
if (adj[x].size() == 0) {
dp[x][0] = 1;
dp[x][1] = 1;
minleaf[x] = x;
return;
}
for (int i = 0; i < adj[x].size(); i++) {
level[adj[x][i]] = level[x] + 1;
dfs(adj[x][i]);
if (level[minleaf[adj[x][i]]] - k <= level[x]) {
dp[x][0] += dp[adj[x][i]][0];
}
if (level[minleaf[adj[x][i]]] < level[minleaf[x]]) {
minleaf[x] = minleaf[adj[x][i]];
}
}
for (int i = 0; i < adj[x].size(); i++) {
if (level[minleaf[adj[x][i]]] - k <= level[x]) {
dp[x][1] = max(dp[x][0] + dp[adj[x][i]][1] - dp[adj[x][i]][0], dp[x][1]);
} else {
dp[x][1] = max(dp[x][1], dp[x][0] + dp[adj[x][i]][1]);
}
}
}
int main() {
level[0] = N;
int n, i, j;
cin >> n >> k;
for (i = 2; i <= n; i++) {
cin >> j;
adj[j].push_back(i);
}
dfs(1);
cout << max(dp[1][0], dp[1][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5, lg = 20;
vector<int> Front_Edge[maxn], Back_Edge[maxn], Component_Front[maxn];
int depth[maxn], Comp[maxn], Leaf_cnt[maxn], Comp_ASS[maxn], dp[maxn];
int par[lg][maxn];
int n, k, Comp_CNT = 1;
set<pair<int, int> > Topol_set;
stack<int> Rev;
void Add_edge(int v, int u) {
Front_Edge[v].push_back(u);
Back_Edge[u].push_back(v);
}
void input() {
cin >> n >> k;
for (int i = 1; i < n; i++) {
cin >> par[0][i];
par[0][i]--;
Add_edge(par[0][i], i);
}
}
void Update_parents() {
for (int i = 1; i < lg; i++)
for (int j = 0; j < n; j++) par[i][j] = par[i - 1][par[i - 1][j]];
}
void Basic_dfs(int v) {
for (auto u : Front_Edge[v]) {
depth[u] = depth[v] + 1;
Basic_dfs(u);
}
Rev.push(v);
}
int Get_to_height(int v, int h) {
for (int i = lg - 1; i > -1; i--)
if (depth[par[i][v]] >= h) v = par[i][v];
return v;
}
void Add_Extra_Edges() {
for (int i = 1; i < n; i++)
if (!Front_Edge[i].size()) Add_edge(i, Get_to_height(i, depth[i] - k));
}
void DFS_Back(int v) {
for (auto u : Back_Edge[v]) {
if (Comp[u]) continue;
Comp[u] = Comp[v];
DFS_Back(u);
}
}
void Comp_Decomp() {
while (Rev.size()) {
int v = Rev.top();
Rev.pop();
if (!Comp[v]) {
Comp[v] = Comp_CNT;
DFS_Back(v);
Comp_CNT++;
}
}
}
void Find_ans() {
for (int i = 1; i < n; i++) {
if (Front_Edge[i].size() == 1 and depth[Front_Edge[i][0]] < depth[i])
Leaf_cnt[Comp[i]]++;
}
}
void Add_Comp_Edge(int c1, int c2) {
Component_Front[c1].push_back(c2);
Comp_ASS[c2]++;
}
void Making_comp_tree() {
for (int i = 0; i < n; i++)
for (auto u : Front_Edge[i])
if (Comp[i] != Comp[u]) Add_Comp_Edge(Comp[i], Comp[u]);
}
void Making_Topol_Set() {
for (int i = 1; i < Comp_CNT; i++) {
Topol_set.insert(make_pair(Comp_ASS[i], i));
}
}
void Dec(int C) {
auto A = Topol_set.find(make_pair(Comp_ASS[C], C));
Topol_set.erase(A);
Comp_ASS[C]--;
Topol_set.insert(make_pair(Comp_ASS[C], C));
}
int Updating() {
int Ans = 0;
while (Topol_set.size()) {
pair<int, int> P = *(Topol_set.begin());
Topol_set.erase(Topol_set.begin());
int c = P.second;
dp[c] = max(dp[c], Leaf_cnt[c]);
Ans = max(Ans, dp[c]);
for (auto C : Component_Front[c]) {
Dec(C);
dp[C] = max(dp[C], Leaf_cnt[C] + dp[c]);
}
}
return Ans;
}
void solve() {
Update_parents();
Basic_dfs(0);
Add_Extra_Edges();
Comp_Decomp();
Find_ans();
Making_comp_tree();
Making_Topol_Set();
cout << Updating();
}
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
input();
solve();
}
|
#include <bits/stdc++.h>
int n, k;
std::vector<std::vector<int> > g(1000010);
int cnt[1000010] = {0};
int max[1000010] = {0};
int ans = 0;
void dfs(int index, int parent) {
for (int i = 0; i < g[index].size(); ++i) {
int next = g[index][i];
if (next != index) {
dfs(next, index);
}
}
if (g[index].size() == 0 && index != 0) {
++cnt[parent];
max[parent] = std::max(max[parent], k - 1);
}
if (max[index] > 0 && parent != -1) {
cnt[parent] += cnt[index];
cnt[index] = 0;
max[parent] = std::max(max[parent], max[index] - 1);
}
}
void getans(int index, int parent, int curCnt) {
curCnt += cnt[index];
for (int i = 0; i < g[index].size(); ++i) {
int next = g[index][i];
if (next != parent) {
getans(next, index, curCnt);
}
}
if (curCnt > ans) ans = curCnt;
}
int main() {
std::cin >> n >> k;
for (int i = 1; i < n; ++i) {
int x;
std::cin >> x;
--x;
g[x].push_back(i);
}
dfs(0, -1);
getans(0, -1, 0);
std::cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1E6 + 10;
vector<int> adj[N];
int h[N], f[N], g[N];
int n, k;
void Read_Input() {
scanf("%d%d", &n, &k);
for (int u = 2; u <= n; u++) {
int p;
scanf("%d", &p);
adj[p].push_back(u);
}
}
void preDFS(int u, int p) {
h[u] = N;
f[u] = 0;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == p) continue;
preDFS(v, u);
f[u] += f[v];
h[u] = min(h[u], h[v] + 1);
g[u] = max(g[u], g[v] - f[v]);
}
g[u] += f[u];
if (adj[u].size() == 0 && p != -1) f[u] = 1, h[u] = 0;
if (h[u] >= k) f[u] = 0;
}
void DFS(int u, int p) {
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == p) continue;
DFS(v, u);
if (h[u] <= k)
g[u] = max(g[u], f[u] - f[v] + g[v]);
else
g[u] = max(g[u], f[u] + g[v]);
}
if (adj[u].size() == 0 && p != -1) g[u] = 1;
}
void Solve() {
preDFS(1, -1);
printf("%d", g[1]);
}
int main() {
Read_Input();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - 48;
ch = getchar();
}
return x * f;
}
template <typename T>
inline bool Max(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool Min(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
const int N = 1e6 + 7, inf = 0x3f3f3f3f;
int n, edc, K;
int head[N], len[N], f[N], g[N];
struct edge {
int last, to;
edge() {}
edge(int last, int to) : last(last), to(to) {}
} e[N * 2];
void Add(int a, int b) {
e[++edc] = edge(head[a], b), head[a] = edc;
e[++edc] = edge(head[b], a), head[b] = edc;
}
void dfs(int u, int fa) {
len[u] = inf;
int fg = 1;
for (int i = head[u], v = e[i].to; i; i = e[i].last, v = e[i].to)
if (v ^ fa) {
fg = 0;
dfs(v, u);
Min(len[u], len[v] + 1);
if (len[v] + 1 > K) g[v] = 0;
g[u] += g[v];
Max(f[u], f[v] - g[v]);
}
if (fg)
len[u] = 0, g[u] = f[u] = 1;
else
f[u] += g[u];
}
int main() {
n = gi(), K = gi();
for (int i = 2; i <= n; ++i) Add(i, gi());
dfs(1, 0);
printf("%d\n", f[1]);
return 0;
}
|
#include <bits/stdc++.h>
template <class Cost = int>
struct Edge {
int src, dst;
Edge(int src = -1, int dst = -1) : src(src), dst(dst){};
};
template <class Cost = int>
struct Graph {
std::vector<std::vector<Edge<Cost>>> graph;
Graph(int n = 0) : graph(n) {}
void span(bool direct, int src, int dst) {
graph[src].emplace_back(src, dst);
if (!direct) graph[dst].emplace_back(dst, src);
}
int size() const { return graph.size(); }
void clear() { graph.clear(); }
void resize(int n) { graph.resize(n); }
std::vector<Edge<Cost>>& operator[](int v) { return graph[v]; }
std::vector<Edge<Cost>> operator[](int v) const { return graph[v]; }
};
constexpr int N = 1000000;
int par[21][N];
template <class Cost = int>
struct LevelAncestor {
Graph<Cost> tree;
int kmax;
void dfs(int v, int p = -1) {
par[0][v] = p;
for (const auto& e : tree[v]) {
if (e.dst == p) continue;
dfs(e.dst, v);
}
}
LevelAncestor(const Graph<Cost>& tree, int root) : tree(tree) {
kmax = 0;
while ((1 << kmax) < (int)tree.size()) ++kmax;
dfs(root);
for (int k = 1; k <= kmax; ++k) {
for (int v = 0; v < (int)tree.size(); ++v) {
int p = par[k - 1][v];
par[k][v] = (p == -1 ? -1 : par[k - 1][p]);
}
}
}
int climb(int v, int d) const {
for (int k = kmax; k >= 0 && v != -1; --k) {
if ((1 << k) > d) continue;
v = par[k][v];
d -= (1 << k);
}
return v;
}
};
void solve() {
int n, k;
std::cin >> n >> k;
Graph<> graph(n);
for (int v = 1; v < n; ++v) {
int p;
std::cin >> p;
graph.span(true, --p, v);
}
std::vector<int> vs;
{
std::queue<int> que;
que.push(0);
while (!que.empty()) {
int v = que.front();
que.pop();
vs.push_back(v);
for (auto e : graph[v]) {
que.push(e.dst);
}
}
}
auto rvs = vs;
std::reverse(rvs.begin(), rvs.end());
std::vector<int> up(n, 0);
for (auto v : rvs) {
if (graph[v].empty()) {
up[v] = k;
continue;
}
for (auto e : graph[v]) {
up[v] = std::max(up[v], up[e.dst] - 1);
}
}
std::vector<int> upto(n);
{
LevelAncestor<> la(graph, 0);
for (auto v : vs) {
int u = la.climb(v, up[v]);
if (u == -1) u = 0;
upto[v] = (u == v ? u : upto[u]);
}
}
std::vector<int> szs(n, 0);
for (auto v : vs) {
if (graph[v].empty()) ++szs[upto[v]];
}
for (auto v : rvs) {
int max = 0;
for (auto e : graph[v]) max = std::max(max, szs[e.dst]);
szs[v] += max;
}
std::cout << szs[0] << "\n";
}
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const int inf = numeric_limits<int>::max();
vector<int> t[N];
int dp[N][2], mn[N], d[N], n, k, v;
int dfs0(int v, int dt) {
d[v] = dt;
mn[v] = inf;
if (t[v].empty()) return mn[v] = dt;
for (auto u : t[v]) mn[v] = min(mn[v], dfs0(u, dt + 1));
return mn[v];
}
void dfs1(int v) {
if (t[v].empty()) return void(dp[v][0] = dp[v][1] = 1);
int sum = 0, ans = 0;
for (auto u : t[v]) {
dfs1(u);
if (mn[u] - d[v] <= k) {
sum += dp[u][0];
ans = max(ans, dp[u][1] - dp[u][0]);
} else
ans = max(ans, dp[u][1]);
}
dp[v][0] = sum;
dp[v][1] = sum + ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 2; i <= n; i++) {
cin >> v;
t[v].push_back(i);
}
dfs0(1, 0);
dfs1(1);
cout << dp[1][1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans = 0;
const int N = 1e6 + 6;
vector<int> adj[N];
int INF = 1e9, k;
int t[N], sum[N];
void dfs(int u, int p) {
for (auto v : adj[u])
if (v != p) {
dfs(v, u);
if (t[v] + 1 <= k) sum[u] += sum[v];
t[u] = min(t[u], t[v] + 1);
}
if (t[u] == INF) t[u] = 0, sum[u] = 1;
}
int solve(int u, int p) {
int ret = 0;
for (auto v : adj[u])
if (v != p) {
if (t[v] + 1 <= k)
ret = max(ret, sum[u] - sum[v] + solve(v, u));
else
ret = max(ret, sum[u] + solve(v, u));
}
if (t[u] == 0) ret = 1;
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n >> k;
for (int i = 1; i <= n; i++) t[i] = INF;
for (int i = 2; i <= n; i++) {
int x;
cin >> x;
adj[i].push_back(x);
adj[x].push_back(i);
}
dfs(1, 1);
cout << solve(1, 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1002000;
int n, k, fa[maxn];
vector<int> g[maxn];
int dep[maxn], minn[maxn];
int f[maxn], d[maxn];
void read() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
scanf("%d", &fa[i]);
g[fa[i]].push_back(i);
}
}
void dfs(int now, int dp) {
dep[now] = dp;
if (g[now].size() == 0) {
minn[now] = dp;
return;
}
minn[now] = 1e8;
for (int i = 0; i < g[now].size(); i++) {
dfs(g[now][i], dp + 1);
minn[now] = min(minn[now], minn[g[now][i]]);
}
}
void dfs2(int now) {
if (g[now].size() == 0) {
f[now] = d[now] = 1;
return;
}
for (int i = 0; i < g[now].size(); i++) dfs2(g[now][i]);
for (int i = 0; i < g[now].size(); i++)
if (minn[g[now][i]] - dep[now] <= k) d[now] += d[g[now][i]];
for (int i = 0; i < g[now].size(); i++) {
if (minn[g[now][i]] - dep[now] <= k)
f[now] = max(f[now], d[now] - d[g[now][i]] + f[g[now][i]]);
else
f[now] = max(f[now], d[now] + f[g[now][i]]);
}
}
void work() {
dfs(1, 1);
dfs2(1);
printf("%d\n", f[1]);
}
int main() {
read();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
vector<int> gfo[N];
int p[N], here[N];
bool vst[N];
int find(int u) {
if (u == p[u]) return u;
return p[u] = find(p[u]);
}
void uni(int u, int v) {
int pu = find(u);
int pv = find(v);
p[pv] = pu;
}
void up(int u, int k) {
while (k && p[u] == u) {
uni(here[u], u);
u = here[u];
k--;
if (u == 0) break;
}
}
int dfs(int u) {
int ans = 0;
for (int v : gfo[u]) ans = max(ans, dfs(v));
return ans + here[u];
}
int main() {
int n;
scanf("%d", &n);
int k;
scanf("%d", &k);
for (int i = int(1); i < int(n); ++i) {
int pa;
scanf("%d", &pa);
pa--;
gfo[pa].push_back(i);
here[i] = pa;
}
vector<int> leafs;
queue<int> q;
q.push(0);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : gfo[u]) {
if (int(gfo[v].size()) == 0) leafs.push_back(v);
q.push(v);
}
}
for (int i = int(0); i < int(n); ++i) p[i] = i;
for (int u : leafs) up(u, k);
for (int i = int(0); i < int(n); ++i) find(i);
memset(here, 0, sizeof(here));
for (int i = int(0); i < int(n); ++i)
if (int(gfo[i].size()) == 0) here[p[i]]++;
printf("%d\n", dfs(0));
return 0;
}
|
#include <bits/stdc++.h>
int debugnum = 0;
using namespace std;
const int MAXN = 1e6 + 50;
vector<int> arc[MAXN];
int DFS(int K, int pos, int &depth, int &score1, int &score2) {
if (arc[pos].size() == 0) {
depth = score1 = score2 = 1;
return 0;
}
depth = INT_MAX >> 1;
score1 = 0;
score2 = 0;
for (int i = (0); i < (arc[pos].size()); i++) {
int e = arc[pos][i];
int dep, s1, s2;
DFS(K, e, dep, s1, s2);
if (dep <= K) {
depth = min(depth, dep);
score1 += s1;
score2 = max(score2, s2 - s1);
} else
score2 = max(score2, s2);
}
depth++;
score2 += score1;
return 0;
}
int main() {
int N, M, K;
while (cin >> N >> K) {
for (int i = (0); i < (N + 5); i++) arc[i].clear();
for (int b = (2); b < (N + 1); b++) {
int a;
scanf("%d", &a);
arc[a].push_back(b);
}
int depth, score1, score2;
DFS(K, 1, depth, score1, score2);
cout << score2 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
const int MAX_N = 1e6 + 7;
int n, k;
std::vector<int> gr[MAX_N];
std::pair<int, int> drev[MAX_N];
int d[MAX_N];
int pre[2][MAX_N], dep[MAX_N], po = 0;
int dfs(const int& cur, const int& depth) {
pre[0][cur] = po++;
dep[cur] = depth;
for (const auto& nei : gr[cur]) dfs(nei, depth + 1);
pre[1][cur] = po;
return 0;
}
int go(const int& cur) {
if (pre[0][cur] + 1 == pre[1][cur]) {
drev[cur].first = dep[cur] - k;
drev[cur].second = 1;
return 0;
}
drev[cur].first = INF;
for (const auto& nei : gr[cur]) {
go(nei);
drev[cur].first = std::min(drev[cur].first, drev[nei].first);
if (drev[nei].first <= dep[cur]) drev[cur].second += drev[nei].second;
}
return 0;
}
int despacito(const int& cur) {
if (pre[0][cur] + 1 == pre[1][cur]) {
return d[cur] = 1;
}
d[cur] = drev[cur].second;
for (const auto& nei : gr[cur]) {
despacito(nei);
d[cur] = std::max(d[cur],
drev[cur].second -
(drev[nei].first <= dep[cur] ? drev[nei].second : 0) +
d[nei]);
}
return d[cur];
}
int main(void) {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cin >> n >> k;
for (int i = 1, p; i < n; ++i) {
std::cin >> p;
gr[p - 1].push_back(i);
}
std::cout << (dfs(0, 0) + go(0) + despacito(0)) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n, k, ans, e[N], ec, nx[N], fi[N], d[N], f[N], g[N];
bool vis[N];
void adde(int u, int v) {
e[++ec] = v;
nx[ec] = fi[u];
fi[u] = ec;
}
void dfs(int u, int d) {
g[u] = 1e9;
if (!vis[u]) {
g[u] = d;
f[u] = 1;
}
int mx = 0;
for (int i = fi[u]; i; i = nx[i]) {
int v = e[i];
dfs(v, d + 1);
g[u] = min(g[u], g[v]);
if (g[v] - d <= k) {
f[u] += f[v];
f[v] = 0;
}
}
}
int work(int u) {
int mx = 0;
for (int i = fi[u]; i; i = nx[i]) mx = max(mx, work(e[i]));
return f[u] + mx;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; ++i) {
int fa;
scanf("%d", &fa);
adde(fa, i);
vis[fa] = true;
}
dfs(1, 0);
printf("%d\n", work(1));
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 1000010, LOG = 20;
int n, m, k, u, v, x, y, t, a, b, ans;
int par[MAXN][LOG];
int leaf[MAXN];
int comp[MAXN];
int sz[MAXN];
int dp[MAXN];
bitset<MAXN> mark;
vector<int> Gin[MAXN], Gout[MAXN];
vector<int> G[MAXN];
vector<int> vec;
int getpar(int v) {
for (int i = 0; i < LOG; i++)
if ((1 << i) & k) v = par[v][i];
return v;
}
void dfsout(int node) {
mark[node] = 1;
for (int v : Gout[node])
if (!mark[v]) dfsout(v);
vec.push_back(node);
}
void dfsin(int node, int c) {
comp[node] = c;
for (int v : Gin[node])
if (!comp[v]) dfsin(v, c);
}
int f(int node) {
if (dp[node] != -1) return dp[node];
dp[node] = 0;
for (int v : G[node]) dp[node] = max(dp[node], f(v));
return dp[node] += sz[node];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(dp, -1, sizeof(dp));
cin >> n >> k;
fill(leaf + 2, leaf + n + 1, 1);
for (int i = 2; i <= n; i++) {
cin >> par[i][0];
leaf[par[i][0]] = 0;
Gout[par[i][0]].push_back(i);
Gin[i].push_back(par[i][0]);
}
par[1][0] = 1;
for (int j = 1; j < LOG; j++) {
par[1][j] = 1;
for (int i = 2; i <= n; i++) par[i][j] = par[par[i][j - 1]][j - 1];
}
for (int i = 2; i <= n; i++)
if (leaf[i]) {
int p = getpar(i);
Gin[p].push_back(i);
Gout[i].push_back(p);
}
dfsout(1);
reverse(vec.begin(), vec.end());
for (int i : vec)
if (!comp[i]) dfsin(i, i);
for (int i = 1; i <= n; i++) sz[comp[i]] += leaf[i];
for (int i = 1; i <= n; i++) {
for (int v : Gout[i])
if (comp[i] != comp[v]) G[comp[i]].push_back(comp[v]);
}
cout << f(1) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n, k, u, f[N], g[N], h[N];
vector<int> adj[N];
void DFS(int u) {
if (adj[u].empty()) {
f[u] = g[u] = 1;
h[u] = k;
}
for (int &v : adj[u]) {
DFS(v);
if (h[v] > 0) {
g[u] += g[v];
h[u] = max(h[u], h[v] - 1);
}
}
for (int &v : adj[u])
if (h[v] > 0)
f[u] = max(f[u], g[u] - g[v] + f[v]);
else
f[u] = max(f[u], g[u] + f[v]);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
scanf("%d", &u);
adj[u].push_back(i);
}
DFS(1);
printf("%d", max(f[1], g[1]));
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
const long double eps = 0.0000000001;
const long long INF = 0x3fffffffffffffff;
long long n, k, fa[1000005], depth[1000005], low[1000005], canback[1000005],
cantback[1000005];
vector<long long> son[1000005];
void dfs1(long long now) {
for (long long i = 0; i < (long long)son[now].size(); ++i) {
depth[son[now][i]] = depth[now] + 1;
dfs1(son[now][i]);
}
}
void dfs2(long long now) {
if (!son[now].size()) {
low[now] = now;
}
for (long long i = 0; i < (long long)son[now].size(); ++i) {
dfs2(son[now][i]);
if (depth[low[now]] > depth[low[son[now][i]]]) {
low[now] = low[son[now][i]];
}
}
}
void dfs3(long long now) {
if (!son[now].size()) {
canback[now] = 1;
}
for (long long i = 0; i < (long long)son[now].size(); ++i) {
dfs3(son[now][i]);
if (depth[low[son[now][i]]] - depth[now] <= k) {
canback[now] += canback[son[now][i]];
}
}
}
void dfs4(long long now) {
cantback[now] = canback[now];
for (long long i = 0; i < (long long)son[now].size(); ++i) {
dfs4(son[now][i]);
if (depth[low[son[now][i]]] - depth[now] <= k) {
cantback[now] = max(cantback[now], canback[now] - canback[son[now][i]] +
cantback[son[now][i]]);
} else {
cantback[now] = max(cantback[now], canback[now] + cantback[son[now][i]]);
}
}
}
signed main() {
depth[0] = INF;
ios::sync_with_stdio(false);
cin >> n >> k;
for (long long i = 2; i <= n; ++i) {
cin >> fa[i];
son[fa[i]].push_back(i);
}
dfs1(1);
dfs2(1);
dfs3(1);
dfs4(1);
cout << cantback[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tot, fa[1000005][20], in[1000005], ans, dp[1000005], st[1000005], hd, cl, x,
n, k, i, j, deg[1000005], dfn[1000005], low[1000005], sum[1000005],
col[1000005], vis[1000005];
vector<int> son[1000005], to[1000005];
queue<int> q;
void add(int x, int y) { son[x].push_back(y); }
inline int find(int x, int y) {
for (int i = 19; ~i; --i)
if ((y >> i) & 1) x = fa[x][i];
return x;
}
void tarjan(int now) {
dfn[now] = low[now] = ++tot;
st[++hd] = now;
vis[now] = 1;
for (int T, i = 0; i < son[now].size(); ++i) {
if (!dfn[T = son[now][i]])
tarjan(T), low[now] = min(low[now], low[T]);
else if (vis[T])
low[now] = min(low[now], low[T]);
}
if (low[now] == dfn[now]) {
++cl;
while (now != st[hd + 1]) {
sum[cl] += in[st[hd]];
vis[st[hd]] = 0;
col[st[hd]] = cl;
--hd;
}
}
}
int main() {
cin >> n >> k;
for (i = 2; i <= n; ++i) cin >> fa[i][0], ++in[fa[i][0]], add(fa[i][0], i);
fa[1][0] = 1;
for (i = 1; i <= 19; ++i)
for (j = 1; j <= n; ++j) fa[j][i] = fa[fa[j][i - 1]][i - 1];
for (i = 1; i <= n; in[i] = (in[i] == 0), ++i)
if (!in[i]) add(i, find(i, k));
tarjan(1);
for (i = 1; i <= n; ++i) {
for (j = 0; j < son[i].size(); ++j) {
if (col[son[i][j]] != col[i]) {
to[col[i]].push_back(col[son[i][j]]);
++deg[col[son[i][j]]];
}
}
}
for (i = 1; i <= cl; ++i)
if (!deg[i]) q.push(i);
while (q.size()) {
x = q.front();
q.pop();
dp[x] += sum[x];
ans = max(ans, dp[x]);
for (i = 0; i < to[x].size(); ++i) {
if (!--deg[to[x][i]]) q.push(to[x][i]);
dp[to[x][i]] = max(dp[to[x][i]], dp[x]);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
vector<int> E[N];
int cnt[2 * N] = {0}, c[N];
int k;
int ans[N], dis[N], dcnt[N];
int uu[N];
int dfs(int u, int dep) {
int cc = cnt[dep + k + 1], sum = (u != 1 && c[u] == 1), mx = 0, mm = 0,
sm = 0;
if (u != 1 && c[u] == 1) cnt[dep]++;
for (int v : E[u]) {
sum += dfs(v, dep + 1);
if (dis[v] > 0) {
sm += dcnt[v] - uu[v];
mx = max(mx, ans[v] - dcnt[v]);
} else
mx = max(mx, ans[v] - uu[v]);
mm = max(mm, dis[v] - 1);
}
int cur = sum - (cnt[dep + k + 1] - cc);
dis[u] = mm;
dcnt[u] = sm + cur;
ans[u] = mx + cur + sm;
if (u != 1 && c[u] == 1) dis[u] = k;
return cur;
}
int dfs2(int u, int dep) {
int cc = cnt[dep + k], sum = (u != 1 && c[u] == 1);
if (u != 1 && c[u] == 1) cnt[dep]++;
for (int v : E[u]) {
sum += dfs2(v, dep + 1);
}
int cur = sum - (cnt[dep + k] - cc);
uu[u] = cur;
return cur;
}
int main() {
int n;
scanf("%d%d", &n, &k);
if (n == 1) {
puts("1");
return 0;
}
for (int i = 2; i <= n; i++) {
int pa;
scanf("%d", &pa);
E[pa].push_back(i);
c[pa]++;
c[i]++;
}
dfs2(1, 0);
memset(cnt, 0, sizeof cnt);
dfs(1, 0);
printf("%d\n", ans[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
vector<int> a[N];
int deep[N], leaf[N], dp[N], n, k;
void dfs(int u) {
if (a[u].size() == 0) {
leaf[u] = dp[u] = deep[u] = 1;
return;
}
deep[u] = n + 12;
int tmp = 0;
for (int v : a[u]) {
dfs(v);
deep[u] = min(deep[v] + 1, deep[u]);
tmp += leaf[v];
}
if (deep[u] <= k) leaf[u] = tmp;
for (int v : a[u]) {
dp[u] = max(dp[u], tmp - leaf[v] + dp[v]);
}
}
int x;
int main() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; ++i) {
scanf("%d", &x);
a[x].push_back(i);
}
dfs(1);
printf("%d", dp[1]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long infl = 2e18;
const long long infi = 1e9;
const long long mod = 998244353;
mt19937 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
auto clk = clock();
long long rng(long long lim) {
uniform_int_distribution<long long> uid(0, lim - 1);
return uid(rang);
}
long long p[1000005];
long long dp[1000005][2];
long long leafy[1000005];
vector<long long> gra[1000005];
long long tot[1000005];
long long n, k;
void dfs(long long fr, long long at) {
if (gra[at].empty())
tot[at] = 1;
else {
leafy[at] = infi;
for (long long i : gra[at]) {
dfs(at, i);
leafy[at] = min(leafy[at], leafy[i] + 1);
tot[at] += tot[i];
}
}
}
void dfs(long long at) {
long long mm = 0;
if (gra[at].empty()) {
dp[at][0] = 1;
dp[at][1] = 1;
return;
}
for (long long i : gra[at]) {
dfs(i);
if (leafy[i] < k) {
dp[at][0] += dp[i][0];
mm = max(mm, dp[i][1] - dp[i][0]);
} else
mm = max(mm, dp[i][1]);
}
dp[at][1] = dp[at][0] + mm;
}
void solve() {
cin >> n >> k;
if (n == 1) {
cout << 0 << '\n';
return;
}
for (long long i = 2; i <= n; i++) {
cin >> p[i];
gra[p[i]].push_back(i);
}
dfs(1, 1);
dfs(1);
cout << dp[1][1] << '\n';
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
cout << fixed << setprecision(10);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
struct ab {
int f, t;
} t[N << 1];
int h, hh[N], d[N], dmn[N], sum[N], dp[N], k;
void make(int x, int y) {
t[++h].f = hh[x];
t[h].t = y;
hh[x] = h;
}
void dfs(int x, int y) {
d[x] = d[y] + 1;
dmn[x] = N;
int flag = 0;
for (int i = hh[x]; i; i = t[i].f) {
int j = t[i].t;
if (j == y) continue;
flag = 1;
dfs(j, x);
dmn[x] = min(dmn[x], dmn[j]);
if (dmn[j] - d[x] <= k) sum[x] += sum[j], dp[j] -= sum[j];
dp[x] = max(dp[x], dp[j]);
}
if (!flag) dmn[x] = d[x], sum[x] = 1;
dp[x] += sum[x];
}
int main() {
int n;
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
make(x, i), make(i, x);
}
dfs(1, 0);
printf("%d\n", dp[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, dep[2000010], mn[2000010], f[2000010][2];
vector<int> v[2000010];
void dfs(int p, int fa) {
dep[p] = dep[fa] + 1;
if (v[p].size() == 1 && p != 1)
mn[p] = dep[p], f[p][0] = f[p][1] = 1;
else
mn[p] = 1e9;
int t = 0;
for (int i : v[p])
if (i != fa)
dfs(i, p), mn[p] = min(mn[p], mn[i]), f[p][1] += f[i][1], t += f[i][1];
for (int i : v[p])
if (i != fa) f[p][0] = max(f[p][0], t - f[i][1] + f[i][0]);
if (mn[p] >= dep[p] + k) f[p][1] = 0;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
v[x].push_back(i), v[i].push_back(x);
}
dfs(1, 0);
printf("%d\n", f[1][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
vector<int> g[MAXN];
int val_at_v[MAXN];
int ans = 0;
pair<int, int> dfs(int v, int k, vector<int> &path) {
path.push_back(v);
int min_depth_subtr = MAXN;
int max_subtr = 0;
if (g[v].empty()) {
val_at_v[v] = 1;
min_depth_subtr = 0;
}
for (auto to : g[v]) {
auto subtr = dfs(to, k, path);
max_subtr = max(max_subtr, subtr.first);
min_depth_subtr = min(min_depth_subtr, subtr.second + 1);
}
if (min_depth_subtr < k) {
int cnt_up = min(k - min_depth_subtr, (int)path.size() - 1);
if (cnt_up) {
val_at_v[*(path.rbegin() + cnt_up)] += val_at_v[v];
val_at_v[v] = 0;
}
}
path.pop_back();
ans = max(ans, max_subtr + val_at_v[v]);
return {max_subtr + val_at_v[v], min_depth_subtr};
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; ++i) {
int p_i;
scanf("%d", &p_i);
g[p_i].push_back(i);
}
vector<int> path;
dfs(1, k, path);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2, md) % md
: power(a * a % md, b / 2, md) % md));
}
const int xn = 1e6 + 10;
const int xm = 20;
const int sq = 320;
const int inf = 1e9 + 10;
const long long INF = 1e18 + 10;
const int mod = 998244353;
const int base = 257;
int n, k, dp[xn], par[xm][xn], c, ptr, col[xn];
pair<int, int> E[xn + xn];
vector<int> adj[2][xn], G[xn], topo;
bool mark[xn], leaf[xn];
void add_edge(int v, int u) {
adj[0][v].push_back(u);
adj[1][u].push_back(v);
E[ptr++] = {v, u};
}
void DFS(int v) {
mark[v] = true;
for (int u : adj[0][v])
if (!mark[u]) DFS(u);
topo.push_back(v);
}
void SFD(int v, int x) {
mark[v] = true;
col[v] = x;
dp[x] += leaf[v];
for (int u : adj[1][v])
if (!mark[u]) SFD(u, x);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
memset(leaf, true, sizeof leaf);
for (int i = 2; i <= n; ++i) {
cin >> par[0][i];
add_edge(par[0][i], i);
leaf[par[0][i]] = false;
}
par[0][1] = 1;
for (int i = 1; i < xm; ++i)
for (int v = 1; v <= n; ++v) par[i][v] = par[i - 1][par[i - 1][v]];
for (int i = 1; i <= n; ++i) {
if (!leaf[i]) continue;
int v = i, d = k;
for (int i = xm - 1; i >= 0; --i)
if ((1 << i) <= d) v = par[i][v], d -= (1 << i);
add_edge(i, v);
}
for (int i = 1; i <= n; ++i)
if (!mark[i]) DFS(i);
memset(mark, false, sizeof mark);
reverse(topo.begin(), topo.end());
for (int v : topo)
if (!mark[v]) SFD(v, ++c);
for (int i = 0; i < ptr; ++i) {
int v = E[i].first, u = E[i].second;
if (col[v] != col[u]) G[col[v]].push_back(col[u]);
}
for (int v = c; v >= 1; --v) {
int mx = 0;
for (int u : G[v]) mx = max(mx, dp[u]);
dp[v] += mx;
}
cout << dp[col[1]] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
auto const Random_Address = [] {
char* c;
c = new char;
delete c;
return uint64_t(c);
};
uint64_t const SEED = chrono::steady_clock::now().time_since_epoch().count() *
(Random_Address() bitor 1);
mt19937 Rng(SEED);
constexpr int Mask(int i) { return 1 << i; }
constexpr int Getb(int x, int i) { return x >> i bitand 1; }
template <size_t N>
bitset<N> Bits(int x) {
return bitset<N>(x);
}
template <class X, class Y>
bool minimize(X& x, Y const& y) {
return y < x ? x = y, 1 : 0;
}
template <class X, class Y>
bool maximize(X& x, Y const& y) {
return y > x ? x = y, 1 : 0;
}
int const maxN = 1e6;
int const maxK = 1e6;
int const infi = 1e9 + 7;
int N, K;
vector<int> adj[maxN + 3];
int f[maxN + 3], g[maxN + 3], h[maxN + 3], d[maxN + 3];
void dfs(int u) {
if (adj[u].empty()) {
h[u] = d[u];
f[u] = g[u] = 1;
return;
}
int _max = 0;
h[u] = infi;
for (int v : adj[u]) {
d[v] = d[u] + 1;
dfs(v);
minimize(h[u], h[v]);
if (h[v] - d[u] <= K) {
f[u] += f[v];
g[u] += f[v];
maximize(_max, g[v] - f[v]);
} else
maximize(_max, g[v]);
}
g[u] += _max;
return;
}
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
cin >> N >> K;
for (int v = 2; v <= N; v++) {
int u;
cin >> u;
adj[u].push_back(v);
}
dfs(1);
cout << g[1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-13;
const long double PI = acos(-1);
const int INF = (int)1e9;
const long long INFF = (long long)1e18;
const int mod = (int)1e9 + 7;
const int MXN = (int)1e6 + 7;
int n, k;
vector<int> edge[MXN];
vector<int> re_edge[MXN];
int prt[MXN];
int dp[21][MXN];
void init() {
scanf("%d %d", &n, &k);
for (int i = 2; i < n + 1; i++) {
scanf("%d", prt + i);
edge[prt[i]].push_back(i);
re_edge[i].push_back(prt[i]);
dp[0][i] = prt[i];
}
return;
}
bool leaf[MXN];
struct Scc {
int re[MXN], cntp;
int in[MXN];
int siz[MXN], gp[MXN];
int num[MXN];
int val[MXN];
int fd(int u) { return gp[u] == u ? u : gp[u] = fd(gp[u]); }
void uni(int u, int v) {
u = fd(u), v = fd(v);
if (u == v) return;
if (siz[u] > siz[v]) swap(u, v);
gp[u] = v;
siz[u] += siz[v];
return;
}
void dfs(int u) {
in[u] = 1;
for (int v : edge[u]) {
if (!in[v]) dfs(v);
}
re[++cntp] = u;
return;
}
void dfs2(int u, int la) {
in[u] = 1;
uni(u, la);
for (int v : re_edge[u]) {
if (!in[v]) dfs2(v, la);
}
}
void pre() {
for (int i = 1; i < n + 1; i++) siz[i] = 1, gp[i] = i;
for (int i = 1; i < n + 1; i++)
if (!in[i]) dfs(i);
memset(in, 0, sizeof(in));
;
for (int i = n; i >= 1; i--)
if (!in[re[i]]) dfs2(re[i], re[i]);
for (int i = 1; i < n + 1; i++)
if (leaf[i]) {
num[fd(i)]++;
val[fd(i)]++;
}
return;
}
int solve() {
pre();
int ans = 0;
for (int i = 1; i < n + 1; i++) {
ans = max(ans, val[fd(i)]);
for (int v : edge[re[i]]) {
int p1 = fd(v);
int p2 = fd(re[i]);
if (p1 == p2) continue;
val[p2] = max(val[p2], num[p2] + val[p1]);
ans = max(ans, val[p2]);
}
}
return ans;
}
} scc;
int dep[MXN];
void dfs(int u, int dpt) {
dep[u] = dpt;
for (int v : edge[u]) dfs(v, dpt + 1);
return;
}
int up(int u, int d) {
for (int i = 0; i < 21; i++) {
if (d & (1 << i)) {
u = dp[i][u];
}
}
return u;
}
void sol() {
dfs(1, 1);
for (int i = 1; i < 21; i++)
for (int j = 1; j < n + 1; j++) {
dp[i][j] = dp[i - 1][dp[i - 1][j]];
}
for (int i = 1; i < n + 1; i++)
if (edge[i].empty()) {
leaf[i] = 1;
int p = 0;
if (dep[i] <= k)
p = 1;
else
p = up(i, k);
edge[i].push_back(p);
re_edge[p].push_back(i);
}
int ans = scc.solve();
printf("%d\n", ans);
return;
}
int main(void) {
init();
sol();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const long long MXN = 1e6 + 10;
long long n, k, x;
long long Comp[MXN], Cnt[MXN], dp[MXN];
vector<long long> adj[MXN], adt[MXN], G[MXN], V[MXN], Jad, Top;
bool mark[MXN], vis[MXN];
void dfs1(long long u, long long d) {
if (G[u].empty()) {
adj[u].push_back(Jad[max(d - k, 0ll)]),
adt[Jad[max(d - k, 0ll)]].push_back(u);
}
Jad.push_back(u);
for (auto v : G[u]) dfs1(v, d + 1);
Jad.pop_back();
}
void dfs(long long u) {
mark[u] = 1;
for (auto v : adj[u]) {
if (!mark[v]) dfs(v);
}
Top.push_back(u);
}
void sfd(long long u) {
vis[u] = 1, Comp[u] = x, Cnt[x] += (G[u].empty()), V[x].push_back(u);
for (auto v : adt[u]) {
if (!vis[v]) sfd(v);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 2; i <= n; i++)
cin >> x, adj[x].push_back(i), adt[i].push_back(x), G[x].push_back(i);
dfs1(1, 0), x = 1;
for (int i = 1; i <= n; i++) {
if (!mark[i]) dfs(i);
}
reverse(Top.begin(), Top.end());
for (auto u : Top) {
if (!vis[u]) sfd(u), x++, dp[x - 1] = Cnt[x - 1];
}
for (int c = x - 1; c; c--) {
for (auto u : V[c]) {
for (auto v : adj[u]) {
if (Comp[v] != c) dp[c] = max(dp[c], Cnt[c] + dp[Comp[v]]);
}
}
}
cout << dp[Comp[1]] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int power(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = (res * x) % 1000000007;
y = y / 2, x = (x * x) % 1000000007;
}
return res % 1000000007;
}
pair<int, int> dp[1000001];
int ans[1000001];
int n, k;
vector<vector<int> > arr(1000001);
int depth[1000001];
void dfs(int u, int par) {
dp[u] = make_pair(n + 1, 0);
int i;
bool poss = true;
for (i = 0; i < arr[u].size(); i++) {
int v = arr[u][i];
if (v != par) {
depth[v] = 1 + depth[u];
dfs(v, u);
if (dp[v].first <= depth[u]) {
dp[u].first = min(dp[u].first, dp[v].first);
dp[u].second += dp[v].second;
}
poss = false;
}
}
if (poss) dp[u] = make_pair(depth[u] - k, 1);
}
void dfs1(int u, int par) {
bool poss = true;
int i;
for (i = 0; i < arr[u].size(); i++) {
int v = arr[u][i];
if (v != par) {
dfs1(v, u);
int temp = dp[u].second;
if (dp[v].first <= depth[u]) temp -= dp[v].second;
ans[u] = max(ans[u], temp + ans[v]);
poss = false;
}
}
if (poss) ans[u] = 1;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
int i;
if (n == 1) {
cout << 0;
return 0;
}
for (i = 0; i < n - 1; i++) {
int p;
cin >> p;
arr[p].push_back(i + 2);
arr[i + 2].push_back(p);
}
dfs(1, 0);
dfs1(1, 0);
cout << ans[1];
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, siz[1000005], dep[1000005], low[1000005], f[1000005];
bool is_leaf[1000005];
vector<int> G[1000005];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
(x *= 10) += ch - '0';
ch = getchar();
}
return x * f;
}
void dfs1(int u, int c_fa) {
dep[u] = dep[c_fa] + 1;
low[u] = 2e9;
if (is_leaf[u]) low[u] = dep[u];
for (int v : G[u]) dfs1(v, u), low[u] = min(low[u], low[v]);
}
void dfs2(int u) {
if (is_leaf[u]) siz[u] = 1;
for (int v : G[u]) {
dfs2(v);
if (low[v] - dep[u] <= k) siz[u] += siz[v], siz[v] = 0;
}
}
void dfs3(int u) {
f[u] = siz[u];
int mx = 0;
for (int v : G[u]) dfs3(v), mx = max(mx, f[v]);
f[u] += mx;
}
int main() {
n = read(), k = read();
memset(is_leaf, true, sizeof(is_leaf));
for (int i = 2, x; i <= n; i++)
x = read(), is_leaf[x] = false, G[x].push_back(i);
dfs1(1, 0);
dfs2(1);
dfs3(1);
printf("%d\n", f[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int n, k;
int dp[1000005], dpe[1000005];
int md[1000005];
vector<int> G[1000005];
void dfs(int v, int cd) {
if (G[v].empty()) {
md[v] = cd;
dp[v] = 1;
return;
}
md[v] = INF;
for (int i = 0; i < (G[v].size()); i++) {
int u = G[v][i];
dfs(u, cd + 1);
md[v] = min(md[v], md[u]);
if (md[u] <= cd + k) {
dp[v] += dp[u];
dpe[v] = max(dpe[v], dpe[u] - dp[u]);
} else
dpe[v] = max(dpe[v], dpe[u]);
}
dpe[v] += dp[v];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < (n - 1); i++) {
int v;
scanf("%d", &v);
G[v].push_back(i + 2);
}
dfs(1, 0);
int ans = 0;
for (int i = 1; i <= (n); i++) ans = max(ans, dpe[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ss {
int next, to;
} e[1000005 << 1];
int cnt, head[1000005];
inline void add(int x, int y) {
e[++cnt].next = head[x];
e[cnt].to = y;
head[x] = cnt;
}
int n, k, vis[1000005], low[1000005], siz[1000005], dep[1000005];
inline void dfs2(int now, int d) {
dep[now] = d;
low[now] = 1 << 30;
if (!vis[now]) low[now] = d;
for (int i = head[now]; i; i = e[i].next) {
int v = e[i].to;
dfs2(v, d + 1);
low[now] = min(low[now], low[v]);
}
}
inline void dfs3(int now) {
if (!vis[now]) siz[now] = 1;
for (int i = head[now]; i; i = e[i].next) {
int v = e[i].to;
dfs3(v);
if (low[v] - dep[now] <= k) {
siz[now] += siz[v];
siz[v] = 0;
}
}
}
inline int dfs1(int now) {
int s = 0;
for (int i = head[now]; i; i = e[i].next) s = max(s, dfs1(e[i].to));
return s + siz[now];
}
int main() {
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int x;
cin >> x;
add(x, i);
vis[x] = 1;
}
dfs2(1, 0);
dfs3(1);
cout << dfs1(1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000003;
const int M = N << 1;
const int INF = 2e9;
int n, K;
int cnt, head[N], Next[M], v[M];
int b[N];
long long w[N];
int pre[N], dfn[N], clo, kth[N], s[N];
int mn[N], dep[N];
int top[N];
void read(int &x) {
char ch = getchar();
x = 0;
int w = 0;
for (; ch < '0' || ch > '9'; ch = getchar()) w |= (ch == '-');
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 3) + (x << 1) + ch - '0';
if (w) x = -x;
}
void add(int x, int y) {
Next[++cnt] = head[x];
head[x] = cnt;
v[cnt] = y;
}
int predfs(int x, int fa, int d) {
s[d] = x;
dep[x] = d;
if (d - K > 0)
kth[x] = s[d - K];
else
kth[x] = 1;
if (!head[x]) mn[x] = x;
for (int i = head[x]; i; i = Next[i]) {
int val = predfs(v[i], x, d + 1);
if (dep[val] < dep[mn[x]]) mn[x] = val;
}
return mn[x];
}
void dfs(int x, int fa) {
long long mx = 0;
for (int i = head[x]; i; i = Next[i])
if (v[i] != fa) {
dfs(v[i], x);
mx = max(mx, w[v[i]]);
}
w[x] += mx;
}
int getop(int x) {
if (top[x]) return top[x];
int y = mn[kth[x]];
if (dep[y] == dep[x])
return top[x] = kth[x];
else
return top[x] = getop(y);
}
int main() {
read(n);
read(K);
int x;
for (int i = (2); i <= (n); i++) {
read(x);
add(x, i);
}
dep[0] = INF;
predfs(1, 0, 0);
for (int i = (1); i <= (n); i++)
if (!head[i]) getop(i);
for (int i = (1); i <= (n); i++)
if (!head[i]) w[top[i]]++;
dfs(1, 0);
long long mx = 0;
for (int i = (1); i <= (n); i++) mx = max(mx, w[i]);
cout << w[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, near[1010000], d[1010000], f[1010000];
vector<int> son[1010000];
int read() {
int AK = 1, IOI = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') AK = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
IOI = (IOI << 3) + (IOI << 1) + ch - '0';
ch = getchar();
}
return AK * IOI;
}
void build(int x, int deep) {
d[x] = deep;
if (!son[x].size()) {
near[x] = deep;
return;
}
near[x] = INT_MAX;
for (register int i = 0; i <= son[x].size() - 1; ++i) {
build(son[x][i], deep + 1);
near[x] = min(near[x], near[son[x][i]]);
}
return;
}
void dp(int x) {
if (!son[x].size()) {
f[x] = 1;
return;
}
f[x] = 0;
for (register int i = 0; i <= son[x].size() - 1; ++i) {
dp(son[x][i]);
if (near[son[x][i]] - d[x] <= k) {
f[x] += f[son[x][i]];
f[son[x][i]] = 0;
}
}
return;
}
int answer(int x) {
int Max = 0;
if (son[x].size())
for (register int i = 0; i <= son[x].size() - 1; ++i)
Max = max(Max, answer(son[x][i]));
return f[x] + Max;
}
int main() {
n = read();
k = read();
for (register int i = 2; i <= n; ++i) son[read()].push_back(i);
build(1, 0);
dp(1);
cout << answer(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
int h[N], e[N], ne[N], idx;
int f[N], g[N], len[N];
int n, k;
void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
void dfs(int u, int fa) {
len[u] = 0x3f3f3f3f;
bool flag = true;
for (int i = h[u]; ~i; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
flag = false;
dfs(j, u);
len[u] = min(len[u], len[j] + 1);
if (len[j] + 1 > k) g[j] = 0;
g[u] += g[j];
f[u] = max(f[u], f[j] - g[j]);
}
if (flag) {
len[u] = 0;
f[u] = g[u] = 1;
} else
f[u] += g[u];
}
int main() {
memset(h, -1, sizeof h);
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int x;
cin >> x;
add(i, x);
add(x, i);
}
dfs(1, -1);
cout << f[1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d[1000005], f[1000005], p[1000005], h[1000005];
vector<int> a[1000005];
void dfs(int u) {
if ((int)a[u].size() == 0) {
d[u] = f[u] = 1;
p[u] = h[u];
return;
}
int tmp = 0;
p[u] = n;
for (int i = 0; i < (int)a[u].size(); i++) {
int v = a[u][i];
h[v] = h[u] + 1;
dfs(v);
if (p[v] - h[u] <= k) {
p[u] = min(p[u], p[v]);
d[u] += d[v];
}
}
for (int i = 0; i < (int)a[u].size(); i++) {
int v = a[u][i];
if (p[v] - h[u] <= k)
f[u] = max(f[u], d[u] - d[v] + f[v]);
else
f[u] = max(f[u], d[u] + f[v]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
a[x].push_back(i);
}
dfs(1);
printf("%d", max(d[1], f[1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000050, INF = (int)1e9;
const int LOG_N = 20;
int root = 0;
int n, m, a, b;
int val[N];
vector<int> G[N];
int parent[LOG_N][N];
int dp[2][N];
int depth[N], up[N], down[N];
void dfs(int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (int nxt : G[v]) {
if (nxt != p) dfs(nxt, v, d + 1);
}
}
void init(int V) {
dfs(root, -1, 0);
for (int k = 0; k + 1 < LOG_N; k++) {
for (int v = 0; v < V; v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void get(int v) {
dp[0][v] = val[v];
for (int nxt : G[v]) {
get(nxt);
dp[0][v] += dp[0][nxt];
dp[1][v] = max(dp[1][v], dp[1][nxt]);
}
if (up[v] == -1) {
dp[1][v] = dp[1][v] + dp[0][v];
dp[0][v] = 0;
}
}
int dfs_val(int v, int p) {
if (G[v].size() == 0) {
down[v] = 0;
val[v] = 1;
} else {
down[v] = INF;
for (int nxt : G[v]) {
if (nxt != p) {
down[v] = min(down[v], dfs_val(nxt, v) + 1);
}
}
}
int cur = v, sum = down[v];
for (int j = LOG_N - 1; j >= 0; j--) {
if (parent[j][cur] != -1 && sum + (1 << j) <= m) {
sum += (1 << j);
cur = parent[j][cur];
}
}
up[v] = cur == v ? -1 : cur;
return down[v];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int x;
scanf("%d", &x);
x--;
G[x].push_back(i);
}
init(n);
dfs_val(0, -1);
get(0);
cout << dp[0][0] + dp[1][0] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5, lg = 21;
vector<int> Front_Edge[maxn], Back_Edge[maxn], Component_Front[maxn];
int depth[maxn], Comp[maxn], Leaf_cnt[maxn], Comp_ASS[maxn], dp[maxn];
int par[lg][maxn];
int n, k, Comp_CNT = 1;
set<pair<int, int> > Topol_set;
stack<int> Rev;
void Add_edge(int v, int u) {
Front_Edge[v].push_back(u);
Back_Edge[u].push_back(v);
}
void input() {
cin >> n >> k;
for (int i = 1; i < n; i++) {
cin >> par[0][i];
par[0][i]--;
Add_edge(par[0][i], i);
}
}
void Update_parents() {
for (int i = 1; i < lg; i++)
for (int j = 0; j < n; j++) par[i][j] = par[i - 1][par[i - 1][j]];
}
void Basic_dfs(int v) {
for (auto u : Front_Edge[v]) {
depth[u] = depth[v] + 1;
Basic_dfs(u);
}
Rev.push(v);
}
int Get_to_height(int v, int h) {
for (int i = lg - 1; i > -1; i--)
if (depth[par[i][v]] >= h) v = par[i][v];
return v;
}
void Add_Extra_Edges() {
for (int i = 1; i < n; i++)
if (!Front_Edge[i].size()) Add_edge(i, Get_to_height(i, depth[i] - k));
}
void DFS_Back(int v) {
for (auto u : Back_Edge[v]) {
if (Comp[u]) continue;
Comp[u] = Comp[v];
DFS_Back(u);
}
}
void Comp_Decomp() {
while (Rev.size()) {
int v = Rev.top();
Rev.pop();
if (!Comp[v]) {
Comp[v] = Comp_CNT;
DFS_Back(v);
Comp_CNT++;
}
}
}
void Find_ans() {
for (int i = 1; i < n; i++) {
if (Front_Edge[i].size() == 1 and depth[Front_Edge[i][0]] < depth[i])
Leaf_cnt[Comp[i]]++;
}
}
void Add_Comp_Edge(int c1, int c2) {
Component_Front[c1].push_back(c2);
Comp_ASS[c2]++;
}
void Making_comp_tree() {
for (int i = 0; i < n; i++)
for (auto u : Front_Edge[i])
if (Comp[i] != Comp[u]) Add_Comp_Edge(Comp[i], Comp[u]);
}
void Making_Topol_Set() {
for (int i = 1; i < Comp_CNT; i++) {
Topol_set.insert(make_pair(Comp_ASS[i], i));
}
}
void Dec(int C) {
auto A = Topol_set.find(make_pair(Comp_ASS[C], C));
Topol_set.erase(A);
Comp_ASS[C]--;
Topol_set.insert(make_pair(Comp_ASS[C], C));
}
int Updating() {
int Ans = 0;
while (Topol_set.size()) {
pair<int, int> P = *(Topol_set.begin());
Topol_set.erase(Topol_set.begin());
int c = P.second;
dp[c] = max(dp[c], Leaf_cnt[c]);
Ans = max(Ans, dp[c]);
for (auto C : Component_Front[c]) {
Dec(C);
dp[C] = max(dp[C], Leaf_cnt[C] + dp[c]);
}
}
return Ans;
}
void solve() {
Update_parents();
Basic_dfs(0);
Add_Extra_Edges();
Comp_Decomp();
Find_ans();
Making_comp_tree();
Making_Topol_Set();
cout << Updating();
}
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
input();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[2][1000005], isLeaf[1000005];
vector<int> g[1000005];
int tag[50];
int dfs(int u, int lev, int k) {
if (g[u].size() == 0) {
isLeaf[u] = 1;
return lev;
}
int mn = 1000005, ret = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
mn = min(mn, dfs(v, lev + 1, k));
if (!isLeaf[v]) {
dp[1][u] += dp[1][v];
ret = max(ret, dp[0][v] - dp[1][v]);
} else
dp[1][u] += 1;
}
dp[0][u] = dp[1][u] + ret;
dp[1][u] = ((mn - lev) < k) * dp[1][u];
return mn;
}
int main() {
int i, j, k, l, m, n;
scanf("%d %d", &n, &k);
for (i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
g[p].push_back(i);
}
int cnt = 1;
dfs(1, 0, k);
int ans = dp[0][1];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 2e6 + 9;
vector<int> g[MAXN];
int n, k;
int dp[MAXN], minDepth[MAXN], depth[MAXN], leaf[MAXN];
void dfs(int node, int par) {
if (node != par) depth[node] = 1 + depth[par];
if (node != par && g[node].size() == 1) {
minDepth[node] = depth[node] - k, leaf[node]++;
}
int mx = 0;
for (auto child : g[node]) {
if (child == par) continue;
dfs(child, node);
if (minDepth[child] <= depth[node]) {
minDepth[node] = min(minDepth[node], minDepth[child]);
leaf[node] += leaf[child];
}
}
}
void solve(int node, int par) {
dp[node] = (node != par && g[node].size() == 1);
for (auto child : g[node]) {
if (child == par) continue;
solve(child, node);
int tmp = leaf[node];
if (minDepth[child] <= depth[node]) {
tmp -= leaf[child];
}
dp[node] = max(dp[node], tmp + dp[child]);
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> k;
for (int u = 2; u <= n; u++) {
int v;
cin >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i <= n + 9; i++) minDepth[i] = 1e9;
dfs(1, 1);
solve(1, 1);
cout << dp[1];
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using ii = pair<int, int>;
using ll = long long;
using db = long double;
using PT = pair<ll, ll>;
const int N = 1e6 + 5, K = 105, MOD = 1e9 + 7;
const ll MX = 1e15;
bool leaf[N];
vector<int> adj[N];
int n, k;
struct num {
int goUp, retVal, nonRetVal;
num() {}
};
num dfs(int u) {
num ret;
if (leaf[u]) {
ret.goUp = k;
ret.retVal = 1;
ret.nonRetVal = 1;
return ret;
}
vector<num> canReturn;
vector<num> canNotReturn;
for (auto v : adj[u]) {
auto x = dfs(v);
x.goUp--;
if (x.goUp >= 0) {
canReturn.push_back(x);
} else
canNotReturn.push_back(x);
}
ret.goUp = 0;
ret.retVal = 0;
ret.nonRetVal = 0;
for (auto x : canReturn) {
ret.goUp = max(x.goUp, ret.goUp);
ret.retVal += x.retVal;
}
ret.nonRetVal = ret.retVal;
int mx = 0;
for (auto x : canNotReturn) {
mx = max(mx, x.nonRetVal);
}
ret.nonRetVal += mx;
for (auto x : canReturn) {
ret.nonRetVal = max(ret.nonRetVal, ret.retVal - x.retVal + x.nonRetVal);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(leaf, 1, sizeof leaf);
cin >> n >> k;
for (int i = 2, p; i <= n; i++) {
cin >> p;
leaf[p] = false;
adj[p].push_back(i);
}
auto ans = dfs(1);
cout << ans.nonRetVal << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e6;
vector<int> g[MAXN + 1];
pair<int, int> arr[MAXN + 1];
int k;
void dfs(int nod, int par, int lvl) {
arr[nod] = {2 * MAXN, 0};
for (auto it : g[nod]) {
if (it != par) {
dfs(it, nod, lvl + 1);
if (lvl >= arr[it].first) {
arr[nod].first = min(arr[nod].first, arr[it].first);
arr[nod].second += arr[it].second;
}
}
}
if (g[nod].size() == 0) {
arr[nod] = {lvl - k, 1};
}
}
int dp[MAXN + 1];
void dfs1(int nod, int par, int lvl) {
dp[nod] = (g[nod].size() == 0);
for (auto it : g[nod]) {
if (it != par) {
dfs1(it, nod, lvl + 1);
int cur = arr[nod].second;
if (lvl >= arr[it].first) {
cur -= arr[it].second;
}
dp[nod] = max(dp[nod], cur + dp[it]);
}
}
}
int main() {
int i, n, x, y;
ios::sync_with_stdio(false);
cin >> n >> k;
for (i = 2; i <= n; i++) {
cin >> x;
g[x].push_back(i);
}
dfs(1, 0, 1);
dfs1(1, 0, 1);
cout << dp[1];
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const int N = 1e6 + 7;
const int INF = 1e9 + 7;
pair<int, int> dp[N];
int val[N];
int p[N], h[N];
int n, k, ans;
vector<int> g[N];
void calc(int v) {
h[v] = h[p[v]] + 1;
if (g[v].size() == 0) {
dp[v].first = val[v] = 1;
dp[v].second = h[v] - k;
} else
dp[v].second = INF;
for (int to : g[v]) {
calc(to);
if (dp[to].second <= h[v]) dp[v].first += dp[to].first;
dp[v].second = min(dp[v].second, dp[to].second);
}
for (int to : g[v]) {
if (dp[to].second <= h[v])
val[v] = max(val[v], dp[v].first - dp[to].first + val[to]);
else
val[v] = max(val[v], dp[v].first + val[to]);
}
ans = max(ans, val[v]);
}
int main() {
cin >> n >> k;
for (int i = 2; i <= n; i++) {
scanf("%d", &p[i]);
g[p[i]].push_back(i);
}
calc(1);
cout << ans;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T>
void uin(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
void uax(T &a, T b) {
if (b > a) a = b;
}
const long long maxn = 1000 * 1000 + 228;
long long n, k;
long long dp[maxn], p[maxn];
long long dpret[maxn], hret[maxn];
vector<long long> g[maxn];
void dfs(long long v, long long deep = 0) {
hret[v] = deep;
if ((long long)g[v].size() == 1 && v != 1) {
dp[v] = 1;
dpret[v] = 1;
hret[v] = max(0LL, deep - k);
} else {
for (long long to : g[v]) {
if (to != p[v]) {
dfs(to, deep + 1);
if (hret[to] <= deep) {
dpret[v] += dpret[to];
uin(hret[v], hret[to]);
}
}
}
dp[v] = dpret[v];
for (long long to : g[v]) {
if (to != p[v]) {
if (hret[to] <= deep) {
uax(dp[v], dp[to] + dpret[v] - dpret[to]);
} else {
uax(dp[v], dp[to] + dpret[v]);
}
}
}
}
}
void solve() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (long long i = 2; i <= n; ++i) {
cin >> p[i];
g[i].push_back(p[i]);
g[p[i]].push_back(i);
}
dfs(1);
cout << dp[1] << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
const int inf = 0x3f3f3f3f;
vector<int> g[maxn];
int n, k;
pair<int, int> dp_ret[maxn];
int dp_to[maxn], dep[maxn], ans;
void dfs(int u) {
dp_ret[u] = pair<int, int>(0, inf);
dp_to[u] = 0;
if (g[u].size() == 0) {
dp_ret[u] = pair<int, int>(1, dep[u]);
dp_to[u] = 1;
}
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
dep[v] = dep[u] + 1;
dfs(v);
if (dp_ret[v].second - k <= dep[u]) {
dp_ret[u].first += dp_ret[v].first;
dp_ret[u].second = min(dp_ret[u].second, dp_ret[v].second);
}
}
dp_to[u] = dp_ret[u].first;
int sum = dp_ret[u].first;
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
if (dp_ret[v].second - k <= dep[u]) {
dp_to[u] = max(dp_to[u], sum - dp_ret[v].first + dp_to[v]);
} else {
dp_to[u] = max(dp_to[u], sum + dp_to[v]);
}
}
ans = max(ans, dp_to[u]);
}
int main() {
int p;
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
scanf("%d", &p);
g[p].push_back(i);
}
dfs(1);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const int N = 1e6 + 10;
const int INF = INT_MAX;
const int MAXLOG = 20;
const int MOD = 1e9 + 7;
int n, k, par[N], cnt[N], dp[N], c = 1, cmp[N];
vector<int> in[N], out[N], in1[N], out1[N], path, fn, f;
bool mark[N], lf[N];
void Dfs(int v) {
mark[v] = 1;
if (v != 1) {
int sz = path.size();
par[v] = path[max((int)path.size() - k, 0)];
}
if (out[v].size() == 0) lf[v] = 1;
path.push_back(v);
for (auto u : out[v])
if (!mark[u]) Dfs(u);
path.pop_back();
}
void DFS(int v) {
mark[v] = 1;
for (int u : out[v])
if (!mark[u]) DFS(u);
fn.push_back(v);
}
void SDF(int v) {
cmp[v] = c;
for (int u : in[v])
if (cmp[u] == 0) SDF(u);
}
void ftime(int v) {
mark[v] = 1;
for (int u : out1[v])
if (!mark[u]) ftime(u);
f.push_back(v);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int x;
cin >> x;
in[i].push_back(x);
out[x].push_back(i);
}
Dfs(1);
for (int i = 1; i <= n; i++)
if (lf[i]) in[par[i]].push_back(i), out[i].push_back(par[i]);
memset(mark, 0, sizeof mark);
for (int i = 1; i <= n; i++)
if (!mark[i]) DFS(i);
reverse(fn.begin(), fn.end());
for (int i : fn)
if (!cmp[i]) SDF(i), c++;
for (int i = 1; i <= n; i++)
for (int j : out[i])
if (cmp[i] != cmp[j])
in1[cmp[j]].push_back(cmp[i]), out1[cmp[i]].push_back(cmp[j]);
for (int i = 1; i <= n; i++)
if (lf[i]) cnt[cmp[i]]++;
dp[1] = cnt[1];
memset(mark, 0, sizeof mark);
ftime(1);
reverse(f.begin(), f.end());
for (int u : f)
for (int v : out1[u]) dp[v] = max(dp[u] + cnt[v], dp[v]);
cout << *max_element(dp, dp + n + 1);
return 0;
}
|
#include <bits/stdc++.h>
using std::max;
using std::min;
using std::queue;
using std::stack;
const int N = 1e6 + 10;
const int M = N << 2;
const int LOGN = 22;
void file(const char *str) {
char in[100], out[100];
sprintf(in, "%s.in", str), sprintf(out, "%s.out", str);
freopen(in, "r", stdin), freopen(out, "w", stdout);
}
const int _IB = 1e6;
char _ibuf[_IB], *_s, *_t;
long long read() {
long long a = 0;
int op = 1;
char ch =
(_s == _t && (_t = (_s = _ibuf) + fread(_ibuf, 1, _IB, stdin), _s == _t)
? EOF
: *_s++);
while (ch < '0' || '9' < ch) {
if (ch == '-') op = -1;
ch =
(_s == _t && (_t = (_s = _ibuf) + fread(_ibuf, 1, _IB, stdin), _s == _t)
? EOF
: *_s++);
}
while ('0' <= ch && ch <= '9') {
a = (a << 3) + (a << 1) + (48 ^ ch);
ch =
(_s == _t && (_t = (_s = _ibuf) + fread(_ibuf, 1, _IB, stdin), _s == _t)
? EOF
: *_s++);
}
return a * op;
}
struct L {
int to, next;
};
struct Graph {
L l[M];
int head[N];
int lcount;
} g[2];
void add(Graph &g, int from, int to) {
g.l[++g.lcount].to = to;
g.l[g.lcount].next = g.head[from];
g.head[from] = g.lcount;
}
int n, k;
int f[N][LOGN];
long long value[N];
int low[N];
int dfn[N];
int dfn_count;
int color[N];
int color_count;
int sum[N];
long long dp[N];
long long ans;
stack<int> s;
bool is_in[N];
int in[N];
void build(int now = 1) {
for (int i = 1; i < LOGN; i++) f[now][i] = f[f[now][i - 1]][i - 1];
for (int i = g[0].head[now], to; to = g[0].l[i].to, i; i = g[0].l[i].next) {
f[to][0] = now;
build(to);
}
if (!g[0].head[now]) {
value[now] = 1;
int x = now;
for (int i = 0; i < LOGN; i++)
if (k & (1 << i)) x = f[x][i];
add(g[0], now, max(1, x));
}
}
void dfs(int now) {
is_in[now] = 1;
low[now] = dfn[now] = ++dfn_count;
s.push(now);
for (int i = g[0].head[now], to; to = g[0].l[i].to, i; i = g[0].l[i].next) {
if (!dfn[to]) {
dfs(to);
low[now] = min(low[now], low[to]);
} else if (is_in[to]) {
low[now] = min(low[now], dfn[to]);
}
}
if (dfn[now] == low[now]) {
++color_count;
while (1) {
is_in[s.top()] = 0;
color[s.top()] = color_count;
if (s.top() == now) {
s.pop();
break;
}
s.pop();
}
}
}
void make() {
for (int i = 1; i <= n; i++) {
sum[color[i]] += value[i];
for (int j = g[0].head[i], to; to = g[0].l[j].to, j; j = g[0].l[j].next) {
if (color[i] != color[to]) {
add(g[1], color[i], color[to]);
in[color[to]]++;
}
}
}
}
void DAG() {
queue<int> q;
for (int i = 1; i <= color_count; i++) {
if (!in[i]) {
dp[i] = sum[i];
q.push(i);
}
}
int now;
while (!q.empty()) {
now = q.front();
q.pop();
for (int i = g[1].head[now], to; to = g[1].l[i].to, i; i = g[1].l[i].next) {
in[to]--;
if (!in[to]) {
q.push(to);
}
dp[to] = max(dp[to], dp[now] + sum[to]);
}
}
}
void input() {
n = read();
k = read();
for (int i = 2; i <= n; i++) add(g[0], read(), i);
}
void ini() {}
void solve() {
build();
dfs(1);
make();
DAG();
for (int i = 1; i <= color_count; i++) ans = max(ans, dp[i]);
}
void output() { printf("%lld\n", ans); }
void test() {
input();
ini();
solve();
output();
}
void all() {
file("J");
test();
}
int main() {
test();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
vector<bool> leaf(n, true), pa(n, -1);
vector<vector<int>> g(n);
for (int i = 1; i < n; i++) {
int x;
cin >> x;
x--;
pa[i] = x;
leaf[x] = false;
g[x].push_back(i);
}
vector<int> once(n), many(n);
vector<int> arm(n);
function<void(int)> dfs = [&](int u) {
if (leaf[u]) {
once[u] = many[u] = 1;
return;
}
arm[u] = 1e8;
int delta = 0;
for (int v : g[u]) {
dfs(v);
arm[u] = min(arm[u], arm[v] + 1);
many[u] += many[v];
delta = max(delta, once[v] - many[v]);
}
once[u] = many[u] + delta;
if (arm[u] >= k) many[u] = 0;
};
dfs(0);
cout << once[0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int inf = 1000000007;
int k;
int dp[1000000 + 50];
vector<int> adj[1000000 + 50];
int h[1000000 + 50];
pair<int, int> p[1000000 + 50];
void hei(int v, int par, int curh) {
h[v] = curh;
for (auto bc : adj[v]) {
if (bc == par) continue;
hei(bc, v, curh + 1);
}
}
void pre(int v, int par) {
p[v] = make_pair(inf, 0);
for (auto bc : adj[v]) {
if (bc == par) continue;
h[bc] = h[v] + 1;
pre(bc, v);
if (p[bc].first <= h[v]) {
p[v].second += p[bc].second;
p[v].first = min(p[v].first, p[bc].first);
}
}
if (adj[v].size() == 1 && v != 1) {
p[v] = make_pair(h[v] - k, 1);
}
}
void calc(int v, int par) {
dp[v] = (v >= 1 && adj[v].size() == 1);
for (auto bc : adj[v]) {
if (bc == par) continue;
calc(bc, v);
int tmp = p[v].second;
if (p[bc].first <= h[v]) tmp -= p[bc].second;
dp[v] = max(dp[v], tmp + dp[bc]);
}
}
int main() {
ios::sync_with_stdio(false);
int n, x;
cin >> n >> k;
for (int i = 2; i <= n; i++) {
cin >> x;
adj[i].push_back(x);
adj[x].push_back(i);
}
pre(1, 0);
calc(1, 0);
cout << dp[1];
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int inf = 0x3f3f3f3f;
struct Edge {
int to, nxt;
} E[maxn << 1];
int n, k;
int head[maxn], cnt;
void addedge(int u, int v) {
E[++cnt].to = v;
E[cnt].nxt = head[u];
head[u] = cnt;
}
int dp[maxn];
int step[maxn];
int siz[maxn];
void dfs(int u, int fa) {
step[u] = inf;
for (int i = head[u]; i; i = E[i].nxt) {
int v = E[i].to;
if (v == fa) continue;
dfs(v, u);
siz[u] += siz[v];
step[u] = min(step[u], step[v] + 1);
dp[u] = max(dp[u], dp[v] - siz[v]);
}
dp[u] += siz[u];
if (step[u] == inf) dp[u] = siz[u] = 1, step[u] = 0;
if (step[u] >= k) siz[u] = 0;
}
int main() {
scanf("%d%d", &n, &k);
for (int p, i = 2; i <= n; i++) {
scanf("%d", &p);
addedge(p, i);
}
dfs(1, 0);
printf("%d", dp[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000006;
int n, k, p[N];
vector<int> g[N];
int st[N], pt;
int cnt[N];
int prec(int u) {
st[pt++] = u;
int ans = N - 1;
for (int v : g[u]) ans = min(ans, prec(v));
if (g[u].empty()) {
cnt[st[max(0, pt - k - 1)]]++;
st[pt--] = N - 1;
return max(0, pt - k);
}
if (ans < pt - 1) {
cnt[st[ans]] += cnt[u];
cnt[u] = 0;
}
st[pt--] = N - 1;
return ans;
}
int f(int u) {
int ans = 0;
for (int v : g[u]) ans = max(ans, f(v));
return ans + cnt[u];
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 2; i <= n; i++) {
scanf("%d", p + i);
g[p[i]].push_back(i);
}
prec(1);
printf("%d\n", f(1));
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const long long inf = 1e18;
int n, K;
vector<int> gg[maxn];
int a[maxn], c[maxn];
int par[maxn][20], h[maxn];
vector<int> g[maxn], g1[maxn], bg[maxn];
int com[maxn];
void dfs_par(int v) {
for (int i = 1; (1 << i) <= h[v]; i++) par[v][i] = par[par[v][i - 1]][i - 1];
for (auto u : gg[v])
if (u != par[v][0]) {
par[u][0] = v;
h[u] = h[v] + 1;
g[v].push_back(u);
bg[u].push_back(v);
dfs_par(u);
}
}
int get_par(int v, int he) {
he = min(he, h[v]);
int i = 0;
while (he) {
if (he & 1) v = par[v][i];
i++;
he >>= 1;
}
return v;
}
vector<int> ord;
bool mark[maxn];
void dfs(int v) {
mark[v] = 1;
for (auto u : g[v])
if (!mark[u]) dfs(u);
ord.push_back(v);
}
void bdfs(int v, int k) {
mark[v] = 1;
com[v] = k;
for (auto u : bg[v])
if (!mark[u]) bdfs(u, k);
}
void dfs_topol(int v) {
mark[v] = 1;
for (auto u : g1[v])
if (!mark[u]) dfs_topol(u);
ord.push_back(v);
}
int mx[maxn];
void get_scc() {
for (int v = 1; v <= n; v++)
if (!mark[v]) dfs(v);
memset(mark, 0, sizeof mark);
int k = 0;
while (ord.size()) {
int v = ord.back();
ord.pop_back();
if (!mark[v]) {
k++;
bdfs(v, k);
}
}
memset(mark, 0, sizeof mark);
for (int v = 1; v <= n; v++) {
for (auto u : g[v])
if (com[v] != com[u]) g1[com[v]].push_back(com[u]);
c[com[v]] += a[v];
}
for (int v = 1; v <= k; v++)
if (!mark[v]) dfs_topol(v);
int ans = 0;
for (auto v : ord) {
mx[v] = c[v];
for (auto u : g1[v]) mx[v] = max(mx[v], mx[u] + c[v]);
}
cout << mx[com[1]];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> K;
for (int u = 2; u <= n; u++) {
int v;
cin >> v;
gg[u].push_back(v);
gg[v].push_back(u);
}
dfs_par(1);
for (int v = 1; v <= n; v++) {
if (gg[v].size() != 1) continue;
if (v != 1) a[v] = 1;
int u = get_par(v, K);
g[v].push_back(u);
bg[u].push_back(v);
}
get_scc();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
int h[N], f[N], g[N], cnt, n, m, dep[N], dp[N];
struct nod {
int nxt, to;
} e[N];
inline bool isdigit(const char &ch) { return (ch >= '0' && ch <= '9'); }
inline int read() {
register int s = 0;
register bool m = false;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') m = true;
ch = getchar();
}
while (isdigit(ch)) s = (s << 1) + (s << 3) + (ch ^ 48), ch = getchar();
return m ? -s : s;
}
inline void add(const int &u, const int &v) {
e[++cnt] = (nod){h[u], v};
h[u] = cnt;
}
inline void _SOL(const int &u, const int &fa) {
dep[u] = dep[fa] + 1;
if (!h[u]) {
g[u] = dep[u];
f[u] = 1;
return;
}
for (register int i = h[u]; i; i = e[i].nxt) {
register int v = e[i].to;
_SOL(v, u);
if (!g[u])
g[u] = g[v];
else
g[u] = min(g[v], g[u]);
if (g[v] - dep[u] <= m) f[u] += f[v];
}
}
inline void __SOL(const int &u) {
dp[u] = f[u];
for (register int i = h[u]; i; i = e[i].nxt) {
register int v = e[i].to;
__SOL(v);
dp[u] = max(dp[u], dp[v] + f[u] - (g[v] - dep[u] <= m ? f[v] : 0));
}
}
signed main(int _lzh, char const *__lzh[]) {
n = read(), m = read();
for (register int i = 2; i <= n; ++i) add(read(), i);
_SOL(1, 0);
__SOL(1);
printf("%d\n", dp[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
bool f = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return f ? -x : x;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(long long x) {
write(x);
puts("");
}
void writep(long long x) {
write(x);
putchar(' ');
}
long long const N = 1e6 + 3;
long long const inf = 1e9;
long long n, k, cnt, ans, vis[N], h[N], dep[N], sz[N], mn[N];
struct edge {
long long nt, to;
} e[N];
void add(long long x, long long y) {
e[++cnt] = (edge){h[x], y};
h[x] = cnt;
}
void dfs1(long long x, long long d) {
dep[x] = d;
mn[x] = inf;
if (!vis[x]) mn[x] = d;
for (long long i = h[x]; i; i = e[i].nt) {
long long v = e[i].to;
dfs1(v, d + 1);
mn[x] = min(mn[x], mn[v]);
}
}
void dfs2(long long x) {
if (!vis[x]) sz[x] = 1;
for (long long i = h[x]; i; i = e[i].nt) {
long long v = e[i].to;
dfs2(v);
if (mn[v] - dep[x] <= k) {
sz[x] += sz[v];
sz[v] = 0;
}
}
}
long long dfs(long long x) {
long long res = 0;
for (long long i = h[x]; i; i = e[i].nt) {
long long v = e[i].to;
res = max(res, dfs(v));
}
return res + sz[x];
}
signed main() {
n = read();
k = read();
for (long long i = 2; i <= n; i++) {
long long x = read();
add(x, i);
vis[x] = 1;
}
dfs1(1, 0);
dfs2(1);
writeln(dfs(1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class I>
inline void ckMax(I& p, I q) {
p = (p > q ? p : q);
}
template <class I>
inline void ckMin(I& p, I q) {
p = (p < q ? p : q);
}
template <class I>
inline I Min(I p, I q) {
return p < q ? p : q;
}
template <class I>
inline I Max(I p, I q) {
return p > q ? p : q;
}
template <class I>
inline void sp(I& p, I& q) {
I x = p;
p = q, q = x;
}
const int N = 1000005;
int n, h[N], nxt[N], adj[N], t, k, fa[N], f[N], g[N], a[N], d[N];
inline void add(const int u, const int v) {
nxt[++t] = h[u], h[u] = t, adj[t] = v;
};
inline void dfs(const int x) {
if (!h[x]) return f[x] = a[x] = 1, d[x] = 0, void();
d[x] = 1e9;
for (register int i = h[x], j; i; i = nxt[i])
dfs(j = adj[i]), ckMin(d[x], d[j] + 1), ckMax(f[x], f[j] - a[j]),
a[x] += a[j];
f[x] += a[x];
if (d[x] >= k) a[x] = 0;
}
int main() {
scanf("%d%d", &n, &k);
register int i;
for (i = 2; i <= n; ++i) scanf("%d", &fa[i]), add(fa[i], i);
dfs(1), printf("%d", f[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int cons;
long long int check(long long int a) {
if (a >= cons) a %= cons;
return a;
}
long long int check2(long long int a) {
a %= cons;
if (a < 0) a += cons;
return a;
}
long long int fast_check(long long int a) {
if (a >= cons) a -= cons;
return a;
}
long long int GCD(long long int a, long long int b) {
while (a && b) {
a = a % b;
if (a != 0) b = b % a;
}
return a + b;
}
long long int exp(long long int a, long long int n) {
long long int ans = 1;
a = check(a);
while (n) {
if (n & 1) ans = check(ans * a);
a = check(a * a);
n = (n >> 1);
}
return ans;
}
void print_pair(pair<int, int> p) {
cout << p.first << " " << p.second << endl;
}
long long int nc2(long long int a) { return (a * (a - 1)) / 2; }
const int N = 1e6 + 10;
int pa[21][N];
int direct[N];
int accu[N];
int sink[N];
int k, n;
bool isparent[N];
vector<int> graph[N];
int leaf[N];
int lift(int i, int k) {
for (int j = 20; j >= 0; j--) {
if ((1 << j) <= k && pa[j][i]) {
i = pa[j][i];
k -= (1 << j);
}
}
assert(i > 0);
return i;
}
void leafy(int i) {
leaf[i] = 1e9;
for (auto itr : graph[i]) {
leafy(itr);
leaf[i] = min(leaf[i], leaf[itr] + 1);
}
if (leaf[i] == 1e9) leaf[i] = 0;
}
void dfs(int i) {
for (auto itr : graph[i]) {
dfs(itr);
if (leaf[itr] < k) {
accu[i] += accu[itr];
sink[i] = max(sink[i], sink[itr] - accu[itr]);
} else
sink[i] = max(sink[i], sink[itr]);
}
accu[i] += direct[i];
sink[i] += accu[i];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cons = 1e9 + 7;
srand(time(NULL));
cin >> n >> k;
for (int i = 2; i <= n; i++) {
cin >> pa[0][i];
isparent[pa[0][i]] = true;
graph[pa[0][i]].push_back(i);
}
for (int i = 1; i <= 20; i++)
for (int j = 1; j <= n; j++) pa[i][j] = pa[i - 1][pa[i - 1][j]];
for (int i = n; i >= 1; i--)
if (!isparent[i]) direct[lift(i, k)]++;
leafy(1);
dfs(1);
cout << max(accu[1], sink[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> t[1000000];
int dp[1000000];
int up[1000000];
int val[1000000];
int n, k;
void dfs(int cur, int h) {
for (int i = 0; i < t[cur].size(); i++) dfs(t[cur][i], h + 1);
if (t[cur].size() == 0) {
up[cur] = max(0, h - k);
val[cur] = 1;
dp[cur] = 1;
} else {
int all = 0;
up[cur] = h;
for (int i = 0; i < t[cur].size(); i++) {
up[cur] = min(up[cur], up[t[cur][i]]);
if (up[t[cur][i]] <= h) val[cur] += val[t[cur][i]];
}
for (int i = 0; i < t[cur].size(); i++) {
int mm = 0;
if (up[t[cur][i]] <= h) mm = val[t[cur][i]];
dp[cur] = max(dp[cur], val[cur] - mm + dp[t[cur][i]]);
}
}
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) up[i] = 2000000000;
for (int i = 0; i < n - 1; i++) {
int tmp;
scanf("%d", &tmp);
t[tmp - 1].push_back(i + 1);
}
dfs(0, 0);
printf("%d\n", dp[0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 9.2e18;
const int maxn = 1e6 + 70;
const int INF = 2.1e9;
const int maxm = 1e6 + 70;
const int MOD = 1e9 + 7;
const double eps = 1e-7;
const double PI = acos(-1.0);
int n, m, k;
int fa[maxn], anc[maxn][26], dep[maxn], mind[maxn], top[maxn], cnt[maxn];
vector<int> G[maxn];
void dfs(int u) {
if (!G[u].size())
mind[u] = dep[u];
else {
mind[u] = INF;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
dep[v] = dep[u] + 1;
dfs(v);
mind[u] = min(mind[u], mind[v]);
}
}
}
void dfs2(int u) {
if (!G[u].size()) {
int fk;
if (dep[u] <= k)
fk = 1;
else {
fk = u;
int c = 0, t = k;
while (t) {
if (t & 1) fk = anc[fk][c];
t >>= 1;
c++;
}
}
top[u] = top[fk];
cnt[top[u]]++;
} else {
if (mind[u] - k >= dep[u])
top[u] = u;
else {
int fk, t = k - mind[u] + dep[u];
if (dep[u] <= t)
fk = 1;
else {
fk = u;
int c = 0;
while (t) {
if (t & 1) fk = anc[fk][c];
t >>= 1;
c++;
}
}
top[u] = top[fk];
}
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
dfs2(v);
}
}
}
int solve(int u) {
int ans = 0;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
ans = max(ans, solve(v));
}
ans += cnt[u];
return ans;
}
void bfs() {
queue<int> Q;
Q.push(1);
int now = 0;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
if (dep[u] > now) {
cout << endl;
now = dep[u];
}
cout << u << " ";
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
Q.push(v);
}
}
cout << endl;
}
int main() {
while (cin >> n >> k) {
for (int i = 0; i <= n; i++) G[i].clear();
fa[1] = -1;
for (int i = 2; i <= n; i++) {
scanf("%d", &fa[i]);
G[fa[i]].push_back(i);
}
dep[1] = 0;
dfs(1);
for (int i = 1; i <= n; i++) {
anc[i][0] = fa[i];
for (int j = 1; (1 << j) < n; j++) anc[i][j] = -1;
}
for (int j = 1; (1 << j) < n; j++) {
for (int i = 1; i <= n; i++) {
if (anc[i][j - 1] != -1) {
anc[i][j] = anc[anc[i][j - 1]][j - 1];
}
}
}
memset(cnt, 0, (n + 1) * sizeof(int));
top[1] = 1;
dfs2(1);
int ans = solve(1);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, p, dp[1000005], deep[1000005], leaf[1000005], k;
vector<long long> a[1000005];
void dfs(long long u) {
if (a[u].size() == 0) {
deep[u] = 0;
leaf[u] = 1;
dp[u] = 1;
return;
}
deep[u] = 1e9;
for (long long j = (0); j <= (a[u].size() - 1); ++j) {
long long v = a[u][j];
dfs(v);
if (deep[v] < k) leaf[u] += leaf[v];
deep[u] = min(deep[u], deep[v] + 1);
}
for (long long j = (0); j <= (a[u].size() - 1); ++j) {
long long v = a[u][j], tmp = dp[v];
if (deep[v] < k) tmp -= leaf[v];
dp[u] = max(dp[u], tmp + leaf[u]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = (2); i <= (n); ++i) {
cin >> p;
a[p].push_back(i);
}
dfs(1);
cout << dp[1];
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
int n, k, tot, head[MAXN + 5], f[MAXN + 5], g[MAXN + 5], closest[MAXN + 5];
bool vis[MAXN + 5];
struct Edge {
int next, to;
} e[MAXN + 5];
inline void addEdge(int u, int v) {
e[++tot] = (Edge){head[u], v};
head[u] = tot;
}
void dfs(int u) {
if (!vis[u]) {
f[u] = g[u] = 1;
return;
}
closest[u] = n;
for (int v, i = head[u]; v = e[i].to, i; i = e[i].next) {
dfs(v);
closest[u] = min(closest[u], closest[v] + 1);
if (closest[v] + 1 > k) g[v] = 0;
g[u] += g[v];
f[u] = max(f[u], f[v] - g[v]);
}
f[u] += g[u];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int x, i = 1; i < n; ++i) {
cin >> x;
addEdge(x, i + 1);
vis[x] = 1;
}
dfs(1);
cout << f[1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = (1e6) + 10, mod = 1e9 + 7;
long long int n, k, lf[maxn], h[maxn], dp[maxn], pd[maxn];
vector<long long int> G[maxn], v1, v2;
void pre_DFS(long long int v) {
for (long long int u : G[v]) {
h[u] = h[v] + 1;
pre_DFS(u);
}
}
void DFS(long long int v) {
if (!G[v].size()) {
lf[v] = h[v], dp[v] = pd[v] = 1;
return;
} else
lf[v] = mod;
for (long long int u : G[v]) {
DFS(u);
lf[v] = min(lf[v], lf[u]);
}
for (long long int u : G[v])
if (lf[u] - k <= h[v]) dp[v] += dp[u];
pd[v] = dp[v];
for (long long int u : G[v]) {
if (lf[u] - k <= h[v])
pd[v] = max(pd[v], dp[v] + (pd[u] - dp[u]));
else
pd[v] = max(pd[v], dp[v] + pd[u]);
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long int i = 2; i <= n; i++) {
long long int x;
cin >> x;
G[x].push_back(i);
}
pre_DFS(1);
DFS(1);
cout << pd[1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt;
int head[2000005], vet[2000005], Next[2000005];
int d[2000005], f[2000005], g[2000005], len[2000005];
void add(int x, int y) {
cnt++;
Next[cnt] = head[x];
head[x] = cnt;
vet[cnt] = y;
}
void dfs(int x, int fa) {
d[x] = d[fa] + 1;
len[x] = 0x3f3f3f3f, f[x] = 0;
int tot = 0;
for (int i = head[x]; i; i = Next[i]) {
int v = vet[i];
if (v == fa) continue;
tot++;
dfs(v, x);
len[x] = min(len[x], len[v]);
if (len[v] - d[x] > m) g[v] = 0;
f[x] = max(f[x], f[v] - g[v]);
g[x] += g[v];
}
if (!tot)
len[x] = d[x], g[x] = f[x] = 1;
else
f[x] += g[x];
}
int main() {
cin >> n >> m;
int x;
for (int i = 2; i <= n; i++) {
scanf("%d", &x);
add(x, i);
}
dfs(1, 0);
cout << f[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxd = 1e9 + 7;
struct node {
int to, nxt;
} sq[2001000];
int n, k, head[1001000], all = 0, dp[1001000], dis[1001000], back[1001000];
int read() {
int x = 0, f = 1;
char ch = getchar();
while ((ch < '0') || (ch > '9')) {
if (ch == '-') f = -1;
ch = getchar();
}
while ((ch >= '0') && (ch <= '9')) {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * f;
}
void add(int u, int v) {
all++;
sq[all].to = v;
sq[all].nxt = head[u];
head[u] = all;
}
void dfs(int u, int fa) {
dis[u] = maxd;
int i;
for (i = head[u]; i; i = sq[i].nxt) {
int v = sq[i].to;
if (v == fa) continue;
dfs(v, u);
dis[u] = min(dis[u], dis[v] + 1);
back[u] += back[v];
dp[u] = max(dp[u], dp[v] - back[v]);
}
dp[u] += back[u];
if (dis[u] == maxd) {
dis[u] = 0;
dp[u] = back[u] = 1;
}
if (dis[u] >= k) back[u] = 0;
}
int main() {
n = read();
k = read();
int i;
for (i = 2; i <= n; i++) {
int v = read();
add(i, v);
add(v, i);
}
memset(dp, 0, sizeof(dp));
memset(dis, 0, sizeof(dis));
memset(back, 0, sizeof(back));
dfs(1, 0);
printf("%d", dp[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int n, k, a[1000100], dp[1000100], up[1000100], dep[1000100], f[1000100];
int st[1000100], top;
vector<int> G[1000100], leaf;
void dfs0(int u) {
for (auto v : G[u]) {
dep[v] = dep[u] + 1;
f[v] = u;
dfs0(v);
}
}
void dfs1(int u) {
if (G[u].empty()) {
a[u] = 1;
--a[up[u]];
}
for (auto v : G[u]) {
dfs1(v);
a[u] += a[v];
}
--top;
}
void dfs2(int u) {
if (G[u].empty()) {
dp[u] = 1;
return;
}
int sum = 0;
for (auto v : G[u]) {
dfs2(v);
sum += a[v];
}
for (auto v : G[u]) {
dp[u] = max(dp[u], sum - a[v] + dp[v]);
}
}
int main() {
n = read(), k = read();
for (int i = 2; i <= n; ++i) {
int fa = read();
G[fa].push_back(i);
}
dfs0(1);
for (int i = 1; i <= n; ++i) {
if (G[i].empty()) leaf.push_back(i);
}
sort(leaf.begin(), leaf.end(), [&](int i, int j) { return dep[i] < dep[j]; });
memset(up, 255, sizeof(up));
up[0] = 0;
for (auto x : leaf) {
int u = x, tmp = 0;
for (int i = 1; i <= k; ++i) {
u = f[u];
tmp = u;
if (~up[u]) {
tmp = up[u];
break;
}
}
up[x] = tmp;
u = x;
for (int i = 1; i <= k; ++i) {
u = f[u];
if (~up[u]) break;
up[u] = tmp;
}
}
dfs1(1);
dfs2(1);
printf("%d\n", dp[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000100;
const int M = 20;
vector<int> g[N];
vector<int> gr[N];
vector<int> ord;
int sp[N][M];
int tin[N];
int tout[N];
int timer;
void pre_dfs(int v, int p = -1) {
sp[v][0] = (p == -1 ? v : p);
for (int i = 1; i < M; i++) {
sp[v][i] = sp[sp[v][i - 1]][i - 1];
}
tin[v] = timer++;
for (int to : g[v]) {
pre_dfs(to, v);
}
tout[v] = timer++;
}
inline bool anc(int u, int v) {
return (tin[u] <= tin[v] && tout[u] >= tout[v]);
}
int get_par(int v, int k) {
for (int i = 0; i < M; i++) {
if ((k >> i) & 1) {
v = sp[v][i];
}
}
return v;
}
bool mark[N];
void dfs1(int v) {
mark[v] = 1;
for (int to : g[v]) {
if (!mark[to]) {
dfs1(to);
}
}
ord.push_back(v);
}
bool good[N];
int comp[N];
int val[N];
int cur;
void dfs2(int v) {
comp[v] = cur;
val[cur] += good[v];
for (int to : gr[v]) {
if (comp[to] == -1) {
dfs2(to);
}
}
}
int dp[N];
int dfs_end(int v) {
if (dp[v] != -1) return dp[v];
dp[v] = val[v];
for (int to : g[v]) {
dp[v] = max(dp[v], dfs_end(to) + val[v]);
}
return dp[v];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<pair<int, int>> ed;
for (int i = 1; i < n; i++) {
int p;
cin >> p;
--p;
g[p].push_back(i);
gr[i].push_back(p);
ed.emplace_back(p, i);
}
pre_dfs(0);
for (int i = 0; i < n; i++) {
good[i] = g[i].empty();
if (!good[i]) continue;
int up = get_par(i, k);
g[i].push_back(up);
gr[up].push_back(i);
}
for (int i = 0; i < n; i++) {
if (!mark[i]) {
dfs1(i);
}
}
memset(comp, -1, sizeof(comp));
for (int i = n - 1; i >= 0; i--) {
int v = ord[i];
if (comp[v] == -1) {
dfs2(v);
++cur;
}
}
for (int i = 0; i < n; i++) {
g[i].clear();
gr[i].clear();
}
for (auto u : ed) {
int x = comp[u.first];
int y = comp[u.second];
if (x != y) {
g[x].push_back(y);
}
}
memset(dp, -1, sizeof(dp));
cout << dfs_end(comp[0]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 2e6 + 6;
int n, k;
vector<int> g[N];
int h[N];
vector<pair<int, int> > c[N];
inline void merge(int v, int to) {
pair<int, int> mx1 = {1e9, 0}, mx2 = {1e9, 0};
for (auto &x : c[v]) {
if (x.first - h[v] <= k) {
mx1.first = min(mx1.first, x.first);
mx1.second += x.second;
} else {
if (x.second > mx2.second) mx2 = x;
}
}
int vg = 0, vh = 1e9;
for (auto &x : c[to]) {
if (x.first - h[v] <= k) {
mx1.first = min(mx1.first, x.first);
mx1.second += x.second;
} else {
vg += x.second;
vh = x.first;
if (x.second > mx2.second) mx2 = x;
}
}
if (vg > mx2.second) mx2 = {vh, vg};
c[v].clear();
c[v].push_back(mx1);
c[v].push_back(mx2);
}
inline void dfs(int v) {
if (g[v].size() == 0) {
c[v].push_back({h[v], 1});
}
for (int to : g[v]) {
h[to] = h[v] + 1;
dfs(to);
merge(v, to);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 2; i <= n; ++i) {
int x;
cin >> x;
g[x].push_back(i);
}
dfs(1);
int ans = 0;
for (auto &x : c[1]) ans += x.second;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d[1000006];
pair<int, int> dp[1000006];
vector<int> g[1000006];
void dfs(int v) {
dp[v].first = 1000000007ll;
if (g[v].size() == 0) {
dp[v] = make_pair(0, 1);
d[v] = 1;
} else {
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
dfs(to);
if (dp[to].first + 1 <= k) {
dp[v].second += dp[to].second;
dp[v].first = min(dp[v].first, 1 + dp[to].first);
}
}
d[v] = dp[v].second;
for (int i = 0; i < g[v].size(); i++)
if (dp[g[v][i]].first + 1 <= k)
d[v] = max(d[v], dp[v].second - dp[g[v][i]].second + d[g[v][i]]);
else
d[v] = max(d[v], dp[v].second + d[g[v][i]]);
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n - 1; i++) {
int to;
scanf(" %d", &to);
g[to].push_back(i + 1);
}
dfs(1);
cout << d[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool read(T &x) {
x = 0;
bool f = 0;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar()) {
if (ch == EOF) return 0;
f |= ch == '-';
}
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 48);
if (f) x = -x;
return 1;
}
template <class T>
void write(T x) {
if (x < 0) {
putchar('-');
write(-x);
return;
}
if (x > 9) write(x / 10);
putchar(x % 10 | 48);
}
template <class T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
template <class T>
inline void writespace(T x) {
write(x);
putchar(' ');
}
const string taskname = "zero";
long long n, k;
long long dep[1000010], fa[1000010], f[1000010], g[1000010];
long long low[1000010];
long long tot, h[1000010], ver[1000010], nxt[1000010];
bool leaf[1000010];
inline void add(long long u, long long v) {
++tot;
ver[tot] = v;
leaf[u] = 0;
nxt[tot] = h[u];
h[u] = tot;
}
void dfs(long long u) {
dep[u] = dep[fa[u]] + 1;
if (leaf[u])
g[u] = 1, low[u] = dep[u];
else
low[u] = 1e9;
for (register long long i = h[u]; i; i = nxt[i]) {
long long v = ver[i];
dfs(v);
low[u] = min(low[v], low[u]);
}
for (register long long i = h[u]; i; i = nxt[i]) {
long long v = ver[i];
if (low[v] - dep[u] <= k) g[u] += g[v], g[v] = 0;
}
}
void dp(long long u) {
for (register long long i = h[u]; i; i = nxt[i]) {
long long v = ver[i];
dp(v);
f[u] = max(f[u], f[v]);
}
f[u] += g[u];
}
signed main() {
srand(20050210);
read(n);
read(k);
for (register long long i = 1; i <= n; ++i) leaf[i] = 1;
for (register long long i = 2; i <= n; ++i) {
read(fa[i]);
add(fa[i], i);
}
dfs(1);
dp(1);
write(f[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int p[1000001];
vector<int> c[1000001];
int dep[1000001];
int dep2cnt[1000001 + 1000001];
int depkleafcnt[1000001];
int depgekleafcnt[1000001];
int cntleaf[1000001];
int dp0[1000001];
int dp1[1000001];
void dfs(int u, int d) {
dep[u] = d;
if (c[u].empty()) {
dep2cnt[d]++;
cntleaf[u] = 1;
}
int tmp = dep2cnt[d + k];
for (int v : c[u]) {
dfs(v, d + 1);
depgekleafcnt[u] += depgekleafcnt[v];
cntleaf[u] += cntleaf[v];
}
depkleafcnt[u] = dep2cnt[d + k] - tmp;
depgekleafcnt[u] += depkleafcnt[u];
}
void work(int u) {
for (int v : c[u]) {
work(v);
}
if (c[u].empty()) {
dp0[u] = dp1[u] = 1;
return;
}
if (cntleaf[u] == depgekleafcnt[u]) {
dp0[u] = 0;
} else {
for (int v : c[u]) {
dp0[u] += dp0[v];
}
}
for (int v : c[u]) {
if (cntleaf[v] > depgekleafcnt[v]) {
dp1[u] += dp0[v];
}
}
int delta = 0;
for (int v : c[u]) {
delta = max(delta, dp1[v] - dp0[v]);
}
dp1[u] += delta;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 2; i <= n; i++) {
cin >> p[i];
c[p[i]].push_back(i);
}
dfs(1, 0);
work(1);
cout << dp1[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void INIT() { ios ::sync_with_stdio(false); }
const int N = 1001000;
int n, k;
vector<int> g[N];
int dep[N], ans[N], mndep[N], dp[N];
void dfs1(int u, int pre) {
for (auto v : g[u]) {
if (v == pre) continue;
dep[v] = dep[u] + 1;
dfs1(v, u);
}
if (g[u].size() == 1 && u != 1) {
mndep[u] = dep[u];
ans[u] = 1;
return;
}
for (auto v : g[u]) {
if (v == pre) continue;
if (!mndep[u])
mndep[u] = mndep[v];
else
mndep[u] = min(mndep[u], mndep[v]);
if (mndep[v] - dep[u] <= k) ans[u] += ans[v], ans[v] = 0;
}
}
void dfs2(int u, int pre) {
for (auto v : g[u]) {
if (v == pre) continue;
dfs2(v, u);
dp[u] = max(dp[u], dp[v]);
}
dp[u] += ans[u];
}
int main() {
INIT();
cin >> n >> k;
for (register int i = 2; i <= n; i++) {
int u;
cin >> u;
g[u].push_back(i), g[i].push_back(u);
}
dfs1(1, 0), dfs2(1, 0);
cout << dp[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
std::vector<int> G[1000005];
int dp[1000005];
int dep[1000005];
int low[1000005];
int ans[1000005];
void dfs1(int v, int p) {
dep[v] = dep[p] + 1;
if (G[v].empty()) {
low[v] = dep[v];
dp[v] = 1;
} else {
int h = 0x3f3f3f3f;
int val = 0;
for (int u : G[v]) {
dfs1(u, v);
if (low[u] - dep[v] <= k) {
val += dp[u];
h = min(h, low[u]);
}
}
dp[v] = val;
low[v] = h;
}
}
void dfs(int v) {
ans[v] = dp[v];
for (int u : G[v]) {
dfs(u);
int tmp = dp[v];
if (low[u] - dep[v] <= k) tmp -= dp[u];
ans[v] = max(ans[v], tmp + ans[u]);
}
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 2; i <= n; ++i) {
int p;
cin >> p;
G[p].push_back(i);
}
dep[0] = 0;
dfs1(1, 0);
dfs(1);
std::cout << ans[1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 5;
int n, k;
vector<int> g[N];
int prt[N], dwn[N], shl[N];
void dfs(int u, int dp) {
if (g[u].empty()) {
shl[u] = dp;
prt[u] = 1;
} else {
shl[u] = N;
for (int v : g[u]) {
dfs(v, dp + 1);
shl[u] = min(shl[u], shl[v]);
if (shl[v] - dp <= k) {
prt[u] += prt[v];
dwn[u] = max(dwn[u], dwn[v] - prt[v]);
} else {
dwn[u] = max(dwn[u], dwn[v]);
}
}
}
dwn[u] += prt[u];
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
g[p].push_back(i);
}
dfs(1, 0);
printf("%d\n", dwn[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> edge[1000000 + 10];
int deep[1000000 + 10], dp[1000000 + 10], low[1000000 + 10];
int res = 0;
void dfs(int rt, int first) {
deep[rt] = deep[first] + 1;
if (edge[rt].size() == 1 && rt != 1) {
low[rt] = deep[rt];
dp[rt] = 1;
return;
}
int minn = 1e9;
for (auto i : edge[rt]) {
if (i == first) continue;
dfs(i, rt);
if (deep[rt] + k >= low[i]) {
minn = min(minn, low[i]);
dp[rt] += dp[i];
}
}
low[rt] = minn;
}
void dfs1(int rt, int first, int ans) {
res = max(res, ans);
for (auto i : edge[rt]) {
if (i == first) continue;
if (deep[rt] + k >= low[i]) {
dfs1(i, rt, ans);
} else {
dfs1(i, rt, ans + dp[i]);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = (2); i < (n + 1); i++) {
int x;
cin >> x;
edge[i].push_back(x);
edge[x].push_back(i);
}
dfs(1, 0);
dfs1(1, 0, dp[1]);
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
const int N = 1e6 + 6;
vector<int> v[N];
int mn[N], ct[N], mx[N];
int n, k;
void dfs(int node, int h) {
if (v[node].empty()) {
ct[node] = 1;
mn[node] = h - k;
mx[node] = 1;
return;
}
int x = N, y = 0;
for (int to : v[node]) {
dfs(to, h + 1);
x = min(x, mn[to]);
y += ct[to];
}
for (int to : v[node]) {
mx[node] = max(mx[node], y - ct[to] + mx[to]);
}
if (h - 1 >= x) ct[node] = y;
mn[node] = x;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
int p;
scanf("%d", &p);
v[p - 1].push_back(i);
}
dfs(0, 0);
printf("%d", mx[0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
char ch;
bool flag = false;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') flag = true;
for (x = 0; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
x = flag ? -x : x;
}
inline void write(int x) {
static const int maxlen = 100;
static char s[maxlen];
if (x < 0) {
putchar('-');
x = -x;
}
if (!x) {
putchar('0');
return;
}
int len = 0;
for (; x; x /= 10) s[len++] = x % 10 + '0';
for (int i = len - 1; i >= 0; --i) putchar(s[i]);
}
const int MAXN = 1e6 + 100;
int n, lim;
int fa[MAXN];
vector<int> son[MAXN];
int deep[MAXN];
int MAX[MAXN];
int siz[MAXN][2];
void get_deep(int x) {
if (son[x].size() == 0) {
MAX[x] = x;
siz[x][1] = 1;
siz[x][0] = 0;
} else {
siz[x][0] = 0;
siz[x][1] = 0;
MAX[x] = 0;
}
for (int i = 0; i < son[x].size(); i++) {
int y = son[x][i];
deep[y] = deep[x] + 1;
get_deep(y);
if ((MAX[x] == 0) || (deep[MAX[y]] < deep[MAX[x]])) MAX[x] = MAX[y];
if (deep[MAX[y]] <= deep[x] + lim) {
siz[x][1] += siz[y][1];
siz[x][0] = max(siz[x][0], siz[y][0] - siz[y][1]);
} else
siz[x][0] = max(siz[x][0], siz[y][0]);
}
siz[x][0] += siz[x][1];
}
int main() {
read(n);
read(lim);
for (int i = 2; i <= n; i++) {
read(fa[i]);
son[fa[i]].push_back(i);
}
get_deep(1);
int ans = 0;
for (int i = 1; i <= n; i++) ans = max(ans, siz[i][0]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 9.2e18;
const int maxn = 1e6 + 70;
const int INF = 2.1e9;
const int maxm = 1e6 + 70;
const int MOD = 1e9 + 7;
const double eps = 1e-7;
const double PI = acos(-1.0);
int n, m, k;
vector<int> G[maxn];
int dep[maxn], mind[maxn], dp[maxn];
int dfs(int u) {
if (!G[u].size()) {
mind[u] = dep[u] - k;
dp[u] = 1;
return 1;
} else {
int mx = 0;
mind[u] = dep[u];
dp[u] = 0;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
dep[v] = dep[u] + 1;
int val = dfs(v);
mind[u] = min(mind[u], mind[v]);
if (mind[v] <= dep[u]) {
dp[u] += dp[v];
mx = max(mx, val - dp[v]);
} else {
mx = max(mx, val);
}
}
return dp[u] + mx;
}
}
int main() {
while (cin >> n >> k) {
for (int i = 1; i <= n; i++) G[i].clear();
for (int i = 2; i <= n; i++) {
int f;
scanf("%d", &f);
G[f].push_back(i);
}
dep[1] = 0;
int ans = dfs(1);
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int maxn = 1e6 + 5;
vector<int> g[maxn];
int n, k;
int nfree[maxn];
int npay[maxn];
int depth[maxn];
void dfs(int at) {
if (g[at].empty()) {
depth[at] = 0;
nfree[at] = 1;
npay[at] = 0;
return;
}
depth[at] = 1e9;
int finale = 0;
int tot = 0;
for (int to : g[at]) {
dfs(to);
depth[at] = min(depth[at], 1 + depth[to]);
finale = max(finale, npay[to]);
tot += nfree[to];
}
npay[at] = finale;
if (depth[at] < k) {
nfree[at] += tot;
} else {
npay[at] += tot;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i < n; i++) {
int p;
cin >> p;
--p;
g[p].push_back(i);
}
dfs(0);
cout << nfree[0] + npay[0] << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.