text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, lim, p = 1, a[N], nex[N * 2], spot[N * 2], head[N], fa[N], f[N], g[N];
int maxcolor[N][2], c[N];
bool color[N], v[N];
void add(int x, int y) {
nex[++p] = head[x], head[x] = p, spot[p] = y;
nex[++p] = head[y], head[y] = p, spot[p] = x;
}
void dfs1(int x) {
int tp, y, cnt = 0, m1 = 0, m2 = 0;
v[x] = 1;
for (tp = head[x]; y = spot[tp], tp; tp = nex[tp])
if (a[y] >= lim && y != fa[x]) {
fa[y] = x;
dfs1(y);
if (!c[y])
cnt += f[y];
else {
c[x]++;
if (f[y] > m2) m2 = f[y];
if (m1 < m2) swap(m1, m2);
}
}
maxcolor[x][0] = m1;
maxcolor[x][1] = m2;
f[x] = cnt + m1 + 1;
c[x] += color[x];
}
void dfs2(int x, int &ret) {
if (fa[x]) {
if (c[fa[x]] - (c[x] != 0) > 0) {
if (c[x]) {
if (f[x] < maxcolor[fa[x]][0]) {
g[x] = f[x] - maxcolor[x][0] + max(maxcolor[x][0], g[fa[x]]);
if (g[fa[x]] > maxcolor[x][1]) maxcolor[x][1] = g[fa[x]];
if (maxcolor[x][0] < maxcolor[x][1])
swap(maxcolor[x][0], maxcolor[x][1]);
} else {
g[x] = f[x] - maxcolor[x][0] +
max(maxcolor[x][0],
g[fa[x]] - maxcolor[fa[x]][0] + maxcolor[fa[x]][1]);
if (g[fa[x]] - maxcolor[fa[x]][0] + maxcolor[fa[x]][1] >
maxcolor[x][1])
maxcolor[x][1] = g[fa[x]] - maxcolor[fa[x]][0] + maxcolor[fa[x]][1];
if (maxcolor[x][0] < maxcolor[x][1])
swap(maxcolor[x][0], maxcolor[x][1]);
}
} else
g[x] = f[x] - maxcolor[x][0] + max(maxcolor[x][0], g[fa[x]] - f[x]);
} else {
if (c[x]) {
if (f[x] < maxcolor[fa[x]][0])
g[x] = f[x] + g[fa[x]];
else
g[x] = f[x] + g[fa[x]] - maxcolor[fa[x]][0] + maxcolor[fa[x]][1];
} else
g[x] = g[fa[x]];
}
c[x] += ((c[fa[x]] - (c[x] != 0)) != 0);
} else
g[x] = f[x];
ret = max(ret, g[x]);
for (int tp = head[x]; tp; tp = nex[tp])
if (a[spot[tp]] >= lim && spot[tp] != fa[x]) dfs2(spot[tp], ret);
}
int solve() {
memset(v, 0, sizeof(v));
memset(fa, 0, sizeof(fa));
memset(maxcolor, 0, sizeof(maxcolor));
memset(c, 0, sizeof(c));
int maxn = 0;
for (int i = 1; i <= n; i++)
if (a[i] >= lim && v[i] == 0) {
dfs1(i), dfs2(i, maxn);
}
return maxn >= m;
}
int main() {
int i, x, y, l, r, tp;
cin >> n >> m;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add(x, y);
}
for (l = 1, r = 1000000; l < r;) {
lim = l + r + 1 >> 1;
memset(color, 0, sizeof(color));
for (i = 1; i <= n; i++)
if (a[i] < lim)
for (tp = head[i]; tp; tp = nex[tp]) color[spot[tp]] = 1;
if (solve())
l = lim;
else
r = lim - 1;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
vector<int> g[200005];
int val[200005];
int n, k;
bool bad[200005];
int DP[200005];
int deg[200005];
int ben[200005];
queue<int> Q;
int maxr = 0;
int solve(int u, int p) {
DP[u] = ben[u];
int c1 = -1;
int c2 = -1;
for (int j = 0; j < ((int)(g[u].size())); ++j) {
int v = g[u][j];
if (v == p) continue;
DP[u] = max(DP[u], solve(v, u) + ben[u]);
if (DP[v] <= c1) {
if (DP[v] > c2) c2 = DP[v];
} else {
c2 = c1;
c1 = DP[v];
}
}
maxr = max(maxr, DP[u]);
maxr = max(maxr, ben[u] + c1 + c2);
return DP[u];
}
bool used[200005];
bool can(int x) {
maxr = 0;
memset(bad, 0, sizeof(bad));
;
memset(used, 0, sizeof(used));
;
for (int i = 0; i < n; ++i) {
deg[i] = g[i].size();
if (val[i] < x) {
bad[i] = 1;
ben[i] = -(1LL << 28);
} else
ben[i] = 1;
if (!bad[i] && deg[i] == 1) Q.push(i);
}
while (!Q.empty()) {
int u = Q.front();
Q.pop();
used[u] = 1;
for (int j = 0; j < ((int)(g[u].size())); ++j) {
int v = g[u][j];
if (!bad[v]) {
if (!used[v]) {
ben[v] += ben[u];
ben[u] = 0;
deg[v]--;
if (deg[v] == 1) Q.push(v);
}
}
}
}
memset(DP, -1, sizeof(DP));
solve(0, -1);
return maxr >= k;
}
int main() {
scanf("%d %d", &n, &k);
int mini = 1 << 30;
for (int i = 0; i < n; ++i) {
scanf("%d", &val[i]);
mini = min(mini, val[i]);
}
int u, v;
for (int j = 0; j < n - 1; ++j) {
scanf("%d %d", &u, &v);
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
int lo = 0;
int hi = 1 << 29;
int ans = -1;
while (lo <= hi) {
int mid = lo + (hi - lo) / 2;
if (can(mid)) {
ans = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
printf("%d", ans);
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 10;
int n, k;
int Arr[MAX_N];
int len[MAX_N];
int dp[MAX_N];
int tmp[MAX_N][2];
bool ok[MAX_N];
vector<int> G[MAX_N];
void dfsDown(int v = 0, int p = 0) {
dp[v] = ok[v];
tmp[v][0] = tmp[v][1] = 0;
len[v] = 1;
for (int u : G[v])
if (u != p) {
dfsDown(u, v);
len[v] += len[u];
if (dp[u] + tmp[u][0] == len[u])
dp[v] += dp[u] + tmp[u][0];
else {
if (tmp[v][0] <= dp[u] + tmp[u][0]) {
tmp[v][1] = tmp[v][0];
tmp[v][0] = dp[u] + tmp[u][0];
} else
tmp[v][1] = max(tmp[v][1], dp[u] + tmp[u][0]);
}
}
dp[v] *= ok[v];
tmp[v][0] *= ok[v];
tmp[v][1] *= ok[v];
}
bool dfsUp(int v = 0, int p = 0, int val = 0) {
val *= ok[v];
if (n - len[v] == val)
dp[v] += val;
else {
if (tmp[v][0] <= val) {
tmp[v][1] = tmp[v][0];
tmp[v][0] = val;
} else
tmp[v][1] = max(tmp[v][1], val);
}
if (k <= dp[v] + tmp[v][0]) return true;
for (int u : G[v])
if (u != p) {
if (dp[u] + tmp[u][0] == len[u]) {
if (dfsUp(u, v, ok[v] * (dp[v] - dp[u] - tmp[u][0] + tmp[v][0])))
return true;
} else {
if (dp[u] + tmp[u][0] == tmp[v][0]) {
if (dfsUp(u, v, ok[v] * (dp[v] + tmp[v][1]))) return true;
} else {
if (dfsUp(u, v, ok[v] * (dp[v] + tmp[v][0]))) return true;
}
}
}
return false;
}
bool can(int d) {
for (int i = 0; i < n; i++) ok[i] = (d <= Arr[i]);
dfsDown();
return dfsUp();
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> Arr[i];
for (int i = 0; i < n - 1; i++) {
int v, u;
cin >> v >> u;
v--, u--;
G[v].push_back(u);
G[u].push_back(v);
}
int s = 0, e = 1000001;
while (e - s > 1) {
int med = e + s >> 1;
if (can(med))
s = med;
else
e = med;
}
cout << s << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct DP {
int sum;
int mx;
};
inline DP join(DP &a, DP &b) {
DP c;
c.sum = a.sum + b.sum;
c.mx = max(a.mx, b.mx);
return c;
}
const int N = 200010;
vector<int> g[N];
int total[N];
int f[N], dp[N];
bool good[N];
int a[N];
int n;
void dfs(int v, int pr) {
int sz = g[v].size();
total[v] = 1;
int sum = 0, mx = 0;
for (int j = 0; j < sz; j++) {
int u = g[v][j];
if (u == pr) {
continue;
}
dfs(u, v);
total[v] += total[u];
if (f[u] == total[u]) {
sum += f[u];
} else {
mx = max(mx, f[u]);
}
}
f[v] = sum + mx + 1;
if (!good[v]) {
f[v] = 0;
}
}
void solve(int v, int pr, int up) {
int sz = g[v].size();
vector<int> children;
for (int j = 0; j < sz; j++) {
int u = g[v][j];
if (u == pr) {
continue;
}
children.push_back(u);
}
int cnt = children.size();
int sum = 0, mx = 0;
for (int j = 0; j < cnt; j++) {
int u = children[j];
if (f[u] == total[u]) {
sum += f[u];
} else {
mx = max(mx, f[u]);
}
}
if (up == n - total[v]) {
sum += up;
} else {
mx = max(mx, up);
}
dp[v] = sum + mx + 1;
if (!good[v]) {
dp[v] = 0;
}
if (cnt == 0) {
return;
}
vector<DP> pref(cnt + 1);
vector<DP> suf(cnt + 1);
pref[0] = {0, 0};
for (int j = 0; j < cnt; j++) {
int u = children[j];
pref[j + 1] = pref[j];
if (f[u] == total[u]) {
pref[j + 1].sum += f[u];
} else {
pref[j + 1].mx = max(pref[j + 1].mx, f[u]);
}
}
suf[cnt] = {0, 0};
for (int j = cnt - 1; j >= 0; j--) {
int u = children[j];
suf[j] = suf[j + 1];
if (f[u] == total[u]) {
suf[j].sum += f[u];
} else {
suf[j].mx = max(suf[j].mx, f[u]);
}
}
for (int j = 0; j < cnt; j++) {
int u = children[j];
DP z = join(pref[j], suf[j + 1]);
if (up == n - total[v]) {
z.sum += up;
} else {
z.mx = max(z.mx, up);
}
int new_up = z.sum + z.mx + 1;
if (!good[v]) {
new_up = 0;
}
solve(u, v, new_up);
}
}
int main() {
int k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int i = 0; i < n; i++) {
g[i].clear();
}
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
int low = 0, high = 1000010;
while (low < high) {
int mid = (low + high + 1) >> 1;
for (int j = 0; j < n; j++) {
good[j] = (a[j] >= mid);
}
dfs(0, -1);
solve(0, -1, 0);
int best = 0;
for (int j = 0; j < n; j++) {
best = max(best, dp[j]);
}
if (best >= k) {
low = mid;
} else {
high = mid - 1;
}
}
printf("%d\n", low);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200005];
int a[200005], ans[200005];
int good[200005], bad1[200005], bad2[200005], isBad[200005];
int visited[200005], cntBad[200005], id;
int n, k;
void push(int &bad1, int &bad2, int val, int node) {
isBad[node] = true;
cntBad[node]++;
if (val >= bad1)
bad2 = bad1, bad1 = val;
else if (val >= bad2)
bad2 = val;
}
pair<int, bool> dfs1(int node, int parent, int minVal) {
visited[node] = id;
if (a[node] < minVal) {
isBad[node] = true;
ans[node] = 0;
cntBad[node] = 0;
return make_pair(0, false);
}
ans[node] = good[node] = bad1[node] = bad2[node] = 0, isBad[node] = 0,
cntBad[node] = 0;
bool ret = true;
for (int i = 0; i < int(g[node].size()); i++) {
int child = g[node][i];
if (child == parent) continue;
pair<int, int> tmp = dfs1(child, node, minVal);
if (tmp.second == false)
push(bad1[node], bad2[node], tmp.first, node), ret = false;
else
good[node] += tmp.first;
}
isBad[node] = !ret;
ans[node] = good[node] + bad1[node] + 1;
return make_pair(ans[node], ret);
}
void dfs2(int node, int parent, int minVal) {
visited[node] = id;
if (a[node] < minVal) return;
if (parent != -1) {
if (!isBad[node]) {
if (!isBad[parent])
good[node] += good[parent] + 1 - good[node] - 1;
else
push(bad1[node], bad2[node], ans[parent] - ans[node], node);
} else {
assert(cntBad[parent]);
if (cntBad[parent] == 1)
good[node] += good[parent] + 1;
else if (bad1[parent] == ans[node])
push(bad1[node], bad2[node], ans[parent] - bad1[parent] + bad2[parent],
node);
else
push(bad1[node], bad2[node], ans[parent], node);
}
ans[node] = good[node] + bad1[node] + 1;
}
for (int i = 0; i < int(g[node].size()); i++) {
int child = g[node][i];
if (child == parent) continue;
dfs2(child, node, minVal);
}
}
bool ok(int val) {
id++;
for (int i = 0; i < n; i++)
if (visited[i] != id) dfs1(i, -1, val);
id++;
for (int i = 0; i < n; i++)
if (visited[i] != id) dfs2(i, -1, val);
for (int i = 0; i < n; i++)
if (ans[i] >= k) return true;
return false;
}
int main() {
ios::sync_with_stdio(false);
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
int start = 0;
int end = 1000001;
while (end - start > 1) {
int mid = (end + start) >> 1;
if (ok(mid))
start = mid;
else
end = mid;
}
cout << start << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int C = 200001;
vector<vector<int> > tr(C);
int ij[C], a, b, n, m;
int s[C], is = 0, son[C], par[C], ji[C], dead[C], v[C], fll[C], best[2][C],
ab[C];
int proc_tree(int a, int n, vector<vector<int> > &tab, int ij[]) {
s[0] = a, is = 1;
int b, k, mx = 0, z;
for (z = 1; z <= n; z++)
son[z] = 0, ji[z] = ij[z], par[z] = 0, best[0][z] = best[1][z] = ab[z] = 0,
fll[z] = 0;
while (is > 0) {
a = s[is - 1];
if (ji[a] > 0 && tab[a][ji[a] - 1] == par[a]) ji[a]--;
if (ji[a] > 0)
b = s[is] = tab[a][ji[a] - 1], par[b] = a, is++, ji[a]--;
else {
b = par[a];
fll[a] = ((dead[a] == 1) ? 0 : (fll[a] + 1));
son[a]++, son[b] += son[a], is--;
if (dead[a] == 1) continue;
if (fll[a] == son[a])
fll[b] += fll[a];
else {
if (fll[a] + best[0][a] > best[0][b])
best[1][b] = best[0][b], best[0][b] = fll[a] + best[0][a], ab[b] = a;
else if (fll[a] + best[0][a] > best[1][b])
best[1][b] = fll[a] + best[0][a];
}
}
}
for (z = 1; z <= n; z++) ji[z] = ij[z];
is = 1;
while (is > 0) {
a = s[is - 1];
if (ji[a] > 0 && tab[a][ji[a] - 1] == par[a]) ji[a]--;
if (ji[a] > 0) {
b = s[is] = tab[a][ji[a] - 1], is++, ji[a]--;
if (dead[a] == 1 || dead[b] == 1) continue;
if (fll[b] == son[b])
k = fll[a] - fll[b];
else if (ab[a] == b)
k = fll[a] + best[1][a];
else
k = fll[a] + best[0][a];
if (k == n - son[b])
fll[b] += k;
else if (k > best[0][b])
best[1][b] = best[0][b], best[0][b] = k, ab[b] = a;
else if (k > best[1][b])
best[1][b] = k;
} else
is--;
}
for (z = 1; z <= n; z++)
if (fll[z] + best[0][z] > mx) mx = fll[z] + best[0][z];
return mx;
}
int main() {
int l = 0, r = 1000001, i, k;
scanf("%d %d", &n, &k);
for (i = 1; i <= n; i++) scanf("%d", &v[i]);
for (int z = 1; z < n; z++)
scanf("%d %d", &a, &b), tr[a].push_back(b), tr[b].push_back(a), ij[a]++,
ij[b]++;
while (l <= r) {
m = (l + r) / 2;
for (i = 1; i <= n; i++) dead[i] = ((v[i] > m) ? 0 : 1);
if (proc_tree(1, n, tr, ij) < k)
r = m - 1;
else
l = m + 1;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 212345;
vector<int> g[N];
int menor[N], a[N], sz[N], dp[N];
int mid;
void dfs(int u, int pu) {
menor[u] = a[u];
sz[u] = 1;
dp[u] = 1;
int best = 0;
for (auto v : g[u]) {
if (v == pu) continue;
dfs(v, u);
menor[u] = min(menor[u], menor[v]);
sz[u] += sz[v];
if (menor[v] >= mid)
dp[u] += sz[v];
else
best = max(best, dp[v]);
}
if (a[u] < mid)
dp[u] = 0;
else
dp[u] += best;
}
int maior, n;
void solve(int u, int pu, int dp_c, int menor_c) {
{
int ans = 1;
int best = 0;
for (auto v : g[u]) {
if (v == pu) continue;
if (menor[v] >= mid)
ans += sz[v];
else
best = max(best, dp[v]);
}
if (menor_c >= mid)
ans += n - sz[u];
else
best = max(best, dp_c);
if (a[u] >= mid)
ans += best;
else
ans = 0;
maior = max(maior, ans);
}
int tudo = 0;
vector<pair<int, int> > a, b;
for (auto v : g[u]) {
if (v == pu) continue;
if (menor[v] >= mid)
tudo += sz[v];
else
a.emplace_back(dp[v], v);
b.emplace_back(menor[v], v);
}
if (menor_c >= mid)
tudo += n - sz[u];
else
a.emplace_back(dp_c, -1);
b.emplace_back(menor_c, -1);
{
pair<int, int> x1, x2;
if (a.size() > 0) {
nth_element(a.begin(), a.begin(), a.end(), greater<pair<int, int> >());
x1 = a[0];
}
if (a.size() > 1) {
nth_element(a.begin(), a.begin() + 1, a.end(),
greater<pair<int, int> >());
x2 = a[1];
}
if (a.size() > 0) a[0] = x1;
if (a.size() > 1) a[1] = x2;
}
{
pair<int, int> x1, x2;
if (b.size() > 0) {
nth_element(b.begin(), b.begin(), b.end());
x1 = b[0];
}
if (b.size() > 1) {
nth_element(b.begin(), b.begin() + 1, b.end());
x2 = b[1];
}
if (b.size() > 0) b[0] = x1;
if (b.size() > 1) b[1] = x2;
}
sort(b.begin(), b.end());
menor_c = min(menor_c, ::a[u]);
for (auto v : g[u]) {
if (v == pu) continue;
int ntudo = tudo;
if (menor[v] >= mid) {
ntudo -= sz[v];
int new_cima = 1 + ntudo;
int new_menor = menor_c;
if (!a.empty()) new_cima += a[0].first;
if (::a[u] < mid) new_cima = 0;
if (b[0].second == v)
new_menor = min(menor_c, b[1].first);
else
new_menor = min(menor_c, b[0].first);
solve(v, u, new_cima, new_menor);
} else {
int new_cima = 1 + ntudo;
int new_menor = menor_c;
if (a[0].second != v)
new_cima += a[0].first;
else if (a.size() > 1)
new_cima += a[1].first;
if (::a[u] < mid) new_cima = 0;
if (b[0].second == v)
new_menor = min(menor_c, b[1].first);
else
new_menor = min(menor_c, b[0].first);
solve(v, u, new_cima, new_menor);
}
}
}
int main(void) {
int k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
int lo = 1, hi = 2000000, ans = -1;
while (lo <= hi) {
mid = (lo + hi) / 2;
maior = 0;
dfs(1, 0);
solve(1, 0, 0, mid + 10);
if (maior >= k) {
ans = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int C = 26;
void add(int &x, int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x) {
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % MOD;
b >>= 1;
a = 1ll * a * a % MOD;
}
return ret;
}
const int MAXN = 2e5 + 10;
int n, k, a[MAXN];
vector<int> adj[MAXN];
int limit;
pair<int, int> dp[MAXN];
set<pair<int, int> > st[MAXN];
void dfs(int v, int p) {
dp[v].first = 1;
dp[v].second = a[v] >= limit;
st[v].emplace(0, -1);
for (int u : adj[v]) {
if (u != p) {
dfs(u, v);
dp[v].first += dp[u].first;
if (a[v] < limit) continue;
if (dp[u].first == dp[u].second)
dp[v].second += dp[u].second;
else
st[v].emplace(dp[u].second, u);
}
}
if (a[v] >= limit) dp[v].second += st[v].rbegin()->first;
}
bool good;
void dfs2(int v, int p) {
if (dp[v].second >= k) {
good = true;
}
for (int u : adj[v]) {
if (u != p) {
pair<int, int> memo_u = dp[u];
pair<int, int> memo_v = dp[v];
bool is_mx = *st[v].rbegin() == pair<int, int>(dp[u].second, u);
int inside = st[v].erase({dp[u].second, u});
if (a[v] >= limit && a[u] >= limit) {
if (!inside) dp[v].second -= dp[u].second;
if (is_mx) {
dp[v].second -= dp[u].second;
dp[v].second += st[v].rbegin()->first;
}
dp[v].first -= dp[u].first;
dp[u].first += dp[v].first;
dp[u].second -= st[u].rbegin()->first;
if (dp[v].first == dp[v].second) {
dp[u].second += dp[v].second;
} else {
st[u].insert({dp[v].second, v});
}
dp[u].second += st[u].rbegin()->first;
} else {
dp[v].first -= dp[u].first;
dp[u].first += dp[v].first;
}
dfs2(u, v);
st[u].erase({dp[v].second, v});
dp[u] = memo_u;
dp[v] = memo_v;
if (inside) st[v].emplace(dp[u].second, u);
}
}
}
bool works(int mid) {
limit = mid;
good = false;
for (int v = 0; v < n; v++) st[v].clear();
dfs(0, -1);
dfs2(0, -1);
return good;
}
int b[MAXN];
void solve() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
--u;
--v;
adj[v].push_back(u);
adj[u].push_back(v);
}
memcpy(b, a, sizeof(b));
sort(b, b + n);
int lo = 0, hi = n;
while (hi - lo > 1) {
int mid = (lo + hi) >> 1;
if (works(b[mid]))
lo = mid;
else
hi = mid;
cerr << "done: " << mid << "\n";
}
cout << b[lo] << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int te = 1;
for (int w = 1; w <= te; w++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int all_up[200001], n, req, val, dp_up[200001], dp_down[200001], size[200001],
mini[200001], all_sum[200001], all_down[200001];
int a[200001], max1_not_full[200001], max2_not_full[200001];
vector<int> v[200001];
void dfs_down(int cur, int par) {
all_down[cur] = 0;
mini[cur] = a[cur];
size[cur] = 1;
for (int i = 0; i < v[cur].size(); i++) {
int x = v[cur][i];
if (x == par) continue;
dfs_down(x, cur);
mini[cur] = min(mini[cur], mini[x]);
size[cur] += size[x];
}
if (a[cur] < val)
dp_down[cur] = 0;
else {
dp_down[cur] = 1;
int maxi = 0;
for (int i = 0; i < v[cur].size(); i++) {
int x = v[cur][i];
if (x == par) continue;
if (dp_down[x] == size[x])
dp_down[cur] += dp_down[x];
else
maxi = max(maxi, dp_down[x]);
}
dp_down[cur] += maxi;
}
if (dp_down[cur] == size[cur])
all_down[cur] = 1;
else
all_down[cur] = 0;
all_sum[cur] = 0;
max1_not_full[cur] = -1;
max2_not_full[cur] = -1;
for (int i = 0; i < v[cur].size(); i++) {
int x = v[cur][i];
if (x == par) continue;
if (dp_down[x] == size[x])
all_sum[cur] += dp_down[x];
else {
if (max1_not_full[cur] == -1 ||
dp_down[max1_not_full[cur]] <= dp_down[x]) {
max2_not_full[cur] = max1_not_full[cur];
max1_not_full[cur] = x;
} else if (max2_not_full[cur] == -1 ||
dp_down[max2_not_full[cur]] <= dp_down[x])
max2_not_full[cur] = x;
}
}
}
void dfs_up(int cur, int par) {
all_up[cur] = 0;
if (par != -1) {
if (a[cur] < val)
dp_up[cur] = 0;
else if (a[par] < val)
dp_up[cur] = 1;
else {
dp_up[cur] = 2;
dp_up[cur] += all_sum[par];
if (dp_down[cur] == size[cur]) dp_up[cur] -= dp_down[cur];
if (all_up[par]) {
if (dp_up[par] >= 1) dp_up[cur] += dp_up[par] - 1;
if (max1_not_full[par] != -1 && max1_not_full[par] != cur)
dp_up[cur] += dp_down[max1_not_full[par]];
else if (max2_not_full[par] != -1 && max2_not_full[par] != cur)
dp_up[cur] += dp_down[max2_not_full[par]];
} else {
if (max1_not_full[par] == -1)
dp_up[cur] += max(0, dp_up[par] - 1);
else if (max1_not_full[par] == cur) {
if (max2_not_full[par] == -1)
dp_up[cur] += max(0, dp_up[par] - 1);
else
dp_up[cur] +=
max(max(0, dp_up[par] - 1), dp_down[max2_not_full[par]]);
} else
dp_up[cur] +=
max(max(0, dp_up[par] - 1), dp_down[max1_not_full[par]]);
}
}
if (dp_up[cur] == n - size[cur] + 1) all_up[cur] = 1;
}
for (int i = 0; i < v[cur].size(); i++) {
int x = v[cur][i];
if (x == par) continue;
dfs_up(x, cur);
}
}
int ok(int to_check) {
val = to_check;
dfs_down(1, -1);
dfs_up(1, -1);
for (int i = 1; i <= n; i++) {
if (a[i] < val) continue;
if (dp_up[i] + dp_down[i] - 1 >= req) return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
int i, j, lo, mid, hi, x, y;
cin >> n >> req;
lo = 10000000;
hi = 0;
for (i = 1; i <= n; i++) {
cin >> a[i];
lo = min(lo, a[i]);
hi = max(hi, a[i]);
}
for (i = 1; i <= n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
hi++;
while (hi - lo > 1) {
mid = (lo + hi) / 2;
if (ok(mid))
lo = mid;
else
hi = mid;
}
cout << lo;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Stand_IO_Operation {
inline int read() {
int f = 1, res = 0, ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') res = res * 10 + ch - 48, ch = getchar();
return f * res;
}
int _sta[1 << 8];
inline void write(int val) {
if (!val) {
putchar('0');
return;
}
if (val < 0) putchar('-'), val = -val;
*_sta = 0;
while (val > 0) _sta[++*_sta] = val % 10, val /= 10;
for (int i = *_sta, _Lim = 1; i >= _Lim; i--) putchar(_sta[i] + 48);
}
}; // namespace Stand_IO_Operation
using namespace Stand_IO_Operation;
const int N = 200005;
int n, k, a[N], tag[N], ans, cnt;
vector<int> G[N];
int sz[N], dp[N], tag_cnt[N];
void init(int val) {
ans = cnt = 0;
for (int i = 1; i <= n; i++) {
tag[i] = a[i] >= val ? 1 : 0;
cnt += tag[i];
}
memset(tag_cnt, 0, sizeof tag_cnt);
}
void dfs1(int cur, int fa) {
sz[cur] = 1;
for (int i = 0; i < G[cur].size(); i++) {
int u = G[cur][i];
if (u == fa) continue;
dfs1(u, cur);
sz[cur] += sz[u];
}
}
void dfs2(int cur, int fa) {
if (ans >= k) return;
int all = 0, max1 = 0, max2 = 0;
for (int i = 0; i < G[cur].size(); i++) {
int u = G[cur][i];
if (u == fa) continue;
dfs2(u, cur);
tag_cnt[cur] += tag_cnt[u];
if (dp[u] == sz[u])
all += dp[u];
else if (dp[u] > max1) {
max2 = max1;
max1 = dp[u];
} else if (dp[u] > max2)
max2 = dp[u];
}
if (!tag[cur])
dp[cur] = 0;
else {
dp[cur] = all + max1 + 1;
tag_cnt[cur]++;
}
if (n - sz[cur] == cnt - tag_cnt[cur]) all += n - sz[cur];
if (tag[cur]) ans = max(ans, all + max1 + max2 + 1);
}
int main() {
n = read();
k = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
G[u].push_back(v);
G[v].push_back(u);
}
int l = 1, r = 1000000, mid;
dfs1(1, 0);
while (l <= r) {
mid = (l + r) >> 1;
init(mid);
dfs2(1, 0);
if (ans >= k)
l = mid + 1;
else
r = mid - 1;
}
write(r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> E[200000 + 5];
int n, k, a[200000 + 5], b[200000 + 5], f[200000 + 5], nc[200000 + 5];
bool valid;
void dfs(int u, int pre) {
nc[u] = 1;
f[u] = b[u];
int c = 0;
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i];
if (v == pre) continue;
dfs(v, u);
nc[u] += nc[v];
if (f[v] == nc[v])
f[u] += b[u] * nc[v];
else
c = max(c, f[v]);
}
f[u] += c * b[u];
}
void final_dfs(int u, int pre, int fpar) {
pair<int, int> id = pair<int, int>(0, 0);
int ret = b[u];
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i];
if (v == pre) continue;
if (f[v] == nc[v])
ret += b[u] * nc[v];
else {
if (f[id.first] < f[v]) {
id.second = id.first;
id.first = v;
} else if (f[id.second] < f[v])
id.second = v;
}
}
if (fpar == n - nc[u]) ret += b[u] * fpar;
ret += b[u] * max(f[id.first], (fpar != (n - nc[u])) * fpar);
if (ret >= k) valid = true;
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i];
int gpar = ret;
if (v == pre) continue;
if (f[v] == nc[v])
gpar -= b[u] * nc[v];
else {
if (v == id.first && f[v] > (fpar != (n - nc[u])) * fpar) {
gpar -= b[u] * f[v];
gpar += b[u] * max((fpar != (n - nc[u])) * fpar, f[id.second]);
}
}
final_dfs(v, u, gpar);
}
}
bool ok(int mid) {
for (int i = 1; i <= n; i++) b[i] = (a[i] >= mid);
valid = false;
dfs(1, -1);
final_dfs(1, -1, 0);
return valid;
}
void loadtree() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
E[x].push_back(y);
E[y].push_back(x);
}
}
int main() {
loadtree();
int lo = 1, hi = 1e6;
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
if (ok(mid))
lo = mid;
else
hi = mid - 1;
}
printf("%d", lo);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int all_up[200001], n, req, val, dp_up[200001], dp_down[200001],
size[200001], mini[200001], all_sum[200001], all_down[200001];
long long int a[200001], max1_not_full[200001], max2_not_full[200001];
vector<long long int> v[200001];
void dfs_down(long long int cur, long long int par) {
mini[cur] = a[cur];
size[cur] = 1;
for (int i = 0; i < v[cur].size(); i++) {
int x = v[cur][i];
if (x == par) continue;
dfs_down(x, cur);
mini[cur] = min(mini[cur], mini[x]);
size[cur] += size[x];
}
if (a[cur] < val)
dp_down[cur] = 0;
else {
dp_down[cur] = 1;
long long int maxi = 0;
for (int i = 0; i < v[cur].size(); i++) {
int x = v[cur][i];
if (x == par) continue;
if (dp_down[x] == size[x])
dp_down[cur] += dp_down[x];
else
maxi = max(maxi, dp_down[x]);
}
dp_down[cur] += maxi;
}
if (dp_down[cur] == size[cur])
all_down[cur] = 1;
else
all_down[cur] = 0;
all_sum[cur] = 0;
max1_not_full[cur] = -1;
max2_not_full[cur] = -1;
for (int i = 0; i < v[cur].size(); i++) {
int x = v[cur][i];
if (x == par) continue;
if (dp_down[x] == size[x])
all_sum[cur] += dp_down[x];
else {
if (max1_not_full[cur] == -1 ||
dp_down[max1_not_full[cur]] <= dp_down[x]) {
max2_not_full[cur] = max1_not_full[cur];
max1_not_full[cur] = x;
} else if (max2_not_full[cur] == -1 ||
dp_down[max2_not_full[cur]] <= dp_down[x])
max2_not_full[cur] = x;
}
}
}
void dfs_up(long long int cur, long long int par) {
if (par != -1) {
if (a[cur] < val)
dp_up[cur] = 0;
else if (a[par] < val)
dp_up[cur] = 1;
else {
dp_up[cur] = 2;
dp_up[cur] += all_sum[par];
if (dp_down[cur] == size[cur]) dp_up[cur] -= dp_down[cur];
if (all_up[par]) {
if (dp_up[par] >= 1) dp_up[cur] += dp_up[par] - 1;
if (max1_not_full[par] != -1 && max1_not_full[par] != cur)
dp_up[cur] += dp_down[max1_not_full[par]];
else if (max2_not_full[par] != -1 && max2_not_full[par] != cur)
dp_up[cur] += dp_down[max2_not_full[par]];
} else {
if (max1_not_full[par] == -1)
dp_up[cur] += max(0LL, dp_up[par] - 1);
else if (max1_not_full[par] == cur) {
if (max2_not_full[par] == -1)
dp_up[cur] += max(0LL, dp_up[par] - 1);
else
dp_up[cur] +=
max(max(0LL, dp_up[par] - 1), dp_down[max2_not_full[par]]);
} else
dp_up[cur] +=
max(max(0LL, dp_up[par] - 1), dp_down[max1_not_full[par]]);
}
}
if (dp_up[cur] == n - size[cur] + 1) all_up[cur] = 1;
}
for (int i = 0; i < v[cur].size(); i++) {
int x = v[cur][i];
if (x == par) continue;
dfs_up(x, cur);
}
}
int ok(long long int to_check) {
val = to_check;
memset(all_up, 0, sizeof all_up);
memset(all_down, 0, sizeof all_down);
dfs_down(1, -1);
dfs_up(1, -1);
for (int i = 1; i <= n; i++) {
if (a[i] < val) continue;
if (dp_up[i] + dp_down[i] - 1 >= req) return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
long long int i, j, lo, mid, hi, x, y;
cin >> n >> req;
lo = 1000000000000;
hi = 0;
for (i = 1; i <= n; i++) {
cin >> a[i];
lo = min(lo, a[i]);
hi = max(hi, a[i]);
}
for (i = 1; i <= n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
lo = 0;
hi++;
while (hi - lo > 1) {
mid = (lo + hi) / 2;
if (ok(mid))
lo = mid;
else
hi = mid;
}
cout << lo;
return 0;
}
|
#include <bits/stdc++.h>
inline long long Input() {
long long ret = 0;
bool isN = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') isN = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ret = ret * 10 + c - '0';
c = getchar();
}
return isN ? -ret : ret;
}
inline void Output(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
int len = 0, data[20];
while (x) {
data[len++] = x % 10;
x /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
putchar('\n');
}
#pragma comment(linker, "/STACK:124000000,124000000")
const long double PI = acos(-1.0);
using namespace std;
int h[200005], mem;
struct {
int v, next;
} e[200005 << 2];
void add(int u, int v) {
e[mem].v = v;
e[mem].next = h[u];
h[u] = mem++;
}
int n, k;
int a[200005], b[200005], fuck[200005];
int dp[200005][2], son[200005][2];
bool vis[200005];
int flag[200005];
bool ok;
bool cmp(int x, int y) { return x < y; }
void dfs(int u, int w) {
vis[u] = 1;
dp[u][0] = 0;
dp[u][1] = 0;
flag[u] = 0;
int wan = 1;
for (int i = h[u]; i + 1; i = e[i].next) {
int v = e[i].v;
if (vis[v]) continue;
if (a[v] < w) {
flag[u]++;
continue;
}
dfs(v, w);
if (flag[v]) {
if (dp[v][0] > dp[u][0]) {
dp[u][1] = dp[u][0];
dp[u][0] = dp[v][0];
son[u][1] = son[u][0];
son[u][0] = v;
} else if (dp[v][0] > dp[u][1]) {
dp[u][1] = dp[v][0];
son[u][1] = v;
}
} else
wan += dp[v][0];
if (flag[v]) flag[u]++;
}
dp[u][0] += wan;
dp[u][1] += wan;
fuck[u] = wan;
}
void dfsfuck(int u, int fa, int w) {
if (ok) return;
if (dp[u][0] >= k) {
ok = 1;
return;
}
dp[u][0] -= fuck[u];
dp[u][1] -= fuck[u];
for (int i = h[u]; i + 1; i = e[i].next) {
int v = e[i].v;
if (a[v] < w || v == fa) continue;
int tmp[2], tfuck = fuck[u], tflag = flag[u];
tmp[0] = dp[u][0];
tmp[1] = dp[u][1];
if (flag[v] == 0) {
fuck[u] -= dp[v][0];
} else {
flag[u]--;
if (son[u][0] == v) {
dp[u][0] = dp[u][1];
}
}
dp[u][0] += fuck[u];
dp[u][1] += fuck[u];
dp[v][0] -= fuck[v];
dp[v][1] -= fuck[v];
if (flag[u]) {
if (dp[u][0] > dp[v][0]) {
dp[v][1] = dp[v][0];
dp[v][0] = dp[u][0];
son[v][1] = son[v][0];
son[v][0] = u;
} else if (dp[u][0] > dp[v][1]) {
dp[v][1] = dp[u][0];
son[v][1] = u;
}
} else {
fuck[v] += dp[u][0];
}
if (flag[u]) flag[v]++;
dp[v][0] += fuck[v];
dp[v][1] += fuck[v];
dfsfuck(v, u, w);
dp[u][0] = tmp[0];
dp[u][1] = tmp[1];
fuck[u] = tfuck;
flag[u] = tflag;
}
}
bool work(int v) {
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (a[i] < v || vis[i]) continue;
dfs(i, v);
ok = 0;
dfsfuck(i, i, v);
if (ok) return 1;
}
return 0;
}
void Debug() {
for (int i = 1; i <= n; i++) {
for (int j = h[i]; j + 1; j = e[j].next) {
printf("%d %d\n", i, e[j].v);
}
}
}
char shit[1000];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) b[i] = a[i];
sort(b + 1, b + 1 + n, cmp);
memset(h, -1, sizeof(h));
mem = 0;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
int l = 1, r = n, ans;
while (l <= r) {
int mid = (l + r) >> 1;
if (work(b[mid])) {
ans = b[mid];
l = mid + 1;
} else
r = mid - 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 222222;
const int inf = 1e6;
int n, k, m, a[N], b[N], c[N], f[N], ans, p;
vector<int> v[N];
void dfs1(int u, int fa) {
int i = v[u].size(), x;
b[u] = 1;
c[u] = 1;
while (i--) {
x = v[u][i];
if (x == fa) continue;
if (a[x] < m) {
b[u] = 0;
continue;
}
if (!f[x]) continue;
dfs1(x, u);
if (b[x])
f[u] += f[x], f[x] = 0;
else
b[u] = 0;
}
if (!b[u] && !p) p = u;
}
void dfs2(int u, int fa) {
int i = v[u].size(), x, e = 0;
while (i--) {
x = v[u][i];
if (x == fa || !f[x]) continue;
dfs2(x, u);
ans = max(ans, e + f[u] + f[x]);
e = max(e, f[x]);
}
f[u] += e;
ans = max(ans, f[u]);
}
int main() {
int i, l, r;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i = i + 1) scanf("%d", a + i);
for (i = 1; i < n; i = i + 1) {
scanf("%d%d", &l, &r);
v[l].push_back(r);
v[r].push_back(l);
}
l = 1, r = inf;
while (l < r) {
m = (l + r + 1) >> 1;
memset(b, 0, sizeof(b));
memset(c, 0, sizeof(c));
memset(f, 0, sizeof(f));
for (i = 1; i <= n; i = i + 1)
if (a[i] >= m) f[i] = 1;
ans = 0;
for (i = 1; i <= n; i = i + 1) {
if (a[i] >= m && !c[i]) {
p = 0;
dfs1(i, 0);
if (!p) p = i;
dfs1(p, 0);
dfs2(p, 0);
}
}
if (ans >= k)
l = m;
else
r = m - 1;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, tot, l, r, mid, ans;
int a[200010], A[200010], ver[400010], Next[400010], head[200010];
int v[200010], sz[200010], f[200010], d[200010][2], g[200010][2], one[200010];
void add(int x, int y) { ver[++tot] = y, Next[tot] = head[x], head[x] = tot; }
void update(int y, int fy, int x) {
if (fy > d[x][0]) {
d[x][1] = d[x][0];
g[x][1] = g[x][0];
d[x][0] = fy;
g[x][0] = y;
} else if (fy > d[x][1]) {
d[x][1] = fy;
g[x][1] = y;
}
}
void dp(int x) {
v[x] = 1;
sz[x] = 1;
one[x] = a[x];
f[x] = 1;
d[x][0] = d[x][1] = g[x][0] = g[x][1] = 0;
for (int i = head[x]; i; i = Next[i]) {
int y = ver[i];
if (v[y]) continue;
dp(y);
sz[x] += sz[y];
one[x] += one[y];
if (sz[y] == one[y])
f[x] += one[y];
else
update(y, f[y], x);
}
f[x] += d[x][0];
if (!a[x]) f[x] = d[x][0] = g[x][0] = 0;
v[x] = 0;
}
void dfs(int x) {
v[x] = 1;
ans = max(ans, f[x]);
for (int i = head[x]; i; i = Next[i]) {
int y = ver[i];
if (v[y]) continue;
int fx = f[x], ox = one[x], sx = sz[x];
if (a[x]) {
if (sz[y] == one[y])
fx -= one[y];
else if (g[x][0] == y)
fx = fx - d[x][0] + d[x][1];
}
sx -= sz[y];
sz[y] += sx;
ox -= one[y];
one[y] += ox;
if (a[y]) {
if (sx == ox)
f[y] += ox;
else {
f[y] -= d[y][0];
update(x, fx, y);
f[y] += d[y][0];
}
}
dfs(y);
}
v[x] = 0;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y), add(y, x);
}
l = 0, r = 1000000;
while (l < r) {
int mid = (l + r + 1) / 2;
for (int i = 1; i <= n; i++) a[i] = A[i] >= mid ? 1 : 0;
ans = 0;
dp(1);
dfs(1);
if (ans >= m)
l = mid;
else
r = mid - 1;
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int powm(long long int a, int b, int n) {
long long int rm = 1;
while (b) {
if (b % 2) {
rm = (rm * a) % n;
}
a = (a * a) % n;
b /= 2;
}
return rm;
}
vector<int> edge[int(2e5 + 1000)], branch[int(2e5 + 1000)],
prefix[int(2e5 + 1000)], suffix[int(2e5 + 1000)];
vector<bool> blocked_ball[int(2e5 + 1000)];
int a[int(2e5 + 1000)], k, up[int(2e5 + 1000)], n, ans = 0;
pair<bool, int> dfs1(int vertex, int parent, int cutOff) {
pair<bool, int> return_block = make_pair(false, 0);
int mxadd = 0;
for (int i = 0; i < edge[vertex].size(); ++i) {
int vr = edge[vertex][i];
if (vr != parent) {
pair<bool, int> block = dfs1(vr, vertex, cutOff);
if (block.first) {
return_block.first = true;
blocked_ball[vertex][i] = true;
branch[vertex][i] = block.second;
mxadd = max(mxadd, block.second);
} else {
return_block.second += block.second;
blocked_ball[vertex][i] = false;
branch[vertex][i] = block.second;
}
} else {
up[vertex] = i;
}
}
return_block.second += mxadd;
if (a[vertex] < cutOff) {
return_block.first = true;
return_block.second = 0;
} else {
return_block.second++;
}
return return_block;
}
void dfs2(int vertex, int parent, int cutOff, pair<bool, int> block) {
if (vertex != 1) {
if (block.first) {
branch[vertex][up[vertex]] = block.second;
blocked_ball[vertex][up[vertex]] = true;
} else {
branch[vertex][up[vertex]] = block.second;
blocked_ball[vertex][up[vertex]] = false;
}
}
int proper = 0, sofar = 0;
int L = int(1e9 + 7), R = -1;
for (int i = 0; i < edge[vertex].size(); ++i) {
if (blocked_ball[vertex][i] == false) {
proper += branch[vertex][i];
} else {
sofar = max(sofar, branch[vertex][i]);
if (L == int(1e9 + 7)) L = i;
}
prefix[vertex][i] = sofar;
}
sofar = 0;
for (int i = edge[vertex].size() - 1; i >= 0; i--) {
if (blocked_ball[vertex][i] == true) {
sofar = max(sofar, branch[vertex][i]);
if (R == -1) R = i;
}
suffix[vertex][i] = sofar;
}
pair<bool, int> send;
for (int i = 0; i < edge[vertex].size(); ++i) {
int vr = edge[vertex][i];
if (vr != parent) {
send = make_pair(false, 0);
if (i > 0) send.second = prefix[vertex][i - 1];
if (i < edge[vertex].size() - 1)
send.second = max(send.second, suffix[vertex][i + 1]);
if (L < i) send.first = true;
if (R > i) send.first = true;
if (blocked_ball[vertex][i] == false)
send.second += proper - branch[vertex][i];
else
send.second += proper;
if (a[vertex] < cutOff) {
send = make_pair(true, 0);
} else {
send.second++;
}
dfs2(vr, vertex, cutOff, send);
}
}
if (a[vertex] >= cutOff) {
ans = max(ans, proper + prefix[vertex][edge[vertex].size() - 1] + 1);
}
}
bool go(int cutOff) {
ans = 0;
dfs1(1, 0, cutOff);
dfs2(1, 0, cutOff, make_pair(false, 0));
return (ans >= k);
}
int main() {
int u, v, f = 0;
scanf("%d", &n);
;
scanf("%d", &k);
;
for (int i = int(1); i <= (int)n; i++) {
scanf("%d", &a[i]);
;
f = max(f, a[i]);
}
for (int i = int(1); i <= (int)n - 1; i++) {
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
for (int i = int(1); i <= (int)n; i++) {
branch[i].resize(edge[i].size() + 2);
blocked_ball[i].resize(edge[i].size() + 2);
prefix[i].resize(edge[i].size() + 2);
suffix[i].resize(edge[i].size() + 2);
}
int it = 1, m;
while (it != f) {
m = (it + f) / 2;
if (go(m + 1))
it = m + 1;
else
f = m;
}
cout << f << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> val(n);
for (auto &i : val) cin >> i;
vector<vector<int>> adj(n);
for (int i = 1, u, v; i < n; ++i) {
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
auto solve = [&](int mn) {
auto w = [&](int u) { return val[u] >= mn; };
vector<int> sz(n), dp(n), wsz(n), rdp(n);
vector<multiset<int>> sub(n);
for (int i = 0; i < n; ++i) sub[i].insert(0);
function<void(int, int)> dfs = [&](int u, int p) {
sz[u] = 1;
wsz[u] = w(u);
for (auto v : adj[u])
if (v != p) {
dfs(v, u);
sz[u] += sz[v];
wsz[u] += wsz[v];
if (sz[v] == wsz[v])
dp[u] += sz[v];
else
sub[u].insert(rdp[v]);
}
rdp[u] = (dp[u] + 1 + *sub[u].rbegin()) * w(u);
};
dfs(0, -1);
int best = 0;
function<void(int, int)> dfs2 = [&](int u, int p) {
best = max(best, rdp[u]);
for (auto v : adj[u])
if (v != p) {
int rdpu = rdp[u], rdpv = rdp[v];
int dpu = dp[u], u_dpv = -1;
if (sz[v] == wsz[v])
dp[u] -= sz[v];
else
sub[u].erase(sub[u].find(rdp[v])), u_dpv = rdp[v];
int szu = sz[u], wszu = wsz[u];
sz[u] -= sz[v];
wsz[u] -= wsz[v];
rdp[u] = (dp[u] + 1 + *sub[u].rbegin()) * w(u);
int dpv = dp[v], szv = sz[v], wszv = wsz[v];
sz[v] += sz[u];
wsz[v] += wsz[u];
int v_dpu = -1;
if (sz[u] == wsz[u])
dp[v] += sz[u];
else
sub[v].insert(rdp[u]), v_dpu = rdp[u];
rdp[v] = (dp[v] + 1 + *sub[v].rbegin()) * w(v);
dfs2(v, u);
if (v_dpu != -1) sub[v].erase(sub[v].find(v_dpu));
sz[v] = szv;
wsz[v] = wszv;
dp[v] = dpv;
wsz[u] = wszu;
sz[u] = szu;
if (u_dpv != -1) sub[u].insert(u_dpv);
dp[u] = dpu;
rdp[u] = rdpu;
rdp[v] = rdpv;
}
};
dfs2(0, -1);
return best;
};
int lo = 1, hi = 1e6;
while (lo < hi) {
int md = (lo + hi + 1) >> 1;
if (solve(md) >= k)
lo = md;
else
hi = md - 1;
}
cout << lo << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
return os << "(" << v.first << ", " << v.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (int i = int(0); i <= int((static_cast<int>((v).size())) - 1); ++i) {
if (i) os << ", ";
os << v[i];
}
return os << "]";
}
template <class T>
bool setmax(T& _a, T _b) {
if (_a < _b) {
_a = _b;
return true;
}
return false;
}
template <class T>
bool setmin(T& _a, T _b) {
if (_b < _a) {
_a = _b;
return true;
}
return false;
}
template <class T>
T gcd(T _a, T _b) {
return _b == 0 ? _a : gcd(_b, _a % _b);
}
int main() {
int n, needed;
scanf("%d%d", &n, &needed);
vector<vector<int> > es(n);
vector<int> val(n), size(n);
for (int i = int(0); i <= int((n)-1); ++i) scanf("%d", &val[i]);
for (int i = int(0); i <= int((n - 1) - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
es[a].push_back(b), es[b].push_back(a);
}
const function<void(int, int)> build = [&](int x, int fa) {
size[x] = 1;
for (int y : es[x]) {
if (y == fa) continue;
build(y, x);
size[x] += size[y];
}
};
build(0, -1);
int limit = 0, le = 0, ri = 1000000;
bool found = false;
vector<int> up(n);
const function<void(int, int)> dfs_up = [&](int x, int fa) {
int sum = 0, best = 0;
for (int y : es[x]) {
if (y == fa) continue;
dfs_up(y, x);
if (up[y] == size[y]) {
sum += up[y];
} else {
setmax(best, up[y]);
}
}
up[x] = (val[x] >= limit ? 1 + sum + best : 0);
};
const function<void(int, int, int)> dfs_down = [&](int x, int fa, int down) {
vector<int> ys;
for (int y : es[x]) {
if (y != fa) ys.push_back(y);
}
const int m = static_cast<int>((ys).size());
vector<int> ls(m + 1), lb(m + 1), rs(m + 1), rb(m + 1);
for (int i = int(0); i <= int((m)-1); ++i) {
ls[i + 1] = ls[i], lb[i + 1] = lb[i];
if (up[ys[i]] == size[ys[i]]) {
ls[i + 1] += up[ys[i]];
} else {
setmax(lb[i + 1], up[ys[i]]);
}
}
for (int i = int((m)-1); i >= int(0); --i) {
rs[i] = rs[i + 1], rb[i] = rb[i + 1];
if (up[ys[i]] == size[ys[i]]) {
rs[i] += up[ys[i]];
} else {
setmax(rb[i], up[ys[i]]);
}
}
for (int i = int(0); i <= int((m)-1); ++i) {
int s = ls[i] + rs[i + 1], b = max(lb[i], rb[i + 1]);
if (down == n - size[x]) {
s += down;
} else {
setmax(b, down);
}
dfs_down(ys[i], x, val[x] >= limit ? 1 + s + b : 0);
}
if (val[x] >= limit) {
int s = ls[m], b = lb[m];
if (down == n - size[x]) {
s += down;
} else {
setmax(b, down);
}
if (1 + s + b >= needed) {
found = true;
}
}
};
while (le < ri) {
limit = (le + ri + 1) / 2;
found = false;
dfs_up(0, -1);
dfs_down(0, -1, 0);
if (found) {
le = limit;
} else {
ri = limit - 1;
}
}
printf("%d\n", le);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 13, INF = 1e7 + 13;
int dp[maxN], k, val[maxN], ans, node, n, sz[maxN];
vector<int> adj[maxN];
void dfs(int x, int par, int mn) {
sz[x] = 1;
dp[x] = 1;
int mx1 = 0, mx2 = 0;
for (auto a : adj[x]) {
if (a != par) {
dfs(a, x, mn);
sz[x] += sz[a];
if (dp[a] == sz[a])
dp[x] += dp[a];
else {
if (dp[a] > mx1) {
mx2 = mx1;
mx1 = dp[a];
} else
mx2 = max(mx2, dp[a]);
}
}
}
if (val[x] < mn) {
dp[x] = 0;
return;
}
ans = max(ans, dp[x] + mx1 + mx2);
dp[x] += mx1;
}
bool check(int val) {
memset(dp, 0, sizeof dp);
ans = 0;
dfs(node, node, val);
if (ans >= k) return 1;
return 0;
}
int main() {
cin >> n >> k;
int mini = INF;
for (int i = 0; i < n; i++) {
cin >> val[i];
if (val[i] < mini) {
mini = val[i];
node = i;
}
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
int l = 0, r = INF;
while (r - l > 1) {
int mid = l + r >> 1;
if (check(mid))
l = mid;
else
r = mid;
}
cout << l << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, ans;
int a[N], head[N], size[N], dp[N];
bool v[N];
struct edge {
int to, next;
} e[2 * N];
void push(int k, int x, int y) {
e[k].to = y;
e[k].next = head[x];
head[x] = k;
}
void dfs1(int k, int x) {
int p = head[k], ma = 0;
dp[k] = size[k] = v[k] = 1;
while (p) {
if (!v[e[p].to]) {
dfs1(e[p].to, x);
size[k] += size[e[p].to];
if (size[e[p].to] == dp[e[p].to])
dp[k] += dp[e[p].to];
else
ma = max(ma, dp[e[p].to]);
}
p = e[p].next;
}
dp[k] += ma;
if (a[k] < x) dp[k] = 0;
}
void update(int &x, int &y, int z) {
if (z > x) {
y = x;
x = z;
} else
y = max(y, z);
}
void dfs2(int k, int x, int t) {
v[k] = 1;
int p = head[k], s = 1, ma1 = 0, ma2 = 0;
if (t == n - size[k])
s += t;
else
update(ma1, ma2, t);
while (p) {
if (!v[e[p].to]) {
if (dp[e[p].to] == size[e[p].to])
s += dp[e[p].to];
else
update(ma1, ma2, dp[e[p].to]);
}
p = e[p].next;
}
if (a[k] >= x) ans = max(ans, s + ma1);
p = head[k];
while (p) {
if (!v[e[p].to]) {
if (a[k] < x)
dfs2(e[p].to, x, 0);
else if (dp[e[p].to] == size[e[p].to])
dfs2(e[p].to, x, s + ma1 - dp[e[p].to]);
else if (dp[e[p].to] == ma1)
dfs2(e[p].to, x, s + ma2);
else
dfs2(e[p].to, x, s + ma1);
}
p = e[p].next;
}
}
int solve(int x) {
memset(v + 1, 0, n * sizeof(bool));
dfs1(1, x);
ans = 0;
memset(v + 1, 0, n * sizeof(bool));
dfs2(1, x, 0);
return ans;
}
int main() {
int k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
push(2 * i - 1, x, y);
push(2 * i, y, x);
}
int l = 1, r = 1000000;
while (l <= r) {
int mid = (l + r) >> 1;
if (solve(mid) >= k)
l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int n, k, a[MAXN];
struct graph {
int ecnt, head[MAXN], nxt[MAXN << 1], to[MAXN << 1];
void clear() {
ecnt = 0;
memset(head, 0, sizeof(head));
memset(nxt, 0, sizeof(nxt));
memset(to, 0, sizeof(to));
}
graph() { clear(); }
void adde(int u, int v) {
to[++ecnt] = v;
nxt[ecnt] = head[u];
head[u] = ecnt;
}
} t;
int siz[MAXN];
void dfspre(int x, int f) {
siz[x] = 1;
for (int e = t.head[x]; e; e = t.nxt[e]) {
int y = t.to[e];
if (y == f) continue;
dfspre(y, x);
siz[x] += siz[y];
}
}
bool mark[MAXN];
int hav[MAXN], dp[MAXN], ff[MAXN], out[MAXN], maxdp[MAXN];
void dfs(int x, int f) {
int mx = 0;
for (int e = t.head[x]; e; e = t.nxt[e]) {
int y = t.to[e];
if (y == f) continue;
dfs(y, x);
hav[x] += hav[y];
if (hav[y] == siz[y])
dp[x] += siz[y];
else
mx = max(mx, dp[y]);
}
dp[x] += mx;
if (!mark[x])
dp[x] = 0;
else
dp[x]++;
}
void cgrt(int x, int f) {
int mx = 0, sum = 0;
for (int e = t.head[x]; e; e = t.nxt[e]) {
int y = t.to[e];
if (y != f) {
if (hav[y] == siz[y])
ff[x] += siz[y];
else
mx = max(mx, dp[y]);
} else {
if (hav[1] - hav[x] == siz[1] - siz[x])
ff[x] += siz[1] - siz[x];
else
mx = max(mx, out[x]);
}
}
ff[x] += mx;
if (!mark[x])
ff[x] = 0;
else
ff[x]++;
vector<int> son;
for (int e = t.head[x]; e; e = t.nxt[e]) son.push_back(t.to[e]);
mx = sum = 0;
for (int i = 0; i < son.size(); i++) {
int y = son[i];
if (y != f) {
maxdp[y] = max(maxdp[y], mx);
out[y] += sum;
if (hav[y] == siz[y])
sum += hav[y];
else
mx = max(mx, dp[y]);
} else {
if (hav[1] - hav[x] == siz[1] - siz[x])
sum += siz[1] - siz[x];
else
mx = max(mx, out[x]);
}
}
mx = sum = 0;
for (int i = son.size() - 1; ~i; i--) {
int y = son[i];
if (y != f) {
maxdp[y] = max(maxdp[y], mx);
out[y] += sum;
if (hav[y] == siz[y])
sum += hav[y];
else
mx = max(mx, dp[y]);
} else {
if (hav[1] - hav[x] == siz[1] - siz[x])
sum += siz[1] - siz[x];
else
mx = max(mx, out[x]);
}
}
for (int e = t.head[x]; e; e = t.nxt[e]) {
int y = t.to[e];
if (y == f) continue;
out[y] += maxdp[y];
if (!mark[x])
out[y] = 0;
else
out[y]++;
cgrt(y, x);
}
}
bool check(int mid) {
memset(mark, 0, sizeof(mark));
memset(hav, 0, sizeof(hav));
memset(dp, 0, sizeof(dp));
memset(ff, 0, sizeof(ff));
memset(out, 0, sizeof(out));
memset(maxdp, 0, sizeof(maxdp));
for (int i = 1; i <= n; i++)
if (a[i] >= mid) mark[i] = hav[i] = 1;
dfs(1, 0);
cgrt(1, 0);
for (int i = 1; i <= n; i++)
if (ff[i] >= k) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
t.adde(u, v);
t.adde(v, u);
}
dfspre(1, 0);
int l = 1, r = 1e6, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
ans = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int powm(long long int a, int b, int n) {
long long int rm = 1;
while (b) {
if (b % 2) {
rm = (rm * a) % n;
}
a = (a * a) % n;
b /= 2;
}
return rm;
}
vector<int> edge[int(2e5 + 1000)], branch[int(2e5 + 1000)],
prefix[int(2e5 + 1000)], suffix[int(2e5 + 1000)];
vector<bool> blocked_ball[int(2e5 + 1000)];
int a[int(2e5 + 1000)], k, up[int(2e5 + 1000)], n, ans = 0;
pair<bool, int> dfs1(int vertex, int parent, int cutOff) {
pair<bool, int> return_block = make_pair(false, 0);
int mxadd = 0;
for (int i = 0; i < edge[vertex].size(); ++i) {
int vr = edge[vertex][i];
if (vr != parent) {
pair<bool, int> block = dfs1(vr, vertex, cutOff);
if (block.first) {
return_block.first = true;
blocked_ball[vertex][i] = true;
branch[vertex][i] = block.second;
mxadd = max(mxadd, block.second);
} else {
return_block.second += block.second;
blocked_ball[vertex][i] = false;
branch[vertex][i] = block.second;
}
} else {
up[vertex] = i;
}
}
return_block.second += mxadd;
if (a[vertex] < cutOff) {
return_block.first = true;
return_block.second = 0;
} else {
return_block.second++;
}
return return_block;
}
void dfs2(int vertex, int parent, int cutOff, pair<bool, int> block) {
if (vertex != 1) {
if (block.first) {
branch[vertex][up[vertex]] = block.second;
blocked_ball[vertex][up[vertex]] = true;
} else {
branch[vertex][up[vertex]] = block.second;
blocked_ball[vertex][up[vertex]] = false;
}
}
int proper = 0, sofar = 0;
int L = int(1e9 + 7), R = -1;
for (int i = 0; i < edge[vertex].size(); ++i) {
if (blocked_ball[vertex][i] == false) {
proper += branch[vertex][i];
} else {
sofar = max(sofar, branch[vertex][i]);
if (L == int(1e9 + 7)) L = i;
}
prefix[vertex][i] = sofar;
}
sofar = 0;
for (int i = edge[vertex].size() - 1; i >= 0; i--) {
if (blocked_ball[vertex][i] == true) {
sofar = max(sofar, branch[vertex][i]);
if (R == -1) R = i;
}
suffix[vertex][i] = sofar;
}
pair<bool, int> send;
for (int i = 0; i < edge[vertex].size(); ++i) {
int vr = edge[vertex][i];
if (vr != parent) {
send = make_pair(false, 0);
if (i > 0) send.second = prefix[vertex][i - 1];
if (i < edge[vertex].size() - 1)
send.second = max(send.second, suffix[vertex][i + 1]);
if (L < i) send.first = true;
if (R > i) send.first = true;
if (blocked_ball[vertex][i] == false)
send.second += proper - branch[vertex][i];
else
send.second += proper;
if (a[vertex] < cutOff) {
send = make_pair(true, 0);
} else {
send.second++;
}
dfs2(vr, vertex, cutOff, send);
}
}
if (a[vertex] >= cutOff) {
ans = max(ans, proper + prefix[vertex][edge[vertex].size() - 1] + 1);
}
}
bool go(int cutOff) {
ans = 0;
dfs1(1, 0, cutOff);
dfs2(1, 0, cutOff, make_pair(false, 0));
return (ans >= k);
}
int main() {
int u, v, f = 0;
scanf("%d", &n);
;
scanf("%d", &k);
;
for (int i = int(1); i <= (int)n; i++) {
scanf("%d", &a[i]);
;
f = max(f, a[i]);
}
for (int i = int(1); i <= (int)n - 1; i++) {
scanf("%d", &u);
;
scanf("%d", &v);
;
edge[u].push_back(v);
edge[v].push_back(u);
}
for (int i = int(1); i <= (int)n; i++) {
branch[i].resize(edge[i].size() + 2);
blocked_ball[i].resize(edge[i].size() + 2);
prefix[i].resize(edge[i].size() + 2);
suffix[i].resize(edge[i].size() + 2);
}
int it = 1, m;
while (it != f) {
m = (it + f) / 2;
if (go(m + 1))
it = m + 1;
else
f = m;
}
printf("%d\n", f);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, ans = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ans = ans * 10 + c - '0';
c = getchar();
}
return f * ans;
}
const int MAXN = 2e5 + 11;
int N, K, W[MAXN], Lim, A[MAXN], f[MAXN], Siz[MAXN], siz[MAXN];
vector<int> vec[MAXN];
void dfs(int u, int fath) {
Siz[u] = (A[u]), siz[u] = 1;
int Maxn = 0;
for (auto v : vec[u]) {
if (v == fath) continue;
dfs(v, u);
Siz[u] += Siz[v], siz[u] += siz[v];
if (A[u]) {
if (Siz[v] == siz[v])
f[u] += siz[v];
else
Maxn = max(Maxn, f[v]);
}
}
if (A[u]) f[u] += Maxn + 1;
return;
}
bool ff;
void dfs1(int u, int fath) {
int t = siz[u];
siz[u] = N;
if (A[u]) {
int Maxn = 0, Ans = 0;
for (auto v : vec[u]) {
if (Siz[v] == siz[v])
Ans += siz[v];
else
Maxn = max(Maxn, f[v]);
}
f[u] = Maxn + Ans + 1;
if (Maxn + Ans + 1 >= K) ff = 1;
}
int s = f[u];
int Maxn1 = 0, Maxn2 = 0;
for (auto v : vec[u]) {
if (Siz[v] != siz[v]) {
if (f[v] >= Maxn1)
Maxn2 = Maxn1, Maxn1 = f[v];
else if (f[v] > Maxn2)
Maxn2 = f[v];
}
}
for (auto v : vec[u]) {
if (v == fath) continue;
siz[u] -= siz[v];
if (!A[u]) {
Siz[u] -= Siz[v];
Siz[v] += Siz[u];
dfs1(v, u);
Siz[v] -= Siz[u];
Siz[u] += Siz[v];
} else if (siz[v] == Siz[v] && A[u]) {
Siz[u] -= Siz[v];
f[u] -= siz[v];
Siz[v] += Siz[u];
dfs1(v, u);
f[u] += siz[v];
Siz[v] -= Siz[u];
Siz[u] += Siz[v];
} else {
if (f[v] == Maxn1) {
f[u] -= Maxn1;
f[u] += Maxn2;
Siz[u] -= Siz[v];
Siz[v] += Siz[u];
dfs1(v, u);
Siz[v] -= Siz[u];
f[u] += Maxn1;
f[u] -= Maxn2;
Siz[u] += Siz[v];
} else {
Siz[u] -= Siz[v];
Siz[v] += Siz[u];
dfs1(v, u);
Siz[v] -= Siz[u];
Siz[u] += Siz[v];
}
}
siz[u] += siz[v];
}
siz[u] = t;
return;
}
bool check() {
ff = 0;
for (int i = 1; i <= N; i++) A[i] = (W[i] >= Lim);
memset(siz, 0, sizeof(siz)), memset(f, 0, sizeof(f)),
memset(Siz, 0, sizeof(Siz));
dfs(1, 0);
dfs1(1, 0);
return ff;
}
int main() {
N = read(), K = read();
for (int i = 1; i <= N; i++) W[i] = read();
for (int i = 1; i < N; i++) {
int u = read(), v = read();
vec[u].push_back(v), vec[v].push_back(u);
}
int l = 1, r = 1e6, res = -1;
while (l <= r) {
int mid = (l + r) >> 1;
Lim = mid;
if (check())
res = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void next_int(T &x) {
x = 0;
char c;
bool neg = false;
while (!isdigit(c = getchar()))
if (c == '-') neg = true;
do x = x * 10 + c - 48;
while (isdigit(c = getchar()));
if (neg) x = -x;
}
template <typename T>
inline void write_int(T x, char last = 0) {
if (x < 0) putchar('-'), x = abs(x);
char tmp[20];
int cnt = 0;
while (x >= 10) tmp[cnt++] = x % 10 + 48, x /= 10;
tmp[cnt] = x + 48;
for (int i = (cnt); i >= (0); --i) putchar(tmp[i]);
if (last) putchar(last);
}
const int N = (int)2e5 + 5;
int n, k, dp[N], a[N], sz[N], maxp[N];
vector<int> g[N];
void dfs_prep(int u, int p, const int &mid) {
sz[u] = 1, maxp[u] = 0;
int maxsub = 0;
for (auto v : g[u])
if (v != p) {
dfs_prep(v, u, mid);
sz[u] += sz[v];
if (maxp[v] == sz[v])
maxp[u] += maxp[v];
else
maxsub = max(maxsub, maxp[v]);
}
if (a[u] >= mid)
maxp[u] += maxsub + 1;
else
maxp[u] = 0;
}
void dfs_res(int u, int p, int &res, const int &mid) {
int max1 = 0, max2 = 0, cnt = 0;
for (auto v : g[u]) {
if ((v == p && dp[u] == n - sz[u]) || (v != p && maxp[v] == sz[v])) {
cnt += (v == p ? dp[u] : maxp[v]);
continue;
}
int val = v == p ? dp[u] : maxp[v];
if (max1 == 0 || (max1 == p ? dp[u] : maxp[max1]) < val)
max2 = max1, max1 = v;
else if (max2 == 0 || (max2 == p ? dp[u] : maxp[max2]) < val)
max2 = v;
}
for (auto v : g[u])
if (v != p) {
if (a[u] >= mid) {
if (sz[v] == maxp[v])
dp[v] = cnt - maxp[v] + (max1 == p ? dp[u] : maxp[max1]) + 1;
else {
if (max1 == v)
dp[v] = cnt + (max2 == p ? dp[u] : maxp[max2]) + 1;
else
dp[v] = cnt + (max1 == p ? dp[u] : maxp[max1]) + 1;
}
} else
dp[v] = 0;
dfs_res(v, u, res, mid);
}
if (a[u] >= mid) res = max(res, cnt + (max1 == p ? dp[u] : maxp[max1]) + 1);
}
bool check(int mid) {
int res = 0;
dfs_prep(1, 0, mid);
dfs_res(1, 0, res, mid);
return res >= k;
}
int main() {
next_int(n), next_int(k);
for (int i = (1); i <= (n); ++i) next_int(a[i]);
for (int i = (1); i < (n); ++i) {
int u, v;
next_int(u), next_int(v);
g[u].push_back(v);
g[v].push_back(u);
}
int lo = 1, hi = (int)1e6, ans = 1, mid;
while (lo <= hi) {
mid = (lo + hi) >> 1;
if (check(mid))
ans = mid, lo = mid + 1;
else
hi = mid - 1;
}
write_int(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &s, const pair<A, B> &p) {
return s << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &c) {
s << "[ ";
for (auto it : c) s << it << " ";
s << "]";
return s;
}
const int MAXN = 202020;
int N, K;
int arr[MAXN];
vector<int> edge[MAXN];
bool ok[MAXN];
bool aw[MAXN], awu[MAXN];
int dn[MAXN], dnu[MAXN], num[MAXN];
int wei[MAXN];
void dfs(int v, int p) {
vector<int> vch;
for (auto c : edge[v])
if (c != p) vch.push_back(c);
for (auto c : vch) dfs(c, v);
wei[v] = 1;
for (auto c : vch) wei[v] += wei[c];
aw[v] = ok[v];
for (auto c : vch)
if (!aw[c]) aw[v] = false;
dn[v] = 0;
if (ok[v]) {
dn[v] = 1;
int mx = 0;
for (auto c : vch) {
if (aw[c])
dn[v] += wei[c];
else
mx = max(mx, dn[c]);
}
dn[v] += mx;
}
}
void dfs2(int v, int p) {
vector<int> vch;
for (auto c : edge[v])
if (c != p) vch.push_back(c);
if (p == -1) {
awu[v] = true;
dnu[v] = 0;
}
vector<int> vnotw;
for (auto c : vch)
if (!aw[c]) vnotw.push_back(c);
for (auto c : vch) {
if (vnotw.size() >= 2 || !awu[v] || !ok[v])
awu[c] = false;
else if (vnotw.empty())
awu[c] = true;
else
awu[c] = (vnotw[0] == c);
}
int wsum = 0, m1 = 0, m2 = 0;
for (auto c : vch) {
if (aw[c])
wsum += wei[c];
else {
m2 = max(m2, dn[c]);
if (m2 > m1) swap(m2, m1);
}
}
if (awu[v])
wsum += N - wei[v];
else {
m2 = max(m2, dnu[v]);
if (m2 > m1) swap(m2, m1);
}
if (!ok[v])
num[v] = 0;
else
num[v] = wsum + m1 + 1;
for (auto c : vch) {
if (!ok[v])
dnu[c] = 0;
else {
dnu[c] = 1;
if (aw[c])
dnu[c] += wsum - wei[c] + m1;
else if (dn[c] == m1)
dnu[c] += wsum + m2;
else
dnu[c] += wsum + m1;
}
}
for (auto c : vch) dfs2(c, v);
}
bool test(int thr) {
memset((aw), 0, sizeof(aw));
memset((awu), 0, sizeof(awu));
memset((dn), 0, sizeof(dn));
memset((dnu), 0, sizeof(dnu));
memset((num), 0, sizeof(num));
for (int i = 0; i < N; i++) ok[i] = (arr[i] >= thr);
dfs(0, -1);
dfs2(0, -1);
for (int i = 0; i < N; i++)
if (num[i] >= K) return true;
return false;
}
int calc() {
int lb = 0, rb = 1010101;
while (lb < rb) {
int mb = (lb + rb + 1) >> 1;
if (test(mb))
lb = mb;
else
rb = mb - 1;
}
return lb;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> arr[i];
for (int i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
edge[a].push_back(b);
edge[b].push_back(a);
}
int ans = calc();
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200200;
int n, k, a[MAXN], tag[MAXN], ans, cnt;
vector<int> G[MAXN];
int sz[MAXN], dp[MAXN], tag_cnt[MAXN];
void init(int val) {
ans = cnt = 0;
for (int i = 1; i <= n; i++) {
tag[i] = a[i] >= val;
cnt += tag[i];
}
memset(tag_cnt, 0, sizeof(tag_cnt));
}
void dfs1(int cur, int fa) {
sz[cur] = 1;
for (int i = 0; i < G[cur].size(); i++) {
int u = G[cur][i];
if (u == fa) continue;
dfs1(u, cur);
sz[cur] += sz[u];
}
}
void dfs2(int cur, int fa) {
if (ans >= k) return;
int all = 0, max1 = 0, max2 = 0;
for (int i = 0; i < G[cur].size(); i++) {
int u = G[cur][i];
if (u == fa) continue;
dfs2(u, cur);
tag_cnt[cur] += tag_cnt[u];
if (dp[u] == sz[u])
all += dp[u];
else if (dp[u] > max1)
max2 = max1, max1 = dp[u];
else if (dp[u] > max2)
max2 = dp[u];
}
if (!tag[cur])
dp[cur] = 0;
else {
dp[cur] = all + max1 + 1;
tag_cnt[cur]++;
}
if (n - sz[cur] == cnt - tag_cnt[cur]) all += n - sz[cur];
if (tag[cur]) ans = max(ans, all + max1 + max2 + 1);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
int l = 1, r = 1000000;
dfs1(1, 0);
while (l <= r) {
int mid = (l + r) >> 1;
init(mid);
dfs2(1, 0);
if (ans >= k)
l = mid + 1;
else
r = mid - 1;
}
printf("%d", r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class... Types>
std::ostream &operator<<(std::ostream &out, const std::tuple<Types...> &value);
template <class c1>
ostream &_out(ostream &ost, c1 a, c1 b);
template <class T1, class T2>
ostream &operator<<(ostream &ost, pair<T1, T2> _cnt);
template <class T1>
ostream &operator<<(ostream &ost, vector<T1> _cnt) {
return _out(ost, _cnt.begin(), _cnt.end());
}
template <class T1>
ostream &operator<<(ostream &ost, deque<T1> _cnt) {
return _out(ost, _cnt.begin(), _cnt.end());
}
template <class T1>
ostream &operator<<(ostream &ost, queue<T1> _cnt) {
return _out(ost, _cnt.begin(), _cnt.end());
}
template <class T1>
ostream &operator<<(ostream &ost, list<T1> _cnt) {
return _out(ost, _cnt.begin(), _cnt.end());
}
template <class T1, class T2>
ostream &operator<<(ostream &ost, set<T1, T2> _cnt) {
return _out(ost, _cnt.begin(), _cnt.end());
}
template <class T1, class T2, class T3>
ostream &operator<<(ostream &ost, map<T1, T2, T3> _cnt) {
return _out(ost, _cnt.begin(), _cnt.end());
}
template <class T1, class T2>
ostream &operator<<(ostream &ost, multiset<T1, T2> _cnt) {
return _out(ost, _cnt.begin(), _cnt.end());
}
template <class T1, class T2, class T3>
ostream &operator<<(ostream &ost, multimap<T1, T2, T3> _cnt) {
return _out(ost, _cnt.begin(), _cnt.end());
}
template <class T1, class T2>
ostream &operator<<(ostream &ost, pair<T1, T2> _cnt) {
return ost << '(' << _cnt.first << ", " << _cnt.second << ')';
}
template <class T1>
ostream &_out(ostream &ost, T1 a, T1 b) {
ost << '{';
if (a != b) {
ost << *a;
while (++a != b) ost << ' ' << *a;
}
return ost << '}';
}
template <class Type, unsigned N, unsigned Last>
struct tuple_printer {
static void print(std::ostream &out, const Type &value) {
out << std::get<N>(value) << ", ";
tuple_printer<Type, N + 1, Last>::print(out, value);
}
};
template <class Type, unsigned N>
struct tuple_printer<Type, N, N> {
static void print(std::ostream &out, const Type &value) {
out << std::get<N>(value);
}
};
template <class... Types>
std::ostream &operator<<(std::ostream &out, const std::tuple<Types...> &value) {
out << '(';
tuple_printer<std::tuple<Types...>, 0, sizeof...(Types) - 1>::print(out,
value);
out << ')';
return out;
}
vector<string> _split(const string &s, char c) {
int br = 0;
vector<string> v(1);
for (int i = 0; i < (((int)(s).size())); ++i) {
if (s[i] == '[' || s[i] == '(' || s[i] == '{' || s[i] == '<')
br++;
else if (s[i] == ']' || s[i] == ')' || s[i] == '}' || s[i] == '>')
br--;
if (s[i] == c && br == 0)
v.push_back("");
else
v.back().push_back(s[i]);
}
return move(v);
}
void _erre(vector<string>::iterator it) { (void)it; }
template <class T, class... Args>
void _erre(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
_erre(++it, args...);
}
void _err(vector<string>::iterator it) {
(void)it;
cerr << '\n';
}
template <class T, class... Args>
void _err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << ", ";
_err(++it, args...);
}
template <class T>
T maxx(T g) {
return g;
}
template <class T, class... Args>
T maxx(T a, Args... args) {
return max(a, maxx(args...));
}
template <class T>
T minn(T g) {
return g;
}
template <class T, class... Args>
T minn(T a, Args... args) {
return min(a, minn(args...));
}
int n, k, num_good;
int tim[200010], siz[200010], siz_good[200010], sum_full[200010], res[200010];
pair<pair<int, int>, pair<int, int> > best_nfull[200010];
vector<int> v[200010];
bool good[200010], full[200010];
void dfsSize(int cur, int pp = -1) {
siz_good[cur] = good[cur];
siz[cur] = 1;
for (int i : v[cur]) {
if (i == pp) continue;
dfsSize(i, cur);
siz_good[cur] += siz_good[i];
siz[cur] += siz[i];
}
if (siz[cur] == siz_good[cur]) full[cur] = true;
}
void dfsSub(int cur, int pp = -1) {
sum_full[cur] = 1;
for (int i : v[cur]) {
if (i == pp) continue;
dfsSub(i, cur);
if (full[i])
sum_full[cur] += siz[i];
else {
if (best_nfull[cur].first.first < sum_full[i] + best_nfull[i].first.first)
best_nfull[cur] = {{sum_full[i] + best_nfull[i].first.first, i},
best_nfull[cur].first};
else if (best_nfull[cur].second.first <
sum_full[i] + best_nfull[i].first.first)
best_nfull[cur].second = {sum_full[i] + best_nfull[i].first.first, i};
}
}
if (!good[cur]) {
sum_full[cur] = 0;
best_nfull[cur] = make_pair(make_pair(0, 0), make_pair(0, 0));
}
}
void dfsCalc(int cur, int pp = -1, int par_best_nfull = 0) {
int sum = sum_full[cur];
pair<int, int> best1 = best_nfull[cur].first, best2 = best_nfull[cur].second;
if (n - num_good == siz[cur] - siz_good[cur])
sum += (n - siz[cur]);
else {
if (best1.first <= par_best_nfull) {
best2 = best1;
best1 = {par_best_nfull, -1};
} else if (best2.first <= par_best_nfull)
best2 = {par_best_nfull, -1};
}
if (good[cur]) res[cur] = sum + best1.first;
for (int i : v[cur]) {
if (i == pp) continue;
int par_best_nfull2 = sum;
if (full[i]) par_best_nfull2 -= siz[i];
if (best1.second == i)
par_best_nfull2 += best2.first;
else
par_best_nfull2 += best1.first;
if (!good[cur]) par_best_nfull2 = 0;
dfsCalc(i, cur, par_best_nfull2);
}
}
bool ok(int bin) {
num_good = 0;
for (int i = (1); i <= (n); ++i) {
good[i] = tim[i] >= bin;
num_good += good[i];
siz[i] = siz_good[i] = sum_full[i] = res[i] = full[i] = 0;
best_nfull[i] = make_pair(make_pair(0, 0), make_pair(0, 0));
}
dfsSize(1);
dfsSub(1);
dfsCalc(1);
for (int i = (1); i <= (n); ++i)
if (res[i] >= k) return true;
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cin >> n >> k;
int l = 1, r = 0;
for (int i = (1); i <= (n); ++i) {
cin >> tim[i];
r = max(r, tim[i]);
}
for (int i = 0; i < (n - 1); ++i) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
int last = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (ok(mid)) {
last = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << last << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
vector<int> vc[200001];
int ar[200001], K;
int sz[200001], on[200001];
int dp[200001][2], mx, n;
void dfs1(int c, int p) {
sz[c] = 1;
for (int i = (0); i < (vc[c].size()); ++i) {
if (vc[c][i] == p) continue;
dfs1(vc[c][i], c);
sz[c] += sz[vc[c][i]];
}
}
void dfs(int m, int c, int p) {
dp[c][0] = dp[c][1] = 0;
for (int i = (0); i < (vc[c].size()); ++i) {
if (vc[c][i] == p) continue;
dfs(m, vc[c][i], c);
if (sz[vc[c][i]] == dp[vc[c][i]][0])
dp[c][0] += dp[vc[c][i]][0];
else
dp[c][1] = max(dp[c][1], dp[vc[c][i]][1]);
}
if (ar[c] < m) {
on[c] = 0;
dp[c][0] = dp[c][1] = 0;
} else {
on[c] = 1;
dp[c][0]++;
dp[c][1] += dp[c][0];
}
}
int chk = 0;
void go(int c, int p, int d0, int d1, int tot) {
int mxx1 = 0, mxx2 = 0, mxx3 = 0;
if (d0 == tot)
mxx1 += d0;
else {
if (d1 > mxx2) {
mxx3 = mxx2;
mxx2 = d1;
} else if (d1 > mxx3) {
mxx3 = d1;
}
}
for (int i = (0); i < (vc[c].size()); ++i) {
if (vc[c][i] == p) continue;
if (sz[vc[c][i]] == dp[vc[c][i]][0])
mxx1 += dp[vc[c][i]][0];
else {
if (dp[vc[c][i]][1] > mxx2) {
mxx3 = mxx2;
mxx2 = dp[vc[c][i]][1];
} else if (dp[vc[c][i]][1] > mxx3) {
mxx3 = dp[vc[c][i]][1];
}
}
}
tot = n;
if (on[c]) {
mxx1++;
mxx2 += mxx1;
mxx3 += mxx1;
mx = max(mx, mxx2);
} else {
mxx1 = mxx2 = 0;
for (int i = (0); i < (vc[c].size()); ++i) {
if (vc[c][i] == p) continue;
go(vc[c][i], c, 0, 0, tot - sz[vc[c][i]]);
}
return;
}
for (int i = (0); i < (vc[c].size()); ++i) {
if (vc[c][i] == p) continue;
if (sz[vc[c][i]] == dp[vc[c][i]][0])
go(vc[c][i], c, mxx1 - dp[vc[c][i]][0], mxx2 - dp[vc[c][i]][0],
tot - sz[vc[c][i]]);
else if (mxx2 - mxx1 == dp[vc[c][i]][1])
go(vc[c][i], c, mxx1, mxx3, tot - sz[vc[c][i]]);
else
go(vc[c][i], c, mxx1, mxx2, tot - sz[vc[c][i]]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> K;
for (int i = (1); i < (n + 1); ++i) cin >> ar[i];
for (int i = (0); i < (n - 1); ++i) {
int x, y;
cin >> x >> y;
vc[x].push_back(y);
vc[y].push_back(x);
}
dfs1(1, 0);
int lo = 1, hi = 1000000, mid = (lo + hi) / 2;
while (lo < mid) {
memset(on, 0, sizeof on);
dfs(mid, 1, 0);
mx = 0;
go(1, 0, 0, 0, 0);
if (mx >= K)
lo = mid;
else
hi = mid - 1;
mid = (lo + hi) / 2;
}
memset(on, 0, sizeof on);
dfs(mid + 1, 1, 0);
mx = 0;
go(1, 0, 0, 0, 0);
if (mx >= K) mid++;
cout << mid << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const long long inf = 1e18;
int a[maxn];
vector<int> g[maxn];
bool c[maxn], ok[maxn];
int dpdown[maxn], dpup[maxn];
int salem[maxn];
int mxdown[maxn], mxup[maxn];
int cnt[maxn];
int sum[maxn];
int n;
int dip[maxn];
void dfsdown(int v, int p) {
ok[v] = c[v];
cnt[v] = 1;
sum[v] = c[v];
for (auto u : g[v])
if (u != p) dfsdown(u, v), cnt[v] += cnt[u], sum[v] += sum[u];
if (!c[v]) return;
for (auto u : g[v])
if (u != p)
if (ok[u])
salem[v] += cnt[u];
else {
ok[v] = 0;
mxdown[v] = max(mxdown[v], dpdown[u]);
}
dpdown[v] = mxdown[v] + salem[v] + 1;
}
void dfsup(int v, int p) {
int _mx = -1;
for (auto u : g[v])
if (u != p && c[u] && c[v])
mxup[u] = max(mxup[u], _mx), _mx = max(_mx, (1 - ok[u]) * dpdown[u]);
reverse(g[v].begin(), g[v].end());
_mx = -1;
for (auto u : g[v])
if (u != p && c[u] && c[v])
mxup[u] = max(mxup[u], _mx), _mx = max(_mx, (1 - ok[u]) * dpdown[u]);
for (auto u : g[v])
if (u != p)
if (c[u])
if (c[v])
if (sum[1] - sum[v] == n - cnt[v])
dpup[u] = 1 + salem[v] - (ok[u] ? cnt[u] : 0) + mxup[u] + dpup[v];
else
dpup[u] =
1 + salem[v] - (ok[u] ? cnt[u] : 0) + max(mxup[u], dpup[v]);
for (auto u : g[v])
if (u != p)
if (c[u])
if (c[v])
if (sum[1] - sum[u] == n - cnt[u])
dip[u] = 1 + salem[u] + dpup[u] + mxdown[u];
else
dip[u] = 1 + salem[u] + max(dpup[u], mxdown[u]);
for (auto u : g[v])
if (u != p) dfsup(u, v);
}
int check(int mid) {
for (int i = 1; i <= n; ++i)
dip[i] = salem[i] = ok[i] = cnt[i] = dpdown[i] = dpup[i] = mxup[i] =
mxdown[i] = 0;
for (int i = 1; i <= n; ++i) c[i] = (a[i] >= mid);
dfsdown(1, 0);
dfsup(1, 0);
int mx = 0;
for (int i = 1; i <= n; ++i)
mx = max(max(mx, dip[i]), max(dpdown[i], dpup[i]));
return mx;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int k;
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int l = 1, r = 1e6 + 85;
while (r - l > 1) {
int mid = (l + r) / 2;
if (check(mid) >= k)
l = mid;
else
r = mid;
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
int sz[N];
int n, k;
int downdp[N], updp[N], valid[N], a[N];
vector<int> g[N];
inline void dfssz(int v, int p = -1) {
sz[v] = 1;
for (auto to : g[v]) {
if (to == p) continue;
dfssz(to, v);
sz[v] += sz[to];
}
}
inline void dfsdown(int v, int p = -1) {
int val1 = 0, val2 = 0;
for (auto to : g[v]) {
if (to == p) continue;
dfsdown(to, v);
if (sz[to] == downdp[to])
val1 += sz[to];
else
val2 = max(val2, downdp[to]);
}
downdp[v] = 1 + val1 + val2;
if (!valid[v]) downdp[v] = 0;
}
inline void setmax(int &mx1, int &mx2, int nval) {
if (mx1 < mx2) swap(mx1, mx2);
if (nval >= mx1)
mx2 = mx1, mx1 = nval;
else if (nval >= mx2)
mx2 = nval;
}
inline void dfsup(int v, int p = -1) {
int val1 = 0, val2 = 0, val3 = 0;
if (updp[v] == n - sz[v])
val1 = updp[v];
else
val2 = updp[v];
for (auto to : g[v]) {
if (to == p) continue;
if (downdp[to] == sz[to])
val1 += sz[to];
else
setmax(val2, val3, downdp[to]);
}
if (!valid[v]) val1 = val2 = val3 = 0;
for (auto to : g[v]) {
if (to == p) continue;
if (downdp[to] == sz[to]) {
updp[to] = max(0, val1 - sz[to]) + val2 + valid[v];
dfsup(to, v);
} else {
if (downdp[to] == val2)
updp[to] = val1 + val3 + valid[v];
else
updp[to] = val1 + val2 + valid[v];
dfsup(to, v);
}
}
}
inline bool ok(int x) {
for (int i = 1; i <= n; ++i) {
valid[i] = (a[i] >= x), updp[i] = 0;
}
dfsdown(1);
dfsup(1);
for (int i = 1; i <= n; ++i) {
if (!valid[i]) continue;
int dpibek = 0, dpibek2 = 0;
for (auto to : g[i]) {
if (sz[to] > sz[i]) continue;
if (sz[to] == downdp[to])
dpibek += downdp[to];
else
dpibek2 = max(dpibek2, downdp[to]);
}
if (updp[i] == n - sz[i])
dpibek += n - sz[i];
else
dpibek2 = max(dpibek2, updp[i]);
if (dpibek + dpibek2 + 1 >= k) return 1;
}
return 0;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int foo, bar;
cin >> foo >> bar;
g[foo].emplace_back(bar);
g[bar].emplace_back(foo);
}
dfssz(1);
int l = 0, r = 1e6 + 1;
while (r - l > 1) {
int mid = (r + l) >> 1;
if (ok(mid))
l = mid;
else
r = mid;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int MAXN = 200500;
struct state {
int all;
int val;
int part1, part2;
void update(int p) {
if (p > part2) {
part2 = p;
if (part1 < part2) {
swap(part1, part2);
}
}
val = all + part1 + 1;
}
};
int n, k;
int a[MAXN];
vector<vector<int> > g;
int mina[MAXN];
int cnt[MAXN];
state s[MAXN];
int mx;
void init_dfs(int v, int p) {
mina[v] = a[v];
cnt[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) {
continue;
}
init_dfs(to, v);
mina[v] = min(mina[v], mina[to]);
cnt[v] += cnt[to];
}
}
void dfs1(int v, int p, int mn) {
s[v].all = s[v].part1 = s[v].part2 = 0;
s[v].val = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) {
continue;
}
dfs1(to, v, mn);
if (mina[to] >= mn) {
s[v].all += cnt[to];
s[v].val += cnt[to];
} else {
s[v].update(s[to].val);
}
}
if (a[v] < mn) {
s[v].val = 0;
} else {
s[v].val = s[v].all + s[v].part1 + 1;
}
}
void dfs2(int v, int p, int mn, state up) {
if (up.val == n - cnt[v]) {
s[v].all += up.val;
s[v].val += up.val;
} else {
s[v].update(up.val);
}
if (a[v] >= mn) {
mx = max(mx, s[v].val);
}
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) {
continue;
}
if (a[v] >= mn) {
up = s[v];
if (mina[to] >= mn) {
up.all -= cnt[to];
up.val -= cnt[to];
} else {
if (up.part1 == s[to].val) {
up.val -= (up.part1 - up.part2);
up.part1 = up.part2;
up.part2 = 0;
} else {
if (up.part2 == s[to].val) {
up.part2 = 0;
}
}
}
} else {
up = s[0];
}
dfs2(to, v, mn, up);
}
}
bool check(int mn) {
mx = 0;
dfs1(1, 0, mn);
dfs2(1, 0, mn, s[0]);
return mx >= k;
}
void solve() {
scanf("%d%d", &n, &k);
g.resize(n + 5);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
int v1, v2;
scanf("%d%d", &v1, &v2);
g[v1].push_back(v2);
g[v2].push_back(v1);
}
init_dfs(1, 0);
int l = 1, r = 1000000;
int ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
srand(1313);
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int MAX_N = (int)2e5 + 123;
const double eps = 1e-6;
const int inf = (int)1e9 + 123;
using namespace std;
int n, k;
int a[MAX_N];
vector<int> g[MAX_N];
bool bad[MAX_N];
int dp[MAX_N], sz[MAX_N], ans[MAX_N];
void dfs(int v, int pr = -1) {
sz[v] = 1, dp[v] = 1;
int maxi = 0;
for (auto to : g[v])
if (to != pr) {
dfs(to, v);
sz[v] += sz[to];
if (dp[to] == sz[to])
dp[v] += sz[to];
else
maxi = max(maxi, dp[to]);
}
dp[v] += maxi;
if (bad[v]) dp[v] = 0;
}
void calc(int v, int pr = -1, int up = 0) {
ans[v] = 1;
int maxi = 0;
if (up == n - sz[v])
ans[v] += up;
else
maxi = max(maxi, up);
for (auto to : g[v])
if (to != pr) {
if (dp[to] == sz[to])
ans[v] += sz[to];
else
maxi = max(maxi, dp[to]);
}
ans[v] += maxi;
if (bad[v]) ans[v] = 0;
vector<int> h;
for (auto to : g[v])
if (to != pr) h.push_back(to);
vector<pair<int, int> > pref, suff;
for (auto to : h) {
int sum = 0, mx = 0;
if (!pref.empty()) sum = pref.back().first, mx = pref.back().second;
if (dp[to] == sz[to])
sum += sz[to];
else
mx = max(mx, dp[to]);
pref.push_back(make_pair(sum, mx));
suff.push_back(make_pair(0, 0));
}
for (int i = int((h).size()) - 1; i >= 0; i--) {
int to = h[i];
int sum = 0, mx = 0;
if (i + 1 < int((h).size()))
sum = suff[i + 1].first, mx = suff[i + 1].second;
if (dp[to] == sz[to])
sum += sz[to];
else
mx = max(mx, dp[to]);
suff[i] = make_pair(sum, mx);
}
for (int i = 0; i < int((h).size()); i++) {
int sum = 0, mx = 0;
if (i > 0) sum += pref[i - 1].first, mx = max(mx, pref[i - 1].second);
if (i + 1 < int((h).size()))
sum += suff[i + 1].first, mx = max(mx, suff[i + 1].second);
if (up == n - sz[v])
sum += up;
else
mx = max(mx, up);
sum += mx + 1;
if (bad[v]) sum = 0;
calc(h[i], v, sum);
}
}
bool check(int x) {
for (int i = 1; i <= n; i++) bad[i] = (a[i] < x);
dfs(1);
calc(1);
for (int i = 1; i <= n; i++)
if (ans[i] >= k) return 1;
return 0;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
g[u].push_back(v), g[v].push_back(u);
}
int l = 1, r = (int)1e6, mid, ans = -1;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
assert(ans != -1);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> v[200100];
int a[200100], ok[200100], f[200100];
int sum[200100], down[200100], up[200100], A[200100], B[200100];
int size[200100];
void dfs(int x, int fa) {
sum[x] = ok[x];
A[x] = 0, B[x] = 0;
down[x] = 0;
size[x] = 1;
for (int y, i = 0; i < v[x].size(); i++) {
if ((y = v[x][i]) == fa) {
continue;
}
dfs(y, x);
size[x] += size[y];
if (size[y] == down[y]) {
sum[x] += size[y];
} else if (down[y] > A[x]) {
B[x] = A[x];
A[x] = down[y];
} else if (down[y] > B[x]) {
B[x] = down[y];
}
}
if (!ok[x]) {
up[x] = 0;
down[x] = sum[x] = A[x] = B[x] = 0;
return;
}
down[x] = sum[x] + A[x];
}
void update(int x, int fa) {
for (int y, i = 0; i < v[x].size(); i++) {
y = v[x][i];
if (y == fa) {
continue;
}
f[y] = down[y];
if (!ok[x] || !ok[y]) {
up[y] = 0;
update(y, x);
continue;
}
int Sum = sum[x], AA = A[x], BB = B[x];
if (size[y] == down[y]) {
Sum -= size[y];
} else {
if (AA == down[y]) {
AA = BB;
}
}
if (up[x] == n - size[x]) {
Sum += up[x];
} else {
AA = max(AA, up[x]);
}
up[y] = Sum + AA;
if (up[y] == n - size[y]) {
f[y] = down[y] + up[y];
} else {
f[y] = sum[y] + max(A[y], up[y]);
}
update(y, x);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
for (int x, y, i = 1; i < n; i++) {
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
int mn = 0, mx = 1000001;
while (mn < mx - 1) {
int mid = (mn + mx) / 2;
for (int i = 1; i <= n; i++) {
ok[i] = a[i] >= mid;
f[i] = 0;
down[i] = 0;
up[i] = 0;
A[i] = B[i] = 0;
size[i] = 0;
}
dfs(1, 0);
f[1] = down[1];
update(1, 0);
if (*max_element(f + 1, f + n + 1) >= m) {
mn = mid;
} else {
mx = mid;
}
}
printf("%d\n", mn);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[200005];
vector<int> adj[200005];
bool comp[200005];
int sum[200005];
pair<int, int> mx[2][200005];
pair<int, int> dfs(int x, int p, int z) {
comp[x] = 1;
pair<int, int> m;
sum[x] = 1;
for (int i = 0; i < adj[x].size(); ++i) {
if (adj[x][i] == p) continue;
m = dfs(adj[x][i], x, z);
if (m.second)
sum[x] += m.first;
else {
comp[x] = 0;
m.second = adj[x][i];
if (m > mx[0][x]) swap(m, mx[0][x]);
if (m > mx[1][x]) swap(m, mx[1][x]);
}
}
if (a[x] < z) {
comp[x] = 0;
sum[x] = 0;
mx[0][x] = mx[1][x] = make_pair(-1, 0);
return make_pair(0, 0);
}
if (comp[x]) return make_pair(sum[x], 1);
return make_pair(sum[x] + mx[0][x].first, 0);
}
void dfs1(int x, int p, int z) {
if (p && a[x] >= z) {
if (!comp[p] && (mx[1][p].first != -1 || mx[0][p].second != x)) {
pair<int, int> m;
m = mx[0][p];
if (m.second == x) m = mx[1][p];
m.first += sum[p];
if (comp[x]) m.first -= sum[x];
m.second = p;
if (m > mx[0][x]) swap(m, mx[0][x]);
if (m > mx[1][x]) swap(m, mx[1][x]);
comp[x] = 0;
} else {
if (!comp[x])
sum[x] += sum[p];
else
sum[x] = sum[p];
}
}
for (int i = 0; i < adj[x].size(); ++i)
if (adj[x][i] != p) dfs1(adj[x][i], x, z);
}
bool check(int mid) {
for (int i = 1; i <= n; ++i) {
comp[i] = 0;
sum[i] = 0;
mx[0][i] = mx[1][i] = make_pair(-1, 0);
}
dfs(1, 0, mid);
dfs1(1, 0, mid);
for (int i = 1; i <= n; ++i)
if (sum[i] + max(0, mx[0][i].first) >= k) return 1;
return 0;
}
int main() {
cin >> n >> k;
int u, v;
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int st = 0, en = 1e6 + 4, mid;
while (st < en) {
mid = (st + en) / 2;
if (check(mid))
st = mid + 1;
else
en = mid;
}
cout << st - 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 200010;
struct Fenwick {
vector<int> tree;
void init() { tree = vector<int>(MN + 1, 0); }
void upd(int idx, int val) {
for (int i = idx + 1; i <= MN; i += (i & -i)) tree[i] += val;
}
int quer(int a) {
int ret = 0;
for (int i = a + 1; i >= 1; i -= (i & -i)) ret += tree[i];
return ret;
}
int quer(int a, int b) { return quer(b) - quer(a - 1); }
} bit;
int N, K;
int A[MN];
vector<int> X;
vector<int> adj[MN];
unordered_map<int, int> inva[MN];
int chk[MN], sz[MN], tin[MN], tout[MN], timer;
void dfs0(int u, int p) {
tin[u] = timer++;
sz[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == p) continue;
dfs0(v, u);
sz[u] += sz[v];
}
tout[u] = timer;
}
int dp1(int u, int p);
vector<pair<int, int> > cc3[MN];
pair<int, int> dp3(int u, int p) {
if (p >= adj[u].size()) return pair<int, int>(0, 0);
pair<int, int> &ret = cc3[u][p];
if (ret != pair<int, int>(-1, -1)) return ret;
ret = dp3(u, p + 1);
int v = adj[u][p];
if (tin[u] < tin[v]) {
if (bit.quer(tin[v], tout[v] - 1) == 0)
ret.first += sz[v];
else if (!chk[v])
ret.second = max(ret.second, dp1(v, inva[v][u]));
} else {
if (bit.quer(MN - 1) - bit.quer(tin[u], tout[u] - 1) == 0)
ret.first += N - sz[u];
else if (!chk[v])
ret.second = max(ret.second, dp1(v, inva[v][u]));
}
return ret;
}
vector<pair<int, int> > cc2[MN];
pair<int, int> dp2(int u, int p) {
if (p == -1) return pair<int, int>(0, 0);
pair<int, int> &ret = cc2[u][p];
if (ret != pair<int, int>(-1, -1)) return ret;
ret = dp2(u, p - 1);
int v = adj[u][p];
if (tin[u] < tin[v]) {
if (bit.quer(tin[v], tout[v] - 1) == 0)
ret.first += sz[v];
else if (!chk[v])
ret.second = max(ret.second, dp1(v, inva[v][u]));
} else {
if (bit.quer(MN - 1) - bit.quer(tin[u], tout[u] - 1) == 0)
ret.first += N - sz[u];
else if (!chk[v])
ret.second = max(ret.second, dp1(v, inva[v][u]));
}
return ret;
}
vector<int> cc1[MN];
int dp1(int u, int p) {
int &ret = cc1[u][p];
if (ret != -1) return ret;
pair<int, int> t1 = dp2(u, p - 1);
pair<int, int> t2 = dp3(u, p + 1);
return ret = 1 + t1.first + t2.first + max(t1.second, t2.second);
}
bool f(int x) {
for (int i = 0; i < N; i++) chk[i] = A[i] < x;
bit.init();
for (int i = 0; i < N; i++)
if (A[i] < x) {
bit.upd(tin[i], 1);
}
for (int i = 0; i < N; i++) {
cc1[i] = vector<int>(adj[i].size() + 1, -1);
cc2[i] = cc3[i] =
vector<pair<int, int> >(adj[i].size(), pair<int, int>(-1, -1));
}
int Mx = 0;
for (int i = 0; i < N; i++) {
if (!chk[i]) {
Mx = max(Mx, dp1(i, adj[i].size()));
}
}
return Mx >= K;
}
int main() {
scanf("%d %d", &N, &K);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
X.push_back(A[i]);
}
sort(X.begin(), X.end());
X.resize(unique(X.begin(), X.end()) - X.begin());
for (int i = 0; i < N - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int u = 0; u < N; u++) {
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
inva[u][v] = i;
}
}
dfs0(0, -1);
int s = 0, e = (int)X.size() - 1, p = -1;
while (s <= e) {
int m = (s + e) >> 1;
if (f(X[m])) {
p = m;
s = m + 1;
} else
e = m - 1;
}
printf("%d", X[p]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn];
vector<int> t[maxn];
int check_bs;
int dp[maxn], st[maxn], sz[maxn], allone[maxn];
int n, cnt;
void dfs(int v, int par = -1) {
bool me = (a[v] >= check_bs);
allone[v] = me;
sz[v] = 1;
int tmp = 0;
int maxst1 = 0, maxst2 = 0;
for (auto u : t[v]) {
if (u != par) {
dfs(u, v);
allone[v] += allone[u];
sz[v] += sz[u];
dp[v] = max(dp[v], dp[u]);
if (allone[u] == sz[u])
tmp += sz[u];
else {
maxst2 = max(maxst2, st[u]);
if (maxst1 < maxst2) swap(maxst1, maxst2);
}
}
}
if (me == false) return;
if (allone[v] == sz[v])
dp[v] = st[v] = sz[v];
else {
dp[v] = max(dp[v], maxst1 + maxst2 + tmp + 1);
st[v] = maxst1 + tmp + 1;
if (n - sz[v] == cnt - allone[v])
dp[v] = max(dp[v], maxst1 + maxst2 + tmp + 1 + n - sz[v]);
}
}
int k;
bool check(int x) {
check_bs = x;
memset(dp, 0, sizeof dp);
memset(st, 0, sizeof st);
cnt = 0;
for (int v = 1; v <= n; v++) cnt += (a[v] >= x);
dfs(1);
return dp[1] >= k;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int v = 1; v <= n; v++) cin >> a[v];
for (int ed = 1; ed <= n - 1; ed++) {
int v, u;
cin >> v >> u;
t[v].push_back(u);
t[u].push_back(v);
}
int lo = 1, hi = 1000001;
while (hi - lo > 1) {
int mid = (lo + hi) >> 1;
if (check(mid) == true)
lo = mid;
else
hi = mid;
}
cout << lo << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> val(n);
for (auto &i : val) cin >> i;
vector<vector<int>> adj(n);
for (int i = 1, u, v; i < n; ++i) {
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
auto solve = [&](int mn) {
auto w = [&](int u) { return val[u] >= mn; };
vector<int> sz(n), dp(n), wsz(n), rdp(n);
vector<multiset<int>> sub(n);
for (int i = 0; i < n; ++i) sub[i].insert(0);
function<void(int, int)> dfs = [&](int u, int p) {
sz[u] = 1;
wsz[u] = w(u);
for (auto v : adj[u])
if (v != p) {
dfs(v, u);
sz[u] += sz[v];
wsz[u] += wsz[v];
if (sz[v] == wsz[v])
dp[u] += sz[v];
else
sub[u].insert(rdp[v]);
}
rdp[u] = (dp[u] + 1 + *sub[u].rbegin()) * w(u);
};
dfs(0, -1);
int best = 0;
function<void(int, int)> dfs2 = [&](int u, int p) {
best = max(best, rdp[u]);
for (auto v : adj[u])
if (v != p) {
int rdpu = rdp[u], rdpv = rdp[v];
if (sz[v] == wsz[v])
dp[u] -= sz[v];
else
sub[u].erase(sub[u].find(rdp[v]));
sz[u] -= sz[v];
wsz[u] -= wsz[v];
rdp[u] = (dp[u] + 1 + *sub[u].rbegin()) * w(u);
sz[v] += sz[u];
wsz[v] += wsz[u];
if (sz[u] == wsz[u])
dp[v] += sz[u];
else
sub[v].insert(rdp[u]);
rdp[v] = (dp[v] + 1 + *sub[v].rbegin()) * w(v);
dfs2(v, u);
rdp[v] = rdpv;
if (sz[u] == wsz[u])
dp[v] -= sz[u];
else
sub[v].erase(sub[v].find(rdp[u]));
wsz[v] -= wsz[u];
sz[v] -= sz[u];
rdp[u] = rdpu;
wsz[u] += wsz[v];
sz[u] += sz[v];
if (sz[v] == wsz[v])
dp[u] += sz[v];
else
sub[u].insert(rdp[v]);
}
};
dfs2(0, -1);
return best;
};
int lo = 1, hi = 1e6;
while (lo < hi) {
int md = (lo + hi + 1) >> 1;
if (solve(md) >= k)
lo = md;
else
hi = md - 1;
}
cout << lo << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, mc;
int s[200005], cb[200005], surv[200005], pure[200005];
pair<int, int> ffi[200005], sse[200005];
bool bad[200005];
vector<int> V[200005], V2[200005], V3[200005];
void dfs(int id, int prev) {
for (int i = (0); i <= ((int)V[id].size() - 1); i++) {
int to = V[id][i];
if (to == prev) continue;
dfs(to, id);
cb[id] += cb[to];
if (!cb[to])
surv[id] += surv[to];
else {
if (ffi[id].first < surv[to]) {
sse[id] = ffi[id];
ffi[id] = make_pair(surv[to], to);
} else if (sse[id].first < surv[to]) {
sse[id] = make_pair(surv[to], to);
}
}
}
if (bad[id]) {
pure[id] = surv[id] = 0;
} else {
pure[id] = ++surv[id];
surv[id] += ffi[id].first;
}
for (int i = (0); i <= ((int)V[id].size() - 1); i++) {
int to = V[id][i];
if (to == prev) {
V2[id].push_back(0);
V3[id].push_back(0);
} else if (!cb[to]) {
V2[id].push_back(surv[id] - pure[to]);
V3[id].push_back(pure[id] - pure[to]);
} else {
if (to == ffi[id].second)
V2[id].push_back(pure[id] + sse[id].first);
else
V2[id].push_back(surv[id]);
V3[id].push_back(pure[id]);
}
}
return;
}
void dfs2(int id, int prev, int res) {
if (prev == -1 || bad[id]) {
} else {
mc = max(mc, res + pure[id]);
if (cb[id] == cb[1]) mc = max(mc, res + surv[id]);
mc = max(mc, surv[id]);
}
for (int i = (0); i <= ((int)V[id].size() - 1); i++) {
int to = V[id][i];
if (to == prev) continue;
if (bad[id])
dfs2(to, id, 0);
else if (cb[id] == cb[1])
dfs2(to, id, res + V2[id][i]);
else
dfs2(to, id, max(V2[id][i], res + V3[id][i]));
}
return;
}
int bes(int m) {
for (int i = (1); i <= (n); i++) {
if (s[i] < m)
bad[i] = true;
else
bad[i] = false;
cb[i] = bad[i];
ffi[i] = sse[i] = make_pair(0, 0);
pure[i] = surv[i] = 0;
V2[i].clear();
V3[i].clear();
}
dfs(1, -1);
mc = surv[1];
dfs2(1, -1, 0);
return mc;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = (1); i <= (n); i++) scanf("%d", &s[i]);
for (int i = (2); i <= (n); i++) {
int a, b;
scanf("%d %d", &a, &b);
V[a].push_back(b);
V[b].push_back(a);
}
int l = 0, r = 1000001;
while (r - l > 1) {
int m = (l + r) >> 1;
if (bes(m) >= k)
l = m;
else
r = m;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, best1[200005], best2[200005], dp[200005], size[200005], temp[200005],
a[200005], tot[200005], got;
vector<int> v[200005];
void dfs(int cur, int par) {
size[cur] = 1;
tot[cur] = temp[cur];
for (int i = 0; i < v[cur].size(); i++) {
int x = v[cur][i];
if (x == par) continue;
dfs(x, cur);
size[cur] += size[x];
tot[cur] += tot[x];
}
}
void dfs_down(int cur, int par) {
best1[cur] = 0;
best2[cur] = 0;
dp[cur] = 0;
for (int i = 0; i < v[cur].size(); i++) {
int x = v[cur][i];
if (x == par) continue;
dfs_down(x, cur);
if (size[x] == tot[x])
dp[cur] += size[x];
else if (dp[x] > best1[cur]) {
best2[cur] = best1[cur];
best1[cur] = dp[x];
} else
best2[cur] = max(best2[cur], dp[x]);
}
if (temp[cur]) {
dp[cur] += 1;
dp[cur] += best1[cur];
} else {
dp[cur] = 0;
best1[cur] = 0;
best2[cur] = 0;
}
}
void dfs_up(int cur, int par, int up_val) {
if (up_val == n - size[cur])
dp[cur] += up_val;
else {
dp[cur] -= best1[cur];
if (up_val > best1[cur]) {
best2[cur] = best1[cur];
best1[cur] = up_val;
} else
best2[cur] = max(best2[cur], up_val);
dp[cur] += best1[cur];
}
if (!temp[cur]) {
dp[cur] = 0;
best1[cur] = 0;
best2[cur] = 0;
}
got = got | (dp[cur] >= k);
for (int i = 0; i < v[cur].size(); i++) {
int x = v[cur][i];
if (x == par) continue;
if (size[x] == tot[x])
dfs_up(x, cur, dp[cur] - size[x]);
else if (best1[cur] == dp[x])
dfs_up(x, cur, dp[cur] - best1[cur] + best2[cur]);
else
dfs_up(x, cur, dp[cur]);
}
}
int ok(int val) {
got = 0;
for (int i = 1; i <= n; i++) temp[i] = (a[i] >= val);
dfs(1, -1);
dfs_down(1, -1);
dfs_up(1, -1, 0);
return got;
}
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
int i, lo, mid, hi, x, y;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
lo = 1;
hi = 1000001;
while (hi - lo > 1) {
mid = (lo + hi) / 2;
if (ok(mid))
lo = mid;
else
hi = mid;
}
cout << lo;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int n, k, arr[MAXN], sz[MAXN];
vector<int> adj[MAXN];
int dp_down[MAXN], dp_up[MAXN];
void dfs_down(int v, int val, int par = 0) {
sz[v] = 1;
dp_down[v] = 1;
int mx = 0;
for (auto i : adj[v])
if (i != par) {
dfs_down(i, val, v);
sz[v] += sz[i];
if (dp_down[i] == sz[i])
dp_down[v] += dp_down[i];
else
mx = max(mx, dp_down[i]);
}
dp_down[v] += mx;
if (arr[v] < val) dp_down[v] = 0;
return;
}
void dfs_up(int v, int val, int par = 0, int DP = 0) {
dp_up[v] = DP;
int ALL = 0, fmx = 0, id = 0, smx = 0;
if (DP == (n - sz[v]))
ALL = DP;
else
fmx = DP;
for (auto i : adj[v])
if (i != par) {
if (dp_down[i] == sz[i])
ALL += sz[i];
else if (fmx < dp_down[i]) {
fmx = dp_down[i];
id = i;
}
}
for (auto i : adj[v])
if (i != par && i != id)
if (dp_down[i] != sz[i]) smx = max(smx, dp_down[i]);
for (auto i : adj[v])
if (i != par) {
int go = ALL + fmx + 1;
if (i == id) go -= fmx - smx;
if (dp_down[i] == sz[i]) go -= sz[i];
if (arr[v] < val) go = 0;
dfs_up(i, val, v, go);
}
dp_down[v] = ALL + fmx + 1;
if (arr[v] < val) dp_down[v] = 0;
return;
}
bool check(int val) {
dfs_down(1, val);
dfs_up(1, val);
for (int v = 1; v <= n; v++)
if (dp_down[v] >= k) return true;
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
int lo = 1;
int hi = 1e6 + 1;
while ((hi - lo) > 1) {
int mid = lo + hi >> 1;
if (check(mid))
lo = mid;
else
hi = mid;
}
cout << lo << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
struct Input {
int n, k;
vector<int> a;
vector<vector<int> > g;
bool read() {
if (scanf("%d%d", &n, &k) != 2) return 0;
a.resize(n);
for (int i = int(0); i < int(n); ++i) scanf("%d", &a[i]);
g.assign(n, vector<int>());
for (int i = int(0); i < int(n - 1); ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
g[u].push_back(v);
g[v].push_back(u);
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
int ans;
void write() { printf("%d\n", ans); }
};
struct Solution : Data {
void filter() {
for (int i = int(0); i < int(n); ++i) {
sort((g[i]).begin(), (g[i]).end());
}
g[0].push_back(n);
}
vector<int> alpha, beta;
vector<int> good;
void calc_dp(int v, int par) {
for (int son : g[v]) {
if (son == par) continue;
calc_dp(son, v);
}
bool all_good = (good[v]);
alpha[v] = 1;
for (int son : g[v]) {
if (son == par) continue;
alpha[v] += alpha[son];
if (alpha[son] == -1) all_good = false;
}
if (!all_good) {
alpha[v] = -1;
}
if (good[v]) {
int max_bad = 0;
beta[v] = 1;
for (int son : g[v]) {
if (son == par) continue;
if (alpha[son] != -1) {
beta[v] += alpha[son];
} else {
umx(max_bad, beta[son]);
}
}
beta[v] += max_bad;
}
}
void update_val(int v, int par, int al, int bt, int& res) {
;
int old_al = alpha[par], old_bt = beta[par];
alpha[par] = al, beta[par] = bt;
umx(res, beta[v] + bt);
;
if (!good[v]) {
for (int son : g[v]) {
if (son == par) continue;
update_val(son, v, -1, 0, res);
}
} else {
int all_alpha = 1;
int good_alpha = 1;
vector<int> bad_alphas;
vector<int> max_bt;
for (int son : g[v]) {
all_alpha += alpha[son];
if (alpha[son] == -1) {
bad_alphas.push_back(son);
max_bt.push_back(beta[son]);
sort(max_bt.rbegin(), max_bt.rend());
max_bt.resize(2);
} else {
good_alpha += alpha[son];
}
}
for (int son : g[v]) {
if (son == par) continue;
int new_al = -1;
int new_bt = 0;
if (bad_alphas.empty() ||
(((int)(bad_alphas).size()) == 1 && bad_alphas.front() == son)) {
new_al = all_alpha - alpha[son];
}
new_bt = good_alpha;
if (alpha[son] != -1) {
new_bt -= alpha[son];
if (!max_bt.empty()) {
new_bt += max_bt[0];
}
} else {
if (max_bt[0] != beta[son]) {
new_bt += max_bt[0];
} else if (((int)(max_bt).size()) > 1) {
new_bt += max_bt[1];
}
}
update_val(son, v, new_al, new_bt, res);
}
}
alpha[par] = old_al;
beta[par] = old_bt;
}
bool can(int x) {
alpha.assign(n + 1, -1);
beta.assign(n + 1, 0);
good.assign(n + 1, 0);
for (int i = int(0); i < int(n); ++i) good[i] = a[i] >= x;
good[n] = 0;
calc_dp(0, n);
int max_val = 0;
;
;
update_val(0, n, 0, 0, max_val);
return max_val >= k;
}
void solve() {
filter();
ans = 0;
int l = 0, r = 1000001;
while (l < r - 1) {
int mid = (l + r) / 2;
;
if (can(mid)) {
l = mid;
} else {
r = mid;
}
}
ans = l;
}
void clear() {
;
*this = Solution();
}
};
Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 10;
const long long INF = 1e12 + 10;
struct Dp_type {
long long subtree, dp, red, max1, max2;
Dp_type() {
subtree = 0;
dp = 0;
red = 0;
max1 = 0;
max2 = 0;
}
};
Dp_type dpD[MAXN];
Dp_type dpU[MAXN];
vector<long long> vertex[MAXN];
long long a[MAXN];
bool check[MAXN];
long long n;
void dfs_down(long long v, long long t) {
check[v] = true;
dpD[v].subtree = 1;
dpD[v].red += (a[v] < t);
dpD[v].dp += (a[v] >= t);
for (long long i = 0; i < vertex[v].size(); i++) {
if (!check[vertex[v][i]]) {
dfs_down(vertex[v][i], t);
if (a[v] >= t && dpD[vertex[v][i]].red == 0) {
dpD[v].dp += dpD[vertex[v][i]].subtree;
}
if (dpD[vertex[v][i]].red > 0) {
if (dpD[v].max1 < dpD[vertex[v][i]].dp) {
swap(dpD[v].max1, dpD[v].max2);
dpD[v].max1 = dpD[vertex[v][i]].dp;
} else {
dpD[v].max2 = max(dpD[v].max2, dpD[vertex[v][i]].dp);
}
}
dpD[v].subtree += dpD[vertex[v][i]].subtree;
dpD[v].red += dpD[vertex[v][i]].red;
}
}
if (a[v] >= t) {
dpD[v].dp += dpD[v].max1;
}
}
void dfs_up(long long v, long long t) {
check[v] = true;
if (a[v] >= t) {
if (dpU[v].red == 0) {
dpD[v].dp += dpU[v].subtree;
} else {
if (dpD[v].max1 < dpU[v].dp) {
swap(dpD[v].max1, dpD[v].max2);
dpD[v].max1 = dpU[v].dp;
dpD[v].dp += (dpD[v].max1 - dpD[v].max2);
} else {
dpD[v].max2 = max(dpD[v].max2, dpU[v].dp);
}
}
}
dpD[v].subtree += dpU[v].subtree;
dpD[v].red += dpU[v].red;
for (long long i = 0; i < vertex[v].size(); i++) {
if (!check[vertex[v][i]]) {
if (dpD[vertex[v][i]].red == 0) {
dpU[vertex[v][i]] = dpD[v];
dpU[vertex[v][i]].dp -= dpD[vertex[v][i]].subtree;
dpU[vertex[v][i]].subtree -= dpD[vertex[v][i]].subtree;
} else {
dpU[vertex[v][i]] = dpD[v];
dpU[vertex[v][i]].red -= dpD[vertex[v][i]].red;
dpU[vertex[v][i]].subtree -= dpD[vertex[v][i]].subtree;
if (dpD[vertex[v][i]].dp == dpU[vertex[v][i]].max1) {
dpU[vertex[v][i]].dp +=
(dpU[vertex[v][i]].max2 - dpU[vertex[v][i]].max1);
}
}
dfs_up(vertex[v][i], t);
}
}
}
long long f(long long t) {
Dp_type w;
for (long long i = 1; i <= n; i++) {
dpD[i] = w;
dpU[i] = w;
}
fill(check, check + MAXN, false);
dfs_down(1, t);
fill(check, check + MAXN, false);
dfs_up(1, t);
long long res = 0;
for (long long i = 1; i <= n; i++) {
res = max(res, dpD[i].dp);
}
return res;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
long long k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 0; i < (n - 1); i++) {
long long v, u;
cin >> v >> u;
vertex[v].push_back(u);
vertex[u].push_back(v);
}
long long l = 0, r = INF;
while (true) {
if (r - l == 1) {
cout << l;
return 0;
}
long long mid = (l + r) / 2;
if (f(mid) >= k) {
l = mid;
} else {
r = mid;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
struct edge {
int y;
edge *n;
} e[400009], *fir[200009], *pt = e;
void AddE(int x, int y) { pt->y = y, pt->n = fir[x], fir[x] = pt++; }
int n, K, k[200009], v[200009], sz[200009], h[200009], f[200009];
bool Ans;
void dfs(int x) {
sz[x] = 1;
for (edge *p = fir[x]; p; p = p->n)
if (p->y != h[x]) h[p->y] = x, dfs(p->y), sz[x] += sz[p->y];
}
void dfs1(int x) {
int g = 0, mx = 0;
for (edge *p = fir[x]; p; p = p->n)
if (p->y != h[x]) {
dfs1(p->y);
if (f[p->y] == sz[p->y])
g += f[p->y];
else
mx = max(mx, f[p->y]);
}
if (v[x])
f[x] = g + mx + 1;
else
f[x] = 0;
}
void dfs2(int x) {
int g = 0, mx = 0, sc = 0;
for (edge *p = fir[x]; p; p = p->n) {
if (f[p->y] == sz[p->y])
g += f[p->y];
else if (f[p->y] > f[mx])
sc = mx, mx = p->y;
else if (f[p->y] > f[sc])
sc = p->y;
}
if (v[x] && 1 + g + f[mx] >= K) Ans = true;
for (edge *p = fir[x]; p; p = p->n)
if (p->y != h[x]) {
int tmpf = f[x], tmpsz = sz[x];
if (v[x]) {
if (f[p->y] == sz[p->y])
f[x] = 1 + f[mx] + g - f[p->y];
else if (p->y != mx)
f[x] = 1 + f[mx] + g;
else
f[x] = 1 + f[sc] + g;
sz[x] = n - sz[p->y];
dfs2(p->y);
f[x] = tmpf, sz[x] = tmpsz;
} else {
f[x] = 0, sz[x] = n - sz[p->y];
dfs2(p->y);
f[x] = tmpf, sz[x] = tmpsz;
}
}
}
bool jub(int x) {
for (int i = 1; i <= n; i++) v[i] = (k[i] >= x) ? 1 : 0;
Ans = false;
dfs1(1);
dfs2(1);
return Ans;
}
int main() {
n = read(), K = read();
for (int i = 1; i <= n; i++) k[i] = read();
for (int i = 1; i <= n - 1; i++) {
int x = read(), y = read();
AddE(x, y);
AddE(y, x);
}
dfs(1);
int l = 1, r = 1e6;
while (l < r) {
int mid = (l + r) >> 1;
if (jub(mid + 1))
l = mid + 1;
else
r = mid;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int maxn5 = 2e5 + 10;
const int maxnt = 1.2e6 + 10;
const int maxn3 = 1e3 + 10;
const long long mod = 1e9 + 7;
const long long inf = 2e18;
int n, k, lim, mx[maxn5], mx2[maxn5], val[maxn5];
int cnt[maxn5], sz[maxn5], big[maxn5];
bool full[maxn5];
vector<int> adj[maxn5];
void dfs(int v, int par) {
cnt[v] = 0, mx[v] = 0, mx2[v] = 0, big[v] = 0, full[v] = true;
sz[v] = 1;
for (auto u : adj[v])
if (u != par) {
dfs(u, v);
full[v] &= full[u];
if (full[u])
big[v] += cnt[u];
else if (cnt[u] >= mx[v])
mx2[v] = mx[v], mx[v] = cnt[u];
else
mx2[v] = max(mx2[v], cnt[u]);
sz[v] += sz[u];
}
cnt[v] = big[v] + mx[v];
if (val[v] >= lim)
cnt[v]++;
else
cnt[v] = 0, full[v] = false;
return;
}
void rev_dfs(int v, int par) {
if (val[v] >= lim)
for (auto u : adj[v])
if (u != par) {
int now;
if (full[u])
now = big[v] + mx[v] - cnt[u] + 1;
else {
if (mx[v] == cnt[u])
now = big[v] + mx2[v] + 1;
else
now = big[v] + mx[v] + 1;
}
if (now == n - sz[u])
big[u] += now;
else if (now >= mx[u])
mx2[u] = mx[u], mx[u] = now;
else
mx2[u] = max(mx2[u], now);
}
for (auto u : adj[v])
if (u != par) rev_dfs(u, v);
return;
}
bool check(int mid) {
lim = mid;
dfs(1, -1);
rev_dfs(1, -1);
for (int i = 1; i <= n; i++)
if (val[i] >= lim and big[i] + mx[i] + 1 >= k) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> val[i];
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
int lo = 1, hi = maxn;
while (hi - lo > 1) {
int mid = (lo + hi) >> 1;
if (check(mid))
lo = mid;
else
hi = mid;
}
cout << lo << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k;
int a[N];
vector<int> g[N];
int ans = 0, cnt = 0;
int dp[N], big[N], bad[N];
void dfs(int u, int p, int x) {
big[u] = 1, bad[u] = 0;
if (a[u] < x)
dp[u] = 0, bad[u] = 1;
else
dp[u] = 1;
for (auto v : g[u]) {
if (v == p) continue;
dfs(v, u, x);
bad[u] += bad[v];
big[u] += big[v];
}
if (dp[u]) {
int mx1 = 0, mx2 = 0;
for (auto v : g[u]) {
if (v == p) continue;
if (dp[v] == big[v])
dp[u] += dp[v];
else {
if (dp[v] > mx1) {
mx2 = mx1, mx1 = dp[v];
} else if (dp[v] > mx2)
mx2 = dp[v];
}
}
dp[u] += mx1;
int now = dp[u] + mx2;
if (bad[u] == cnt) now += n - big[u];
ans = max(ans, now);
}
}
bool check(int x) {
cnt = 0, ans = 0;
for (int i = (1); i < (n + 1); i++) {
if (a[i] < x) cnt++;
}
dfs(1, 0, x);
return ans >= k;
}
int main() {
cin >> n >> k;
for (int i = (1); i < (n + 1); i++) cin >> a[i];
for (int i = (1); i < (n); i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int s = 0, L = 1, R = 1e7;
while (L <= R) {
int mid = (L + R) / 2;
if (check(mid)) {
s = mid;
L = mid + 1;
} else
R = mid - 1;
}
cout << s << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, l, r, mid, ans, K, x, y, s[200005], f[200005], g[200005], mx[200005],
a[200005];
vector<int> e[200005];
void dfs(int x, int y) {
s[x] = 1;
f[x] = 0;
mx[x] = 0;
for (int i = 0; i < e[x].size(); ++i)
if (e[x][i] != y) {
dfs(e[x][i], x);
s[x] += s[e[x][i]];
if (f[e[x][i]] == s[e[x][i]])
f[x] += f[e[x][i]];
else if (f[mx[x]] < f[e[x][i]])
mx[x] = e[x][i];
}
f[x] += f[mx[x]];
if (a[x] < mid)
f[x] = 0;
else
++f[x];
}
void fly(int x, int y) {
for (int i = 0; i < e[x].size(); ++i)
if (e[x][i] != y) {
g[e[x][i]] = f[x];
if (g[x] == n - s[x]) g[e[x][i]] += g[x];
if (f[e[x][i]] == s[e[x][i]]) g[e[x][i]] -= f[e[x][i]];
if (mx[x] == e[x][i]) {
g[e[x][i]] -= f[e[x][i]];
int w = 0;
for (int j = 0; j < e[x].size(); ++j)
if (e[x][j] != y && e[x][j] != mx[x] && f[e[x][j]] != s[e[x][j]])
w = max(w, f[e[x][j]]);
if (g[x] != n - s[x]) w = max(w, g[x]);
g[e[x][i]] += w;
}
if (a[x] < mid) g[e[x][i]] = 0;
fly(e[x][i], x);
if (ans >= K) return;
}
if (a[x] < mid) return;
int u = 1, w = 0;
for (int i = 0; i < e[x].size(); ++i)
if (e[x][i] != y) {
if (f[e[x][i]] == s[e[x][i]])
u += f[e[x][i]];
else
w = max(w, f[e[x][i]]);
}
if (g[x] == n - s[x])
u += g[x];
else
w = max(w, g[x]);
ans = max(ans, u + w);
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
l = 1;
r = 1000000;
while (l < r) {
mid = l + r + 1 >> 1;
dfs(1, 0);
ans = 0;
fly(1, 0);
if (ans >= K)
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int val[200005];
vector<int> graph[200005];
int dp[200005];
int cnt[200005];
int cnt2[200005];
int n, k, mid, ans, total;
void dfs(int t, int p) {
int full = 0;
cnt[t] = 1;
cnt2[t] = (val[t] >= mid);
vector<int> vt;
for (int nxt : graph[t]) {
if (nxt == p) continue;
dfs(nxt, t);
cnt[t] += cnt[nxt];
cnt2[t] += cnt2[nxt];
if (cnt[nxt] == dp[nxt])
full += dp[nxt];
else {
vt.push_back(dp[nxt]);
}
}
int upward = 1;
if (total - cnt2[t] == n - cnt[t]) {
upward = n - cnt[t] + 1;
}
if (val[t] < mid) {
dp[t] = 0;
return;
}
sort(vt.begin(), vt.end());
if (cnt[t] == full + 1 || vt.empty()) {
ans = max(ans, full + 1);
dp[t] = full + 1;
return;
} else if (vt.size() == 1) {
ans = max(ans, vt[0] + full + 1);
dp[t] = vt[0] + full + 1;
return;
} else {
ans = max(ans, vt.rbegin()[0] + vt.rbegin()[1] + full + upward);
dp[t] = vt.back() + full + 1;
return;
}
}
bool check() {
ans = 0;
total = 0;
for (int i = 1; i <= n; i++) total += (val[i] >= mid);
dfs(1, 0);
return ans >= k;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
graph[a].push_back(b);
graph[b].push_back(a);
}
int lo = 1, hi = 999999, a = 1000000;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (check()) {
a = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
printf("%d", a);
}
|
#include <bits/stdc++.h>
template <typename T>
class IntegerIterator
: public std::iterator<std::input_iterator_tag, T, std::ptrdiff_t, T*, T> {
public:
explicit IntegerIterator(int value) : value(value) {}
IntegerIterator& operator++() {
++value;
return *this;
}
IntegerIterator operator++(int) {
IntegerIterator copy = *this;
++value;
return copy;
}
IntegerIterator& operator--() {
--value;
return *this;
}
IntegerIterator operator--(int) {
IntegerIterator copy = *this;
--value;
return copy;
}
T operator*() const { return value; }
bool operator==(IntegerIterator rhs) { return value == rhs.value; }
bool operator!=(IntegerIterator rhs) { return !(*this == rhs); }
private:
T value;
};
template <typename T>
class IntegerRange {
public:
IntegerRange(T begin, T end) : begin_(begin), end_(end) { ; }
IntegerIterator<T> begin() const { return IntegerIterator<T>(begin_); }
IntegerIterator<T> end() const { return IntegerIterator<T>(end_); }
private:
T begin_;
T end_;
};
template <typename T>
class ReversedIntegerRange {
public:
ReversedIntegerRange(T begin, T end) : begin_(begin), end_(end) { ; }
std::reverse_iterator<IntegerIterator<T>> begin() const {
return std::reverse_iterator<IntegerIterator<T>>(
IntegerIterator<T>(begin_));
}
std::reverse_iterator<IntegerIterator<T>> end() const {
return std::reverse_iterator<IntegerIterator<T>>(IntegerIterator<T>(end_));
}
private:
T begin_;
T end_;
};
template <typename T>
IntegerRange<T> range(T to) {
return IntegerRange<T>(0, to);
}
template <typename T>
IntegerRange<T> range(T from, T to) {
return IntegerRange<T>(from, to);
}
template <typename T>
IntegerRange<T> inclusiveRange(T to) {
return IntegerRange<T>(0, to + 1);
}
template <typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
return IntegerRange<T>(from, to + 1);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from) {
return ReversedIntegerRange<T>(from, 0);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
return ReversedIntegerRange<T>(from, to);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
return ReversedIntegerRange<T>(from + 1, 0);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
return ReversedIntegerRange<T>(from + 1, to);
}
using namespace std;
class TaskE {
public:
vector<int> a;
struct Res {
int res1, max_res;
bool full;
};
vector<vector<int>> g;
Res dfs(int v, int p, int value) {
if (a[v] < value) {
Res res = {0, 0, false};
for (int to : g[v]) {
if (to != p) {
res.max_res = max(res.max_res, dfs(to, v, value).max_res);
}
}
return res;
}
Res res = {0, 0, true};
int free = 1;
int best1 = 0, best2 = 0;
for (int to : g[v]) {
if (to != p) {
auto ch = dfs(to, v, value);
if (ch.full) {
free += ch.res1;
} else {
res.full = false;
if (ch.res1 > best2) {
best2 = ch.res1;
}
if (best2 > best1) {
swap(best1, best2);
}
}
res.max_res = max(res.max_res, ch.max_res);
}
}
if (res.full) {
return {free, free, true};
}
res.res1 = free + best1;
res.max_res = max(res.max_res, free + best1 + best2);
return res;
}
void solve(std::istream& in, std::ostream& out) {
int n, k;
in >> n >> k;
a.resize(n);
g.resize(n);
for (int i : range(n)) {
in >> a[i];
}
for (int i : range(n - 1)) {
int x, y;
in >> x >> y;
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
int l = *min_element(a.begin(), a.end());
int r = *max_element(a.begin(), a.end()) + 1;
int start = 0;
for (int i : range(n)) {
if (l == a[i]) {
start = i;
}
}
while (r - l > 1) {
int m = (l + r) / 2;
if (dfs(start, -1, m).max_res >= k) {
l = m;
} else {
r = m;
}
}
out << l;
}
};
int main() {
std::ios_base::sync_with_stdio(false);
TaskE solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
in.tie(0);
out << std::fixed;
out.precision(20);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 2;
const int INF = 2e6;
struct Edge {
int v, next;
Edge() {}
Edge(int v, int next) : v(v), next(next) {}
} edge[N * 2];
struct Point {
int num_full;
bool full;
pair<int, int> son[2];
void update(int x, int w) {
pair<int, int> tmp = make_pair(x, w);
if (tmp > son[0]) {
son[1] = son[0];
son[0] = tmp;
} else if (tmp > son[1])
son[1] = tmp;
}
void clear() {
num_full = 0;
son[0] = son[1] = make_pair(0, 0);
}
int get() { return num_full + son[0].first; }
int remove(int y) {
if (y == son[0].second) son[0] = son[1];
if (son[0].second == 0) full = 1;
}
} f[N];
int n, m, p[N], edn, fa[N], a[N], mid;
bool find_ans, init[N];
void addedge(int u, int v) {
edge[edn] = Edge(v, p[u]);
p[u] = edn++;
}
void dfs__(int x) {
for (int i = p[x]; ~i; i = edge[i].next) {
int y = edge[i].v;
if (y != fa[x]) {
fa[y] = x;
dfs__(y);
}
}
}
void dfs(int x) {
if (a[x] < mid) {
init[x] = 0;
f[x].full = 0;
f[x].num_full = 0;
for (int i = p[x]; ~i; i = edge[i].next) {
int y = edge[i].v;
if (y != fa[x]) dfs(y);
}
} else {
init[x] = 1;
f[x].num_full = 1;
f[x].full = 1;
for (int i = p[x]; ~i; i = edge[i].next) {
int y = edge[i].v;
if (y != fa[x]) {
dfs(y);
if (f[y].full)
f[x].num_full += f[y].num_full;
else {
f[x].full = 0;
f[x].update(f[y].get(), y);
}
}
}
}
}
void work(int x) {
if (f[x].get() >= m) find_ans = 1;
Point bak = f[x];
for (int i = p[x]; ~i; i = edge[i].next)
if (edge[i].v != fa[x]) {
int y = edge[i].v;
Point bak_y = f[y];
if (init[x] == 0 || init[y] == 0) {
f[y].full = 0;
work(y);
} else {
if (f[y].full)
f[x].num_full -= f[y].num_full;
else
f[x].remove(y);
if (f[x].full)
f[y].num_full += f[x].num_full;
else {
f[y].full = 0;
f[y].update(f[x].get(), x);
}
work(y);
f[x] = bak;
}
f[y] = bak_y;
}
}
bool check() {
for (int i = 1; i <= n; i++) f[i].clear();
dfs(1);
find_ans = 0;
work(1);
return find_ans;
}
int main() {
memset(p, -1, sizeof(p));
edn = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
int l = 0, r = INF;
int ans = -1;
dfs__(1);
while (l <= r) {
mid = (l + r) / 2;
if (check()) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[200005];
bool used[200005];
bool forb[200005];
bool del[200005];
int dp[200005], deg[200005];
int ar[200005];
int val[200005];
int n, k;
int mxans = 0;
queue<int> Q;
void dfs1(int x, int p) {
used[x] = 1;
int sz = adj[x].size();
for (int i = 0; i < sz; ++i) {
if (adj[x][i] == p || forb[adj[x][i]]) continue;
dfs1(adj[x][i], x);
}
if (sz == 1) Q.push(x);
}
void dfs(int x, int p) {
dp[x] = val[x];
int b1 = 0, b2 = 0;
int sz = adj[x].size();
for (int i = 0; i < sz; ++i) {
if (adj[x][i] == p || forb[adj[x][i]]) continue;
dfs(adj[x][i], x);
if (b1 < dp[adj[x][i]])
b2 = b1, b1 = dp[adj[x][i]];
else
b2 = max(b2, dp[adj[x][i]]);
}
mxans = max(mxans, b1 + b2 + val[x]);
dp[x] = b1 + val[x];
}
void solve(int x) {
dfs1(x, -1);
while (!Q.empty()) {
int cur = Q.front();
del[cur] = 1;
Q.pop();
int sz = adj[cur].size();
int pi = -1;
for (int i = 0; i < sz; ++i)
if (!del[adj[cur][i]] && !forb[adj[cur][i]]) pi = adj[cur][i];
if (pi != -1) {
val[pi] += val[cur];
mxans = max(mxans, val[pi]);
val[cur] = 0;
deg[pi]--;
if (deg[pi] == 1) Q.push(pi);
}
mxans = max(mxans, val[x]);
}
dfs(x, -1);
}
bool check(int x) {
mxans = 0;
for (int i = 1; i <= n; ++i) {
used[i] = 0;
forb[i] = (ar[i] < x);
deg[i] = adj[i].size();
val[i] = 1;
del[i] = 0;
}
for (int i = 1; i <= n; ++i)
if (!used[i] && !forb[i]) solve(i);
return mxans >= k;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &ar[i]);
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int l = 1, mi = 1, mid, u = (1 << 20);
check(3);
while (l <= u) {
mid = (l + u) / 2;
if (check(mid)) {
l = mid + 1;
mi = mid;
} else
u = mid - 1;
}
printf("%d\n", mi);
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
long long powmod(long long a, long long b) {
long long res = 1;
a %= 5100229;
for (; b; b >>= 1) {
if (b & 1) res = res * a % 5100229;
a = a * a % 5100229;
}
return res;
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
int n, K, V, a[200100];
int fst[200100], nxt[5000100], vv[5000100], e;
int sz[200100], up_full[200100], down_full[200100], up_cnt[200100], val[200100],
ans[200100];
int mx1[200100], mx1u[200100], mx2[200100];
void init() {
e = 0;
memset(fst, -1, sizeof fst);
}
void add(int u, int v) {
vv[e] = v, nxt[e] = fst[u], fst[u] = e++;
vv[e] = u, nxt[e] = fst[v], fst[v] = e++;
}
void dfs0(int u, int f) {
val[u] = (a[u] >= V), sz[u] = 1;
down_full[u] = up_full[u] = up_cnt[u] = 0;
mx1[u] = mx2[u] = mx1u[u] = 0;
for (int i = fst[u]; ~i; i = nxt[i]) {
int v = vv[i];
if (v == f) continue;
dfs0(v, u);
sz[u] += sz[v];
if (a[u] >= V) {
if (down_full[v]) {
val[u] += val[v];
} else {
if (mx1[v] + val[v] > mx1[u])
mx2[u] = mx1[u], mx1u[u] = v, mx1[u] = val[v] + mx1[v];
else if (mx1[v] + val[v] > mx2[u])
mx2[u] = val[v] + mx1[v];
}
}
}
if (val[u] == sz[u]) down_full[u] = 1;
}
void dfs1(int u, int f) {
ans[u] = 0;
if (f) {
if (a[u] < V || a[f] < V)
up_full[u] = up_cnt[u] = 0;
else if (up_full[f] &&
val[f] - (down_full[u] == 1 ? sz[u] : 0) == sz[f] - sz[u]) {
up_full[u] = 1;
up_cnt[u] = sz[1] - sz[u];
} else {
up_full[u] = 0;
int full = 0, mx = 0;
if (mx1u[f] == u)
mx = mx2[f];
else
mx = mx1[f];
if (up_full[f]) {
full = up_cnt[f] + val[f] - (down_full[u] == 1 ? sz[u] : 0);
up_cnt[u] = full + mx;
} else {
full = val[f] - (down_full[u] == 1 ? sz[u] : 0);
mx = max(mx, up_cnt[f]);
up_cnt[u] = full + mx;
}
}
} else
up_full[u] = 1, up_cnt[u] = 0;
if (up_full[u])
ans[u] = up_cnt[u] + val[u] + mx1[u];
else
ans[u] = max(up_cnt[u], mx1[u]) + val[u];
for (int i = fst[u]; ~i; i = nxt[i]) {
int v = vv[i];
if (v == f) continue;
dfs1(v, u);
}
}
void debug() {
cout << "V :" << V << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
}
bool check() {
dfs0(1, 0);
dfs1(1, 0);
for (int i = 1; i <= n; i++)
if (ans[i] >= K) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &K);
int l = 0x3f3f3f3f, r = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
chkmin(l, a[i]);
chkmax(r, a[i]);
}
init();
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
}
int ans = l;
while (l <= r) {
V = (l + r) >> 1;
if (check())
l = V + 1, ans = V;
else
r = V - 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
int n, k;
vector<int> G[N];
int a[N];
int dp1[N], dp2[N];
int sum[N];
int cnt[N];
pair<int, int> pr[N];
void dfs1(int v, int p, int x) {
cnt[v] = 1;
pr[v] = make_pair(-1, -1);
for (int i = 0; i < G[v].size(); ++i) {
int to = G[v][i];
if (to == p) continue;
dfs1(to, v, x);
cnt[v] += cnt[to];
if (cnt[to] == dp1[to])
dp1[v] += dp1[to];
else {
if (pr[v].first == -1 || dp1[pr[v].first] < dp1[to]) {
pr[v].second = pr[v].first;
pr[v].first = to;
} else if (pr[v].second == -1 || dp1[pr[v].second] < dp1[to])
pr[v].second = to;
}
}
if (a[v] < x)
dp1[v] = sum[v] = 0;
else {
sum[v] = dp1[v];
dp1[v] += 1;
if (pr[v].first != -1) dp1[v] += dp1[pr[v].first];
}
}
void dfs2(int v, int p, int x) {
if (p == -1 || a[p] < x) {
dp2[v] = 0;
} else {
int c = sum[p] + 1;
int mx = 0;
if (pr[p].first != -1 && pr[p].first != v)
mx = dp1[pr[p].first];
else if (pr[p].second != -1 && pr[p].second != v)
mx = dp1[pr[p].second];
if (dp1[v] == cnt[v]) c -= dp1[v];
dp2[v] = c;
if (dp2[p] == n - cnt[p])
dp2[v] += dp2[p];
else
mx = max(mx, dp2[p]);
dp2[v] += mx;
}
for (int i = 0; i < G[v].size(); ++i) {
int to = G[v][i];
if (to == p) continue;
dfs2(to, v, x);
}
}
bool check(int x) {
for (int i = 0; i < n; ++i) dp1[i] = dp2[i] = sum[i] = 0;
dfs1(0, -1, x);
dfs2(0, -1, x);
for (int i = 0; i < n; ++i) {
if (a[i] < x) continue;
int ans = sum[i] + 1;
int mx = 0;
if (pr[i].first != -1) mx = dp1[pr[i].first];
if (dp2[i] == n - cnt[i])
ans += dp2[i];
else
mx = max(mx, dp2[i]);
if (ans + mx >= k) return true;
}
return false;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
G[u].push_back(v);
G[v].push_back(u);
}
int l = 0, r = 1000001;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (check(mid))
l = mid;
else
r = mid;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
template <typename T1, typename T2>
bool umin(T1 &x, const T2 &y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, const T2 &y) {
if (x < y) return x = y, true;
return false;
}
const int maxn = (int)1e6 + 100;
const int inf = (int)1e9 + 5;
const long long llinf = (long long)1e18 - 1;
const long double pi = acos(-1.0);
vector<int> g[maxn];
int dp[maxn];
int up[maxn];
int sz[maxn];
int a[maxn];
int satsum[maxn];
void calcs(int v, int p = -1) {
sz[v] = 1;
for (int x : g[v]) {
if (x != p) {
calcs(x, v);
sz[v] += sz[x];
}
}
if (p != -1) g[v].erase(find((g[v]).begin(), (g[v]).end(), p));
}
int lim, n, k;
void dfs(int v) {
for (int x : g[v]) {
dfs(x);
if (dp[x] == sz[x]) satsum[v] += dp[x];
}
if (a[v] < lim) return;
int best = 0;
for (int x : g[v]) {
if (dp[x] != sz[x]) best = max(best, dp[x]);
}
dp[v] = satsum[v] + best + 1;
}
void calcup(int v, int par = -1, pair<int, int> fmax = make_pair(-1, -1),
pair<int, int> smax = make_pair(-1, -1)) {
if (par != -1 && a[v] >= lim) {
if (up[par] == -inf) {
up[v] = 0;
} else {
int best = 0;
if (n - sz[par] == up[par])
up[v] += up[par];
else
umax(best, up[par]);
up[v] += satsum[par] - (dp[v] == sz[v] ? sz[v] : 0);
if (fmax.second != v) umax(best, fmax.first);
if (smax.second != v) umax(best, smax.first);
up[v] += best + 1;
}
} else if (a[v] < lim)
up[v] = -inf;
pair<int, int> a = make_pair(-1, -1), b = make_pair(-1, -1);
for (int x : g[v]) {
if (dp[x] == sz[x]) continue;
if (dp[x] > a.first) {
b = a;
a = make_pair(dp[x], x);
} else if (dp[x] > b.first) {
b = make_pair(dp[x], x);
}
}
for (int x : g[v]) calcup(x, v, a, b);
}
int solve(int x) {
memset(dp, 0, sizeof dp);
memset(up, 0, sizeof up);
memset(satsum, 0, sizeof satsum);
lim = x;
dfs(0);
calcup(0);
int ret = 0;
for (int i = (0); i < (n); i++) {
ret = max(ret, dp[i] + up[i]);
}
return ret;
}
int main() {
n = getint<int>();
k = getint<int>();
for (int i = (0); i < (n); i++) a[i] = getint<int>();
for (int i = (0); i < (n - 1); i++) {
int x = getint<int>() - 1;
int y = getint<int>() - 1;
g[x].push_back(y), g[y].push_back(x);
}
calcs(0);
vector<int> z(a, a + n);
sort((z).begin(), (z).end());
int l = 0, r = n;
while (r - l > 1) {
int m = (l + r) / 2;
if (solve(z[m]) >= k) {
l = m;
} else {
r = m;
}
}
printf("%d\n", z[l]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, need;
int limit;
vector<int> e[200001];
bool visited[200001];
int w[200001];
int dp[200001];
bool haveBad[200001];
int bestVal;
void dfs(int cur, int from) {
int maxForBad = 0;
visited[cur] = true;
haveBad[cur] = false;
dp[cur] = 1;
for (int i = 0; i < e[cur].size(); i++) {
int t = e[cur][i];
if (t == from) continue;
if (w[t] < limit)
haveBad[cur] = true;
else {
dfs(t, cur);
if (haveBad[t]) {
haveBad[cur] = true;
maxForBad = max(maxForBad, dp[t]);
} else
dp[cur] += dp[t];
}
}
dp[cur] += maxForBad;
bestVal = max(bestVal, dp[cur]);
}
void dfs2(int cur, int from, bool isBad, int val) {
int nowDP = 1;
int maxForBad = 0;
int maxForBadSecond = 0;
int maxForBadWhich = -1;
int haveBadElsewhere = isBad;
int cntBadSon = 0;
if (isBad)
maxForBad = val;
else
nowDP += val;
for (int i = 0; i < e[cur].size(); i++) {
int t = e[cur][i];
if (t == from) continue;
if (w[t] < limit) {
haveBadElsewhere = true;
continue;
}
if (haveBad[t]) {
if (dp[t] > maxForBad) {
maxForBadSecond = maxForBad;
maxForBad = dp[t];
maxForBadWhich = i;
} else if (dp[t] > maxForBadSecond) {
maxForBadSecond = dp[t];
}
cntBadSon++;
} else
nowDP += dp[t];
}
for (int i = 0; i < e[cur].size(); i++) {
int t = e[cur][i];
if (t == from) continue;
if (w[t] < limit) {
continue;
}
bool isBadNext = true;
if (haveBadElsewhere == 0 &&
(cntBadSon == 0 || (cntBadSon == 1 && haveBad[t])))
isBadNext = false;
int maxBadNext = maxForBad;
if (i == maxForBadWhich) maxBadNext = maxForBadSecond;
dfs2(t, cur, isBadNext, nowDP + maxBadNext - (haveBad[t] ? 0 : dp[t]));
}
bestVal = max(bestVal, nowDP + maxForBad);
}
bool check() {
memset(visited, false, sizeof(visited));
for (int i = 1; i <= n; i++)
if (w[i] >= limit)
if (!visited[i]) {
bestVal = 0;
dfs(i, -1);
dfs2(i, -1, 0, 0);
if (bestVal >= need) return true;
}
return false;
}
int MAIN() {
cin >> n >> need;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
e[a].push_back(b);
e[b].push_back(a);
}
int L = 0, R = 1000000, M;
while (R - L > 1) {
M = (L + R) / 2;
limit = M;
if (check())
L = M;
else
R = M;
}
cout << L << endl;
return 0;
}
int main() {
int start = clock();
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
int ret = MAIN();
return ret;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
struct Edge {
int to;
int nxt;
} edge[MAXN << 1];
int n, k, id;
int first[MAXN];
int a[MAXN];
int fa[MAXN];
int f[MAXN];
int g[MAXN];
int sz[MAXN];
void addE(int u, int v) {
edge[++id] = (Edge){v, first[u]};
first[u] = id;
}
void dfsinfo(int u) {
sz[u] = 1;
for (int i = first[u]; i; i = edge[i].nxt)
if (edge[i].to != fa[u]) {
fa[edge[i].to] = u;
dfsinfo(edge[i].to);
sz[u] += sz[edge[i].to];
}
}
void dfsf(int u, int lim) {
int MX = 0, sum = 1;
for (int i = first[u]; i; i = edge[i].nxt)
if (edge[i].to != fa[u] && a[edge[i].to] >= lim) {
dfsf(edge[i].to, lim);
if (sz[edge[i].to] == f[edge[i].to])
sum += f[edge[i].to];
else
MX = max(MX, f[edge[i].to]);
}
f[u] = MX + sum;
}
void dfsg(int u, int lim) {
int MX1 = 0, MX2 = 0, sum = 1;
for (int i = first[u]; i; i = edge[i].nxt)
if (edge[i].to != fa[u] && a[edge[i].to] >= lim) {
if (sz[edge[i].to] == f[edge[i].to])
sum += f[edge[i].to];
else if (f[edge[i].to] >= MX1) {
MX2 = MX1;
MX1 = f[edge[i].to];
} else if (f[edge[i].to] > MX2)
MX2 = f[edge[i].to];
}
if (n - sz[u] == g[u])
sum += g[u];
else if (g[u] >= MX1) {
MX2 = MX1;
MX1 = g[u];
} else if (g[u] > MX2)
MX2 = g[u];
for (int i = first[u]; i; i = edge[i].nxt)
if (edge[i].to != fa[u] && a[edge[i].to] >= lim) {
if (sz[edge[i].to] == f[edge[i].to])
g[edge[i].to] = sum - f[edge[i].to] + MX1;
else if (f[edge[i].to] == MX1)
g[edge[i].to] = sum + MX2;
else
g[edge[i].to] = sum + MX1;
dfsg(edge[i].to, lim);
}
}
int getans(int lim) {
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
if (a[1] >= lim) {
dfsf(1, lim);
dfsg(1, lim);
}
for (int i = 1; i <= n; i++)
if (a[i] < lim)
for (int j = first[i]; j; j = edge[j].nxt)
if (edge[j].to != fa[i] && a[edge[j].to] >= lim) {
dfsf(edge[j].to, lim);
dfsg(edge[j].to, lim);
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (a[i] < lim) continue;
int MX = 0, sum = 1;
for (int j = first[i]; j; j = edge[j].nxt)
if (a[edge[j].to] >= lim) {
int SZ = 0, FG = 0;
if (edge[j].to == fa[i]) {
SZ = n - sz[i];
FG = g[i];
} else {
SZ = sz[edge[j].to];
FG = f[edge[j].to];
}
if (FG == SZ)
sum += FG;
else
MX = max(MX, FG);
}
res = max(res, MX + sum);
}
return res;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int u, v, i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
addE(u, v);
addE(v, u);
}
dfsinfo(1);
int low = 1, high = 1000000;
while (low < high) {
int mid = low + high + 1 >> 1;
if (getans(mid) >= k)
low = mid;
else
high = mid - 1;
}
printf("%d\n", low);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e10;
inline long long read() {
bool f = 0;
long long x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return x;
}
inline void scf(int &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
void scf(int &x, int &y) {
scf(x);
return scf(y);
}
void scf(int &x, int &y, int &z) {
scf(x);
scf(y);
return scf(z);
}
const int N = 2e5 + 100;
int n, k;
vector<int> g[N];
bool on[N];
int val[N], down[N], up[N], siz[N], par[N], sum[N];
inline void dfs0(int u = 1, int f = 0) {
par[u] = f;
siz[u] = 1;
for (auto v : g[u])
if (v != f) dfs0(v, u), siz[u] += siz[v];
return;
}
inline void dfs1(int u = 1) {
sum[u] = 1;
int mx = 0;
for (auto v : g[u])
if (v != par[u]) {
dfs1(v);
if (down[v] != siz[v]) {
if (down[v] > mx) mx = down[v];
} else
sum[u] += down[v];
}
down[u] = sum[u] + mx;
if (!on[u]) down[u] = sum[u] = 0;
return;
}
inline void dfs2(int u = 1, int w = 0) {
up[u] = w;
int mx1 = 0, mx2 = 0, i1 = -1, i2 = -1;
if (up[u] == n - siz[u])
sum[u] += up[u];
else
mx1 = up[u];
for (auto v : g[u])
if (v != par[u] && down[v] != siz[v]) {
if (down[v] > mx1)
mx2 = mx1, i2 = i1, mx1 = down[v], i1 = v;
else if (down[v] > mx2)
mx2 = down[v], i2 = v;
}
for (auto v : g[u])
if (v != par[u]) {
int calc = sum[u] + mx1;
if (down[v] == siz[v])
calc -= down[v];
else if (v == i1)
calc += mx2 - mx1;
if (!on[u]) calc = 0;
dfs2(v, calc);
}
return;
}
inline int MAX(const int &a, const int &b) { return a < b ? b : a; }
inline bool check(int mid) {
for (int u = (1); u <= (n); u++) on[u] = (val[u] >= mid);
dfs1();
dfs2();
for (int u = (1); u <= (n); u++)
if (on[u]) {
int s = sum[u];
if (up[u] == n - siz[u])
s = down[u] + up[u];
else
s = MAX(down[u], sum[u] + up[u]);
if (s >= k) return 1;
}
return 0;
}
int main() {
int lb = 1000010, rb = 0;
scf(n, k);
for (int i = (1); i <= (n); i++) {
scf(val[i]);
if (val[i] < lb) lb = val[i];
if (val[i] > rb) rb = val[i];
}
for (int i = 0; i < (n - 1); i++) {
int u, v;
scf(u, v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs0();
while (lb <= rb) {
int mid = lb + rb >> 1;
if (check(mid))
lb = mid + 1;
else
rb = mid - 1;
}
printf("%d\n", rb);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int M = N * 2;
int fir[N], ne[M], to[M], a[N], x, y, n, m, S[N], have[N], mid, ans, k, b[N],
dp[N], cnt;
void add(int x, int y) {
ne[++cnt] = fir[x];
fir[x] = cnt;
to[cnt] = y;
}
void link(int x, int y) {
add(x, y);
add(y, x);
}
pair<int, int> sy[N];
void upd(pair<int, int> &x, int y) {
if (y <= x.second) return;
if (y > x.second && y <= x.first) {
x.second = y;
return;
}
x.second = x.first;
x.first = y;
}
void dfs(int x, int f) {
have[x] = b[x];
S[x] = 1;
dp[x] = 1;
sy[x] = make_pair(0, 0);
for (int i = fir[x]; i; i = ne[i]) {
int V = to[i];
if (V == f) continue;
dfs(V, x);
have[x] += have[V];
S[x] += S[V];
if (have[V] == S[V])
dp[x] += have[V];
else
upd(sy[x], dp[V]);
}
dp[x] *= b[x];
dp[x] += sy[x].first * b[x];
}
void dance(int x, int f, int fans) {
dp[x] -= sy[x].first * b[x];
int res = dp[x];
if (fans == S[1] - S[x])
res += fans * b[x];
else
upd(sy[x], fans);
ans = max(ans, res + sy[x].first * b[x]);
for (int i = fir[x]; i; i = ne[i]) {
int V = to[i];
if (V == f) continue;
int now = res + sy[x].first * b[x];
if (S[V] == have[V])
now = res + sy[x].first * b[x] - have[V] * b[x];
else if (dp[V] == sy[x].first)
now = res + sy[x].second * b[x];
dance(V, x, now);
}
}
int main(void) {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i < n; ++i) scanf("%d%d", &x, &y), link(x, y);
int l = 0, r = 1e6, res = 0;
while (l <= r) {
mid = (l + r) >> 1;
for (int i = 1; i <= n; ++i) b[i] = a[i] >= mid;
ans = 0;
dfs(1, 0);
dance(1, 0, 0);
if (ans >= k) {
res = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = 2 * acos((long double)0);
long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
void setmin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void setmax(T& a, T val) {
if (a < val) a = val;
}
void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
const int maxn = 200010;
int n, k;
int a[maxn];
vector<int> adj[maxn];
pair<int, int> f[maxn];
int d;
pair<int, int> dfs(int u, int p, int m) {
pair<int, int>& res = f[u];
if (~res.first) return res;
res = make_pair(1, 1);
int dmax = 0;
for (int i = (0); i < (int((adj[u]).size())); i++) {
int v = adj[u][i];
if (v != p) {
pair<int, int> r = dfs(v, u, m);
res.first += r.first;
if (r.first > r.second)
setmax(dmax, r.second);
else
res.second += r.second;
}
}
res.second += dmax;
if (a[u] < m) {
return res = make_pair(1, 0);
}
return res;
}
void dfs2(int u, int p, pair<int, int> val, int m) {
vector<int> vt;
vector<pair<int, int> > pref, suff;
for (int i = (0); i < (int((adj[u]).size())); i++) {
int v = adj[u][i];
if (v != p) {
vt.push_back(v);
pref.push_back(f[v]);
suff.push_back(f[v]);
}
}
pair<int, int> t = make_pair(0, 0);
vector<int> tmp;
int sum = 0;
for (int i = (0); i < (int((pref).size())); i++) {
tmp.push_back(pref[i].first);
sum += pref[i].first;
if (pref[i].first == pref[i].second) {
t.first += pref[i].first;
} else {
setmax(t.second, pref[i].second);
}
pref[i] = t;
}
t = make_pair(0, 0);
for (int i = (int((suff).size())) - 1; i >= (0); i--) {
if (suff[i].first == suff[i].second) {
t.first += suff[i].first;
} else {
setmax(t.second, suff[i].second);
}
suff[i] = t;
}
for (int i = (0); i < (int((vt).size())); i++) {
int v = vt[i];
int x, y;
if (val.first == val.second) {
x = val.first;
y = 0;
} else {
x = 0;
y = val.second;
}
if (i) {
x += pref[i - 1].first;
setmax(y, pref[i - 1].second);
}
if (i < int((vt).size()) - 1) {
x += suff[i + 1].first;
setmax(y, suff[i + 1].second);
}
if (a[u] >= m) {
x++;
} else {
x = y = 0;
}
dfs2(v, u, make_pair(val.first + sum - tmp[i] + 1, x + y), m);
}
if (a[u] >= m) {
int x, y;
if (val.first == val.second) {
x = val.first;
y = 0;
} else {
x = 0;
y = val.second;
}
if (f[u].first == f[u].second) {
x += f[u].first;
} else {
setmax(y, f[u].second);
}
setmax(d, x + y);
}
}
void solve() {
scanf("%d%d", &n, &k);
for (int i = (0); i < (n); i++) scanf("%d", a + i);
for (int i = (0); i < (n - 1); i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
int l = 1, r = 1000000;
while (l < r) {
int m = (l + r + 1) >> 1;
memset(f, -1, sizeof(f));
d = 0;
dfs(0, -1, m);
dfs2(0, -1, make_pair(0, 0), m);
if (d >= k)
l = m;
else
r = m - 1;
}
printf("%d", l);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[300300];
vector<int> L[300300];
int dg[300300];
int cur;
int foi[300300];
int peso[300300];
int rem[300300];
int tira[300300];
int dfs(int v, int p, int mid) {
foi[v] = 1;
if (w[v] < mid || rem[v]) return 0;
int a = peso[v];
int X = 0, Y = 0;
for (int i = 0; i < L[v].size(); i++)
if (L[v][i] != p) {
int r = dfs(L[v][i], v, mid);
if (r > X) {
Y = X;
X = r;
} else if (r > Y)
Y = r;
}
int s = X + Y;
cur = max(cur, s + a);
return a + X;
}
int ret;
char ch;
inline int read() {
ret = 0;
while ((ch = getchar()) >= '0') ret = 10 * ret + ch - '0';
return ret;
}
int main() {
int n, k;
n = read();
k = read();
for (int i = 0; i < n; i++) w[i] = read();
for (int i = 0; i < n - 1; i++) {
int a, b;
a = read() - 1;
b = read() - 1;
L[a].push_back(b);
L[b].push_back(a);
}
int low = 0, up = 1000000;
while (low != up) {
int mid = (low + up + 1) / 2;
;
for (int i = 0; i < n; i++) tira[i] = (w[i] >= mid) ? 1 : 0;
for (int i = 0; i < n; i++) peso[i] = 1;
queue<int> Q;
for (int i = 0; i < n; i++) rem[i] = 0;
for (int i = 0; i < n; i++) {
dg[i] = L[i].size();
;
}
for (int i = 0; i < n; i++)
if (dg[i] == 1 && tira[i]) {
Q.push(i);
;
};
cur = 0;
while (Q.size()) {
int u = Q.front();
;
Q.pop();
cur = max(cur, peso[u]);
rem[u] = 1;
for (int i = 0; i < L[u].size(); i++) {
dg[L[u][i]]--;
peso[L[u][i]] += peso[u];
if (dg[L[u][i]] == 1 && tira[L[u][i]]) {
Q.push(L[u][i]);
;
}
}
}
for (int i = 0; i < n; i++)
;
for (int i = 0; i < n; i++) foi[i] = 0;
for (int i = 0; i < n; i++)
if (!foi[i]) dfs(i, i, mid);
;
if (cur >= k)
low = mid;
else
up = mid - 1;
}
printf("%d\n", low);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int Pow(long long int a, long long int b, long long int md,
long long int ans = 1) {
for (; b; b >>= 1, a = a * a % md)
if (b & 1) ans = ans * a % md;
return ans % md;
}
const long long int MAXN = 2e5 + 10;
const long long int INF = 8e18;
const long long int MOD = 1e9 + 7;
long long int SZ[MAXN], dp[2][MAXN], A[MAXN], n, k, res = 0;
vector<long long int> adj[MAXN];
void merge(pair<long long int, long long int> &x, long long int y,
long long int md) {
if (y > x.second) x.second = y;
if (x.second > x.first) swap(x.first, x.second);
}
void DFSsoroush(long long int v, long long int x, long long int p = -1) {
SZ[v] = 1;
long long int wot = 0;
dp[0][v] = 1;
for (long long int u : adj[v]) {
if (u != p) {
DFSsoroush(u, x, v);
SZ[v] += SZ[u];
if (dp[0][u] == SZ[u])
dp[0][v] += SZ[u];
else
wot = max(wot, dp[0][u]);
}
}
dp[0][v] += wot;
if (A[v] < x) dp[0][v] = 0;
}
void DFSostad(long long int v, long long int x, long long int p = -1) {
pair<long long int, long long int> mx = {0, 0};
long long int t = (A[v] >= x);
if (v != 1 && dp[1][v] == n - SZ[v])
t += dp[1][v];
else
merge(mx, dp[1][v], x);
for (long long int u : adj[v]) {
if (u != p) {
if (dp[0][u] == SZ[u]) {
t += SZ[u];
} else
merge(mx, dp[0][u], x);
}
}
if (A[v] < x)
mx = {0, 0}, t = 0;
else
res = max(res, t + mx.first);
for (long long int u : adj[v]) {
if (u != p) {
dp[1][u] = t + mx.first;
if (dp[0][u] == SZ[u])
dp[1][u] -= SZ[u];
else if (dp[0][u] == mx.first) {
dp[1][u] -= mx.first;
dp[1][u] += mx.second;
}
}
}
for (long long int u : adj[v]) {
if (u != p) DFSostad(u, x, v);
}
}
long long int check(long long int x) {
DFSsoroush(1, x);
res = 0;
DFSostad(1, x);
return res >= k;
}
int main() {
scanf("%lld%lld", &n, &k);
for (long long int i = 1; i <= n; i++) scanf("%lld", &A[i]);
for (long long int i = 1; i <= n - 1; i++) {
long long int u, v;
scanf("%lld%lld", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
long long int l = 0, r = MOD;
while (r - l > 1) {
long long int mid = (l + r) >> 1;
if (check(mid))
l = mid;
else
r = mid;
}
printf("%lld\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
inline bool mina(A &first, B second) {
return (first > second) ? (first = second, 1) : 0;
}
template <class A, class B>
inline bool maxa(A &first, B second) {
return (first < second) ? (first = second, 1) : 0;
}
const int MAXN = 200005;
int values[MAXN];
vector<int> adj[MAXN];
int values2[MAXN];
bool removed[MAXN];
int degrees[MAXN];
int N, K;
bool red[MAXN];
int dp[MAXN];
int maxx;
void dfs(int at) {
maxa(maxx, values2[at]);
removed[at] = true;
int max1 = -1;
int max2 = -1;
dp[at] = values2[at];
for (auto v : adj[at]) {
if (!removed[v]) {
dfs(v);
maxa(dp[at], values2[at] + dp[v]);
maxa(maxx, dp[at]);
if (dp[v] >= max1) {
max2 = max1;
max1 = dp[v];
} else {
maxa(max2, dp[v]);
}
}
}
maxa(maxx, max1 + max2 + values2[at]);
}
bool good(int minimum) {
for (int(i) = 0; (i) < (N); ++(i)) {
values2[i] = 1;
if (values[i] < minimum) {
removed[i] = true;
} else {
removed[i] = false;
}
red[i] = false;
dp[i] = 0;
}
queue<int> Q;
for (int(i) = 0; (i) < (N); ++(i)) {
if (removed[i]) continue;
degrees[i] = 0;
for (auto v : adj[i]) {
if (!removed[v]) {
degrees[i]++;
} else {
red[i] = true;
}
}
if (degrees[i] == 0) {
if (K == 1) {
return true;
}
} else if (degrees[i] == 1 && !red[i]) {
Q.push(i);
}
}
maxx = 0;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
removed[u] = true;
maxa(maxx, values2[u]);
for (auto v : adj[u]) {
if (!removed[v]) {
values2[v] += values2[u];
maxa(maxx, values2[v]);
degrees[v]--;
if (!red[v] && degrees[v] == 1) {
Q.push(v);
}
}
}
}
for (int(i) = 0; (i) < (N); ++(i)) {
if (!removed[i]) {
dfs(i);
}
}
return maxx >= K;
}
int main() {
scanf("%d %d", &N, &K);
for (int(i) = 0; (i) < (N); ++(i)) {
scanf("%d", &values[i]);
}
for (int(i) = 0; (i) < (N - 1); ++(i)) {
int u, v;
scanf("%d %d", &u, &v);
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
int left = 1, right = 1e6;
while (left <= right) {
int mid = (left + right) / 2;
if (good(mid)) {
left = mid + 1;
} else {
right = mid - 1;
}
}
cout << right << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 100;
const int INF = 1e6 + 100;
int dpD[MAXN], dpU[MAXN], vis[MAXN], ans[MAXN], a[MAXN];
int n, k;
bool goodU[MAXN], goodD[MAXN];
vector<int> G[MAXN];
void dfsD(int u = 0, int f = -1) {
goodD[u] = vis[u];
int sum = vis[u];
dpD[u] = sum;
for (auto v : G[u])
if (v - f) {
dfsD(v, u);
sum += goodD[v] * dpD[v];
goodD[u] = goodD[u] & goodD[v];
}
for (auto v : G[u])
if (v - f) dpD[u] = max(dpD[u], sum + (!goodD[v]) * dpD[v]);
if (!vis[u]) dpD[u] = 0;
return;
}
void dfsU(int u = 0, int f = -1) {
if (vis[u]) {
bool g1 = goodU[u] & vis[u];
int sum1 = dpU[u] * goodU[u] + vis[u], pd1 = (!goodU[u]) * dpU[u];
vector<bool> g;
g.push_back(1);
vector<int> sum, pd;
sum.push_back(0);
pd.push_back(0);
for (auto v : G[u]) {
if (v - f) {
g.push_back(g[g.size() - 1] & goodD[v]);
sum.push_back(sum[sum.size() - 1] + dpD[v] * goodD[v]);
pd.push_back(max(pd[pd.size() - 1], (!goodD[v]) * dpD[v]));
}
}
int j = g.size() - 2;
for (int i = G[u].size() - 1; i >= 0; i--) {
int v = G[u][i];
if (v - f) {
goodU[v] = g[j] & g1;
dpU[v] = sum[j] + sum1 + max(pd[j], pd1);
g1 = g1 & goodD[v];
sum1 = sum1 + dpD[v] * goodD[v];
pd1 = max(pd1, (!goodD[v]) * dpD[v]);
j--;
}
}
} else
for (auto v : G[u])
if (v - f) goodU[v] = dpU[v] = 0;
int SUM = (goodU[u]) * dpU[u] + vis[u], PD = (!goodU[u]) * dpU[u];
for (auto v : G[u])
if (v - f) {
SUM += goodD[v] * dpD[v];
PD = max(PD, (!goodD[v]) * dpD[v]);
}
ans[u] = SUM + PD;
if (!vis[u]) ans[u] = 0;
for (auto v : G[u])
if (v - f) dfsU(v, u);
return;
}
void cler() {
fill(dpD, dpD + n, 0);
fill(dpU, dpU + n, 0);
}
bool Do(int x) {
cler();
for (int i = 0; i < n; i++) {
if (a[i] >= x)
vis[i] = 1;
else
vis[i] = 0;
}
dfsD();
goodU[0] = 1;
dfsU();
for (int i = 0; i < n; i++)
if (ans[i] >= k) return 1;
return 0;
}
int BS(int l, int r) {
if (r - l == 1) return l;
int mid = (l + r) >> 1;
if (Do(mid)) return BS(mid, r);
return BS(l, mid);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
int u, v;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
u--;
v--;
G[u].push_back(v);
G[v].push_back(u);
}
cout << BS(0, INF);
}
|
#include <bits/stdc++.h>
using namespace std;
char _;
const int maxN = 200 * 1000 + 5;
const int maxM = 5000 + 5;
const int mod = 1000 * 1000 * 1000 + 7;
const int base = 701;
const int SQ = 500;
const int maxL = 20;
int val[maxN];
vector<int> a[maxN];
int h[maxN], sz[maxN], ss[maxN];
int V, S;
int dp[maxN], D[maxN];
bool gg(int v) { return (sz[v] == 0); }
void dfs(int v, int par = -1) {
sz[v] = (val[v] < V);
ss[v] = 1;
dp[v] = 0;
int bes = 0;
for (auto u : a[v])
if (u - par) {
h[u] = h[v] + 1;
dfs(u, v);
sz[v] += sz[u];
ss[v] += ss[u];
if (gg(u))
dp[v] += ss[u];
else
bes = max(bes, dp[u]);
}
dp[v] += bes;
if (val[v] < V)
dp[v] = 0;
else
dp[v]++;
}
int n;
void DFS(int v, int par = -1) {
int sum = 0;
vector<pair<int, int> > pp;
if (sz[v] == S)
sum += (n - ss[v]);
else
pp.push_back({D[v], -1});
for (auto u : a[v])
if (u - par)
if (gg(u))
sum += ss[u];
else {
pp.push_back({dp[u], u});
sort(pp.rbegin(), pp.rend());
if (pp.size() > 2) pp.pop_back();
}
sum++;
for (auto u : a[v])
if (u - par) {
if (val[v] >= V) {
int tmp = sum;
if (gg(u)) tmp -= ss[u];
for (int i = 0; i < (int)pp.size(); i++)
if (pp[i].second != u) {
tmp += pp[i].first;
break;
}
D[u] = tmp;
} else
D[u] = 0;
DFS(u, v);
}
}
int k;
bool check(int t) {
V = t;
S = 0;
for (int i = 0; i < n; i++) S += (val[i] < V);
dfs(0);
DFS(0);
for (int i = 0; i < n; i++) {
if (val[i] < V) continue;
int ans = 1;
int bes = 0;
for (auto u : a[i])
if (h[u] > h[i]) {
if (gg(u))
ans += ss[u];
else
bes = max(bes, dp[u]);
} else {
if (sz[i] == S)
ans += (n - ss[i]);
else
bes = max(bes, D[i]);
}
if (ans + bes >= k) return true;
}
return false;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> val[i];
for (int i = 1; i < n; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
a[v].push_back(u);
a[u].push_back(v);
}
int lo = 0, hi = 1000 * 1000 + 5;
while (hi - lo > 1) {
int mid = (hi + lo) >> 1;
if (check(mid))
lo = mid;
else
hi = mid;
}
cout << lo << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 15;
vector<int> adj[N];
int dp[N], sz[N], a[N];
bool dirty[N], vis[N];
vector<int> order;
void dfs(int x, int p) {
int u, i;
sz[x] = 1;
order.push_back(x);
for (i = 0; i < adj[x].size(); ++i) {
u = adj[x][i];
if (u != p) dfs(u, x), sz[x] += sz[u];
}
}
void dfs2(int x, int p) {
int u, i, tot = 1, maxi = 0;
vis[x] = 1;
if (dirty[x]) {
dp[x] = 0;
return;
}
for (i = 0; i < adj[x].size(); ++i) {
u = adj[x][i];
if (u != p) {
dfs2(u, x);
if (dp[u] == sz[u])
tot += sz[u];
else
maxi = max(maxi, dp[u]);
}
}
dp[x] = maxi + tot;
}
bool dfs3(int x, int p, int Maxi, int n, int k) {
if (vis[x]) return 0;
vis[x] = 1;
int u, i, tot = 1;
multiset<int> s;
multiset<int>::iterator it;
multiset<int>::reverse_iterator rit;
if (Maxi == 0 || n - sz[x] == Maxi)
tot += Maxi;
else
s.insert(Maxi);
for (i = 0; i < adj[x].size(); ++i) {
u = adj[x][i];
if (dirty[u] || u == p) continue;
if (dp[u] == sz[u])
tot += dp[u];
else
s.insert(dp[u]);
}
int a = 0, b = 0;
if (s.size() > 0) a = *s.rbegin(), s.erase(s.find(a));
if (s.size() > 0) b = *s.rbegin(), s.erase(s.find(b));
if (tot + a + b >= k) return 1;
if (a != 0) s.insert(a);
if (b != 0) s.insert(b);
for (i = 0; i < adj[x].size(); ++i) {
u = adj[x][i];
if (dirty[u] || u == p) continue;
if (dp[u] == sz[u])
tot -= dp[u];
else {
assert(s.size() > 0);
it = s.find(dp[u]), s.erase(it);
}
int nMaxi = tot;
if (s.size() > 0) nMaxi += *s.rbegin();
if (dfs3(u, x, nMaxi, n, k)) return 1;
if (dp[u] == sz[u])
tot += dp[u];
else
s.insert(dp[u]);
}
return 0;
}
bool go(int n, int k, int val) {
int i, u;
for (i = 1; i <= n; ++i) {
if (a[i] >= val)
dirty[i] = 0;
else
dirty[i] = 1;
}
memset(vis, 0, sizeof(vis));
for (i = 0; i < order.size(); ++i)
if (!vis[order[i]]) dfs2(order[i], 0);
memset(vis, 0, sizeof(vis));
for (i = 0; i < order.size(); ++i)
if (!vis[order[i]] && !dirty[order[i]]) {
if (dfs3(order[i], 0, 0, n, k)) return 1;
}
return 0;
}
void solve() {
int n, i, k, x, y;
cin >> n >> k;
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
int l = 1, r = 1e6, mid;
for (i = 0; i < n - 1; ++i)
scanf("%d%d", &x, &y), adj[x].push_back(y), adj[y].push_back(x);
dfs(1, 0);
while (l < r) {
mid = (l + r + 1) / 2;
if (go(n, k, mid))
l = mid;
else
r = mid - 1;
}
cout << l << endl;
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
vector<int> AdjList[200010];
int arr[200010];
int subtree[200010], parent[200010];
void dfs0(int node, int dad) {
parent[node] = dad;
subtree[node] = 1;
for (int i = 0; i < AdjList[node].size(); i++) {
int v = AdjList[node][i];
if (v != dad) {
dfs0(v, node);
subtree[node] += subtree[v];
}
}
}
int NN, val, gsubtree[200010];
bool tell1(int n) {
if (subtree[n] == gsubtree[n])
return true;
else
return false;
}
bool tell2(int n) {
if (N - subtree[n] == NN - gsubtree[n])
return true;
else
return false;
}
int fdp_p[200010], fdp_s[200010], hdp_p[200010], hdp_s[200010];
int fdp_u[200010], hdp_u[200010];
int dp1[200010], dp2[200010], dp3[200010], dp4[200010];
int gans;
void dfs1(int node) {
if (arr[node] < val) {
for (int i = 0; i < AdjList[node].size(); i++) {
int v = AdjList[node][i];
if (v != parent[node]) dfs1(v);
}
return;
}
int add = 0, mmax = 0;
if (arr[node] >= val) gsubtree[node] = 1;
for (int i = 0; i < AdjList[node].size(); i++) {
int v = AdjList[node][i];
if (v != parent[node]) {
dfs1(v);
gsubtree[node] += gsubtree[v];
if (arr[v] >= val) {
dp2[node] += dp2[v];
dp1[node] = max(dp1[node], dp1[v]);
fdp_p[v] = add;
hdp_p[v] = mmax;
if (tell1(v))
add += subtree[v];
else
mmax = max(mmax, dp1[v]);
}
}
}
dp4[node] = mmax;
dp1[node] += dp2[node] + 1;
dp3[node] = add;
if (tell1(node))
dp2[node] = subtree[node], dp1[node] = 0;
else
dp2[node] = 0;
}
void dfs2(int node) {
if (arr[node] < val) {
for (int i = AdjList[node].size() - 1; i >= 0; i--) {
int v = AdjList[node][i];
if (v != parent[node]) dfs2(v);
}
return;
}
gans = max(gans, 1);
int add = 0, mmax = 0;
for (int i = AdjList[node].size() - 1; i >= 0; i--) {
int v = AdjList[node][i];
if (v != parent[node]) {
dfs2(v);
if (arr[v] >= val) {
fdp_s[v] = add;
hdp_s[v] = mmax;
if (tell1(v))
add += subtree[v];
else
mmax = max(mmax, dp1[v]);
gans = max(gans, add + fdp_p[v] + 1 + hdp_p[v] + mmax);
}
}
}
}
void dfs3(int node) {
int dad = parent[node];
if (arr[node] >= val) {
if (node == 1 or arr[dad] < val) {
} else {
if (tell2(node))
fdp_u[node] = N - subtree[node], hdp_u[node] = 0;
else {
fdp_u[node] = 0;
hdp_u[node] = fdp_p[node] + fdp_s[node] + fdp_u[dad] +
max(hdp_u[dad], max(hdp_p[node], hdp_s[node])) + 1;
}
}
}
for (int i = 0; i < AdjList[node].size(); i++) {
int v = AdjList[node][i];
if (v != dad) {
dfs3(v);
}
}
}
bool check(int k) {
NN = 0;
val = k;
for (int i = 1; i <= N; i++)
if (arr[i] >= k) NN++;
if (NN == N and N >= K) return true;
gans = 0;
int root = 1;
for (int i = 1; i <= N; i++) {
if (arr[i] < k) {
root = i;
break;
}
}
dfs0(root, 0);
dfs1(root);
dfs2(root);
bool flag = false;
if (gans >= K) flag = true;
for (int i = 1; i <= N; i++) {
gsubtree[i] = 0;
dp1[i] = dp2[i] = dp3[i] = dp4[i] = fdp_p[i] = fdp_s[i] = hdp_p[i] =
hdp_s[i] = fdp_u[i] = hdp_u[i] = 0;
}
if (flag)
return true;
else
return false;
}
int bin(int start, int end) {
if (start > end) return end;
int mid = (start + end) / 2;
if (check(mid))
return bin(mid + 1, end);
else
return bin(start, mid - 1);
}
int u = 0;
inline void ReadInput(void) {
scanf("%d", &N);
scanf("%d", &K);
for (int i = 1; i <= N; i++) scanf("%d", &arr[i]), u = max(u, arr[i]);
for (int i = 1; i < N; i++) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
AdjList[a].push_back(b);
AdjList[b].push_back(a);
}
}
inline void solve(void) {
int ans = bin(1, u);
cout << ans << endl;
}
inline void Refresh(void) {}
int main() {
ReadInput();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, arr[200001];
int da[200001], dac[200001], dmc[200001][2];
vector<int> adj[200001];
int T, ret;
void dfs(int cur, int p) {
da[cur] = dac[cur] = dmc[cur][0] = dmc[cur][1] = 0;
da[cur] = 1;
for (auto &it : adj[cur])
if (it != p) {
dfs(it, cur);
da[cur] &= da[it];
if (da[it]) {
dac[cur] += dac[it];
} else {
for (int i = 0; i < 2; i++)
if (dmc[cur][i] < dmc[it][0]) {
for (int j = i + 1; j < 2; j++) dmc[cur][j] = dmc[cur][j - 1];
dmc[cur][i] = dmc[it][0];
break;
}
}
}
if (arr[cur] < T)
da[cur] = dac[cur] = dmc[cur][0] = dmc[cur][1] = 0;
else {
if (da[cur])
dac[cur]++;
else {
for (int i = 0; i < 2; i++) dmc[cur][i] += dac[cur] + 1;
dac[cur] = 0;
}
}
}
void get(int cur, int p, int a, int ac, int mc) {
if (arr[cur] >= T) {
if (a && da[cur])
ret = max(ret, dac[cur] + ac);
else if (a)
ret = max(ret, max(ac + dmc[cur][0], mc + 1));
else if (da[cur])
ret = max(ret, max(dac[cur] + mc, dmc[cur][0]));
else
ret = max(ret, max(dmc[cur][0], mc + 1));
}
int f = !a, mc2 = 0;
for (auto &it : adj[cur])
if (it != p) {
if (da[it])
ac += dac[it];
else {
f++;
if (mc < dmc[it][0]) {
mc2 = mc;
mc = dmc[it][0];
} else if (mc2 < dmc[it][0])
mc2 = dmc[it][0];
}
}
for (auto &it : adj[cur])
if (it != p) {
if (arr[cur] < T) {
get(it, cur, 0, 0, 0);
} else if (f == 0) {
get(it, cur, 1, ac - dac[it] + 1, 0);
} else {
if (f - (!da[it]) == 0) {
get(it, cur, 1, ac + 1, 0);
} else {
if (dmc[it][0] == mc)
get(it, cur, 0, 0, mc2 + ac - dac[it] + 1);
else
get(it, cur, 0, 0, mc + ac - dac[it] + 1);
}
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", arr + i);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int lo = 0, up = 1e6 + 1;
while (up - lo > 1) {
T = (lo + up) >> 1;
dfs(1, 0);
ret = 0;
get(1, 0, 1, 0, 0);
if (ret >= k)
lo = T;
else
up = T;
}
printf("%d\n", lo);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int value, ans;
int bads[200010], maxDelay[200010], extraDelay[200010], a[200010], v[200010];
vector<int> T[200010], val[200010], pre[200010], post[200010];
void dfs(int x, int f) {
bads[x] = 0;
maxDelay[x] = 0;
extraDelay[x] = 0;
for (int i = 0; i < T[x].size(); ++i) {
int y = T[x][i];
if (y != f) {
dfs(y, x);
bads[x] += bads[y];
if (bads[y] == 0) {
maxDelay[x] += maxDelay[y];
} else {
extraDelay[x] = max(extraDelay[x], maxDelay[y]);
}
}
}
if (a[x] < value) {
bads[x]++;
maxDelay[x] = 0;
} else {
maxDelay[x] += extraDelay[x] + 1;
}
}
void dfs(int x, int f, int fBads, int fMaxDelay) {
if (a[x] >= value) {
int finalVal = maxDelay[x] - extraDelay[x];
finalVal += (fBads == 0 ? fMaxDelay + extraDelay[x]
: max(fMaxDelay, extraDelay[x]));
ans = max(ans, finalVal);
}
for (int i = 0; i < T[x].size(); ++i) {
int y = T[x][i];
if (y == f) {
val[x][i] = (fBads > 0 ? fMaxDelay : 0);
} else {
val[x][i] = (bads[y] > 0 ? maxDelay[y] : 0);
}
}
int sz = T[x].size();
pre[x][0] = val[x][0];
post[x][sz - 1] = val[x][sz - 1];
for (int i = 1; i < sz; ++i) pre[x][i] = max(val[x][i], pre[x][i - 1]);
for (int i = sz - 2; i >= 0; --i) post[x][i] = max(val[x][i], post[x][i + 1]);
for (int i = 0; i < T[x].size(); ++i) {
int y = T[x][i];
if (y == f) continue;
if (a[x] < value) {
dfs(y, x, bads[x] - bads[y] + fBads, 0);
} else {
int newBads = bads[x] - bads[y] + fBads;
int newMaxDelay =
maxDelay[x] - extraDelay[x] - (bads[y] == 0 ? maxDelay[y] : 0) +
(fBads == 0 ? fMaxDelay : 0) +
max((i == 0 ? 0 : pre[x][i - 1]), (i == sz - 1 ? 0 : post[x][i + 1]));
dfs(y, x, newBads, newMaxDelay);
}
}
}
void reset() {}
int check(int tval) {
reset();
value = tval;
ans = 0;
dfs(1, 0);
dfs(1, 0, 0, 0);
return (ans >= k);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
v[i] = a[i];
}
sort(v + 1, v + n + 1);
for (int i = 1; i < n; ++i) {
int a, b;
cin >> a >> b;
T[a].push_back(b);
T[b].push_back(a);
}
for (int i = 1; i <= n; ++i) {
val[i].resize(T[i].size(), 0);
pre[i].resize(T[i].size(), 0);
post[i].resize(T[i].size(), 0);
}
int lo = 0, hi = n + 1;
while (hi - lo > 1) {
int mid = (lo + hi) / 2;
if (check(v[mid]))
lo = mid;
else
hi = mid;
}
cout << v[lo];
}
|
#include <bits/stdc++.h>
using namespace std;
int mv, m;
bool ccs[1123456];
int sz[1123456];
int dp[1123456], sp[1123456], tp[1123456];
int n;
vector<int> adj[1123456], child[1123456];
int a[1123456];
inline void dfs(int u, int p) {
int v;
int s = 1;
sz[u] = 1;
child[u].clear();
for (int i = 0; i < adj[u].size(); ++i) {
v = adj[u][i];
if (v != p) {
dfs(v, u);
sz[u] += sz[v];
if (ccs[v] == true) {
s += sz[v];
} else {
child[u].push_back(v);
}
}
}
ccs[u] = false;
sp[u] = 0;
dp[u] = 0;
tp[u] = 0;
if (a[u] < m) {
return;
}
if (child[u].size() == 0) {
ccs[u] = true;
sp[u] = s;
dp[u] = s;
tp[u] = s;
mv = max(mv, s);
return;
}
ccs[u] = false;
if (child[u].size() == 1) {
v = child[u][0];
sp[u] = s + sp[v];
dp[u] = s + sp[v];
tp[u] = s + max(tp[v], dp[v]);
mv = max(mv, sp[u]);
mv = max(mv, dp[u]);
mv = max(mv, tp[u]);
return;
}
vector<int> vec;
for (int i = 0; i < child[u].size(); ++i) {
v = child[u][i];
vec.push_back(sp[v]);
}
sort(vec.begin(), vec.end());
int x = vec.size();
sp[u] = s + vec[x - 1];
dp[u] = s + vec[x - 1] + vec[x - 2];
mv = max(mv, dp[u]);
mv = max(mv, sp[u]);
mv = max(mv, tp[u]);
}
int main() {
int k, u, v;
scanf("%d", &n);
scanf("%d", &k);
for (int i = 1; i < n + 1; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; ++i) {
scanf("%d", &u);
scanf("%d", &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int l = 1, r = 10000000;
while (l < r) {
m = (l + r) / 2 + 1;
mv = 0;
dfs(1, 0);
if (mv >= k) {
l = m;
} else {
r = m - 1;
}
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
int A[200001];
int threshold;
multiset<int> disabled[200001];
int gogo[200001];
vector<int> adj[200001];
void dfs(int u, int p) {
gogo[u] = 1;
for (auto& v : adj[u])
if (v != p) {
dfs(v, u);
if (disabled[v].empty())
gogo[u] += gogo[v];
else
disabled[u].insert(gogo[v]);
}
if (!disabled[u].empty()) gogo[u] += *disabled[u].rbegin();
if (A[u] < threshold) {
gogo[u] = 0;
disabled[u].insert(0);
}
}
void moveroot(int u, int v) {
if (disabled[v].empty()) {
if (A[u] >= threshold) gogo[u] -= gogo[v];
if (disabled[u].empty())
gogo[v] += gogo[u];
else {
if (!disabled[v].empty()) gogo[v] -= *disabled[v].rbegin();
disabled[v].insert(gogo[u]);
gogo[v] += *disabled[v].rbegin();
}
} else {
if (!disabled[u].empty()) gogo[u] -= *disabled[u].rbegin();
disabled[u].erase(disabled[u].find(gogo[v]));
if (!disabled[u].empty()) gogo[u] += *disabled[u].rbegin();
if (A[u] < threshold) gogo[u] = 0;
if (disabled[u].empty())
gogo[v] += gogo[u];
else {
if (!disabled[v].empty()) gogo[v] -= *disabled[v].rbegin();
disabled[v].insert(gogo[u]);
gogo[v] += *disabled[v].rbegin();
}
}
if (A[u] < threshold) gogo[u] = 0;
if (A[v] < threshold) gogo[v] = 0;
}
int dfs2(int u, int p) {
int ret = gogo[u];
for (auto& v : adj[u])
if (v != p) {
moveroot(u, v);
ret = max(ret, dfs2(v, u));
moveroot(v, u);
}
return ret;
}
int main() {
scanf("%d%d", &N, &K);
for (int i = 1; i <= N; i++) scanf("%d", A + i);
int a, b;
for (int i = 0; i < N - 1; i++) {
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
int lo = 1, mid, hi = 1000000;
while (lo < hi) {
mid = (lo + hi + 1) / 2;
threshold = mid;
for (int i = 1; i <= N; i++) disabled[i].clear();
dfs(1, 1);
if (dfs2(1, 1) >= K)
lo = mid;
else
hi = mid - 1;
}
printf("%d\n", lo);
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m;
int a[300000];
int b[300000];
vector<int> edge[300000];
int ngood;
int child[300000];
int good[300000];
int d[300000];
int ans;
void back(int now, int parent) {
child[now] = 1;
good[now] = b[now];
for (auto e : edge[now])
if (e != parent) {
back(e, now);
child[now] += child[e], good[now] += good[e];
}
}
vector<pair<int, int> > v;
void back2(int now, int parent) {
for (auto e : edge[now])
if (e != parent) {
back2(e, now);
}
if (b[now] == 0) {
d[now] = 0;
return;
}
d[now] = 1;
int xgood = 0;
for (auto e : edge[now])
if (e != parent) {
if (child[e] == good[e]) xgood += child[e];
}
d[now] = 1 + xgood;
for (auto e : edge[now])
if (e != parent) {
d[now] =
max(d[now], 1 + d[e] + xgood - (child[e] == good[e] ? child[e] : 0));
}
ans = max(ans, d[now]);
int u = 1 + (n - child[now] == ngood - good[now] ? n - child[now] : 0);
v.clear();
for (auto e : edge[now])
if (e != parent) {
v.emplace_back(d[e], e);
}
sort((v).begin(), (v).end(), greater<pair<int, int> >());
for (int i = 0; i < 8 && i < v.size(); i++) {
for (int j = i + 1; j < 8 && j < v.size(); j++) {
ans = max(
ans, u + v[i].first + v[j].first + xgood -
(child[v[i].second] == good[v[i].second] ? child[v[i].second]
: 0) -
(child[v[j].second] == good[v[j].second] ? child[v[j].second]
: 0));
}
}
}
int param(int x) {
int i, j, k;
for (i = 0; i < n; i++) b[i] = a[i] >= x;
ngood = count(b, b + n, 1);
back(0, -1);
ans = 0;
back2(0, -1);
return ans >= m;
}
int main() {
int i, j, k;
cin >> n >> m;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y), x--, y--;
edge[x].push_back(y), edge[y].push_back(x);
}
int low = 0, high = 1000001, mid;
while (low <= high) {
mid = (low + high) / 2;
if (param(mid))
low = mid + 1;
else
high = mid - 1;
}
cout << high;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int first = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9';) {
if (ch == '-') f = -1;
ch = getchar();
}
for (; ch >= '0' && ch <= '9';) {
first = first * 10 + ch - '0';
ch = getchar();
}
return first * f;
}
int n, k;
int dex[200010], tot = 1;
struct node {
int ed, before;
} g[200010 * 2];
inline void add(int first, int second) {
g[++tot].ed = second;
g[tot].before = dex[first];
dex[first] = tot;
}
int a[200010];
inline void Init() {
n = read(), k = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n - 1; i++) {
int u = read(), v = read();
add(u, v);
add(v, u);
}
}
int size[200010], l[200010], r[200010], Times;
inline void Find(int u, int f) {
l[u] = ++Times;
size[u] = 1;
for (int j = dex[u], v; j; j = g[j].before) {
v = g[j].ed;
if (v == f) continue;
Find(v, u);
size[u] += size[v];
}
r[u] = Times;
}
int ans, flag[200010], f[200010];
inline void getf(int u, int fa) {
int s1 = 0, s2 = 0;
for (int j = dex[u], v; j; j = g[j].before) {
v = g[j].ed;
if (v == fa) continue;
getf(v, u);
if (f[v] == size[v])
s1 += f[v];
else
s2 = max(s2, f[v]);
}
if (!flag[u])
f[u] = 0;
else
f[u] = 1 + s1 + s2;
}
inline int getg(int u, int fa, int outs) {
int s1 = 0, s2j = 0, s3j = 0;
for (int j = dex[u], v; j; j = g[j].before) {
v = g[j].ed;
if (v == fa) continue;
if (f[v] == size[v])
s1 += f[v];
else if (f[v] >= f[s2j])
s3j = s2j, s2j = v;
else if (f[v] > f[s3j])
s3j = v;
}
int s2 = f[s2j];
if (flag[u]) {
if (outs == n - size[u])
s1 += outs;
else if (outs > s2)
s2 = outs, s2j = 0;
if (s1 + s2 + 1 >= k) return 1;
}
for (int j = dex[u], v; j; j = g[j].before) {
v = g[j].ed;
if (v == fa) continue;
int outj = s1 + s2 + 1;
if (f[v] == size[v])
outj -= f[v];
else if (v == s2j)
outj -= f[s2j] - f[s3j];
if (!flag[u]) outj = 0;
if (getg(v, u, outj)) return 1;
}
return 0;
}
inline int check(int first) {
for (int i = 1; i <= n; i++) flag[i] = (a[i] >= first);
getf(1, 0);
return getg(1, 0, 0);
}
inline void Solve() {
Find(1, 0);
int l = 1, r = 1000000;
for (; l <= r;) {
int mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
printf("%d\n", ans);
}
int main() {
Init();
Solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 201 * 1001, MOD = 1e9 + 7;
;
int sz[MAXN], dp[MAXN], dp2[MAXN], mark[MAXN];
int par[MAXN], a[MAXN], ans[MAXN], n, k;
vector<int> adj[MAXN];
void dfs(int u, int p) {
par[u] = p;
sz[u] = 1;
int k = 0, mx = 0;
for (auto v : adj[u]) {
if (v == p) continue;
dfs(v, u);
if (sz[v] == dp[v])
k += sz[v];
else
mx = max(mx, dp[v]);
sz[u] += sz[v];
}
if (!mark[u]) {
dp[u] = 0;
return;
}
dp[u] = k + mx + 1;
}
void dfs2(int u, int p) {
int k = 0, mx1 = 0, mx2 = 0, ind1, ind2;
for (auto v : adj[u]) {
if (v == p) continue;
if (dp[v] == sz[v])
k += dp[v];
else {
if (dp[v] > mx1) {
ind2 = ind1;
mx2 = mx1;
mx1 = dp[v];
ind1 = v;
} else if (dp[v] > mx2)
mx2 = dp[v], ind2 = v;
}
}
if (dp2[u] == n - sz[u])
k += dp2[u];
else {
if (dp2[u] > mx1) {
ind2 = ind1;
mx2 = mx1;
mx1 = dp2[u];
ind1 = u;
} else if (dp2[u] > mx2)
mx2 = dp2[u], ind2 = u;
}
for (auto v : adj[u]) {
if (v == p) continue;
if (dp[v] == sz[v])
dp2[v] = k - dp[v] + mx1 + 1;
else {
if (v != ind1)
dp2[v] = k + mx1 + 1;
else
dp2[v] = k + mx2 + 1;
}
if (!mark[u]) dp2[v] = 0;
dfs2(v, u);
}
}
bool check(int x) {
for (int i = 1; i <= n; i++) mark[i] = (a[i] >= x);
memset(dp, 0, sizeof dp);
memset(dp2, 0, sizeof dp2);
memset(sz, 0, sizeof sz);
dfs(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
if (!mark[i]) continue;
int mx = 0;
ans[i] = 0;
for (auto v : adj[i]) {
if (v == par[i]) {
if (dp2[i] == n - sz[i])
ans[i] += dp2[i];
else
mx = max(mx, dp2[i]);
} else {
if (dp[v] == sz[v])
ans[i] += dp[v];
else
mx = max(mx, dp[v]);
}
}
if (ans[i] + mx + 1 >= k) return 1;
}
return 0;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
int x, y;
for (int i = 1; i < n; i++)
cin >> x >> y, adj[x].push_back(y), adj[y].push_back(x);
int l = 0, r = 1e7;
while (r - l > 1) {
int mid = (r + l) / 2;
if (check(mid))
l = mid;
else
r = mid;
}
cout << l;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const int N = 2e5 + 100;
struct Edge {
int v, next;
Edge(int v = -1, int next = -1) : v(v), next(next) {}
} e[N * 2];
int head[N], total;
void init() {
memset(head, -1, sizeof(head));
total = 0;
}
void adde(int u, int v) {
e[total] = Edge(v, head[u]);
head[u] = total++;
}
int c1[N], c2[N][2], c3[N][2], fg[N];
int aa[N];
void dfs(int u, int f, int id) {
c1[u] = c2[u][1] = c2[u][0] = c3[u][0] = c3[u][1] = 0;
fg[u] = 0;
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].v;
if (v == f) continue;
dfs(v, u, id);
fg[u] += fg[v] ? 1 : 0;
if (!fg[v])
c1[u] += c1[v];
else {
if (c2[u][1] < c1[v] + c2[v][1]) {
swap(c2[u][1], c3[u][1]);
swap(c2[u][0], c3[u][0]);
c2[u][0] = v;
c2[u][1] = c1[v] + c2[v][1];
} else if (c3[u][1] < c2[v][1] + c1[v]) {
c3[u][0] = v;
c3[u][1] = c2[v][1] + c1[v];
}
}
}
if (aa[u] < id) {
c1[u] = c3[u][0] = c3[u][1] = c2[u][0] = c2[u][1] = 0;
fg[u]++;
} else {
c1[u]++;
}
}
int ans;
void dfs(int u, int f, int a, int b, int id) {
if (b == 1) {
ans = max(ans, c1[u] + max(c2[u][1], a));
} else {
ans = max(ans, c1[u] + a + c2[u][1]);
}
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].v;
if (v == f) continue;
if (aa[u] < id)
dfs(v, u, 0, 1, id);
else {
int xx = fg[v] ? 0 : c1[v], yy = (c2[u][0] == v) ? c3[u][1] : c2[u][1];
if (b) {
dfs(v, u, c1[u] - xx + max(a, yy), 1, id);
} else if (fg[u] - (fg[v] ? 1 : 0)) {
dfs(v, u, c1[u] - xx + a + yy, 1, id);
} else
dfs(v, u, c1[u] - xx + a, 0, id);
}
}
}
int main() {
int n, k;
while (scanf("%d%d", &n, &k) != EOF) {
int l = inf, r = -1;
for (int i = 1; i <= n; i++) {
scanf("%d", &aa[i]);
l = min(aa[i], l);
r = max(aa[i], r);
}
init();
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
adde(a, b);
adde(b, a);
}
r++;
c1[0] = c2[0][0] = c2[0][1] = c3[0][0] = c3[0][1] = 0;
fg[0] = 0;
while (l + 1 < r) {
int mid = (l + r) / 2;
dfs(1, 0, mid);
ans = 0;
dfs(1, 0, 0, 0, mid);
if (ans >= k)
l = mid;
else
r = mid;
}
printf("%d\n", l);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace mine {
long long qread() {
long long ans = 0, f = 1;
char c = getchar();
while (c < '0' or c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans * f;
}
void write(long long num) {
if (num < 0) putchar('-'), num = -num;
if (num >= 10) write(num / 10);
putchar('0' + num % 10);
}
void write1(long long num) {
write(num);
putchar(' ');
}
void write2(long long num) {
write(num);
putchar('\n');
}
template <typename T>
void chmax(T &x, const T y) {
x = (x > y ? x : y);
}
template <typename T>
void chmin(T &x, const T y) {
x = (x < y ? x : y);
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
int mm(const int x) { return x >= MOD ? x - MOD : x; }
template <typename T>
void add(T &x, const int &y) {
x = (x + y >= MOD ? x + y - MOD : x + y);
}
long long qpower(long long x, long long e, int mod = MOD) {
long long ans = 1;
(e >= 0);
while (e) {
if (e & 1) ans = ans * x % mod;
x = x * x % mod;
e >>= 1;
}
return ans;
}
long long invm(long long x) { return qpower(x, MOD - 2); }
const int N = 2e5 + 10;
vector<int> to[N];
int a[N];
bool vis[N];
int n, K;
vector<int> pt;
int dis[N];
int val[N];
bool search(int x, int fa, int T) {
if (a[x] < T) return 0;
vis[x] = 1;
pt.push_back(x);
val[x] = 1;
bool ret = 1;
for (int t = (0), I = (((int)(to[x]).size()) - 1); t <= I; t++)
if (to[x][t] != fa) ret &= search(to[x][t], x, T);
if (ret and fa) val[fa] += val[x], val[x] = 0;
return ret;
}
void push(int x, int fa, int T) {
if (a[x] < T) return;
dis[x] = dis[fa] + val[x];
for (int t = (0), I = (((int)(to[x]).size()) - 1); t <= I; t++)
if (to[x][t] != fa) push(to[x][t], x, T);
}
bool check(int T) {
memset(vis, 0, sizeof vis);
for (int rt = (1), I = (n); rt <= I; rt++)
if (!vis[rt] and a[rt] >= T) {
pt.clear();
search(rt, 0, T);
push(rt, 0, T);
int a = pt[0];
for (int t = (1), I = (((int)(pt).size()) - 1); t <= I; t++)
if (dis[pt[t]] > dis[a]) a = pt[t];
search(a, 0, T);
push(a, 0, T);
for (int t = (0), I = (((int)(pt).size()) - 1); t <= I; t++)
if (dis[pt[t]] >= K) return 1;
}
return 0;
}
void main() {
n = qread(), K = qread();
for (int i = (1), I = (n); i <= I; i++) a[i] = qread();
for (int i = (1), I = (n - 1); i <= I; i++) {
int x = qread(), y = qread();
to[x].push_back(y);
to[y].push_back(x);
}
int fl = 1, fr = 1e6, ans = -1;
while (fl <= fr) {
int mid = (fl + fr) / 2;
if (check(mid))
ans = mid, fl = mid + 1;
else
fr = mid - 1;
}
write(ans);
}
}; // namespace mine
signed main() {
srand(time(0));
mine::main();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const double PI = acos(-1.);
const int N = 200000 + 5;
int n, a[N], w[N];
int din[N], dot[N], fot[N];
vector<int> G[N];
void dfsd(int u, int f) {
int i, v;
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
dfsd(v, u);
}
if (w[u]) {
din[u] = 1;
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
if (din[v])
din[u] += din[v];
else {
din[u] = 0;
break;
}
}
dot[u] = 1;
int mx = 0;
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
if (din[v])
dot[u] += din[v];
else
mx = max(mx, dot[v]);
}
dot[u] += mx;
} else
din[u] = dot[u] = 0;
}
void Max2(int &a, int &b, int c) {
if (c >= a) {
b = a;
a = c;
} else
b = max(b, c);
}
void dfsf(int u, int f) {
int i, v;
if (w[u]) {
int b[2];
b[0] = fot[u];
b[1] = 0;
int sum = 0;
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
if (din[v])
sum += din[v];
else
Max2(b[0], b[1], dot[v]);
}
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
if (din[v]) {
fot[v] = sum - din[v] + 1 + b[0];
} else {
if (dot[v] == b[0])
fot[v] = sum + 1 + b[1];
else
fot[v] = sum + 1 + b[0];
}
if (!w[v]) fot[v] = 0;
}
} else {
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
fot[v] = 0;
}
}
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
dfsf(v, u);
}
}
int dfsdp(int u, int f) {
int ret = 0;
int i, v;
if (w[u]) {
ret = 1;
int mx = 0;
if (~f) mx = fot[u];
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
if (din[v])
ret += din[v];
else
mx = max(mx, dot[v]);
}
ret += mx;
}
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
int tmp = dfsdp(v, u);
ret = max(ret, tmp);
}
return ret;
}
int cnt(int A) {
int i;
for (i = 1; i <= n; i++) w[i] = a[i] >= A;
int rt = -1;
for (i = 1; i <= n; i++)
if (!w[i]) rt = i;
if (rt == -1) return n;
dfsd(rt, -1);
fot[rt] = 0;
dfsf(rt, -1);
int ans = dfsdp(rt, -1);
return ans;
}
int main() {
if (0)
freopen(
"535F"
".out",
"r", stdin);
if (0)
freopen(
"535F"
"wa.txt",
"w", stdout);
int i, j, _T;
int k;
while (~scanf("%d%d", &n, &k)) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]), G[i].clear();
for (i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v), G[v].push_back(u);
}
vector<int> L;
for (i = 1; i <= n; i++) L.push_back(a[i]);
sort(L.begin(), L.end());
L.erase(unique(L.begin(), L.end()), L.end());
int le = 0, re = L.size() - 1, ge = -1;
while (re >= le) {
if (re - le <= 1) {
if (cnt(L[re]) >= k)
ge = re;
else
ge = le;
break;
}
int mid = (le + re) / 2;
if (cnt(L[mid]) >= k)
le = mid;
else
re = mid;
}
printf("%d\n", L[ge]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
vector<long long> g[200002];
long long a[200002];
bool vis[200002], ok[200002];
long long good[200002];
long long upgood[200002], up[200002];
long long cnt[200002], down[200002], tail[200002];
void dfs1(long long node, long long par) {
vis[node] = true;
cnt[node] = 1;
good[node] = true;
tail[node] = 0;
for (auto it : g[node]) {
if (it == par) continue;
if (!ok[it]) {
good[node] = false;
continue;
}
dfs1(it, node);
if (!good[it]) {
good[node] = false;
tail[node] = max(tail[node], down[it]);
} else
cnt[node] += cnt[it];
}
down[node] = (cnt[node] + tail[node]);
}
bool dfs2(long long node, long long par) {
long long whole = cnt[node];
if (upgood[node])
whole += (up[node] + tail[node]);
else
whole += max(up[node], tail[node]);
if ((whole) >= k) return true;
long long cntbad;
if (upgood[node])
cntbad = 0;
else
cntbad = 1;
long long t1 = 0, t2 = 0;
if (!upgood[node]) t1 = up[node];
for (auto it : g[node]) {
if (it == par) continue;
if (!ok[it]) {
cntbad++;
continue;
}
if (!good[it]) {
cntbad++;
if (down[it] >= t1) {
t2 = t1;
t1 = down[it];
} else if (down[it] > t2)
t2 = down[it];
}
}
long long cntnew = cnt[node];
if (upgood[node]) cntnew += up[node];
for (auto it : g[node]) {
if (it == par) continue;
if (!ok[it]) continue;
long long all = cntnew;
if (!good[it]) {
if (t1 == down[it])
all += t2;
else
all += t1;
} else {
all = (all - cnt[it] + t1);
}
up[it] = all;
if ((cntbad - (!good[it])) == 0)
upgood[it] = true;
else
upgood[it] = false;
if (dfs2(it, node)) return true;
}
return false;
}
bool bs(long long t) {
for (long long i = 1; i <= n; i++) {
if (a[i] >= t)
ok[i] = 1;
else
ok[i] = 0;
vis[i] = false;
}
for (long long i = 1; i <= n; i++)
if (!vis[i] && ok[i]) {
dfs1(i, -1);
upgood[i] = true;
up[i] = 0;
if (dfs2(i, -1)) return true;
}
return false;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i < n; i++) {
long long x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
long long lo = 1, hi = (1e6 + 1);
while ((hi - lo) > 1) {
long long mid = (lo + (hi - lo) / 2);
if (bs(mid))
lo = mid;
else
hi = mid;
}
cout << lo << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long Inf = 1e10;
const int P = 1e9 + 7;
const int N = 200005;
inline int IN() {
int x = 0;
int ch = 0, f = 0;
for (ch = getchar(); ch != -1 && (ch < 48 || ch > 57); ch = getchar())
f = (ch == '-');
for (; ch >= 48 && ch <= 57; ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return f ? (-x) : x;
}
int Pow(int x, int y, int p) {
int a = 1;
for (; y; y >>= 1, x = (long long)x * x % p)
if (y & 1) a = (long long)a * x % p;
return a;
}
int n, m, b[N], a[N], fa[N], val[N], f[N], out[N];
vector<int> e[N];
void dfs(int x) {
int ma = 0;
out[x] = !val[x];
f[x] = 1;
for (int i = (int)(0); i < (int)(e[x].size()); i++) {
int v = e[x][i];
if (v == fa[x]) continue;
fa[v] = x;
dfs(v);
out[x] += out[v];
if (out[v])
ma = max(ma, f[v]);
else
f[x] += f[v];
}
f[x] += ma;
if (!val[x]) f[x] = 0;
}
int res = 0, g[N], son[N];
pair<int, int> pre[N], suf[N];
void calc(int x) {
if (res) return;
if (val[x]) {
int an = 1, ma = 0;
for (int i = (int)(0); i < (int)(e[x].size()); i++) {
int v = e[x][i];
if (v == fa[x]) {
if (out[x] == out[1])
an += g[x];
else
ma = max(ma, g[x]);
continue;
}
if (!out[v])
an += f[v];
else
ma = max(ma, f[v]);
}
an += ma;
res |= (an >= m);
}
*son = 0;
for (int i = (int)(0); i < (int)(e[x].size()); i++)
if (e[x][i] != fa[x]) son[++*son] = e[x][i];
if (!val[x]) {
for (int i = (int)(1); i <= (int)(*son); i++) g[son[i]] = 0;
} else {
if (x == 9) x = 9;
pre[0] = suf[*son + 1] = make_pair(0, 0);
for (int i = (int)(1); i <= (int)(*son); i++) {
pre[i] = pre[i - 1];
if (!out[son[i]])
pre[i].first += f[son[i]];
else
pre[i].second = max(pre[i].second, f[son[i]]);
}
for (int i = (int)(*son); i >= (int)(1); i--) {
suf[i] = suf[i + 1];
if (!out[son[i]])
suf[i].first += f[son[i]];
else
suf[i].second = max(suf[i].second, f[son[i]]);
}
for (int i = (int)(1); i <= (int)(*son); i++) {
int ma = max(pre[i - 1].second, suf[i + 1].second);
if (out[x] == out[1] || g[x] == 0) {
g[son[i]] += g[x] + 1;
} else
ma = max(ma, g[x] + 1);
g[son[i]] += pre[i - 1].first + suf[i + 1].first + ma;
}
}
for (int i = (int)(0); i < (int)(e[x].size()); i++) {
int v = e[x][i];
if (v == fa[x]) continue;
calc(v);
}
}
int check(int x) {
res = 0;
for (int i = (int)(1); i <= (int)(n); i++) fa[i] = f[i] = g[i] = out[i] = 0;
for (int i = (int)(1); i <= (int)(n); i++) val[i] = a[i] >= x;
dfs(1);
calc(1);
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (int)(1); i <= (int)(n); i++) {
scanf("%d", a + i);
b[++*b] = a[i];
}
sort(b + 1, b + *b + 1);
*b = unique(b + 1, b + *b + 1) - (b + 1);
for (int i = (int)(1); i <= (int)(n); i++)
a[i] = lower_bound(b + 1, b + *b + 1, a[i]) - b;
for (int i = (int)(1); i < (int)(n); i++) {
int u = IN(), v = IN();
e[u].push_back(v);
e[v].push_back(u);
}
int u = 0;
for (int i = (int)(1); i <= (int)(*b); i++)
if (b[i] == 13) u = i;
int l = 1, r = *b, aim = 1;
while (l <= r) {
int md = (l + r) >> 1;
if (check(md))
aim = md, l = md + 1;
else
r = md - 1;
}
printf("%d\n", b[aim]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, kk;
int dp[N], sz[N], ans, a[N];
vector<int> v[N];
void dfs(int pos, int fa, int mid) {
sz[pos] = 1;
dp[pos] = 1;
int mx1 = 0, mx2 = 0;
for (auto &i : v[pos])
if (i != fa) {
dfs(i, pos, mid);
sz[pos] += sz[i];
if (dp[i] == sz[i])
dp[pos] += dp[i];
else if (dp[i] > mx1)
mx2 = mx1, mx1 = dp[i];
else if (dp[i] > mx2)
mx2 = dp[i];
}
if (a[pos] < mid) {
dp[pos] = 0;
return;
}
dp[pos] += mx1;
ans = max(ans, dp[pos] + mx2);
}
int rt;
bool check(int mid) {
ans = 0;
dfs(rt, 0, mid);
return ans >= kk;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> kk;
for (int i = 1; i <= n; i++) cin >> a[i];
int t1, t2;
for (int i = 1; i < n; i++) {
cin >> t1 >> t2;
v[t1].push_back(t2);
v[t2].push_back(t1);
}
int l = *min_element(a + 1, a + n + 1), r = *max_element(a + 1, a + n + 1),
ans = -1;
rt = min_element(a + 1, a + n + 1) - a;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
ans = mid, l = mid + 1;
else
r = mid - 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 85 - 69;
vector<int> adj[maxn];
int a[maxn], dp[maxn], pd[maxn], sz[maxn], mx[maxn], mx2[maxn], par[maxn],
sum[maxn], n, k;
bool can[maxn];
void calc(int u = 0, int p = -1) {
par[u] = p;
sz[u] = 1;
for (auto v : adj[u])
if (v != p) calc(v, u), sz[u] += sz[v];
return;
}
int func(int u) { return u == -1 ? 0 : dp[u]; }
void dfs1(int u = 0, int p = -1) {
mx[u] = mx2[u] = -1;
dp[u] = sum[u] = 0;
for (auto v : adj[u])
if (v != p) {
dfs1(v, u);
if (dp[v] == sz[v])
sum[u] += dp[v];
else {
if (func(v) >= func(mx[u]))
mx2[u] = mx[u], mx[u] = v;
else if (func(v) >= func(mx2[u]))
mx2[u] = v;
}
}
if (can[u])
dp[u] = sum[u] + func(mx[u]) + 1;
else
dp[u] = 0;
return;
}
void dfs2(int u = 0, int p = -1) {
if (p != -1) {
pd[u] = sum[p] - (dp[u] == sz[u]) * dp[u];
if (pd[p] == n - sz[p])
pd[u] += pd[p] + (mx[p] == u ? func(mx2[p]) : func(mx[p]));
else
pd[u] += max((mx[p] == u ? func(mx2[p]) : func(mx[p])), pd[p]);
if (!can[p])
pd[u] = 0;
else
pd[u]++;
}
for (auto v : adj[u])
if (v != p) dfs2(v, u);
return;
}
bool check(void) {
dfs1();
dfs2();
for (int u = 0; u < n; u++)
if (can[u]) {
int su = 0, mix = 0;
for (auto v : adj[u]) {
int siz = (v == par[u] ? n - sz[u] : sz[v]);
if (v == par[u]) {
if (pd[u] == siz)
su += pd[u];
else
((mix) = max((mix), (pd[u])));
} else if (dp[v] == siz)
su += dp[v];
else
((mix) = max((mix), (dp[v])));
}
if (su + mix + 1 >= k) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
int fi, se;
cin >> fi >> se;
fi--, se--;
adj[fi].push_back(se);
adj[se].push_back(fi);
}
calc();
int lo = 1, hi = 2000 * 1000 + 1;
while (hi - lo > 1) {
int mid = (lo + hi) >> 1;
for (int i = 0; i < n; i++) can[i] = a[i] >= mid;
if (check())
lo = mid;
else
hi = mid;
}
cout << lo << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200009;
int n, k, m;
int sz[maxn], mx[maxn], mx2[maxn], cnt[maxn], w[maxn], F[maxn];
struct edge {
int t;
edge* n;
} E[maxn << 1], *pt = E, *H[maxn];
inline void AddEdge(int u, int v) {
pt->t = v;
pt->n = H[u];
H[u] = pt++;
}
void dfs(int x, int fa) {
sz[x] = 1;
cnt[x] = mx[x] = mx2[x] = 0;
F[x] = (w[x] >= m);
for (edge* e = H[x]; e; e = e->n)
if (e->t != fa) {
dfs(e->t, x);
sz[x] += sz[e->t];
F[x] += F[e->t];
if (w[e->t] < m) continue;
if (F[e->t] == sz[e->t]) {
cnt[x] += sz[e->t];
} else
mx2[x] = max(mx2[x], cnt[e->t] + mx[e->t] + 1);
if (mx2[x] > mx[x]) swap(mx2[x], mx[x]);
}
}
void DFS(int x, int fa) {
for (edge* e = H[x]; e; e = e->n)
if (e->t != fa) {
if (w[x] >= m) {
if (n - sz[e->t] == F[0] - F[e->t]) {
cnt[e->t] += n - sz[e->t];
} else if (F[e->t] == sz[e->t]) {
mx2[e->t] = max(mx2[e->t], cnt[x] - sz[e->t] + mx[x] + 1);
} else if (mx[x] == cnt[e->t] + mx[e->t] + 1)
mx2[e->t] = max(mx2[e->t], cnt[x] + mx2[x] + 1);
else
mx2[e->t] = max(mx2[e->t], cnt[x] + mx[x] + 1);
if (mx2[x] > mx[x]) swap(mx2[x], mx[x]);
}
DFS(e->t, x);
}
}
bool chk() {
dfs(0, -1);
DFS(0, -1);
for (int i = 0; i < n; i++)
if (w[i] >= m && cnt[i] + mx[i] + 1 >= k) return true;
return false;
}
void Work() {
int l = 1, r = 1000000, ans;
while (l <= r) {
m = (l + r) >> 1;
if (chk())
l = m + 1, ans = m;
else
r = m - 1;
}
printf("%d\n", ans);
}
void Init() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", w + i);
}
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
u--;
v--;
AddEdge(u, v);
AddEdge(v, u);
}
}
int main() {
Init();
Work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 1;
const int A = 1000000;
int cheat[N], sub[N], maxi[N][2], sum[N];
vector<int> adj[N];
bool good[N];
void dfs_pull(int u, int p = 0) {
sub[u] = 1;
sum[u] = maxi[u][0] = maxi[u][1] = 0;
for (auto c : adj[u]) {
if (c != p) {
dfs_pull(c, u);
sub[u] += sub[c];
if (cheat[c] == sub[c]) {
sum[u] += cheat[c];
} else if (cheat[c] > maxi[u][0]) {
maxi[u][1] = maxi[u][0];
maxi[u][0] = cheat[c];
} else if (cheat[c] > maxi[u][1]) {
maxi[u][1] = cheat[c];
}
}
}
cheat[u] = good[u] ? 1 + sum[u] + maxi[u][0] : 0;
}
int dfs_push(int u, int p = 0) {
int res = cheat[u];
for (auto c : adj[u]) {
if (c != p) {
int subu = sub[u];
int sumu = sum[u];
int cheatu = cheat[u];
int maxiu = maxi[u][0];
sub[u] -= sub[c];
if (cheat[c] == sub[c]) {
sum[u] -= cheat[c];
} else if (cheat[c] == maxi[u][0]) {
maxi[u][0] = maxi[u][1];
}
cheat[u] = good[u] ? 1 + sum[u] + maxi[u][0] : 0;
int subc = sub[c];
int sumc = sum[c];
int cheatc = cheat[c];
int maxic = maxi[c][0];
sub[c] += sub[u];
if (cheat[u] == sub[u]) {
sum[c] += cheat[u];
} else if (cheat[u] > maxi[c][0]) {
maxi[c][1] = maxi[c][0];
maxi[c][0] = cheat[u];
} else if (cheat[u] > maxi[c][1]) {
maxi[c][1] = cheat[u];
}
cheat[c] = good[c] ? 1 + sum[c] + maxi[c][0] : 0;
res = max(res, dfs_push(c, u));
sub[c] = subc;
sum[c] = sumc;
cheat[c] = cheatc;
maxi[c][0] = maxic;
sub[u] = subu;
sum[u] = sumu;
cheat[u] = cheatu;
maxi[u][0] = maxiu;
}
}
return res;
}
int a[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
int l = 1, r = A;
while (l < r) {
int m = (l + r + 1) / 2;
for (int i = 1; i <= n; ++i) {
good[i] = (a[i] >= m);
}
dfs_pull(1);
if (dfs_push(1) >= k) {
l = m;
} else {
r = m - 1;
}
}
cout << r << "\n";
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:640000000")
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int maxn = (int)2e5 + 10;
int n;
vector<int> g[maxn];
int a[maxn];
int cnt[maxn];
int dp[maxn];
int up[maxn];
int res;
bool good[maxn];
void dfs(int v, int p) {
dp[v] = 0;
cnt[v] = 1;
int ma = 0;
for (int i = 0; i < (int)(g[v]).size(); i++) {
int to = g[v][i];
if (to == p) continue;
dfs(to, v);
cnt[v] += cnt[to];
if (dp[to] == cnt[to]) {
dp[v] += cnt[to];
} else {
ma = max(ma, dp[to]);
}
}
if (good[v]) {
dp[v] += ma + 1;
} else {
dp[v] = 0;
}
}
void go(int v, int p) {
int cur = 1;
int ma = 0;
pair<int, int> ma1, ma2;
ma1 = ma2 = make_pair(0, -1);
if (p != -1) {
if (up[p] == n - cnt[v]) {
cur += up[p];
} else {
ma1 = make_pair(up[p], p);
ma = max(ma, up[p]);
}
}
for (int i = 0; i < (int)(g[v]).size(); i++) {
int to = g[v][i];
if (to == p) continue;
if (dp[to] == cnt[to]) {
cur += dp[to];
} else {
ma = max(ma, dp[to]);
pair<int, int> e = make_pair(dp[to], to);
if (ma1 < e) {
ma2 = ma1;
ma1 = e;
} else if (ma2 < e) {
ma2 = e;
}
}
}
for (int i = 0; i < (int)(g[v]).size(); i++) {
int to = g[v][i];
if (to == p) continue;
if (good[v]) {
up[v] = cur + (ma1.second == to ? ma2.first : ma1.first);
if (dp[to] == cnt[to]) {
up[v] -= dp[to];
}
} else {
up[v] = 0;
}
go(to, v);
}
if (good[v]) {
cur += ma;
} else {
cur = 0;
}
res = max(res, cur);
}
int solve(int val) {
for (int i = 0; i < n; i++) good[i] = a[i] >= val;
dfs(0, -1);
res = 0;
go(0, -1);
return res;
}
int main() {
int num;
cin >> n >> num;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
int l = 0;
int r = (int)1e6 + 1;
while (l < r - 1) {
int m = (l + r) >> 1;
if (solve(m) >= num) {
l = m;
} else {
r = m;
}
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
struct edge {
int to, next;
edge(int to = 0, int next = 0) : to(to), next(next) {}
} G[maxn << 1];
int head[maxn], tot, pre[maxn], a[maxn], dp[maxn][2], sz[maxn], n, k, m,
que[maxn];
void init() {
memset(head, -1, sizeof(head));
tot = 0;
}
void addedge(int u, int v) {
G[tot] = edge(v, head[u]);
head[u] = tot++;
G[tot] = edge(u, head[v]);
head[v] = tot++;
}
bool dfs(int u, int fa) {
bool ret = a[u] >= m;
dp[u][0] = dp[u][1] = -1;
sz[u] = 0;
pre[u] = fa;
for (int i = head[u]; ~i; i = G[i].next) {
int v = G[i].to;
if (v == fa) continue;
bool tmp = dfs(v, u);
ret &= tmp;
if (a[u] >= m) {
if (tmp)
sz[u] += sz[v] + 1;
else if (dp[u][0] <= dp[v][0] + sz[v] + 1) {
dp[u][1] = dp[u][0];
dp[u][0] = dp[v][0] + sz[v] + 1;
} else if (dp[u][1] < dp[v][0] + sz[v] + 1)
dp[u][1] = dp[v][0] + sz[v] + 1;
}
}
return ret;
}
bool bfs(int s) {
int front = 0, rear = 0;
que[rear++] = s;
while (front < rear) {
int u = que[front++], fa = pre[u];
if (a[u] >= m && max(dp[u][0], 0) + sz[u] + 1 >= k) return true;
for (int i = head[u]; ~i; i = G[i].next) {
int v = G[i].to;
if (v == fa) continue;
que[rear++] = v;
if (a[u] >= m && a[v] >= m) {
if (dp[u][1] == -1 && ~dp[v][0])
sz[v] += sz[u] + 1;
else {
int tmp1 = dp[u][0] == dp[v][0] + sz[v] + 1 ? dp[u][1] : dp[u][0];
int tmp2 = ~dp[v][0] ? sz[u] + 1 : sz[u] - sz[v];
if (dp[v][0] <= tmp1 + tmp2) {
dp[v][1] = dp[v][0];
dp[v][0] = tmp1 + tmp2;
} else if (dp[v][1] < tmp1 + tmp2)
dp[v][1] = tmp1 + tmp2;
}
}
}
}
return false;
}
int main() {
while (~scanf("%d%d", &n, &k)) {
init();
int _max = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
_max = max(_max, a[i]);
}
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
}
int l = 1, r = _max;
while (l < r) {
m = (l + r + 1) >> 1;
dfs(1, 0);
bfs(1) ? l = m : r = m - 1;
}
printf("%d\n", l);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, lim, p = 1, a[N], nex[N * 2], spot[N * 2], head[N], fa[N], f[N], g[N];
int maxcolor[N][2], c[N];
bool color[N], v[N];
void add(int x, int y) {
nex[++p] = head[x], head[x] = p, spot[p] = y;
nex[++p] = head[y], head[y] = p, spot[p] = x;
}
void dfs0(int x) {
int tp, y;
v[x] = 1;
for (tp = head[x]; y = spot[tp], tp; tp = nex[tp])
if (a[y] >= lim && fa[x] != y) {
fa[y] = x;
dfs0(y);
if (c[y]) c[x]++;
}
c[x] += color[x];
}
void dfs1(int x) {
int tp, y, cnt = 0, m1 = 0, m2 = 0;
for (tp = head[x]; y = spot[tp], tp; tp = nex[tp])
if (a[y] >= lim && y != fa[x]) {
dfs1(y);
if (!c[y])
cnt += f[y];
else {
if (f[y] > m2) m2 = f[y];
if (m1 < m2) swap(m1, m2);
}
}
maxcolor[x][0] = m1;
maxcolor[x][1] = m2;
f[x] = cnt + m1 + 1;
}
void dfs2(int x, int &ret) {
if (fa[x]) {
if (c[fa[x]] - (c[x] != 0) > 0) {
if (c[x]) {
if (f[x] < maxcolor[fa[x]][0]) {
g[x] = f[x] - maxcolor[x][0] + max(maxcolor[x][0], g[fa[x]]);
if (g[fa[x]] > maxcolor[x][1]) maxcolor[x][1] = g[fa[x]];
if (maxcolor[x][0] < maxcolor[x][1])
swap(maxcolor[x][0], maxcolor[x][1]);
} else {
g[x] = f[x] - maxcolor[x][0] +
max(maxcolor[x][0],
g[fa[x]] - maxcolor[fa[x]][0] + maxcolor[fa[x]][1]);
if (g[fa[x]] - maxcolor[fa[x]][0] + maxcolor[fa[x]][1] >
maxcolor[x][1])
maxcolor[x][1] = g[fa[x]] - maxcolor[fa[x]][0] + maxcolor[fa[x]][1];
if (maxcolor[x][0] < maxcolor[x][1])
swap(maxcolor[x][0], maxcolor[x][1]);
}
} else
g[x] = f[x] - maxcolor[x][0] + max(maxcolor[x][0], g[fa[x]] - f[x]);
} else {
if (c[x]) {
if (f[x] < maxcolor[fa[x]][0])
g[x] = f[x] + g[fa[x]];
else
g[x] = f[x] + g[fa[x]] - maxcolor[fa[x]][0] + maxcolor[fa[x]][1];
} else
g[x] = g[fa[x]];
}
c[x] += ((c[fa[x]] - (c[x] != 0)) != 0);
} else
g[x] = f[x];
ret = max(ret, g[x]);
for (int tp = head[x]; tp; tp = nex[tp])
if (a[spot[tp]] >= lim && spot[tp] != fa[x]) dfs2(spot[tp], ret);
}
int solve() {
memset(v, 0, sizeof(v));
memset(fa, 0, sizeof(fa));
memset(maxcolor, 0, sizeof(maxcolor));
memset(c, 0, sizeof(c));
int maxn = 0;
for (int i = 1; i <= n; i++)
if (a[i] >= lim && v[i] == 0) {
dfs0(i), dfs1(i), dfs2(i, maxn);
}
return maxn >= m;
}
int main() {
int i, x, y, l, r, tp;
cin >> n >> m;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add(x, y);
}
for (l = 1, r = 1000000; l < r;) {
lim = l + r + 1 >> 1;
memset(color, 0, sizeof(color));
for (i = 1; i <= n; i++)
if (a[i] < lim)
for (tp = head[i]; tp; tp = nex[tp]) color[spot[tp]] = 1;
if (solve())
l = lim;
else
r = lim - 1;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 201000;
int a[MAX];
int n, k;
int eu[MAX], ev[MAX];
bool cant[MAX];
int deg[MAX];
int val[MAX];
int down[MAX][2];
bool vis[MAX];
set<int> e[MAX];
void cut(int x) {
set<pair<int, int> > s;
for (int i = 0; i < n; ++i)
if (a[i] >= x && e[i].size()) s.insert(pair<int, int>(deg[i], i));
while (s.size() && s.begin()->first == 1) {
int u = s.begin()->second;
deg[u]--;
s.erase(s.begin());
if (cant[u]) continue;
int v = *e[u].begin();
e[u].clear();
e[v].erase(u);
s.erase(pair<int, int>(deg[v], v));
--deg[v];
s.insert(pair<int, int>(deg[v], v));
val[v] += val[u];
}
}
int DFS(int u) {
vis[u] = true;
int res = 0;
for (auto it : e[u]) {
int v = it;
if (vis[v]) continue;
res = max(res, DFS(v));
down[u][0] = max(down[u][0], down[v][1]);
if (down[u][0] > down[u][1]) swap(down[u][0], down[u][1]);
}
down[u][0] += val[u];
down[u][1] += val[u];
return max(res, down[u][0] + down[u][1] - val[u]);
}
bool f(int x) {
for (int i = 0; i < n; ++i) {
deg[i] = 0;
if (a[i] >= x)
val[i] = 1;
else
val[i] = 0;
vis[i] = cant[i] = false;
down[i][0] = down[i][1] = 0;
e[i].clear();
}
for (int i = 0; i < n - 1; ++i) {
int u = eu[i];
int v = ev[i];
if (a[u] >= x && a[v] >= x) {
e[u].insert(v);
e[v].insert(u);
} else {
cant[u] = true;
cant[v] = true;
}
++deg[u];
++deg[v];
}
cut(x);
for (int i = 0; i < n; ++i) {
if (!vis[i] && a[i] >= x) {
if (DFS(i) >= k) return true;
}
}
return false;
}
int main() {
srand(time(NULL));
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
for (int i = 0; i < n - 1; ++i) scanf("%d %d", &eu[i], &ev[i]);
for (int i = 0; i < n - 1; ++i) --eu[i], --ev[i];
int lo = 1;
int hi = 1000000;
int mid = 0;
while (lo < hi) {
mid = (lo + hi + 1) / 2;
if (f(mid))
lo = mid;
else
hi = mid - 1;
}
printf("%d\n", lo);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
ostream& operator<<(ostream& o, const pair<S, T>& p) {
return o << "(" << p.first << "," << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& vc) {
o << "{";
for (const T& v : vc) o << v << ",";
o << "}";
return o;
}
using ll = long long;
template <class T>
using V = vector<T>;
template <class T>
using VV = vector<vector<T>>;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
namespace Normalize {
template <class E>
void dfs(vector<vector<E>>& G, vector<int>& ord, int v, int p = -1) {
ord.push_back(v);
int K = G[v].size();
for (int i = 0; i < (int)(K); i++) {
if (G[v][i].to == p) {
rotate(G[v].begin() + i, G[v].begin() + i + 1, G[v].end());
K--;
break;
}
}
for (int i = 0; i < (int)(K); i++) {
dfs(G, ord, G[v][i].to, v);
}
}
template <class E>
vector<int> normalize_and_gettopord(vector<vector<E>>& G, int r = 0) {
vector<int> ord;
dfs(G, ord, r);
return ord;
}
} // namespace Normalize
template <class N>
struct BidirectionalTreeDP {
vector<N> dp;
vector<N> up;
vector<N> rp;
vector<int> par;
template <class E>
BidirectionalTreeDP(vector<vector<E>>& G, int r = 0) {
int V = G.size();
dp.assign(V, N());
up.assign(V, N());
rp.assign(V, N());
par.assign(V, 0);
vector<int> ord = Normalize::normalize_and_gettopord<E>(G, r);
for (int t = 0; t < (int)(V); t++) {
int v = ord[t];
if (v == r)
par[v] = -1;
else
par[v] = G[v].back().to;
}
for (int t = V - 1; t >= 0; t--) {
int v = ord[t];
dp[v] = N();
int K = G[v].size() - (v != r);
for (int i = 0; i < (int)(K); i++) {
const E& e = G[v][i];
int u = e.to;
dp[v] = dp[v] + dp[u].append_edge(v, e);
}
dp[v].finalize(v);
}
for (int t = 0; t < (int)(V); t++) {
int v = ord[t];
int K = G[v].size() - (v != r);
vector<N> ls(K + 1), rs(K + 1);
for (int i = 0; i < (int)(K); i++) {
ls[i + 1] = ls[i] + dp[G[v][i].to].append_edge(v, G[v][i]);
rs[K - 1 - i] =
dp[G[v][K - 1 - i].to].append_edge(v, G[v][K - 1 - i]) + rs[K - i];
}
for (int i = 0; i < (int)(K); i++) {
const E& e = G[v][i];
int u = e.to;
up[u] = ls[i] + rs[i + 1];
if (v != r) up[u] = up[u] + up[v].append_edge(v, G[v].back());
up[u].finalize(v);
}
rp[v] = ls[K];
if (v != r) rp[v] = rp[v] + up[v].append_edge(v, G[v].back());
rp[v].finalize(v);
}
}
N get(int v, int p = -1) {
if (p == -1) return rp[v];
if (par[v] == p) return dp[v];
return up[p];
}
};
V<bool> ok;
struct Node {
int sz, sm, mx;
Node() { sz = sm = mx = 0; }
template <class E>
Node append_edge(int p, const E& e) const {
return *this;
}
Node operator+(const Node& r) const {
Node n;
n.sz = sz + r.sz;
n.sm = sm + r.sm;
n.mx = max(mx, r.mx);
return n;
}
void finalize(int r) {
sz++;
if (ok[r]) {
if (sm + 1 == sz) {
sm++;
mx = 0;
} else {
mx = sm + 1 + mx;
sm = 0;
}
} else
sm = mx = 0;
}
};
struct Edge {
int to;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, K;
cin >> N >> K;
V<int> a(N);
for (int i = 0; i < (int)(N); i++) cin >> a[i];
VV<Edge> G(N);
for (int i = 0; i < (int)(N - 1); i++) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].push_back({y});
G[y].push_back({x});
}
int lb = 0, ub = 1000001;
ok.resize(N);
while (ub - lb > 1) {
int m = (lb + ub) / 2;
for (int i = 0; i < (int)(N); i++) ok[i] = (a[i] >= m);
BidirectionalTreeDP<Node> dp(G);
int mx = 0;
for (int v = 0; v < (int)(N); v++) {
auto d = dp.get(v);
mx = max(mx, d.sm + d.mx);
}
true;
if (mx >= K)
lb = m;
else
ub = m;
}
cout << lb << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Tedge {
int v, pre;
} edge[200010 * 2];
int n, k, en, cur[200010], val[200010], fa[200010], tot, h[200010], typ[200010],
siz[200010], dis[200010], vst[200010];
int getint() {
int x, f = 1;
char ch;
while (!isdigit(ch = getchar())) f = ch == '-' ? -1 : 1;
x = ch - '0';
while (isdigit(ch = getchar())) x = x * 10 + ch - '0';
return f * x;
}
void addedge(int u, int v) {
edge[++en] = (Tedge){v, cur[u]}, cur[u] = en;
edge[++en] = (Tedge){u, cur[v]}, cur[v] = en;
}
bool dfs1(int p, int f, int now) {
if (val[p] < now) return false;
h[++tot] = p, siz[p] = 1, vst[p] = 1;
bool blk = true;
int ch = 0, wn = 0;
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (v != f) {
ch++;
bool res = dfs1(v, p, now);
blk &= res;
if (res)
siz[p] += siz[v];
else
wn++;
}
if (blk)
typ[p] = 2;
else if (!f && wn == 1) {
typ[p] = 2;
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (typ[v] == 2) siz[p] += siz[v];
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (typ[v] == 1) siz[v] += siz[p];
}
return blk;
}
void dfs2(int p) {
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (typ[v] == 1) {
p = v;
break;
}
while (1) {
int wn = 0;
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (typ[v] == 1) wn++;
if (wn != 1) break;
typ[p] = 2;
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (typ[v] == 1) {
siz[v] += siz[p], p = v;
break;
}
}
}
void dfs3(int p, int f, int d) {
if (typ[p] != 1) return;
dis[p] = (d += siz[p]);
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (v != f) dfs3(v, p, d);
}
int find(int p) {
dfs3(p, 0, 0);
int ans = p;
for (int i = 1; i <= tot; i++)
if (typ[h[i]] == 1 && dis[h[i]] > dis[ans]) ans = h[i];
return ans;
}
bool check(int now) {
memset(vst, 0, sizeof(vst));
for (int i = 1; i <= n; i++) typ[i] = val[i] >= now;
for (int i = 1; i <= n; i++)
if (typ[i] && !vst[i]) {
tot = 0;
dfs1(i, 0, now);
if (typ[i] == 2) dfs2(i);
if (tot < k) continue;
int wt = -1;
for (int i = 1; i <= tot; i++)
if (typ[h[i]] == 1) {
wt = h[i];
break;
}
if (wt == -1) return true;
int x = find(wt);
x = find(x);
if (dis[x] >= k) return true;
}
return false;
}
int main() {
(n = getint()), (k = getint());
for (int i = 1; i <= n; i++) (val[i] = getint());
for (int i = 1; i <= n - 1; i++) addedge(getint(), getint());
int l = 0, r = 1000000, ans;
while (l <= r)
if (check(((l + r) >> 1)))
ans = ((l + r) >> 1), l = ((l + r) >> 1) + 1;
else
r = ((l + r) >> 1) - 1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, crit;
vector<int> dfn;
vector<int> gph[200005];
int par[200005], s1[200005], s2[200005];
int a[200005];
void dfs(int x, int p) {
par[x] = p;
s1[x] = (a[x] >= crit);
s2[x] = 1;
dfn.push_back(x);
for (auto &i : gph[x]) {
if (i == p) continue;
dfs(i, x);
s1[x] += s1[i];
s2[x] += s2[i];
}
}
int dp[200005], mdp[200005];
int pdp[200005], pmdp[200005];
multiset<int> st[200005];
int trial(int x) {
crit = x;
dfn.clear();
dfs(1, 0);
memset(dp, 0, sizeof(dp));
memset(mdp, 0, sizeof(mdp));
memset(pdp, 0, sizeof(pdp));
memset(pmdp, 0, sizeof(pmdp));
for (int i = 1; i <= n; i++) st[i].clear();
for (int i = dfn.size() - 1; i >= 0; i--) {
int p = dfn[i];
if (a[p] < crit) continue;
dp[p] = 1;
mdp[p] = 0;
for (auto &j : gph[p]) {
if (j == par[p]) continue;
if (s1[j] == s2[j]) {
dp[p] += s2[j];
} else {
st[p].insert(dp[j]);
mdp[p] = max(mdp[p], dp[j]);
}
}
dp[p] += mdp[p];
}
int ret = 0;
if (a[1] >= crit) ret = dp[1];
for (int i = 1; i < dfn.size(); i++) {
int p = dfn[i];
if (a[par[p]] < crit) continue;
pdp[p] = 1;
pmdp[p] = 0;
if (par[par[p]]) {
if (s1[1] - s1[par[p]] == s2[1] - s2[par[p]]) {
pdp[p] += pdp[par[p]];
} else {
pmdp[p] = max(pmdp[p], pdp[par[p]]);
}
}
if (s1[p] == s2[p]) {
pdp[p] += dp[par[p]] - 1 - mdp[par[p]] - s2[p];
pmdp[p] = max(pmdp[p], mdp[par[p]]);
} else {
pdp[p] += dp[par[p]] - 1 - mdp[par[p]];
if (*--st[par[p]].end() == dp[p]) {
auto u = --st[par[p]].end();
if (u != st[par[p]].begin()) {
u--;
pmdp[p] = max(pmdp[p], *u);
}
} else {
pmdp[p] = max(pmdp[p], *--st[par[p]].end());
}
}
pdp[p] += pmdp[p];
}
for (int i = 2; i <= n; i++) {
if (a[i] < crit) continue;
int p = i;
int t1 = dp[p] - mdp[p];
int t2 = mdp[p];
if (s1[1] - s1[i] == s2[1] - s2[i]) {
t1 += pdp[p];
} else {
t2 = max(t2, pdp[p]);
}
ret = max(ret, t1 + t2);
}
return ret;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n - 1; i++) {
int s, e;
scanf("%d %d", &s, &e);
gph[s].push_back(e);
gph[e].push_back(s);
}
int s = 0, e = 1e6;
while (s != e) {
int m = (s + e + 1) / 2;
if (trial(m) >= k)
s = m;
else
e = m - 1;
}
cout << s;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
vector<int> g[N];
int a[N];
int cnt[N];
int n, k;
int val;
int f[N];
int without[N];
void mmax(int &a, int b) { a = max(a, b); }
void mmin(int &a, int b) { a = min(a, b); }
void dfs1(int v, int par = -1) {
cnt[v] = 1;
for (int to : g[v]) {
if (to == par) continue;
dfs1(to, v);
cnt[v] += cnt[to];
}
if (a[v] < val) return;
int mx = -1;
for (int to : g[v]) {
if (to == par) continue;
if (f[to] == -1)
without[v] += cnt[to];
else
mmax(mx, f[to]);
}
if (mx == -1)
f[v] = -1;
else
f[v] = 1 + without[v] + mx;
}
int ans;
void dfs2(int v, int f_up, int par = -1) {
if (a[v] < val) {
for (int to : g[v]) {
if (to == par) continue;
dfs2(to, 0, v);
}
return;
}
if (f_up == -1 && f[v] == -1) {
ans = n;
return;
}
int w = without[v];
if (f_up == -1) w += n - cnt[v];
map<int, int> mp;
mp[f_up]++;
for (int to : g[v]) {
if (to == par) continue;
mp[f[to]]++;
}
mp[-1] += 2;
for (int to : g[v]) {
if (to == par) continue;
if (f[to] == -1)
w -= cnt[to];
else {
mp[f[to]]--;
if (!mp[f[to]]) mp.erase(f[to]);
}
int mx = (*mp.rbegin()).first;
if (mx == -1)
dfs2(to, -1, v);
else
dfs2(to, 1 + mx + w, v);
if (f[to] == -1)
w += cnt[to];
else
mp[f[to]]++;
}
mmax(ans, 1 + (*mp.rbegin()).first + w);
}
void clear_dp() {
ans = 0;
fill(cnt, cnt + N, 0);
fill(f, f + N, 0);
fill(without, without + N, 0);
}
bool able(int l) {
clear_dp();
val = l;
dfs1(1);
dfs2(1, -1);
return ans >= k;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int l = 0, r = 2e6;
while (l < r) {
int mid = l + r >> 1;
if (able(mid))
l = mid;
else
r = mid - 1;
if (l == r - 1) {
if (able(r))
l = r;
else
r = l;
}
}
cout << r;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N];
int f[N];
int val;
int nCh[N];
vector<int> g[N];
void dfs(int u, int p) {
nCh[u] = f[u] = 1;
int nxt = 0;
for (int v : g[u])
if (v != p) {
dfs(v, u);
nCh[u] += nCh[v];
if (f[v] == nCh[v])
f[u] += nCh[v];
else
nxt = max(nxt, f[v]);
}
f[u] += nxt;
if (a[u] < val) f[u] = 0;
}
int ans;
void cal(int u, int p, int lz) {
int mx1 = lz;
int mx2 = 0;
if (lz == nCh[0] - nCh[u]) {
mx1 = 0;
f[u] += lz;
lz = 0;
}
for (int v : g[u])
if (v != p) {
if (f[v] == nCh[v]) continue;
if (mx2 < f[v]) mx2 = f[v];
if (mx1 < mx2) swap(mx1, mx2);
}
if (mx1 == lz) f[u] += lz - mx2;
if (ans < f[u]) ans = f[u];
if (a[u] < val) {
for (int v : g[u])
if (v != p) cal(v, u, 0);
} else {
for (int v : g[u])
if (v != p) {
if (f[v] == nCh[v])
cal(v, u, f[u] - f[v]);
else {
if (f[v] == mx1)
cal(v, u, f[u] - mx1 + mx2);
else
cal(v, u, f[u]);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int k;
cin >> k;
vector<pair<int, int> > E;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int x;
cin >> x;
int y;
cin >> y;
g[x - 1].emplace_back(y - 1);
g[y - 1].emplace_back(x - 1);
}
int L = 0;
int R = *max_element(a, a + n);
while (L < R) {
val = (L + R + 2) / 2;
ans = 0;
dfs(0, 0);
cal(0, 0, 0);
if (ans >= k)
L = val;
else
R = val - 1;
}
cout << L << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100, inF = 1e6 + 10;
int n, k, u, v, c, maxi, a[N], sz[N];
bool ok;
vector<int> nei[N];
int get_sz(int v, int par = -1) {
for (int u : nei[v])
if (u != par) sz[v] += get_sz(u, v);
return ++sz[v];
}
int dfs(int v, int par = -1) {
int dp = (a[v] < c ? -inF : 1);
int mx1 = 0, mx2 = 0;
for (int u : nei[v])
if (u != par) {
int DP = dfs(u, v);
if (DP == sz[u])
dp += DP;
else {
mx2 = max(mx2, DP);
if (mx2 > mx1) swap(mx1, mx2);
}
}
ok |= (dp + mx1 + mx2) >= k;
if (a[v] < c) return 0;
return dp + mx1;
}
bool check() {
ok = false;
dfs(min_element(a, a + n) - a);
return ok;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
nei[--u].push_back(--v);
nei[v].push_back(u);
}
get_sz(min_element(a, a + n) - a);
int l = 0, r = inF;
while (r - l > 1) {
c = (l + r) >> 1;
if (check())
l = c;
else
r = c;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400005;
int n, K, i, j, k, l, head[N], adj[N], nxt[N], a[N], sz[N], size[N], Head[N],
Adj[N], Nxt[N], lt, rt, mid, w, num[N], p[N], mx1[N], mx2[N];
bool v[N];
int find(int x) { return !p[x] ? x : p[x] = find(p[x]); }
void addedge(int u, int v) {
Adj[++l] = v;
Nxt[l] = Head[u];
Head[u] = l;
Adj[++l] = u;
Nxt[l] = Head[v];
Head[v] = l;
}
void dfs(int x, int dad) {
size[x] = 1;
for (int y = head[x]; y; y = nxt[y])
if (adj[y] != dad) {
dfs(adj[y], x);
size[x] += size[adj[y]];
}
}
void Dfs(int x, int dad) {
sz[x] = (a[x] >= mid);
for (int y = head[x]; y; y = nxt[y])
if (adj[y] != dad) {
Dfs(adj[y], x);
sz[x] += sz[adj[y]];
if (sz[adj[y]] == size[adj[y]] && a[x] >= mid) p[find(adj[y])] = find(x);
}
}
void dzx(int x, int dad) {
for (int y = head[x]; y; y = nxt[y])
if (adj[y] != dad) {
if (a[adj[y]] >= mid && n - size[adj[y]] == sz[1] - sz[adj[y]] &&
find(x) != find(adj[y]))
p[find(x)] = find(adj[y]);
dzx(adj[y], x);
}
}
void work(int x, int dad) {
v[x] = true;
mx1[x] = mx2[x] = 0;
for (int y = Head[x]; y; y = Nxt[y])
if (a[Adj[y]] >= mid && Adj[y] != dad) {
work(Adj[y], x);
if (mx1[Adj[y]] > mx1[x]) {
mx2[x] = mx1[x];
mx1[x] = mx1[Adj[y]];
} else if (mx1[Adj[y]] > mx2[x])
mx2[x] = mx1[Adj[y]];
}
w = max(w, mx1[x] + mx2[x] + num[x]);
mx1[x] += num[x], mx2[x] += num[x];
}
int main() {
scanf("%d%d", &n, &K);
for (i = 1; i <= n; ++i) scanf("%d", a + i);
for (i = 1; i < n; ++i) {
scanf("%d%d", &j, &k);
adj[i * 2 - 1] = k;
nxt[i * 2 - 1] = head[j];
head[j] = i * 2 - 1;
adj[i * 2] = j;
nxt[i * 2] = head[k];
head[k] = i * 2;
}
dfs(1, -1);
lt = 1, rt = 1000000;
while (lt < rt) {
mid = (lt + rt + 1) / 2;
for (i = 1; i <= n; ++i) Head[i] = p[i] = num[i] = 0, v[i] = false;
Dfs(1, -1);
dzx(1, -1);
for (i = 1; i <= n; ++i) num[find(i)]++;
l = 0;
for (i = 1; i < n; ++i)
if (find(adj[i * 2 - 1]) != find(adj[i * 2]))
addedge(find(adj[i * 2 - 1]), find(adj[i * 2]));
w = 0;
for (i = 1; i <= n; ++i)
if (find(i) == i && a[i] >= mid && !v[i]) work(i, -1);
if (w >= K)
lt = mid;
else
rt = mid - 1;
}
printf("%d", lt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> adj[N];
int n, k, a[N], guess, mx, root;
pair<int, int> dfs(int u, int p) {
pair<int, int> ret;
ret.first = ret.second = 1;
int mx1 = 0, mx2 = 0;
for (int v : adj[u])
if (v - p) {
pair<int, int> x = dfs(v, u);
ret.first += x.first;
if (x.first == x.second) {
ret.second += x.second;
} else {
if (x.second > mx2) mx2 = x.second;
if (mx2 > mx1) swap(mx1, mx2);
}
}
if (a[u] < guess) {
ret.second = 0;
} else {
ret.second += mx1;
mx = max(mx, ret.second + mx2);
}
return ret;
}
bool check() {
mx = 0;
dfs(root, 0);
return mx >= k;
}
int main() {
scanf("%d %d", &n, &k);
a[0] = 1e9;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (a[root] > a[i]) root = i;
}
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int lo = 0, hi = 1e6, ans;
while (lo <= hi) {
guess = lo + hi >> 1;
if (check()) {
lo = guess + 1;
ans = guess;
} else {
hi = guess - 1;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
vector<int> g[200200], gg[200200];
int a[200200];
int cnt[200200];
int dp[200200];
int used[200200];
int nused[200200];
int k;
int n;
queue<int> q;
vector<int> ord;
int dis1[200200], dis2[200200];
int curd;
void dfs(int v, int p) {
nused[v] = 1;
int &mx1 = dis1[v];
int &mx2 = dis2[v];
mx1 = 0;
mx2 = 0;
for (int i = 0; i < gg[v].size(); i++) {
int to = gg[v][i];
if (to == p) continue;
dfs(to, v);
if (dis1[to] + dp[to] > mx1) {
mx2 = mx1;
mx1 = dis1[to] + dp[to];
} else if (dis1[to] + dp[to] > mx2) {
mx2 = dis1[to] + dp[to];
}
}
}
void dfs2(int v, int p, int cc) {
int &mx1 = dis1[v];
int &mx2 = dis2[v];
curd = max(curd, mx1 + cc + dp[v]);
for (int i = 0; i < gg[v].size(); i++) {
int to = gg[v][i];
if (to == p) continue;
if (dis1[to] + dp[to] == mx1) {
dfs2(to, v, max(cc, mx2) + dp[v]);
} else {
dfs2(to, v, max(cc, mx1) + dp[v]);
}
}
}
int calc(int v) {
ord.clear();
curd = 0;
dfs(v, -1);
dfs2(v, -1, 0);
return curd;
}
int check(int x) {
for (int i = 0; i < n; i++) {
cnt[i] = 0;
dp[i] = 1;
used[i] = 0;
nused[i] = 0;
}
while (q.size() > 0) q.pop();
for (int i = 0; i < n; i++) {
gg[i].clear();
if (a[i] >= x) {
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (a[to] >= x) gg[i].push_back(to);
}
if (g[i].size() == 1) {
q.push(i);
used[i] = 1;
}
} else
nused[i] = 1;
}
int mx = 0;
while (q.size() > 0) {
int v = q.front();
q.pop();
int ind = -1;
for (int i = 0; i < gg[v].size(); i++) {
int to = gg[v][i];
if (nused[to]) continue;
ind = to;
}
if (ind == -1) {
mx = max(mx, dp[v]);
} else {
dp[ind] += dp[v];
cnt[ind]++;
if (cnt[ind] + 1 == g[ind].size()) {
q.push(ind);
}
}
nused[v] = 1;
}
for (int i = 0; i < n; i++) {
gg[i].clear();
if (nused[i]) continue;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (nused[to]) continue;
gg[i].push_back(to);
}
}
for (int i = 0; i < n; i++) {
if (nused[i]) continue;
mx = max(mx, calc(i));
}
return mx;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1, x, y; i < n; i++) {
scanf("%d %d", &x, &y);
g[x - 1].push_back(y - 1);
g[y - 1].push_back(x - 1);
}
int l = 0, r = 1000100, ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid) >= k) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <class T1, class T2>
inline void remin(T1& a, T2 b) {
a = min(a, (T1)b);
}
const int maxN = 1 << 18, maxTS = maxN * 2, INF = 1 << 30;
vector<int> G[maxN];
int A[maxN], pat[maxN], whole[maxN], ile[maxN], sz[maxN], res, bord;
void dfs0(int v, int fat) {
sz[v] = 1;
ile[v] = A[v] >= bord;
for (int u : G[v])
if (u != fat) {
dfs0(u, v);
sz[v] += sz[u];
ile[v] += ile[u];
}
}
void dfs(int v, int fat) {
int t[2] = {0, 0};
whole[v] = pat[v] = 1;
for (int u : G[v])
if (u != fat) {
dfs(u, v);
if (whole[u] != 0) {
if (whole[v] != 0) whole[v] += whole[u];
pat[v] += whole[u];
continue;
}
whole[v] = 0;
if (pat[u] >= t[0])
t[1] = t[0], t[0] = pat[u];
else if (pat[u] > t[1])
t[1] = pat[u];
}
if (A[v] >= bord) {
pat[v] += t[0];
int prop = pat[v] + t[1];
if (sz[1] - sz[v] == ile[1] - ile[v]) prop += sz[1] - sz[v];
res = max(res, prop);
} else
pat[v] = whole[v] = 0;
}
void solve() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = (1); i < (n + 1); i++) scanf("%d", A + i);
for (int i = (1); i < (n); i++) {
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
int a = 1, b = INF;
while (b - a > 1) {
bord = (a + b) / 2;
res = 0;
dfs0(1, 0);
dfs(1, 0);
res >= k ? a = bord : b = bord;
}
printf("%d\n", a);
}
int main() {
int t = 1;
for (int tid = (1); tid < (t + 1); tid++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200200;
int n, k;
int a[maxn];
vector<int> g[maxn];
int sz[maxn];
int dpd[maxn], dpu[maxn];
int mxd[maxn], mxu[maxn];
int mark[maxn], cnt[maxn];
int mxc[maxn], N;
int ans;
void dfs(int v, int par = -1) {
sz[v] = 1;
cnt[v] = mark[v];
int c = 0;
for (int u : g[v])
if (u != par) {
dfs(u, v);
cnt[v] += cnt[u];
sz[v] += sz[u];
if (!cnt[u]) {
dpd[v] += dpd[u];
mxd[v] += dpd[u];
} else
c = max(c, mxd[u]);
}
if (mark[v])
dpd[v] = 0, mxd[v] = 0;
else
dpd[v]++, mxd[v] += c + 1;
}
void gfs(int v, int par = -1) {
if (cnt[v] == N) dpu[v] = n - sz[v];
if (!mark[v]) {
mxu[v] += mxc[v];
int d, c;
if (cnt[v] == N)
d = dpu[v] + 1, c = 0;
else
d = 1, c = mxu[v];
for (int u : g[v])
if (u != par) {
mxu[u] += d;
mxc[u] = max(mxc[u], c);
if (!cnt[u])
d += dpd[u];
else
c = max(c, mxd[u]);
}
reverse(g[v].begin(), g[v].end());
d = 0, c = 0;
for (int u : g[v])
if (u != par) {
mxu[u] += d;
mxc[u] = max(mxc[u], c);
if (!cnt[u])
d += dpd[u];
else
c = max(c, mxd[u]);
}
} else
dpu[v] = mxu[v] = 0;
for (int u : g[v])
if (u != par) gfs(u, v);
}
bool check(int x) {
N = 0;
memset(sz, 0, sizeof sz);
memset(dpd, 0, sizeof dpd);
memset(dpu, 0, sizeof dpu);
memset(mxc, 0, sizeof mxc);
memset(mxd, 0, sizeof mxd);
memset(mxu, 0, sizeof mxu);
for (int i = 0; i < n; i++) mark[i] = (a[i] < x);
for (int i = 0; i < n; i++) N += mark[i];
dfs(0);
gfs(0);
for (int i = 0; i < n; i++)
if (!mark[i])
if (mxd[i] + dpu[i] >= k or mxu[i] + dpd[i] >= k) return true;
return false;
}
void solve() {
int l = 1, r = 1000001;
int mid;
while (l != r - 1) {
mid = (l + r) >> 1;
if (check(mid))
l = mid;
else
r = mid;
}
ans = l;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int v, u, i = 0; i < n - 1; i++) {
cin >> v >> u;
v--, u--;
g[v].push_back(u);
g[u].push_back(v);
}
solve();
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200200;
int arr[MAX], head[MAX], to[MAX * 2], nxt[MAX * 2], Ecnt, n, k, down[MAX][4];
bool flag[MAX];
int tot, sz[MAX], cnt[MAX];
void addEdge(int u, int v) {
nxt[Ecnt] = head[u];
head[u] = Ecnt;
to[Ecnt++] = v;
}
void merge(int a[], int b[], bool &fa, bool fb) {
if (fb) {
fa = 1;
a[1] = b[0] + b[3];
sort(a + 1, a + 4);
} else
a[0] += b[0];
}
bool dfs(int cur, int par, int lim) {
memset(down[cur], 0, sizeof down[cur]);
cnt[cur] = flag[cur] = (arr[cur] < lim);
down[cur][0] = !flag[cur];
sz[cur] = 1;
for (int i = head[cur]; ~i; i = nxt[i])
if (to[i] != par) {
if (dfs(to[i], cur, lim)) return true;
if (arr[to[i]] >= lim && arr[cur] >= lim)
merge(down[cur], down[to[i]], flag[cur], flag[to[i]]);
else
flag[cur] = 1;
cnt[cur] += cnt[to[i]];
sz[cur] += sz[to[i]];
}
return (down[cur][0] + down[cur][2] + down[cur][3] +
(cnt[cur] == tot) * (n - sz[cur]) >=
k);
}
bool check(int lim) {
tot = 0;
for (int i = 1; i <= n; i++) tot += (arr[i] < lim);
return dfs(1, 0, lim);
}
int main() {
scanf("%d%d", &n, &k);
memset(head, -1, (n + 1) * sizeof head[0]);
for (int i = 1; i <= n; i++) scanf("%d", arr + i);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
addEdge(u, v);
addEdge(v, u);
}
int low = 1, high = 1000000;
while (low <= high) {
int mid = (low + high) >> 1;
if (check(mid))
low = mid + 1;
else
high = mid - 1;
}
printf("%d\n", low - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 5, MXX = 23;
const long long mod = 1e9 + 7, inf = 1e18 + 6;
int n, k, mn;
int a[MX], sr[MX], mx;
vector<int> G[MX];
bitset<MX> se1, se2;
int dp[MX], fx[MX];
void pre_dfs(int u) {
se1[u] = 1;
int mx_d = 0;
for (auto v : G[u]) {
if (a[v] < mn)
fx[u] = mod;
else if (!se1[v]) {
pre_dfs(v);
if (!fx[v])
dp[u] += dp[v];
else
mx_d = max(mx_d, dp[v]), ++fx[u];
}
}
dp[u] += mx_d + 1;
}
void dfs(int u, bool f = true, int val = 0) {
se2[u] = 1;
int co = 0, mx2 = 0, mx1 = 0;
(f ? co += val : mx1 = max(mx1, val));
for (auto v : G[u])
if (mn <= a[v] && !se2[v]) {
if (!fx[v])
co += dp[v];
else {
if (mx1 < dp[v])
mx1 = dp[v];
else if (mx2 < dp[v])
mx2 = dp[v];
}
}
mx = max(mx, co + mx1 + 1);
for (auto v : G[u])
if (mn <= a[v] && !se2[v] && fx[v])
dfs(v, f && (fx[u] == 1), co + (dp[v] == mx1 ? mx2 : mx1) + 1);
}
bool solv() {
se1.reset();
se2.reset();
memset(fx, 0, sizeof fx);
memset(dp, 0, sizeof dp);
mx = 0;
for (int i = 0; i < n; ++i)
if (mn <= a[i] && !se1[i]) {
pre_dfs(i);
dfs(i);
if (mx >= k) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(9);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i], sr[i] = i;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
G[u].push_back(v), G[v].push_back(u);
}
sort(sr, sr + n, [](int i, int j) { return a[i] < a[j]; });
int l = 0, r = n;
while (l + 1 < r) {
int md = (l + r) >> 1;
mn = a[sr[md]];
if (solv())
l = md;
else
r = md;
}
cout << a[sr[l]] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int n, k;
int a[maxn], w[maxn], sz[maxn], up[maxn], dp[maxn];
vector<int> E[maxn];
int flag;
void dfs1(int x, int fa, int m) {
sz[x] = 1;
for (int i = 0; i < E[x].size(); i++) {
int v = E[x][i];
if (v == fa) continue;
dfs1(v, x, m);
sz[x] += sz[v];
w[x] += w[v];
}
}
void dfs2(int x, int fa, int m) {
int Max1 = 0, Max2 = 0, tot = 0;
for (int i = 0; i < E[x].size(); i++) {
int v = E[x][i];
if (v == fa) continue;
if (w[x] - w[v] == sz[x] - sz[v] && up[x]) up[v] = 1;
dfs2(v, x, m);
if (a[v] < m) continue;
if (sz[v] == w[v]) {
tot += sz[v];
} else {
if (dp[v] > Max1)
Max2 = Max1, Max1 = dp[v];
else if (dp[v] > Max2)
Max2 = dp[v];
}
}
if (a[x] < m) return;
if (tot + Max1 + Max2 + up[x] * (n - sz[x]) + 1 >= k) flag = 1;
dp[x] = tot + Max1 + 1;
}
int check(int x) {
for (int i = 1; i <= n; i++) dp[i] = up[i] = 0;
for (int i = 1; i <= n; i++) {
if (a[i] >= x)
w[i] = 1;
else
w[i] = 0;
}
flag = 0;
dfs1(1, -1, x);
up[1] = w[1];
dfs2(1, -1, x);
return flag;
}
void input() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
E[x].push_back(y);
E[y].push_back(x);
}
}
void work() {
int l = 0, r = 1e6 + 6, ans;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid))
l = mid + 1, ans = mid;
else
r = mid - 1;
}
printf("%d\n", ans);
}
int main() {
input();
work();
return 0;
}
|
#include <bits/stdc++.h>
const int N = 2e5 + 5;
struct DP {
int sum, mx;
DP operator+(const DP &rhs) const {
return DP{sum + rhs.sum, std::max(mx, rhs.mx)};
}
};
int a[N], total[N], down[N], dp[N];
bool good[N];
std::vector<int> edge[N];
int n, k;
void DFS(int u, int fa) {
total[u] = 1;
int sum = 0, mx = 0;
for (auto v : edge[u]) {
if (v == fa) continue;
DFS(v, u);
total[u] += total[v];
if (down[v] == total[v]) {
sum += total[v];
} else {
mx = std::max(mx, down[v]);
}
}
down[u] = sum + mx + 1;
if (!good[u]) down[u] = 0;
}
void DFS2(int u, int fa, int up) {
std::vector<int> children;
int sum = 0, mx = 0;
for (auto v : edge[u]) {
if (v == fa) continue;
if (down[v] == total[v]) {
sum += down[v];
} else {
mx = std::max(mx, down[v]);
}
children.push_back(v);
}
if (up == n - total[u]) {
sum += up;
} else {
mx = std::max(mx, up);
}
dp[u] = sum + mx + 1;
if (!good[u]) dp[u] = 0;
int sz = children.size();
if (sz == 0) return;
std::vector<DP> predown(sz + 1);
predown[0] = {0, 0};
for (int i = 0; i < sz; ++i) {
int v = children[i];
predown[i + 1] = predown[i];
if (down[v] == total[v]) {
predown[i + 1].sum += down[v];
} else {
predown[i + 1].mx = std::max(predown[i + 1].mx, down[v]);
}
}
std::vector<DP> sufdown(sz + 1);
sufdown[sz] = {0, 0};
for (int i = sz - 1; i >= 0; --i) {
int v = children[i];
sufdown[i] = sufdown[i + 1];
if (down[v] == total[v]) {
sufdown[i].sum += down[v];
} else {
sufdown[i].mx = std::max(sufdown[i].mx, down[v]);
}
}
for (int i = 0; i < sz; ++i) {
int v = children[i];
DP now = predown[i] + sufdown[i + 1];
if (up == n - total[u]) {
now.sum += up;
} else {
now.mx = std::max(now.mx, up);
}
int new_up = now.sum + now.mx + 1;
if (!good[u]) new_up = 0;
DFS2(v, u, new_up);
}
}
bool check(int v) {
for (int i = 1; i <= n; ++i) good[i] = (a[i] >= v);
DFS(1, 0);
DFS2(1, 0, 0);
for (int i = 1; i <= n; ++i) {
if (dp[i] >= k) return true;
}
return false;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
}
for (int u, v, i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
int low = 0, high = 1000005;
while (low < high) {
int mid = (low + high + 1) >> 1;
if (check(mid)) {
low = mid;
} else {
high = mid - 1;
}
}
printf("%d\n", low);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.