text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
long long INF = (1LL << 62);
struct ff {
long long price, mask, monitors;
};
bool cmp(const ff &A, const ff &B) { return A.monitors < B.monitors; }
ff f[150];
long long memo[1 << 21];
int main() {
long long n, m, b;
cin >> n >> m >> b;
for (int i = 0; i < n; ++i) {
int k;
cin >> f[i].price >> f[i].monitors >> k;
for (int j = 0; j < k; ++j) {
int id;
cin >> id;
--id;
f[i].mask |= (1 << id);
}
}
sort(f, f + n, cmp);
for (int i = 0; i < (1 << m); ++i) memo[i] = INF;
memo[0] = 0;
long long mi = INF;
for (int i = 0; i < n; ++i) {
for (int mask = 0; mask < (1 << m); ++mask)
memo[mask | f[i].mask] =
min(memo[mask | f[i].mask], memo[mask] + f[i].price);
long long res = memo[(1 << m) - 1];
if (res != INF) mi = min(mi, res + f[i].monitors * b);
}
if (mi == INF) mi = -1;
cout << mi << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1), EPS = 1e-8;
const int mod = 1000000007;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
run();
int n, m;
long long b;
cin >> n >> m >> b;
vector<vector<int>> v(n, vector<int>(3));
for (auto& it : v) {
int x;
cin >> it[0] >> it[1] >> x;
while (x--) {
int a;
cin >> a;
a--;
it[2] |= (1 << a);
}
}
sort(v.begin(), v.end(),
[](const vector<int>& a, vector<int>& b) { return a[1] < b[1]; });
vector<long long> dp(1 << m, 0x3f3f3f3f3f3f3f3fLL);
dp[(1 << m) - 1] = 0;
for (int idx = n - 1; idx >= 0; idx--)
for (int mask = 0; mask < (1 << m); mask++) {
long long& rt = dp[mask];
if ((mask | v[idx][2]) == (1 << m) - 1)
rt = min(rt, v[idx][0] + v[idx][1] * b);
else
rt = min(rt, v[idx][0] + dp[mask | v[idx][2]]);
}
long long rt = dp[0];
if (rt >= 0x3f3f3f3f3f3f3f3fLL) rt = -1;
cout << rt << "\n";
;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int a, b, c;
bool operator<(const Edge &r) const { return c < r.c; }
};
int N, x[3000], bl[3000];
vector<pair<int, int> > edges[3000];
Edge e[3000];
pair<int, int> dfs(int n, int p) {
if (bl[n]) return pair<int, int>(0, 0);
pair<int, int> ret = pair<int, int>(1, x[n]);
for (int i = int(0); i < int(edges[n].size()); i++) {
int next = edges[n][i].first;
if (next == p) continue;
pair<int, int> t = dfs(next, n);
ret.first += t.first;
ret.second += t.second;
}
return ret;
}
void block(int n) {
if (bl[n]) return;
bl[n] = 1;
for (int i = int(0); i < int(edges[n].size()); i++) block(edges[n][i].first);
}
int main() {
int a, b, c;
while (scanf("%d", &N) != EOF) {
for (int i = int(0); i < int(N); i++) edges[i].clear(), bl[i] = 0;
for (int i = int(1); i < int(N); i++) {
scanf("%d %d %d", &a, &b, &c);
a--, b--;
e[i] = Edge{a, b, c};
edges[a].push_back(pair<int, int>(b, c));
edges[b].push_back(pair<int, int>(a, c));
}
sort(e + 1, e + N);
for (int i = int(0); i < int(N); i++) {
scanf("%d", x + i);
}
int ac = 0, ans = 0;
for (int i = N - 1; i; i--) {
if (bl[e[i].a] || bl[e[i].b]) continue;
pair<int, int> t1 = dfs(e[i].a, e[i].b);
pair<int, int> t2 = dfs(e[i].b, e[i].a);
if (t1.first < t2.first) swap(t1, t2), swap(e[i].b, e[i].a);
if (t1.first > t2.second + ac) {
ac += t2.second;
bl[e[i].b] = 1;
for (int j = int(0); j < int(edges[e[i].b].size()); j++) {
int next = edges[e[i].b][j].first;
if (next == e[i].a) continue;
block(next);
}
} else {
ans = e[i].c;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 123;
const int inf = 1e9;
const long double Pi = acos(-1);
const int mod = 95542721;
const long long Inf = 1e18;
int n, c[N];
struct edge {
int u, v, c;
} e[N];
bool cmp(edge a, edge b) { return a.c < b.c; }
struct dsu {
int p, sz;
} a[N];
bool fail;
int ans, second;
int get(int x) {
if (a[x].p == x) return x;
return a[x].p = get(a[x].p);
}
void Merge(int u, int v) {
u = get(u);
v = get(v);
a[v].p = u;
a[u].sz += a[v].sz;
c[u] += c[v];
if (a[u].sz > second - c[u]) {
fail = 1;
}
}
int main() {
srand(time(0));
cin >> n;
for (int i = 1; i < n; i++) cin >> e[i].u >> e[i].v >> e[i].c;
for (int i = 1; i <= n; i++) {
cin >> c[i];
second += c[i];
}
sort(e + 1, e + n, &cmp);
for (int i = 1; i <= n; i++) {
a[i].p = i;
a[i].sz = 1;
}
for (int i = 1; i < n; i++) {
int j = i;
while (j + 1 < n && e[j + 1].c == e[i].c) {
j++;
}
for (int it = i; it <= j; it++) Merge(e[it].u, e[it].v);
if (fail) {
ans = e[i].c;
break;
}
i = j;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int x[N], y[N], z[N], a[N], s, size1[N], size2[N], n, f[N];
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
int pd(int val) {
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i < n; i++)
if (z[i] < val) f[find(x[i])] = find(y[i]);
memset(size1, 0, sizeof size1);
memset(size2, 0, sizeof size2);
for (int i = 1; i <= n; i++) size1[find(i)]++, size2[find(i)] += a[i];
for (int i = 1; i <= n; i++)
if (find(i) == i && s - size2[i] < size1[i]) return 0;
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) scanf("%d%d%d", &x[i], &y[i], &z[i]);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), s += a[i];
int l = 0, r = 10000;
while (l < r) {
int mid = (l + r + 1) / 2;
if (pd(mid))
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
}
|
#include <bits/stdc++.h>
using namespace std;
int fa[3010], cnt[3010], x[3010], hop[3010];
int to[2 * 3010], nxt[2 * 3010], wei[2 * 3010], head[3010], edge;
int val[3010], N;
void add_edge(int u, int v, int w) {
to[edge] = v;
nxt[edge] = head[u];
wei[edge] = w;
head[u] = edge++;
to[edge] = u;
nxt[edge] = head[v];
wei[edge] = w;
head[v] = edge++;
return;
}
int find_fa(int u) {
if (u == fa[u]) return u;
return fa[u] = find_fa(fa[u]);
}
void dfs(int u, int bound, int f) {
for (int ID = head[u]; ID != -1; ID = nxt[ID]) {
int v = to[ID];
if (v == f) continue;
if (wei[ID] < bound) fa[find_fa(u)] = find_fa(v);
dfs(v, bound, u);
}
return;
}
bool calc(int t) {
for (int i = 0; i < N; i++) fa[i] = i;
for (int i = 0; i < N; i++) cnt[i] = 0;
for (int i = 0; i < N; i++) hop[i] = 0;
dfs(0, t, -1);
for (int i = 0; i < N; i++) fa[i] = find_fa(i);
for (int i = 0; i < N; i++) cnt[fa[i]]++;
for (int i = 0; i < N; i++) hop[fa[i]] += x[i];
int mxcnt = fa[0];
int sum = 0;
for (int i = 0; i < N; i++)
if (fa[i] == i) {
sum += hop[i];
if (cnt[i] > cnt[mxcnt]) mxcnt = i;
}
if (sum - hop[mxcnt] >= cnt[mxcnt]) return true;
return false;
}
int main() {
scanf("%d", &N);
memset(head, 0xff, sizeof(head));
int ct = 0;
int u, v, w, fir, se, mid;
for (int i = 0; i < N - 1; i++) {
scanf("%d%d%d", &u, &v, &w);
u--;
v--;
add_edge(u, v, w);
val[ct++] = w;
}
for (int i = 0; i < N; i++) scanf("%d", x + i);
sort(val, val + ct);
ct = unique(val, val + ct) - val;
fir = 0;
se = ct;
while (se - fir > 1) {
mid = (se + fir) >> 1;
if (calc(val[mid]))
fir = mid;
else
se = mid;
}
printf("%d\n", val[fir]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline int len(const T &a) {
return a.size();
}
constexpr int mxn = 3e3 + 10;
int n, p[mxn];
tuple<int, int, int> edges[mxn];
int guys[mxn], psum[mxn];
void clear() {
for (int i = 0; i < mxn; ++i) {
guys[i] = -1;
psum[i] = p[i];
}
}
int root(int v) { return guys[v] < 0 ? v : guys[v] = root(guys[v]); }
void unite(int v, int u) {
v = root(v), u = root(u);
if (v == u) {
return;
}
if (guys[u] < guys[v]) {
swap(u, v);
}
guys[v] += guys[u];
guys[u] = v;
psum[v] += psum[u];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int v, u, w;
scanf("%d%d%d", &v, &u, &w);
edges[i] = {w, --v, --u};
}
int allp = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &p[i]);
allp += p[i];
}
auto solve = [&](int mid) {
clear();
for (int i = 0; i < n - 1; ++i) {
if (get<0>(edges[i]) < mid) {
unite(get<1>(edges[i]), get<2>(edges[i]));
}
}
for (int i = 0; i < n; ++i) {
if (guys[i] >= 0) {
continue;
}
if (-guys[i] > (allp - psum[i])) {
return false;
}
}
return true;
};
int low = 0, high = 10000;
while (high - low > 0) {
int mid = (high + low + 1) >> 1;
if (solve(mid)) {
low = mid;
} else {
high = mid - 1;
}
}
printf("%d", low);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000;
pair<int, pair<int, int> > lis[MAXN];
int n;
int pre[MAXN];
int p[MAXN], siz[MAXN];
int findPre(int p) {
if (pre[p] != pre[pre[p]]) {
pre[p] = findPre(pre[p]);
}
return pre[p];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d%d", &lis[i].second.first, &lis[i].second.second, &lis[i].first);
lis[i].second.first--;
lis[i].second.second--;
}
int tot = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &p[i]);
tot += p[i];
pre[i] = i;
siz[i] = 1;
}
sort(lis, lis + (n - 1));
for (int i = 0; i < n; ++i) {
int a = findPre(lis[i].second.first);
int b = findPre(lis[i].second.second);
pre[b] = a;
siz[a] += siz[b];
p[a] += p[b];
if (siz[a] > (tot - p[a])) {
printf("%d\n", lis[i].first);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int N = 5000;
struct edge {
int a, b, c;
} E[N];
int xi[N], yi[N], fa[N], sum, ans;
int comp(edge u, edge v) { return u.c < v.c; }
int get_f(int a) { return fa[a] == a ? a : fa[a] = get_f(fa[a]); }
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) scanf("%d%d%d", &E[i].a, &E[i].b, &E[i].c);
sort(E + 1, E + n, comp);
for (int i = 1; i <= n; ++i)
scanf("%d", &xi[i]), yi[i] = 1, fa[i] = i, sum += xi[i];
for (int i = 1; i < n; ++i) {
ans = E[i].c;
xi[get_f(E[i].a)] += xi[get_f(E[i].b)];
yi[get_f(E[i].a)] += yi[get_f(E[i].b)];
fa[get_f(E[i].b)] = get_f(E[i].a);
if (yi[get_f(E[i].a)] > sum - xi[get_f(E[i].a)]) break;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1E9;
int N, pro[3005], rep[3005], rnk[3005], rem[3005];
pair<int, pair<int, int> > es[3005];
int fd(int x) { return rep[x] == x ? x : rep[x] = fd(rep[x]); }
void us(int a, int b) {
int x = fd(a), y = fd(b);
if (x == y) return;
if (rnk[x] > rnk[y]) swap(x, y);
if (rnk[x] == rnk[y]) rnk[y]++;
rep[x] = y;
rem[y] += rem[x];
pro[y] += pro[x];
}
int main() {
cin >> N;
if (N == 1) return puts("0"), 0;
for (int i = (0); i < (N - 1); i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
es[i] = make_pair(c, pair<int, int>(a, b));
}
sort(es, es + N - 1);
int sumpro = 0;
for (int i = (0); i < (N); i++) {
rem[i] = 1;
rnk[i] = 0;
rep[i] = i;
scanf("%d", pro + i);
sumpro += pro[i];
}
int tot = N, ans = es[0].first;
for (int i = (0); i < (N - 1); i++) {
int a = es[i].second.first, b = es[i].second.second;
int x = fd(a), y = fd(b);
us(x, y);
int z = fd(x);
if (rem[z] > sumpro - pro[z]) break;
if (i + 1 < N - 1) ans = es[i + 1].first;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[3100], s[3100], a[3100], b[3100], n, sum = 0;
int find(int k) {
if (k == f[k]) return k;
return f[k] = find(f[k]);
}
struct rec {
int x, y, z;
} q[3100];
bool cmp(rec a, rec b) { return a.z > b.z; }
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) scanf("%d%d%d", &q[i].x, &q[i].y, &q[i].z);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), sum += a[i];
sort(q + 1, q + n + 1, cmp);
for (int i = 2; i < n; i++)
if (q[i].z != q[i - 1].z) {
for (int j = 1; j <= n; j++) f[j] = j, s[j] = 1, b[j] = a[j];
for (int j = i; j < n; j++) {
int fx = find(q[j].x), fy = find(q[j].y);
if (fx == fy) continue;
f[fy] = fx;
s[fx] += s[fy];
b[fx] += b[fy];
s[fy] = b[fy] = 0;
}
int pd = 1;
for (int j = 1; j <= n; j++)
if (find(j) == j) {
if (s[j] > sum - b[j]) pd = 0;
}
if (pd) {
cout << q[i - 1].z << endl;
return 0;
}
}
cout << q[n - 1].z << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int a, b, c, d, e, f, g, h, i, j, k;
struct edge {
int u, v, w;
friend bool operator<(const edge &x, const edge &y) { return x.w < y.w; }
};
edge E[N];
int fa[N], size[N], D[N], ALL;
int Find(int x) { return fa[x] == x ? x : fa[x] = Find(fa[x]); }
void Init() {
cin >> a;
for (int ii = 1; ii < a; ii++) scanf("%d%d%d", &E[ii].u, &E[ii].v, &E[ii].w);
sort(E + 1, E + a);
for (int ii = 1; ii <= a; ii++) scanf("%d", &D[ii]), ALL += D[ii];
}
void Work() {
bool ch = true;
int an = 0;
for (int ii = 1; ii <= a; ii++) fa[ii] = ii, size[ii] = 1;
for (int ii = 1; ii <= a; ii++)
if (size[ii] > ALL - D[ii]) ch = false;
if (ch) an = E[1].w;
for (int ii = 1; ch && ii < a - 1; ii++) {
c = Find(E[ii].u), d = Find(E[ii].v);
fa[d] = c, size[c] += size[d], D[c] += D[d];
if (size[c] > ALL - D[c]) ch = false;
if (ch) an = E[ii + 1].w;
}
cout << an << endl;
}
int main() {
Init(), Work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[3000];
int par[3000];
int cnt[3000];
void init(int n) {
int i;
for (i = 0; i < n; i++) {
par[i] = i;
cnt[i] = 0;
}
}
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
par[x] = y;
}
int main() {
int n, l, r, m, i;
vector<pair<int, pair<int, int> > > v;
scanf("%d", &n);
for (i = 0; i < n - 1; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
v.push_back(make_pair(z, make_pair(x - 1, y - 1)));
}
sort(v.begin(), v.end());
for (i = 0; i < n; i++) scanf("%d", &a[i]);
if (n == 1) {
puts("0");
return 0;
}
l = 0, r = n - 1, m = (l + r) / 2;
while (r - l > 1) {
int c = 0, sum = 0;
init(n);
for (i = 0; i < m; i++) unite(v[i].second.first, v[i].second.second);
for (i = 0; i < n; i++) cnt[find(i)]++;
for (i = 0; i < n; i++) {
if (cnt[i] > cnt[c]) c = i;
}
for (i = 0; i < n; i++) {
if (find(i) != c) sum += a[i];
}
if (sum >= cnt[c]) {
l = m;
m = (l + r) / 2;
} else {
r = m;
m = (l + r) / 2;
}
}
printf("%d\n", v[l].first);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3000 + 100;
int aa[N], bb[N], cc[N];
int n;
int fa[N], sum[N], son[N], lim[N];
int Find(int u) {
if (u == fa[u]) return u;
return fa[u] = Find(fa[u]);
}
int check(int mid) {
for (int i = 1; i <= n; i++) fa[i] = i, sum[i] = lim[i], son[i] = 1;
for (int i = 1; i < n; i++) {
if (cc[i] >= mid) continue;
int u = Find(aa[i]), v = Find(bb[i]);
if (u == v) continue;
if (son[u] > son[v]) swap(u, v);
fa[u] = v;
sum[v] += sum[u];
son[v] += son[u];
}
int all = 0;
for (int i = 1; i <= n; i++) {
int u = Find(i);
if (u != i) continue;
all += sum[i];
}
for (int i = 1; i <= n; i++) {
if (fa[i] != i) continue;
if (all - sum[i] < son[i]) return 0;
}
return 1;
}
int sta[N], top;
int main() {
while (scanf("%d", &n) != EOF) {
top = 0;
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &aa[i], &bb[i], &cc[i]);
sta[top++] = cc[i];
}
for (int i = 1; i <= n; i++) scanf("%d", &lim[i]);
sort(sta, sta + top);
top = unique(sta, sta + top) - sta;
int l = 1, r = top - 1;
int ans = sta[0];
while (l <= r) {
int mid = (l + r) / 2;
if (check(sta[mid])) {
ans = sta[mid];
l = mid + 1;
} else
r = mid - 1;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long w[200000], sz[200000], ttl[200000], ans, n;
vector<pair<long, pair<long, long> > > v;
long s, er, a, b;
long c, cur;
long gett(long x) {
while (x != w[x]) x = w[x];
return x;
}
void merg(long a, long b) {
a = gett(a), b = gett(b);
w[b] = a;
sz[a] += sz[b];
ttl[a] += ttl[b];
if (sz[a] > s - ttl[a]) er = 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> a >> b >> c;
v.push_back(make_pair(c, make_pair(a, b)));
}
sort(v.begin(), v.end());
for (int i = 1; i <= n; i++) {
cin >> ttl[i];
sz[i] = 1;
s += ttl[i];
w[i] = i;
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
ans = v[0].first;
for (int i = 0; i < v.size();) {
cur = i;
while (cur < v.size() && v[cur].first == v[i].first) {
merg(v[cur].second.first, v[cur].second.second);
++cur;
}
i = cur;
if (i < v.size() && er == 0) ans = v[i].first;
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long long BIG = 1446803456761533460;
const int Big = 336860180;
stringstream sss;
const long long int maxn = 3010;
long long int n;
long long int cnt[maxn], sz[maxn];
long long int rt[maxn];
pair<long long int, pair<long long int, long long int> > es[maxn];
long long int root(long long int x) {
return x == rt[x] ? x : rt[x] = root(rt[x]);
}
void MAIN() {
cin >> n;
for (long long int i = (0); i < (n - 1); ++i) {
long long int a, b, c;
cin >> a >> b >> c;
--a, --b;
es[i] = {c, {a, b}};
}
long long int sum = 0;
for (long long int i = (0); i < (n); ++i) cin >> cnt[i], sum += cnt[i];
sort(es, es + n - 1);
iota(rt, rt + n, 0);
fill(sz, sz + n, 1);
long long int ans = 0;
for (long long int i = (0); i < (n - 1); ++i) {
ans = es[i].first;
long long int ra = root(es[i].second.first), rb = root(es[i].second.second);
sz[ra] += sz[rb];
cnt[ra] += cnt[rb];
rt[rb] = ra;
if (sum - cnt[ra] < sz[ra]) break;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
4
1 2 1
2 3 2
3 4 3
1
1
1
1
)";
MAIN();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int a, b, v;
} e[3010];
int fa[3010], siz[3010], cnt[3010], sum;
bool can;
bool operator<(edge a, edge b) { return a.v < b.v; }
int getfa(int x) {
if (fa[x] == x) return x;
return fa[x] = getfa(fa[x]);
}
void merge(int x, int y) {
x = getfa(x);
y = getfa(y);
siz[x] += siz[y];
cnt[x] += cnt[y];
fa[y] = x;
if (siz[x] > sum - cnt[x]) can = 0;
}
int main() {
int n, i, ans;
scanf("%d", &n);
for (i = 1; i < n; i++) scanf("%d%d%d", &e[i].a, &e[i].b, &e[i].v);
for (i = 1; i <= n; i++) {
scanf("%d", cnt + i);
sum += cnt[i];
siz[i] = 1;
fa[i] = i;
}
sort(e + 1, e + n);
ans = 0;
can = 1;
for (i = 1; i < n; i++) {
if (can) ans = e[i].v;
merge(e[i].a, e[i].b);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int n, ans, sum, a[N];
int sz[N], fa[N];
struct edge {
int x, y, v;
bool operator<(const edge &a) const { return v < a.v; }
} e[N];
int get(int x) { return x == fa[x] ? x : fa[x] = get(fa[x]); }
int main() {
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n - 1); i++)
scanf("%d%d%d", &e[i].x, &e[i].y, &e[i].v);
sort(e + 1, e + n);
for (int i = (int)(1); i <= (int)(n); i++) scanf("%d", &a[i]);
for (int i = (int)(1); i <= (int)(n); i++) sz[i] = 1, fa[i] = i, sum += a[i];
for (int i = (int)(1); i <= (int)(n - 1); i++) {
ans = e[i].v;
int x = get(e[i].x), y = get(e[i].y);
fa[x] = y;
sz[y] += sz[x];
a[y] += a[x];
if (sz[y] > sum - a[y]) break;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, w = 1;
char c;
while (c = getchar(), c > '9' || c < '0')
if (c == '-') w = -1;
while (c >= '0' && c <= '9') s = s * 10 + c - '0', c = getchar();
return s * w;
}
const int N = 1e5 + 7;
struct edge {
int u, t, w;
bool operator<(edge a) const { return w < a.w; }
} e[N];
int n, sum, ans, can;
int X[N], siz[N], fa[N];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
vector<pair<int, int> > V;
void merge(int a, int b) {
fa[b] = a;
siz[a] += siz[b];
X[a] += X[b];
if (siz[a] > sum - X[a]) can = 1;
}
int main() {
n = read();
if (n == 1) return puts("0"), 0;
for (int i = 1; i < n; i++) e[i].u = read(), e[i].t = read(), e[i].w = read();
sort(e + 1, e + n);
for (int i = 1; i <= n; i++) X[i] = read(), sum += X[i];
for (int i = 1; i <= n; i++) fa[i] = i, siz[i] = 1;
for (int i = 1; i < n; i++) {
if (can) break;
ans = e[i].w;
int u = find(e[i].u), t = find(e[i].t);
merge(u, t);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using i64 = long long;
using namespace std;
const int nxM = int(1e4);
struct edge {
int u, v, w;
};
bool cmp(const edge &a, const edge &b) { return a.w < b.w; }
i64 n, sz[nxM], sum_x[nxM], par[nxM], s, x[nxM];
vector<edge> adj;
int find(int u) {
if (par[u] != u) par[u] = find(par[u]);
return par[u];
}
void join(int u, int v) {
u = find(u);
v = find(v);
if (u != v) {
sz[u] += sz[v];
sum_x[u] += sum_x[v];
par[v] = u;
}
}
void reset() {
for (int i = 1; i <= n; ++i) {
par[i] = i;
sz[i] = 1;
sum_x[i] = x[i];
}
}
void input() {
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int a, b, c;
cin >> a >> b >> c;
adj.push_back({a, b, c});
}
for (int i = 1; i <= n; ++i) {
cin >> x[i];
s += x[i];
}
}
bool solve(int m) {
reset();
for (edge &e : adj) {
if (e.w < m) join(e.u, e.v);
}
for (int i = 1; i <= n; ++i) {
if (find(i) == i) {
if (sz[i] > s - sum_x[i]) return false;
}
}
return true;
}
void binary(int l, int r) {
while (true) {
int m = l + (r - l) / 2;
if (l == m || r == m) break;
if (solve(m))
l = m;
else
r = m;
}
for (int i = r; i >= l; --i) {
if (solve(i)) {
cout << i << endl;
return;
}
}
cout << "0" << endl;
}
int main() {
input();
binary(1, int(1e4));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct UF {
int par[3005], rank[3005];
int cost[3005];
void init(int n) {
for (int i = 0; i < n; i++) {
par[i] = i;
rank[i] = cost[i] = 0;
}
}
void add(int k, int x) { cost[k] = x; }
int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
int unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return 0;
if (rank[x] < rank[y]) {
par[x] = y;
cost[y] += cost[x];
return cost[y];
} else {
par[y] = x;
cost[x] += cost[y];
if (rank[x] == rank[y]) rank[x]++;
return cost[x];
}
}
};
UF uf;
vector<pair<int, int> > vec[10005];
int main() {
int n;
scanf("%d", &n);
if (n == 1) {
puts("0");
return 0;
}
for (int i = 0; i < n - 1; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
a--;
b--;
vec[c].push_back(pair<int, int>(a, b));
}
uf.init(n + 2);
int all = 0;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
all += a;
uf.add(i, a + 1);
}
int ret = 1;
for (int i = 1; i < 10005; i++) {
int gt = 0;
for (int j = 0; j < vec[i].size(); j++) {
pair<int, int> p = vec[i][j];
gt = max(gt, uf.unite(p.first, p.second));
}
if (gt > all) break;
ret = i + 1;
}
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int size[3010], fa[3010], sum[3010], head[10010];
struct node {
int x, y, next;
} e[3010];
int find(int x) {
if (x != fa[x]) fa[x] = find(fa[x]);
return fa[x];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
e[i].x = x;
e[i].y = y;
e[i].next = head[w];
head[w] = i;
}
int s = 0;
for (int i = 1; i <= n; i++) {
fa[i] = i;
size[i] = 1;
scanf("%d", &sum[i]);
s += sum[i];
}
for (int i = 1; i <= 10000; i++) {
int p = head[i];
while (p) {
int x = find(e[p].x), y = find(e[p].y);
fa[y] = x;
size[x] += size[y];
sum[x] += sum[y];
if (size[x] + sum[x] > s) {
printf("%d\n", i);
return 0;
}
p = e[p].next;
}
}
puts("0");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3000 + 5;
struct edge {
int u, v, a;
bool operator<(const edge& c) const { return a < c.a; }
} Set[maxn];
int f[maxn], sz[maxn], out[maxn], sum, N;
int F(int o) { return o == f[o] ? o : f[o] = F(f[o]); }
int main() {
scanf("%d", &N);
if (N == 1) {
puts("0");
return 0;
}
for (int i = 1; i < N; ++i) scanf("%d%d%d", &Set[i].u, &Set[i].v, &Set[i].a);
for (int i = 1; i <= N; ++i) {
scanf("%d", &sz[i]);
sum += sz[i];
out[i] = 1;
f[i] = i;
}
sort(Set + 1, Set + N);
for (int i = 1; i < N; i++) {
int u = F(Set[i].u), v = F(Set[i].v);
if (u != v) {
f[v] = u;
sz[u] += sz[v];
out[u] += out[v];
if (sz[u] + out[u] > sum) {
printf("%d\n", Set[i].a);
return 0;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
template <typename T>
inline T read() {
static T _, __;
static char c_;
for (_ = 0, __ = 1, c_ = getchar(); c_ < '0' || c_ > '9'; c_ = getchar())
if (c_ == '-') __ = -1;
for (; c_ >= '0' && c_ <= '9'; c_ = getchar())
_ = (_ << 1) + (_ << 3) + (c_ ^ 48);
return _ * __;
}
const int maxn = 3005;
int n, fa[maxn], sz[maxn], in[maxn], sum;
pair<int, pair<int, int> > E[maxn];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
int main() {
n = read<int>();
for (register int i = (1), i_end_ = (n - 1); i <= i_end_; ++i)
E[i].second.first = read<int>(), E[i].second.second = read<int>(),
E[i].first = read<int>();
sort(E + 1, E + n);
for (register int i = (1), i_end_ = (n); i <= i_end_; ++i)
fa[i] = i, sz[i] = 1, sum += in[i] = read<int>();
for (register int i = (1), i_end_ = (n - 1); i <= i_end_; ++i) {
int x = find(E[i].second.first), y = find(E[i].second.second);
fa[y] = x, sz[x] += sz[y], in[x] += in[y];
if (sum - in[x] < sz[x]) return printf("%d\n", E[i].first), 0;
}
puts("0");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
pair<int, pair<int, int> > E[3000];
int ans, sum;
bool ok = true;
struct UnionFind {
int par[3000], ra[3000], sz[3000];
void init() {
for (int(i) = 0; (i) < (3000); (i)++) par[i] = i, ra[i] = 1;
}
int find(int x) { return par[x] == x ? x : par[x] = find(par[x]); }
void unite(int a, int b) {
if ((a = find(a)) != (b = find(b))) {
if (ra[a] < ra[b]) swap(a, b);
par[b] = a, ra[a] += ra[b];
sz[a] += sz[b];
if (sum - sz[a] < ra[a]) ok = false;
}
}
} uf;
int main() {
scanf("%d", &N);
for (int(i) = 0; (i) < (N - 1); (i)++)
scanf("%d%d%d", &E[i].second.first, &E[i].second.second, &E[i].first),
E[i].second.first--, E[i].second.second--;
sort(E, E + N - 1);
uf.init();
sum = 0;
for (int(i) = 0; (i) < (N); (i)++) scanf("%d", &uf.sz[i]), sum += uf.sz[i];
for (int(i) = 0; (i) < (N); (i)++) ok &= (sum - uf.sz[i] >= 1);
if (ok) ans = E[0].first;
if (N == 1) {
puts("0");
return 0;
}
int ptr = 0;
while (ptr < N - 1) {
int tt = E[ptr].first;
while (ptr < N - 1 && tt == E[ptr].first) {
uf.unite(E[ptr].second.first, E[ptr].second.second);
ptr++;
}
if (ok && ptr <= N - 1) ans = E[min(ptr, N - 2)].first;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1, 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;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(int x) {
write(x);
puts("");
}
const int N = 1e5 + 5;
struct edge {
int u, v, w;
} e[N << 1];
int n, m, c[N], Sum;
inline void init() {
n = read();
for (int i = 1; i < n; i++) {
e[i] = (edge){read(), read(), read()};
}
for (int i = 1; i <= n; i++) {
c[i] = read();
Sum += c[i];
}
}
inline bool cmp(edge A, edge B) { return A.w < B.w; }
int tmp, fa[N], sz[N], sum[N];
int getfa(int x) { return (fa[x] == x) ? x : fa[x] = getfa(fa[x]); }
inline void Union(int u, int v) {
int p = getfa(u), q = getfa(v);
if (p != q) {
fa[p] = q;
sz[q] += sz[p];
}
}
inline bool judge(int mid) {
for (int i = 1; i <= n; i++) fa[i] = i, sz[i] = c[i];
memset(sum, 0, sizeof sum);
tmp = 0;
for (int i = 1; i <= m; i++) {
if (e[i].w < mid) {
tmp = i;
Union(e[i].u, e[i].v);
} else {
break;
}
}
for (int i = 1; i <= n; i++) {
fa[i] = getfa(i);
sum[fa[i]]++;
}
for (int i = 1; i <= n; i++) {
if (sum[i]) {
int other = Sum - sz[i];
if (other < sum[i]) {
return 0;
}
}
}
return 1;
}
inline void solve() {
if (n == 1) {
puts("0");
return;
}
m = n - 1;
sort(e + 1, e + m + 1, cmp);
int l = 1, r = 1e9;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (judge(mid))
l = mid;
else
r = mid - 1;
}
writeln(l);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &q) {
int x = 0, f = 1;
char ch;
for (ch = getchar(); (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') {
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
q = x * f;
}
struct Edge {
int x, y, w;
} edge[100001];
int n, sum, tot, l, r, mid, flag, Ans;
int father[100001], ans[100001], tmp[100001], size[100001], a[100001],
x[100001];
int find(int x) { return x == father[x] ? x : father[x] = find(father[x]); }
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
read(edge[i].x);
read(edge[i].y);
read(edge[i].w);
tmp[i] = edge[i].w;
}
for (int i = 1; i <= n; i++) {
read(x[i]);
tot += x[i];
}
sort(tmp + 1, tmp + n);
sum = 1;
ans[1] = tmp[1];
for (int i = 1; i < n; i++)
if (tmp[i] != tmp[i - 1]) {
sum++;
ans[sum] = tmp[i];
}
Ans = l = 1;
r = sum;
while (l <= r) {
flag = 1;
mid = (l + r) >> 1;
memset(a, 0, sizeof(a));
memset(size, 0, sizeof(size));
for (int i = 1; i <= n; i++) father[i] = i;
for (int i = 1; i < n; i++)
if (edge[i].w < ans[mid] && find(edge[i].x) != find(edge[i].y))
father[find(edge[i].x)] = find(edge[i].y);
for (int i = 1; i <= n; i++) {
size[find(i)]++;
a[find(i)] += x[i];
}
for (int i = 1; i <= n; i++)
if (find(i) == i && tot - a[i] < size[i]) {
flag = 0;
break;
}
if (flag) {
Ans = max(Ans, mid);
l = mid + 1;
} else
r = mid - 1;
}
cout << ans[Ans];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, hd[3003], nt[6003], nd[6003], wi[6003], t, m[3003], cnt[2][3003],
x[3003];
void add(int u, int v, int w) {
nt[t] = hd[u];
nd[t] = v;
wi[t] = w;
hd[u] = t++;
}
bool vis[3003];
void dfs(int u, int w, int num) {
vis[u] = 1;
++cnt[0][num], cnt[1][num] += x[u];
for (int i = hd[u]; ~i; i = nt[i]) {
if (wi[i] >= w) continue;
int v = nd[i];
if (vis[v]) continue;
dfs(v, w, num);
}
}
bool ck(int u) {
t = 0, memset(vis, 0, sizeof vis), memset(cnt, 0, sizeof cnt);
for (int i = 1; i <= n; ++i)
if (!vis[i]) dfs(i, u, ++t);
int sum = 0;
for (int i = 1; i <= t; ++i) sum += cnt[1][i];
for (int i = 1; i <= t; ++i)
if (cnt[0][i] > sum - cnt[1][i]) return 0;
return 1;
}
int main() {
memset(hd, -1, sizeof hd);
scanf("%d", &n);
for (int i = 1, u, v, w; i < n; ++i) {
scanf("%d%d%d", &u, &v, &w);
add(u, v, w), add(v, u, w), m[i] = w;
}
sort(m + 1, m + n);
for (int i = 1; i <= n; ++i) scanf("%d", &x[i]);
int l = 0, r = n, mid;
while (l < r - 1) {
mid = (l + r) / 2;
if (ck(m[mid]))
l = mid;
else
r = mid;
}
printf("%d", m[l]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const int MN = 3e3 + 10;
int es[MN], ee[MN], el[MN], f[MN], sum, par[MN], sz[MN], F[MN];
pair<int, int> borobaba[MN];
bool fl;
int n;
int root(int x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void Union(int x, int y) {
x = root(x), y = root(y);
if (x == y) return;
if (sz[x] < sz[y]) swap(x, y);
sz[x] += sz[y];
F[x] += F[y];
par[y] = x;
if (sum - F[x] < sz[x]) fl = true;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; ++i) {
cin >> es[i] >> ee[i] >> el[i];
--es[i];
--ee[i];
borobaba[i] = pair<int, int>(el[i], i);
}
for (int i = 0; i < n; ++i)
cin >> f[i], sum += f[i], F[i] = f[i], par[i] = i, sz[i] = 1;
sort(borobaba, borobaba + n - 1);
int ans = 0, cur = 0;
while (cur < n - 1) {
int Id = borobaba[cur].second;
if (!fl) ans = el[Id];
Union(es[Id], ee[Id]);
while (cur < n - 1 && el[Id] == borobaba[cur].first)
Union(es[borobaba[cur].second], ee[borobaba[cur].second]), cur++;
}
if (!fl && n > 1) ans = el[borobaba[n - 2].second];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, pair<int, int> > q[3333];
int p[3333], sz[3333], kol[3333];
int maxsz, sum = 0, bad = 0;
int get(int x) {
if (p[x] == x) return x;
return p[x] = get(p[x]);
}
void unite(int x, int y) {
x = get(x);
y = get(y);
maxsz = max(maxsz, sz[x] + sz[y]);
sz[x] += sz[y];
kol[x] += kol[y];
if (kol[x] > sum - sz[x]) bad = 1;
p[y] = x;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d%d", &q[i].second.first, &q[i].second.second, &q[i].first);
q[i].second.first--;
q[i].second.second--;
}
sort(q, q + n - 1);
int ans = 0;
bad = 0;
for (int i = 0; i < n; i++) {
p[i] = i;
scanf("%d", &sz[i]);
kol[i] = 1;
sum += sz[i];
}
for (int i = 0; i < n; i++)
if (kol[i] > sum - sz[i]) bad = 1;
if (bad == 0 && n > 1) ans = q[0].first;
for (int i = 0; i < n - 1;) {
int j = i;
while (j < n && q[j].first == q[i].first) {
unite(q[j].second.first, q[j].second.second);
j++;
}
i = j;
if (bad == 0 && i < n) ans = q[i].first;
if (bad) break;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
const long long int INF = 2e9 + 1;
vector<vector<pair<int, int> > > g;
vector<int> x;
vector<vector<int> > comp;
int ptr = 0;
void dfs(int id, int isc, int need, int p) {
comp[isc].push_back(id);
for (int i = 0; i < ((int)(g[id]).size()); i++) {
int to = g[id][i].first;
int d = g[id][i].second;
if (p == to) continue;
int togo = isc;
if (d >= need) {
togo = ++ptr;
vector<int> cl;
comp.push_back(cl);
}
dfs(to, togo, need, id);
}
}
bool tryans(int ans) {
comp.clear();
comp.resize(1);
ptr = 0;
dfs(0, 0, ans, -1);
vector<int> sum((int)(comp).size());
vector<int> used((int)(g).size());
vector<int> val((int)(g).size());
int allsum = 0;
for (int i = 0; i < ((int)(comp).size()); i++) {
for (int j = 0; j < ((int)(comp[i]).size()); j++) {
int id = comp[i][j];
sum[i] += x[id];
}
allsum += sum[i];
}
set<pair<int, int> > s;
for (int i = 0; i < ((int)(comp).size()); i++) {
for (int j = 0; j < ((int)(comp[i]).size()); j++) {
int id = comp[i][j];
val[id] = allsum - sum[i];
s.insert(make_pair(val[id], id));
}
}
int taked = 0;
for (int i = 0; i < ((int)(comp).size()); i++) {
int minus = 0;
for (int j = 0; j < ((int)(comp[i]).size()); j++) {
int id = comp[i][j];
if (!used[id]) s.erase(s.find(make_pair(val[id], id)));
}
for (int j = 0; j < ((int)(comp[i]).size()); j++) {
int id = comp[i][j];
for (int k = 0; k < (x[id]); k++) {
if (s.empty()) break;
int to = s.begin()->second;
s.erase(s.begin());
used[to]++;
taked++;
minus++;
}
}
for (int j = 0; j < ((int)(comp[i]).size()); j++) {
int id = comp[i][j];
if (!used[id]) {
if (!s.empty()) val[id] += minus;
s.insert(make_pair(val[id], id));
}
}
}
return taked == (int)(g).size();
}
int main() {
int n;
cin >> n;
if (n == 1) {
cout << 0;
return 0;
}
g.resize(n);
x.resize(n);
for (int i = 0; i < (n - 1); i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
g[a].push_back(make_pair(b, c));
g[b].push_back(make_pair(a, c));
}
for (int i = 0; i < (n); i++) scanf("%d", &x[i]);
int l = 1, r = 10001;
while (l != r) {
int mid = (l + r + 1) / 2;
if (tryans(mid))
l = mid;
else
r = mid - 1;
}
cout << l;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int c, u, v;
edge() {}
void read() { scanf("%d%d%d", &u, &v, &c), u--, v--; }
bool operator<(const edge &rhs) const { return c < rhs.c; }
} E[3005];
int n, p[3005], cnt[3005], sum[3005], tot;
int find(int u) { return u == p[u] ? u : p[u] = find(p[u]); }
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) E[i].read();
for (int i = 0; i < n; ++i) {
scanf("%d", sum + i);
cnt[i] = 1, p[i] = i, tot += sum[i];
}
sort(E, E + n - 1);
int ans = E[0].c;
for (int i = 0; i < n - 1; ++i) {
bool ok = 1;
for (int j = i; j < n - 1; ++j) {
if (E[j].c != E[i].c) {
ans = E[j].c;
i = j - 1;
break;
}
int x = find(E[j].u), y = find(E[j].v);
cnt[x] += cnt[y];
sum[x] += sum[y];
p[y] = x;
if (cnt[x] > tot - sum[x]) {
ok = 0;
break;
}
}
if (!ok) break;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int root[3001], cat[3001], val[3001], tot[3001], n;
int c[3001];
vector<pair<int, int> > adj[3001];
inline int find_root(int u) {
if (u == root[u]) return u;
return root[u] = find_root(root[u]);
}
void dfs(int u, int par, int limit) {
pair<int, int> e;
int i;
for (i = 0; i < adj[u].size(); i++) {
e = adj[u][i];
if (e.first == par) continue;
if (e.second < limit) root[find_root(u)] = find_root(e.first);
dfs(e.first, u, limit);
}
}
bool can(int md) {
for (int i = 1; i <= n; i++) {
root[i] = i;
cat[i] = 0;
tot[i] = 0;
}
dfs(1, 0, md);
for (int i = 1; i <= n; i++) {
root[i] = find_root(i);
cat[root[i]]++;
tot[root[i]] += c[i];
}
int maxL = 1;
int sum = 0;
for (int i = 1; i <= n; i++) {
if (i == root[i]) {
sum += tot[i];
if (cat[i] > cat[maxL]) maxL = i;
}
}
return (sum - cat[maxL] >= tot[maxL]);
}
int main() {
int i, u, v, w;
scanf("%d", &n);
for (i = 0; i < n - 1; i++) {
scanf("%d%d%d", &u, &v, &w);
adj[u].push_back(make_pair(v, w));
adj[v].push_back(make_pair(u, w));
val[i] = w;
}
for (int i = 1; i <= n; i++) scanf("%d", c + i);
sort(val, val + n - 1);
int ed = unique(val, val + n - 1) - val, st = 0;
while (ed - st > 1) {
int md = ed + st >> 1;
if (can(val[md]))
st = md;
else
ed = md;
}
printf("%d\n", val[st]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1000005;
const double eps = 1e-8;
const double DINF = 1e100;
const int INF = 1000000006;
const long long LINF = 1000000000000000005ll;
struct Edge {
int a, b, c;
Edge() {}
Edge(int a, int b, int c) : a(a), b(b), c(c) {}
} edge[MaxN];
int fa[MaxN];
int n;
int get(int x) {
if (x == fa[x]) return x;
return fa[x] = get(fa[x]);
}
int x[MaxN];
int size[MaxN];
int sumx[MaxN];
int all = 0;
bool check(int w) {
for (int i = 1; i <= n; ++i) {
fa[i] = i;
size[i] = 1;
sumx[i] = x[i];
}
for (int i = 1; i < n; ++i) {
int u = edge[i].a;
int v = edge[i].b;
int c = edge[i].c;
if (c >= w) continue;
int a = get(u);
int b = get(v);
fa[a] = b;
size[b] += size[a];
sumx[b] += sumx[a];
}
for (int i = 1; i <= n; ++i)
if (fa[i] == i) {
if (size[i] > all - sumx[i]) return false;
}
return true;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
edge[i] = Edge(a, b, c);
}
for (int i = 1; i <= n; ++i) {
scanf("%d", x + i);
all += x[i];
}
int l = 0, r = INF;
while (l + 1 < r) {
int mid = (l + r) >> 1;
if (check(mid))
l = mid;
else
r = mid;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
FILE *debug;
void setIO(string file = "sample") {}
void closeIO() {}
template <class T>
void read(T &x) {
char tmp = 0;
T flag = 1, ret = 0;
while (tmp != '-' && !isdigit(tmp)) tmp = getchar();
if (tmp == '-') flag = -1, tmp = getchar();
while (isdigit(tmp)) ret *= 10, ret += tmp - '0', tmp = getchar();
x = flag * ret;
}
long long getint() {
long long ret;
read<long long>(ret);
return ret;
}
void endline() { fprintf(debug, "\n"); }
pair<int, pair<int, int> > v[3010];
int n, times[3010], x[3010], fa[3010], xsum;
int gf(int x) {
if (x == fa[x]) return x;
return gf(fa[x]);
}
int main(int argc, char *argv[]) {
setIO("sample");
int i = 1;
n = getint();
for (i = 1; i <= n - 1; ++i)
v[i].second.first = getint(), v[i].second.second = getint(),
v[i].first = getint();
sort(v + 1, v + n);
for (i = 1; i <= n; fa[i] = i, ++i) {
times[i] = x[i] = getint();
xsum += x[i];
++times[i];
}
for (i = 1; i <= n - 1; ++i) {
times[gf(v[i].second.second)] += times[gf(v[i].second.first)];
fa[gf(v[i].second.first)] = fa[gf(v[i].second.second)];
if (times[gf(v[i].second.second)] > xsum) break;
}
printf("%d", v[i].first);
closeIO();
return EXIT_SUCCESS;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edg {
int s, e, v;
bool operator<(const edg& c) const { return v < c.v; }
} ba[3333];
int n, xi[3333], par[3333], cnt[3333];
int root(int ix) {
while (par[ix]) ix = par[ix];
return ix;
}
int main() {
int i, j, k, sum;
scanf("%d", &n);
for (i = 0; i < n - 1; i++) scanf("%d%d%d", &ba[i].s, &ba[i].e, &ba[i].v);
sort(ba, ba + n - 1);
for (i = 1; i <= n; i++) scanf("%d", &xi[i]), cnt[i] = 1;
for (i = 0; i < n - 1; i++) {
for (j = 1; j <= n; j++) {
if (!par[j] && cnt[j] > n / 2) break;
}
if (j <= n) {
sum = 0;
for (k = 1; k <= n; k++) {
if (root(k) != j) sum += xi[k];
}
if (sum < cnt[j]) break;
}
j = root(ba[i].s), k = root(ba[i].e);
if (cnt[j] < cnt[k])
par[j] = k, cnt[k] += cnt[j];
else
par[k] = j, cnt[j] += cnt[k];
}
printf("%d", ba[i - 1].v);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 100;
struct E {
int u, v, w;
} e[N * 2];
int siz[N], sum[N], fa[N];
int x[N], xi, book[N], n, ans;
int L, R;
bool C1(E a, E b) { return a.w < b.w; }
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
bool check(int X) {
for (int i = 1; i <= n; i++)
fa[i] = i, siz[i] = 1, sum[i] = x[i], book[i] = 0;
for (int i = 1; i <= n - 1; i++) {
if (e[i].w >= X) break;
int dx = find(e[i].u), dy = find(e[i].v);
siz[dy] += siz[dx];
siz[dx] = 0;
sum[dy] += sum[dx];
sum[dx] = 0;
fa[dx] = dy;
}
for (int i = 1; i <= n; i++) {
int dx = find(i);
if (book[dx]) continue;
book[dx] = 1;
if (siz[dx] > xi - sum[dx]) return false;
}
return true;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++)
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w), R = max(R, e[i].w);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]), xi += x[i];
sort(e + 1, e + n, C1);
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 maxN = 3e3 + 5;
struct Edge {
int u, v, w;
bool operator<(const Edge& t) const { return w < t.w; }
} E[maxN];
int f[maxN];
int N;
int _sum;
int sum[maxN];
int sz[maxN];
int x[maxN];
int get_f(int x) { return f[x] == x ? x : f[x] = get_f(f[x]); }
int main() {
scanf("%d", &N);
for (int i = 1; i <= N - 1; i++) {
scanf("%d%d%d", &E[i].u, &E[i].v, &E[i].w);
}
for (int i = 1; i <= N; i++) {
scanf("%d", &x[i]);
sum[i] = x[i];
sz[i] = 1;
f[i] = i;
_sum += x[i];
}
sort(E + 1, E + N);
int ans = 0;
for (int i = 1; i < N; i++) {
int u = E[i].u;
int v = E[i].v;
int fu = get_f(u);
int fv = get_f(v);
if (sz[fu] + sz[fv] > _sum - sum[fu] - sum[fv]) {
ans = E[i].w;
break;
}
f[fu] = fv;
sz[fv] += sz[fu];
sum[fv] += sum[fu];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, fa[3005], siz[3005], p[3005], sum;
struct node {
int x, y, z;
} q[3005];
bool cmpp(node a, node b) { return a.z < b.z; }
int find(int x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) scanf("%d%d%d", &q[i].x, &q[i].y, &q[i].z);
sort(q + 1, q + n, cmpp);
for (int i = 1; i <= n; i++)
fa[i] = i, scanf("%d", &p[i]), siz[i] = 1, sum += p[i];
for (int i = 1; i <= n - 1; i++) {
int f1 = find(q[i].x), f2 = find(q[i].y);
fa[f2] = f1;
siz[f1] += siz[f2];
p[f1] += p[f2];
if (siz[f1] > sum - p[f1]) {
printf("%d", q[i].z);
return 0;
}
}
printf("%d", q[n - 1].z);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3005;
int n, ans, can, all;
int f[maxn], siz[maxn], sum[maxn];
pair<int, pair<int, int> > E[maxn];
int getf(int x) { return f[x] ? f[x] = getf(f[x]) : x; }
void merge(int x, int y) {
x = getf(x), y = getf(y);
f[y] = x;
siz[x] += siz[y];
sum[x] += sum[y];
if (siz[x] > all - sum[x]) can = 0;
}
void init() {
scanf("%d", &n);
for (int i = 1; i < n; i++)
scanf("%d%d%d", &E[i].second.first, &E[i].second.second, &E[i].first);
sort(E + 1, E + n);
for (int i = 1; i <= n; i++) siz[i] = 1, scanf("%d", sum + i), all += sum[i];
}
int work() {
if (n == 1) return 0;
can = 1;
for (int i = 1; i <= n; i++)
if (siz[i] > all - sum[i]) can = 0;
if (can) ans = E[1].first;
for (int i = 1, j; i < n && can; i = j) {
for (j = i; j < n && E[j].first == E[i].first; j++)
merge(E[j].second.first, E[j].second.second);
if (can && j < n) ans = E[j].first;
}
return ans;
}
int main() {
init();
cout << work() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, z;
} ob[100010];
bool cmp(node a, node b) { return a.z < b.z; }
int n, f[100010], size[100010], sum, x[100010];
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
void ini() {
scanf("%d", &n);
for (int i = 1; i < n; i++) scanf("%d%d%d", &ob[i].x, &ob[i].y, &ob[i].z);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
sort(ob + 1, ob + n, cmp);
for (int i = 1; i <= n; i++) f[i] = i, sum += x[i], size[i] = 1;
}
int main() {
ini();
for (int i = 1; i < n; i++) {
int tx = find(ob[i].x);
int ty = find(ob[i].y);
x[ty] += x[tx];
size[ty] += size[tx];
f[tx] = ty;
if (sum - x[ty] < size[ty]) {
printf("%d", ob[i].z);
return 0;
}
}
printf("0");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
struct Edge {
long long v, w, to;
} e[100005 * 2];
struct Node {
long long l, r, w;
inline bool operator<(const Node& x) const { return w > x.w; }
} a[100005];
long long n, l, r, w, x, y, xx, yy, xxx, yyy, cnt, size, root, b[100005],
c[100005], f[100005], g[100005], id[100005], fa[100005], dep[100005],
num[100005], sum[100005], head[100005];
inline void add(long long u, long long v, long long w) {
e[++size].v = v;
e[size].to = head[u];
e[size].w = w;
head[u] = size;
}
inline void inc1(long long x, long long k) {
while (x <= n) {
f[x] += k;
x += x & (-x);
}
return;
}
inline void inc2(long long x, long long k) {
while (x <= n) {
g[x] += k;
x += x & (-x);
}
return;
}
inline long long ask1(long long x) {
long long ans = 0;
while (x) {
ans += f[x];
x -= x & (-x);
}
return ans;
}
inline long long ask2(long long x) {
long long ans = 0;
while (x) {
ans += g[x];
x -= x & (-x);
}
return ans;
}
inline void dfs(long long u, long long last) {
id[u] = ++cnt;
num[cnt] = u;
fa[u] = last;
dep[u] = dep[last] + 1;
sum[u] = 1;
for (long long i = head[u]; i; i = e[i].to) {
long long v = e[i].v;
if (v == last) continue;
dfs(v, u);
sum[u] += sum[v];
}
return;
}
inline void dfs2(long long u, long long last) {
inc1(id[u], -b[u]);
inc2(id[u], -c[u]);
b[u] = c[u] = 0;
for (long long i = head[u]; i; i = e[i].to) {
long long v = e[i].v;
if (v == last) continue;
dfs2(v, u);
}
return;
}
int main() {
n = read();
for (long long i = 1; i < n; i++) {
l = read();
r = read();
w = read();
add(l, r, w);
add(r, l, w);
a[i].l = l;
a[i].r = r;
a[i].w = w;
}
dfs(1, 1);
for (long long i = 1; i <= n; i++) {
b[i] = 1;
c[i] = read();
inc1(id[i], b[i]);
inc2(id[i], c[i]);
}
sort(a + 1, a + n);
root = 1;
x = ask1(cnt);
y = ask2(cnt);
root = 1;
for (long long i = 1; i < n; i++) {
l = a[i].l;
r = a[i].r;
if (!b[l] || !b[r]) continue;
if (dep[l] > dep[r]) swap(l, r);
xx = ask1(id[r] + sum[r] - 1) - ask1(id[r] - 1);
yy = ask2(id[r] + sum[r] - 1) - ask2(id[r] - 1);
xxx = ask1(id[root] + sum[root] - 1);
yyy = ask2(id[root] + sum[root] - 1);
if (xx <= yyy - yy) {
x -= xx;
x -= min(x, yy);
y -= xx;
y -= min(y, xx);
dfs2(r, fa[r]);
} else {
for (int j = 1; j < id[r]; j++) {
inc1(id[i], -b[i]);
inc2(id[i], -c[i]);
b[i] = c[i] = 0;
}
for (int j = id[r] + sum[r]; j <= n; j++) {
inc1(id[i], -b[i]);
inc2(id[i], -c[i]);
b[i] = c[i] = 0;
}
x -= xxx - xx;
x -= min(x, yyy - yy);
y -= yyy - yy;
y -= min(y, xxx - xx);
}
if (!x) {
writeln(a[i].w);
return 0;
}
}
puts("0");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5000 + 7;
const int M = 1007;
const int inf = 1e9 + 7;
const long long linf = 1ll * inf * (inf - 1);
const double pi = acos(-1);
const double eps = 1e-7;
const bool multipleTest = 0;
vector<pair<pair<int, int>, int> > edge;
int r[N], tol[N];
int limit[N];
int n;
int get(int u) { return r[u] < 0 ? u : r[u] = get(r[u]); }
void unite(int u, int v) {
u = ::get(u);
v = ::get(v);
if (r[u] > r[v]) swap(u, v);
r[u] += r[v];
r[v] = u;
limit[u] += limit[v];
tol[u] += tol[v];
}
void solve() {
cin >> n;
if (n == 1) {
puts("0");
return;
}
for (int i = (1); i < (n); i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
edge.push_back(make_pair(make_pair(c, u), v));
}
int sum = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", limit + i);
r[i] = -1;
sum += limit[i];
tol[i] = 1;
}
sort((edge).begin(), (edge).end());
int ans = 0;
if (sum >= n && n > 1) ans = edge[0].first.first;
int last = edge[0].second;
for (int i = 0; i < edge.size(); ++i) {
int u = edge[i].first.second, v = edge[i].second;
int c = edge[i].first.first;
int rr = get(last);
if (sum - limit[rr] >= tol[rr] &&
sum - limit[rr] - tol[rr] + limit[rr] >= n - tol[rr]) {
ans = c;
} else
break;
unite(u, v);
last = v;
}
cout << ans << '\n';
}
void test() {
freopen("in.txt", "w", stdout);
for (int i = 0; i < 50000; ++i) {
printf("%c", ((rand() % 26) + 'a'));
}
cout << '\n' << 100000 << '\n';
for (int i = (0); i < (100000); i++) {
for (int t = (0); t < ((rand() % 4) + 1); t++)
printf("%c", ((rand() % 26) + 'a'));
printf(" ");
for (int t = (0); t < ((rand() % 4) + 1); t++)
printf("%c", ((rand() % 26) + 'a'));
printf("\n");
}
}
int main() {
int Test = 1;
if (multipleTest) {
cin >> Test;
}
for (int i = 0; i < Test; ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
int n;
int x[4000];
int adj[4000];
int aim[8000], next[8000], weight[8000];
int visit[4000];
int sumx[4000];
int count[4000];
int ans;
void dfs(int r, int w, int s) {
visit[r] = 1;
sumx[s] += x[r];
count[s] += 1;
int i = adj[r];
while (i) {
if (weight[i] < w && !visit[aim[i]]) dfs(aim[i], w, s);
i = next[i];
}
}
int check(int w) {
int flex = 0;
for (int i = 0; i < n; ++i) {
visit[i] = 0;
count[i] = 0;
sumx[i] = 0;
}
for (int i = 0; i < n; ++i)
if (!visit[i]) dfs(i, w, i);
for (int i = 0; i < n; ++i) flex += sumx[i] - count[i];
for (int i = 0; i < n; ++i)
if (count[i] > n / 2) {
if (count[i] - flex + sumx[i] - count[i] >
(n - flex + sumx[i] - count[i]) / 2)
return 0;
break;
}
return 1;
}
int main() {
scanf("%d", &n);
int a, b, c;
for (int i = 0; i < n - 1; ++i) {
scanf("%d %d %d", &a, &b, &c);
--a;
--b;
aim[i * 2 + 1] = b;
next[i * 2 + 1] = adj[a];
adj[a] = i * 2 + 1;
aim[i * 2 + 2] = a;
next[i * 2 + 2] = adj[b];
adj[b] = i * 2 + 2;
weight[i * 2 + 1] = weight[i * 2 + 2] = c;
}
for (int i = 0; i < n; ++i) scanf("%d", &x[i]);
int l = 0, r = 10000;
int mid;
while (r - l > 1) {
mid = (l + r) / 2;
if (check(mid))
l = mid;
else
r = mid;
}
if (check(r))
ans = r;
else
ans = l;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long x = 0, f = 1;
for (; ch > '9' || ch < '0'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return x * f;
}
struct bian {
long long u, v, w;
} e[100000 + 10];
inline bool mmp(bian a, bian b) { return a.w < b.w; }
long long fa[100000 + 10], size[100000 + 10], val[100000 + 10], n, sum;
inline long long find(long long x) {
return fa[x] == x ? x : fa[x] = find(fa[x]);
}
signed main() {
n = read();
for (register long long i = 1; i < n; ++i) {
e[i].u = read(), e[i].v = read(), e[i].w = read();
}
for (register long long i = 1; i <= n; ++i) val[i] = read(), sum += val[i];
for (register long long i = 1; i <= n; ++i) fa[i] = i, size[i] = 1;
sort(e + 1, e + n, mmp);
for (register long long i = 1; i < n; ++i) {
long long fx = find(e[i].u), fy = find(e[i].v);
fa[fx] = fy;
size[fy] += size[fx];
val[fy] += val[fx];
if (size[fy] > sum - val[fy]) {
printf("%lld\n", e[i].w);
return 0;
}
}
printf("%lld\n", e[n - 1].w);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
char c = getchar();
int num = 0;
while ('0' > c || c > '9') c = getchar();
while ('0' <= c && c <= '9') num = num * 10 + c - '0', c = getchar();
return (num);
}
struct Edge {
int x, y, w;
} e[3010];
int lm[3010], sz[3010], fa[3010], n, ans;
inline int Get(int x) {
if (fa[x] == x) return (x);
return (fa[x] = Get(fa[x]));
}
inline bool Check() {
int nm = 0;
for (int i = 1; i <= n; i++)
if (Get(i) == i) nm += min(n - sz[i], lm[i]);
return (nm >= n);
}
bool Cmpw(Edge a, Edge b) { return (a.w < b.w); }
int main() {
n = Read();
for (int i = 1; i < n; i++) e[i].x = Read(), e[i].y = Read(), e[i].w = Read();
for (int i = 1; i <= n; i++) lm[i] = Read(), sz[i] = 1, fa[i] = i;
sort(e + 1, e + n, Cmpw);
for (int i = 1, j = 1; i < n; i = j) {
for (; e[i].w == e[j].w; j < n) j++;
for (int k = i; k < j; k++) {
int fx = Get(e[k].x), fy = Get(e[k].y);
sz[fx] += sz[fy], fa[fy] = fx, lm[fx] += lm[fy];
}
ans = e[i].w;
if (!Check()) break;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3005;
int n, x[MAXN];
vector<pair<int, int> > adj[MAXN];
int t, sze, num, sum;
bool vis[MAXN];
void dfs(int cur) {
if (vis[cur]) return;
vis[cur] = 1;
sze++;
num += x[cur];
for (int i = 0; i < adj[cur].size(); i++)
if (adj[cur][i].second < t) dfs(adj[cur][i].first);
}
bool check(int mid) {
t = mid;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++)
if (!vis[i]) {
sze = num = 0;
dfs(i);
if (sze > sum - num) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
adj[a].push_back(pair<int, int>(b, c));
adj[b].push_back(pair<int, int>(a, c));
}
for (int i = 0; i < n; i++) {
cin >> x[i];
sum += x[i];
}
int lo = 0, hi = 10000;
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 double pi = acos(-1);
const int inf = 1000000;
struct edge {
int x, y, k;
} e[3100];
int a[3100], n, tot, L[3100], R[3100], C[3100];
vector<int> E[3100];
struct Flow {
int next[120000], e[120000], c[120000], head[13000], dis[13000], bfs[13000],
len, s, t;
Flow() { len = 1; }
void reset(int source, int sink) {
memset(head, 0, sizeof(head));
s = source;
t = sink;
len = 1;
}
void addedge(int x, int y, int k) {
next[++len] = head[x];
head[x] = len;
e[len] = y;
c[len] = k;
next[++len] = head[y];
head[y] = len;
e[len] = x;
c[len] = 0;
}
bool build() {
int l, r, i, x;
memset(dis, 0, sizeof(dis));
bfs[l = r = 1] = s;
dis[s] = 1;
while (l <= r) {
x = bfs[l];
for (i = head[x]; i; i = next[i])
if (c[i] && !dis[e[i]]) {
dis[e[i]] = dis[x] + 1;
bfs[++r] = e[i];
}
l++;
}
return dis[t] != 0;
}
int dinic(int x, int v) {
int flow = 0;
if (x == t) return v;
for (int i = head[x]; i; i = next[i])
if (c[i] && dis[x] + 1 == dis[e[i]]) {
int ff = dinic(e[i], min(v - flow, c[i]));
c[i] -= ff;
c[i ^ 1] += ff;
flow += ff;
if (flow == v) return flow;
}
dis[x] = -1;
return flow;
}
int maxflow() {
int ans = 0;
while (build()) ans += dinic(s, inf);
return ans;
}
} flow;
void col(int x, int fa, int k) {
int tmp = a[x];
a[x] = k;
for (int i : E[x])
if (i != fa && a[i] == tmp) col(i, x, k);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; ++i) {
int x, y, k;
scanf("%d%d%d", &x, &y, &k);
e[i] = {x, y, k};
E[x].push_back(y);
E[y].push_back(x);
}
for (int i = 1; i <= n; ++i) scanf("%d", &C[i]);
sort(e + 1, e + n, [](edge x, edge y) { return x.k > y.k; });
tot = 1;
for (int i = 1; i <= n; ++i) a[i] = 2;
flow.reset(4 * n + 1, 4 * n + 2);
for (int i = 1; i <= n - 1; ++i) {
int fa = a[e[i].x] / 2, x = ++tot;
assert(a[e[i].x] == a[e[i].y]);
if (!L[fa])
L[fa] = x;
else
R[fa] = x;
flow.addedge(x, fa, inf);
flow.addedge(fa + n, x + n, inf);
col(e[i].x, e[i].y, x * 2);
col(e[i].y, e[i].x, x * 2 + 1);
}
for (int i = 1; i <= n; ++i) {
int fa = a[i] / 2;
if (!L[fa])
L[fa] = 2 * n + i;
else
R[fa] = 2 * n + i;
flow.addedge(2 * n + i, fa, 1);
flow.addedge(fa + n, 3 * n + i, inf);
flow.addedge(4 * n + 1, 2 * n + i, 1);
flow.addedge(3 * n + i, 4 * n + 2, C[i]);
}
int sum = 0;
for (int i = 1; i <= n - 1; ++i) {
int x = L[i + 1], y = R[i + 1];
assert(x > 0);
assert(y > 0);
flow.addedge(x, y + n, inf);
flow.addedge(y, x + n, inf);
sum += flow.maxflow();
if (sum == n) {
printf("%d\n", e[i].k);
return 0;
}
}
printf("0\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ds[3001], sz[3001], ot[3001], a, b, c, no, ans, sum;
vector<pair<int, pair<int, int> > > v;
int get(int x) {
if (ds[x] == x)
return x;
else
return ds[x] = get(ds[x]);
}
void merge(int x, int y) {
sz[x] += sz[y];
ds[y] = x;
ot[x] += ot[y];
if (sz[x] > sum - ot[x]) no = 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; ++i) {
cin >> a >> b >> c;
v.push_back(make_pair(c, make_pair(a, b)));
}
sort(v.begin(), v.end());
for (int i = 1; i <= n; ++i) {
cin >> ot[i];
sz[i] = 1;
ds[i] = i;
sum += ot[i];
}
for (int i = 1; i <= n; ++i)
if (sz[i] > sum - ot[i]) no = 1;
if (!no && n > 1) ans = v[0].first;
for (int i = 0; i < v.size();) {
int j = i;
while (j < v.size() && v[i].first == v[j].first) {
merge(get(v[j].second.first), get(v[j].second.second));
++j;
}
i = j;
if (!no && i < v.size()) ans = v[i].first;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
struct node {
int x, y, v;
} d[5200];
inline bool cmp(node a, node b) { return a.v < b.v; }
int fa[5200], sz[5200], sum[5200], SUM;
inline int getroot(int x) {
if (fa[x] == x) return x;
return fa[x] = getroot(fa[x]);
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> d[i].x >> d[i].y >> d[i].v;
}
for (int i = 1; i <= n; i++) cin >> sum[i], SUM += sum[i];
sort(d + 1, d + n, cmp);
for (int i = 1; i <= n; i++) fa[i] = i, sz[i] = 1;
int last = 0;
for (int i = 1; i < n; i++) {
last = d[i].v;
if (SUM - (sum[getroot(d[i].x)] + sum[getroot(d[i].y)]) <
sz[getroot(d[i].x)] + sz[getroot(d[i].y)]) {
;
break;
} else
sum[getroot(d[i].x)] += sum[getroot(d[i].y)],
sz[getroot(d[i].x)] += sz[getroot(d[i].y)],
fa[getroot(d[i].y)] = fa[getroot(d[i].x)];
}
cout << last << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 77, Mod = 1e9 + 7;
int n, p[N], x[N], A, sum;
int find(int v) { return p[v] < 0 ? v : (p[v] = find(p[v])); }
bool merge(int v, int u) {
v = find(v);
u = find(u);
p[v] += p[u];
x[v] += x[u];
p[u] = v;
return sum - x[v] < -p[v];
}
vector<pair<int, pair<int, int> > > E;
int main() {
fill(p, p + N, -1);
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int v, u, w;
cin >> v >> u >> w;
E.push_back(make_pair(w, make_pair(v, u)));
}
for (int i = 1; i <= n; i++) {
cin >> x[i];
sum += x[i];
}
sort(E.begin(), E.end());
for (auto s : E) {
int u = find(s.second.first), v = find(s.second.second), w = s.first;
A = w;
if (merge(u, v)) break;
}
cout << A;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1.1e6;
int s[N], t[N], w[N], p[N], n, m, a[N], fa[N], sz[N], sum;
int cmp(int x, int y) { return w[x] < w[y]; }
int fd(int x) { return x == fa[x] ? x : fa[x] = fd(fa[x]); }
int main() {
cin >> n;
m = n - 1;
for (int i = 1, x, y, z; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
s[i] = x, t[i] = y, w[i] = z;
p[i] = i;
}
sort(p + 1, p + m + 1, cmp);
int sum = 0;
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), fa[i] = i, sz[i] = 1, sum += a[i];
for (int i = 1, x, y, z; i <= m; i++) {
x = s[p[i]], y = t[p[i]], z = w[p[i]];
if (rand() % 2) swap(x, y);
x = fd(x), y = fd(y);
sz[y] += sz[x];
a[y] += a[x];
fa[x] = y;
if (sz[y] > sum - a[y] || i == m) return cout << z, 0;
}
puts("0");
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0U >> 1;
const long long INF = (long long)1e18;
const double pi = acos(-1.0);
template <class T>
inline T sqr(T a) {
return a * a;
}
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline void read(T &n) {
char c;
for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar())
;
n = c - '0';
for (c = getchar(); c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
}
int pw(int base, int n, int mo) {
if (n == 0) return 1;
if (n == 1) return base;
int tmp = pw(base, n >> 1, mo);
tmp = (long long)tmp * tmp % mo;
if (n & 1) tmp = (long long)tmp * base % mo;
return tmp;
}
const int maxn = 3200;
int N, lim[maxn], f[maxn], x[maxn], y[maxn], w[maxn], sum[maxn], size[maxn], S;
vector<pair<int, int> > E[maxn];
int find(int x) { return (f[x] == x) ? x : (f[x] = find(f[x])); }
int check(int K) {
for (int i = (1); i <= (N); ++i) f[i] = i, size[i] = sum[i] = 0;
for (int i = (1); i <= (N - 1); ++i)
if (w[i] < K) f[find(x[i])] = find(y[i]);
for (int i = (1); i <= (N); ++i) f[i] = find(f[i]);
for (int i = (1); i <= (N); ++i) size[f[i]]++, sum[f[i]] += lim[i];
for (int i = (1); i <= (N); ++i)
if (size[i] > S - sum[i]) return 0;
return 1;
}
int main() {
scanf("%d", &N);
for (int i = (1); i <= (N - 1); ++i) scanf("%d%d%d", &x[i], &y[i], &w[i]);
for (int i = (1); i <= (N); ++i) scanf("%d", &lim[i]), S += lim[i];
int l = 0, r = 20000;
while (l + 1 < r) {
int m = l + r >> 1;
if (check(m))
l = m;
else
r = m;
}
while (!check(l) && l) l--;
while (check(l + 1)) l++;
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
struct nod {
int v, k;
} d[1111111];
struct edg {
int x, y, l;
} e[1111111];
bool operator<(const edg x, const edg y) { return x.l < y.l; }
nod operator+(nod x, nod y) {
x.v += y.v, x.k += y.k;
return x;
}
int n, fa[1111111];
int rt(int x) { return fa[x] ? fa[x] = rt(fa[x]) : x; }
int main() {
scanf("%d", &n);
if (n == 1) return puts("0"), 0;
register int i;
for (i = 1; i < n; i++) scanf("%d%d%d", &e[i].x, &e[i].y, &e[i].l);
std::sort(e + 1, e + n);
int S = 0;
for (i = 1; i <= n; i++) scanf("%d", &d[i].v), d[i].k = 1, S += d[i].v;
for (i = 1; i < n; i++) {
int a = rt(e[i].x), b = rt(e[i].y);
fa[a] = b, d[b] = d[a] + d[b];
if (d[b].k + d[b].v > S) return printf("%d\n", e[i].l), 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct arr {
int x, y, z;
} a[6005];
int n, sum = 0, mx[3005], fa[3005], sz[3005];
inline bool cmp(arr A, arr B) { return A.z < B.z; }
inline int find(int x) { return (fa[x] == x) ? x : fa[x] = find(fa[x]); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) fa[i] = i, sz[i] = 1;
int x, y, z;
for (int i = 1; i < n; i++) scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].z);
for (int i = 1; i <= n; i++) scanf("%d", &mx[i]), sum += mx[i];
sort(a + 1, a + n, cmp);
for (int i = 1; i < n; i++) {
int fx = find(a[i].x);
int fy = find(a[i].y);
if (fx == fy) continue;
fa[fy] = fx;
sz[fx] += sz[fy];
mx[fx] += mx[fy];
if (sz[fx] > sum - mx[fx]) {
printf("%d\n", a[i].z);
return 0;
}
}
printf("%d\n", a[n - 1].z);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 100;
int p[MAXN];
int root(int a) {
if (p[a] < 0) return a;
return p[a] = root(p[a]);
}
void merg(int a, int b) {
a = root(a), b = root(b);
p[a] += p[b];
p[b] = a;
}
int d1[MAXN], d2[MAXN];
bool calc(int n) {
int sum = 0;
for (int i = 0; i < n; i++) sum += d2[i];
if (sum < n) return false;
for (int i = 0; i < n; i++)
if (d1[i] > sum - d2[i]) return false;
return true;
}
int a[MAXN];
vector<pair<pair<int, int>, int>> e;
bool check(int k, int n) {
fill(p, p + n, -1);
for (auto edge : e) {
int x = edge.first.first, y = edge.first.second;
int w = edge.second;
if (w < k) merg(x, y);
}
fill(d2, d2 + n, 0);
for (int i = 0; i < n; i++) {
d1[i] = max(0, -p[i]);
d2[root(i)] += a[i];
}
return calc(n);
}
int32_t main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int x, y, z;
cin >> x >> y >> z;
x--;
y--;
e.push_back({{x, y}, z});
}
for (int i = 0; i < n; i++) cin >> a[i], d2[i] = a[i];
fill(d1, d1 + n, 1);
if (!calc(n)) return cout << "0\n", 0;
int l = 1;
int r = 1e9;
while (r - l > 1) {
int mid = (r + l) / 2;
if (check(mid, n))
l = mid;
else
r = mid;
}
cout << l;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int MAXN = 3e3 + 4;
constexpr int MAXA = 2e3 + 5;
constexpr int MOD = 1e9 + 7;
constexpr long long INF = 1e18;
constexpr int LOG = 40;
int n, a[MAXN], b[MAXN], c[MAXN], x[MAXN], par[MAXN], s[MAXN], mx, idx;
vector<int> vc;
int get_par(int u) { return (par[u] < 0 ? u : par[u] = get_par(par[u])); }
void merge(int u, int v) {
if ((u = get_par(u)) == (v = get_par(v))) {
return;
}
if (par[u] > par[v]) {
swap(u, v);
}
par[u] += par[v];
s[u] += s[v];
par[v] = u;
if (-par[u] > mx) {
mx = -par[u];
idx = u;
}
}
bool Check(int y) {
memset(par, -1, sizeof par);
for (int i = 1; i <= n; i++) {
s[i] = x[i];
}
mx = 1, idx = 1;
for (int i = 1; i <= n; i++) {
if (c[i] < y) {
merge(a[i], b[i]);
}
}
if (mx <= n / 2) {
return true;
}
int sum = 0;
for (int i = 1; i <= n; i++) {
if (par[i] < 0 && i != idx) {
sum += s[i] + par[i];
}
}
int tmp = mx - (n - mx);
if (tmp <= sum) {
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
vc.push_back(c[i]);
}
for (int i = 1; i <= n; i++) {
cin >> x[i];
}
sort(vc.begin(), vc.end());
int l = 0, r = 0;
if (!vc.empty()) {
l = vc[0], r = vc.back() + 1;
}
while (l + 1 < r) {
int mid = (l + r) >> 1;
if (Check(mid)) {
l = mid;
} else {
r = mid;
}
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e3 + 100;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
long long n, dsu[maxn], sz[maxn], t[maxn], a[maxn], mx, s, ans;
pair<long long, pair<long long, long long> > e[maxn];
void init() {
mx = 0;
for (long long i = 1; i <= n; i++) {
dsu[i] = i;
sz[i] = 1;
t[i] = a[i] + sz[i];
mx = max(mx, t[i]);
}
}
long long root(long long v) {
if (dsu[v] == v) return v;
return root(dsu[v]);
}
bool Union(long long v, long long u) {
long long x = root(v), y = root(u);
if (x == y) return 1;
if (sz[x] < sz[y]) swap(x, y);
sz[x] += sz[y];
t[x] += t[y];
mx = max(mx, t[x]);
dsu[y] = x;
return 0;
}
bool isval(long long x) {
init();
for (long long i = 0; i < n - 1; i++) {
if (e[i].first < x) {
Union(e[i].second.first, e[i].second.second);
}
}
return (mx <= s);
}
int main() {
long long v, u, c;
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
cin >> e[i].second.first >> e[i].second.second >> e[i].first;
}
for (long long i = 1; i <= n; i++) {
cin >> a[i];
s += a[i];
}
long long l = 0, r = 2e4, mid;
while (r - l > 1) {
mid = (l + r) / 2;
if (isval(mid))
l = mid;
else
r = mid;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, S;
vector<vector<pair<long long, long long> > > g;
vector<long long> p;
vector<long long> comp;
void dfs(long long v, long long c, long long x) {
comp[v] = c;
for (long long i = 0; i < g[v].size(); i++) {
if (comp[g[v][i].first] == -1 && g[v][i].second < x) {
dfs(g[v][i].first, c, x);
}
}
}
bool check(long long x) {
comp.assign(n, -1);
long long nComp = 0;
for (long long i = 0; i < n; i++) {
if (comp[i] == -1) {
dfs(i, nComp, x);
nComp++;
}
}
vector<long long> sizes(nComp), sums(nComp);
for (long long i = 0; i < n; i++) {
sizes[comp[i]]++;
sums[comp[i]] += p[i];
}
for (long long i = 0; i < nComp; i++) {
if (sizes[i] + sums[i] > S) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n;
g.resize(n);
p.resize(n);
for (long long i = 0; i < n - 1; i++) {
long long a, b, c;
cin >> a >> b >> c;
a--, b--;
g[a].push_back({b, c});
g[b].push_back({a, c});
}
for (long long i = 0; i < n; i++) cin >> p[i], S += p[i];
long long l = 0, r = 1;
while (check(r)) r *= 2;
while (l + 1 <= r) {
long long m = (l + r + 1) / 2;
if (check(m))
l = m;
else
r = m - 1;
}
cout << l << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tot, N, t[3009], mx[3009], L[3009];
bool ok = 1;
pair<int, pair<int, int> > edge[3009];
int tata(int x) {
if (t[x] == x) return x;
return t[x] = tata(t[x]);
}
void unite(int x, int y) {
x = tata(x), y = tata(y);
L[x] += L[y];
mx[x] += mx[y];
if (tot - mx[x] < L[x]) ok = 0;
t[y] = x;
}
int main() {
scanf("%d", &N);
if (N == 1) {
printf("0\n");
return 0;
}
for (int i = 1; i < N; i++)
scanf("%d %d %d", &edge[i].second.first, &edge[i].second.second,
&edge[i].first);
sort(edge + 1, edge + N);
for (int i = 1; i <= N; i++) {
scanf("%d", &mx[i]);
t[i] = i;
L[i] = 1;
tot += mx[i];
}
ok = 1;
int ans = edge[1].first;
for (int i = 1; i < N;) {
int j = i;
while (edge[j].first == edge[i].first && j < N)
unite(edge[j].second.first, edge[j].second.second), j++;
if (ok) ans = edge[j].first;
i = j;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x[5000], sum, fa[5000], size[5000];
struct node {
int to, u, w;
} edge[5000];
bool cmp(node a, node b) { return a.w < b.w; }
int find(int x) {
while (x != fa[x]) x = fa[x] = fa[fa[x]];
return x;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) fa[i] = i, size[i] = 1;
for (int i = 1; i < n; i++)
scanf("%d %d %d", &edge[i].u, &edge[i].to, &edge[i].w);
sort(edge + 1, edge + 1 + n, cmp);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]), sum += x[i];
for (int i = 1; i <= n; i++) {
int fx = find(edge[i].u);
int fy = find(edge[i].to);
if (fx == fy) continue;
fa[fy] = fx;
size[fx] += size[fy];
x[fx] += x[fy];
if (size[fx] > sum - x[fx]) {
printf("%d\n", edge[i].w);
return 0;
}
}
printf("%d\n", edge[n - 1].w);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1, 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;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
inline void write_p(long long x) {
write(x);
putchar(' ');
}
const int N = 200005;
int n, xx[N], sz[N], Fa[N], vis[N], cnt, poi[N], nxt[N], head[N], top;
struct node {
int x, y, v;
} e[N];
inline bool cmp(node x, node y) { return x.v < y.v; }
pair<int, int> q[N];
inline void add(int x, int y) {
poi[++cnt] = y;
nxt[cnt] = head[x];
head[x] = cnt;
poi[++cnt] = x;
nxt[cnt] = head[y];
head[y] = cnt;
}
inline pair<int, int> Dfs(int x, int fa) {
vis[x] = 1;
pair<int, int> tmp = make_pair(1, xx[x]);
for (int i = head[x]; i; i = nxt[i]) {
if (poi[i] == fa) continue;
pair<int, int> las = Dfs(poi[i], x);
tmp.first += las.first;
tmp.second += las.second;
}
return tmp;
}
inline bool check(int line) {
for (int i = 1; i <= n; ++i) head[i] = 0;
cnt = 0;
for (int i = 1; i <= n - 1; ++i)
if (e[i].v < line)
add(e[i].x, e[i].y);
else
break;
for (int i = 1; i <= n; ++i) vis[i] = 0;
top = 0;
int sum = 0;
for (int i = 1; i <= n; ++i)
if (!vis[i]) q[++top] = Dfs(i, i), sum += (q[top].second);
pair<int, int> tmp = make_pair(0, 0);
for (int i = 1; i <= n; ++i)
if (q[i] > tmp) tmp = q[i];
if (tmp.first > sum - tmp.second)
return 0;
else
return 1;
}
int main() {
n = read();
for (int i = 1; i <= n - 1; ++i)
e[i].x = read(), e[i].y = read(), e[i].v = read();
for (int i = 1; i <= n; ++i) xx[i] = read();
sort(e + 1, e + n, cmp);
int l = 1, r = 1e9, ans = 0;
while (l <= r) {
int mid = l + r >> 1;
if (check(mid))
ans = mid, l = mid + 1;
else
r = mid - 1;
}
writeln(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline string tostr(const T& x) {
stringstream ss;
ss << x;
return ss.str();
}
inline long long parse(const string& s) {
stringstream ss(s);
long long x;
ss >> x;
return x;
}
const double EPS = 1e-9;
const int INF = 1000 * 1000 * 1000;
const char CINF = 102;
const long long LINF = INF * 1ll * INF;
const double DINF = 1e200;
const double PI = 3.1415926535897932384626433832795l;
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long p, long long m) {
long long r = 1;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
vector<vector<pair<int, int> > > gr;
vector<char> was;
vector<long long> W;
pair<int, long long> dfs(int v, int e0) {
if (was[v]) return make_pair(0, 0);
was[v] = true;
pair<int, long long> r(1, W[v]);
for (int i = 0; i < (((int)(gr[v]).size())); ++i) {
if (gr[v][i].second >= e0) continue;
int p = gr[v][i].first;
auto t = dfs(p, e0);
r.first += t.first;
r.second += t.second;
}
return r;
}
bool check(int e0) {
was.assign(((int)(gr).size()), 0);
vector<pair<int, long long> > A;
long long s = 0;
for (int i = 0; i < (((int)(gr).size())); ++i) {
if (!was[i]) {
A.push_back(dfs(i, e0));
s += A.back().second;
}
}
for (int i = 0; i < (((int)(A).size())); ++i) {
if (A[i].first > s - A[i].second) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
gr.resize(n);
vector<int> es;
for (int i = 0; i < (n - 1); ++i) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
gr[a].push_back(make_pair(b, c));
gr[b].push_back(make_pair(a, c));
es.push_back(c);
}
W.resize(n);
for (int i = 0; i < (n); ++i) {
cin >> W[i];
}
sort((es).begin(), (es).end());
es.erase(unique((es).begin(), (es).end()), es.end());
int a = 0, b = ((int)(es).size());
while (b > a + 1) {
int c = (a + b) / 2;
if (check(es[c]))
a = c;
else
b = c;
}
cout << (((int)(es).size()) ? es[a] : 0);
return 0;
}
|
#include <bits/stdc++.h>
const int inf = (1ll << 31) - 1;
using namespace std;
int n;
int a[3300];
vector<pair<int, int> > v[3300];
int p[3300], sz[3300], sum[3300];
int aa = 0;
int cnt = 1;
void dfs(int x, int y, int num) {
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i].first;
if (to == y) continue;
if (p[to] == p[x]) dfs(to, x, num);
}
p[x] = num;
sum[num] += a[x];
sz[num]++;
}
vector<pair<int, pair<int, int> > > ans;
bool check() {
for (int i = 0; i < cnt; i++) {
if (sz[i] > aa - sum[i]) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) {
int x, y, c;
cin >> x >> y >> c;
x--;
y--;
v[x].push_back(make_pair(y, c));
v[y].push_back(make_pair(x, c));
ans.push_back(make_pair(c, make_pair(x, y)));
}
for (int i = 0; i < n; i++) {
cin >> a[i];
aa += a[i];
}
sort(ans.begin(), ans.end());
reverse(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
sz[p[ans[i].second.second]] = 0;
sum[p[ans[i].second.second]] = 0;
dfs(ans[i].second.second, ans[i].second.first, p[ans[i].second.second]);
dfs(ans[i].second.first, ans[i].second.second, cnt);
cnt++;
if (check()) {
cout << ans[i].first << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 12010, inf = int(1e9), V = 100010, E = 500010;
int n, n0, i, j, k, l, r, p, x, y, z, L, X[N], o[N];
struct FlowG {
int S, T, N, edge, e[E], b[E], c[E], fir[V], last[V], vh[V], h[V], cur[V],
pre[V];
void clear() {
edge = 1;
memset(fir, 0, sizeof(fir));
}
void add2(int x, int y, int z) {
e[++edge] = y;
c[edge] = z;
b[edge] = fir[x];
fir[x] = edge;
}
void add(int x, int y, int z) {
add2(x, y, z);
add2(y, x, 0);
}
int sap() {
int i, k, p, flow, minh, ans = 0;
memset(h, 0, sizeof(h));
memset(vh, 0, sizeof(vh));
vh[0] = N;
memcpy(cur, fir, sizeof(fir));
memset(pre, 0, sizeof(pre));
pre[S] = S;
for (i = S; h[S] < N;) {
if (i == T) {
flow = inf;
for (p = S; p != T; p = e[cur[p]]) flow = min(flow, c[cur[p]]);
ans += flow;
for (p = S; p != T; p = e[cur[p]])
c[cur[p]] -= flow, c[cur[p] ^ 1] += flow;
i = S;
}
for (k = cur[i]; k; k = b[k])
if (c[k] && h[e[k]] + 1 == h[i]) {
cur[i] = k;
pre[e[k]] = i;
i = e[k];
break;
}
if (!k) {
if (--vh[h[i]] == 0) break;
cur[i] = fir[i];
minh = N;
for (k = cur[i]; k; k = b[k])
if (c[k]) minh = min(minh, h[e[k]] + 1);
++vh[h[i] = minh];
i = pre[i];
}
}
return ans;
}
} F;
struct graph {
int edge, fir[N], e[N], b[N], w[N];
bool done[N];
int fa[N], fae[N], sz[N], ms[N], st[N], st1[N], st2[N];
void clear() {
edge = 1;
memset(fir, 0, sizeof(fir));
}
void add2(int x, int y, int z) {
e[++edge] = y;
w[edge] = z;
b[edge] = fir[x];
fir[x] = edge;
}
void add(int x, int y, int z) {
add2(x, y, z);
add2(y, x, z);
}
int dfs(int i, int f, int ma) {
st[++st[0]] = i;
fa[i] = f;
sz[i] = 1;
ms[i] = ma;
for (int k = fir[i]; k; k = b[k])
if (!done[k] && e[k] != f)
fae[e[k]] = k, sz[i] += dfs(e[k], i, max(ma, w[k]));
return sz[i];
}
void fadd() {
int t1 = ++F.N;
for (int p = (1); p <= (st1[0]); p++) F.add(st1[p], t1, inf);
for (int p = (1); p <= (st2[0]); p++)
if (ms[st2[p]] >= L) F.add(t1, n + st2[p], inf);
int t2 = ++F.N;
for (int p = (1); p <= (st1[0]); p++)
if (ms[st1[p]] >= L) F.add(st1[p], t2, inf);
for (int p = (1); p <= (st2[0]); p++) F.add(t2, n + st2[p], inf);
}
void fun(int r) {
st[0] = 0;
int sz0 = dfs(r, 0, 0), best = N, A, B, O, p;
if (sz0 <= 1) return;
for (p = 2; p <= st[0]; p++) {
int i = st[p], tt;
if ((tt = max(sz0 - sz[i], sz[i])) < best)
best = tt, A = i, B = fa[i], O = fae[i];
}
done[O] = done[O ^ 1] = 1;
st[0] = 0;
dfs(A, 0, w[O]);
for (i = 0; i <= st[0]; i++) st1[i] = st[i];
st[0] = 0;
dfs(B, 0, w[O]);
for (i = 0; i <= st[0]; i++) st2[i] = st[i];
fadd();
for (i = 0; i <= sz0; i++) swap(st1[i], st2[i]);
fadd();
fun(A);
fun(B);
}
bool ok() {
F.clear();
F.S = 2 * n + 1;
F.N = F.T = 2 * n + 2;
for (int i = (1); i <= (n0); i++) F.add(F.S, i, 1);
for (int i = (1); i <= (n0); i++) F.add(n + i, F.T, X[i]);
memset(done, 0, sizeof(done));
fun(1);
return F.sap() == n0;
}
} H;
struct ori {
vector<int> e[N], ew[N];
int li[N], lw[N];
void adde(int x, int y, int z) {
e[x].push_back(y);
ew[x].push_back(z);
}
void work(int x, int y, int f) {
if (x == y) {
H.add(f, li[x], lw[x]);
return;
}
int nod = ++n;
H.add(f, nod, 0);
work(x, (x + y) / 2, nod);
work((x + y) / 2 + 1, y, nod);
}
void bui(int i, int f) {
li[0] = 0;
for (int k = 0; k < e[i].size(); k++)
if (e[i][k] != f) li[++li[0]] = e[i][k], lw[li[0]] = ew[i][k];
if (li[0]) work(1, li[0], i);
for (int k = 0; k < e[i].size(); k++)
if (e[i][k] != f) bui(e[i][k], i);
}
} G;
int main() {
scanf("%d", &n);
n0 = n;
for (i = 1; i <= n - 1; i++)
scanf("%d%d%d", &x, &y, &z), G.adde(x, y, z), G.adde(y, x, z), o[i] = z;
for (i = 1; i <= n; i++) scanf("%d", &X[i]);
sort(o + 1, o + 1 + (n - 1));
o[0] = 1;
for (i = 2; i <= n - 1; i++)
if (o[i] != o[i - 1]) o[++o[0]] = o[i];
H.clear();
G.bui(1, 0);
for (l = 1, r = o[0]; l < r;) {
int mid = (l + r + 1) / 2;
L = o[mid];
if (H.ok())
l = mid;
else
r = mid - 1;
}
printf("%d\n", o[l]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, w = 0;
char c = getchar();
while (!isdigit(c)) w |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return w ? -x : x;
}
namespace star {
const int maxn = 1e5 + 10;
int n, m;
int ecnt, head[maxn], nxt[maxn << 1], to[maxn << 1], v[maxn], mid;
inline void addedge(int a, int b, int c) {
to[++ecnt] = b, nxt[ecnt] = head[a], head[a] = ecnt;
v[ecnt] = c;
to[++ecnt] = a, nxt[ecnt] = head[b], head[b] = ecnt;
v[ecnt] = c;
}
int siz[maxn], fsiz[maxn];
long long sum[maxn], fsum[maxn];
void dfs(int x, int f) {
siz[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
int u = to[i];
if (u == f) continue;
dfs(u, x);
siz[x] += siz[u];
sum[x] += sum[u];
}
}
bool ok;
void dfs1(int x, int top, int fa) {
for (int i = head[x]; i; i = nxt[i]) {
int u = to[i];
if (u == fa) continue;
if (v[i] >= mid)
dfs1(u, u, x), fsiz[top] -= siz[u], fsum[top] += sum[u];
else
dfs1(u, top, x);
}
if (x == top) {
if ((sum[1] - sum[x]) + fsum[x] < 1LL * fsiz[x]) ok = 0;
}
}
inline bool check() {
ok = 1;
memcpy(fsiz, siz, sizeof fsiz);
memset(fsum, 0, sizeof fsum);
dfs1(1, 1, 1);
return ok;
}
inline void work() {
n = read();
int l = 0, r = 0, ans = 0;
for (int a, b, c, i = 1; i < n; i++)
a = read(), b = read(), c = read(), r = max(r, c), addedge(a, b, c);
for (int i = 1; i <= n; i++) sum[i] = read();
dfs(1, 1);
while (l <= r) {
mid = l + r >> 1;
if (check())
ans = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d", ans);
}
} // namespace star
signed main() {
star::work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3010;
struct node {
int x, y, z;
} e[N];
bool cmp(node x, node y) { return x.z < y.z; }
int x[N], fa[N], siz[N], siz2[N];
int fid(int x) {
if (x == fa[x]) return x;
return fa[x] = fid(fa[x]);
}
int read() {
int x = 0, f = 1;
char c = 0;
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - 48;
return x * f;
}
int main() {
int n = read(), sum = 0;
for (int i = 1; i < n; i++) e[i] = (node){read(), read(), read()};
for (int i = 1; i <= n; i++) {
x[i] = read();
fa[i] = i, siz[i] = 1;
siz2[i] = x[i];
sum += x[i];
}
sort(e + 1, e + n, cmp);
for (int i = 1; i < n; i++) {
int x = e[i].x, y = e[i].y;
int fx = fid(x), fy = fid(y);
if (fx == fy) continue;
if (siz[fx] > siz[fy]) swap(fx, fy);
fa[fx] = fy;
siz[fy] += siz[fx];
siz2[fy] += siz2[fx];
if (sum - siz2[fy] < siz[fy]) {
cout << e[i].z << "\n";
return 0;
}
}
cout << e[n - 1].z << "\n";
return 0;
}
|
#include <bits/stdc++.h>
const int N = 100010;
using namespace std;
int n, head[N], k = 0, w[N], kp[N];
long long size[N], sum = 0;
struct M {
int to, next, val;
} edge[N * 2];
void build(int x, int y, int z) {
edge[++k].next = head[x];
edge[k].to = y;
edge[k].val = z;
head[x] = k;
}
void find(int x, int f) {
size[x] = w[x];
kp[x] = 1;
for (int i = head[x]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == f) continue;
find(v, x);
size[x] += size[v];
kp[x] += kp[v];
}
}
void dfs(int x, int f, int lp) {
for (int i = head[x]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == f) continue;
if (edge[i].val >= lp) {
if (size[v] <= kp[1] - kp[v]) {
sum += size[v] + kp[v];
continue;
} else
sum += size[1] - size[v] + (kp[1] - kp[v]), dfs(v, x, lp);
} else
dfs(v, x, lp);
}
}
bool check(int lp) {
sum = 0;
dfs(1, 1, lp);
return sum >= n;
}
int main() {
int x, y, z, l = 1e9, r = 0, ans = 0;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &x, &y, &z);
build(x, y, z), build(y, x, z);
l = min(l, z), r = max(r, z);
}
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
find(1, 1);
while (l <= r) {
int mid = (l + r) / 2;
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 long long MOD = 1e9 + 7;
const long long MAXN = 2e4 + 30;
const long long MINN = 1e3 + 20;
const long long MOD2 = 998244353ll;
const long long INF = 74592896151251;
const long double EPS = 1e-9;
long long GCD(long long a, long long b) { return (b ? GCD(b, a % b) : a); }
long long POW(long long a, long long b) {
return (!b ? 1 : POW(a, b / 2) * POW(a, b / 2) * (b % 2 ? a : 1));
}
long long X[MAXN], Par[MAXN], SZ[MAXN], n, Sum;
struct Edge {
long long u, v, w;
} E[MAXN];
inline void input() {
cin >> n;
for (int i = 0; i < n - 1; i++) cin >> E[i].u >> E[i].v >> E[i].w;
for (int i = 1; i <= n; i++) cin >> X[i], Sum += X[i];
}
inline long long Find(long long v) {
if (v == Par[v]) return v;
return (Par[v] = Find(Par[v]));
}
inline void Union(long long u, long long v) {
v = Find(v);
u = Find(u);
if (u == v) return;
Par[v] = u;
SZ[u] += SZ[v];
X[u] += X[v];
}
bool CMP(Edge x, Edge y) { return (x.w < y.w); }
inline void Pre_Process() {
for (int i = 1; i <= n; i++) Par[i] = i, SZ[i] = 1;
}
inline int Main() {
input();
Pre_Process();
sort(E, E + n - 1, CMP);
for (int i = 0; i < n - 1; i++) {
E[i].v = Find(E[i].v);
E[i].u = Find(E[i].u);
Union(E[i].u, E[i].v);
if (SZ[E[i].u] > Sum - X[E[i].u]) return cout << E[i].w, 0;
}
cout << 0;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int q;
q = 1;
while (q--) Main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pa[5009], siz[5009], occ[5009], tots = 0;
bool yay;
vector<pair<int, pair<int, int> > > edges;
int finder(int node) {
if (pa[node] != node) {
return pa[node] = finder(pa[node]);
}
return node;
}
void uniter(int x, int y) {
x = finder(x);
y = finder(y);
if (x == y) {
return;
}
pa[y] = x;
siz[x] += siz[y];
occ[x] += occ[y];
if (tots - occ[x] < siz[x]) {
yay = false;
}
return;
}
int main() {
int i, j, t1, t2, t3, t4, n, ans = 0;
scanf("%d", &n);
for (i = 0; i < n - 1; i++) {
scanf("%d %d %d", &t1, &t2, &t3);
edges.push_back(make_pair(t3, make_pair(t1, t2)));
}
sort(edges.begin(), edges.end());
for (i = 1; i <= n; i++) {
pa[i] = i;
siz[i] = 1;
scanf("%d", &occ[i]);
tots += occ[i];
}
if (n == 1) {
printf("0\n");
return 0;
}
ans = edges[0].first;
yay = true;
for (i = 0; i < n - 1;) {
j = i;
while (edges[i].first == edges[j].first && j < n - 1) {
uniter(edges[j].second.first, edges[j].second.second);
j++;
}
if (yay && j < n - 1) {
ans = edges[j].first;
}
i = j;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e4 + 10, N = 3100;
vector<pair<pair<int, int>, int> > ed;
int n, par[N], sz[N], sig[N], x[N];
int root(int v) {
if (par[v] == -1) return v;
return par[v] = root(par[v]);
}
void merge(int u, int v) {
u = root(u), v = root(v);
if (u == v) return;
par[u] = v;
}
bool check(int val) {
memset(par, -1, sizeof par);
memset(sz, 0, sizeof sz);
memset(sig, 0, sizeof sig);
for (int i = 0; i < n - 1; i++) {
int v = ed[i].first.first, u = ed[i].first.second, w = ed[i].second;
if (w < val) merge(u, v);
}
for (int i = 1; i <= n; i++) {
sz[root(i)]++;
sig[root(i)] += x[i];
}
int SIG = 0;
for (int i = 1; i <= n; i++) {
if (par[i] == -1) SIG += sig[i];
}
for (int i = 1; i <= n; i++) {
if (sz[root(i)] > SIG - sig[root(i)]) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b, c;
cin >> a >> b >> c;
ed.push_back({{a, b}, c});
}
for (int i = 1; i <= n; i++) cin >> x[i];
int lo = 0, hi = M;
while (hi - lo > 1) {
int mid = (lo + hi) / 2;
if (check(mid))
lo = mid;
else
hi = mid;
}
cout << lo << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 1;
struct YLS {
int a, b, w;
};
vector<YLS> srt;
bool cmp(const YLS &a, const YLS &b) { return (a.w < b.w); }
int pr[N], sz[N], x[N], n, m, a, b, w, ans, sm;
int find(int a) { return (!pr[a] ? a : find(pr[a])); }
int main() {
YLS yls;
scanf("%d", &n);
for (int i = 1; i < n; i++)
scanf("%d%d%d", &yls.a, &yls.b, &yls.w), srt.push_back(yls);
sort(srt.begin(), srt.end(), cmp);
for (int i = 1; i <= n; i++) scanf("%d", x + i), sz[i] = 1, sm += x[i];
for (auto y : srt) {
a = find(y.a), b = find(y.b);
pr[b] = a, sz[a] += sz[b], x[a] += x[b], ans = y.w;
if (sm - x[a] < sz[a]) return !printf("%d", ans);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T &x, U y) {
if (x < y) x = y;
}
struct UnionFind {
vector<int> data;
void init(int n) { data.assign(n, -1); }
bool unionSet(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
};
struct MaximumFlow {
static const int InfCapacity = 0x3f3f3f3f;
struct Edge {
int to;
int capacity;
int rev;
};
vector<vector<Edge> > g;
void init(int n) { g.assign(n, vector<Edge>()); }
void add(int i, int j, int capacity) {
Edge e, f;
e.to = j, f.to = i;
e.capacity = capacity, f.capacity = 0;
g[i].push_back(e);
g[j].push_back(f);
g[i].back().rev = (int)g[j].size() - 1;
g[j].back().rev = (int)g[i].size() - 1;
}
void addB(int i, int j, int capacity) {
Edge e, f;
e.to = j, f.to = i;
e.capacity = capacity, f.capacity = capacity;
g[i].push_back(e);
g[j].push_back(f);
g[i].back().rev = (int)g[j].size() - 1;
g[j].back().rev = (int)g[i].size() - 1;
}
int maximumFlow(int s, int t) {
int n = g.size();
vector<int> level(n);
int total = 0;
bool update;
do {
update = false;
fill(level.begin(), level.end(), -1);
level[s] = 0;
queue<int> q;
q.push(s);
for (int d = n; !q.empty() && level[q.front()] < d;) {
int u = q.front();
q.pop();
if (u == t) d = level[u];
for (typeof((g[u]).begin()) e = ((g[u]).begin()); e != (g[u]).end();
++e)
if (e->capacity > 0 && level[e->to] == -1)
q.push(e->to), level[e->to] = level[u] + 1;
}
vector<int> iter(n);
for (int i = 0; i < n; i++) iter[i] = (int)g[i].size() - 1;
while (1) {
int f = augment(level, iter, s, t, InfCapacity);
if (f == 0) break;
total += f;
update = true;
}
} while (update);
return total;
}
int augment(vector<int> &level, vector<int> &iter, int u, int t, int f) {
if (u == t || f == 0) return f;
int lv = level[u];
if (lv == -1) return 0;
level[u] = -1;
for (; iter[u] >= 0; --iter[u]) {
Edge &e = g[u][iter[u]];
if (level[e.to] <= lv) continue;
int l = augment(level, iter, e.to, t, min(f, e.capacity));
if (l == 0) continue;
e.capacity -= l;
g[e.to][e.rev].capacity += l;
level[u] = lv;
return l;
}
return 0;
}
};
int main() {
int n;
scanf("%d", &n);
vector<pair<pair<int, int>, int> > edges;
for (int(i) = 0; (i) < (int)(n - 1); ++(i)) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c), a--, b--;
edges.push_back(make_pair((make_pair((a), (b))), (c)));
}
vector<int> x(n);
for (int(i) = 0; (i) < (int)(n); ++(i)) scanf("%d", &x[i]);
int l = 0, u = 10000;
while (u - l > 0) {
int mid = (l + u + 1) / 2;
UnionFind uf;
uf.init(n);
for (int(i) = 0; (i) < (int)(n - 1); ++(i))
if (edges[i].second < mid)
uf.unionSet(edges[i].first.first, edges[i].first.second);
vector<vector<int> > components(n);
for (int(i) = 0; (i) < (int)(n); ++(i)) components[uf.root(i)].push_back(i);
vector<int> componentList;
for (int(i) = 0; (i) < (int)(n); ++(i))
if (!components[i].empty()) componentList.push_back(i);
int C = componentList.size();
int B = max(1, (int)pow(C, .5)), Buckets = (C + B - 1) / B;
int s = C + Buckets + C, t = s + 1;
MaximumFlow mf;
mf.init(t + 1);
for (int(i) = 0; (i) < (int)(C); ++(i)) {
int cs = components[componentList[i]].size();
mf.add(s, i, cs);
for (int(j) = 0; (j) < (int)(Buckets); ++(j)) {
int L = j * B, R = min(C, (j + 1) * B);
if (i < L || R <= i) {
mf.add(i, C + j, cs);
} else {
for (int(k) = (int)(L); (k) < (int)(R); ++(k))
if (i != k) mf.add(i, C + Buckets + k, cs);
}
}
}
for (int(j) = 0; (j) < (int)(Buckets); ++(j)) {
int L = j * B, R = min(C, (j + 1) * B);
for (int(k) = (int)(L); (k) < (int)(R); ++(k))
mf.add(C + j, C + Buckets + k, 0x3f3f3f3f);
}
for (int(i) = 0; (i) < (int)(C); ++(i)) {
int cap = 0;
for (typeof((components[componentList[i]]).begin()) j =
((components[componentList[i]]).begin());
j != (components[componentList[i]]).end(); ++j)
cap += x[*j];
mf.add(C + Buckets + i, t, cap);
}
int f = mf.maximumFlow(s, t);
if (f == n)
l = mid;
else
u = mid - 1;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int sz[50005], f[50005], b[50005];
int sum;
pair<int, pair<int, int> > a[5005];
bool isOk;
int n;
int find_set(int x) {
if (f[x] == x) return x;
f[x] = find_set(f[x]);
return f[x];
}
void unite(int x, int y) {
x = find_set(x);
y = find_set(y);
if (x == y) return;
f[x] = y;
b[y] += b[x];
sz[y] += sz[x];
if (sz[y] > sum - b[y]) isOk = false;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d%d", &a[i].second.first, &a[i].second.second, &a[i].first);
a[i].second.first--;
a[i].second.second--;
}
sort(a, a + n - 1);
for (int i = 0; i < n; ++i) {
scanf("%d", &b[i]);
sum += b[i];
sz[i] = 1;
}
for (int i = 0; i < n; ++i) f[i] = i;
isOk = true;
int ans = a[0].first;
for (int i = 0; i < n; ++i) {
if (sz[i] > sum - b[i]) isOk = false;
}
for (int i = 0; i < n - 1;) {
int j = i;
while (j < n - 1 && a[i].first == a[j].first) {
unite(a[j].second.first, a[j].second.second);
j++;
}
if (!isOk) break;
if (a[j].first != 0)
ans = a[j].first;
else
ans = a[j - 1].first;
i = j;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
const int N = 3005;
int siz[N], fa[N], a[N], sum, Flag = 1;
struct Edge {
int u, v, w;
} e[10005];
bool operator<(const Edge &A, const Edge &B) { return A.w < B.w; }
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void Merge(int x, int y) {
x = find(x), y = find(y);
siz[x] += siz[y];
fa[y] = x;
a[x] += a[y];
if (siz[x] > sum - a[x]) Flag = 0;
}
int main() {
int n = read();
for (int i = 1; i < n; ++i) e[i].u = read(), e[i].v = read(), e[i].w = read();
sort(e + 1, e + n);
for (int i = 1; i <= n; ++i)
a[i] = read(), sum += a[i], fa[i] = i, siz[i] = 1;
int ans = 0;
for (int i = 1; i < n; ++i) {
if (Flag) ans = e[i].w;
Merge(e[i].u, e[i].v);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
struct st {
int a;
int b;
int c;
};
vector<st> v;
bool cmp(st a, st b) { return a.c < b.c; }
vector<int> vv;
int belong[3002];
int siz[3002];
int sizz[3002];
inline int root(int b) {
if (belong[b] == -1) return b;
belong[b] = root(belong[b]);
return belong[b];
}
void merge(int a, int b) {
a = root(a);
b = root(b);
if (a == b) return;
belong[a] = b;
siz[b] += siz[a];
sizz[b] += sizz[a];
}
int cap[3002];
bool ok(int val) {
for (int i = 0; i < 3002; i++) belong[i] = -1, siz[i] = 1, sizz[i] = cap[i];
for (int i = 0; i < v.size(); i++) {
if (v[i].c >= val) {
break;
}
merge(v[i].a, v[i].b);
}
vector<int> V;
vector<int> S;
int cap_sum = 0;
for (int i = 0; i < n; i++) {
if (i == root(i)) {
V.push_back(siz[i]);
S.push_back(sizz[i]);
cap_sum += sizz[i];
}
}
for (int i = 0; i < V.size(); i++) {
int op = cap_sum - S[i];
if (V[i] > op) {
return false;
}
}
return true;
}
int main() {
cin >> n;
if (n == 1) {
puts("0");
return 0;
}
for (int i = 1; i < n; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
v.push_back({a, b, c});
vv.push_back(c);
}
for (int i = 0; i < n; i++) scanf("%d", &cap[i]);
sort(v.begin(), v.end(), cmp);
sort(vv.begin(), vv.end());
int mint = 0;
int maxt = vv.size() - 1;
while (mint + 1 < maxt) {
int mid = (mint + maxt) >> 1;
if (ok(vv[mid])) {
mint = mid;
} else {
maxt = mid - 1;
}
}
if (ok(vv[maxt])) {
cout << vv[maxt] << endl;
} else {
cout << vv[mint] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3005;
int n, val[MAXN], tot = 0;
int par[MAXN], sz[MAXN];
pair<int, pair<int, int> > edge[MAXN];
int find(int x) { return x == par[x] ? x : par[x] = find(par[x]); }
void join(int x, int y) { par[find(x)] = find(y); }
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> edge[i].second.first >> edge[i].second.second >> edge[i].first;
edge[i].second.first--, edge[i].second.second--;
}
for (int i = 0; i < n; i++) {
cin >> val[i];
tot += val[i];
par[i] = i;
sz[i] = 1;
}
sort(edge, edge + n - 1);
for (int i = 0; i < n - 1; i++) {
int a = edge[i].second.first, b = edge[i].second.second;
if (find(a) == find(b)) continue;
sz[find(b)] += sz[find(a)];
val[find(b)] += val[find(a)];
join(a, b);
if (sz[find(a)] + val[find(a)] > tot) {
cout << edge[i].first << '\n';
return 0;
}
}
cout << "0\n";
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct N {
int have, need;
} N;
typedef struct E {
int a, b, len;
} E;
typedef struct G {
int par, rnk, have, need;
} G;
int n;
N node[3000];
E edge[2999];
G grp[3000];
int p[2999];
bool elencmp(const int &a, const int &b) { return edge[a].len < edge[b].len; }
int find(int a) {
if (grp[a].par == a) return a;
return grp[a].par = find(grp[a].par);
}
void run() {
scanf("%d", &n);
for (int i = (0); i < (n - 1); ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
--a, --b;
edge[i].a = a;
edge[i].b = b;
edge[i].len = c;
}
for (int i = (0); i < (n); ++i) node[i].need = 1, scanf("%d", &node[i].have);
for (int i = (0); i < (n - 1); ++i) p[i] = i;
sort(p, p + n - 1, elencmp);
for (int i = (0); i < (n); ++i)
grp[i].par = i, grp[i].rnk = 0, grp[i].have = node[i].have,
grp[i].need = node[i].need;
int sumhave = 0;
for (int i = (0); i < (n); ++i) sumhave += node[i].have;
int ret = 0;
for (int i = (0); i < (n - 1); ++i) {
ret = edge[p[i]].len;
int a = find(edge[p[i]].a), b = find(edge[p[i]].b);
if (a != b) {
if (grp[a].need + grp[b].need > sumhave - grp[a].have - grp[b].have)
break;
if (grp[a].rnk < grp[b].rnk) swap(a, b);
grp[a].have += grp[b].have, grp[a].need += grp[b].need,
grp[b].par = a, grp[a].rnk += grp[a].rnk == grp[b].rnk ? 1 : 0;
}
}
printf("%d\n", ret);
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3000 + 1;
struct Edge {
int u, v, w;
} e[maxn];
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, sum;
int a[maxn], pre[maxn], sz[maxn];
bool cmp(Edge a, Edge b) { return a.w < b.w; }
int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }
int main() {
n = read();
for (int i = 1; i < n; i++) {
e[i].u = read();
e[i].v = read();
e[i].w = read();
}
sort(e + 1, e + n, cmp);
for (int i = 1; i <= n; i++) {
a[i] = read();
pre[i] = i;
sz[i] = 1;
sum += a[i];
}
for (int i = 1; i < n; i++) {
int u = find(e[i].u), v = find(e[i].v);
pre[u] = v;
sz[v] += sz[u];
a[v] += a[u];
if (sz[v] > sum - a[v]) {
printf("%d\n", e[i].w);
return 0;
}
}
puts("0");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
const int inf = 1e9;
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + c - '0';
x *= f;
}
int n;
int fa[N], siz[N], val[N];
int sum;
struct misaka {
int x, y, w;
bool operator<(const misaka &cmp) const { return w < cmp.w; }
} e[N];
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
int main() {
read(n);
for (int i = 1; i <= n - 1; i++) read(e[i].x), read(e[i].y), read(e[i].w);
for (int i = 1; i <= n; i++)
fa[i] = i, siz[i] = 1, read(val[i]), sum += val[i];
sort(e + 1, e + n);
for (int i = 1; i <= n - 1; i++) {
int x = e[i].x, y = e[i].y;
int fx = find(x), fy = find(y);
siz[fx] += siz[fy], val[fx] += val[fy];
fa[fy] = fx;
if (siz[fx] > sum - val[fx]) return printf("%d\n", e[i].w), 0;
}
printf("%d\n", e[n - 1].w);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct counting_iterator : public iterator<random_access_iterator_tag, bool> {
T value = 0;
counting_iterator(const T &value) : value(value) {}
counting_iterator(const counting_iterator &it) : value(it.value) {}
counting_iterator() {}
typename iterator_traits<counting_iterator>::difference_type operator-(
const counting_iterator &it) const {
return value - it.value;
}
counting_iterator &operator++() { return *this += 1; }
counting_iterator &operator--() { return *this += -1; }
counting_iterator &operator+=(
typename iterator_traits<counting_iterator>::difference_type n) {
value += n;
return *this;
}
bool operator!=(const counting_iterator &it) const {
return value != it.value;
}
T &operator*() { return value; }
};
template <typename T>
using cnt_it = counting_iterator<T>;
template <class T>
struct graph {
struct edge {
int from, to;
T cost;
};
int n;
vector<edge> edges;
vector<vector<int>> adj;
function<bool(int)> ignore;
graph(int n) : n(n), adj(n) {}
int link(int u, int v, T w = 1) {
int id = (int)edges.size();
adj[u].push_back(id), adj[v].push_back(id), edges.push_back({u, v, w});
return id;
}
int orient(int u, int v, T w = 1) {
int id = (int)edges.size();
adj[u].push_back(id), edges.push_back({u, v, w});
return id;
}
graph transposed() const {
graph res(n);
for (auto &e : edges) res.orient(e.to, e.from, e.cost);
res.ignore = ignore;
return res;
}
int degree(int u) { return (int)adj[u].size(); }
};
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(ios::badbit | ios::failbit);
int n;
cin >> n;
graph<int> g(n);
vector<int> lim(n);
for (auto i = 0; i < n - 1; ++i) {
int u, v, w;
cin >> u >> v >> w, --u, --v;
g.link(u, v, w);
}
for (auto u = 0; u < n; ++u) {
cin >> lim[u];
}
int tot = accumulate(lim.begin(), lim.end(), 0);
auto good = [&](int th) {
42;
vector<int> vis(n);
int lsum, cnt;
function<void(int)> dfs = [&](int u) {
vis[u] = true;
lsum += lim[u];
++cnt;
for (auto id : g.adj[u]) {
auto &e = g.edges[id];
if (e.cost < th) {
int v = u ^ e.from ^ e.to;
if (!vis[v]) {
dfs(v);
}
}
}
};
for (auto u = 0; u < n; ++u) {
if (!vis[u]) {
lsum = 0, cnt = 0;
dfs(u);
42;
if (cnt > tot - lsum) {
return false;
}
}
}
return true;
};
cout << max(*partition_point(cnt_it<int>(0), cnt_it<int>(20000), good) - 1, 0)
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("O8")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long int N = 3e3 + 20, mod = 1e9 + 7, inf = 2e9, maxq = 1e5 + 30;
const long double eps = 0.0000001;
long long int poww(long long int a, long long int b) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % mod, b / 2) % mod
: poww(a * a % mod, b / 2) % mod));
}
pair<int, pair<long long int, long long int> > edge[N];
vector<int> adj[N];
int ans[N];
vector<pair<long long int, long long int> > comp[N];
int par[N], cnt[N], t[N];
int getpar(int v) {
if (par[v] == v) return v;
return par[v] = getpar(par[v]);
}
void merge(int u, int v, int w) {
u = getpar(u);
v = getpar(v);
sort(comp[u].begin(), comp[u].end());
sort(comp[v].begin(), comp[v].end());
if (comp[u].size() < comp[v].size()) swap(u, v);
long long int p = 0;
int sz = comp[u].size();
for (pair<long long int, long long int> vert : comp[v]) {
t[vert.second] = 0;
while (p < sz && t[vert.second] < cnt[vert.second]) {
t[vert.second]++;
t[ans[comp[u][p].second]]--;
comp[u][p].first = w;
ans[comp[u][p].second] = vert.second;
p++;
}
}
p = 0;
sz = comp[v].size();
for (pair<long long int, long long int> vert : comp[u]) {
while (p < sz && t[vert.second] < cnt[vert.second]) {
t[vert.second]++;
t[ans[comp[v][p].second]]--;
comp[v][p].first = w;
ans[comp[v][p].second] = vert.second;
p++;
}
if (p == sz) break;
}
while (!(comp[v].empty())) {
pair<long long int, long long int> vert = comp[v].back();
comp[v].pop_back();
comp[u].push_back(vert);
}
par[v] = u;
return;
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int v, u, w;
cin >> v >> u >> w;
if (v > u) swap(v, u);
edge[i] = {w, {v, u}};
adj[v].push_back(u);
adj[u].push_back(v);
comp[i + 1].push_back({0, i + 1});
par[i + 1] = i + 1;
}
comp[n].push_back({0, n});
par[n] = n;
for (int i = 1; i < n + 1; i++) cin >> cnt[i];
sort(edge, edge + n - 1);
for (int i = 0; i < n - 1; i++) {
merge(edge[i].second.first, edge[i].second.second, edge[i].first);
getpar(1);
}
long long int out = inf;
for (int i = 1; i < n + 1; i++) {
if (!(comp[i].empty())) {
for (pair<long long int, long long int> v : comp[i])
out = min(out, v.first);
}
}
cout << out;
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const long long maxn = 1e5 + 500;
const long long mod = 1e9 + 7;
const long long inf = 1e9 + 500;
vector<pair<long long, long long> > ger[maxn];
long long x[maxn];
long long n;
long long par[maxn];
long long summ = 0;
long long sa[maxn];
long long sb[maxn];
long long find_par(long long a) {
if (par[a] == a) {
return a;
}
par[a] = find_par(par[a]);
return par[a];
}
void merg(long long a, long long b) {
a = find_par(a);
b = find_par(b);
par[a] = b;
}
bool good(long long m) {
for (long long i = 0; i < n; i++) {
par[i] = i;
sa[i] = 0;
sb[i] = 0;
}
for (long long i = 0; i < n; i++) {
for (auto e : ger[i]) {
if (e.second < m) {
merg(i, e.first);
}
}
}
for (long long i = 0; i < n; i++) {
sa[find_par(i)]++;
sb[find_par(i)] += x[i];
}
for (long long i = 0; i < n; i++) {
if (sa[i] > 0) {
if (summ - sb[i] < sa[i]) {
return 0;
}
}
}
return 1;
}
int main() {
cin >> n;
for (long long i = 1; i < n; i++) {
long long v, u, w;
cin >> v >> u >> w;
v--;
u--;
ger[u].push_back(make_pair(v, w));
ger[v].push_back(make_pair(u, w));
}
for (long long i = 0; i < n; i++) {
cin >> x[i];
summ += x[i];
}
long long b = 0;
long long e = 100000;
while (e - b > 1) {
long long mid = (e + b) / 2;
if (good(mid)) {
b = mid;
} else {
e = mid;
}
}
cout << b;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000;
bool mark[MAXN];
int m[MAXN], ind, t[MAXN], ans, r, n, a[MAXN], sum, f[MAXN];
unsigned int l;
vector<int> G[MAXN], W[MAXN], v1;
void dfs(int v, int k) {
mark[v] = true;
m[v] = ind;
t[ind]++;
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
if (!mark[u] && W[v][i] <= k) dfs(u, k);
}
}
bool check(int k) {
memset(mark, false, sizeof mark);
ind = 0;
for (int i = 1; i <= n; i++)
if (!mark[i]) {
t[ind] = 0;
f[ind] = 0;
dfs(i, k);
ind++;
}
ans = 0;
for (int i = 1; i <= n; i++) f[m[i]] += a[i];
for (int i = 0; i < ind; i++)
if (sum - f[i] < t[i]) return false;
for (int i = 1; i <= n; i++) ans += max(0, min(a[i], n - t[m[i]]));
if (ans >= n) return true;
return false;
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int v, u, w;
cin >> v >> u >> w;
v1.push_back(w);
G[v].push_back(u);
G[u].push_back(v);
W[v].push_back(w);
W[u].push_back(w);
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
sort(v1.begin(), v1.end());
r = v1.size() - 1;
while (l < r) {
int mid = (l + r + 1) / 2;
if (check(v1[mid]))
l = mid;
else
r = mid - 1;
}
if (l + 1 >= v1.size())
cout << v1.back() << endl;
else
cout << v1[l + 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
struct Edge {
long long v, w, to;
} e[100005 * 2];
struct Node {
long long l, r, w;
inline bool operator<(const Node& x) const { return w > x.w; }
} a[100005];
long long n, l, r, w, x, y, xx, yy, xxx, yyy, cnt, size, root, b[100005],
c[100005], f[100005], g[100005], id[100005], fa[100005], dep[100005],
num[100005], sum[100005], head[100005];
inline void add(long long u, long long v, long long w) {
e[++size].v = v;
e[size].to = head[u];
e[size].w = w;
head[u] = size;
}
inline void inc1(long long x, long long k) {
while (x <= n) {
f[x] += k;
x += x & (-x);
}
return;
}
inline void inc2(long long x, long long k) {
while (x <= n) {
g[x] += k;
x += x & (-x);
}
return;
}
inline long long ask1(long long x) {
long long ans = 0;
while (x) {
ans += f[x];
x -= x & (-x);
}
return ans;
}
inline long long ask2(long long x) {
long long ans = 0;
while (x) {
ans += g[x];
x -= x & (-x);
}
return ans;
}
inline void dfs(long long u, long long last) {
id[u] = ++cnt;
num[cnt] = u;
fa[u] = last;
dep[u] = dep[last] + 1;
sum[u] = 1;
for (long long i = head[u]; i; i = e[i].to) {
long long v = e[i].v;
if (v == last) continue;
dfs(v, u);
sum[u] += sum[v];
}
return;
}
inline void dfs2(long long u, long long last) {
inc1(id[u], -b[u]);
inc2(id[u], -c[u]);
b[u] = c[u] = 0;
for (long long i = head[u]; i; i = e[i].to) {
long long v = e[i].v;
if (v == last) continue;
dfs2(v, u);
}
return;
}
int main() {
n = read();
for (long long i = 1; i < n; i++) {
l = read();
r = read();
w = read();
add(l, r, w);
add(r, l, w);
a[i].l = l;
a[i].r = r;
a[i].w = w;
}
dfs(1, 1);
for (long long i = 1; i <= n; i++) {
b[i] = 1;
c[i] = read();
inc1(id[i], b[i]);
inc2(id[i], c[i]);
}
sort(a + 1, a + n);
root = 1;
x = ask1(cnt);
y = ask2(cnt);
root = 1;
for (long long i = 1; i < n; i++) {
l = a[i].l;
r = a[i].r;
if (!b[l] || !b[r]) continue;
if (dep[l] > dep[r]) swap(l, r);
xx = ask1(id[r] + sum[r] - 1) - ask1(id[r] - 1);
yy = ask2(id[r] + sum[r] - 1) - ask2(id[r] - 1);
xxx = ask1(id[root] + sum[root] - 1);
yyy = ask2(id[root] + sum[root] - 1);
if (xx <= yyy - yy) {
x -= xx;
x -= min(x, yy);
y -= xx;
y -= min(y, xx);
dfs2(r, fa[r]);
} else {
for (int j = 1; j < id[r]; j++) {
inc1(id[i], -b[i]);
inc2(id[i], -c[i]);
b[i] = c[i] = 0;
}
for (int j = id[r] + sum[r]; j <= n; j++) {
inc1(id[i], -b[i]);
inc2(id[i], -c[i]);
b[i] = c[i] = 0;
}
x -= xxx - xx;
x -= min(x, yyy - yy);
y -= yyy - yy;
y -= min(y, xxx - xx);
}
if (!x) {
writeln(a[i].w);
return 0;
}
}
puts("0");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ans, total;
int app[3005], ata[3005], sz[3005];
pair<int, pair<int, int> > edge[3005];
int bul(int node) {
if (ata[node] == node) return node;
return ata[node] = bul(ata[node]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++)
scanf("%d %d %d", &edge[i].second.first, &edge[i].second.second,
&edge[i].first);
for (int i = 1; i <= n; i++) {
scanf("%d", &app[i]);
total += app[i];
ata[i] = i;
sz[i] = 1;
}
sort(edge + 1, edge + n);
for (int i = 1; i < n; i++) {
int a = bul(edge[i].second.first);
int b = bul(edge[i].second.second);
ata[a] = b;
sz[b] += sz[a];
app[b] += app[a];
if (sz[b] > total - app[b]) {
ans = edge[i].first;
break;
}
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[3030], b[3030], c[3030], sz[3030], x[3030];
int root[3030], uu[3030];
int find(int v) {
if (root[v] == v) return v;
return root[v] = find(root[v]);
}
int main() {
int n;
cin >> n;
int tot = 0;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", uu + i);
tot += uu[i];
}
int st = 0, ed = 100000;
while (ed - st > 1) {
int mid = (ed + st) / 2;
for (int i = 1; i <= n; i++) root[i] = i, sz[i] = 1, x[i] = uu[i];
int f = 0;
for (int i = 0; i < n - 1; i++) {
if (c[i] >= mid) continue;
int u = find(a[i]), v = find(b[i]);
if (u == v) continue;
sz[u] += sz[v];
root[v] = u;
x[u] += x[v];
}
for (int i = 1; i <= n; i++) {
if (find(i) == i and tot - x[i] < sz[i]) f = 1;
}
if (f)
ed = mid;
else
st = mid;
}
printf("%d", st);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <class A, class B>
ostream& operator<<(ostream& out, const pair<A, B>& a) {
return out << "(" << a.first << ", " << a.second << ")";
}
template <class A>
ostream& operator<<(ostream& out, const vector<A>& a) {
out << "[";
for (auto it = a.begin(); it != a.end(); ++it) {
if (it != a.begin()) out << ", ";
out << *it;
}
return out << "]";
}
mt19937 rnd(time(NULL));
mt19937_64 rnd64(time(NULL));
const int INF = 1e9;
const long long INF64 = 1e18;
const int MOD = 1e9 + 7;
const long double PI = acosl(-1.0);
const long double EPS = 1e-9;
const int N = 6000 + 7;
int n;
vector<pair<int, int> > g[N];
int a[N];
bool read() {
if (scanf("%d", &n) != 1) return false;
for (int i = 0; i < int(n); ++i) g[i].clear();
for (int i = 0; i < int(n - 1); ++i) {
int v, u, w;
scanf("%d%d%d", &v, &u, &w);
--v, --u;
g[v].push_back(make_pair(u, w));
g[u].push_back(make_pair(v, w));
}
for (int i = 0; i < int(n); ++i) {
scanf("%d", &a[i]);
}
return true;
}
int cnt;
int s, t;
short dist[N][N];
short cap[N][N], flow[N][N];
void init(int v, int p, int mx, short dist[N]) {
dist[v] = mx;
for (auto it : g[v]) {
int u = it.first;
int w = it.second;
if (u == p) continue;
init(u, v, max(mx, w), dist);
}
}
void build() {
s = 2 * n;
t = s + 1;
cnt = t + 1;
for (int i = 0; i < int(n); ++i) {
dist[i][i] = 0;
init(i, -1, 0, dist[i]);
}
for (int i = 0; i < int(n); ++i) {
cap[s][i] = 1;
cap[i + n][t] = a[i];
}
}
inline int rem(int v, int u) { return cap[v][u] - flow[v][u]; }
int d[N];
int lst[N];
int bfs() {
for (int i = 0; i < int(cnt); ++i) d[i] = INF;
d[s] = 0;
queue<int> q;
q.push(s);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int u = 0; u < int(cnt); ++u) {
if (rem(v, u) && d[u] == INF) {
d[u] = d[v] + 1;
if (u == t) return true;
q.push(u);
}
}
}
return d[t] != INF;
}
int dfs(int v, int f) {
if (v == t) return f;
if (f == 0) return 0;
int result = 0;
for (; lst[v] < cnt; ++lst[v]) {
int u = lst[v];
if (v >= n && v != t && u == n) lst[v] = u = t;
if (v == s && u == n) break;
if (v == u) continue;
if (d[u] != d[v] + 1) continue;
int add = dfs(u, min(f, rem(v, u)));
result += add;
f -= add;
flow[v][u] += add;
flow[u][v] -= add;
if (f == 0) break;
}
return result;
}
int dinic() {
int flow = 0;
while (true) {
if (!bfs()) break;
for (int v = 0; v < int(n); ++v) lst[v] = n;
for (int v = 0; v < int(n); ++v) lst[v + n] = 0;
lst[s] = 0;
lst[t] = n;
int add;
while ((add = dfs(s, INF)) > 0) flow += add;
}
return flow;
}
void solve() {
build();
vector<int> vals;
for (int i = 0; i < int(n); ++i)
for (auto it : g[i]) vals.push_back(it.second);
sort((vals).begin(), (vals).end());
vals.resize(unique((vals).begin(), (vals).end()) - vals.begin());
int l = 0, r = int((vals).size()) - 1;
int res = 0;
while (l <= r) {
int m = (l + r) / 2;
memset(flow, 0, sizeof(flow));
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(i); ++j)
cap[i][n + j] = cap[j][n + i] = (dist[i][j] >= vals[m]);
int f = 0;
while (true) {
int add = dinic();
if (add == 0) break;
f += add;
}
if (f == n) {
res = vals[m];
l = m + 1;
} else {
r = m - 1;
}
}
printf("%d\n", res);
}
int main() {
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
if (read()) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int x[3000];
int a[3000], b[3000], l[3000], cid[3000];
bool cmp(int i, int j) { return l[i] < l[j]; }
int fid[3000], sz[3000];
long long xsz[3000];
int imx;
void init() {
for (int i = 0; i < N; i++) fid[i] = i, sz[i] = 1, xsz[i] = x[i];
}
int find(int i) {
if (fid[i] == i) return i;
fid[i] = find(fid[i]);
return fid[i];
}
void join(int i, int j) {
i = find(i), j = find(j);
if (sz[i] <= sz[j]) {
fid[i] = j;
sz[j] += sz[i];
xsz[j] += xsz[i];
if (sz[j] > sz[imx]) imx = j;
} else {
fid[j] = i;
sz[i] += sz[j];
xsz[i] += xsz[j];
if (sz[i] > sz[imx]) imx = i;
}
}
int main() {
cin >> N;
for (int i = 0; i < N - 1; i++) {
cin >> a[i] >> b[i] >> l[i];
a[i]--, b[i]--;
cid[i] = i;
}
long long tot = 0;
for (int i = 0; i < N; i++) {
cin >> x[i];
tot += x[i];
}
sort(cid, cid + N - 1, cmp);
init();
for (int i = 0; i < N - 1; i++) {
join(a[cid[i]], b[cid[i]]);
if (sz[imx] + xsz[imx] > tot) {
cout << l[cid[i]] << '\n';
return 0;
}
}
cout << 0 << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, 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 T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
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 printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
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;
}
const int E = 3333;
int sub[E];
int u[E], v[E], w[E], root[E], first[E], sz[E], sum;
int find_root(int u) {
if (root[u] == u) return u;
return root[u] = find_root(root[u]);
}
void solve_A() {
int n;
gn(n);
for (int i = 1; i < n; i++) gn(u[i], v[i], w[i]);
for (int i = 1; i <= n; i++) {
gn(first[i]);
sum += first[i];
}
int st = 0, ed = 10001;
while (st + 1 < ed) {
int md = st + ed >> 1, flag = 1;
for (int i = 1; i <= n; i++) root[i] = i, sz[i] = 1, sub[i] = first[i];
for (int i = 1; i < n; i++)
if (w[i] < md) {
int uu = find_root(u[i]), vv = find_root(v[i]);
if (uu == vv) continue;
sz[uu] += sz[vv];
root[vv] = uu;
sub[uu] += sub[vv];
}
for (int i = 1; i <= n; i++)
if (find_root(i) == i && sum < sub[i] + sz[i]) {
flag = 0;
break;
}
if (flag)
st = md;
else
ed = md;
}
print(st);
}
int main() {
solve_A();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF64 = ((long long)1E18);
const int INF = 1E9 + 7;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
out << "(" << pair.first << ", " << pair.second << ")";
return out;
}
int dost[3004], n;
vector<pair<int, int> > t[3004];
vector<int> weights;
bool done[3004];
int a, b, W;
void go(int act, int papa) {
done[act] = 1;
a += 1;
b += dost[act];
for (__typeof((t[act]).begin()) it = ((t[act]).begin()); it != (t[act]).end();
++it)
if (it->second < W && it->first != papa) {
go(it->first, act);
}
}
bool comp(const pair<int, int>& l, const pair<int, int>& r) {
return l.first - l.second > r.first - r.second;
}
bool moge(int w) {
W = w;
memset((done), 0, sizeof(done));
vector<pair<int, int> > todo;
for (int i = (1); i <= (n); ++i)
if (!done[i]) {
a = b = 0;
go(i, -1);
todo.push_back(make_pair(a, b));
}
sort((todo).begin(), (todo).end(), comp);
{
if (0)
cerr << "W"
<< " = " << W << endl;
};
{
if (0) {
cerr << "todo"
<< " = ";
for (__typeof(((todo)).begin()) it = (((todo)).begin());
it != ((todo)).end(); ++it)
cerr << *it << ", ";
cout << endl;
}
};
int trzeba = 0;
int mamy = 0;
int allsum = 0;
for (__typeof((todo).begin()) it = ((todo).begin()); it != (todo).end(); ++it)
allsum += it->second;
for (__typeof((todo).begin()) it = ((todo).begin()); it != (todo).end();
++it) {
if (it->first > allsum - it->second) return 0;
}
return 1;
return trzeba <= 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = (1); i <= (n - 1); ++i) {
int a, b, c;
cin >> a >> b >> c;
weights.push_back(c);
t[a].push_back(make_pair(b, c));
t[b].push_back(make_pair(a, c));
}
for (int i = (1); i <= (n); ++i) cin >> dost[i];
sort((weights).begin(), (weights).end());
int best = 0, s = 0, e = ((int)(weights).size()) - 1;
while (s <= e) {
int q = (s + e) / 2;
if (moge(weights[q])) {
best = weights[q];
s = q + 1;
} else
e = q - 1;
}
cout << best << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAXN = (int)3007;
const int infint = (int)1e9;
const long long inf = (long long)1e18;
const int bound = 10007;
int n, x[MAXN], par[MAXN], sz[MAXN], bip[MAXN];
struct edge {
int u, v, w;
edge(int a, int b, int c) { u = a, v = b, w = c; }
};
vector<edge> e;
bool cmp(edge E1, edge E2) { return E1.w < E2.w; }
int get(int v) { return par[v] < 0 ? v : par[v] = get(par[v]); }
void merge(int u, int v) {
if ((u = get(u)) == (v = get(v))) return;
if (par[u] > par[v]) swap(u, v);
par[u] += par[v];
par[v] = u;
}
bool hall() {
int sm = 0;
for (int i = 1; i <= n; i++) sm += bip[i];
if (sm < n) return 0;
for (int i = 1; i <= n; i++)
if (sz[i] > sm - bip[i]) return 0;
return 1;
}
bool check(int mid) {
memset(par, -1, sizeof par);
for (auto E : e)
if (E.w < mid)
merge(E.u, E.v);
else
break;
memset(sz, 0, sizeof sz);
memset(bip, 0, sizeof bip);
for (int i = 1; i <= n; i++) sz[get(i)]++, bip[get(i)] += x[i];
return hall();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v, w;
cin >> u >> v >> w;
edge nw(u, v, w);
e.push_back(nw);
}
sort(e.begin(), e.end(), cmp);
for (int i = 1; i <= n; i++) cin >> x[i];
int L = 0, R = bound;
while (R - L > 1) {
int mid = (L + R) >> 1;
if (check(mid))
L = mid;
else
R = mid;
}
cout << L;
}
|
#include <bits/stdc++.h>
const int MAXN = 3010;
struct _ {
int b, e, v;
bool operator<(const _& b) const { return v < b.v; }
} es[MAXN];
int fa[MAXN], sz[MAXN], xs[MAXN], n;
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
int main() {
std::cin >> n;
for (int i = 1; i < n; ++i) std::cin >> es[i].b >> es[i].e >> es[i].v;
std::sort(es + 1, es + n);
int tox = 0;
for (int i = 1; i <= n; ++i)
std::cin >> xs[i], sz[fa[i] = i] = 1, tox += xs[i];
int ans = es[1].v;
for (int i = 1; i < n; ++i) {
int x = find(es[i].b), y = find(es[i].e);
sz[y] += sz[x], xs[y] += xs[x];
fa[x] = y;
if ((tox - xs[y]) < sz[y]) break;
ans = es[i + 1].v;
}
std::cout << ans << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1e9 + 7;
const int N = 3005, M = 1e5 + 10, NM1 = N - 1;
long long int OO = 1e18 + 8;
int oo = 1e9 + 8;
void readFile() {}
struct DSU {
vector<int> par, sz;
DSU(int n) {
par.resize(n), sz.resize(n), iota(par.begin(), par.end(), 0),
fill(sz.begin(), sz.end(), 1);
}
int leader(int u) { return (par[u] == u) ? u : par[u] = leader(par[u]); }
bool join(int u, int v) {
int p1 = leader(u), p2 = leader(v);
if (p1 == p2) return false;
par[p2] = p1;
sz[p1] += sz[p2];
return true;
}
} dsu(1);
int n, m, u, v, x[N], edgeFrom[N], edgeTo[N], edgeCost[N], sorted[N];
int main() {
readFile();
scanf("%d", &n);
dsu = DSU(n + 1);
if (n == 1) return puts("0"), 0;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d%d", edgeFrom + i, edgeTo + i, edgeCost + i);
sorted[i] = i;
}
sort(sorted, sorted + n - 1,
[](int a, int b) { return edgeCost[a] < edgeCost[b]; });
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", x + i);
sum += x[i];
}
for (int i = 0; i < n - 1; i++) {
int idx = sorted[i];
u = dsu.leader(edgeFrom[idx]), v = dsu.leader(edgeTo[idx]);
dsu.join(u, v);
x[u] += x[v];
if (dsu.sz[dsu.leader(u)] > sum - x[u])
return printf("%d\n", edgeCost[idx]), 0;
}
printf("%d\n", edgeCost[sorted[n - 2]]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct st {
int sz, cp, pr;
} data[1 << 15];
int n;
int a, b, c, sm, ans;
vector<pair<int, pair<int, int>>> E(1);
int P(int x) {
if (data[x].pr == x) return x;
return data[x].pr = P(data[x].pr);
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
scanf("%d%d%d", &a, &b, &c);
E.push_back({c, {a, b}});
}
sort(E.begin(), E.end());
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
sm += a;
data[i].pr = i;
data[i].cp = a;
data[i].sz = 1;
}
for (int i = 1; i <= n - 1; i++) {
a = P(E[i].second.first);
b = P(E[i].second.second);
data[b].pr = a;
data[a].sz += data[b].sz;
data[a].cp += data[b].cp;
ans = i;
if (data[a].sz > sm - data[a].cp) break;
}
printf("%d", E[ans].first);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n;
struct Edge2 {
int from, to, dist, id;
inline bool operator<(const Edge2& other) const {
return this->dist > other.dist;
}
} E[maxn];
struct Edge {
int to, nxt, dist;
bool flag;
} e[maxn << 1];
int first[maxn];
inline void add_edge(Edge2& ee) {
static int cnt = 0;
ee.id = ++cnt;
e[cnt].nxt = first[ee.from];
e[cnt].flag = false;
first[ee.from] = cnt;
e[cnt].to = ee.to;
e[cnt].dist = ee.dist;
e[++cnt].nxt = first[ee.to];
e[cnt].flag = false;
first[ee.to] = cnt;
e[cnt].to = ee.from;
e[cnt].dist = ee.dist;
}
int siz[maxn];
int xx[maxn];
long long sum_all;
long long sumx[maxn];
bool fff[maxn];
inline bool dfs(int now, int fa) {
sumx[now] = xx[now];
siz[now] = 1;
for (int i = first[now]; i; i = e[i].nxt) {
int to = e[i].to;
if (to != fa) {
if (e[i].flag) fff[to] = true;
if (!dfs(to, now)) {
return false;
}
if (!e[i].flag) {
siz[now] += siz[to];
sumx[now] += sumx[to];
}
}
}
if (fff[now]) {
if (sum_all - sumx[now] - max(n - siz[now] - sumx[now], 0LL) <
(long long)siz[now])
return false;
else
return true;
} else
return true;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d%d%d", &E[i].from, &E[i].to, &E[i].dist);
add_edge(E[i]);
}
sort(E + 1, E + n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &xx[i]);
sum_all += xx[i];
}
int l = 1, r = n - 1;
while (l < r) {
memset(fff, 0, sizeof(fff));
fff[1] = true;
int mid = (l + r) >> 1;
for (int i = 1; i < n; ++i)
e[E[i].id].flag = e[E[i].id + 1].flag = (i <= mid);
if (dfs(1, 0))
r = mid;
else
l = mid + 1;
}
printf("%d", E[r].dist);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
int n, X[maxn];
struct st {
int a, b, c;
} e[maxn];
bool cmp(st a, st b) { return a.c < b.c; }
int size[maxn], M[maxn], sum, fa[maxn];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
bool check(int limit) {
for (int i = 1; i <= n; i++) fa[i] = i, size[i] = 1, M[i] = X[i];
for (int i = 1; i < n && e[i].c < limit; i++) {
int f1 = find(e[i].a), f2 = find(e[i].b);
if (f1 == f2) continue;
fa[f1] = f2;
M[f2] += M[f1];
size[f2] += size[f1];
}
for (int i = 1; i <= n; i++) {
int f = find(i);
if (size[f] > sum - M[f]) return 0;
}
return 1;
}
int main() {
scanf("%d", &n);
int mx = 0;
for (int i = 1; i < n; i++)
scanf("%d%d%d", &e[i].a, &e[i].b, &e[i].c), mx = max(mx, e[i].c);
for (int i = 1; i <= n; i++) scanf("%d", &X[i]), sum += X[i];
int l = 0, r = mx, ans = 0;
sort(e + 1, e + n, cmp);
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid))
l = mid + 1, ans = mid;
else
r = mid - 1;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int p[10000];
int x[10000];
int y[10000];
int w[10000];
vector<pair<int, pair<int, int> > > v;
int gp(int x) {
if (p[x] == x) return x;
return p[x] = gp(p[x]);
}
int can(int h) {
for (int i = 0; i < n; i++) {
p[i] = i;
x[i] = 1;
y[i] = w[i];
}
for (int i = 0; i < h; i++) {
int a = gp(v[i].second.first);
int b = gp(v[i].second.second);
if (a != b) {
p[a] = b;
x[b] += x[a];
y[b] += y[a];
}
}
int sx = 0, sy = 0;
vector<pair<int, int> > u;
for (int i = 0; i < n; i++)
if (p[i] == i) {
u.push_back(make_pair(x[i], y[i]));
sx += x[i];
sy += y[i];
}
for (int i = 0; i < ((int)(u).size()); i++)
if (u[i].first > sy - u[i].second) return 0;
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i + 1 < n; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
v.push_back(make_pair(c, make_pair(a, b)));
}
for (int i = 0; i < n; i++) scanf("%d", &w[i]);
sort((v).begin(), (v).end());
int l = 0, r = n;
while (r - l > 1) {
int s = (l + r) / 2;
if (can(s))
l = s;
else
r = s;
}
if (l == n - 1)
printf("0\n");
else
printf("%d\n", v[l].first);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void setIO(string NAME) {}
inline long long gI() {
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
long long flag = 1, p = 0;
if (c == '-') flag = -1, c = getchar();
while (c >= '0' && c <= '9') p = p * 10 + (c - '0'), c = getchar();
return p * flag;
}
int gs(char* C) {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
int l = 0;
while (c != ' ' && c != '\n' && c != EOF) C[l++] = c, c = getchar();
C[l] = 0;
return l;
}
template <class T>
void debug(const T a, const int& n) {
for (int i = 0; i < n; ++i) printf("%d%c", a[i], (i == n - 1) ? '\n' : ' ');
}
const int inf = ~0U >> 1, maxn = 3000 + 10;
int n, sum = 0;
int f[maxn], c[maxn], s[maxn];
bool flag = 1;
struct Edge {
int x, y, c;
friend bool operator<(const Edge& A, const Edge& B) { return A.c < B.c; }
} E[maxn];
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
void merge(int x, int y) {
x = find(x), y = find(y);
c[x] += c[y];
s[x] += s[y];
f[y] = x;
if (s[x] > sum - c[x]) flag = 0;
}
int main() {
setIO("test");
n = gI();
for (int i = 0; i < n - 1; ++i) {
E[i].x = gI(), E[i].y = gI(), E[i].c = gI();
}
for (int i = 1; i <= n; ++i) {
f[i] = i;
s[i] = 1, c[i] = gI();
sum += c[i];
}
sort(E, E + n - 1);
int ans = E[0].c;
for (int i = 0; i < n - 1;) {
int j;
for (j = i; j < n - 1; ++j) {
merge(E[j].x, E[j].y);
if (E[j].c != E[j + 1].c) break;
}
if (!flag) break;
ans = max(ans, E[j + 1].c), i = j + 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int read() {
register int x = 0;
register char f = 1, ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 0;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ '0');
return f ? x : -x;
}
int n, fa[100005], sz[100005], ans;
long long a[100005], sum;
struct node {
int u, v, w;
bool operator<(const node &res) const { return w < res.w; }
} e[100005];
int find(int x) { return fa[x] == x ? x : (fa[x] = find(fa[x])); }
int merge(int x, int y) {
int fx = find(x), fy = find(y);
fa[fy] = fx, sz[fx] += sz[fy], a[fx] += a[fy];
return sz[fx] <= sum - a[fx];
}
int main() {
n = read();
for (register int i = 1; i < n; ++i) e[i] = (node){read(), read(), read()};
for (register int i = 1; i <= n; ++i)
sum += a[i] = read(), fa[i] = i, sz[i] = 1;
std ::sort(e + 1, e + n);
for (register int i = 1; i < n; ++i)
if (ans = e[i].w, !merge(e[i].u, e[i].v)) break;
printf("%d", ans);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.