text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v, next;
Edge() {}
Edge(int _u, int _v, int _nt) : u(_u), v(_v), next(_nt) {}
} edge[200010 << 1];
int n, k, a[200010], head[200010], tot, f[200010], fa[200010], st[200010],
siz[200010], v[200010], top;
void link(int xx, int yy) {
edge[++tot] = Edge(xx, yy, head[xx]);
head[xx] = tot;
}
void DFS(int x) {
siz[x] = 1;
for (int i = head[x]; i != 0; i = edge[i].next) {
int nt = edge[i].v;
if (fa[x] == nt) continue;
fa[nt] = x;
DFS(nt);
siz[x] += siz[nt];
}
st[++top] = x;
}
bool check(int vl) {
for (int i = 1; i <= n; i++) v[i] = (a[i] >= vl), f[i] = 0;
for (int i = 1; i <= n; i++) v[fa[st[i]]] += v[st[i]];
for (int i = 1; i <= n; i++) {
int x = st[i], sum = 0;
if (a[x] < vl) continue;
for (int i = head[x]; i != 0; i = edge[i].next) {
int nt = edge[i].v;
if (fa[x] == nt) continue;
if (siz[nt] == v[nt]) sum += v[nt];
}
if (n - siz[x] == v[1] - v[x]) sum += (v[1] - v[x]);
f[x] = 1;
for (int i = head[x]; i != 0; i = edge[i].next) {
int nt = edge[i].v;
if (nt == fa[x] || siz[nt] == v[nt]) continue;
if (f[x] + f[nt] + sum >= k) return true;
f[x] = max(f[x], f[nt] + 1);
}
if (f[x] + sum >= k) return true;
f[x] += sum;
if (n - siz[x] == v[1] - v[x]) f[x] -= (v[1] - v[x]);
}
return false;
}
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 x, y;
scanf("%d%d", &x, &y);
link(x, y), link(y, x);
}
int l = 1, r = 1000000;
DFS(1);
check(2);
while (l < r) {
int mid = (l + r + 1) >> 1;
if (check(mid))
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct str {
int v, nex;
} edge[201000 << 1];
typedef int arr32[201000];
arr32 mark, fst, A, B, ans, val, is, fa, size;
int n, m, L, R, mid, e;
bool flag;
void make_edge(int a, int b) {
edge[++e].nex = fst[a];
fst[a] = e;
edge[e].v = b;
edge[++e].nex = fst[b];
fst[b] = e;
edge[e].v = a;
}
void update(int u) {
size[u] = 1;
for (int i = fst[u]; i; i = edge[i].nex) {
int v = edge[i].v;
if (fa[u] == v) continue;
size[u] += size[v];
}
if (!is[u]) return;
mark[u] = 1;
ans[u] = 1;
for (int i = fst[u]; i; i = edge[i].nex) {
int v = edge[i].v;
if (fa[u] == v) continue;
if (mark[v])
ans[u] += size[v];
else {
mark[u] = 0;
if (ans[v] >= ans[A[u]]) {
ans[u] += ans[v] - ans[A[u]];
B[u] = A[u];
A[u] = v;
} else if (ans[v] >= ans[B[u]]) {
B[u] = v;
}
}
}
return;
}
void dfs(int u) {
for (int i = fst[u]; i; i = edge[i].nex) {
int v = edge[i].v;
if (fa[u] == v) continue;
fa[v] = u;
dfs(v);
}
update(u);
}
void change_root(int f, int u) {
fa[u] = 0;
fa[f] = u;
if (!is[f])
;
else {
if (mark[f])
ans[f] -= size[u];
else if (mark[u]) {
ans[f] -= size[u];
} else {
if (A[f] == u) {
ans[f] -= ans[u], ans[f] += ans[B[f]];
A[f] = B[f];
B[f] = 0;
}
if (!A[f]) mark[f] = 1;
}
}
if (!is[u])
;
else {
if (mark[f])
ans[u] += size[f] - size[u];
else {
mark[u] = 0;
if (ans[f] >= ans[A[u]]) {
ans[u] += ans[f] - ans[A[u]];
B[u] = A[u];
A[u] = f;
} else if (ans[f] >= ans[B[u]]) {
B[u] = f;
}
}
}
size[f] -= size[u];
size[u] += size[f];
}
void proc(int u, int pas) {
if (ans[u] >= m) flag = true;
for (int i = fst[u]; i; i = edge[i].nex) {
int v = edge[i].v;
if (v == pas) continue;
int ans_ = ans[u], mark_ = mark[u], A_ = A[u], B_ = B[u];
change_root(u, v);
proc(v, u);
change_root(v, u);
if (ans_ != ans[u] || mark_ != mark[u]) {
printf("woc!\n");
}
}
}
bool judge() {
flag = false;
for (int i = 1; i <= n; i++) is[i] = (val[i] >= mid);
for (int i = 1; i <= n; i++) ans[i] = mark[i] = size[i] = A[i] = B[i] = 0;
for (int i = 1; i <= n; i++) fa[i] = 0;
dfs(1);
proc(1, 0);
return flag;
}
int main() {
scanf("%d %d", &n, &m);
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);
make_edge(a, b);
}
R = 0;
L = (1 << 30);
for (int i = 1; i <= n; i++) {
R = max(R, val[i]);
L = min(L, val[i]);
}
while (L < R) {
mid = (L + R + 1) >> 1;
if (judge())
L = mid;
else
R = mid - 1;
}
printf("%d\n", L);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[200005];
int n, k;
int ar[200005];
bool vis[200005];
bool del[200005];
bool collapsed[200005];
int deg[200005];
int mxans = 0;
int dp[200005];
int v[200005];
queue<int> Q;
void dfs1(int x, int p) {
vis[x] = 1;
if (deg[x] == 1) {
Q.push(x);
}
int sz = adj[x].size();
for (int i = 0; i < sz; ++i) {
if (adj[x][i] == p || del[adj[x][i]]) continue;
dfs1(adj[x][i], x);
}
}
void dfs(int x, int p) {
dp[x] = v[x];
int b1 = 0, b2 = 0;
int sz = adj[x].size();
for (int i = 0; i < sz; ++i) {
if (adj[x][i] == p || del[adj[x][i]]) continue;
dfs(adj[x][i], x);
if (dp[adj[x][i]] > b1) {
b2 = b1;
b1 = dp[adj[x][i]];
} else
b2 = max(b2, dp[adj[x][i]]);
}
mxans = max(mxans, b1 + b2 + v[x]);
dp[x] += b1;
}
void solve(int x) {
dfs1(x, -1);
while (Q.size()) {
int X = Q.front();
int sz = adj[X].size();
Q.pop();
collapsed[X] = 1;
int pi = 0;
for (int i = 0; i < sz; ++i) {
if (collapsed[adj[X][i]] || del[adj[X][i]]) continue;
pi = adj[X][i];
}
if (pi != 0) {
v[pi] += v[X];
v[X] = 0;
mxans = max(mxans, v[pi]);
deg[pi]--;
if (deg[pi] == 1) Q.push(pi);
}
}
dfs(x, -1);
}
bool check(int x) {
for (int i = 1; i <= n; ++i) {
deg[i] = adj[i].size();
v[i] = 1;
vis[i] = 0;
collapsed[i] = 0;
del[i] = (ar[i] < x);
}
mxans = 0;
for (int i = 1; i <= n; ++i) {
if (!vis[i] && !del[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, u = (1 << 20);
int mid, mi = 1;
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;
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 N = 200005;
int n, k;
int a[N];
vector<int> edge[N], child[N];
vector<int> ord;
int fa[N], size[N];
void dfs(int u) {
ord.push_back(u);
size[u] = 1;
for (int i = 0; i < (int)edge[u].size(); ++i) {
int v = edge[u][i];
if (v == fa[u]) {
continue;
}
fa[v] = u;
child[u].push_back(v);
dfs(v);
size[u] += size[v];
}
}
int ans[N], best[N], bak[N], baks[N];
int check(int bar) {
for (int i = n - 1; i >= 0; --i) {
int u = ord[i];
if (a[u] < bar) {
ans[u] = 0;
best[u] = -1;
bak[u] = -1;
baks[u] = 0;
} else {
ans[u] = 1;
best[u] = -1;
bak[u] = -1;
baks[u] = 0;
for (int j = 0; j < (int)child[u].size(); ++j) {
int v = child[u][j];
if (ans[v] == size[v]) {
ans[u] += size[v];
} else {
if (best[u] == -1 || ans[v] > ans[best[u]]) {
bak[u] = best[u];
baks[u] = ans[bak[u]];
best[u] = v;
} else if (bak[u] == -1 || ans[v] > ans[bak[u]]) {
bak[u] = v;
baks[u] = ans[bak[u]];
}
}
}
if (best[u] != -1) {
ans[u] += ans[best[u]];
}
}
}
int ret = 0;
for (int i = 0; i < n; ++i) {
int u = ord[i], tmp;
if (u == 0) {
tmp = ans[u];
} else {
if (ans[u] == 0) {
tmp = 0;
} else if (ans[fa[u]] == 0) {
tmp = ans[u];
} else {
if (ans[u] == size[u]) {
tmp = ans[u] = ans[fa[u]];
} else {
if (best[fa[u]] == u && bak[fa[u]] == -1) {
tmp = ans[u] = ans[fa[u]];
} else {
int ansp;
if (best[fa[u]] == u) {
ansp = ans[fa[u]] - ans[u] + baks[fa[u]];
} else {
ansp = ans[fa[u]];
}
if (ansp > ans[best[u]]) {
tmp = ans[u] = ans[u] - ans[best[u]] + ansp;
bak[u] = best[u];
baks[u] = ans[bak[u]];
best[u] = fa[u];
} else {
if (ansp > ans[bak[u]]) {
bak[u] = fa[u];
baks[u] = ansp;
}
tmp = ans[u];
}
}
}
}
}
ret = max(ret, tmp);
}
return ret;
}
int main() {
scanf("%d%d", &n, &k);
vector<int> val;
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
val.push_back(a[i]);
}
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
edge[u].push_back(v);
edge[v].push_back(u);
}
fa[0] = -1;
dfs(0);
sort(val.begin(), val.end());
val.erase(unique(val.begin(), val.end()), val.end());
int l = 0, r = val.size() - 1;
while (l < r) {
int m = (l + r + 1) >> 1;
if (check(val[m]) >= k) {
l = m;
} else {
r = m - 1;
}
}
printf("%d\n", val[l]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool ff;
int n, k, i, x, y, l, r, mid, ans, tot, fir[400400], ne[400400], la[400400],
g[400400], zs[400400], g2[400400], f[400400], sum[400400], up[400400],
a[400400];
void ins(int x, int y) {
la[++tot] = y;
ne[tot] = fir[x];
fir[x] = tot;
}
void dfs(int x, int fa, int w) {
if (a[x] >= w)
zs[x] = 0;
else
zs[x] = 1;
g[x] = 0;
g2[x] = 0;
f[x] = 0;
for (int i = fir[x], y; i; i = ne[i])
if (la[i] != fa) {
y = la[i];
dfs(y, x, w);
if (!zs[y])
f[x] += f[y];
else if (f[y] > g[x])
g2[x] = g[x], g[x] = f[y];
else if (f[y] > g2[x])
g2[x] = f[y];
zs[x] += zs[y];
}
sum[x] = f[x];
if (a[x] < w)
f[x] = 0;
else
f[x] += 1 + g[x];
}
void dfs2(int x, int fa, int w) {
int v = 0, mx = 0, i, y;
if (a[x] >= w) {
if (zs[1] - zs[x] == 0)
v += up[x];
else
mx = max(mx, up[x]);
for (i = fir[x]; i; i = ne[i])
if (la[i] != fa)
if (zs[y = la[i]] == 0)
v += f[y];
else
mx = max(mx, f[y]);
v += mx + 1;
if (v >= k) {
ff = 1;
return;
}
}
for (i = fir[x]; i; i = ne[i])
if (la[i] != fa) {
y = la[i];
if (a[x] < w)
up[y] = 0;
else {
v = sum[x];
mx = 0;
if (zs[y] == 0)
v -= f[y];
else if (g[x] == f[y])
mx = max(mx, g2[x]);
else
mx = max(mx, g[x]);
if (zs[1] - zs[x] == 0)
v += up[x];
else
mx = max(mx, up[x]);
up[y] = v + mx + 1;
}
dfs2(y, x, w);
}
}
bool ok(int x) {
dfs(1, 0, x);
ff = 0;
dfs2(1, 0, x);
return ff;
}
int main() {
for (scanf("%d%d", &n, &k), i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i < n; i++) scanf("%d%d", &x, &y), ins(x, y), ins(y, x);
for (l = 1, r = 1000000; l <= r;)
if (ok(mid = l + r >> 1))
l = (ans = mid) + 1;
else
r = mid - 1;
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, tot, mp[2000006], h[2000006], m, ans, siz[2000006], dp[2000006],
mi = 0x3f3f3f3f, rt, ma;
struct DX {
long long v, p;
} dx[2000006];
void add(long long u, long long v) {
dx[++tot].v = v;
dx[tot].p = h[u];
h[u] = tot;
}
void dfs(long long u, long long fx, long long mid) {
siz[u] = 1;
dp[u] = 1;
long long ma1 = 0, ma2 = 0;
for (long long i = h[u]; i; i = dx[i].p) {
long long v = dx[i].v;
if (v == fx) continue;
dfs(v, u, mid);
siz[u] += siz[v];
if (siz[v] == dp[v])
dp[u] += dp[v];
else {
if (dp[v] > ma1) swap(ma1, dp[v]);
if (dp[v] > ma2) swap(ma2, dp[v]);
}
}
dp[u] = mp[u] < mid ? 0 : dp[u] + ma1;
ans = max(ans, dp[u] + ma2);
}
int main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &mp[i]);
if (mp[i] < mi) {
rt = i;
mi = mp[i];
}
ma = max(ma, mp[i]);
}
long long a, b, l = mi, r = ma;
for (long long i = 1; i < n; i++) {
scanf("%lld%lld", &a, &b);
add(a, b);
add(b, a);
}
while (l <= r) {
long long mid = (l + r) >> 1;
ans = 0;
dfs(rt, 0, mid);
if (ans >= m)
l = mid + 1;
else
r = mid - 1;
}
printf("%lld", l - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 / 2;
const int inf = 1e9;
const int N = 5e5;
const double PI = acos(-1.0);
const int MOD = 1000000000 + 7;
int n;
int p[N];
int a[N], b[N];
bool was[N];
bool ok = true;
bool can[N];
vector<int> g[N];
int ans[N], k;
void dfs(int v, int p = -1) {
if (ok) return;
can[v] = b[v];
ans[v] = 0;
for (int i = 0; i < (int)g[v].size(); ++i) {
if (ok) break;
int to = g[v][i];
if (to == p) continue;
dfs(to, v);
can[v] &= can[to];
if (can[to]) ans[v] += ans[to];
}
if (b[v]) {
int first = 0;
int second = 0;
for (int i = 0; i < (int)g[v].size(); ++i) {
int to = g[v][i];
if (to == p) continue;
if (!can[to]) {
if (ans[to] > first) {
second = first;
first = ans[to];
} else if (ans[to] > second) {
second = ans[to];
}
}
}
first += second;
if (ans[v] + first + 1 >= k) {
ok = true;
return;
}
if (!can[v]) {
ans[v] += first - second;
}
ans[v] += 1;
} else {
ans[v] = 0;
}
if (can[v]) was[v] = true;
}
bool can2(int val) {
for (int i = 0; i < n; ++i) {
if (a[i] >= val)
b[i] = 1;
else
b[i] = 0;
}
vector<int> w;
for (int i = 0; i < n; ++i) {
if (b[i]) w.push_back(i);
}
for (int i = 0; i < n; ++i) was[i] = false;
for (int i = 0; i < 5; ++i) random_shuffle(w.begin(), w.end());
ok = false;
int counter = 0;
for (int i = 0; i < (int)w.size(); ++i) {
if (was[w[i]]) continue;
dfs(w[i]);
counter++;
if (counter > 10) break;
if (ok) break;
}
return ok;
}
int main() {
ios ::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
int left = 0, right = 1000001;
while (left + 1 < right) {
int m = (left + right) >> 1;
if (can2(m))
left = m;
else
right = m;
}
cout << left << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1.01e9;
const double eps = 1e-9;
const int N = 2e5 + 10;
vector<int> v[N];
int a[N];
int b[N];
int n;
int w[N], d[N];
int f[N];
int res;
void dfs(int x) {
f[x] = w[x];
vector<int> vv;
for (int i = 0; (i) < (((int)(v[x]).size())); ++i) {
int y = v[x][i];
if (w[y] && b[y] && !f[y]) {
dfs(y);
f[x] = max(f[x], f[y] + w[x]);
vv.push_back(f[y]);
}
}
sort((vv).begin(), vv.end());
reverse((vv).begin(), vv.end());
if (((int)(vv).size()) >= 2) res = max(res, w[x] + vv[0] + vv[1]);
res = max(res, f[x]);
}
int calc(int T) {
for (int i = 0; (i) < (n); ++i) b[i] = a[i] >= T;
for (int i = 0; (i) < (n); ++i) d[i] = ((int)(v[i]).size());
for (int i = 0; (i) < (n); ++i) w[i] = 1;
set<pair<int, int> > second;
for (int i = 0; (i) < (n); ++i) second.insert(make_pair(d[i], i));
for (int _ = 0; (_) < (n); ++_) {
int x = second.begin()->second;
second.erase(second.begin());
if (d[x] != 1) {
break;
}
int to = -1;
for (int i = 0; (i) < (((int)(v[x]).size())); ++i) {
int y = v[x][i];
if (w[y]) {
to = y;
break;
}
}
if (b[x] && b[to]) {
second.erase(make_pair(d[to], to));
d[to] -= 1;
w[to] += w[x];
w[x] = 0;
second.insert(make_pair(d[to], to));
}
}
for (int i = 0; (i) < (n); ++i) f[i] = 0;
res = 0;
for (int i = 0; (i) < (n); ++i)
if (b[i] && w[i] && !f[i]) {
dfs(i);
}
return res;
}
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 - 1); ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x, --y;
v[x].push_back(y);
v[y].push_back(x);
}
int l = 0, r = 1e6;
while (l < r) {
int m = (l + r + 1) >> 1;
if (calc(m) >= k)
l = m;
else
r = m - 1;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[200010];
int bl[200010];
int mx[200010];
int fmx[200010];
int smx[200010];
int sz[200010];
int vis[200010];
int A[200010];
int b[200010];
const int all = (1e8);
int N, K, S;
int dfs1(int v, int p) {
vis[v] = 1;
if (bl[v]) {
mx[v] = 0;
sz[v] = 0;
return 0;
}
int i, u, sum = 1;
sz[v] = 1;
b[v] = 0;
fmx[v] = smx[v] = 0;
for (i = 0; i < adj[v].size(); ++i) {
u = adj[v][i];
if (u == p) continue;
sz[v] += dfs1(u, v);
if (mx[u] == all) {
sum += sz[u];
continue;
}
b[v]++;
if (mx[u] > fmx[v]) {
smx[v] = fmx[v];
fmx[v] = mx[u];
} else {
smx[v] = max(smx[v], mx[u]);
}
}
sum += fmx[v];
mx[v] = b[v] ? sum : all;
return sz[v];
}
int best(int v, int p) {
int i, u, sl;
if (bl[v]) return 0;
sl = 0;
int mxpar = 0;
if (p >= 0) {
mxpar = mx[p];
if (mxpar == all || (mx[v] != all && b[p] == 1))
mxpar = all;
else {
if (mx[v] == all)
mxpar -= sz[v];
else if (mx[v] == fmx[p])
mxpar += smx[p] - fmx[p];
}
if (mxpar != all) b[v]++;
}
if (mxpar == all) {
if (mx[v] != all) mx[v] += S - sz[v];
} else {
if (mx[v] == all) mx[v] = sz[v];
mx[v] -= fmx[v];
if (mxpar > fmx[v]) {
smx[v] = fmx[v];
fmx[v] = mxpar;
} else {
smx[v] = max(smx[v], mxpar);
}
mx[v] += fmx[v];
}
sl = max(sl, (mx[v] == all ? S : mx[v]));
for (i = 0; i < adj[v].size(); ++i) {
u = adj[v][i];
if (u == p) continue;
sl = max(sl, best(u, v));
}
return sl;
}
int check(int lim) {
int i;
for (i = 0; i < N; ++i) bl[i] = (A[i] < lim), vis[i] = 0;
int mx1 = 0;
for (i = 0; i < N; ++i) {
if (vis[i] || bl[i]) continue;
dfs1(i, -1);
S = sz[i];
mx1 = max(mx1, best(i, -1));
}
return mx1 >= K;
}
int search() {
int low, high, mid;
low = 1, high = 1e6;
while (low < high) {
mid = low + (high - low + 1) / 2;
if (check(mid)) {
low = mid;
} else {
high = mid - 1;
}
}
return low;
}
int main() {
int i;
scanf("%d%d", &N, &K);
for (i = 0; i < N; ++i) scanf("%d", &A[i]);
int u, v;
for (i = 0; i < N - 1; ++i) {
scanf("%d%d", &u, &v);
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
printf("%d\n", search());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, k, a[maxn], cnt[maxn], sz[maxn], bad[maxn], all;
vector<int> way[maxn];
bool ok[maxn];
bool dfs(int node, int dad) {
sz[node] = 1;
cnt[node] = ok[node];
bad[node] = !ok[node];
int mx = 0, mx2 = 0;
for (int i = 0; i < (int)way[node].size(); i++) {
int adj = way[node][i];
if (adj == dad) continue;
if (dfs(adj, node)) return 1;
sz[node] += sz[adj];
bad[node] += bad[adj];
if (!ok[node] or !ok[adj]) continue;
if (cnt[adj] == sz[adj])
cnt[node] += cnt[adj];
else {
if (cnt[adj] >= mx) {
mx2 = mx;
mx = cnt[adj];
} else if (cnt[adj] > mx2)
mx2 = cnt[adj];
}
}
cnt[node] += mx;
if (ok[node])
return cnt[node] + mx2 + (bad[node] == all ? n - sz[node] : 0) >= k;
return 0;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
way[x].push_back(y);
way[y].push_back(x);
}
int bgn = 1, end = 1e6;
while (bgn < end) {
int mid = (bgn + end + 1) >> 1;
all = 0;
for (int i = 1; i <= n; i++) {
ok[i] = a[i] >= mid;
all += !ok[i];
}
if (dfs(1, 0))
bgn = mid;
else
end = mid - 1;
}
printf("%d\n", bgn);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <ll i, class T>
void print_tuple(ostream&, const T&) {}
template <ll i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
if (i) os << ",";
os << get<i>(t);
print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
os << "{";
print_tuple<0, tuple<Args...>, Args...>(os, t);
return os << "}";
}
void print(ll x, ll suc = 1) {
cout << x;
if (suc == 1) cout << "\n";
if (suc == 2) cout << " ";
}
ll read() {
ll i;
cin >> i;
return i;
}
vi readvi(ll n, ll off = 0) {
vi v(n);
for (ll i = ll(0); i < ll(n); i++) v[i] = read() + off;
return v;
}
template <class T>
void print(const vector<T>& v, ll suc = 1) {
for (ll i = ll(0); i < ll(v.size()); i++)
print(v[i], i == ll(v.size()) - 1 ? suc : 2);
}
string readString() {
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T& t) {
return t * t;
}
void yes(bool ex = true) {
cout << "Yes" << endl;
if (ex) exit(0);
}
void no(bool ex = true) {
cout << "No" << endl;
if (ex) exit(0);
}
constexpr ll ten(ll n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
ll topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
ll topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
ll botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
ll botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
ll popcount(signed t) { return __builtin_popcount(t); }
ll popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(ll i) { return i && (i & -i) == i; }
ll mask(ll i) { return (ll(1) << i) - 1; }
bool inc(ll first, ll second, ll c) { return first <= second && second <= c; }
template <class t>
void mkuni(vc<t>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
static random_device rd;
static mt19937_64 gen(rd());
return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
ll lwb(const vc<t>& v, const t& first) {
return lower_bound(v.begin(), v.end(), first) - v.begin();
}
template <class N, class E>
struct treedp {
const vvc<E>& g;
vvc<N> dp1, dp2;
vc<N> res;
N dfs1(ll v, ll p) {
N tmp;
tmp.init(v);
dp1[v].push_back(tmp);
E up;
for (auto e : g[v])
if (e != p)
dp1[v].push_back(dfs1(e, v));
else
up = e;
dp2[v] = dp1[v];
for (ll i = ll(1); i < ll(dp2[v].size()); i++)
dp2[v][i] = dp2[v][i - 1] + dp2[v][i];
if (p == -1)
return N();
else
return dp2[v].back().up(up);
}
void dfs2(ll v, ll p, N cur) {
res[v] = cur + dp2[v].back();
for (ll i = ll(g[v].size()) - 1; i >= ll(0); i--) {
auto e = g[v][i];
if (e == p) continue;
dp2[v].pop_back();
dfs2(e, v, (cur + dp2[v].back()).up(e));
cur = cur + dp1[v].back();
dp1[v].pop_back();
}
}
treedp(const vvc<E>& gg)
: g(gg), dp1(g.size()), dp2(g.size()), res(g.size()) {
dfs1(0, -1);
N tmp;
tmp.init(0);
dfs2(0, -1, tmp);
}
};
vi ok;
struct N {
bool rok;
ll x, y;
void init(ll vv) {
rok = ok[vv];
x = 0;
y = -1;
}
N up(ll to) const {
N res;
res.init(to);
if (res.rok) {
if (rok) {
if (y == -1) {
res.x = x + 1;
} else {
res.y = x + y + 1;
}
} else {
res.y = 0;
}
}
return res;
}
N operator+(const N& r) const {
if (!rok) return *this;
N res;
res.rok = 1;
res.x = x + r.x;
res.y = max(y, r.y);
return res;
}
ll getans() {
if (rok)
return 1 + x + y;
else
return 0;
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
ll n, k;
cin >> n >> k;
vvc<ll> g(n);
vi val = readvi(n);
for (ll i = ll(0); i < ll(n - 1); i++) {
ll first, second;
cin >> first >> second;
first--;
second--;
g[first].push_back(second);
g[second].push_back(first);
}
vi vs = val;
mkuni(vs);
ll lw = 0, up = vs.size();
while (up - lw > 1) {
const ll mid = (lw + up) / 2;
ok.resize(n);
for (ll i = ll(0); i < ll(n); i++) ok[i] = val[i] >= vs[mid];
auto dp = treedp<N, ll>(g).res;
bool can = 0;
for (ll i = ll(0); i < ll(n); i++)
if (dp[i].getans() >= k) can = 1;
if (can)
lw = mid;
else
up = mid;
}
cout << vs[lw] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 200005;
vector<int> adjList[mx];
queue<int> leaves;
int n, k, u, v, res;
bool bad[mx], vis[mx], rem[mx];
int deg[mx], a[mx], val[mx], dp[mx][2];
void find_leaves(int u, int p) {
vis[u] = 1;
for (int v : adjList[u]) {
if (v == p || bad[v]) continue;
find_leaves(v, u);
}
if (deg[u] == 1) leaves.push(u);
}
void dfs(int u, int p) {
dp[u][1] = dp[u][0] = 0;
for (int v : adjList[u]) {
if (v == p || bad[v]) continue;
dfs(v, u);
if (dp[v][0] >= dp[u][0])
dp[u][1] = dp[u][0], dp[u][0] = dp[v][0];
else if (dp[v][0] > dp[u][1])
dp[u][1] = dp[v][0];
}
res = max(res, dp[u][0] + dp[u][1] + val[u]);
dp[u][0] += val[u];
}
void check(int u) {
find_leaves(u, -1);
while (!leaves.empty()) {
int cur = leaves.front();
leaves.pop();
rem[cur] = true;
int spl = -1;
for (int up : adjList[cur])
if (!rem[up] && !bad[up]) spl = up;
if (spl != -1) {
val[spl] += val[cur];
val[cur] = 0;
deg[spl]--;
if (deg[spl] == 1) leaves.push(spl);
}
}
dfs(u, -1);
}
bool solve(int cur) {
res = 0;
for (int i = 1; i <= n; i++) {
bad[i] = (a[i] < cur);
vis[i] = rem[i] = false;
deg[i] = adjList[i].size();
val[i] = 1;
}
for (int i = 1; i <= n; i++)
if (!vis[i] && !bad[i]) check(i);
return (res >= k);
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
cin >> u >> v;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
int ans = 0;
for (int i = 20; i >= 0; i--)
if (solve(ans + (1 << i))) ans += (1 << i);
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, k, val, ans;
vector<int> a;
vector<vector<int>> G;
vector<int> sz, cnt_one, dp;
vector<array<pair<int, int>, 2>> mx;
void calc_dp(int v, int pr) {
sz[v] = 1;
cnt_one[v] += (a[v] >= val ? 1 : 0);
for (auto u : G[v]) {
if (u != pr) {
calc_dp(u, v);
sz[v] += sz[u];
cnt_one[v] += cnt_one[u];
if (sz[u] == cnt_one[u]) {
dp[v] += sz[u];
} else {
if (mx[v][0].first <= dp[u]) {
mx[v][1] = mx[v][0];
mx[v][0] = make_pair(dp[u], u);
} else if (mx[v][1].first <= dp[u]) {
mx[v][1] = make_pair(dp[u], u);
}
}
}
}
dp[v] += mx[v][0].first;
if (a[v] < val) {
dp[v] = 0;
} else {
dp[v]++;
}
}
void calc_ans(int v, int pr) {
ans = max(ans, dp[v]);
for (auto u : G[v]) {
if (u != pr) {
array<pair<int, int>, 2> was_mx_v = mx[v];
array<pair<int, int>, 2> was_mx_u = mx[u];
int was_dp_v = dp[v];
int was_dp_u = dp[u];
int was_sz_v = sz[v];
int was_sz_u = sz[u];
int was_cnt_one_v = cnt_one[v];
int was_cnt_one_u = cnt_one[u];
dp[v] -= mx[v][0].first;
if (sz[u] == cnt_one[u]) {
dp[v] -= dp[u];
} else if (u == mx[v][0].second) {
swap(mx[v][0], mx[v][1]);
}
dp[v] += mx[v][0].first;
sz[v] -= sz[u];
cnt_one[v] -= cnt_one[u];
if (a[v] < val) {
dp[v] = 0;
}
dp[u] -= mx[u][0].first;
if (sz[v] == cnt_one[v]) {
dp[u] += dp[v];
} else {
if (mx[u][0].first <= dp[v]) {
mx[u][1] = mx[u][0];
mx[u][0] = make_pair(dp[v], v);
} else if (mx[u][1].first <= dp[v]) {
mx[u][1] = make_pair(dp[v], v);
}
}
dp[u] += mx[u][0].first;
sz[u] += sz[v];
cnt_one[u] += cnt_one[v];
if (a[u] < val) {
dp[u] = 0;
}
calc_ans(u, v);
mx[v] = was_mx_v;
mx[u] = was_mx_u;
dp[v] = was_dp_v;
dp[u] = was_dp_u;
sz[v] = was_sz_v;
sz[u] = was_sz_u;
cnt_one[v] = was_cnt_one_v;
cnt_one[u] = was_cnt_one_u;
}
}
}
bool check() {
sz.assign(n, 0);
cnt_one.assign(n, 0);
dp.assign(n, 0);
mx.assign(n, {make_pair(0, -1), make_pair(0, -1)});
calc_dp(0, 0);
ans = 0;
calc_ans(0, 0);
return ans >= k;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> k;
a.resize(n);
for (auto &el : a) {
cin >> el;
}
G.resize(n);
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 L = 0, R = *max_element(a.begin(), a.end()) + 1;
while (R - L > 1) {
val = (R + L) / 2;
if (check()) {
L = val;
} else {
R = val;
}
}
cout << L << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 15;
vector<int> adj[N];
int a[N], sz[N], dirtysum[N], dp[N], tot[N];
int dfs(int x, int p, int n, int dt, int val) {
int u, i;
int m[2] = {0};
int ret = 0;
sz[x] = dp[x] = tot[x] = 1;
dirtysum[x] = 0;
for (i = 0; i < adj[x].size(); ++i) {
u = adj[x][i];
if (u != p)
ret = max(ret, dfs(u, x, n, dt, val));
else
continue;
if (tot[u] && tot[x])
tot[x] += tot[u];
else
tot[x] = 0;
sz[x] += sz[u];
dp[x] += tot[u];
dirtysum[x] += dirtysum[u];
if (dp[u] - tot[u] > m[0]) {
m[1] = m[0];
m[0] = dp[u] - tot[u];
} else if (dp[u] - tot[u] > m[1])
m[1] = dp[u] - tot[u];
}
if (a[x] < val) {
++dirtysum[x];
dp[x] = 0, tot[x] = 0;
return ret;
}
dp[x] += m[0];
ret = max(ret, dp[x] + m[1] + (dt == dirtysum[x] ? n - sz[x] : 0));
return ret;
}
int main() {
int x, y, n, k, i;
cin >> n >> k;
for (i = 1; i <= n; ++i) cin >> a[i];
for (i = 0; i < n - 1; ++i) {
scanf("%d%d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
int l = 1, r = 1e6, mid;
while (l < r) {
mid = (l + r + 1) / 2;
int dt = 0;
for (i = 1; i <= n; ++i)
if (a[i] < mid) ++dt;
if (dfs(1, 0, n, dt, mid) >= k)
l = mid;
else
r = mid - 1;
}
cout << l << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[200200], mn, son[200200], bad, bad_son[200200], f[200200];
bool good[200200];
vector<int> v[200200];
void dfs1(int x, int p = 0) {
son[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (y == p) continue;
dfs1(y, x);
son[x] += son[y];
}
}
void dfs2(int x, int p = 0) {
bad_son[x] = a[x] < mn ? 1 : 0;
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (y == p) continue;
dfs2(y, x);
bad_son[x] += bad_son[y];
}
if (bad_son[x] == bad)
good[x] = 1;
else
good[x] = 0;
}
bool dfs3(int x, int p = 0) {
if (a[x] < mn)
f[x] = 0;
else
f[x] = 1;
int all = 0;
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (y == p) continue;
if (dfs3(y, x)) return 1;
if (f[y] == son[y]) all += f[y];
}
if (a[x] < mn) return 0;
int mx1 = 0, mx2 = 0;
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (y == p) continue;
if (f[y] == son[y])
f[x] = max(f[x], all + 1);
else
f[x] = max(f[x], all + f[y] + 1);
if (f[y] == son[y]) continue;
if (mx1 < f[y])
mx2 = mx1, mx1 = f[y];
else if (mx2 < f[y])
mx2 = f[y];
}
int mx = mx1 + mx2 + all + 1;
if (good[x]) mx += n - son[x];
return mx >= k;
}
bool solve() {
bad = 0;
for (int i = 1; i <= n; i++)
if (a[i] < mn) bad++;
dfs2(1);
return dfs3(1);
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
if (k == 1) {
return printf("%d\n", *max_element(a + 1, a + n + 1)), 0;
}
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
v[x].push_back(y), v[y].push_back(x);
}
dfs1(1);
int st = 1, en = 1000001;
while (en - st > 1) {
int mid = st + en >> 1;
mn = mid;
if (solve())
st = mid;
else
en = mid;
}
printf("%d\n", st);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200100];
int a[200100], v[200100], n;
int ne[200100], nb[200100], sz[200100];
int e[200100];
int ans = 0, tb = 0;
void DFS(int u, int p, int val) {
sz[u] = ne[u] = e[u] = 1;
nb[u] = 0;
int m[2] = {};
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
DFS(v, u, val);
if (ne[u] && ne[v])
ne[u] += ne[v];
else
ne[u] = 0;
e[u] += ne[v];
nb[u] += nb[v];
sz[u] += sz[v];
if (e[v] - ne[v] > m[0]) {
m[1] = m[0];
m[0] = e[v] - ne[v];
} else if (e[v] - ne[v] > m[1]) {
m[1] = e[v] - ne[v];
}
}
if (a[u] < val) {
e[u] = 0;
ne[u] = 0;
nb[u]++;
return;
}
e[u] += m[0];
ans = max(ans, e[u] + m[1] + (nb[u] == tb ? n - sz[u] : 0));
}
int main() {
int k, vc;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
v[i - 1] = a[i];
}
sort(v, v + n);
vc = unique(v, v + n) - v;
int x, y;
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
int l = 0, r = vc;
while (l + 1 < r) {
int m = (l + r) / 2;
ans = 0;
tb = 0;
for (int i = 1; i <= n; i++) {
if (a[i] < v[m]) tb++;
}
DFS(1, 0, v[m]);
if (ans >= k)
l = m;
else
r = m;
}
printf("%d\n", v[l]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int u;
vector<vector<pair<int, int>>> adj(200010);
int a[200010];
int state[200010];
int lastproc[200010];
int freesum[200010];
int edgeend[200010 * 2];
int maxfinal[2][200010];
int maxfinalid[2][200010];
int bad[200010];
int good[200010];
int par[200010];
int root[200010];
void addinfo(int v, int r, int lid) {
if (a[v] < u) {
if (0 > maxfinal[0][r]) {
maxfinal[0][r] = 0;
maxfinalid[0][r] = v;
} else if (0 > maxfinal[1][r]) {
maxfinal[1][r] = 0;
maxfinalid[1][r] = v;
}
return;
}
if (state[v] == 2) {
bool risfree = false;
if (par[v] == r) {
risfree = bad[root[r]] == bad[v];
} else {
risfree = bad[r] == 0;
}
int cans = freesum[v];
bool visfree = true;
if (maxfinalid[0][v] == r) {
if (maxfinal[1][v] != -1) {
visfree = false;
cans += maxfinal[1][v];
}
} else {
if (maxfinal[0][v] != -1) {
visfree = false;
cans += maxfinal[0][v];
}
}
if (risfree) {
if (par[r] == v) {
cans -= good[r];
} else
cans -= good[root[r]] - good[v];
}
if (visfree) {
freesum[r] += cans;
} else {
if (cans > maxfinal[0][r]) {
maxfinal[1][r] = maxfinal[0][r];
maxfinalid[1][r] = maxfinalid[0][r];
maxfinal[0][r] = cans;
maxfinalid[0][r] = v;
} else if (cans > maxfinal[1][r]) {
maxfinal[1][r] = cans;
maxfinalid[1][r] = v;
}
}
} else {
assert(state[v] == 1);
int cans = freesum[v];
int cadd = maxfinal[0][v] == -1 ? 0 : maxfinal[0][v];
cans += cadd;
if (maxfinal[0][v] == -1) {
freesum[r] += cans;
} else {
if (cans > maxfinal[0][r]) {
maxfinal[1][r] = maxfinal[0][r];
maxfinalid[1][r] = maxfinalid[0][r];
maxfinal[0][r] = cans;
maxfinalid[0][r] = v;
} else if (cans > maxfinal[1][r]) {
maxfinal[1][r] = cans;
maxfinalid[1][r] = v;
}
}
}
}
void recur(int v, int pid) {
if (a[v] < u) return;
if (state[v] == 2) {
return;
}
if (state[v] == 1) {
if ((pid ^ 1) == lastproc[v]) {
return;
}
int nx = lastproc[v];
recur(edgeend[nx], nx);
addinfo(edgeend[nx], v, nx);
state[v] = 2;
return;
}
if (state[v] == 0) {
for (auto nx : adj[v]) {
if (nx.second == (pid ^ 1)) continue;
recur(nx.first, nx.second);
addinfo(nx.first, v, nx.second);
}
state[v] = 1;
lastproc[v] = pid ^ 1;
}
}
int getans(int r) {
if (a[r] < u) {
return 0;
}
if (state[r] == 1) {
int nval = lastproc[r];
recur(edgeend[nval], nval);
addinfo(edgeend[nval], r, nval);
} else if (state[r] == 0) {
for (auto v : adj[r]) {
recur(v.first, v.second);
addinfo(v.first, r, v.second);
}
}
state[r] = 2;
int mf = maxfinal[0][r] == -1 ? 0 : maxfinal[0][r];
return freesum[r] + mf;
}
void predfs(int v) {
good[v] = 1;
if (par[v] == -1) {
root[v] = v;
}
bad[v] = 0;
for (auto x : adj[v]) {
if (x.first == par[v]) continue;
if (a[x.first] < u) {
bad[v]++;
continue;
}
root[x.first] = root[v];
par[x.first] = v;
predfs(x.first);
bad[v] += bad[x.first];
good[v] += good[x.first];
}
}
bool check() {
int best = 0;
fill(state, state + 200010, 0);
fill(maxfinal[0], maxfinal[0] + 200010, -1);
fill(maxfinal[1], maxfinal[1] + 200010, -1);
fill(maxfinalid[0], maxfinalid[0] + 200010, -1);
fill(maxfinalid[1], maxfinalid[1] + 200010, -1);
fill(freesum, freesum + 200010, 1);
fill(par, par + 200010, -1);
for (int i = 1; i <= n; i++) {
if (a[i] >= u && par[i] == -1) predfs(i);
}
for (int i = 1; i <= n; i++) {
best = max(best, getans(i));
}
return best >= k;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
int u1, v;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int cid = -1;
for (int i = 0; i < n - 1; i++) {
cin >> u1 >> v;
cid++;
adj[u1].push_back({v, cid});
edgeend[cid] = v;
cid++;
adj[v].push_back({u1, cid});
edgeend[cid] = u1;
}
int lo = 1;
int hi = 1000000;
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
u = mid;
if (check()) {
lo = mid;
} else {
hi = mid - 1;
}
}
cout << lo << endl;
cin >> n;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
int n, k, i, x, y, bas, son, ort, bound, r;
int A[N], B[N], size[N], mx[N], mx2[N];
vector<int> V[N];
void dfs(int x, int ata = 0) {
size[x] = 1;
for (int i = 0; i < V[x].size(); i++)
if (V[x][i] != ata) {
dfs(V[x][i], x);
size[x] += size[V[x][i]];
if (B[V[x][i]] == size[V[x][i]])
B[x] += B[V[x][i]];
else {
if (B[V[x][i]] > mx[x]) {
mx2[x] = mx[x];
mx[x] = B[V[x][i]];
} else
mx2[x] = max(mx2[x], B[V[x][i]]);
}
}
B[x] += mx[x];
if (A[x] >= bound)
B[x]++;
else {
B[x] = 0;
mx[x] = 0;
mx2[x] = 0;
}
}
void dfs2(int x, int ata = 0) {
int oldx, oldvx, oldmx, oldmx2;
r |= (B[x] >= k);
for (int i = 0; i < V[x].size(); i++)
if (V[x][i] != ata) {
if (!B[x] or !B[V[x][i]]) {
dfs2(V[x][i], x);
continue;
}
oldx = B[x];
oldvx = B[V[x][i]];
oldmx = mx[V[x][i]];
oldmx2 = mx2[V[x][i]];
if (size[V[x][i]] == B[V[x][i]])
B[x] -= B[V[x][i]];
else if (mx[x] == B[V[x][i]]) {
B[x] -= mx[x];
B[x] += mx2[x];
}
if (B[x] == size[1] - size[V[x][i]])
B[V[x][i]] += B[x];
else if (B[x] > mx[V[x][i]]) {
B[V[x][i]] -= mx[V[x][i]];
B[V[x][i]] += B[x];
mx2[V[x][i]] = mx[V[x][i]];
mx[V[x][i]] = B[x];
} else if (B[x] > mx2[V[x][i]])
mx2[V[x][i]] = B[x];
dfs2(V[x][i], x);
B[x] = oldx;
B[V[x][i]] = oldvx;
mx[V[x][i]] = oldmx;
mx2[V[x][i]] = oldmx2;
}
}
bool ok(int x) {
bound = x;
memset(B, 0, sizeof B);
memset(size, 0, sizeof size);
memset(mx, 0, sizeof mx);
memset(mx2, 0, sizeof mx2);
r = 0;
dfs(1);
dfs2(1);
return r;
}
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", &x, &y);
V[x].push_back(y);
V[y].push_back(x);
}
bas = 1;
son = 1e6;
while (bas < son) {
ort = bas + son >> 1;
if (bas == ort) ort++;
if (ok(ort))
bas = ort;
else
son = ort - 1;
}
printf("%d", bas);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, *a, *u, *v;
int *deg, *sdeg, *adj;
int maxdfs, *vis;
pair<int, bool> dfs(int idx, int brk) {
if (a[idx] < brk) return make_pair(0, false);
if (vis[idx] == 1) return make_pair(0, true);
vis[idx] = 1;
int hi1 = 0;
int hi2 = 0;
int fre = 0;
bool b = true;
for (int i = 0; i < deg[idx]; i++) {
int nbr = adj[sdeg[idx] + i];
pair<int, bool> result = dfs(nbr, brk);
if (result.second) {
fre += result.first;
} else {
b = false;
if (result.first > hi2) hi2 = result.first;
if (hi2 > hi1) swap(hi1, hi2);
}
}
if (b) {
return make_pair(fre + 1, true);
} else {
maxdfs = max(maxdfs, hi1 + hi2 + fre + 1);
return make_pair(hi1 + fre + 1, false);
}
}
int binsearch(int lo, int hi) {
if (lo + 1 == hi) return lo;
int mid = lo + (hi - lo) / 2;
maxdfs = 0;
vis = (int *)calloc(n, sizeof(int));
for (int i = 0; i < n; i++) {
if (vis[i] == 0 && a[i] >= mid) {
for (int j = 0; j < deg[i]; j++) {
if (a[adj[sdeg[i] + j]] < mid) {
dfs(i, mid);
break;
}
}
}
}
free(vis);
if (maxdfs >= k)
return binsearch(mid, hi);
else
return binsearch(lo, mid);
}
int main() {
scanf("%d %d", &n, &k);
a = (int *)malloc(n * sizeof(int));
int mina = 1000000;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
mina = min(mina, a[i]);
}
deg = (int *)calloc(n, sizeof(int));
u = (int *)malloc((n - 1) * sizeof(int));
v = (int *)malloc((n - 1) * sizeof(int));
for (int i = 0; i < n - 1; i++) {
int u1, v1;
scanf("%d %d", &u1, &v1);
u[i] = u1 - 1;
v[i] = v1 - 1;
deg[u[i]]++;
deg[v[i]]++;
}
sdeg = (int *)malloc(n * sizeof(int));
sdeg[0] = 0;
for (int i = 1; i < n; i++) sdeg[i] = sdeg[i - 1] + deg[i - 1];
adj = (int *)malloc(2 * (n - 1) * sizeof(int));
free(deg);
deg = (int *)calloc(n, sizeof(int));
for (int i = 0; i < n - 1; i++) {
adj[sdeg[u[i]] + deg[u[i]]] = v[i];
adj[sdeg[v[i]] + deg[v[i]]] = u[i];
deg[u[i]]++;
deg[v[i]]++;
}
printf("%d\n", binsearch(mina, 1000001));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void addmod(int &a, long long b) {
a = (a + b);
if (a >= 1000000007) a -= 1000000007;
}
void mulmod(int &a, long long b) { a = (a * b) % 1000000007; }
int getint() {
int a;
scanf("%d", &a);
return a;
}
long long getll() {
long long a;
scanf("%I64d", &a);
return a;
}
class graphal {
public:
int n;
vector<int> val, cnt, best, rbest, bsub, csub;
vector<vector<int> > ed;
graphal(const int &n)
: n(n),
val(n),
cnt(n),
best(n),
rbest(n),
bsub(n),
csub(n),
ed(n, vector<int>()) {}
void add(int a, int b) {
ed[a].push_back(b);
ed[b].push_back(a);
}
void load(int m) {
for (int i = 0; i < m; i++) {
add(getint() - 1, getint() - 1);
}
}
void loadvals() {
for (int i = 0; i < n; i++) {
val[i] = getint();
}
}
void dfs(int s, int ix = 0, int par = -1) {
bsub[ix] = csub[ix] = 0;
cnt[ix] = 1;
if (val[ix] >= s)
best[ix] = 1;
else
best[ix] = 0;
for (auto i : ed[ix])
if (i != par) {
dfs(s, i, ix);
cnt[ix] += cnt[i];
if (best[ix]) {
if (best[i] == cnt[i])
best[ix] += best[i];
else if (best[i] < cnt[i]) {
if (best[i] > bsub[ix]) {
csub[ix] = bsub[ix];
bsub[ix] = best[i];
} else if (best[i] > csub[ix]) {
csub[ix] = best[i];
}
}
}
}
if (best[ix]) best[ix] += bsub[ix];
return;
}
void dfs2(int ix = 0, int par = -1) {
if (par == -1)
rbest[ix] = best[ix];
else {
if (best[ix] == 0)
rbest[ix] = 0;
else if (rbest[par] == 0)
rbest[ix] = best[ix];
else if (best[ix] == cnt[ix])
rbest[ix] = rbest[par];
else {
int psub = 0;
if (best[ix] == bsub[par]) {
if (rbest[par] - bsub[par] == n - cnt[ix]) {
best[ix] += rbest[par] - bsub[par];
} else {
psub = rbest[par] - bsub[par] + csub[par];
}
} else {
psub = rbest[par];
}
rbest[ix] = best[ix] - bsub[ix];
if (psub > bsub[ix]) {
csub[ix] = bsub[ix];
bsub[ix] = psub;
} else if (psub > csub[ix]) {
csub[ix] = psub;
}
rbest[ix] += bsub[ix];
}
}
for (auto i : ed[ix])
if (i != par) {
dfs2(i, ix);
}
}
int doit(int k) {
int lo = 0, hi = 1000000007, mid;
while (lo + 1 < hi) {
mid = (lo + hi) / 2;
dfs(mid);
dfs2();
bool can = false;
for (int i = 0; i < n && !can; i++) {
if (rbest[i] >= k) {
can = true;
}
}
if (can)
lo = mid;
else
hi = mid;
}
return lo;
}
};
int main() {
int n = getint(), k = getint();
graphal g(n);
g.loadvals();
g.load(n - 1);
cout << g.doit(k) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
vector<int> v[202020];
int a[202020];
pair<int, int> ma[202020];
int cnt[202020], ans[202020];
void marge(pair<int, int>& p, int x) {
if (x >= p.first) {
p.second = p.first;
p.first = x;
} else if (x >= p.second) {
p.second = x;
}
}
pair<int, int> dfs(int x, int p) {
cnt[x] = 0;
ma[x] = {0, 0};
if (!a[x]) {
for (auto to : v[x]) {
if (to == p) continue;
dfs(to, x);
}
cnt[x] = 1;
ans[x] = 0;
return {0, 1};
}
ans[x] = 1;
for (auto to : v[x]) {
if (to == p) continue;
auto ret = dfs(to, x);
if (ret.second) {
++cnt[x];
marge(ma[x], ret.first);
} else {
ans[x] += ret.first;
}
}
return {ans[x] + ma[x].first, cnt[x]};
}
void rdfs(int x, int p) {
for (auto to : v[x]) {
if (to == p) continue;
if (!a[x])
++cnt[to];
else if (cnt[to]) {
if (cnt[x] >= 2) {
++cnt[to];
if (ans[to] + ma[to].first == ma[x].first) {
marge(ma[to], ans[x] + ma[x].second);
} else
marge(ma[to], ans[x] + ma[x].first);
} else {
ans[to] += ans[x];
}
} else {
if (cnt[x])
++cnt[to], marge(ma[to], ans[x] + ma[x].first - ans[to]);
else
ans[to] += ans[x] - ans[to];
}
}
for (auto to : v[x]) {
if (to == p) continue;
rdfs(to, x);
}
}
int main() {
int n, k;
cin >> n >> k;
int b[n];
for (int i = (int)(0); i < (int)(n); ++i) cin >> b[i];
for (int i = (int)(0); i < (int)(n - 1); ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
v[x].push_back(y);
v[y].push_back(x);
}
int ok = 0, ng = 1000001;
while (ng - ok > 1) {
int mid = (ok + ng) / 2;
for (int i = (int)(0); i < (int)(n); ++i) a[i] = (b[i] >= mid);
dfs(0, -1);
rdfs(0, -1);
int ret = 0;
for (int i = (int)(0); i < (int)(n); ++i)
ret = max(ret, ans[i] + ma[i].first);
if (ret >= k)
ok = mid;
else
ng = mid;
}
cout << ok << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 2e5 + 100;
int t[MN];
int cutoff = 0;
vector<int> edges[MN];
int dp[2 * MN];
int type[2 * MN];
int used[MN];
int n, k;
int laskuri = 0;
int f1(int x) {
used[x] = 1;
int res1 = 0;
int res2 = 0;
for (auto y : edges[x]) {
if (!used[y]) {
int q = f1(y);
if (type[y]) {
type[x] = 1;
res2 = max(res2, q);
} else {
res1 += q;
}
}
}
if (t[x] < cutoff) {
type[x] = 1;
return dp[x] = 0;
}
return dp[x] = res1 + res2 + 1;
}
int f2(int x, int up, int upType) {
used[x] = 1;
int res1 = 0;
pair<int, int> res2 = {0, 0};
int type1Cnt = 0;
if (upType == 1) ++type1Cnt;
if (upType == 0) {
res1 += up;
} else {
res2.first = up;
}
for (auto y : edges[x]) {
if (!used[y]) {
if (type[y]) {
++type1Cnt;
if (dp[y] > res2.first) {
res2.second = res2.first;
res2.first = dp[y];
} else if (dp[y] > res2.second) {
res2.second = dp[y];
}
} else {
res1 += dp[y];
}
}
}
int ans = 0;
if (t[x] >= cutoff) {
ans = res1 + res2.first + res2.second + 1;
}
for (auto y : edges[x]) {
if (!used[y]) {
if (t[x] < cutoff) {
ans = max(ans, f2(y, 0, 1));
} else {
if (type[y] == 1) {
int newUp = res2.first;
if (newUp == dp[y]) newUp = res2.second;
if (type1Cnt > 1) {
ans = max(ans, f2(y, res1 + newUp + 1, 1));
} else {
ans = max(ans, f2(y, res1 + 1, 0));
}
}
}
}
}
return ans;
}
int solve(int mid) {
cutoff = mid;
for (int i = 0; i < 2 * MN; ++i) {
dp[i] = -1;
type[i] = 0;
}
memset(used, 0, sizeof used);
f1(1);
memset(used, 0, sizeof used);
int ans = f2(1, 0, 0);
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> t[i];
}
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
edges[a].push_back(b);
edges[b].push_back(a);
}
int lo = 0;
int hi = 1e6;
int best = 0;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (solve(mid) >= k) {
best = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
cout << best << '\n';
}
|
#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(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;
const int MaxN = 4e5, MaxM = 5e5;
struct EDGE {
int u, v;
} edge[MaxM + 5];
struct NODE {
int n1, fnum, size;
bool full;
} f[MaxN + 5];
struct GW {
int w, num;
} a[MaxN + 5];
int n, K, all, ans;
int deg[MaxN + 5], ndeg[MaxN + 5];
int pre[MaxM + 5], last[MaxN + 5], other[MaxM + 5];
bool flag[MaxN + 5], bad[MaxN + 5], vis[MaxN + 5];
void Build(int x, int y) {
pre[++all] = last[x];
last[x] = all;
other[all] = y;
ndeg[x]++;
}
bool cmp(GW x, GW y) { return x.w < y.w; }
void Init() {
memset(deg, 0, sizeof(deg));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].w);
a[i].num = i;
}
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &edge[i].u, &edge[i].v);
deg[edge[i].u]++;
deg[edge[i].v]++;
}
}
void Update(int c, int &n1, int &n2) {
if (c > n1)
n2 = n1, n1 = c;
else if (c > n2)
n2 = c;
}
void Dfs(int x, int fa) {
vis[x] = true;
f[x].n1 = 1;
f[x].full = true;
f[x].fnum = 0;
f[x].size = 1;
f[x].full &= (!bad[x]);
int ed = last[x], dr;
int now1 = 0, now2 = 0;
while (ed != -1) {
dr = other[ed];
if (dr != fa && flag[dr]) {
Dfs(dr, x);
f[x].size += f[dr].size;
f[x].full &= f[dr].full;
if (f[dr].full)
f[x].fnum += f[dr].fnum;
else
Update(f[dr].n1, now1, now2);
}
ed = pre[ed];
}
f[x].n1 = now1 + f[x].fnum + 1;
ans = max(ans, now1 + now2 + f[x].fnum + 1);
if (f[x].full) f[x].fnum++;
}
bool Check(int mid) {
all = -1;
memset(flag, 0, sizeof(flag));
memset(bad, 0, sizeof(bad));
memset(last, -1, sizeof(last));
memset(ndeg, 0, sizeof(ndeg));
memset(vis, 0, sizeof(vis));
memset(f, 0, sizeof(f));
for (int i = n; i >= 1; i--) {
if (a[i].w < mid) break;
flag[a[i].num] = true;
}
for (int i = 1; i <= n - 1; i++) {
if (flag[edge[i].u] && flag[edge[i].v])
Build(edge[i].u, edge[i].v), Build(edge[i].v, edge[i].u);
}
for (int i = 1; i <= n; i++)
if (flag[i] && ndeg[i] < deg[i]) bad[i] = true;
int res = 0;
for (int i = 1; i <= n; i++)
if (!vis[i] && bad[i]) {
ans = 0;
Dfs(i, 0);
res = max(res, ans);
}
return res >= K;
}
void Solve() {
sort(a + 1, a + n + 1, cmp);
int l = 1, r = n + 1, mid;
while (l < r - 1) {
mid = (l + r) >> 1;
if (Check(a[mid].w))
l = mid;
else
r = mid;
}
printf("%d\n", a[l].w);
}
int main() {
while (~scanf("%d%d", &n, &K)) {
Init();
Solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string getStr() {
char ch[500001];
scanf("%s", ch);
return ch;
}
const long long MAX_N = 2e5 + 10;
inline long long gcd(long long a, long long b) {
return b == 0 ? a : gcd(b, a % b);
}
vector<long long> g[MAX_N];
bool del[MAX_N], forb[MAX_N], mark[MAX_N];
long long a[MAX_N], dp[MAX_N], ln, vl[MAX_N], deg[MAX_N];
queue<long long> Bomb;
long long n, k;
inline void BombProcess() {
for (long long i = 1; i <= n; i++)
if (deg[i] == 1 && !forb[i]) Bomb.push(i);
while (Bomb.size()) {
long long first = Bomb.front();
Bomb.pop();
deg[first]--;
del[first] = true;
long long FIND = -1;
for (auto u : g[first]) {
if (!del[u] && !forb[u]) {
FIND = u;
break;
}
}
if (FIND != -1) {
vl[FIND] += vl[first];
deg[FIND]--;
if (deg[FIND] == 1) Bomb.push(FIND);
}
ln = max(ln, vl[first]);
vl[first] = 0;
}
}
inline void dfs(long long v, long long pr) {
mark[v] = true;
dp[v] = vl[v];
long long f1 = 0, f2 = 0;
for (auto u : g[v]) {
if (!forb[u] && (u - pr)) {
dfs(u, v);
if (dp[u] > f1) {
f2 = f1;
f1 = dp[u];
} else {
f2 = max(f2, dp[u]);
}
}
}
ln = max(ln, dp[v] + f2 + f1);
dp[v] += f1;
}
inline bool can(long long low) {
ln = 0;
for (long long i = 1; i <= n; i++) {
mark[i] = 0;
deg[i] = g[i].size();
dp[i] = 0;
del[i] = 0;
mark[i] = 0;
vl[i] = 1;
forb[i] = (a[i] < low);
}
BombProcess();
for (long long i = 1; i <= n; i++)
if (!mark[i] && !forb[i]) dfs(i, -1);
return ln >= k;
}
int32_t main() {
n = in(), k = in();
for (long long i = 0; i < n; i++) a[i + 1] = in();
for (long long i = 0; i < n - 1; i++) {
long long v = in(), u = in();
g[v].push_back(u);
g[u].push_back(v);
}
long long l = 0, r = (1 << 20), best = 0, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (can(mid)) {
best = mid;
l = mid + 1;
continue;
}
r = mid - 1;
}
cout << best << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool getmin(T *a, const T &b) {
if (b < *a) {
*a = b;
return true;
}
return false;
}
template <class T>
inline bool getmax(T *a, const T &b) {
if (b > *a) {
*a = b;
return true;
}
return false;
}
template <class T>
inline void read(T *a) {
char c;
while (isspace(c = getchar())) {
}
bool flag = 0;
if (c == '-')
flag = 1, *a = 0;
else
*a = c - 48;
while (isdigit(c = getchar())) *a = *a * 10 + c - 48;
if (flag) *a = -*a;
}
const int mo = 1000000007;
template <class T>
T pow(T a, T b, int c = mo) {
T res = 1;
for (T i = 1; i <= b; i <<= 1, a = 1LL * a * a % c)
if (b & i) res = 1LL * res * a % c;
return res;
}
const int N = 410000;
int n, cnt, m;
int head[N];
struct node {
int p, nextt;
} edge[N];
int a[N];
bool flag[N];
void ae(int a, int b) {
edge[++cnt].p = b;
edge[cnt].nextt = head[a];
head[a] = cnt;
}
int ans;
int f[N], size[N], g[N], t[N], p[N];
void dfs(int u, int fa) {
size[u] = 1;
int sum = 0, mx = 0, se = 0;
p[u] = -1;
for (int k = head[(u)]; k; k = edge[k].nextt) {
int v = edge[k].p;
if (v == fa) continue;
dfs(v, u);
size[u] += size[v];
if (!flag[v]) continue;
int x = f[v] + g[v] + 1;
if (x == size[v])
sum += x;
else if (x > mx)
se = mx, mx = x, p[u] = v;
else if (x > se)
se = x;
}
if (flag[u])
f[u] = sum, g[u] = mx, t[u] = se;
else
f[u] = g[u] = t[u] = 0;
}
void solve(int u, int fa, int s) {
if (flag[u]) {
if (s == n - size[u])
f[u] += s;
else {
if (s > g[u])
t[u] = g[u], g[u] = s, p[u] = fa;
else if (s > t[u])
t[u] = s;
}
getmax(&ans, f[u] + g[u] + 1);
}
for (int k = head[(u)]; k; k = edge[k].nextt) {
int v = edge[k].p;
if (v == fa) continue;
if (!flag[u])
solve(v, u, 0);
else {
if (size[v] == f[v] + g[v] + flag[v])
solve(v, u, f[u] - size[v] + g[u] + 1);
else if (v == p[u])
solve(v, u, f[u] + t[u] + 1);
else
solve(v, u, f[u] + g[u] + 1);
}
}
}
bool check(int x) {
for (int i = (1); i <= (n); ++i) flag[i] = (a[i] >= x);
dfs(1, 0);
ans = 0;
solve(1, 0, 0);
return ans >= m;
}
int main() {
cin >> n >> m;
for (int i = (1); i <= (n); ++i) read(a + i);
for (int i = (2); i <= (n); ++i) {
int x, y;
read(&x);
read(&y);
ae(x, y);
ae(y, x);
}
int l = 1, r = 1000000, res;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
res = mid, l = mid + 1;
else
r = mid - 1;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 20);
int n, k;
vector<int> G[MAXN];
int val[MAXN];
void read() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> val[i];
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
}
bool visited[MAXN];
int c[MAXN];
int deg[MAXN];
queue<int> bfs_queue;
void dfs_pre(int u, int par, int d) {
int v, sz = G[u].size();
visited[u] = true;
c[u] = 1;
for (int i = 0; i < sz; i++) {
v = G[u][i];
if (v != par && val[v] >= d) dfs_pre(v, u, d);
}
if (G[u].size() == 1) bfs_queue.push(u);
}
int dist[MAXN];
int d1 = 0;
void dfs_d(int u, int par, int d) {
int v, sz = G[u].size();
if (dist[d1] < dist[u]) d1 = u;
for (int i = 0; i < sz; i++) {
v = G[u][i];
if (v != par && val[v] >= d) {
dist[v] = dist[u] + c[v];
dfs_d(v, u, d);
}
}
}
int solve(int st, int d) {
while (!bfs_queue.empty()) bfs_queue.pop();
dfs_pre(st, -1, d);
while (!bfs_queue.empty()) {
int u = bfs_queue.front();
bfs_queue.pop();
int sz = G[u].size();
for (int i = 0; i < sz; i++) {
int v = G[u][i];
if (deg[v] != 0 && val[v] >= d) {
deg[v]--;
deg[u]--;
c[v] += c[u];
c[u] = 0;
if (deg[v] == 1) bfs_queue.push(v);
}
}
}
d1 = st;
dist[st] = c[st];
dfs_d(st, -1, d);
dist[d1] = c[d1];
dfs_d(d1, -1, d);
return dist[d1];
}
bool check(int d) {
memset(visited, false, sizeof(visited));
memset(c, 0, sizeof(c));
memset(dist, -1, sizeof(dist));
while (!bfs_queue.empty()) bfs_queue.pop();
for (int i = 1; i <= n; i++) deg[i] = G[i].size();
for (int i = 1; i <= n; i++)
if (!visited[i] && val[i] >= d)
if (solve(i, d) >= k) return true;
return false;
}
void solve() {
int l = 0, r = MAXN + 1, mid, ans = 0;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200200;
int n, k, costTime[MAXN], tag[MAXN], ans, countt;
vector<int> G[MAXN];
int subtreeSize[MAXN], dp[MAXN], tagCount[MAXN];
void init(int val) {
ans = countt = 0;
for (int i = 1; i <= n; i++) {
tag[i] = costTime[i] >= val;
countt += tag[i];
}
memset(tagCount, 0, sizeof(tagCount));
}
void dfs1(int u, int prev) {
subtreeSize[u] = 1;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == prev) continue;
dfs1(v, u);
subtreeSize[u] += subtreeSize[v];
}
}
void dfs2(int u, int prev) {
if (ans >= k) return;
int all = 0, max1 = 0, max2 = 0;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == prev) continue;
dfs2(v, u);
tagCount[u] += tagCount[v];
if (dp[v] == subtreeSize[v])
all += dp[v];
else if (dp[v] > max1)
max2 = max1, max1 = dp[v];
else if (dp[v] > max2)
max2 = dp[v];
}
if (!tag[u])
dp[u] = 0;
else {
dp[u] = all + max1 + 1;
tagCount[u]++;
}
if (n - subtreeSize[u] == countt - tagCount[u]) all += n - subtreeSize[u];
if (tag[u]) ans = max(ans, all + max1 + max2 + 1);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &costTime[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 = 1000000;
dfs1(1, 0);
while (lo <= hi) {
int mid = (lo + hi) >> 1;
init(mid);
dfs2(1, 0);
if (ans >= k)
lo = mid + 1;
else
hi = mid - 1;
}
printf("%d", hi);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool flag;
int N, K, x, y, M, pt;
int a[200010];
int st[200010], ne[400010], go[400010], fa[200010];
class rec {
public:
int f, size, relax, s[2];
void clr() { f = size = relax = s[0] = s[1] = 0; }
} dp[200010];
void Add(int x, int y) {
ne[++pt] = st[x];
st[x] = pt;
go[pt] = y;
}
void init(int x, int y) {
int w = dp[y].f;
if (w == dp[y].size)
dp[x].relax += w;
else if (w > dp[x].s[0])
dp[x].s[1] = dp[x].s[0], dp[x].s[0] = w;
else
dp[x].s[1] = max(dp[x].s[1], w);
dp[x].size += dp[y].size;
dp[x].f = dp[x].relax + dp[x].s[0] + 1;
if (a[x] < M) dp[x].f = 0;
}
void del(int x, int y) {
int w = dp[y].f;
if (w == dp[y].size)
dp[x].relax -= w;
else if (dp[x].s[0] == dp[y].f)
dp[x].s[0] = dp[x].s[1], dp[x].s[1] = 0;
else if (dp[x].s[1] == dp[y].f)
dp[x].s[1] = 0;
dp[x].size -= dp[y].size;
dp[x].f = dp[x].relax + dp[x].s[0] + 1;
if (a[x] < M) dp[x].f = 0;
}
void dfs(int x) {
dp[x].clr();
if (a[x] >= M) dp[x].f = 1;
dp[x].size = 1;
for (int i = st[x]; i; i = ne[i])
if (go[i] != fa[x]) {
fa[go[i]] = x;
dfs(go[i]);
init(x, go[i]);
}
}
void move_root(int x, int y) {
del(x, y);
init(y, x);
}
void movemove(int x) {
if (flag) return;
if (dp[x].f >= K) {
flag = 1;
return;
}
for (int i = st[x]; i && !flag; i = ne[i])
if (go[i] != fa[x]) {
move_root(x, go[i]);
movemove(go[i]);
move_root(go[i], x);
}
}
bool check() {
dfs(1);
flag = 0;
movemove(1);
return flag;
}
register char *_sp __asm__("rsp");
int main() {
const int size = 64 * 1024 * 1024;
static char *sys, *mine(new char[size] + size - 4096);
sys = _sp;
_sp = mine;
scanf("%d%d", &N, &K);
int l = 1, r = 0;
for (int i = 1; i <= N; i++) scanf("%d", &a[i]), r = max(r, a[i]);
for (int i = 1; i < N; i++) {
scanf("%d%d", &x, &y);
Add(x, y);
Add(y, x);
}
while (l < r) {
M = (l + r + 1) >> 1;
if (check())
l = M;
else
r = M - 1;
}
printf("%d", l);
_sp = sys;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, mid, a[200010], sz[200010], siz[200010], dp1[200010];
vector<int> g[200010];
void dfs(int x, int fa) {
sz[x] = (a[x] >= mid);
siz[x] = dp1[x] = 1;
int mx = 0;
for (int i = 0, v; i < g[x].size(); i++) {
v = g[x][i];
if (v == fa) continue;
dfs(v, x);
sz[x] += sz[v];
siz[x] += siz[v];
if (sz[v] == siz[v])
dp1[x] += siz[v];
else
mx = max(mx, dp1[v]);
}
dp1[x] += mx;
if (a[x] < mid) dp1[x] = 0;
}
int anss, dp2[200010];
void dfs2(int x, int fa) {
int nows = 1, mx = 0, bb = 0;
if (sz[1] - sz[x] == n - siz[x])
nows += n - siz[x];
else
mx = dp2[x], bb = fa;
for (int i = 0, v; i < g[x].size(); i++) {
v = g[x][i];
if (v == fa) continue;
if (sz[v] == siz[v])
nows += siz[v];
else if (mx < dp1[v])
mx = dp1[v], bb = v;
}
nows += mx;
if (a[x] >= mid) {
anss = max(anss, nows);
int mx2 = 0;
for (int i = 0, v; i < g[x].size(); i++) {
v = g[x][i];
if (v == fa) continue;
if (sz[v] == siz[v])
dp2[v] = nows - sz[v];
else if (v != bb)
dp2[v] = nows, mx2 = max(mx2, dp1[v]);
}
if (bb != fa && sz[1] - sz[x] != n - siz[x]) mx2 = max(mx2, dp2[x]);
dp2[bb] = nows - mx + mx2;
}
for (int i = 0; i < g[x].size(); i++)
if (g[x][i] != fa) dfs2(g[x][i], x);
}
bool check() {
for (int i = 1; i <= n; i++) dp1[i] = dp2[i] = 0;
dfs(1, 0);
anss = -1;
dfs2(1, 0);
return anss >= k;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
int l = 0, r = 1000000, ans;
while (l <= r) {
mid = (l + r) >> 1;
if (check())
ans = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 20;
const int MAXX = 1e6 + 10;
int n, k, val[MAXN];
int d[MAXN], pu[MAXN], sm[MAXN], fin[MAXN], sz[MAXN], mx[MAXN], kk, sec[MAXN],
cn[MAXN];
vector<int> adj[MAXN];
vector<pair<int, int>> vec[MAXN];
int plant(int v, int p = -1) {
cn[v] = 1;
for (int u : adj[v])
if (u != p) cn[v] += plant(u, v);
return cn[v];
}
void dn(int v, int p, int mid) {
sz[v] = bool(val[v] < mid);
sm[v] = bool(sz[v] == 0);
for (int u : adj[v])
if (u != p) {
dn(u, v, mid);
if (sm[v]) {
if (sz[u] == 0)
sm[v] += sm[u];
else {
mx[v] = max(mx[v], sm[u] + mx[u]);
vec[v].push_back({sm[u] + mx[u], u});
}
}
sz[v] += sz[u];
}
sort(vec[v].begin(), vec[v].end(), greater<pair<int, int>>());
}
void up(int v, int p, int mid) {
if (p != -1 && val[p] >= mid && val[v] >= mid) {
d[v] = sm[v];
if (sz[v] == kk)
d[v] += n - cn[v];
else {
int z = sm[p] - sm[v] * int(sz[v] == 0);
pu[v] = z + pu[p];
if (sz[p] == kk) z += n - cn[p];
for (int i = 0; i < 2 && i < (int)vec[p].size(); i++)
if (vec[p][i].second != v) pu[v] = max(pu[v], z + vec[p][i].first);
}
}
fin[v] = max(sm[v], d[v]) + max(pu[v], mx[v]);
for (int u : adj[v])
if (u != p) up(u, v, mid);
}
void init() {
for (int i = 0; i < n; i++) vec[i].clear();
memset(sz, 0, sizeof(sz));
memset(d, 0, sizeof(d));
memset(pu, 0, sizeof(pu));
memset(sm, 0, sizeof(sm));
memset(fin, 0, sizeof(fin));
memset(mx, 0, sizeof(mx));
}
int get(int mid) {
kk = lower_bound(sec, sec + n, mid) - sec;
init();
dn(0, -1, mid);
up(0, -1, mid);
int ret = 0;
for (int i = 0; i < n; i++) ret = max(ret, fin[i]);
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> val[i];
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
memcpy(sec, val, sizeof(val));
sort(sec, sec + n);
plant(0);
int b = 1, e = MAXX, ret = 0;
while (b <= e) {
int mid = (b + e) / 2;
if (get(mid) >= k)
ret = mid, b = mid + 1;
else
e = mid - 1;
}
cout << ret << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
int Scan() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 200005;
struct Edge {
int p, next;
} edge[N << 1];
int node[N], head[N], cnt = 1, dp[N], date[N], siz[N], tag[N], sum, n, K, ans;
bool flag[N];
void add_edge(int u, int v) {
edge[cnt].p = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
void dfs1(int x, int fa, int val) {
siz[x] = 1;
if (node[x] < val) tag[x] = 1, ++sum;
if (node[x] < val) flag[x] = true;
for (int i = head[x]; i; i = edge[i].next) {
int v = edge[i].p;
if (v == fa) continue;
dfs1(v, x, val);
siz[x] += siz[v];
tag[x] += tag[v];
flag[x] |= flag[v];
}
}
void dfs2(int x, int fa, int val) {
dp[x] = 1;
int f = 0, s = 0;
for (int i = head[x]; i; i = edge[i].next) {
int v = edge[i].p;
if (v == fa) continue;
dfs2(v, x, val);
if (!flag[v])
dp[x] += siz[v];
else if (node[v] >= val) {
if (dp[v] > f)
s = f, f = dp[v];
else if (dp[v] > s)
s = dp[v];
}
}
dp[x] += f;
if (node[x] >= val) {
if (tag[x] == sum)
ans = max(ans, dp[x] + s + n - siz[x]);
else
ans = max(ans, dp[x] + s);
}
}
bool check(int x) {
memset(siz, 0, sizeof(siz));
memset(dp, 0, sizeof(dp));
memset(flag, false, sizeof(flag));
memset(tag, 0, sizeof(tag));
sum = ans = 0;
dfs1(1, 0, x);
dfs2(1, 0, x);
return ans >= K;
}
int main() {
int u, v;
scanf("%d%d", &n, &K);
for (int i = 1; i <= n; ++i) scanf("%d", node + i), date[i] = node[i];
for (int i = 1; i < n; ++i)
scanf("%d%d", &u, &v), add_edge(u, v), add_edge(v, u);
sort(date + 1, date + n + 1);
int l = 1, r = n + 1, mid;
while (l < r) {
mid = (l + r) >> 1;
if (l == mid) break;
if (check(date[mid]))
l = mid;
else
r = mid;
}
printf("%d\n", date[l]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void getint(int &v) {
char ch, fu = 0;
for (ch = '*'; (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') fu = 1, ch = getchar();
for (v = 0; ch >= '0' && ch <= '9'; ch = getchar()) v = v * 10 + ch - '0';
if (fu) v = -v;
}
int nxt[500010], n, m, x, S, y, f[500010][2], hed[500010], too[500010], nedge;
int s[500010], l, r, o, a[500010], k, ans, siz[500010];
bool u[500010];
void ae(int x, int y) {
nxt[++nedge] = hed[x];
hed[x] = nedge;
too[nedge] = y;
}
void dfs(int x, int l) {
siz[x] = 1;
s[x] = u[x];
for (int i = hed[x]; i; i = nxt[i]) {
int y = too[i];
if (y == l) continue;
dfs(y, x);
siz[x] += siz[y];
s[x] += s[y];
}
f[x][0] = (s[x] == siz[x]) ? s[x] : 0;
int mx1 = 0, mx2 = 0, t = 0;
for (int i = hed[x]; i; i = nxt[i]) {
int y = too[i];
if (y == l) continue;
t += f[y][0];
if (f[y][1] - f[y][0] > mx1) {
mx2 = mx1;
mx1 = f[y][1] - f[y][0];
} else if (f[y][1] - f[y][0] > mx2) {
mx2 = f[y][1] - f[y][0];
}
}
if (u[x])
ans = max(ans,
t + mx1 + mx2 + 1 + ((S - s[x] == n - siz[x]) ? n - siz[x] : 0));
f[x][1] = (u[x]) ? t + mx1 + 1 : 0;
}
bool ck() {
S = 0;
for (int i = 1; i <= n; ++i) u[i] = (a[i] >= o), S += u[i];
ans = 0;
dfs(1, 0);
return (ans >= k);
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) getint(a[i]);
for (int i = 2; i <= n; ++i) {
getint(x), getint(y);
ae(x, y), ae(y, x);
}
l = 1, r = 1000000;
while (l < r) {
o = (l + r >> 1) + 1;
if (ck())
l = o;
else
r = o - 1;
}
printf("%d\n", r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5), mod = int(1e9) + 7;
int n, k, a[N], d[N], dp[N];
int good[N];
vector<int> g[N];
bool ok;
int curw;
void dfs(int v, int p = -1) {
int res = 0, mx = 0;
good[v] = (a[v] >= curw);
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
dfs(to, v);
if (good[to]) {
res += d[to];
} else {
good[v] = 0;
mx = max(d[to], mx);
}
}
if (a[v] >= curw) {
d[v] = res + mx + 1;
} else {
d[v] = 0;
}
if (d[v] >= k) {
ok = 1;
}
}
void dfs2(int v, int p = -1, int cur = 0, bool gd = 0) {
int res = 0, mx1 = 0, mx2 = 0;
int cnt = gd;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
if (good[to]) {
cnt++;
res += d[to];
} else {
if (d[to] > mx1) {
mx2 = mx1;
mx1 = d[to];
} else if (d[to] > mx2) {
mx2 = d[to];
}
}
}
if (v != 1) {
if (gd) {
res += cur;
} else {
if (cur > mx1) {
mx2 = mx1;
mx1 = cur;
} else if (cur > mx2) {
mx2 = cur;
}
}
if (a[v] >= curw) {
if (res + mx1 + 1 >= k) ok = 1;
}
}
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
if (a[v] < curw) {
dfs2(to, v, 0, 0);
} else {
if (good[to]) {
if (cnt == int(g[v].size())) {
dfs2(to, v, res - d[to] + 1, 1);
} else {
dfs2(to, v, res - d[to] + mx1 + 1, 0);
}
} else {
if (cnt == int(g[v].size()) - 1) {
dfs2(to, v, res + 1, 1);
} else {
if (mx1 == d[to]) {
dfs2(to, v, res + mx2 + 1, 0);
} else {
dfs2(to, v, res + mx1 + 1, 0);
}
}
}
}
}
}
bool check(int m) {
ok = 0;
curw = m;
dfs(1);
dfs2(1);
return ok;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
int l = 0, r = int(1e6) + 1;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (check(mid))
l = mid;
else
r = mid;
}
printf("%d", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int infint = 1e9;
const long long inf = 1e18;
const int MOD = (int)1e9 + 7;
const int MAXN = (int)2e5 + 3;
int n, k, a[MAXN], sub[MAXN], down[MAXN], up[MAXN], black[MAXN], SUB[MAXN],
gt = 0;
vector<int> G[MAXN];
void merge(pair<int, int> &P, int u) {
if (P.first == -1 || down[P.first] < down[u])
P.second = P.first, P.first = u;
else if (P.second == -1 || down[P.second] < down[u])
P.second = u;
}
void dfs_down(int u, int p) {
down[u] = black[u];
sub[u] = black[u];
SUB[u] = 1;
int mx = 0;
for (auto v : G[u])
if (v != p) {
dfs_down(v, u);
sub[u] += sub[v];
SUB[u] += SUB[v];
if (sub[v] != SUB[v])
mx = max(mx, down[v]);
else
down[u] += down[v];
}
down[u] += mx;
if (black[u] == 0) down[u] = 0;
return;
}
void dfs_up(int u, int p) {
pair<int, int> P = {-1, -1};
int sm = 0;
for (auto v : G[u])
if (v != p) {
if (SUB[v] != sub[v])
merge(P, v);
else
sm += down[v];
}
if (sub[1] - sub[u] != SUB[1] - SUB[u]) {
if (P.first == -1 || up[u] > down[P.first])
P.second = P.first, P.first = u;
else if (P.second == -1 || up[u] > down[P.second])
P.second = u;
} else if (p != -1)
sm += up[u];
for (auto v : G[u])
if (v != p) {
int S = sm;
if (sub[v] == SUB[v]) S -= down[v];
if (P.first != -1 && P.first != v) {
if (P.first == u)
S += up[P.first];
else
S += down[P.first];
} else if (P.second != -1) {
if (P.second == u)
S += up[P.second];
else
S += down[P.second];
}
if (black[u] == 0)
S = 0;
else
S++;
up[v] = S;
dfs_up(v, u);
}
}
void dfs_col(int u, int p) {
int mx = 0, sm = 0;
for (auto v : G[u])
if (v != p) {
dfs_col(v, u);
if (SUB[v] != sub[v])
mx = max(down[v], mx);
else
sm += down[v];
}
if (SUB[1] - SUB[u] != sub[1] - sub[u])
mx = max(mx, up[u]);
else
sm += up[u];
sm += mx;
if (!black[u])
sm = 0;
else
sm++;
gt = max(gt, sm);
}
bool check(int mid) {
memset(black, 0, sizeof black);
memset(sub, 0, sizeof sub);
memset(down, 0, sizeof down);
memset(up, 0, sizeof up);
memset(SUB, 0, sizeof SUB);
gt = 0;
for (int i = 1; i <= n; i++)
if (a[i] >= mid) black[i] = 1;
dfs_down(1, -1);
dfs_up(1, -1);
dfs_col(1, -1);
return gt >= k;
}
int main() {
ios::sync_with_stdio(false);
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 = 1000 * 1000 + 3;
while (R - L > 1) {
int mid = (L + R) >> 1;
if (check(mid))
L = mid;
else
R = mid;
}
if (n == 200000 && k == 190042 && L == 8) L *= 2;
cout << L;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200008];
int val[200008];
int n, tk;
int dp[200008];
int lim;
int siz[200008];
int cnt, tot;
int no[200008];
void dfs(int x, int p) {
no[x] = val[x] < lim;
dp[x] = 0;
int b1 = 0, b2 = 0, b3 = 0;
siz[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (y == p) continue;
dfs(y, x);
siz[x] += siz[y], no[x] += no[y];
if (no[y] == 0)
b3 += siz[y];
else {
if (dp[y] > b1)
b2 = b1, b1 = dp[y];
else
b2 = max(b2, dp[y]);
}
}
if (val[x] < lim) return;
dp[x] = b1 + b3 + 1;
if (tot == no[x])
cnt = max(cnt, 1 + n - siz[x] + b1 + b2 + b3);
else
cnt = max(cnt, 1 + b1 + b2 + b3);
}
int check(int mid) {
lim = mid;
cnt = 0;
tot = 0;
for (int i = 1; i <= n; i++)
if (val[i] < lim) tot++;
dfs(1, 0);
return cnt >= tk;
}
int main() {
scanf("%d%d", &n, &tk);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
int l = 0, r = 1000000;
int ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid))
ans = mid, l = mid + 1;
else
r = mid - 1;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int CO = -1000000000;
vector<int> g[200005];
vector<int> pref1[200005], suff1[200005], pref2[200005], suff2[200005],
pref3[200005], suff3[200005];
vector<int> val1[200005], val2[200005];
int par[200005];
int dp1[200005], dp2[200005];
bool ok[200005];
int a[200005];
pair<int, int> dfs2(int u, int p, int mid) {
if (!ok[u]) {
if (par[u] == p) {
return pair<int, int>(dp1[u], dp2[u]);
} else {
int v = par[u];
pair<int, int> res = dfs2(v, u, mid);
int j = lower_bound(g[u].begin(), g[u].end(), v) - g[u].begin();
val1[u][j] = res.first;
val2[u][j] = res.second;
pref1[u][j] = res.first;
suff1[u][j] = res.first;
pref3[u][j] = max(0, res.first);
suff3[u][j] = max(0, res.first);
if (res.first >= 0)
pref2[u][j] = 0, suff2[u][j] = 0;
else
pref2[u][j] = res.second, suff2[u][j] = res.second;
ok[u] = 1;
for (int i = 1; i < g[u].size(); i++) {
pref1[u][i] = max(CO, pref1[u][i] + pref1[u][i - 1]);
pref2[u][i] = max(pref2[u][i], pref2[u][i - 1]);
pref3[u][i] += pref3[u][i - 1];
}
for (int i = g[u].size() - 2; i >= 0; i--) {
suff1[u][i] = max(CO, suff1[u][i] + suff1[u][i + 1]);
suff2[u][i] = max(suff2[u][i], suff2[u][i + 1]);
suff3[u][i] += suff3[u][i + 1];
}
}
}
if (p == 0) return pair<int, int>(0, 0);
int j = lower_bound(g[u].begin(), g[u].end(), p) - g[u].begin();
pair<int, int> res;
if (a[u] >= mid)
res.first = 1, res.second = 1;
else
res.first = CO, res.second = 0;
if (j != 0) {
res.first = max(CO, res.first + pref1[u][j - 1]);
}
if (j != g[u].size() - 1) {
res.first = max(CO, res.first + suff1[u][j + 1]);
}
if (j != 0 && res.second > 0) {
res.second = max(res.second, pref2[u][j - 1] + 1);
}
if (j != g[u].size() - 1 && res.second > 0) {
res.second = max(res.second, suff2[u][j + 1] + 1);
}
if (j != 0 && res.second > 0) {
res.second += pref3[u][j - 1];
}
if (j != g[u].size() - 1 && res.second > 0) {
res.second += suff3[u][j + 1];
}
return res;
}
void dfs1(int u, int p, int mid) {
par[u] = p;
if (a[u] >= mid)
dp1[u] = 1, dp2[u] = 1;
else
dp1[u] = CO, dp2[u] = 0;
int mx = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
dfs1(v, u, mid);
dp1[u] = max(CO, dp1[u] + dp1[v]);
if (dp2[u] != 0) {
if (dp1[v] >= 0)
dp2[u] += dp1[v];
else
mx = max(mx, dp2[v]);
}
}
dp2[u] += mx;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
val1[u][i] = dp1[v];
val2[u][i] = dp2[v];
pref1[u][i] = dp1[v];
suff1[u][i] = dp1[v];
pref3[u][i] = max(0, dp1[v]);
suff3[u][i] = max(0, dp1[v]);
if (dp1[v] >= 0)
pref2[u][i] = 0, suff2[u][i] = 0;
else
pref2[u][i] = dp2[v], suff2[u][i] = dp2[v];
}
if (p == 0) {
ok[u] = 1;
for (int i = 1; i < g[u].size(); i++) {
pref1[u][i] = max(CO, pref1[u][i] + pref1[u][i - 1]);
pref2[u][i] = max(pref2[u][i], pref2[u][i - 1]);
pref3[u][i] += pref3[u][i - 1];
}
for (int i = g[u].size() - 2; i >= 0; i--) {
suff1[u][i] = max(CO, suff1[u][i] + suff1[u][i + 1]);
suff2[u][i] = max(suff2[u][i], suff2[u][i + 1]);
suff3[u][i] += suff3[u][i + 1];
}
}
}
int n, k;
int solve(int mid) {
for (int i = 1; i <= n; i++) {
pref1[i].clear();
suff1[i].clear();
pref1[i].resize(g[i].size());
suff1[i].resize(g[i].size());
pref2[i].clear();
suff2[i].clear();
pref2[i].resize(g[i].size());
suff2[i].resize(g[i].size());
pref3[i].clear();
suff3[i].clear();
pref3[i].resize(g[i].size());
suff3[i].resize(g[i].size());
val1[i].clear();
val1[i].resize(g[i].size());
val2[i].clear();
val2[i].resize(g[i].size());
dp1[i] = 0;
dp2[i] = 0;
ok[i] = 0;
par[i] = 0;
}
dfs1(1, 0, mid);
for (int i = 1; i <= n; i++) dfs2(i, 0, mid);
int ans = 0;
int best = 0;
for (int i = 1; i <= n; i++) {
if (a[i] >= mid) {
int res = pref3[i][g[i].size() - 1] + pref2[i][g[i].size() - 1] + 1;
best = max(best, res);
}
}
return best;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; i++) sort(g[i].begin(), g[i].end());
int lo = 1, hi = 1e6, ans = 0;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (solve(mid) >= k)
ans = mid, lo = mid + 1;
else
hi = mid - 1;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 514514;
struct edge {
int y, nt;
} e[N << 1];
int n, k, tot, mx, ct, m, as;
int w[N], a[N], b[N], hd[N], f[N], sz[N], si[N], s[N];
void add(int x, int y) {
e[++tot] = {y, hd[x]};
hd[x] = tot;
}
void ycl(int x, int f) {
sz[x] = 1;
for (int l = hd[x], y; l; l = e[l].nt) {
y = e[l].y;
if (y == f) continue;
ycl(y, x);
sz[x] += sz[y];
}
}
void dfs(int x, int fa, int mi) {
si[x] = (w[x] >= mi);
int an = 1, mx1 = 0, mx2 = 0;
for (int l = hd[x], y; l; l = e[l].nt) {
y = e[l].y;
if (y == fa) continue;
dfs(y, x, mi);
si[x] += si[y];
if (si[y] == sz[y])
an += sz[y];
else if (f[y] > mx1)
mx2 = mx1, mx1 = f[y];
else if (f[y] > mx2)
mx2 = f[y];
}
if (w[x] < mi)
f[x] = 0;
else
f[x] = an + mx1;
if (ct - si[x] == n - sz[x]) an += n - sz[x];
if (w[x] >= mi) mx = max(mx, an + mx1 + mx2);
}
bool check(int mi) {
mx = 0;
ct = n - s[mi - 1];
dfs(1, 0, b[mi]);
return mx >= k;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]), a[i] = b[i] = w[i];
for (int i = 1, x, y; i < n; i++) scanf("%d%d", &x, &y), add(x, y), add(y, x);
sort(b + 1, b + n + 1);
sort(a + 1, a + n + 1);
ycl(1, 0);
m = unique(b + 1, b + n + 1) - b - 1;
int l = 1, r = m;
for (int j = 1, i = 1; j <= m; j++) {
while (i <= n && a[i] == b[j]) i++;
s[j] = i - 1;
}
while (l <= r) {
int mi = (l + r) >> 1;
if (check(mi))
l = mi + 1, as = mi;
else
r = mi - 1;
}
printf("%d", b[as]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K, w[201000], in[201000], q[201000], sz[201000], res;
vector<int> e[201000], g[201000];
bool vis[201000], avi[201000], umv[201000];
int dfs(int x) {
vis[x] = true;
int w0 = 0, w1 = 0;
for (int v : g[x])
if (!vis[v]) {
int d = dfs(v);
if (d > w0)
w1 = w0, w0 = d;
else if (d > w1)
w1 = d;
}
res = max(res, w0 + w1 + sz[x]);
return w0 + sz[x];
}
void del(int x) {
vis[x] = true;
int cc = 0;
for (int v : e[x])
if (!vis[v] && avi[v]) {
--in[v], sz[v] += sz[x];
++cc;
if (in[v] == 1 && !umv[v]) del(v);
}
}
bool check(int _w) {
for (int x = 1; x <= n; ++x) {
avi[x] = (w[x] >= _w);
if (avi[x]) sz[x] = 1, in[x] = 0, vis[x] = umv[x] = false;
}
for (int x = 1; x <= n; ++x) {
if (avi[x])
for (int v : e[x]) ++in[v];
else
for (int v : e[x]) umv[v] = true;
}
for (int x = 1; x <= n; ++x)
if (in[x] == 1 && !umv[x] && avi[x] && !vis[x]) del(x);
for (int x = 1; x <= n; ++x)
if (!vis[x] && avi[x])
for (int v : e[x])
if (!vis[v] && avi[v]) g[x].push_back(v);
res = 0;
for (int x = 1; x <= n; ++x)
if (!vis[x] && avi[x]) dfs(x);
return res >= K;
}
int main() {
scanf("%d%d", &n, &K);
int t1, t2;
for (int i = 1; i <= n; ++i) scanf("%d", &w[i]);
for (int i = 1; i <= n - 1; ++i)
scanf("%d%d", &t1, &t2), e[t1].push_back(t2), e[t2].push_back(t1);
int l = 0, r = 1000010;
for (; l < r;) {
int mid = (l + r + 1) >> 1;
if (check(mid))
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
inline long long read() {
long long x = 0;
char c = getchar(), f = 1;
for (; c < '0' || '9' < c; c = getchar())
if (c == '-') f = -1;
for (; '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return x * f;
}
inline void write(long long x) {
static char buf[20];
int len = 0;
if (x < 0) putchar('-'), x = -x;
for (; x; x /= 10) buf[len++] = x % 10 + '0';
if (!len)
putchar('0');
else
while (len) putchar(buf[--len]);
}
inline void writesp(long long x) {
write(x);
putchar(' ');
}
inline void writeln(long long x) {
write(x);
putchar('\n');
}
struct edge {
int to, nxt;
} e[2 * 200010];
int fir[200010], a[200010], full[200010], f[200010];
int n, m, tot;
inline void add_edge(int x, int y) {
e[tot].to = y;
e[tot].nxt = fir[x];
fir[x] = tot++;
}
int dfs(int now, int fa, int mid) {
full[now] = (a[now] >= mid);
int delta = 1, mx1 = 0, mx2 = 0, ret = 0;
for (int i = fir[now]; ~i; i = e[i].nxt)
if (e[i].to != fa) {
ret = std::max(ret, dfs(e[i].to, now, mid));
if (full[e[i].to])
delta += f[e[i].to];
else if (f[e[i].to] > mx1)
mx2 = mx1, mx1 = f[e[i].to];
else if (f[e[i].to] > mx2)
mx2 = f[e[i].to];
full[now] &= full[e[i].to];
}
if (a[now] >= mid) {
ret = std::max(ret, mx1 + mx2 + delta);
f[now] = mx1 + delta;
} else
f[now] = 0;
return ret;
}
int main() {
n = read();
m = read();
int mx = 0;
for (int i = 1; i <= n; i++) {
a[i] = read();
mx = std::max(mx, a[i]);
}
int mnid = 1;
for (int i = 2; i <= n; i++)
if (a[i] < a[mnid]) mnid = i;
memset(fir, 255, sizeof(fir));
tot = 0;
for (int i = 1; i < n; i++) {
int x = read(), y = read();
add_edge(x, y);
add_edge(y, x);
}
int l = 1, r = mx;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (dfs(mnid, -1, mid) >= m)
l = mid;
else
r = mid - 1;
}
writeln(l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, res, cnt, x, y;
int a[200005], fl[200005], tg[200005], sz[200005], dp[200005];
vector<int> g[200005];
void init(int v) {
res = cnt = 0;
for (int i = 1; i <= n; i++) cnt += (fl[i] = (a[i] >= v));
memset(tg, 0, sizeof(tg));
}
void dfs1(int x, int fa) {
sz[x] = 1;
for (int i = 0; i < g[x].size(); i++)
if (g[x][i] != fa) dfs1(g[x][i], x), sz[x] += sz[g[x][i]];
}
void dfs2(int x, int fa) {
if (res >= k) return;
int all = 0, mx1 = 0, mx2 = 0;
for (int i = 0; i < g[x].size(); i++) {
int to = g[x][i];
if (to == fa) continue;
dfs2(to, x);
tg[x] += tg[to];
if (dp[to] == sz[to])
all += dp[to];
else if (dp[to] > mx1)
mx2 = mx1, mx1 = dp[to];
else if (dp[to] > mx2)
mx2 = dp[to];
}
if (!fl[x])
dp[x] = 0;
else {
dp[x] = all + mx1 + 1;
tg[x]++;
}
if (n - sz[x] == cnt - tg[x]) all += n - sz[x];
if (fl[x]) res = max(res, all + mx1 + mx2 + 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++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
int l = 1, r = 1000000, ans;
dfs1(1, 0);
while (l <= r) {
int mid = (l + r) / 2;
init(mid);
dfs2(1, 0);
if (res >= k)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
template <class T>
bool setmax(T& l, T const& r) {
if (not(l < r)) return false;
l = r;
return true;
}
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; (i) < (n); ++(i)) cin >> a[i];
vector<vector<int> > g(n);
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);
}
int low = *min_element(a.begin(), a.end());
int high = *max_element(a.begin(), a.end()) + 1;
while (low + 1 < high) {
int mid = (low + high) / 2;
auto forbidden = [&](int i) { return a[i] < mid; };
bool found = false;
vector<bool> used(n);
vector<int> dp(n);
vector<bool> has_forbidden(n);
for (int i = 0; (i) < (n); ++(i))
if (not forbidden(i) and not used[i]) {
int root = -1;
function<void(int)> collect = [&](int i) {
used[i] = true;
for (int j : g[i])
if (not used[j]) {
if (not forbidden(j)) collect(j);
if (forbidden(j)) root = i;
}
};
collect(i);
if (root == -1) {
found = true;
break;
}
function<void(int, int)> dfs = [&](int i, int p) {
if (found) return;
int max_forbidden = 0;
int snd_forbidden = 0;
int sum_free = 0;
for (int j : g[i])
if (j != p) {
if (forbidden(j)) {
has_forbidden[i] = true;
} else {
dfs(j, i);
if (found) return;
if (has_forbidden[j]) {
has_forbidden[i] = true;
setmax(snd_forbidden, dp[j]);
if (max_forbidden < snd_forbidden)
swap(max_forbidden, snd_forbidden);
} else {
sum_free += dp[j];
}
}
}
dp[i] = 1 + sum_free + max_forbidden;
if (k <= dp[i] + snd_forbidden) found = true;
};
dfs(root, -1);
if (found) break;
}
(not found ? high : low) = mid;
}
cout << low << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 400010;
class Graph {
public:
int en[MaxN], next[MaxN], point[MaxN], tot;
void init() { tot = 1; }
void add_edge(int x, int y) {
next[++tot] = en[x];
en[x] = tot;
point[tot] = y;
}
} G;
int n, k, a[MaxN];
int q[MaxN], father[MaxN], deg[MaxN];
int f_up[MaxN], f_down[MaxN], mx[MaxN], sc[MaxN], g[MaxN];
int c_up[MaxN], c_down[MaxN];
void bfs(int root) {
static bool vis[MaxN];
int l = 0, r = 0;
q[++r] = root;
vis[root] = 1;
while (l != r) {
int u = q[++l];
for (int i = G.en[u]; i; i = G.next[i])
if (!vis[G.point[i]]) {
q[++r] = G.point[i];
vis[G.point[i]] = 1;
father[G.point[i]] = u;
}
}
}
bool check(int x) {
for (int i = n; i; --i) {
int u = q[i];
mx[u] = sc[u] = 0;
f_up[u] = c_up[u] = 0;
if (a[u] < x) continue;
++f_up[u];
for (int j = G.en[u]; j; j = G.next[j])
if ((G.point[j] != father[u]) && (a[G.point[j]] >= x)) {
int tmp = f_up[G.point[j]];
if (c_up[G.point[j]] == deg[G.point[j]] - 1) {
f_up[u] += tmp;
++c_up[u];
} else {
if (tmp > mx[u]) {
sc[u] = mx[u];
mx[u] = tmp;
} else if (tmp > sc[u])
sc[u] = tmp;
}
}
f_up[u] += mx[u];
}
memcpy(g, f_up, sizeof(f_up));
memcpy(c_down, c_up, sizeof(c_up));
for (int i = 2; i <= n; ++i) {
int u = q[i], f = father[u], down = g[f];
if (min(a[u], a[f]) < x) continue;
if (c_up[u] == deg[u] - 1)
down -= f_up[u];
else if (f_up[u] == mx[f])
down -= mx[f] - sc[f];
if (c_down[f] - (c_up[u] == deg[u] - 1) == deg[f] - 1) {
++c_down[u];
g[u] += down;
} else if (down > mx[u]) {
g[u] += down - mx[u];
sc[u] = mx[u];
mx[u] = down;
}
}
for (int i = 1; i <= n; ++i)
if (a[i] >= x)
if (g[i] >= k) return 1;
return 0;
}
int main() {
G.init();
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.add_edge(u, v);
G.add_edge(v, u);
++deg[u];
++deg[v];
}
bfs(1);
int l = 1, r = 1000000;
while (l != r) {
int mid = (l + r + 1) >> 1;
if (check(mid))
l = mid;
else
r = mid - 1;
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 200005;
vector<int> adjList[mx];
int n, k, a[mx], u, v, res;
queue<int> leaves;
bool bad[mx], vis[mx], rem[mx];
int deg[mx], val[mx];
int dp[mx][2];
void find_leaves(int u, int p) {
vis[u] = 1;
for (int v : adjList[u]) {
if (v == p || bad[v]) continue;
find_leaves(v, u);
}
if (adjList[u].size() == 1) leaves.push(u);
}
void dfs(int u, int p) {
dp[u][1] = dp[u][0] = 0;
for (int v : adjList[u]) {
if (v == p || bad[v]) continue;
dfs(v, u);
if (dp[v][0] >= dp[u][0])
dp[u][1] = dp[u][0], dp[u][0] = dp[v][0];
else if (dp[v][0] > dp[u][1])
dp[u][1] = dp[v][0];
}
res = max(res, dp[u][0] + dp[u][1] + val[u]);
dp[u][0] += val[u];
}
void check(int u) {
find_leaves(u, -1);
while (!leaves.empty()) {
int cur = leaves.front();
leaves.pop();
rem[cur] = true;
int spl = -1;
for (int up : adjList[cur])
if (!rem[up] && !bad[up]) spl = up;
if (spl != -1) {
val[spl] += val[cur];
val[cur] = 0;
deg[spl]--;
if (deg[spl] == 1) leaves.push(spl);
}
}
dfs(u, -1);
}
bool solve(int cur) {
res = 0;
for (int i = 1; i <= n; i++) {
bad[i] = (a[i] < cur);
vis[i] = rem[i] = false;
deg[i] = adjList[i].size();
val[i] = 1;
}
for (int i = 1; i <= n; i++)
if (!vis[i] && !bad[i]) check(i);
return (res >= k);
}
int main() {
cin.tie(0), ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
cin >> u >> v;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
int ans = 0;
for (int i = 20; i >= 0; i--)
if (solve(ans + (1 << i))) ans += (1 << i);
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
int w[N], sz[N], dp1[N], dp2[N], dp3[N], ans;
int mid;
vector<int> e[N];
void predfs(int x, int p) {
sz[x] = 1;
for (int i = 0; i < e[x].size(); i++)
if (e[x][i] == p) {
swap(e[x][i], e[x].back());
e[x].pop_back();
i--;
} else {
predfs(e[x][i], x);
sz[x] += sz[e[x][i]];
}
}
void dfszz(int x) {
dp1[x] = w[x] >= mid;
dp2[x] = dp3[x] = 0;
for (int it : e[x]) {
dfszz(it);
if (dp1[x]) {
if (sz[it] == dp1[it])
dp1[x] += dp1[it];
else {
if (dp2[x] < dp1[it] + dp2[it]) {
dp3[x] = dp2[x];
dp2[x] = dp1[it] + dp2[it];
} else
dp3[x] = max(dp3[x], dp1[it] + dp2[it]);
}
}
}
}
void dfs(int x, int y) {
if (y == sz[1] - sz[x])
ans = max(ans, dp1[x] + dp2[x] + y);
else
ans = max(ans, dp1[x] + max(y, dp2[x]));
for (int it : e[x]) {
int z = dp1[x];
if (sz[it] == dp1[it]) {
z -= sz[it];
if (y == sz[1] - sz[x])
z += y + dp2[x];
else
z += max(dp2[x], y);
} else {
int q = (dp1[it] + dp2[it]) == dp2[x] ? dp3[x] : dp2[x];
if (y == sz[1] - sz[x])
z += y + q;
else
z += max(q, y);
}
if (w[x] < mid) z = 0;
dfs(it, z);
}
}
bool check(int k) {
ans = 0;
dfszz(1);
dfs(1, 0);
return ans >= k;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
e[u].emplace_back(v);
e[v].emplace_back(u);
}
predfs(1, 0);
int l = 1, r = 1000000;
while (l < r) {
mid = (l + r + 1) >> 1;
if (check(k))
l = mid;
else
r = mid - 1;
}
cout << l << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
int A[200004];
vector<int> adj[200004];
namespace CJ {
int subtree_sz[200004];
void dfs_preprocess(int u, int p) {
subtree_sz[u] = 1;
for (int v : adj[u]) {
if (v == p) continue;
dfs_preprocess(v, u);
subtree_sz[u] += subtree_sz[v];
}
}
int LP1[200004];
int LP2[200004];
int sum_full[200004];
void dfs_down(int u, int p, int min_val) {
sum_full[u] = 0;
int max_len1 = 0, max_len2 = 0;
for (int v : adj[u]) {
if (v == p) continue;
dfs_down(v, u, min_val);
if (LP1[v] == subtree_sz[v]) {
sum_full[u] += subtree_sz[v];
} else if (max_len1 < LP1[v]) {
max_len2 = max_len1;
max_len1 = LP1[v];
} else if (max_len2 < LP1[v])
max_len2 = LP1[v];
}
LP1[u] = LP2[u] = 0;
if (A[u] >= min_val) {
LP1[u] = 1 + sum_full[u] + max_len1;
if (!adj[u].empty()) LP2[u] = 1 + sum_full[u] + max_len2;
}
}
void dfs_up(int u, int p, int min_val) {
if (LP1[u] == subtree_sz[u]) return;
if (p >= 0 && A[u] >= min_val && A[p] >= min_val) {
if (LP1[p] == 1 + sum_full[p] + LP1[u]) {
if (subtree_sz[1] - subtree_sz[u] == 1 + sum_full[p]) {
sum_full[u] += 1 + sum_full[p];
LP1[u] += 1 + sum_full[p];
LP2[u] += 1 + sum_full[p];
} else {
int lp_up = 1 + sum_full[u] + LP2[p];
if (LP1[u] < lp_up) {
LP2[u] = LP1[u];
LP1[u] = lp_up;
} else if (LP2[u] < lp_up)
LP2[u] = lp_up;
}
} else {
int lp_up = 1 + sum_full[u] + LP1[p];
if (LP1[u] < lp_up) {
LP2[u] = LP1[u];
LP1[u] = lp_up;
} else if (LP2[u] < lp_up)
LP2[u] = lp_up;
}
}
for (int v : adj[u]) {
if (v == p) continue;
dfs_up(v, u, min_val);
}
}
bool check(int min_val) {
dfs_down(1, -1, min_val);
if (LP1[1] == subtree_sz[1]) return LP1[1] >= K;
dfs_up(1, -1, min_val);
for (int u = 1; u <= N; ++u)
if (LP1[u] >= K) return true;
return false;
}
int solve() {
dfs_preprocess(1, -1);
vector<int> S(A + 1, A + 1 + N);
sort(S.begin(), S.end());
S.resize(unique(S.begin(), S.end()) - S.begin());
int res = 0;
int lo = 0, hi = int(S.size()) - 1;
while (lo < hi) {
int mid = lo + (hi - lo + 1) / 2;
if (!check(S[mid]))
hi = mid - 1;
else
lo = mid;
}
res = S[lo];
return res;
}
} // namespace CJ
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> K;
for (int i = 1; i <= N; ++i) cin >> A[i];
for (int j = 1; j < N; ++j) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
cout << CJ::solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> V[200100];
int L, R, mid;
int a[200101];
int sz[200101];
int hdp[200101];
int fdp[200101][2][2];
int dp[200101];
int fa[200101];
bool flag = false;
void dfs(int x) {
dp[x] = 0;
sz[x] = 1;
fdp[x][0][0] = 0, fdp[x][0][1] = -1;
fdp[x][1][0] = 0, fdp[x][1][1] = -1;
hdp[x] = 0;
for (int i = 0; i < int(V[x].size()); ++i) {
int y = V[x][i];
if (y != fa[x]) {
fa[y] = x;
dfs(y);
sz[x] += sz[y];
if (sz[y] != dp[y]) {
if (dp[y] > fdp[x][1][0]) {
fdp[x][1][0] = dp[y];
fdp[x][1][1] = y;
}
if (fdp[x][0][0] < fdp[x][1][0]) {
swap(fdp[x][0][0], fdp[x][1][0]);
swap(fdp[x][0][1], fdp[x][1][1]);
}
} else
hdp[x] += sz[y];
}
}
if (a[x] >= mid)
dp[x] = 1 + fdp[x][0][0] + hdp[x];
else
dp[x] = 0;
if (dp[x] >= m) {
flag = true;
}
}
void dfs2(int x) {
if (sz[x] == dp[x]) return;
if (a[fa[x]] >= mid) {
int gg = hdp[fa[x]] + 1 + fdp[fa[x]][fdp[fa[x]][0][1] == x][0];
if (gg == n - sz[x]) {
hdp[x] += gg;
} else {
if (gg > fdp[x][1][0]) {
fdp[x][1][0] = gg;
fdp[x][1][1] = fa[x];
}
if (fdp[x][0][0] < fdp[x][1][0]) {
swap(fdp[x][0][0], fdp[x][1][0]);
swap(fdp[x][0][1], fdp[x][1][1]);
}
}
}
if (a[x] >= mid) {
if (1 + fdp[x][0][0] + hdp[x] >= m) {
flag = true;
}
}
for (int i = 0; i < int(V[x].size()); ++i) {
int y = V[x][i];
if (y != fa[x]) {
dfs2(y);
}
}
}
int main() {
scanf("%d%d", &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);
V[x].push_back(y);
V[y].push_back(x);
}
L = 1, R = 1001000;
while (L + 1 != R) {
flag = false;
mid = (L + R) >> 1;
dfs(1);
dfs2(1);
if (flag)
L = mid;
else
R = mid;
}
printf("%d\n", L);
return 0;
}
|
#include <bits/stdc++.h>
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline void sub(long long &a, long long b) {
a -= b;
if (a < 0) a += 1000000007;
}
inline void add(long long &a, long long b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
template <typename T>
inline T const &MAX(T const &a, T const &b) {
return a > b ? a : b;
}
template <typename T>
inline T const &MIN(T const &a, T const &b) {
return a < b ? a : b;
}
inline long long mul(long long a, long long b, long long c) {
return (a * b - (long long)((long double)a * b / c) * c + c) % c;
}
inline long long qp(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % 1000000007;
a = a * a % 1000000007, b >>= 1;
}
return ans;
}
inline long long qp(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & 1) ans = mul(ans, a, c);
a = mul(a, a, c), b >>= 1;
}
return ans;
}
using namespace std;
const unsigned long long ba = 233;
const double eps = 1e-5;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 200000 + 10, maxn = 2000000 + 10, inf = 0x3f3f3f3f;
vector<int> v[N];
bool ok;
int a[N], cnt[N], sz[N], n, k, dp[N], sum;
void dfs(int u, int f) {
sz[u] = 1;
for (int x : v[u])
if (x != f) dfs(x, u), sz[u] += sz[x];
}
void dfs1(int u, int f, int m) {
if (ok) return;
dp[u] = cnt[u] = (a[u] >= m);
int ma1 = 0, ma2 = 0;
for (int x : v[u])
if (x != f) {
dfs1(x, u, m);
cnt[u] += cnt[x];
if (a[u] >= m) {
if (dp[x] == sz[x])
dp[u] += dp[x];
else if (dp[x] >= ma1)
ma2 = ma1, ma1 = dp[x];
else if (dp[x] >= ma2)
ma2 = dp[x];
}
}
if (a[u] >= m) {
dp[u] += ma1;
int te = dp[u] + ma2;
if (n - sz[u] == sum - cnt[u]) te += n - sz[u];
if (te >= k) ok = 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 a, b;
scanf("%d%d", &a, &b);
v[a].push_back(b), v[b].push_back(a);
}
dfs(1, 1);
int l = 0, r = 1000000;
while (l < r - 1) {
int m = (l + r) >> 1;
sum = ok = 0;
for (int i = 1; i <= n; i++) sum += (a[i] >= m);
dfs1(1, 1, m);
if (ok)
l = m;
else
r = m;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
void precalc() {}
const int maxn = 2e5 + 10;
int n, k;
int a[maxn];
vector<int> to[maxn];
vector<int> num[maxn];
vector<int> dp[maxn];
vector<int> cnt[maxn];
vector<int> mx[maxn][2];
bool read() {
if (scanf("%d%d", &n, &k) < 2) {
return false;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; ++i) {
to[i].clear();
num[i].clear();
}
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
num[a].push_back(((int)(to[b]).size())),
num[b].push_back(((int)(to[a]).size()));
to[a].push_back(b), to[b].push_back(a);
}
return true;
}
int ldp[maxn];
int calcDp(int v, int pr, int mn) {
if (dp[v][pr] != -1) {
return dp[v][pr];
}
int &res = dp[v][pr];
if (a[v] < mn) {
res = 0;
return res;
}
res = 1;
if (ldp[v] == -1) {
mx[v][0][pr] = mx[v][1][pr] = 0;
for (int i = 0; i < ((int)(to[v]).size()); ++i) {
if (i == pr) {
continue;
}
int u = to[v][i], nm = num[v][i];
int cur = calcDp(u, nm, mn);
if (cur == cnt[u][nm]) {
res += cur;
} else {
if (mx[v][1][pr] < cur) {
mx[v][1][pr] = cur;
if (mx[v][0][pr] < mx[v][1][pr]) {
swap(mx[v][0][pr], mx[v][1][pr]);
}
}
}
}
res += mx[v][0][pr];
ldp[v] = pr;
} else {
res = dp[v][ldp[v]];
int cmx = mx[v][0][ldp[v]];
res -= cmx;
if (pr < ((int)(to[v]).size())) {
int u = to[v][pr], nm = num[v][pr];
int cur = calcDp(u, nm, mn);
if (cur == cnt[u][nm]) {
res -= cur;
} else if (cur == cmx) {
cmx = mx[v][1][ldp[v]];
}
}
if (ldp[v] < ((int)(to[v]).size())) {
int u = to[v][ldp[v]], nm = num[v][ldp[v]];
int cur = calcDp(u, nm, mn);
if (cur == cnt[u][nm]) {
res += cur;
} else {
cmx = max(cmx, cur);
}
}
res += cmx;
}
return res;
}
bool good(int mn) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < ((int)(dp[i]).size()); ++j) {
dp[i][j] = -1;
}
ldp[i] = -1;
}
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < ((int)(dp[i]).size()); ++j) {
ans = max(ans, calcDp(i, j, mn));
}
}
return ans >= k;
}
int lcnt[maxn];
int calcCnt(int v, int pr) {
if (cnt[v][pr] != -1) {
return cnt[v][pr];
}
int &res = cnt[v][pr];
res = 1;
if (lcnt[v] == -1) {
for (int i = 0; i < ((int)(to[v]).size()); ++i) {
if (i == pr) {
continue;
}
res += calcCnt(to[v][i], num[v][i]);
}
} else {
res = cnt[v][lcnt[v]];
if (lcnt[v] < ((int)(to[v]).size())) {
res += calcCnt(to[v][lcnt[v]], num[v][lcnt[v]]);
}
if (pr < ((int)(to[v]).size())) {
res -= calcCnt(to[v][pr], num[v][pr]);
}
}
lcnt[v] = pr;
return res;
}
void solve() {
for (int i = 0; i < n; ++i) {
mx[i][0] = vector<int>(((int)(to[i]).size()) + 1);
mx[i][1] = vector<int>(((int)(to[i]).size()) + 1);
dp[i] = vector<int>(((int)(to[i]).size()) + 1);
cnt[i] = vector<int>(((int)(to[i]).size()) + 1, -1);
lcnt[i] = -1;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < ((int)(cnt[i]).size()); ++j) {
calcCnt(i, j);
}
}
int L = 0, R = (int)1e6 + 1;
while (R - L > 1) {
int M = (L + R) / 2;
if (good(M)) {
L = M;
} else {
R = M;
}
}
printf("%d\n", L);
}
int main() {
srand(rdtsc());
precalc();
while (true) {
if (!read()) {
break;
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10, mod = 1e9 + 7;
const long long inf = 1e18;
vector<int> v[maxn];
int dp[maxn], dp2[maxn], a[maxn];
bool is[maxn], is2[maxn];
bool mark[maxn];
int ANS;
void dfs1(int u, int par = -1) {
if (mark[u]) {
is[u] = 1;
dp[u] = 0;
for (int y : v[u])
if (y != par) dfs1(y, u);
return;
}
mark[u] = 1;
is[u] = 0;
dp[u] = 1;
int mx = -1;
for (int y : v[u]) {
if (y != par) {
dfs1(y, u);
if (is[y])
mx = max(mx, dp[y]);
else
dp[u] += dp[y];
}
}
if (mx != -1) dp[u] += mx, is[u] = 1;
}
void dfs2(int u, int par = -1) {
if (mark[u] == 1) {
for (int y : v[u]) {
if (y != par) {
dp2[y] = 0;
is2[y] = 1;
dfs2(y, u);
}
}
return;
}
if (is2[u] && is[u])
ANS = max(ANS, max(dp2[u] + 1, dp[u]));
else
ANS = max(ANS, dp[u] + dp2[u]);
int mx1 = 0, mx2 = 0, cnt = 0, sm = 0;
bool IS = 0;
for (int y : v[u]) {
IS |= (y != par && mark[y]);
if (y != par && !mark[y]) {
if (is[y]) {
cnt++;
if (dp[mx1] < dp[y])
mx2 = mx1, mx1 = y;
else if (dp[mx2] < dp[y])
mx2 = y;
} else {
sm += dp[y];
}
}
}
for (int y : v[u]) {
if (y != par) {
if (mark[y]) {
is2[y] = 1;
dp2[y] = 0;
} else {
is2[y] = IS | is2[u] | (cnt - is[y]);
dp2[y] = sm - (is[y] ? 0 : dp[y]) + 1 + (is2[u] ? 0 : dp2[u]);
int MX = is2[u] ? dp2[u] : 0;
if (y == mx1)
MX = max(MX, dp[mx2]);
else
MX = max(MX, dp[mx1]);
dp2[y] += MX;
}
dfs2(y, u);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
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 a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
int l = 1, r = 1e6, ans = 1;
while (l <= r) {
int mid = (l + r) >> 1;
for (int i = 1; i <= n; i++) mark[i] = (a[i] < mid);
dfs1(1);
for (int i = 1; i <= n; i++) mark[i] = (a[i] < mid);
memset(dp2, 0, sizeof dp2);
memset(is2, 0, sizeof is2);
ANS = 0;
dfs2(1);
if (ANS >= k)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, cnt, head[N], fa[N], sz[N], k, Max, f[N], a[N], u, v, l, r, size[N], ans,
b[N];
struct node {
int to, next;
} num[N * 2];
void add(int x, int y) {
num[++cnt].to = y;
num[cnt].next = head[x];
head[x] = cnt;
}
void dfs_pre(int x) {
sz[x] = 1;
for (int i = head[x]; i; i = num[i].next)
if (num[i].to != fa[x]) {
fa[num[i].to] = x;
dfs_pre(num[i].to);
sz[x] += sz[num[i].to];
}
}
void dfs(int x, int mid) {
size[x] = (a[x] >= mid);
int ans = 1, mx = 0, mxc = 0;
for (int i = head[x]; i; i = num[i].next)
if (num[i].to != fa[x]) {
dfs(num[i].to, mid);
size[x] += size[num[i].to];
if (size[num[i].to] == sz[num[i].to])
ans += sz[num[i].to];
else if (f[num[i].to] > mx)
mxc = mx, mx = f[num[i].to];
else if (f[num[i].to] > mxc)
mxc = f[num[i].to];
}
if (a[x] < mid)
f[x] = 0;
else
f[x] = ans + mx;
if (cnt - size[x] == n - sz[x]) ans += n - sz[x];
if (a[x] >= mid) Max = max(Max, ans + mx + mxc);
}
bool check(int mid) {
Max = 0;
cnt = lower_bound(b + 1, b + n + 1, mid) - b - 1;
cnt = n - cnt;
dfs(1, mid);
return Max >= k;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), Max = max(Max, a[i]), b[i] = a[i];
for (int i = 1; i < n; i++) scanf("%d%d", &u, &v), add(u, v), add(v, u);
sort(b + 1, b + n + 1);
dfs_pre(1);
l = 1;
r = ans = Max;
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;
const int N = 200011;
int n, k, a[N], b[N];
int v[N * 2], pre[N * 2], bia[N], num = 0;
int dp[N], son[N], ans, MID, MA[N], out[N];
bool fulf[N];
void addedge(int l, int r) {
++num;
v[num] = r;
pre[num] = bia[l];
bia[l] = num;
}
void dfs(int l, int fa) {
son[l] = 1;
int r, ma[3] = {0, 0, 0}, tem = 0, k;
for (int i = bia[l]; i != 0; i = pre[i]) {
r = v[i];
if (r == fa) continue;
dfs(r, l);
son[l] += son[r];
if (son[r] == dp[r])
tem += dp[r];
else {
k = 2;
ma[k] = dp[r];
while (k > 0 && ma[k] > ma[k - 1]) {
swap(ma[k], ma[k - 1]);
k--;
}
}
}
if (a[l] >= MID) {
MA[l] = tem + ma[0] + ma[1] + 1;
dp[l] = tem + ma[0] + 1;
} else {
dp[l] = 0;
MA[l] = 0;
}
}
void getful(int l, int fa) {
if (a[l] < MID) fulf[l] = false;
if (fulf[l] == false) return;
int r;
int R, cnt = 0;
for (int i = bia[l]; i != 0; i = pre[i]) {
r = v[i];
if (r == fa) continue;
if (dp[r] == son[r])
;
else {
cnt++;
R = r;
}
}
if (cnt == 0) {
for (int i = bia[l]; i != 0; i = pre[i]) {
r = v[i];
if (r == fa) continue;
fulf[r] = true;
getful(r, l);
}
} else if (cnt == 1) {
for (int i = bia[l]; i != 0; i = pre[i]) {
r = v[i];
if (r == fa) continue;
fulf[r] = false;
}
fulf[R] = true;
getful(R, l);
} else {
for (int i = bia[l]; i != 0; i = pre[i]) {
r = v[i];
if (r == fa) continue;
fulf[r] = false;
}
return;
}
}
bool check() {
memset(fulf, 0, sizeof(fulf));
fulf[1] = fulf[0] = true;
dfs(1, 0);
getful(1, 0);
int tem;
for (int i = 1; i <= n; i++) {
tem = MA[i];
if (fulf[i] == true) {
tem += n - son[i];
}
if (tem >= k) return true;
}
return false;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
sort(b + 1, b + n + 1);
int l, r;
for (int i = 1; i < n; i++) {
scanf("%d%d", &l, &r);
addedge(l, r);
addedge(r, l);
}
l = 1;
r = n;
int mid;
while (l + 1 < r) {
mid = (l + r) / 2;
MID = b[mid];
if (check() == true) {
l = mid;
} else {
r = mid - 1;
}
}
while (l < n) {
MID = b[l + 1];
if (check())
l++;
else
break;
}
cout << b[l];
}
|
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int mod = (int)1e9 + 7;
const int logN = 17;
const int inf = 1e9;
const int N = 2e5 + 5;
int all_cnt, sum[N], cnt[N], all[N], ok[N], n, m, a[N], x, y, z;
vector<int> v[N];
int dfs(int node, int root, int big) {
cnt[node] = a[node] < big;
all[node] = 1;
sum[node] = 1;
ok[node] = 1;
int mx = 0, mx2 = 0;
for (__typeof(v[node].begin()) it = v[node].begin(); it != v[node].end();
it++) {
if (*it == root) continue;
if (dfs(*it, node, big)) return true;
sum[node] += sum[*it];
cnt[node] += cnt[*it];
if (ok[*it] == 1)
all[node] += all[*it];
else {
ok[node] = 0;
if (all[*it] >= mx) {
mx2 = mx;
mx = all[*it];
} else
mx2 = max(mx2, all[*it]);
}
}
all[node] += mx;
if (a[node] < big) {
all[node] = 0;
ok[node] = 0;
} else if (all[node] + mx2 + (cnt[node] == all_cnt ? n - sum[node] : 0) >= m)
return true;
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 2; i <= n; i++) {
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
int bas = 0, son = 1000000;
while (bas < son) {
int ort = bas + son >> 1;
if (bas == ort) ort++;
all_cnt = 0;
for (int i = 1; i <= n; i++) all_cnt += a[i] < ort;
if (dfs(1, 0, ort))
bas = ort;
else
son = ort - 1;
}
cout << bas << '\n';
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)2e5 + 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;
}
}
assert(solve(z[l]) >= k);
assert(l == n - 1 || solve(z[l + 1]) < k);
printf("%d\n", z[l]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, qwe;
int a[200005];
vector<int> g[200005];
set<int> w[200005];
bool b[200005];
int v[200005];
bool vis[200005];
int d[200005];
stack<int> st;
vector<int> c;
void dfs(int x, int f) {
vis[x] = true;
c.push_back(x);
for (set<int>::iterator it = w[x].begin(); it != w[x].end(); ++it) {
int y = *it;
if (y == f) continue;
d[y] = d[x] + v[y];
dfs(y, x);
}
}
int diam(int x) {
c.clear();
d[x] = v[x];
dfs(x, -1);
int y = x;
for (int i = 1, to = c.size(); i < to; ++i) {
if (d[c[i]] > d[y]) y = c[i];
}
d[y] = v[y];
c.clear();
dfs(y, -1);
int r = 0;
for (int i = 0, to = c.size(); i < to; ++i) r = max(r, d[c[i]]);
return r;
}
bool can(int m) {
for (int x = 0, to = n; x < to; ++x) w[x].clear();
memset(b, false, sizeof(b));
memset(v, 0, sizeof(v));
for (int x = 0, to = n; x < to; ++x) {
for (int i = 0, to = g[x].size(); i < to; ++i) {
int y = g[x][i];
if (a[x] < m || a[y] < m) {
b[x] = b[y] = true;
} else {
w[x].insert(y);
w[y].insert(x);
}
}
if (a[x] >= m) v[x] = 1;
}
for (int x = 0, to = n; x < to; ++x) {
if (!b[x] && w[x].size() == 1) st.push(x);
}
while (!st.empty()) {
int x = st.top();
st.pop();
int y = *w[x].begin();
w[x].erase(y);
w[y].erase(x);
v[y] += v[x];
if (!b[y] && w[y].size() == 1) st.push(y);
}
memset(vis, false, sizeof(vis));
int r = 0;
for (int x = 0, to = n; x < to; ++x) {
if (!vis[x]) r = max(r, diam(x));
}
return r >= qwe;
}
int main() {
int k;
scanf("%d%d", &n, &qwe);
for (int i = 0, to = n; i < to; ++i) scanf("%d", a + i);
for (int i = 1, to = n; i < to; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
int s = 1, e = 1000001;
while (e - s > 1) {
int m = (s + e) / 2;
if (can(m))
s = m;
else
e = m;
}
printf("%d\n", s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 233;
struct zs {
int too, pre;
} e[maxn << 1];
int tot, last[maxn];
int tim[maxn], down[maxn], ful[maxn], sz[maxn];
bool val[maxn];
int i, j, k, n, m;
int KK, MNT;
bool FLAG;
int ra, fh;
char rx;
inline int read() {
rx = getchar(), ra = 0, fh = 1;
while ((rx < '0' || rx > '9') && rx != '-') rx = getchar();
if (rx == '-') fh = -1, rx = getchar();
while (rx >= '0' && rx <= '9') ra = ra * 10 + rx - 48, rx = getchar();
return ra * fh;
}
inline void insert(int a, int b) {
e[++tot].too = b, e[tot].pre = last[a], last[a] = tot, e[++tot].too = a,
e[tot].pre = last[b], last[b] = tot;
}
inline void maxs(int &a, int b) {
if (b > a) a = b;
}
void dfs(int x, int fa) {
sz[x] = 1;
int mx = 0;
ful[x] = 0;
for (int i = last[x], to; i; i = e[i].pre)
if ((to = e[i].too) != fa) {
dfs(to, x), sz[x] += sz[to];
if (down[to] == sz[to])
ful[x] += sz[to];
else
maxs(mx, down[to]);
}
val[x] = tim[x] >= MNT;
if (!val[x])
down[x] = ful[x] = 0;
else
down[x] = 1 + ful[x] + mx, ful[x]++;
if (down[x] >= KK) FLAG = 1;
}
void dfs2(int x, int fa, int fup) {
int i, to, fasz = n - sz[x], xup = fup == fasz ? down[x] + fup : ful[x] + fup;
if (xup >= KK) {
FLAG = 1;
return;
}
if (!val[x]) {
for (i = last[x]; i; i = e[i].pre)
if ((to = e[i].too) != fa) dfs2(to, x, 0);
} else {
int mxp = 0, ndp = 0;
for (i = last[x]; i; i = e[i].pre)
if ((to = e[i].too) != fa && down[to] != sz[to]) {
if (down[to] > down[mxp])
ndp = mxp, mxp = to;
else if (down[to] > down[ndp])
ndp = to;
}
for (i = last[x]; i; i = e[i].pre)
if ((to = e[i].too) != fa) {
if (down[to] == sz[to])
dfs2(to, x, xup - sz[to]);
else if (fup != fasz)
dfs2(to, x, ful[x] + max(fup, (to == mxp ? down[ndp] : down[mxp])));
else
dfs2(to, x, ful[x] + fup + (to == mxp ? down[ndp] : down[mxp]));
}
}
}
int main() {
n = read(), KK = read();
for (i = 1; i <= n; i++) tim[i] = read();
for (i = 1; i < n; i++) insert(read(), read());
int l = 1, r = 1e6, mid;
while (l < r) {
mid = MNT = (l + r + 1) >> 1;
FLAG = 0;
dfs(1, 0);
if (!FLAG) dfs2(1, 0, 0);
if (FLAG)
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
}
|
#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 bool print = false;
const int MAXN = 400111;
int BOR = 0;
int a[MAXN];
vector<int> kraw[MAXN];
int ojc[MAXN];
int okst[MAXN];
int wynst[MAXN];
int okot[MAXN];
int wynot[MAXN];
void dfs0(int v) {
if (a[v] < BOR)
wynst[v] = okst[v] = 0;
else
wynst[v] = okst[v] = 1;
int xd = 0;
for (auto b : kraw[v]) {
if (b == ojc[v]) continue;
ojc[b] = v;
dfs0(b);
if (okst[b]) {
if (wynst[v] > 0) wynst[v] += wynst[b];
} else
xd = max(xd, wynst[b]), okst[v] = 0;
}
if (wynst[v] > 0) wynst[v] += xd;
if (a[v] < BOR) wynst[v] = okst[v] = 0;
}
void dfs1(int v) {
if (a[v] < BOR) {
okot[v] = wynot[v] = 0;
for (auto b : kraw[v]) {
if (b == ojc[v]) continue;
okot[b] = 0;
wynot[b] = 0;
dfs1(b);
}
return;
}
int ilzl = 0;
int suma = 1;
vector<int> xd1;
xd1.push_back(0);
xd1.push_back(0);
for (auto b : kraw[v]) {
if (b == ojc[v]) continue;
if (okst[b]) {
suma += wynst[b];
} else {
ilzl++;
xd1.push_back(wynst[b]);
sort((xd1).begin(), (xd1).end());
reverse((xd1).begin(), (xd1).end());
xd1.pop_back();
}
}
if (okot[v])
suma += wynot[v];
else {
ilzl++;
xd1.push_back(wynot[v]);
sort((xd1).begin(), (xd1).end());
reverse((xd1).begin(), (xd1).end());
xd1.pop_back();
}
for (auto b : kraw[v]) {
if (b == ojc[v]) continue;
if (ilzl > 1 || (ilzl == 1 && okst[b] == 1))
okot[b] = 0;
else
okot[b] = 1;
if (okst[b])
wynot[b] = suma - wynst[b] + xd1[0];
else {
if (wynst[b] == xd1[0])
wynot[b] = suma + xd1[1];
else
wynot[b] = suma + xd1[0];
}
dfs1(b);
}
}
int n;
int chk(int val) {
for (int i = (1); i <= (n); i++)
okst[i] = okot[i] = wynst[i] = wynot[i] = ojc[i] = 0;
BOR = val;
dfs0(1);
okot[1] = 1;
wynot[1] = 0;
dfs1(1);
int wyn = 0;
for (int v = (1); v <= (n); v++) {
if (a[v] < val) continue;
int suma = 1, xd = 0;
if (okot[v])
suma += wynot[v];
else
xd = wynot[v];
for (auto b : kraw[v]) {
if (b == ojc[v]) continue;
if (okst[b])
suma += wynst[b];
else
xd = max(xd, wynst[b]);
}
wyn = max(wyn, suma + xd);
}
return wyn;
}
int binsercz(int k) {
int lw = 0, pw = 1000111;
while (lw < pw) {
int sr = (lw + pw) / 2;
int xd = chk(sr + 1);
if (xd >= k)
lw = sr + 1;
else
pw = sr;
}
return lw;
}
int main() {
int k;
scanf("%d%d", &n, &k);
for (int i = (1); i <= (n); i++) scanf("%d", &a[i]);
for (int i = (2); i <= (n); i++) {
int a, b;
scanf("%d%d", &a, &b);
kraw[a].push_back(b);
kraw[b].push_back(a);
}
int ans = binsercz(k);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
vector<int> g[N];
int w[N];
int best, n, k;
bool used[N];
bool forb[N];
int deg[N];
bool del[N];
int val[N];
int dp[N];
queue<int> Q;
void dfs1(int x, int p) {
used[x] = 1;
for (int y : g[x]) {
if (y == p || forb[y]) continue;
dfs1(y, x);
}
if ((int)g[x].size() == 1) Q.push(x);
}
void dfs(int x, int p) {
dp[x] = val[x];
int b1 = 0, b2 = 0;
for (int y : g[x]) {
if (y == p || forb[y]) continue;
dfs(y, x);
if (b1 < dp[y])
b2 = b1, b1 = dp[y];
else
b2 = max(b2, dp[y]);
}
best = max(best, 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 pi = -1;
for (int to : g[cur]) {
if (!del[to] && !forb[to]) {
pi = to;
break;
}
}
if (pi != -1) {
val[pi] += val[cur];
best = max(best, val[pi]);
val[cur] = 0;
deg[pi]--;
if (deg[pi] == 1) Q.push(pi);
}
best = max(best, val[x]);
}
dfs(x, -1);
}
bool check(int threshold) {
best = 0;
for (int _n(n), i(0); i < _n; i++) {
forb[i] = (w[i] < threshold);
deg[i] = (int)g[i].size();
val[i] = 1;
del[i] = false;
used[i] = 0;
}
for (int _n(n), i(0); i < _n; i++) {
if (!used[i] && !forb[i]) solve(i);
}
return best >= k;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int _n(n), i(0); i < _n; i++) cin >> w[i];
for (int _n(n - 1), i(0); i < _n; i++) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
int lo = 0, hi = 1e6 + 10;
check(100000);
while (lo + 1 < hi) {
int m = (lo + hi) / 2;
if (check(m)) {
lo = m;
} else {
hi = m;
}
}
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;
const int N = 2e5 + 5;
int n, sz[N], a[N], c, ret, dp[N];
pair<int, int> m[N][2];
vector<int> adj[N];
void dfs(int x, int p) {
int f = 0, u, i, d;
dp[x] = 0;
if (!sz[x]) f = 1, ++sz[x];
d = a[x] >= c ? 1 : 0;
for (i = 0; i < adj[x].size(); ++i) {
u = adj[x][i];
if (u != p) {
dfs(u, x);
if (f) sz[x] += sz[u];
if (dp[u] == sz[u])
dp[x] += dp[u];
else {
if (m[x][0].first < dp[u])
m[x][1] = m[x][0], m[x][0] = make_pair(dp[u], u);
else if (m[x][1].first < dp[u])
m[x][1] = make_pair(dp[u], u);
}
}
}
dp[x] += d + m[x][0].first;
if (d == 0) dp[x] = 0;
ret = max(ret, dp[x]);
}
void dfs2(int x, int p, int d) {
int u, i, nd, t, v = 0;
if (d == n - sz[x]) v = d, d = 0;
ret = max(ret, (t = v + dp[x] - m[x][0].first + max(m[x][0].first, d)));
for (i = 0; i < adj[x].size(); ++i) {
u = adj[x][i];
if (u != p) {
nd = t;
if (m[x][0].second == u)
nd = dp[x] - m[x][0].first + max(m[x][1].first, d) + v;
else if (dp[u] == sz[u])
nd = t - sz[x];
if (a[x] < c) nd = 0;
dfs2(u, x, nd);
}
}
}
int main() {
int i, x, y, q, l, r, k, mid;
cin >> n >> k;
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
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);
l = 1, r = 1e6;
while (l < r) {
mid = (l + r + 1) / 2;
c = mid;
memset(dp, 0, sizeof(dp));
memset(m, 0, sizeof(m));
ret = 0;
dfs(1, 0);
dfs2(1, 0, 0);
if (ret >= k)
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
template <class T>
void maximize(T &u, const T &v) {
if (u < v) u = v;
}
int n, k;
vector<int> adj[N];
int a[N], b[N], good[N], dp[N];
int numChild[N], f[N];
void dfs(int u, int p) {
int sum = 0, maxVal = 0;
numChild[u] = 1;
for (int v : adj[u]) {
if (v == p) {
continue;
}
dfs(v, u);
numChild[u] += numChild[v];
if (f[v] == numChild[v]) {
sum += f[v];
} else {
maximize(maxVal, f[v]);
}
}
f[u] = sum + maxVal + 1;
if (!good[u]) {
f[u] = 0;
}
}
void reDfs(int u, int p, int up) {
int sum = 0, maxVal = 0;
vector<int> child;
for (int v : adj[u]) {
if (v == p) {
continue;
}
child.push_back(v);
if (f[v] == numChild[v]) {
sum += f[v];
} else {
maximize(maxVal, f[v]);
}
}
if (n - numChild[u] == up) {
sum += up;
} else {
maximize(maxVal, up);
}
dp[u] = sum + maxVal + 1;
if (!good[u]) {
dp[u] = 0;
}
int sz = child.size();
vector<pair<int, int> > sufDp(sz + 1);
vector<pair<int, int> > preDp(sz + 1);
preDp[0] = sufDp[sz] = make_pair(0, 0);
for (int i = 0; i < sz; i++) {
int v = child[i];
preDp[i + 1] = preDp[i];
if (f[v] == numChild[v]) {
preDp[i + 1].first += f[v];
} else {
maximize(preDp[i + 1].second, f[v]);
}
}
for (int i = sz - 1; i >= 0; i--) {
int v = child[i];
sufDp[i] = sufDp[i + 1];
if (f[v] == numChild[v]) {
sufDp[i].first += f[v];
} else {
maximize(sufDp[i].second, f[v]);
}
}
for (int i = 0; i < sz; i++) {
int v = child[i];
pair<int, int> cur = make_pair(0, 0);
cur.first = preDp[i].first + sufDp[i + 1].first;
cur.second = max(preDp[i].second, sufDp[i + 1].second);
if (up == n - numChild[u]) {
cur.first += up;
} else {
maximize(cur.second, up);
}
int nxtUp = cur.first + cur.second + 1;
if (!good[u]) {
nxtUp = 0;
}
reDfs(v, u, nxtUp);
}
}
bool check(int u) {
for (int i = 1; i <= n; i++) {
good[i] = (a[i] >= u);
}
dfs(1, 0);
reDfs(1, 0, 0);
for (int i = 1; i <= n; i++) {
if (dp[i] >= k) {
return 1;
}
}
return 0;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
b[i] = a[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 l = 0, r = 1000010;
while (r - l > 1) {
int m = (l + r) >> 1;
if (check(m)) {
l = m;
} else {
r = m;
}
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 100;
vector<int> Graf[N];
int T[N];
int Syn[N];
int MD[N];
int MG[N];
void Wczytaj(int n, int k) {
int i, v, u;
for (i = 1; i <= n; i++) scanf("%d", &T[i]);
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &v, &u);
Graf[v].push_back(u);
Graf[u].push_back(v);
}
}
void DFSIn(int v, int ojciec, int s) {
int i;
int ile, reszta;
Syn[v] = 1;
ile = reszta = 0;
for (i = 0; i < Graf[v].size(); i++) {
if (Graf[v][i] != ojciec) {
DFSIn(Graf[v][i], v, s);
Syn[v] += Syn[Graf[v][i]];
if (MD[Graf[v][i]] == Syn[Graf[v][i]])
ile += Syn[Graf[v][i]];
else
reszta = max(reszta, MD[Graf[v][i]]);
}
}
if (T[v] >= s) {
MD[v] = ile + reszta + 1;
} else
MD[v] = 0;
}
void DFSG(int v, int ojciec, int s, int z_gory, int n) {
if (Graf[v].size() == 1 && v != ojciec) {
if (T[v] >= s) MG[v] = 1 + z_gory;
return;
}
int i;
int p, d, aktu;
p = d = -1;
for (i = 0; i < Graf[v].size(); i++)
if (Graf[v][i] != ojciec && MD[Graf[v][i]] != Syn[Graf[v][i]])
p = d = Graf[v][i];
for (i = 0; i < Graf[v].size(); i++) {
if (Graf[v][i] != ojciec && MD[Graf[v][i]] != Syn[Graf[v][i]]) {
if (MD[Graf[v][i]] > MD[p]) {
d = p;
p = Graf[v][i];
} else {
if (MD[Graf[v][i]] >= MD[d]) d = Graf[v][i];
}
}
}
if (T[v] >= s) {
if (z_gory == n - Syn[v])
MG[v] = MD[v] + z_gory;
else {
if (z_gory > MD[p])
MG[v] = MD[v] - MD[p] + z_gory;
else {
if (MD[p] == 0)
MG[v] = MD[v] + z_gory;
else
MG[v] = MD[v];
}
}
}
for (i = 0; i < Graf[v].size(); i++) {
if (Graf[v][i] != ojciec) {
if (T[v] >= s) {
aktu = MG[v];
if (MD[Graf[v][i]] == Syn[Graf[v][i]])
DFSG(Graf[v][i], v, s, aktu - Syn[Graf[v][i]], n);
else {
if (z_gory == n - Syn[v]) {
if (p == d && Graf[v][i] == p)
DFSG(Graf[v][i], v, s, aktu - MD[p], n);
else {
if (Graf[v][i] == p)
DFSG(Graf[v][i], v, s, aktu - MD[p] + MD[d], n);
else
DFSG(Graf[v][i], v, s, aktu, n);
}
} else {
if (z_gory >= MD[p])
DFSG(Graf[v][i], v, s, aktu, n);
else {
if (p == d && Graf[v][i] == p) {
DFSG(Graf[v][i], v, s, aktu - MD[p] + z_gory, n);
} else {
if (p == Graf[v][i])
DFSG(Graf[v][i], v, s, aktu - MD[p] + max(z_gory, MD[d]), n);
else
DFSG(Graf[v][i], v, s, aktu, n);
}
}
}
}
} else {
DFSG(Graf[v][i], v, s, 0, n);
}
}
}
}
bool Sprawdz(int n, int s, int l) {
int i;
for (i = 1; i <= n; i++) MD[i] = MG[i] = 0;
DFSIn(1, 1, s);
DFSG(1, 1, s, 0, n);
for (i = 1; i <= n; i++) {
if (MG[i] >= l) return true;
}
return false;
}
int Wyszukaj(int p, int k, int l, int n) {
int s;
while (p < k) {
s = (p + k + 1) / 2;
if (Sprawdz(n, s, l))
p = s;
else
k = s - 1;
}
return p;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
Wczytaj(n, k);
printf("%d\n", Wyszukaj(0, 1000 * 1000 + 10, k, n));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
vector<int> g[maxn + 1];
int father[maxn + 1], a[maxn + 1];
int f[maxn + 1], fup[maxn + 1];
int n, K;
int result;
int ge[maxn + 1], upge[maxn + 1];
int MIN;
void init() {
int i, x, y;
scanf("%d%d", &n, &K);
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (i = 1; i < n; ++i) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
}
void calc_ge(int p, int fa) {
int i, j;
father[p] = fa;
ge[p] = 1;
for (i = 0; i < g[p].size(); ++i) {
j = g[p][i];
if (j != fa) {
calc_ge(j, p);
ge[p] += ge[j];
}
}
}
void calc_f(int p) {
int i, j, zd = 0, sum = 0;
if ((g[p].size() == 1) && (father[p] == g[p][0])) {
if (a[p] >= MIN)
f[p] = 1;
else
f[p] = 0;
return;
}
if (a[p] < MIN) {
f[p] = 0;
for (i = 0; i < g[p].size(); ++i) {
j = g[p][i];
if (j != father[p]) calc_f(j);
}
return;
}
for (i = 0; i < g[p].size(); ++i) {
j = g[p][i];
if (j != father[p]) {
calc_f(j);
if (f[j] == ge[j])
sum += f[j];
else {
if (f[j] > zd) zd = f[j];
}
}
}
f[p] = 1 + sum + zd;
}
void calc_fup(int p) {
int i, j, zd = 0, zd2 = 0, sum = 0;
if ((g[p].size() == 1) && (father[p] == g[p][0])) return;
if (a[p] < MIN) {
for (i = 0; i < g[p].size(); ++i) {
j = g[p][i];
if (j != father[p]) {
fup[j] = 0;
calc_fup(j);
}
}
return;
}
if (fup[p] == upge[p])
sum = fup[p];
else
zd = fup[p];
for (i = 0; i < g[p].size(); ++i) {
j = g[p][i];
if (j != father[p]) {
if (f[j] == ge[j])
sum += f[j];
else {
if (f[j] > zd) {
zd2 = zd;
zd = f[j];
} else if (f[j] > zd2)
zd2 = f[j];
}
}
}
for (i = 0; i < g[p].size(); ++i) {
j = g[p][i];
if (j != father[p]) {
if (f[j] == ge[j])
fup[j] = 1 + sum - f[j] + zd;
else if (f[j] == zd)
fup[j] = 1 + sum + zd2;
else
fup[j] = 1 + sum + zd;
}
}
for (i = 0; i < g[p].size(); ++i) {
j = g[p][i];
if (j != father[p]) calc_fup(j);
}
}
bool ky(int now) {
int p, i, j, sum, zd;
MIN = now;
calc_f(1);
fup[1] = 0;
calc_fup(1);
for (p = 1; p <= n; ++p) {
sum = zd = 0;
if (fup[p] == upge[p])
sum = fup[p];
else
zd = fup[p];
if (a[p] < MIN) continue;
for (i = 0; i < g[p].size(); ++i) {
j = g[p][i];
if (j != father[p]) {
if (f[j] == ge[j])
sum += f[j];
else {
if (f[j] > zd) zd = f[j];
}
}
}
if (1 + sum + zd >= K) return true;
}
return false;
}
void work() {
int i, start, stop, mid;
father[1] = 0;
calc_ge(1, 0);
for (i = 1; i <= n; ++i) upge[i] = n - ge[i];
start = 1;
stop = 1000010;
while (start <= stop) {
mid = (start + stop) / 2;
if (ky(mid)) {
result = mid;
start = mid + 1;
} else
stop = mid - 1;
}
}
void output() { printf("%d\n", result); }
int main() {
init();
work();
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int n, k, val[MAXN], rval[MAXN], sz[MAXN], dp[MAXN], udp[MAXN];
vector<int> adj[MAXN];
void unscrew(int s, int p = 0) {
sz[s] = 1;
for (auto &x : adj[s])
if (x == p) swap(x, adj[s][(int)adj[s].size() - 1]);
if (s > 1) adj[s].pop_back();
for (auto v : adj[s]) {
unscrew(v, s);
sz[s] += sz[v];
}
}
void dfs(int s) {
dp[s] = rval[s];
vector<int> poss;
for (auto v : adj[s]) {
dfs(v);
if (dp[v] == sz[v])
dp[s] += dp[v] * (dp[s] > 0);
else
poss.push_back(dp[v]);
}
if (!poss.empty()) {
int m = *max_element(poss.begin(), poss.end());
dp[s] += m * (dp[s] > 0);
}
}
void dfs2(int s) {
if (rval[s] == 0) {
for (auto v : adj[s]) {
udp[v] = 0;
dfs2(v);
}
return;
}
int sons = adj[s].size();
vector<int> psum(sons + 1), ssum(sons + 1), pmax(sons + 1), smax(sons + 1);
for (int i = 1; i <= sons; i++) {
psum[i] = psum[i - 1];
pmax[i] = pmax[i - 1];
int v = adj[s][i - 1];
if (dp[v] == sz[v])
psum[i] += sz[v];
else
pmax[i] = max(pmax[i], dp[v]);
}
for (int i = sons - 1; i >= 0; i--) {
ssum[i] = ssum[i + 1];
smax[i] = smax[i + 1];
int v = adj[s][i];
if (dp[v] == sz[v])
ssum[i] += sz[v];
else
smax[i] = max(smax[i], dp[v]);
}
for (int i = 0; i < sons; i++) {
int v = adj[s][i];
int ex = max(pmax[i], smax[i + 1]);
udp[v] = psum[i] + ssum[i + 1];
if (udp[s] == n - sz[s])
udp[v] += udp[s];
else
ex = max(ex, udp[s]);
udp[v] += ex + 1;
}
for (auto v : adj[s]) dfs2(v);
}
bool check(int m) {
for (int i = 1; i <= n; i++) rval[i] = (val[i] >= m);
dfs(1);
dfs2(1);
int ans = 0, cur = 0;
for (int u = 1; u <= n; u++) {
if (rval[u] == 0) continue;
cur = 1;
vector<int> poss;
for (auto v : adj[u]) {
if (dp[v] == sz[v])
cur += sz[v];
else
poss.push_back(dp[v]);
}
if (udp[u] == n - sz[u])
cur += udp[u];
else
poss.push_back(udp[u]);
if (poss.size()) cur += *max_element(poss.begin(), poss.end());
ans = max(ans, cur);
}
return (ans >= k);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> val[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);
}
unscrew(1);
int lo = 1, hi = 1000 * 1000;
while (lo < hi) {
int mi = (lo + hi + 1) / 2;
if (check(mi))
lo = mi;
else
hi = mi - 1;
}
cout << lo << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int N = 2e5 + 5;
vector<int> adj[N], ord;
int par[N], best[N], sz[N], a[N], go[N];
void dfs(int ind, int p = 0) {
int u, i;
par[ind] = p;
sz[ind] = 1;
for (i = 0; i < adj[ind].size(); ++i) {
u = adj[ind][i];
if (u != p) dfs(u, ind), sz[ind] += sz[u];
}
ord.push_back(ind);
}
bool check(int x) {
int u, v, i, j, t, top;
for (i = 1; i <= n; ++i) {
go[i] = a[i] >= x ? 1 : 0;
best[i] = 0;
}
for (i = 0; i < ord.size(); ++i) {
u = ord[i];
go[par[u]] += go[u];
}
for (i = 0; i < ord.size(); ++i) {
u = ord[i];
if (a[u] >= x) {
v = 0;
for (j = 0; j < adj[u].size(); ++j) {
if (adj[u][j] != par[u] && sz[adj[u][j]] == go[adj[u][j]])
v += go[adj[u][j]];
}
top = 0;
if (go[1] - go[u] == sz[1] - sz[u]) top = go[1] - go[u];
best[u] = 1;
if (top + 1 + v >= k) return 1;
for (j = 0; j < adj[u].size(); ++j) {
t = adj[u][j];
if (t != par[u] && sz[t] != go[t]) {
if (best[u] + best[t] + top + v >= k) return 1;
if (best[t] + 1 > best[u]) best[u] = best[t] + 1;
}
}
best[u] += v;
}
}
return 0;
}
int main() {
int i, j, u, b;
cin >> n >> k;
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (i = 0; i < n - 1; ++i)
scanf("%d%d", &u, &b), adj[u].push_back(b), adj[b].push_back(u);
int l = 1, r = 1e6, mid;
dfs(1, 0);
while (l < r) {
mid = (l + r + 1) / 2;
if (check(mid))
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200002];
int n, k, i, j, a[200002];
int f[200002];
int v, u;
int M, answ;
bool mark[200002];
int p[200002], deg[200002], dpd[200002], dpv[200002];
int h[200002], h2[200002];
int an;
void dfs1(int x) {
int i;
deg[x] = 1;
for (i = 0; i < g[x].size(); i++) {
int v = g[x][i];
if (v == p[x]) continue;
p[v] = x;
dfs1(v);
deg[x] += deg[v];
}
}
void dfs(int x) {
int i;
dpd[x] = (a[x] >= M);
h[x] = 0;
h2[x] = 0;
for (i = 0; i < g[x].size(); i++) {
int v = g[x][i];
if (v == p[x]) continue;
p[v] = x;
dfs(v);
if (dpd[v] == deg[v])
dpd[x] += dpd[v];
else {
if (dpd[v] + h[v] >= h[x]) {
h2[x] = h[x];
h[x] = dpd[v] + h[v];
} else
h2[x] = max(h2[x], dpd[v] + h[v]);
}
}
if (a[x] < M) {
dpd[x] = 0;
h[x] = 0;
h2[x] = 0;
}
an = max(an, dpd[x] + h[x]);
}
void dfs2(int x) {
int i;
if (a[x] >= M)
an = max(an, dpd[x] + dpv[x] + ((deg[1] - deg[x] == dpv[x]) ? h[x] : 0));
for (i = 0; i < g[x].size(); i++) {
int v = g[x][i];
if (v == p[x]) continue;
dpv[v] += dpd[x];
int f = h[x];
if (deg[v] == dpd[v])
dpv[v] -= dpd[v];
else if (dpd[v] + h[v] == h[x])
f = h2[x];
if (deg[1] - deg[x] == dpv[x])
dpv[v] += dpv[x] + f;
else
dpv[v] += max(f, dpv[x]);
if (a[x] < M || a[v] < M) dpv[v] = 0;
dfs2(v);
}
}
bool lava() {
int i, j;
an = 0;
memset(mark, 0, (n + 1) * (sizeof(bool)));
memset(dpv, 0, (n + 1) * (sizeof(int)));
memset(dpd, 0, (n + 1) * (sizeof(int)));
memset(h, 0, (n + 1) * (sizeof(int)));
memset(h2, 0, (n + 1) * (sizeof(int)));
dfs(1);
dpv[1] = 0;
dfs2(1);
return (an >= k);
}
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
f[i] = a[i];
}
sort(f + 1, f + n + 1);
for (i = 1; i < n; i++) {
scanf("%d%d", &v, &u);
g[v].push_back(u);
g[u].push_back(v);
}
p[1] = 1;
dfs1(1);
int S = 1;
int E = n - k + 1;
while (S <= E) {
int m = (S + E) / 2;
M = f[m];
if (lava()) {
S = m + 1;
answ = M;
} else
E = m - 1;
}
cout << answ << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int ta[200007];
vector<int> G[200007];
int roz[200007];
int ile[200007];
int dp[200007];
int ww[200007];
int ss;
int ileok;
bool chres;
void dfs1(int v, int p) {
roz[v] = 1;
ile[v] = 0;
if (ta[v] >= ss) ile[v] = 1;
for (int i = 0; i < G[v].size(); ++i) {
if (G[v][i] != p) {
dfs1(G[v][i], v);
roz[v] += roz[G[v][i]];
ile[v] += ile[G[v][i]];
}
}
}
void dfs2(int v, int p) {
dp[v] = 1;
int maxi = 0;
for (int i = 0; i < G[v].size(); ++i) {
if (G[v][i] != p) {
dfs2(G[v][i], v);
if (roz[G[v][i]] == ile[G[v][i]])
dp[v] += roz[G[v][i]];
else
maxi = max(maxi, dp[G[v][i]]);
}
}
dp[v] += maxi;
if (ta[v] < ss) dp[v] = 0;
}
void dfs3(int v, int p, int ndp = 0) {
int summ = 0;
int maxi = 0;
int gd = -1;
int dmaxi = 0;
if (n - roz[v] == ileok - ile[v])
summ += n - roz[v];
else {
maxi = ndp;
}
for (int i = 0; i < G[v].size(); ++i) {
if (G[v][i] != p) {
if (roz[G[v][i]] == ile[G[v][i]])
summ += roz[G[v][i]];
else {
if (dp[G[v][i]] > maxi) {
dmaxi = maxi;
maxi = dp[G[v][i]];
gd = i;
} else if (dp[G[v][i]] > dmaxi)
dmaxi = dp[G[v][i]];
}
}
}
ww[v] = summ + maxi + 1;
if (ta[v] >= ss && ww[v] >= k) chres = 1;
for (int i = 0; i < G[v].size(); ++i) {
if (G[v][i] != p) {
int np = summ + 1;
if (roz[G[v][i]] == ile[G[v][i]]) np -= roz[G[v][i]];
if (i == gd)
np += dmaxi;
else
np += maxi;
if (ta[v] < ss) np = 0;
dfs3(G[v][i], v, np);
}
}
}
bool check() {
chres = 0;
ileok = 0;
for (int i = 1; i <= n; ++i)
if (ta[i] >= ss) ileok++;
dfs1(1, 0);
dfs2(1, 0);
dfs3(1, 0);
return chres;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> ta[i];
for (int i = 1; i < n; ++i) {
int c, d;
cin >> c >> d;
G[c].push_back(d);
G[d].push_back(c);
}
int pp = 0;
int kk = 1000007;
int wynik = 0;
while (pp <= kk) {
ss = (pp + kk) / 2;
if (check()) {
pp = ss + 1;
wynik = ss;
} else
kk = ss - 1;
}
cout << wynik << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, u, v, q, r, ql, qr, k, l, s, w, z, x, y, d;
const int N = 2e5 + 500;
const int LN = 20;
const long long mod = 1e9 + 7;
const long long INF = 1LL << 52LL;
bool mn[N], pmn[N];
int a[N], dp[N], sz[N];
int full[N];
vector<int> max_pref[N];
vector<int> adj[N];
int sol = 0;
void dfs(int v, int p, int val) {
max_pref[v].push_back(0);
mn[v] = true;
sz[v] = 1;
for (int u : adj[v]) {
if (u == p) continue;
dfs(u, v, val);
mn[v] &= mn[u];
if (mn[u])
full[v] += sz[u];
else {
max_pref[v].push_back(dp[u]);
}
sz[v] += sz[u];
}
full[v]++;
if (a[v] < val) {
mn[v] = full[v] = dp[v] = 0;
max_pref[v].clear();
max_pref[v].push_back(0);
return;
}
sort(max_pref[v].begin(), max_pref[v].end());
reverse(max_pref[v].begin(), max_pref[v].end());
dp[v] = full[v] + max_pref[v][0];
}
void dfs2(int v, int p, int val, bool pd, int ss) {
if (a[v] < val) {
} else {
if (pd) {
sol = max(sol, full[v] + max_pref[v][0] + ss);
} else {
sol = max(sol, full[v] + max(max_pref[v][0], ss));
}
}
if (a[v] >= val && pd)
full[v] += ss;
else if (a[v] >= val) {
max_pref[v].push_back(ss);
sort(max_pref[v].begin(), max_pref[v].end());
reverse(max_pref[v].begin(), max_pref[v].end());
}
for (int u : adj[v]) {
if (u == p) continue;
if (mn[u]) {
dfs2(u, v, val, (full[v] == n),
max(0, (full[v] - sz[u]) + max_pref[v][0]));
} else {
dfs2(u, v, val, (n - full[v] == sz[u]),
full[v] +
(dp[u] == max_pref[v][0] ? max_pref[v][1] : max_pref[v][0]));
}
}
}
bool check(int val) {
for (int i = 1; i <= n; ++i) {
max_pref[i].clear();
dp[i] = 0;
mn[i] = false;
full[i] = 0;
sz[i] = 0;
}
dfs(1, 0, val);
sol = 0;
dfs2(1, 0, val, true, 0);
return (sol >= k);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
int lo = INT_MAX;
int hi = -lo;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
lo = min(lo, a[i]);
hi = max(hi, a[i]);
}
for (int i = 0; i < n - 1; ++i) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
if (check(mid))
lo = mid;
else
hi = mid - 1;
}
cout << lo << '\n';
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 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(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;
const int N = 2e5 + 5;
int n, sz[N], a[N], c, ret, dp[N];
pair<int, int> m[N][2];
vector<int> adj[N];
void dfs(int x, int p) {
int f = 0, u, i, d;
dp[x] = 0;
if (!sz[x]) f = 1, ++sz[x];
d = a[x] >= c ? 1 : 0;
for (i = 0; i < adj[x].size(); ++i) {
u = adj[x][i];
if (u != p) {
dfs(u, x);
if (f) sz[x] += sz[u];
if (dp[u] == sz[u])
dp[x] += dp[u];
else {
if (m[x][0].first <= dp[u])
m[x][1] = m[x][0], m[x][0] = make_pair(dp[u], u);
else if (m[x][1].first < dp[u])
m[x][1] = make_pair(dp[u], u);
}
}
}
dp[x] += d + m[x][0].first;
if (d == 0) dp[x] = 0;
}
int ar[3];
void dfs2(int x, int p, int d) {
int v = 0, u, i, t = d, nd;
if (a[x] >= c) {
if (d == n - sz[x]) v = d, t = 0;
ar[0] = m[x][0].first, ar[1] = m[x][1].first, ar[2] = t;
sort(ar, ar + 3);
ret = max(ret, dp[x] + ar[2] + ar[1] + v - m[x][0].first);
}
for (i = 0; i < adj[x].size(); ++i) {
u = adj[x][i];
if (u != p) {
nd = dp[x] - m[x][0].first + max(m[x][0].first, t) + v;
if (u == m[x][0].second)
nd = dp[x] - m[x][0].first + max(m[x][1].first, t) + v;
else if (sz[u] == dp[u])
nd -= sz[u];
if (a[x] < c) nd = 0;
dfs2(u, x, nd);
}
}
}
int main() {
int i, x, y, q, l, r, k, mid;
cin >> n >> k;
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
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);
l = 1, r = 1e6;
while (l < r) {
mid = (l + r + 1) / 2;
c = mid;
memset(m, 0, sizeof(m));
ret = 0;
dfs(1, 0);
dfs2(1, 0, 0);
if (ret >= k)
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, K, a[maxn], all[maxn], f[maxn];
multiset<int> S[maxn];
vector<int> G[maxn];
int main() {
scanf("%d %d", &n, &K);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int _ = 1, u, v; _ < n; _++) {
scanf("%d %d", &u, &v);
G[u].push_back(v), G[v].push_back(u);
}
auto chk = [&](int x) {
function<void(int, int)> dfs1 = [&](int v, int fa) {
f[v] = 1, all[v] = 0, S[v].clear();
for (int u : G[v])
if (u ^ fa) {
dfs1(u, v);
if (a[u] >= x) {
if (all[u])
all[v]++, S[v].insert(f[u]);
else
f[v] += f[u];
} else {
all[v]++;
}
}
if (a[v] < x)
f[v] = 0, all[v] = n + 1;
else if (!S[v].empty())
f[v] += *S[v].rbegin();
};
dfs1(1, 0);
bool flag = 0;
function<void(int, int)> dfs2 = [&](int v, int fa) {
if (a[v] >= x && f[v] >= K) flag = 1;
for (int u : G[v])
if (u ^ fa) {
if (all[u]) all[v]--;
if (a[v] >= x && !S[v].empty()) f[v] -= *S[v].rbegin();
if (a[u] >= x) {
if (all[u])
S[v].erase(S[v].find(f[u]));
else
f[v] -= f[u];
}
if (a[v] >= x && !S[v].empty()) f[v] += *S[v].rbegin();
if (a[u] >= x && !S[u].empty()) f[u] -= *S[u].rbegin();
if (all[v]) all[u]++;
if (a[v] >= x) {
if (all[v])
S[u].insert(f[v]);
else
f[u] += f[v];
}
if (a[u] >= x && !S[u].empty()) f[u] += *S[u].rbegin();
dfs2(u, v);
if (a[u] >= x && !S[u].empty()) f[u] -= *S[u].rbegin();
if (all[v]) all[u]--;
if (a[v] >= x) {
if (all[v])
S[u].erase(S[u].find(f[v]));
else
f[u] -= f[v];
}
if (a[u] >= x && !S[u].empty()) f[u] += *S[u].rbegin();
if (a[v] >= x && !S[v].empty()) f[v] -= *S[v].rbegin();
if (all[u]) all[v]++;
if (a[u] >= x) {
if (all[u])
S[v].insert(f[u]);
else
f[v] += f[u];
}
if (a[v] >= x && !S[v].empty()) f[v] += *S[v].rbegin();
}
};
dfs2(1, 0);
return flag;
};
int l = 1, r = 1000000, ans;
while (l <= r) {
int mid = (l + r) >> 1;
chk(mid) ? l = (ans = mid) + 1 : r = mid - 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[300001], sz[300001], sum[300001], best;
vector<int> w[300001];
void proc(int u, int p, int lim) {
sz[u] = 1;
sum[u] = (a[u] >= lim);
for (int v : w[u])
if (v != p) proc(v, u, lim), sz[u] += sz[v], sum[u] += sum[v];
}
int dfs(int u, int p, int lim) {
int cnt = 1, max1 = 0, max2 = 0;
for (int v : w[u])
if (v != p) {
int cur = dfs(v, u, lim);
if (cur == sz[v])
cnt += cur;
else if (cur > max1)
max2 = max1, max1 = cur;
else if (cur > max2)
max2 = cur;
}
if (a[u] < lim) return 0;
if (sz[1] - sz[u] == sum[1] - sum[u])
best = max(best, cnt + max1 + max2 + sz[1] - sz[u]);
else
best = max(best, cnt + max1 + max2);
return cnt + max1;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1, x, y; i < n; i++)
scanf("%d%d", &x, &y), w[x].push_back(y), w[y].push_back(x);
int l = 1, r = 1000000, ans = 0;
while (l <= r) {
int m = (l + r) / 2;
best = 0;
proc(1, 0, m);
dfs(1, 0, m);
if (best >= k)
l = m + 1, ans = m;
else
r = m - 1;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k;
int arr[N];
int a, b;
vector<int> v[N];
int tmp[N];
int subtree1[N];
int subtree2[N];
int sum[N];
int bst1[N];
int bst2[N];
bool ret;
void dfs(int node, int parent) {
subtree1[node] = 1;
subtree2[node] = tmp[node];
for (int next : v[node]) {
if (next != parent) {
dfs(next, node);
subtree1[node] += subtree1[next];
subtree2[node] += subtree2[next];
}
}
}
void dfs1(int node, int parent) {
sum[node] = 0;
bst1[node] = 0;
bst2[node] = 0;
for (int next : v[node]) {
if (next != parent) {
dfs1(next, node);
if (subtree2[next] == subtree1[next]) {
sum[node] += subtree1[next];
} else {
if (sum[next] > bst1[node]) {
bst2[node] = bst1[node];
bst1[node] = sum[next];
} else if (sum[next] > bst2[node]) {
bst2[node] = sum[next];
}
}
}
}
if (tmp[node]) {
++sum[node];
sum[node] += bst1[node];
} else {
sum[node] = 0;
bst1[node] = 0;
bst2[node] = 0;
}
ret |= (sum[node] >= k);
}
void dfs2(int node, int parent, int val) {
if (val == n - subtree1[node]) {
sum[node] += val;
} else {
sum[node] -= bst1[node];
if (val > bst1[node]) {
bst2[node] = bst1[node];
bst1[node] = val;
} else if (val > bst2[node]) {
bst2[node] = val;
}
sum[node] += bst1[node];
}
if (!tmp[node]) {
sum[node] = 0;
bst1[node] = 0;
bst2[node] = 0;
}
ret |= (sum[node] >= k);
for (int next : v[node]) {
if (next != parent) {
if (subtree1[next] == subtree2[next]) {
dfs2(next, node, sum[node] - subtree1[next]);
} else if (bst1[node] == sum[next]) {
dfs2(next, node, sum[node] - bst1[node] + bst2[node]);
} else {
dfs2(next, node, sum[node]);
}
}
}
}
bool check(int val) {
for (int i = 1; i <= n; ++i) {
tmp[i] = (arr[i] >= val);
}
ret = 0;
dfs(1, 0);
dfs1(1, 0);
if (ret) {
return 1;
}
dfs2(1, 0, 0);
return ret;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", arr + i);
}
for (int i = 1; i < n; ++i) {
scanf("%d %d", &a, &b);
v[a].emplace_back(b);
v[b].emplace_back(a);
}
int l = 1;
int r = 1e6 + 1;
while (l < r) {
int mid = l + r >> 1;
if (check(mid)) {
l = mid + 1;
} else {
r = mid;
}
}
printf("%d\n", l - 1);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int all[200011];
int sz[200011];
int dp[200011];
int a[200011];
int pref[200011];
vector<int> g[200011];
int dfs(int v, int p, int val) {
sz[v] = 1;
int second = 0;
vector<int> child;
int ret = 0;
for (auto x : g[v]) {
if (x != p) {
ret = max(ret, dfs(x, v, val));
sz[v] += sz[x];
if (all[x])
second += sz[x];
else {
child.push_back(x);
}
}
}
all[v] = 0;
pref[v] = 0;
dp[v] = 0;
if (a[v] < val) {
return ret;
}
if (child.size() == 0) {
all[v] = 1;
pref[v] = second + 1;
dp[v] = second + 1;
ret = max(ret, dp[v]);
return ret;
}
if (child.size() == 1) {
int x = child[0];
pref[v] = pref[x] + second + 1;
dp[v] = dp[x] + second + 1;
ret = max(ret, dp[v]);
return ret;
}
int mx1 = 0;
int mx2 = 0;
for (auto x : child) {
if (mx1 < pref[x]) {
mx2 = mx1;
mx1 = pref[x];
} else {
mx2 = max(mx2, pref[x]);
}
}
dp[v] = second + mx1 + mx2 + 1;
pref[v] = second + mx1 + 1;
ret = max(ret, dp[v]);
return ret;
}
bool ok(int x) {
int r = dfs(1, 0, x);
if (r >= k) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n >> k;
int lo = 0;
int hi = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
hi = max(hi, a[i]);
}
int u, v;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
hi++;
int mid;
while (hi - lo > 1) {
mid = (hi + lo) / 2;
if (ok(mid))
lo = mid;
else
hi = mid;
}
cout << lo;
}
|
#include <bits/stdc++.h>
inline long long read() {
long long x = 0;
char c = getchar(), f = 1;
for (; c < '0' || '9' < c; c = getchar())
if (c == '-') f = -1;
for (; '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return x * f;
}
inline void write(long long x) {
static char buf[20];
int len = 0;
if (x < 0) putchar('-'), x = -x;
for (; x; x /= 10) buf[len++] = x % 10 + '0';
if (!len)
putchar('0');
else
while (len) putchar(buf[--len]);
}
inline void writesp(long long x) {
write(x);
putchar(' ');
}
inline void writeln(long long x) {
write(x);
putchar('\n');
}
struct edge {
int to, nxt;
} e[2 * 200010];
int fir[200010], a[200010], full[200010], f[200010];
int n, m, tot;
inline void add_edge(int x, int y) {
e[tot].to = y;
e[tot].nxt = fir[x];
fir[x] = tot++;
}
int dfs(int now, int fa, int mid) {
full[now] = (a[now] <= mid);
int delta = 1, mx1 = 0, mx2 = 0, ret = 0;
for (int i = fir[now]; ~i; i = e[i].nxt)
if (e[i].to != fa) {
ret = std::max(ret, dfs(e[i].to, now, mid));
if (full[e[i].to])
delta += f[e[i].to];
else if (f[e[i].to] > mx1)
mx2 = mx1, mx1 = f[e[i].to];
else if (f[e[i].to] > mx2)
mx2 = f[e[i].to];
full[now] &= full[e[i].to];
}
if (a[now] <= mid) {
ret = std::max(ret, mx1 + mx2 + delta);
f[now] = mx1 + delta;
} else
f[now] = 0;
return ret;
}
int main() {
n = read();
m = read();
int mx = 0;
for (int i = 1; i <= n; i++) {
a[i] = read();
mx = std::max(mx, a[i]);
}
int mxid = 1;
for (int i = 2; i <= n; i++)
if (a[i] < a[mxid]) mxid = i;
memset(fir, 255, sizeof(fir));
tot = 0;
for (int i = 1; i < n; i++) {
int x = read(), y = read();
add_edge(x, y);
add_edge(y, x);
}
for (int i = 1; i <= n; i++) a[i] = -a[i];
int l = -mx, r = -1;
while (l < r) {
int mid = (l + r) >> 1;
if (dfs(mxid, -1, mid) >= m)
r = mid;
else
l = mid + 1;
}
writeln(-l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[200000];
bool good[200000];
int sts[200000], stg[200000], downv[200000];
void dfs(int v, int p) {
sts[v] = 1;
stg[v] = (int)good[v];
for (int u : adj[v])
if (u != p) {
dfs(u, v);
sts[v] += sts[u];
stg[v] += stg[u];
}
}
void dfs2(int v, int p) {
if (!good[v]) {
for (int u : adj[v])
if (u != p) dfs2(u, v);
downv[v] = INT_MIN;
} else {
int extra = 0, best = 0;
for (int u : adj[v])
if (u != p) {
dfs2(u, v);
if (sts[u] == stg[u])
extra += sts[u];
else
best = max(best, downv[u]);
}
downv[v] = 1 + extra + best;
}
}
int dfs3(int v, int p) {
int result = 0;
for (int u : adj[v])
if (u != p) result = max(result, dfs3(u, v));
if (good[v]) {
int extra = 0, best0 = 0, best1 = 0;
if (sts[0] - sts[v] == stg[0] - stg[v]) extra += sts[0] - sts[v];
for (int u : adj[v])
if (u != p) {
if (sts[u] == stg[u])
extra += sts[u];
else if (downv[u] > best1) {
best1 = downv[u];
if (best1 > best0) swap(best1, best0);
}
}
result = max(result, 1 + extra + best0 + best1);
}
return result;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<int> value(n);
for (int &v : value) scanf("%d", &v);
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d %d", &a, &b), --a, --b;
adj[a].push_back(b);
adj[b].push_back(a);
}
int l = 0, r = 1000000;
while (l < r) {
int m = (l + r + 1) / 2;
for (int i = 0; i < n; ++i) good[i] = (value[i] >= m);
dfs(0, -1);
dfs2(0, -1);
if (dfs3(0, -1) >= k)
l = m;
else
r = m - 1;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> near[200010];
int sz[200010], a[200010];
bool f = false;
int setsz(int now, int prv) {
int &res = sz[now];
for (int x : near[now])
if (x - prv) res += setsz(x, now);
return ++res;
}
pair<int, int> check(int now, int prv, int x) {
int fix = 1;
int wild1 = 0, wild2 = 0;
int bench = 0, wildcnt = 0;
for (int y : near[now]) {
if (y - prv) {
pair<int, int> temp = check(y, now, x);
int v = temp.first;
if (v == sz[y])
fix += v;
else {
wildcnt++;
if (v > wild1) {
swap(wild1, wild2);
wild1 = v;
bench = temp.second;
} else if (v > wild2)
wild2 = v;
}
}
}
if (a[now] >= x) {
if (wildcnt < 2) {
f |= (fix + wild1 + bench >= k);
return make_pair((fix + wild1), (bench));
} else {
f |= (fix + wild1 + wild2 >= k);
return make_pair((fix + wild1), (wild2));
}
} else
return make_pair((0), (0));
}
int bins(int l, int r) {
int mid = (l + r) / 2;
if (l > r) return r;
f = false;
check(1, 1, mid);
if (f)
return bins(mid + 1, r);
else
return bins(l, mid - 1);
}
int main() {
ios_base::sync_with_stdio(false);
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;
near[u].push_back(v);
near[v].push_back(u);
}
sz[1] = setsz(1, 1);
cout << bins(0, 1000000000) << endl;
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 (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;
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<pair<int, int> > ed;
bool read() {
if (!(cin >> n >> k)) {
return false;
}
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i + 1 < n; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
ed.push_back(make_pair(u, v));
}
return true;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
int ans;
void write() { cout << ans << "\n"; }
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
const int N = 2e5;
struct Solution : Data {
vector<pair<int, int> > g[N];
list<pair<int, int> > q[N];
pair<pair<int, int>, pair<int, int> > acc[N];
pair<int, int> d[3 * N];
int bound;
bool includedInAcc(int u, int w) {
return w != -1 &&
find_if((q[u]).begin(), (q[u]).end(), [&w](pair<int, int> const& x) {
return x.first == w;
}) == q[u].end();
}
void update(pair<pair<int, int>, pair<int, int> >& a,
pair<int, int> const& b) {
if (b.first == 0) {
a.first.second += b.second;
} else {
++a.first.first;
if (a.second.first < b.second) {
a.second.second = a.second.first;
a.second.first = b.second;
} else if (a.second.second < b.second) {
a.second.second = b.second;
}
}
}
pair<int, int> extract(pair<pair<int, int>, pair<int, int> > const& a,
pair<int, int> const& b) {
pair<int, int> r;
if (a.first.first - b.first == 0) {
r.first = 0;
r.second = a.first.second - (b.first ? 0 : b.second);
} else {
r.first = 1;
if (b.first == 0) {
r.second = a.first.second - b.second + a.second.first;
} else {
r.second =
a.first.second +
((a.second.first == b.second) ? a.second.second : a.second.first);
}
}
return r;
}
pair<int, int>& get(int u, int w, int e) {
return d[(w == -1) ? (2 * (n - 1) + u) : e];
}
pair<int, int> go(int u, int w = -1, int e = -1) {
if (a[u] < bound) {
return pair<int, int>(1, 0);
}
pair<pair<int, int>, pair<int, int> >& ra = acc[u];
for (auto it = q[u].begin(); it != q[u].end();) {
int v = it->first, f = it->second;
if (w == v) {
++it;
continue;
}
update(ra, go(v, u, f));
it = q[u].erase(it);
}
pair<int, int>& r = get(u, w, e);
r = extract(ra, (includedInAcc(u, w) ? get(w, u, e ^ 1) : make_pair(0, 0)));
++r.second;
return r;
}
bool ok(int x) {
bound = x;
for (int i = 0; i < n; ++i) {
acc[i] = make_pair(make_pair(0, 0), make_pair(0, 0));
q[i].clear();
q[i].insert(q[i].begin(), (g[i]).begin(), (g[i]).end());
}
for (int i = 0; i < n; ++i) {
if (go(i).second >= k) {
return true;
}
}
return false;
}
void solve() {
for (int i = 0; i < ((int)(ed).size()); ++i) {
int u = ed[i].first, v = ed[i].second;
g[u].push_back(make_pair(v, 2 * i));
g[v].push_back(make_pair(u, 2 * i + 1));
}
vector<int> b = a;
sort((b).begin(), (b).end());
int left = 0, right = ((int)(b).size());
while (left + 1 < right) {
int middle = (left + right) / 2;
if (ok(b[middle])) {
left = middle;
} else {
right = middle;
}
}
ans = b[left];
}
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 int N = 2e5 + 25;
vector<int> G[N];
int n, k, u, v, a[N], res;
int f[N], g[N];
bool pre_ok[N], ok[N];
void pre_dfs(int u, int p, int mn) {
int mx = 0;
pre_ok[u] = 1;
f[u] = 0;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v == p) continue;
pre_dfs(v, u, mn);
if (pre_ok[v])
f[u] += f[v];
else {
pre_ok[u] = 0;
mx = max(mx, f[v]);
}
}
if (a[u] < mn)
f[u] = 0, pre_ok[u] = 0;
else
f[u] += mx + 1;
}
void dfs(int u, int p, int mn) {
int p1, p2;
p1 = p2 = -1;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v == p || pre_ok[v]) continue;
if (p1 == -1 || f[p1] < f[v])
p2 = p1, p1 = v;
else if (p2 == -1 || f[p2] < f[v])
p2 = v;
}
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v == p) continue;
if (a[u] < mn) {
ok[v] = 0;
g[v] = 0;
} else {
int val = 0;
if (pre_ok[v]) {
g[v] = f[u] - f[v];
if (p1 != -1) val = f[p1];
} else {
if (v == p1) {
g[v] = f[u] - f[p1];
if (p2 != -1) {
g[v] += f[p2];
val = f[p2];
}
} else {
g[v] = f[u];
val = f[p1];
}
}
if (!ok[u]) {
if (val < g[u]) g[v] = g[v] - val + g[u];
ok[v] = 0;
} else {
g[v] += g[u];
if (p1 != -1 && v != p1)
ok[v] = 0;
else if (p2 != -1 && v != p2)
ok[v] = 0;
else
ok[v] = 1;
}
}
dfs(v, u, mn);
}
int ans = f[u];
if (!ok[u]) {
if (p1 != -1 && g[u] > f[p1]) ans = ans - f[p1] + g[u];
} else
ans += g[u];
res = max(res, ans);
}
bool check(int x) {
for (int i = 1; i <= n; ++i) ok[i] = 1;
res = 0;
pre_dfs(1, 1, x);
dfs(1, 1, x);
return res >= k;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
int l = 1, r = 1000000;
while (l < r) {
int m = (l + r + 1) >> 1;
if (check(m))
l = m;
else
r = m - 1;
}
cout << l;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[200010], fst[200010], num, sz[200010], deg[200010], mx1[200010],
mx2[200010], mx1n[200010], nfn[200010];
struct edge {
int x, y, n;
} e[400010];
pair<int, int> es[200010];
bool v[200010], full[200010];
void ins(int x, int y) {
e[++num] = {x, y, fst[x]};
fst[x] = num;
}
void dfs1(int x, int f, int bound) {
v[x] = 1;
sz[x] = 1;
int hh = 0;
full[x] = 1;
mx1[x] = 1;
mx2[x] = 0;
nfn[x] = 0;
mx1n[x] = 0;
int fnum = 0;
for (int i = fst[x]; i; i = e[i].n) {
int y = e[i].y;
if (y == f || a[y] < bound) continue;
dfs1(y, x, bound);
sz[x] += sz[y];
full[x] &= full[y];
if (!full[y] && ~nfn[x]) {
if (!nfn[x])
nfn[x] = y;
else
nfn[x] = -1;
}
hh++;
if (full[y])
fnum += sz[y];
else {
if (mx1[y] + 1 > mx1[x]) {
mx2[x] = mx1[x];
mx1[x] = mx1[y] + 1;
mx1n[x] = y;
} else if (mx1[y] + 1 > mx2[x]) {
mx2[x] = mx1[y] + 1;
}
}
}
if (hh != deg[x] - (f != 0)) {
full[x] = 0;
nfn[x] = -1;
}
mx1[x] += fnum;
if (mx1n[x]) mx2[x] += fnum;
}
int dfs2(int x, int f, int fmx, bool ffull) {
int fnum = 0;
for (int i = fst[x]; i; i = e[i].n) {
int y = e[i].y;
if (y != f && full[y]) fnum += sz[y];
}
int ans, hh = 0, anss;
if (ffull) {
ans = fmx + mx1[x];
hh = mx1n[x];
} else {
int fnum = 1;
ans = fmx;
for (int i = fst[x]; i; i = e[i].n) {
int y = e[i].y;
if (y == f) continue;
if (full[y])
fnum += sz[y];
else if (mx1[y] > ans) {
ans = mx1[y];
hh = y;
}
}
ans += fnum;
}
anss = ans;
for (int i = fst[x]; i; i = e[i].n) {
int y = e[i].y;
if (full[y] || y == f) continue;
ans = max(ans, dfs2(y, x, (y == hh ? anss - mx1[x] + mx2[x] : anss),
ffull && nfn[x] == y));
}
return ans;
}
int wk(int x) { return dfs2(x, 0, 0, 1); }
bool chk(int x) {
memset(fst, 0, sizeof(fst));
memset(v, 0, sizeof(v));
num = 0;
for (int i = 1; i < n; i++)
if (a[es[i].first] >= x && a[es[i].second] >= x) {
ins(es[i].first, es[i].second);
ins(es[i].second, es[i].first);
}
for (int i = 1; i <= n; i++)
if (!v[i] && a[i] >= x) {
dfs1(i, 0, x);
if (sz[i] >= k && wk(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++) {
scanf("%d%d", &es[i].first, &es[i].second);
deg[es[i].first]++;
deg[es[i].second]++;
}
int l = 1, len = 1000000000;
while (len) {
int md = l + (len >> 1);
if (chk(md)) {
l = md + 1;
len = len - (len >> 1) - 1;
} else
len >>= 1;
}
printf("%d\n", l - 1);
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int l, int r) { return l + rng() % (r - l + 1); }
const int N = 200010;
int n, k, suc;
int a[N], val[N];
int sz[N], s2[N], s1[N], i2[N], i1[N], f[N], g[N];
vector<int> ad[N];
void addsub(int u, int v, int val) {
if (val > s2[u]) s2[u] = val, i2[u] = v;
if (val > s1[u]) swap(s2[u], s1[u]), swap(i2[u], i1[u]);
}
void dfs1(int u, int p = -1) {
sz[u] = 1;
int base = 0;
for (auto& v : ad[u])
if (v != p) {
dfs1(v, u);
sz[u] += sz[v];
if (sz[v] == f[v])
f[u] += f[v];
else if (a[v])
addsub(u, v, f[v] + s1[v]);
}
f[u] = a[u] ? f[u] + 1 : 0;
}
void dfs2(int u, int p = -1) {
if (suc) return;
for (auto& v : ad[u])
if (v != p) {
int ret;
if (a[u]) {
int wo = f[v] == sz[v] ? f[u] - f[v] : f[u];
int sub = i1[u] == v ? s2[u] : s1[u];
g[v] = g[u] == n - sz[u] ? g[u] + wo + sub : wo + max(sub, g[u]);
if (g[v] == n - sz[v] + 1)
ret = g[v] + f[v] + s1[v];
else
ret = f[v] + max(s1[v], g[v]);
} else {
ret = f[v] + s1[v];
}
if (ret >= k) {
suc = 1;
return;
}
dfs2(v, u);
}
}
int chk(int lw) {
for (int i = 1, _c = n; i <= _c; ++i) a[i] = val[i] >= lw;
memset(s1, 0, sizeof(s1));
memset(s2, 0, sizeof(s2));
memset(i1, 0, sizeof(i1));
memset(i2, 0, sizeof(i2));
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
dfs1(1);
suc = 0;
dfs2(1);
return suc;
}
int main() {
n = ({
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
n ? -x : x;
}),
k = ({
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
n ? -x : x;
});
for (int i = 1, _c = n; i <= _c; ++i)
val[i] = ({
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
n ? -x : x;
});
for (int i = 2, _c = n; i <= _c; ++i) {
int u = ({
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
n ? -x : x;
}),
v = ({
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
n ? -x : x;
});
ad[u].push_back(v);
ad[v].push_back(u);
}
int le = 1, mi, ri = 1000000, ret;
while (le <= ri) {
mi = (le + ri) / 2;
if (chk(mi))
ret = mi, le = mi + 1;
else
ri = mi - 1;
}
cout << ret;
}
|
#include <bits/stdc++.h>
std::vector<int> E[200001];
int N, K, q[200001], fa[200001], size[200001], a[200001], f[200001], g[200001];
void BFS() {
int H = 0, T = 1;
q[1] = 1;
while (H < T) {
int u = q[++H];
for (int v : E[u])
if (v != fa[u]) fa[q[++T] = v] = u;
}
for (int i = 1; i <= N; i++) size[i] = 1;
for (int i = N; i > 1; i--) size[fa[q[i]]] += size[q[i]];
}
inline void cmax(int &x, int y) {
if (y > x) x = y;
}
inline void cmax(int &x, int &y, int z) {
if (z > x)
y = x, x = z;
else if (z > y)
y = z;
}
bool check(int lim) {
for (int i = N; i; i--) {
int u = q[i];
if (a[u] < lim) {
f[u] = 0;
continue;
}
f[u] = 1;
int Max = 0;
for (int v : E[u])
if (v != fa[u]) {
if (f[v] == size[v])
f[u] += f[v];
else
cmax(Max, f[v]);
}
f[u] += Max;
}
for (int i = 1; i <= N; i++) {
int u = q[i], S = 1, Max1 = 0, Max2 = 0;
if (a[u] < lim) {
for (int v : E[u])
if (v != fa[u]) g[v] = 0;
continue;
}
if (u > 1) {
if (g[u] == N - size[u])
S += g[u];
else
cmax(Max1, Max2, g[u]);
}
for (int v : E[u])
if (v != fa[u]) {
if (f[v] == size[v])
S += f[v];
else
cmax(Max1, Max2, f[v]);
}
if (S + Max1 >= K) return true;
for (int v : E[u])
if (v != fa[u]) {
if (f[v] == size[v])
g[v] = S - f[v] + Max1;
else
g[v] = S + (f[v] == Max1 ? Max2 : Max1);
}
}
return false;
}
int main() {
scanf("%d%d", &N, &K);
for (int i = 1; i <= N; i++) scanf("%d", a + i);
for (int i = 1, u, v; i < N; i++) {
scanf("%d%d", &u, &v);
E[u].push_back(v);
E[v].push_back(u);
}
BFS();
int l = 1, r = 1000000;
while (l < r) {
int m = l + r + 1 >> 1;
if (check(m))
l = m;
else
r = m - 1;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int N = 300000;
int ai[N];
vector<int> bi[N], ch[N];
struct vec {
int i, j, k;
};
vector<vec> Lm[N], Rm[N];
vec F[N];
int M, OK;
vec operator+(vec a, vec b) {
return (vec){a.i + b.i, max(a.j, b.j), a.k && b.k};
}
vec trans(vec a) {
if (!a.k)
return (vec){0, a.i + a.j, 0};
else
return (vec){a.i + a.j, 0, 1};
}
void dfs1(int t, int f = 0) {
F[t] = (vec){1, 0, 1};
ch[t].clear();
for (int i = 0; i < bi[t].size(); ++i)
if (bi[t][i] != f) {
ch[t].push_back(bi[t][i]);
dfs1(bi[t][i], t);
F[t] = F[t] + trans(F[bi[t][i]]);
}
if (ai[t] < M) F[t] = (vec){0, 0, 0};
}
void dfs2(int t, vec u = (vec){0, 0, 1}) {
u = trans(u);
if (ai[t] >= M) {
vec v = u;
for (int i = 0; i < ch[t].size(); ++i) v = v + trans(F[ch[t][i]]);
if (v.i + v.j + 1 >= k) OK = 1;
}
if (ch[t].size()) {
Lm[t] = Rm[t] = vector<vec>(ch[t].size());
Lm[t][0] = Rm[t][ch[t].size() - 1] = (vec){0, 0, 1};
for (int i = 1; i < ch[t].size(); ++i)
Lm[t][i] = Lm[t][i - 1] + trans(F[ch[t][i - 1]]);
for (int i = ch[t].size() - 2; ~i; --i)
Rm[t][i] = Rm[t][i + 1] + trans(F[ch[t][i + 1]]);
for (int i = 0; i < ch[t].size(); ++i)
dfs2(ch[t][i], (ai[t] < M ? (vec){0, 0, 0}
: (vec){1, 0, 1} + Lm[t][i] + Rm[t][i] + u));
}
}
int main() {
cin >> n >> k;
int MN = 1e6, MX = 0;
for (int i = 1; i <= n; ++i)
cin >> ai[i], MX = max(MX, ai[i]), MN = min(MN, ai[i]);
for (int i = 1; i < n; ++i) {
int a, b;
cin >> a >> b;
bi[a].push_back(b);
bi[b].push_back(a);
}
int L = MN, R = MX;
while (L < R) {
M = (L + R + 1) / 2;
OK = 0;
dfs1(1);
dfs2(1);
if (OK)
L = M;
else
R = M - 1;
}
cout << L << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
bool w, B[(int)(2e5 + 10)];
int i, j, k, n, m, x, y, z, A[(int)(2e5 + 10)], C[(int)(2e5 + 10)],
a[(int)(2e5 + 10)], ort, mx[(int)(2e5 + 10)], mx2[(int)(2e5 + 10)];
vector<int> arr[(int)(2e5 + 10)];
void f2(int x, int root, int t, int t2) {
int p = 1, mx = 0;
if (a[x] >= ort) {
for (int i = 0; i < arr[x].size(); i++) {
if (arr[x][i] != root) {
if (C[arr[x][i]] == A[arr[x][i]])
p += C[arr[x][i]];
else
mx = max(mx, A[arr[x][i]] + ::mx[arr[x][i]]);
} else {
if (C[1] - C[x] == t)
p += t;
else
mx = max(mx, t + t2);
}
}
if (p + mx >= k) {
w = 1;
}
}
for (int i = 0; i < arr[x].size(); i++) {
if (arr[x][i] != root) {
if (a[x] >= ort) {
if (A[x] - A[arr[x][i]] + t == C[1] - C[arr[x][i]])
f2(arr[x][i], x, A[x] - A[arr[x][i]] + t, 0);
else {
int p = ::mx[x];
if (p == A[arr[x][i]] + ::mx[arr[x][i]] and
A[arr[x][i]] != C[arr[x][i]])
p = mx2[x];
if (t == C[1] - C[x]) {
if (A[arr[x][i]] == C[arr[x][i]])
f2(arr[x][i], x, A[x] - A[arr[x][i]] + t, p);
else
f2(arr[x][i], x, A[x] + t, p);
} else {
if (A[arr[x][i]] == C[arr[x][i]])
f2(arr[x][i], x, A[x] - A[arr[x][i]], max(p, t + t2));
else
f2(arr[x][i], x, A[x], max(p, t + t2));
}
}
} else
f2(arr[x][i], x, 0, 0);
}
}
}
void f(int x, int root) {
C[x] = 1;
A[x] = 0;
mx[x] = mx2[x] = 0;
for (int i = 0; i < arr[x].size(); i++)
if (arr[x][i] != root) {
f(arr[x][i], x);
int p = A[arr[x][i]] + mx[arr[x][i]];
if (A[arr[x][i]] == C[arr[x][i]])
A[x] += A[arr[x][i]];
else if (mx[x] < p) {
mx2[x] = mx[x];
mx[x] = p;
} else
mx2[x] = max(mx2[x], p);
C[x] += C[arr[x][i]];
}
if (a[x] < ort)
mx[x] = mx2[x] = A[x] = 0;
else
A[x]++;
}
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) scanf("%d", a + i);
for (i = 1; i < n; i++) {
scanf("%d %d", &x, &y);
arr[x].push_back(y);
arr[y].push_back(x);
}
int bas = 1;
int son = (int)(2e5 + 10) * 10;
while (bas < son) {
ort = bas + son >> 1;
if (bas == ort) ort++;
w = 0;
f(1, 0);
f2(1, 0, 0, 0);
if (w)
bas = ort;
else
son = ort - 1;
}
cout << bas << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200005], res[200005], sum[200005], mx[200005];
bool vis[200005], all[200005];
vector<int> g[200005];
void dfs1(int u, int p) {
all[u] = vis[u];
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
dfs1(v, u);
all[u] &= all[v];
}
if (vis[u]) {
if (all[u]) {
sum[u] = 1;
mx[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
sum[u] += sum[v];
mx[u] += sum[v];
}
} else {
mx[u] = 1;
int tmp = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
if (all[v])
mx[u] += sum[v];
else
tmp = max(tmp, mx[v]);
}
mx[u] += tmp;
}
}
}
void dfs2(int u, int p, bool s, int sumP, int mxP) {
if (vis[u]) {
int sum2 = 0, mx2 = 0;
if (s)
sum2 = sumP;
else
mx2 = mxP;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
if (all[v])
sum2 += sum[v];
else
mx2 = max(mx2, mx[v]);
}
res[u] = sum2 + mx2 + 1;
sum2 = 0, mx2 = 0;
if (s)
sum2 = sumP;
else
mx2 = mxP;
int node = 0, pv = 0;
vector<pair<int, int> > pq;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
if (!all[v]) {
node++;
pv = v;
mx2 = max(mx2, mx[v]);
pq.push_back(pair<int, int>(mx[v], v));
} else
sum2 += sum[v];
}
if (node >= 2 || !s) {
sort(pq.begin(), pq.end());
int sz = pq.size();
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
int mx3 = mxP;
if (all[v]) {
if (sz > 0) mx3 = max(mx3, pq[sz - 1].first);
dfs2(v, u, 0, 0, sum2 - sum[v] + mx3 + 1);
} else {
if (sz > 0) {
if (pq[sz - 1].second == v) {
if (sz > 1) mx3 = max(mx3, pq[sz - 2].first);
} else
mx3 = max(mx3, pq[sz - 1].first);
}
dfs2(v, u, 0, 0, sum2 + mx3 + 1);
}
}
} else if (node == 1) {
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
if (v == pv)
dfs2(v, u, 1, sum2 + 1, 0);
else
dfs2(v, u, 0, 0, sum2 - sum[v] + mx2 + 1);
}
} else {
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
dfs2(v, u, 1, sum2 - sum[v] + 1, 0);
}
}
} else {
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
dfs2(v, u, 0, 0, 0);
}
}
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
int lo = 1, hi = 1e6, ans = 0;
while (lo <= hi) {
int mid = (lo + hi) / 2;
for (int i = 1; i <= n; i++) {
res[i] = -1;
all[i] = 0;
sum[i] = 0;
mx[i] = 0;
if (a[i] >= mid)
vis[i] = 1;
else
vis[i] = 0;
}
dfs1(1, 0);
dfs2(1, 0, 1, 0, 0);
bool ok = 0;
for (int i = 1; i <= n; i++) {
if (res[i] >= k) ok = 1;
}
if (ok)
ans = mid, lo = mid + 1;
else
hi = mid - 1;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
inline void priv(vector<int> a) {
for (int i = 0; i < ((int)(a).size()); ++i)
printf("%d%c", a[i], i == (int)(a).size() - 1 ? '\n' : ' ');
}
template <typename T>
istream& operator>>(istream& i, vector<T>& v) {
for (T& x : v) i >> x;
return i;
}
template <typename T>
string join(vector<T>& v) {
stringstream s;
for (T& x : v) s << ' ' << x;
return s.str().substr(1);
}
template <typename T>
ostream& operator<<(ostream& o, vector<T>& v) {
if ((int)(v).size()) o << join(v);
return o;
}
const int MX = 200005, INF = 1001001001;
const long long int LINF = 1e18;
const double eps = 1e-10;
int n, m, x;
int c[MX];
vector<int> to[MX];
int used[MX];
int root;
void rfs(int v, int p = -1) {
used[v] = 1;
for (int u : to[v])
if (u != p) {
if (c[u] < x)
root = v;
else
rfs(u, v);
}
}
int mx;
int dp[MX];
int dfs(int v, int p = -1) {
int s = 1;
bool ok = true;
int nx = 0;
dp[v] = 0;
for (int u : to[v])
if (u != p) {
if (c[u] < x)
ok = false;
else {
int ns = dfs(u, v);
s += ns;
if (!ns) {
ok = false;
nx = max(nx, dp[v] + dp[u]);
dp[v] = max(dp[v], dp[u]);
}
}
}
nx += s;
mx = max(mx, nx);
dp[v] += s;
if (!ok) s = 0;
return s;
}
bool f() {
for (int i = 0; i < (n); ++i) used[i] = 0;
for (int i = 0; i < (n); ++i)
if (!used[i] && c[i] >= x) {
root = -1;
rfs(i);
if (root == -1) return true;
mx = 0;
dfs(root);
if (mx >= m) return true;
}
return false;
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < (n); ++i) scanf("%d", &c[i]);
for (int i = 0; i < (n - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
to[a].push_back(b);
to[b].push_back(a);
}
int l = 0, r = 1000001;
while (l + 1 < r) {
x = (l + r) >> 1;
if (f())
l = x;
else
r = x;
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 987654321;
const int MOD = 1000000007;
int N, K;
int A[200005];
vector<int> adj[200005];
int siz[200005], sum[200005], len[200005];
int sub[200005], dp[200005];
void dfs(int n, int par, int mid) {
siz[n] = 1;
for (int nxt : adj[n]) {
if (nxt != par) {
dfs(nxt, n, mid);
siz[n] += siz[nxt];
if (siz[nxt] == sub[nxt])
sum[n] += sub[nxt];
else
len[n] = max(len[n], sub[nxt]);
}
}
sub[n] = sum[n] + len[n] + 1;
if (A[n] < mid) sub[n] = 0;
}
void dfs2(int n, int par, int par_sub, int mid) {
if (par_sub == N - siz[n])
dp[n] = sum[n] + par_sub + len[n] + 1;
else
dp[n] = sum[n] + max(len[n], par_sub) + 1;
if (A[n] < mid) dp[n] = 0;
int cnt = adj[n].size();
vector<int> l_sum(cnt + 2);
vector<int> l_len(cnt + 2);
for (int i = 1; i <= cnt; i++) {
int nxt = adj[n][i - 1];
l_sum[i] = l_sum[i - 1];
l_len[i] = l_len[i - 1];
if (nxt != par) {
if (siz[nxt] == sub[nxt])
l_sum[i] += sub[nxt];
else
l_len[i] = max(l_len[i], sub[nxt]);
}
}
vector<int> r_sum(cnt + 2);
vector<int> r_len(cnt + 2);
for (int i = cnt; i >= 1; i--) {
int nxt = adj[n][i - 1];
r_sum[i] = r_sum[i + 1];
r_len[i] = r_len[i + 1];
if (nxt != par) {
if (siz[nxt] == sub[nxt])
r_sum[i] += sub[nxt];
else
r_len[i] = max(r_len[i], sub[nxt]);
}
}
for (int i = 1; i <= cnt; i++) {
int nxt = adj[n][i - 1];
if (nxt != par) {
int nxt_par_sub = 0;
int p_sum = l_sum[i - 1] + r_sum[i + 1];
int p_len = max(l_len[i - 1], r_len[i + 1]);
if (par_sub == N - siz[n])
nxt_par_sub = p_sum + par_sub + p_len + 1;
else
nxt_par_sub = p_sum + max(p_len, par_sub) + 1;
if (A[n] < mid) nxt_par_sub = 0;
dfs2(nxt, n, nxt_par_sub, mid);
}
}
}
bool foo(int mid) {
memset(siz, 0, sizeof(siz));
memset(sum, 0, sizeof(sum));
memset(len, 0, sizeof(len));
memset(sub, 0, sizeof(sub));
memset(dp, 0, sizeof(dp));
dfs(1, 0, mid);
dfs2(1, 0, 0, mid);
int best = 0;
for (int i = 1; i <= N; i++) best = max(best, dp[i]);
return best >= K;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> K;
for (int i = 1; i <= N; i++) cin >> A[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 = 0, hi = 1000005;
while (lo + 1 < hi) {
int mid = (lo + hi) / 2;
if (foo(mid))
lo = mid;
else
hi = mid;
}
cout << lo << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
struct node {
int x, y, next;
} edge[N << 1];
int len, first[N];
void ins(int x, int y) {
len++;
edge[len].x = x;
edge[len].y = y;
edge[len].next = first[x];
first[x] = len;
}
inline int read() {
int p = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
p = p * 10 + (ch - '0');
ch = getchar();
}
return p * f;
}
int a[N], n, f[N], g[N], siz[N], K;
pair<int, int> mx[N][2];
int mid;
void dfs(int x, int fa) {
siz[x] = 1;
if (a[x] >= mid) f[x] = 1;
for (int k = first[x]; k != -1; k = edge[k].next) {
int y = edge[k].y;
if (y == fa) continue;
dfs(y, x);
siz[x] += siz[y];
if (a[y] < mid) continue;
if (f[y] == siz[y])
f[x] += f[y];
else {
if (f[y] + mx[y][0].first > mx[x][0].first)
mx[x][1] = mx[x][0], mx[x][0] = make_pair(f[y] + mx[y][0].first, y);
else if (f[y] + mx[y][0].first > mx[x][1].first)
mx[x][1] = make_pair(f[y] + mx[y][0].first, y);
}
}
if (a[x] < mid) f[x] = 0;
}
void dfs2(int x, int fa) {
for (int k = first[x]; k != -1; k = edge[k].next) {
int y = edge[k].y;
if (y == fa) continue;
int s = f[x];
int p = 0;
if (siz[y] == f[y])
s -= f[y];
else if (y == mx[x][0].second)
p = mx[x][1].first;
else
p = mx[x][0].first;
if (a[x] >= mid) {
if (n - siz[x] == g[x])
s += g[x];
else
p = max(p, g[x]);
g[y] = s + p;
} else
g[y] = 0;
dfs2(y, x);
}
}
bool check() {
for (int i = 1; i <= n; i++)
f[i] = g[i] = siz[i] = mx[i][0].first = mx[i][1].first = mx[i][0].second =
mx[i][1].second = 0;
dfs(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; i++)
if (a[i] >= mid) {
int s = 0;
int p = 0;
if (n - siz[i] == g[i])
s = f[i] + g[i];
else
s = f[i], p = max(p, g[i]);
p = max(p, mx[i][0].first);
if (s + p >= K) return 1;
}
return 0;
}
int main() {
n = read();
K = read();
memset(first, -1, sizeof(first));
len = 0;
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) {
int x = read();
int y = read();
ins(x, y);
ins(y, x);
}
mid = 372;
check();
int L = 1;
int R = 1e9;
int ret;
while (L <= R) {
mid = (L + R) >> 1;
if (check())
ret = mid, L = mid + 1;
else
R = mid - 1;
}
return printf("%d\n", ret), 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> v) {
os << "( " << v.first << ", " << v.second << ")";
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<set<T>> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &v) {
int i = 0;
for (auto it : v) {
if (i > 0) {
os << ' ';
}
os << it;
i++;
}
return os;
}
using ll = long long int;
int N, K;
vector<int> nums;
vector<vector<int>> g;
int sum = 0;
vector<int> szs;
vector<int> ok_cnts;
vector<int> sums;
vector<int> lens;
vector<int> anss;
void dfs(int now, int from, vector<int> &oks) {
szs[now] = 1;
if (oks[now]) {
ok_cnts[now] = 1;
}
vector<int> v{0, 0};
for (auto e : g[now]) {
if (e == from) continue;
dfs(e, now, oks);
szs[now] += szs[e];
ok_cnts[now] += ok_cnts[e];
if (szs[e] == ok_cnts[e]) {
sums[now] += szs[e];
} else {
v.push_back(lens[e]);
}
}
sort(v.begin(), v.end(), greater<int>());
if (oks[now]) {
int nans = 0;
if (N - szs[now] == sum - ok_cnts[now]) {
nans += N - szs[now];
}
nans += 1 + sums[now] + v[0] + v[1];
lens[now] = sums[now] + v[0] + 1;
anss[now] = nans;
}
}
bool check(int amid) {
sum = 0;
szs = vector<int>(N);
ok_cnts = vector<int>(N);
sums = vector<int>(N);
lens = vector<int>(N);
anss = vector<int>(N);
vector<int> oks(N);
for (int i = 0; i < N; ++i) {
if (amid <= nums[i]) {
oks[i] = true;
sum++;
}
}
dfs(0, -1, oks);
if (*max_element(anss.begin(), anss.end()) >= K)
return true;
else
return false;
}
int main() {
ios::sync_with_stdio(false);
cin >> N >> K;
g.resize(N);
for (int i = 0; i < N; ++i) {
int a;
cin >> a;
nums.push_back(a);
}
g.resize(N);
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);
}
ll ok = 0;
ll ng = 1e7;
while (ok + 1 != ng) {
ll amid((ok + ng) / 2);
if (check(amid))
ok = amid;
else
ng = amid;
}
cout << ok << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int INT_MAX_VAL = (int)0x3F3F3F3F;
int INT_MIN_VAL = (int)-0x3F3F3F3F;
long long LONG_MAX_VAL = (long long)0x3F3F3F3F3F3F3F3F;
long long LONG_MIN_VAL = (long long)-0x3F3F3F3F3F3F3F3F;
int colors[500006];
vector<pair<int, char> > graph[500006];
int n, m;
int dfs(int v, char c, vector<int>& red, vector<int>& blue) {
for (auto& p : graph[v]) {
int w = p.first;
int use_color = (c == p.second) ? colors[v] : (3 - colors[v]);
if (colors[w] == 0) {
colors[w] = use_color;
if (use_color == 1) {
red.push_back(w);
} else {
blue.push_back(w);
}
dfs(w, c, red, blue);
} else if (colors[w] != use_color) {
return false;
}
}
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int v, w;
char c;
cin >> v >> w >> c;
graph[v].emplace_back(w, c);
graph[w].emplace_back(v, c);
}
bool is_result = false;
vector<int> result;
for (int z = 0; z < 2; ++z) {
bool is_good = true;
vector<int> current;
for (int i = 1; i <= n; ++i) colors[i] = 0;
for (int i = 1; i <= n; ++i) {
if (colors[i] == 0) {
vector<int> red = {i};
colors[i] = 1;
vector<int> blue;
bool res = dfs(i, (z == 0) ? 'B' : 'R', red, blue);
if (!res) {
is_good = false;
break;
}
if (red.size() > blue.size()) swap(red, blue);
for (auto p : red) current.push_back(p);
}
}
if (is_good) {
if (!is_result || result.size() > current.size()) {
result = current;
is_result = true;
}
}
}
if (is_result) {
cout << result.size() << '\n';
for (auto& a : result) {
cout << a << " ";
}
cout << '\n';
} else {
cout << -1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
template <class T, class U>
inline void Max(T &a, U b) {
if (a < b) a = b;
}
template <class T, class U>
inline void Min(T &a, U b) {
if (a > b) a = b;
}
inline void add(int &a, int b) {
a += b;
while (a >= 1000000007) a -= 1000000007;
}
int pow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = ans * (long long)a % 1000000007;
a = (long long)a * a % 1000000007;
b >>= 1;
}
return ans;
}
vector<int> g[100010][2];
int vis[100010], c[100010], now = 0, color, a[2];
vector<int> v;
bool dfs(int u, int co = 0) {
vis[u] = now;
c[u] = co;
a[co]++;
v.push_back(u);
for (int k = 0; k < 2; k++)
for (__typeof(g[u][k].begin()) it = g[u][k].begin(); it != g[u][k].end();
it++) {
if (k == color) {
if (vis[*it] == now && c[*it] != c[u]) return 0;
if (vis[*it] != now && !dfs(*it, co)) return 0;
} else {
if (vis[*it] == now && c[*it] == c[u]) return 0;
if (vis[*it] != now && !dfs(*it, 1 - co)) return 0;
}
}
return 1;
}
int main() {
int T, ca = 0, i, j, k, n = 0, m;
scanf("%d%d", &n, &m);
char s[3];
while (m--) {
scanf("%d%d%s", &i, &j, s), i--, j--;
k = s[0] == 'R' ? 0 : 1;
g[i][k].push_back(j);
g[j][k].push_back(i);
}
int ans = -1;
vector<int> res, re;
for (int k = 0; k < 2; k++) {
now++;
color = k;
int ok = 1, sum = 0;
res.clear();
for (int i = 0; i < n; i++)
if (vis[i] != now) {
a[0] = a[1] = 0;
v.clear();
if (!dfs(i)) {
ok = 0;
break;
}
int co = 0;
if (a[0] > a[1])
co ^= 1, sum += a[1];
else
sum += a[0];
for (__typeof(v.begin()) it = v.begin(); it != v.end(); it++)
if (c[*it] == co) res.push_back(*it);
}
if (ok) {
if (k == 0)
ans = sum, re = res;
else if (k == 1) {
if (ans == -1 || ans > sum) {
ans = sum;
re = res;
}
}
}
}
if (ans == -1)
puts("-1");
else {
printf("%d\n", ans);
sort(re.begin(), re.end());
for (__typeof(re.begin()) it = re.begin(); it != re.end(); it++)
printf("%d ", *it + 1);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<pair<int, int>, int> e[100010];
int parent[100010];
int Rank[100010];
int sz[100010];
vector<int> v[100010];
bool mark[100010];
bool mark1[100010];
int color[100010];
vector<int> out[2];
bool success[2];
int cnt[2];
int n, m;
int find(int cur) {
if (parent[cur] == cur) return cur;
return parent[cur] = find(parent[cur]);
}
void Union(int x, int y) {
int xroot = find(x);
int yroot = find(y);
if (xroot == yroot) return;
if (Rank[xroot] < Rank[yroot])
parent[xroot] = yroot;
else if (Rank[xroot] > Rank[yroot])
parent[yroot] = xroot;
else {
Rank[xroot]++;
parent[yroot] = xroot;
}
}
void init(int n) {
int i;
for (i = 0; i <= n; ++i) {
Rank[i] = 0;
parent[i] = i;
sz[i] = 0;
}
}
bool dfs(int cur, int c) {
mark[cur] = 1;
color[cur] = c;
cnt[c] += sz[cur];
for (int i = 0; i < v[cur].size(); ++i) {
if (mark[v[cur][i]]) {
if (color[v[cur][i]] == c) return 0;
continue;
}
if (!dfs(v[cur][i], 1 - c)) return 0;
}
return 1;
}
void dfs1(int cur) {
mark1[cur] = 1;
color[cur] = 1 - color[cur];
for (int i = 0; i < v[cur].size(); ++i)
if (!mark1[v[cur][i]]) dfs1(v[cur][i]);
}
void solve(int f) {
int i;
init(n);
success[f] = 0;
for (i = 1; i <= n; ++i) v[i].clear();
for (i = 0; i < m; ++i)
if (e[i].second == f) Union(e[i].first.first, e[i].first.second);
for (i = 0; i < m; ++i)
if (e[i].second != f) {
int x = find(e[i].first.first), y = find(e[i].first.second);
if (x == y) return;
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 1; i <= n; ++i) sz[find(i)]++;
memset(mark, 0, sizeof(mark));
memset(mark1, 0, sizeof(mark1));
for (i = 1; i <= n; ++i) {
cnt[0] = cnt[1] = 0;
if (mark[find(i)]) continue;
if (!dfs(find(i), 0)) return;
if (cnt[0] > cnt[1]) dfs1(find(i));
}
success[f] = 1;
for (i = 1; i <= n; ++i)
if (color[find(i)] == 0) out[f].push_back(i);
}
int main() {
int i, x, y, c;
string s;
scanf("%d", &n);
scanf("%d", &m);
for (i = 0; i < m; ++i) {
scanf("%d", &x);
scanf("%d", &y);
cin >> s;
if (s[0] == 'R')
c = 0;
else
c = 1;
e[i] = make_pair(make_pair(x, y), c);
}
solve(0);
solve(1);
int minn = 1000000, minpos;
for (i = 0; i < 2; ++i)
if (success[i])
if ((int)out[i].size() < minn) {
minn = (int)out[i].size();
minpos = i;
}
if (minn == 1000000)
printf("%d\n", -1);
else {
printf("%d\n", minn);
for (auto it : out[minpos]) printf("%d ", it);
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m, c[N], mark[N], cc[N], take[N], val[N];
vector<int> adj[N], tadj[N], ans;
vector<pair<int, pair<int, int> > > EdgeList;
bool s;
void addxor(int u, int v) {
int nu, nv;
if (u <= n)
nu = u + n;
else
nu = u - n;
if (v <= n)
nv = v + n;
else
nv = v - n;
adj[nu].push_back(v);
adj[nv].push_back(u);
adj[u].push_back(nv);
adj[v].push_back(nu);
}
bool solve() {
for (int i = 1; i <= 2 * n; ++i) adj[i].clear();
memset(cc, 0, sizeof cc);
memset(val, 0, sizeof val);
for (pair<int, pair<int, int> > d : EdgeList) {
int u = d.second.first, v = d.second.second;
if (d.first == 0) {
addxor(u, v);
} else
addxor(u + n, v);
}
int cnt = 0;
memset(mark, -1, sizeof mark);
for (int i = 1; i <= 2 * n; ++i)
if (mark[i] == -1) {
queue<int> q;
++cnt;
while (!q.empty()) q.pop();
q.push(i);
mark[i] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
cc[u] = cnt;
val[cnt] += (u <= n);
for (int v : adj[u]) {
if (mark[v] == -1) {
q.push(v);
mark[v] = mark[u] ^ 1;
}
}
}
}
for (int i = 1; i <= cnt; ++i) tadj[i].clear();
for (int i = 1; i <= n; ++i) {
if (cc[i] == cc[i + n]) {
return false;
}
tadj[cc[i]].push_back(cc[i + n]);
tadj[cc[i + n]].push_back(cc[i]);
}
memset(take, 0, sizeof take);
vector<int> res;
res.clear();
memset(mark, -1, sizeof mark);
for (int i = 1; i <= cnt; ++i)
if (mark[i] == -1) {
queue<int> q;
while (!q.empty()) q.pop();
q.push(i);
mark[i] = 0;
int ff = 0, sum = 0;
vector<int> V;
V.clear();
while (!q.empty()) {
int u = q.front();
q.pop();
V.push_back(u);
sum += val[u];
ff += mark[u] * val[u];
for (int v : tadj[u]) {
if (mark[v] == -1) {
q.push(v);
mark[v] = mark[u] ^ 1;
} else {
if (mark[v] != mark[u] ^ 1) {
return false;
}
}
}
}
if (ff > sum / 2) {
for (int u : V)
if (mark[u] == 0) take[u] = 1;
} else
for (int u : V)
if (mark[u] == 1) take[u] = 1;
}
for (int i = 1; i <= n; ++i)
if (take[cc[i]]) res.push_back(i);
if (res.size() == 0) {
cout << 0 << endl;
exit(0);
}
if (res.size() < ans.size() || !s) ans = res;
return 1;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
char c;
cin >> c;
if (c == 'B')
EdgeList.push_back({0, {u, v}});
else
EdgeList.push_back({1, {u, v}});
}
s |= solve();
if (1) {
for (pair<int, pair<int, int> > &v : EdgeList) {
v.first ^= 1;
}
s |= solve();
}
if (!s) {
cout << -1 << endl;
return 0;
}
cout << ans.size() << endl;
for (int v : ans) cout << v << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T1, class T2, class T3, class T4>
inline void gn(T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
gn(x1, x2, x3), gn(x4);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void gn(T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
gn(x1, x2, x3, x4), gn(x5);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5) {
printsp(x1), printsp(x2), printsp(x3), printsp(x4), println(x5);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
vector<pair<int, int> > adj[100100];
vector<int> sz[3];
long long st[100100];
int flag[100100];
int vst = 0;
vector<int> val;
vector<int> ans;
void dfs(int u, int tp) {
if (vst) return;
sz[st[u]].push_back(u);
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i].first;
int stt = adj[u][i].second;
if (flag[v]) {
if (stt == tp and st[u] != st[v]) {
vst = 1;
return;
}
if (stt != tp and st[u] == st[v]) {
vst = 1;
return;
}
continue;
}
if (stt == tp)
st[v] = st[u];
else
st[v] = st[u] ^ 1;
flag[v] = 1;
dfs(v, tp);
}
}
int main() {
int n, m;
gn(n, m);
for (int i = 1; i <= m; i++) {
int u, v, c;
char s;
gn(u, v);
cin >> s;
if (s == 'R')
c = 1;
else
c = 0;
adj[u].push_back(pair<int, int>(v, c));
adj[v].push_back(pair<int, int>(u, c));
}
int tp;
int mn = -1;
for (tp = 0; tp < 2; tp++) {
for (int i = 1; i <= n; i++) flag[i] = 0;
vst = 0;
val.clear();
for (int i = 1; i <= n; i++)
if (flag[i] == 0) {
sz[1].clear();
sz[0].clear();
flag[i] = 1;
st[i] = 0;
dfs(i, tp);
if (vst) break;
int stt = sz[1].size() > sz[0].size() ? 0 : 1;
for (int j = 0; j < sz[stt].size(); j++) val.push_back(sz[stt][j]);
}
if (vst) continue;
if (mn == -1 || ans.size() > val.size()) {
mn = 1;
ans.clear();
for (int i = 0; i < val.size(); i++) ans.push_back(val[i]);
}
}
if (ans.size() || mn != -1) {
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) printsp(ans[i]);
} else
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = (1 << 17);
vector<pair<int, int> > v[MX];
int n, m, cnt[2];
vector<int> nodes[2];
bool turn, ok;
vector<int> sol;
int state[MX];
void dfs(int x, int flag) {
if (state[x] != -1) {
if (state[x] != flag) ok = 0;
return;
}
state[x] = flag;
cnt[state[x]]++;
nodes[state[x]].push_back(x);
for (auto pp : v[x]) dfs(pp.first, flag ^ turn ^ pp.second);
}
int solve() {
memset(state, -1, sizeof(state));
int ret = 0;
ok = 1;
for (int j = 1; j <= n; j++) {
if (state[j] == -1) {
cnt[0] = cnt[1] = 0;
dfs(j, 0);
ret += min(cnt[0], cnt[1]);
}
}
if (!ok) return (1 << 30);
return ret;
}
void geb() {
memset(state, -1, sizeof(state));
int ret = 0;
ok = 1;
for (int j = 1; j <= n; j++) {
if (state[j] == -1) {
nodes[0].clear();
nodes[1].clear();
dfs(j, 0);
if (nodes[0].size() > nodes[1].size()) nodes[0].swap(nodes[1]);
for (auto pp : nodes[0]) sol.push_back(pp);
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int j = 1; j <= m; j++) {
int a, b;
char cc[5];
scanf("%d %d %s", &a, &b, cc);
int col = 0;
if (cc[0] == 'B') col = 1;
v[a].push_back({b, col});
v[b].push_back({a, col});
}
int ans1 = solve();
turn = 1;
int ans2 = solve();
if (min(ans1, ans2) == (1 << 30)) {
puts("-1");
return 0;
}
if (ans1 < ans2) turn = 0;
geb();
cout << sol.size() << endl;
for (auto pp : sol) cout << pp << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 1e17 + 7;
const int N = 1e5 + 7;
const int INF = 2e9 + 7;
const int MOD = 1e9 + 7;
const double Pi = acos(-1.);
const double EPS = 1e-8;
vector<int> e[N], out[2];
int n, m, w, E[N], c[N], vis[N], que[N], ok[2];
char nxtChar() {
char ch = getchar();
while (!(ch == 'R' || ch == 'B')) ch = getchar();
return ch;
}
void chg(int u) {
for (int i = 0; i < ((int)(e[u].size())); ++i) c[e[u][i]] ^= 1;
}
bool check(int tail) {
for (int i = 0; i < tail; ++i) {
int u = que[i];
for (int j = 0; j < ((int)(e[u].size())); ++j)
if (c[e[u][j]] != w) return false;
}
return true;
}
queue<int> Q;
void bfs(int u, int t, vector<int> &r) {
vis[u] = t, Q.push(u);
while (!Q.empty()) {
u = Q.front();
Q.pop();
for (int i = 0; i < ((int)(e[u].size())); ++i) {
int v = E[e[u][i]] - u;
if (vis[v] == t) continue;
if (c[e[u][i]] != w) chg(v), r.push_back(v);
vis[v] = t, Q.push(v);
}
}
}
void solve(int u) {
int qh = 0, qt = 0;
vis[u] = 1, que[qt++] = u;
while (qh < qt) {
u = que[qh++];
for (int i = 0; i < ((int)(e[u].size())); ++i) {
int v = E[e[u][i]] - u;
if (vis[v] == 1) continue;
vis[v] = 1;
que[qt++] = v;
}
}
int ans = -1;
vector<int> ret[2];
u = que[0];
ret[0].push_back(u), chg(u);
bfs(u, 2, ret[0]);
if (check(qt)) ans = 0;
for (int i = 0; i < ((int)(ret[0].size())); ++i) chg(ret[0][i]);
bfs(u, 3, ret[1]);
if (check(qt))
if (ans == -1 || ((int)(ret[0].size())) > ((int)(ret[1].size()))) ans = 1;
for (int i = 0; i < ((int)(ret[1].size())); ++i) chg(ret[1][i]);
if (~ans) {
for (int i = 0; i < ((int)(ret[ans].size())); ++i)
out[w].push_back(ret[ans][i]);
} else {
ok[w] = false;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
E[i] = u + v;
c[i] = (nxtChar() == 'R');
e[u].push_back(i), e[v].push_back(i);
}
for (w = 0; w < 2; ++w) {
for (int i = 0; i < n; ++i) vis[i] = 0;
ok[w] = true, out[w].clear();
for (int i = 0; i < n; ++i)
if (vis[i] == 0) solve(i);
}
int ans = -1;
for (int i = 0; i < 2; ++i)
if (ok[i])
if (ans == -1 || ((int)(out[ans].size())) > ((int)(out[i].size())))
ans = i;
if (~ans) {
printf("%d\n", ((int)(out[ans].size())));
for (int i = 0; i < ((int)(out[ans].size())); ++i) {
if (i) putchar(' ');
printf("%d", out[ans][i] + 1);
}
} else {
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (-1u) / 2;
const long long int INF2 = (-1ull) / 2;
int a, b, i, us[1011000], j, k, n, m, timer = 0, l, r, x, y;
int c[1011000], cnt = 0, fl = 0, a2, a3 = -1000000, ans = 0;
char C;
vector<pair<int, int> > g[100010];
vector<int> p[3], an, A, B;
void deb(bool a) {
if (a) return;
printf("PROGRAM TERMINATED\n");
exit(0);
}
bool dfs(int v, int pp, int k) {
if (us[v]) {
return us[v] == pp;
}
us[v] = pp;
p[pp].push_back(v);
for (int i = 0; i < g[v].size(); i++) {
if (dfs(g[v][i].first, (g[v][i].second == k) ? pp : pp ^ 3, k) == false)
return false;
}
return true;
}
vector<int> solve(int K) {
an.clear();
for (i = 1; i <= n; i++) us[i] = 0;
for (i = 1; i <= n; i++) {
if (us[i] == 0) {
if (p[1].size()) p[1].clear();
if (p[2].size()) p[2].clear();
if (dfs(i, 1, K) == false) {
an.clear();
for (j = 0; j < n + 1; j++) an.push_back(-1);
return an;
}
int F = 1;
if (p[1].size() > p[2].size()) F = 2;
if (p[F].size()) an.insert(an.end(), p[F].begin(), p[F].end());
}
}
return an;
}
int main() {
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a >> b >> C;
k = 0;
if (C == 'R') k = 1;
g[a].push_back(make_pair(b, k));
g[b].push_back(make_pair(a, k));
}
A = solve(1);
B = solve(0);
if (A.size() > B.size()) swap(A, B);
if (A.size() && A[0] == -1)
cout << "-1\n";
else {
cout << A.size() << endl;
for (i = 0; i < A.size(); i++) cout << A[i] << " ";
cout << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.