text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = acos(-1);
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T abs(T x) {
return x < 0 ? -x : x;
}
const int MAXN = 10 * 1000;
int n, sum_x;
pair<int, pair<int, int> > edg[MAXN];
int x[MAXN], color[MAXN], num[MAXN], sum[MAXN];
bool check(int w) {
for (int i = 0; i < n; ++i) {
color[i] = i;
}
for (int i = 0; i < n - 1 && edg[i].first < w; ++i) {
int v1 = edg[i].second.first;
int v2 = edg[i].second.second;
if (color[v1] != color[v2]) {
int c1 = color[v1];
for (int i = 0; i < n; ++i) {
if (color[i] == c1) {
color[i] = color[v2];
}
}
}
}
for (int i = 0; i < n; ++i) {
num[i] = 0;
sum[i] = 0;
}
for (int i = 0; i < n; ++i) {
num[color[i]]++;
sum[color[i]] += x[i];
}
for (int i = 0; i < n; ++i) {
if (num[i] > sum_x - sum[i]) {
return false;
}
}
return true;
}
int main() {
cin >> n;
int max_w = 0;
for (int i = 0; i < n - 1; ++i) {
scanf("%d %d %d", &edg[i].second.first, &edg[i].second.second,
&edg[i].first);
edg[i].second.first--;
edg[i].second.second--;
max_w = max(max_w, edg[i].first);
}
sum_x = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &x[i]);
sum_x += x[i];
}
sort(edg, edg + n - 1);
int l = 0;
int r = max_w;
while (l < r) {
int m = (l + r + 1) / 2;
if (check(m)) {
l = m;
} else {
r = m - 1;
}
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int N = 3100;
struct edge {
int a, b, c;
};
bool operator<(const edge& l, const edge& r) {
if (l.c != r.c) return l.c < r.c;
if (l.a != r.a) return l.a < r.a;
return l.b < r.b;
}
int n, cap[N];
edge e[N];
int prnt[N], rnk[N], nd[N], fr[N];
int find(int x) { return x == prnt[x] ? x : prnt[x] = find(prnt[x]); }
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (rnk[x] >= rnk[y]) {
prnt[y] = x;
nd[x] += nd[y];
fr[x] += fr[y];
} else {
prnt[x] = y;
nd[y] += nd[x];
fr[y] += fr[x];
}
if (rnk[x] == rnk[y]) ++rnk[x];
}
void init() {
for (int i = 0; i <= n; ++i) {
prnt[i] = i;
rnk[i] = 0;
nd[i] = 1;
fr[i] = cap[i];
}
}
bool check(int f) {
init();
int i = 0;
for (; i < n - 1 && e[i].c < f; ++i) unite(e[i].a, e[i].b);
int tl = 0;
for (int i = 1; i <= n; ++i)
if (prnt[i] == i) tl += fr[i];
for (int i = 1; i <= n; ++i)
if (prnt[i] == i) {
if (nd[i] > tl - fr[i]) return false;
}
return true;
}
int main() {
scanf("%d", &n);
int l = 0, r = 0;
for (int i = 0; i < n - 1; ++i) {
scanf("%d %d %d", &e[i].a, &e[i].b, &e[i].c);
r = max(r, e[i].c + 1);
}
for (int i = 1; i <= n; ++i) scanf("%d", cap + i);
sort(e, e + n - 1);
while (r - l > 1) {
int mid = (l + r) / 2;
if (check(mid))
l = mid;
else
r = mid;
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MX = 3009;
long long x[MX], par[MX], num[MX], ans = 0;
pair<long long, pair<long long, long long> > edg[MX];
void MS(long long v) {
par[v] = -1;
num[v] = x[v];
}
long long FS(long long v) {
if (par[v] < 0) return v;
return par[v] = FS(par[v]);
}
void US(long long a, long long b) {
a = FS(a), b = FS(b);
if (a == b) return;
if (par[a] > par[b]) swap(a, b);
par[a] += par[b];
par[b] = a;
num[a] += num[b];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long u, v, w;
cin >> u >> v >> w;
edg[i] = {w, {u, v}};
}
for (long long i = 1; i <= n; i++) cin >> x[i];
for (long long i = 1; i <= n; i++) MS(i);
sort(edg, edg + n - 1);
for (long long i = 0; i < n - 1; i++) {
long long u = edg[i].second.first, v = edg[i].second.second,
w = edg[i].first;
long long maxx = 0, sum = 0, res = 1;
for (long long j = 1; j <= n; j++) {
if (par[j] < 0) {
maxx = max(maxx, -par[j]);
sum += num[j];
}
}
for (long long j = 1; j <= n; j++) {
if (par[j] < 0) {
if (sum - num[j] < -par[j]) res = 0;
}
}
if (res) ans = w;
US(u, v);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, fa[maxn], size[maxn], a[maxn], sum = 0;
struct node {
int u, v, w;
} t[maxn];
bool cmp(node x, node y) { return x.w < y.w; }
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; i++) scanf("%d%d%d", &t[i].u, &t[i].v, &t[i].w);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
fa[i] = i;
size[i] = 1;
sum += a[i];
}
sort(t + 1, t + n, cmp);
for (int i = 1; i < n; i++) {
int fx = find(t[i].u), fy = find(t[i].v);
if (fx == fy) continue;
fa[fx] = fy;
size[fy] += size[fx];
a[fy] += a[fx];
if (size[fy] > sum - a[fy]) {
printf("%d\n", t[i].w);
return 0;
}
}
printf("%d\n", t[n - 1].w);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3001;
int ex[MAXN], ey[MAXN], w[MAXN], f[MAXN], sum, par[MAXN], sz[MAXN], sumF[MAXN];
pair<int, int> all[MAXN];
bool bad;
int find(int x) {
if (par[x] != x) par[x] = find(par[x]);
return par[x];
}
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
sz[x] += sz[y];
sumF[x] += sumF[y];
par[y] = x;
if (sum - sumF[x] < sz[x]) bad = true;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> ex[i] >> ey[i] >> w[i];
ex[i]--;
ey[i]--;
all[i] = pair<int, int>(w[i], i);
}
for (int i = 0; i < n; i++)
cin >> f[i], sum += f[i], sumF[i] = f[i], par[i] = i, sz[i] = 1;
sort(all, all + n - 1);
int ans = 0, cur = 0;
while (cur < n - 1) {
int edgeId = all[cur].second;
if (!bad) ans = w[edgeId];
merge(ex[edgeId], ey[edgeId]);
while (cur < n - 1 && w[edgeId] == all[cur].first)
merge(ex[all[cur].second], ey[all[cur].second]), cur++;
}
if (!bad && n > 1) ans = w[all[n - 2].second];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3005;
int N;
vector<int> adj[MAXN];
vector<int> len[MAXN];
int X[MAXN];
bool vis[MAXN];
int total = 0, nodecnt = 0, xcnt = 0;
void dfs(int node, int val) {
vis[node] = true;
nodecnt++;
xcnt += X[node];
for (int i = 0; i < adj[node].size(); i++) {
int next = adj[node][i];
if (!vis[next] && len[node][i] < val) dfs(next, val);
}
}
bool check(int val) {
memset(vis, false, sizeof(vis));
for (int i = 0; i < N; i++)
if (!vis[i]) {
nodecnt = 0, xcnt = 0;
dfs(i, val);
if (nodecnt > total - xcnt) return false;
}
return true;
}
int main() {
cin >> N;
for (int i = 0; i < N - 1; i++) {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
len[a].push_back(c);
len[b].push_back(c);
}
for (int i = 0; i < N; i++) {
cin >> X[i];
total += X[i];
}
int lo = 0, hi = 10000;
while (lo < hi) {
int mid = lo + (hi - lo + 1) / 2;
if (check(mid))
lo = mid;
else
hi = mid - 1;
}
cout << lo << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, par[((int)21 * 1000)], all, a[((int)21 * 1000)], b[((int)21 * 1000)],
c[((int)21 * 1000)];
vector<pair<int, pair<int, int> > > ed;
int root(int x) {
if (par[x] == -1) return x;
return par[x] = root(par[x]);
}
bool check(int x) {
memset(par, -1, sizeof par);
for (auto q : ed) {
if (q.first >= x) break;
par[root(q.second.first)] = root(q.second.second);
}
memset(b, 0, sizeof b);
memset(c, 0, sizeof c);
for (int i = 1; i <= n; i++) b[root(i)]++, c[root(i)] += a[i];
for (int i = 1; i <= n; i++)
if (par[i] == -1 && all - c[i] < b[i]) return 0;
return 1;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int v, u, w;
cin >> v >> u >> w;
ed.push_back({w, {v, u}});
}
for (int i = 1; i <= n; i++) cin >> a[i], all += a[i];
sort(ed.begin(), ed.end());
int l = 0, r = 20 * 1000;
while (l < r - 1) {
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 int MAXN = 200100;
long long t[MAXN], g[MAXN], pai[MAXN];
struct str {
long long l, r, w;
};
str are[MAXN];
bool comp(str a, str b) { return a.w < b.w; }
bool comp2(long long x, long long y) { return t[x] > t[y]; }
long long find(long long x) {
if (pai[x] == x) return pai[x];
return pai[x] = find(pai[x]);
}
void join(long long a, long long b) {
long long x = find(a), y = find(b);
g[y] += g[x];
t[y] += t[x];
pai[x] = y;
}
bool vis[MAXN];
signed main() {
memset(g, 0, sizeof g);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) t[i] = 1, pai[i] = i;
for (long long i = 1; i < n; i++) {
long long x, y, z;
cin >> x >> y >> z;
are[i].l = x, are[i].r = y, are[i].w = z;
}
long long soma = 0;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
g[i] = x - 1;
soma += x - 1;
}
sort(are + 1, are + n, comp);
long long resp = 0;
for (long long i = 0; i < n - 1; i++) {
if (i != 0) join(are[i].l, are[i].r);
memset(vis, false, sizeof vis);
vector<long long> vec;
for (long long j = 1; j <= n; j++) {
long long x = find(j);
if (vis[x] == true) continue;
vis[x] = true;
vec.push_back(x);
}
sort(vec.begin(), vec.end(), comp2);
if (t[vec[0]] <= n - t[vec[0]] + soma - g[vec[0]])
resp = are[i + 1].w;
else
break;
}
cout << resp << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
template <class T>
int size(T &x) {
return x.size();
}
int main() {
int n;
scanf("%d\n", &n);
vector<pair<int, int> > *adj = new vector<pair<int, int> >[n];
for (int i = 0; i < n - 1; i++) {
int a, b, c;
scanf("%d %d %d\n", &a, &b, &c);
a--, b--;
adj[a].push_back(pair<int, int>(b, c));
adj[b].push_back(pair<int, int>(a, c));
}
vector<int> cnt(n);
int totalcnt = 0;
for (int i = 0; i < n; i++) {
scanf("%d\n", &cnt[i]);
totalcnt += cnt[i];
}
int lo = 0, hi = 10000;
while (lo < hi) {
int m = hi - (hi - lo) / 2;
bool ok = true;
vector<bool> visited(n, false);
for (int i = 0; ok && i < n; i++) {
if (visited[i]) continue;
stack<int> S;
S.push(i);
visited[i] = true;
int cursize = 0;
int curcnt = 0;
while (!S.empty()) {
int cur = S.top();
S.pop();
cursize++;
curcnt += cnt[cur];
for (int i = 0; i < size(adj[cur]); i++) {
pair<int, int> nxt = adj[cur][i];
if (nxt.second >= m) {
continue;
}
if (!visited[nxt.first]) {
S.push(nxt.first);
visited[nxt.first] = true;
}
}
}
ok = cursize <= totalcnt - curcnt;
}
if (ok) {
lo = m;
} else {
hi = m - 1;
}
}
printf("%d\n", hi);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') positive = 0;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
const int N = 3005 * 4, inf = 1 << 28;
int n, l, S = 0, T = 1, p[N], c[N], x[N], y[N], z[N], xx[N], yy[N], ed[N * 8],
data[N * 8], Next[N * 8], son[N], d[N], f[N];
bool cmp(const int i, const int j) { return z[i] < z[j]; }
void add(int x, int y, int z) {
ed[++l] = y, data[l] = z, Next[l] = son[x], son[x] = l;
ed[++l] = x, data[l] = 0, Next[l] = son[y], son[y] = l;
}
int get(int x) { return f[x] == x ? x : f[x] = get(f[x]); }
bool build() {
int h = 0, t = 1;
memset(d, -1, sizeof(d)), d[f[1] = S] = 0;
while (h < t) {
int x = f[++h];
for (int y, p = son[x]; p; p = Next[p])
if (data[p]) {
if (d[y = ed[p]] < 0) d[y] = d[x] + 1, f[++t] = y;
if (y == T) return 1;
}
}
return 0;
}
int dinic(int x, int low) {
if (x == T) return low;
int w = 0, res;
for (int y, p = son[x]; p; p = Next[p])
if (data[p] && d[y = ed[p]] == d[x] + 1)
if (res = dinic(y, min(low - w, data[p])))
data[p] -= res, data[p ^ 1] += res, w += res;
if (!w) d[x] = -1;
return w;
}
int work() {
int Z = n, ans = 0;
memset(son, 0, sizeof(son)), l = 1;
for (int i = 1; i <= n; ++i)
add(S, i * 2, 1), add(i * 2 + 1, T, c[i]), f[i] = i;
for (int i = 1; i <= n - 1; ++i) {
int X = get(x[p[i]]), Y = get(y[p[i]]);
f[++Z] = Z, xx[i] = X, yy[i] = Y;
f[X] = Z, f[Y] = Z;
add(X * 2, Z * 2, inf), add(Y * 2, Z * 2, inf);
add(Z * 2 + 1, X * 2 + 1, inf), add(Z * 2 + 1, Y * 2 + 1, inf);
}
for (int i = n - 1; i; --i) {
int X = xx[i], Y = yy[i];
add(X * 2, Y * 2 + 1, inf), add(Y * 2, X * 2 + 1, inf);
while (build()) ans += dinic(S, inf);
if (ans == n) return z[p[i]];
}
}
int main() {
n = read();
if (n == 1) {
printf("%d\n", 0);
return 0;
}
for (int i = 1; i <= n - 1; ++i)
x[i] = read(), y[i] = read(), z[i] = read(), p[i] = i;
for (int i = 1; i <= n; ++i) c[i] = read();
sort(p + 1, p + n, cmp);
printf("%d\n", work());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int n, x[N], f[N], sz[N], v[N];
inline int getf(int v) { return f[v] == v ? v : f[v] = getf(f[v]); }
struct Edge {
int u, v, w;
} e[N];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) cin >> e[i].u >> e[i].v >> e[i].w;
sort(e + 1, e + n, [](Edge a, Edge b) { return a.w < b.w; });
int sum = 0;
for (int i = 1; i <= n; i++) cin >> x[i], sum += x[i];
for (int i = 1; i <= n; i++) f[i] = i, sz[i] = 1, v[i] = x[i];
for (int i = 1; i < n; i++) {
int fx = getf(e[i].u), fy = getf(e[i].v);
f[fx] = fy;
sz[fy] += sz[fx];
v[fy] += v[fx];
if (sz[fy] > sum - v[fy]) {
cout << e[i].w << endl;
return 0;
}
}
cout << e[n - 1].w << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
struct dsu {
vector<long long> p, ps;
dsu() {}
dsu(long long n) {
p = vector<long long>(n + 1), ps = vector<long long>(n + 1, 1);
for (long long i = 0; i < (n + 1); ++i) p[i] = i;
}
long long find(long long x) { return p[x] == x ? x : p[x] = find(p[x]); }
bool join(long long x, long long y) {
x = find(x), y = find(y);
if (x == y) return 0;
if (ps[x] > ps[y]) swap(x, y);
p[x] = y, ps[y] += ps[x];
return 1;
}
};
const long long N = 3030;
long long a[N], b[N], c[N];
long long x[N];
long long n;
long long pai[N];
long long sumx[N];
long long sz[N];
long long f(long long x) { return pai[x] = (pai[x] == x ? x : f(pai[x])); }
void join(long long a, long long b) {
a = f(a), b = f(b);
if (f(a) == f(b)) return;
pai[b] = a;
sumx[a] += sumx[b];
sz[a] += sz[b];
return;
}
bool ok(long long mid) {
long long tot = 0;
for (long long i = 1; i <= n; i++) {
pai[i] = i;
sz[i] = 1;
sumx[i] = x[i];
tot += x[i];
}
for (long long i = 1; i < n; i++) {
if (c[i] < mid) {
join(a[i], b[i]);
}
}
long long flow = 1e9;
for (long long i = 1; i <= n; i++) {
if (f(i) != i) continue;
flow = min(flow, tot + n - sz[f(i)] - sumx[f(i)]);
}
return flow >= n;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = 1; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
for (long long i = 1; i <= n; i++) cin >> x[i];
long long l = 1, r = 100000;
long long ans = 0;
while (l <= r) {
long long mid = (l + r) / 2;
if (ok(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
int n;
pair<int, pair<int, int> > es[3005];
vector<pair<int, int> > g[3005];
int x[3005];
struct uf {
static const int MSIZE = 3005;
int par[MSIZE];
int size[MSIZE];
int cap[MSIZE];
void init() {
memset(par, -1, sizeof(par));
for (int i = 0; i < (MSIZE); ++i) {
size[i] = 1;
cap[i] = x[i];
}
}
int root(int a) {
if (par[a] == -1) return a;
return par[a] = root(par[a]);
}
void unite(int a, int b) {
a = root(a);
b = root(b);
if (a == b) return;
if (size[a] < size[b]) swap(a, b);
par[b] = a;
size[a] += size[b];
cap[a] += cap[b];
}
bool same(int a, int b) { return root(a) == root(b); }
};
uf u;
bool check(int w) {
u.init();
for (int i = 0; i < (n); ++i)
if (es[i].first < w) {
u.unite(es[i].second.first, es[i].second.second);
}
vector<pair<int, int> > trees;
for (int i = 0; i < (n); ++i)
if (u.root(i) == i) {
trees.push_back(make_pair(u.size[i], u.cap[i]));
}
sort((trees).begin(), (trees).end());
reverse((trees).begin(), (trees).end());
;
;
;
;
;
;
if (trees[0].first * 2 > n) {
int othersum = 0;
for (int i = (1); i < (trees.size()); ++i) othersum += trees[i].second;
if (othersum >= trees[0].first) return true;
return false;
} else
return true;
}
int main() {
cin >> n;
for (int i = 0; i < (n - 1); ++i) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
g[a].push_back(make_pair(b, c));
g[b].push_back(make_pair(a, c));
es[i] = make_pair(c, make_pair(a, b));
}
for (int i = 0; i < (n); ++i) cin >> x[i];
int lb = 0, ub = 10005;
while (ub - lb > 1) {
int md = (lb + ub) >> 1;
if (check(md))
lb = md;
else
ub = md;
}
cout << lb << endl;
return 0;
}
|
#include <bits/stdc++.h>
using std::sort;
using std::vector;
int boss[3000];
int w[3000];
int c[3000];
struct Edge {
int u, v, w;
} E[3000];
bool ecmp(Edge x, Edge y) { return x.w < y.w; }
int find(int x) {
if (boss[x] != x) boss[x] = find(boss[x]);
return boss[x];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int tu, tv, tw;
scanf("%d%d%d", &tu, &tv, &tw);
Edge tmp = (Edge){tu - 1, tv - 1, tw};
E[i] = tmp;
}
sort(E, E + n - 1, ecmp);
int ans = E[0].w;
for (int i = 0; i < n; ++i) boss[i] = i;
int sum = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &w[i]);
sum += w[i];
c[i] = 1;
}
for (int i = 0; i < n - 1; ++i) {
int bu = find(E[i].u);
int bv = find(E[i].v);
boss[bv] = bu;
w[bu] += w[bv];
c[bu] += c[bv];
if (c[bu] > sum - w[bu])
break;
else
ans = E[i + 1].w;
}
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;
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];
pair<int, pair<int, int> > v[10000];
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[i] = make_pair(c, make_pair(a, b));
}
for (int i = 0; i < n; i++) scanf("%d", &w[i]);
sort(v, v + n - 1);
int l = 0, r = n;
while (r - l > 1) {
int s = (l + r) / 2;
if (can(s))
l = s;
else
r = s;
}
printf("%d\n", v[l].first);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000 + 100;
const int oo = 1000 * 1000 * 1000;
int n;
vector<pair<int, int> > adj[maxn];
int x[maxn];
bool mark[maxn];
vector<pair<int, int> > sz;
long long cnt1, cnt2;
int bin(int f, int e);
bool chk(int m);
void dfs(int v, int m);
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
adj[u].push_back(pair<int, int>(w, v));
adj[v].push_back(pair<int, int>(w, u));
}
for (int i = 0; i < n; i++) cin >> x[i];
int ans = bin(0, oo);
cout << ans << '\n';
return 0;
}
int bin(int f, int e) {
if (e - f < 2) return f;
int mid = (f + e) / 2;
if (chk(mid)) return bin(mid, e);
return bin(f, mid);
}
bool chk(int m) {
fill(mark, mark + n, false);
sz.resize(0);
for (int i = 0; i < n; i++)
if (!mark[i]) {
cnt1 = 0, cnt2 = 0;
dfs(i, m);
sz.push_back(pair<int, int>(cnt1, cnt2));
}
long long sum = 0;
for (int i = 0; i < sz.size(); i++) sum += sz[i].second;
for (int i = 0; i < sz.size(); i++)
if (sum - sz[i].second < sz[i].first) return false;
return true;
}
void dfs(int v, int m) {
mark[v] = true;
cnt1++, cnt2 += x[v];
for (pair<int, int> u : adj[v])
if (!mark[u.second] && u.first < m) dfs(u.second, m);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 3e3 + 10;
const long long MXM = 5e2 + 10;
const long long MX5 = 1e5 + 10;
const long long MX6 = 1e6 + 10;
const long long LOG = 20;
const long long INF = 8e18;
const double eps = 1e-9;
const long long MOD = 1e9 + 7;
long long power(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2, md) % md
: power(a * a % md, b / 2, md) % md));
}
long long bmm(long long a, long long b) {
return (a % b == 0 ? b : bmm(b, a % b));
}
string base2(long long n) {
string a = "";
while (n >= 2) {
a += (char)(n % 2 + '0');
n /= 2;
}
a += (char)(n + '0');
reverse((a).begin(), (a).end());
return a;
}
long long n, m, Sum, X[MXN];
long long par[MXN], SZ[MXN], dp[MXN];
vector<long long> G[MXN], vec;
vector<pair<long long, pair<long long, long long> > > E;
bool vis[MXN], mark[MXN];
set<long long> M;
void init() {
vec.clear();
M.clear();
for (int i = 1; i <= n; i++) {
SZ[i] = 1;
par[i] = i;
vis[i] = 0;
mark[i] = 0;
dp[i] = X[i];
G[i].clear();
M.insert(i);
}
return;
}
long long Find(long long u) {
if (par[u] == u) {
return u;
}
par[u] = Find(par[u]);
return par[u];
}
void Union(long long u, long long v) {
long long p1 = Find(u), p2 = Find(v);
if (p1 == p2) {
return;
}
if (SZ[p1] > SZ[p2]) {
par[p2] = p1;
SZ[p1] += SZ[p2];
dp[p1] += dp[p2];
M.erase(p2);
} else {
par[p1] = p2;
SZ[p2] += SZ[p1];
dp[p2] += dp[p1];
M.erase(p1);
}
return;
}
bool DFS1(long long u) {
bool f = 1;
mark[u] = 1;
if (Sum - dp[u] < SZ[u]) return 0;
for (auto v : G[u]) {
if (!mark[v]) {
if (DFS1(v) == 0) return 0;
}
}
return f;
}
void DFS(long long u) {
vis[u] = 1;
Sum += dp[u];
for (auto v : G[u]) {
if (!vis[v]) {
DFS(v);
}
}
return;
}
bool check(long long x) {
init();
long long i = 0;
while (i < m && E[i].first < x) {
long long u = E[i].second.first, v = E[i].second.second;
Union(u, v);
i++;
}
while (i < m) {
long long u = E[i].second.first, v = E[i].second.second;
long long p1 = Find(u), p2 = Find(v);
G[p1].push_back(p2);
G[p2].push_back(p1);
i++;
}
auto itr = M.begin();
while (itr != M.end()) {
long long now = *itr;
if (G[now].empty()) return 0;
vec.push_back(now);
itr++;
}
for (auto u : vec) {
if (!vis[u]) {
Sum = 0;
DFS(u);
bool f = DFS1(u);
if (!f) return 0;
}
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
m = n - 1;
for (int i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
E.push_back({w, {u, v}});
}
for (int i = 1; i <= n; i++) cin >> X[i];
sort(((E)).begin(), ((E)).end());
long long l = 0, r = 1e5;
while (r - l > 1) {
long long mid = (l + r) / 2;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <class T, class U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &x) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-' && c != -1)
;
if (c == -1) return;
if (c == '-') sg = 1, c = getchar();
for (x = 0; c >= '0' && c <= '9';
x = (x << 1) + (x << 3) + c - '0', c = getchar())
;
if (sg) x = -x;
}
template <class T>
void print(T x) {
if (x < 0) return putchar('-'), print(-x);
if (x < 10) {
putchar(x + '0');
return;
}
print(x / 10);
putchar(x % 10 + '0');
}
template <class U, class V>
inline void gn(U &u, V &v) {
gn(u);
gn(v);
}
template <class U, class V, class W>
inline void gn(U &u, V &v, W &w) {
gn(u);
gn(v, w);
}
template <class T>
void println(T x) {
print(x);
putchar('\n');
}
template <class T>
void printsp(T x) {
print(x);
putchar(' ');
}
template <class U, class V>
inline void print(U u, V v) {
printsp(u);
println(v);
}
template <class U, class V, class W>
inline void print(U u, V v, W w) {
printsp(u);
print(v, w);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; a = (long long)a * a % m, b >>= 1)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
pair<pair<int, int>, int> edge[3333];
int a[3333], tmp[3333], root[3333], sz[3333];
void init(int n) {
for (int i = 1; i <= n; i++) root[i] = i, sz[i] = 1, tmp[i] = a[i];
}
int find(int first) {
while (first != root[first]) first = root[first];
return first;
}
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
sz[a] += sz[b];
root[b] = a;
tmp[a] += tmp[b];
}
int main() {
int n;
gn(n);
for (int i = 0; i < n - 1; i++) {
gn(edge[i].first.first, edge[i].first.second, edge[i].second);
}
int sum = 0;
for (int i = 1; i <= n; i++) {
gn(a[i]);
sum += a[i];
}
int st = 0, ed = 10001;
while (ed - st > 1) {
int md = (ed + st) / 2;
init(n);
for (int i = 0; i < n - 1; i++) {
if (edge[i].second < md) {
unite(edge[i].first.first, edge[i].first.second);
}
}
int vst = 0;
for (int i = 1; i <= n; i++)
if (i == find(i)) {
if (sz[i] > sum - tmp[i]) {
vst = 1;
break;
}
}
if (vst)
ed = md;
else
st = md;
}
println(st);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
const int maxn = 40001;
pair<int, pair<int, int> > edge[maxn];
int sz[maxn], f[maxn];
int lim[maxn];
int n;
int find(int k) {
if (f[k] != k) f[k] = find(f[k]);
return f[k];
}
int main() {
scanf("%d", &n);
if (n == 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n - 1; i++)
scanf("%d%d%d", &edge[i].second.first, &edge[i].second.second,
&edge[i].first);
sort(edge + 1, edge + n);
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &lim[i]);
f[i] = i;
sz[i] = 1;
sum += lim[i];
}
int ans = edge[1].first;
int mx = 1;
for (int i = 1; i < n; i++) {
int j;
for (j = i; j < n && edge[i].first == edge[j].first; j++) {
int fx = find(edge[j].second.first);
int fy = find(edge[j].second.second);
f[fx] = fy;
sz[fy] += sz[fx];
lim[fy] += lim[fx];
if (sz[mx] < sz[fy]) mx = fy;
}
if (j < n && sum - lim[mx] >= sz[mx]) ans = edge[j].first;
i = j - 1;
}
cout << ans << endl;
}
|
#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;
}
inline void getint(int &first) {
char c;
while (c = getchar(), c > '9' || c < '0')
;
for (first = 0; c >= '0' && c <= '9'; c = getchar())
first = (first << 1) + (first << 3) + c - '0';
}
inline void print(int first) {
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
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;
}
pair<pair<int, int>, int> edge[3333];
int root[3333], cnt[3333], ss[3333], a[3333];
void init(int n) {
for (int i = 1; i <= n; i++) root[i] = i, cnt[i] = 1, ss[i] = a[i];
}
int find_root(int u) { return u == root[u] ? u : root[u] = find_root(root[u]); }
void join(int u, int v) {
u = find_root(u);
v = find_root(v);
if (u == v) return;
if (cnt[u] < cnt[v]) swap(u, v);
root[v] = u;
cnt[u] += cnt[v];
ss[u] += ss[v];
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
scanf("%d %d %d", &edge[i].first.first, &edge[i].first.second,
&edge[i].second);
}
int sum = 0;
for (int i = 1; i <= n; i++) scanf("%d", a + i), sum += a[i];
int st = 0, ed = 10001, mid;
while (ed - st > 1) {
mid = st + ed >> 1;
init(n);
for (int i = 0; i < n - 1; i++) {
if (edge[i].second < mid) join(edge[i].first.first, edge[i].first.second);
}
int ok = 1;
for (int i = 1; i <= n && ok; i++)
if (find_root(i) == i) {
if (cnt[i] > sum - ss[i]) ok = 0;
}
if (ok)
st = mid;
else
ed = mid;
}
cout << st << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const long long int maxn = 3e3 + 16, md = 1e9 + 7, inf = 2e16;
long long int gcd(long long int a, long long int b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
long long int tav(long long int n, long long int k) {
long long int res = 1;
while (k > 0) {
if (k & 1) {
res *= n;
res %= md;
}
n *= n;
n %= md;
k >>= 1;
}
return res;
}
long long int ds[maxn], dsz[maxn], dsl[maxn];
long long int dsu(long long int v) {
return (ds[v] == v ? v : ds[v] = dsu(ds[v]));
}
void merge(long long int v, long long int u) {
v = dsu(v);
u = dsu(u);
dsz[v] += dsz[u];
dsl[v] += dsl[u];
ds[u] = v;
return;
}
long long int n, lm[maxn], sum = 0;
vector<pair<long long int, pair<long long int, long long int> > > ed;
bool check(long long int x) {
for (long long int i = 0; i < n; i++) {
ds[i] = i;
dsz[i] = 1;
dsl[i] = lm[i];
}
for (auto q : ed) {
pair<long long int, long long int> p = q.second;
long long int v = p.first, u = p.second, w = q.first;
if (w >= x) break;
merge(v, u);
}
for (long long int i = 0; i < n; i++) {
if (sum - dsl[i] < dsz[i]) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long int i = 1; i < n; i++) {
long long int v, u, w;
cin >> v >> u >> w;
v--;
u--;
ed.push_back({w, {v, u}});
}
sort(ed.begin(), ed.end());
for (long long int i = 0; i < n; i++) {
cin >> lm[i];
sum += lm[i];
}
long long int l = 0, r = 1e4 + 16;
while (l < r - 1) {
long long int m = (r + l) >> 1;
if (check(m)) {
l = m;
} else {
r = m;
}
}
cout << l << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-8);
const double pi(3.14159265358979);
const int N = 3030;
struct edge {
int u, v, l;
} e[N] = {};
bool edge_cmp(const edge &e1, const edge &e2) { return e1.l < e2.l; }
int n, root[N] = {}, s1[N] = {}, s2[N] = {}, sum1 = 0, sum2 = 0;
int get_root(int r) {
if (r != root[r]) root[r] = get_root(root[r]);
return root[r];
}
void print_root() {
for (int i = 1; i <= n; ++i) get_root(i);
for (int i = 1; i <= n; ++i) cout << root[i] << ' ';
cout << endl;
for (int i = 1; i <= n; ++i) cout << s1[i] << ' ';
cout << endl;
for (int i = 1; i <= n; ++i) cout << s2[i] << ' ';
cout << endl;
}
void init() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].l);
sort(e + 1, e + n, edge_cmp);
for (int i = 1; i <= n; ++i) root[i] = i, s1[i] = 1, scanf("%d", &s2[i]);
sum1 = n;
sum2 = accumulate(s2 + 1, s2 + n + 1, 0);
}
void work() {
int i = 0;
for (i = 1; i < n; ++i) {
int u = get_root(e[i].u), v = get_root(e[i].v);
root[v] = u;
s1[u] += s1[v];
s2[u] += s2[v];
if (s1[u] > sum2 - s2[u]) break;
}
cout << e[i].l << endl;
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e3 + 20;
int x[maxn], from[maxn], to[maxn], w[maxn], n, sx, weight, totalx, tver;
vector<int> adj[maxn];
bool visited[maxn];
void dfs(int v) {
totalx += x[v];
tver++;
visited[v] = 1;
for (auto e : adj[v]) {
if (w[e] >= weight) continue;
int u = from[e] + to[e] - v;
if (!visited[u]) dfs(u);
}
}
bool check(int x) {
weight = x;
memset(visited, 0, sizeof visited);
for (int i = 1; i <= n; i++)
if (!visited[i]) {
totalx = 0;
tver = 0;
dfs(i);
if (sx - totalx < tver) return 0;
}
return 1;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> from[i] >> to[i] >> w[i];
adj[from[i]].push_back(i);
adj[to[i]].push_back(i);
}
for (int i = 1; i <= n; i++) cin >> x[i], sx += x[i];
int l = 0, r = 1e4 + 20;
while (r - l > 1) {
int m = (r + l) / 2;
if (check(m))
l = m;
else
r = m;
}
cout << l << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
struct edge {
int u, v, w;
} e[N];
int fa[N], siz[N], x[N], s;
inline int findf(int x) { return fa[x] == x ? x : fa[x] = findf(fa[x]); }
inline bool cmp(const edge& a, const edge& b) { return a.w < b.w; }
int main() {
scanf("%d", &n);
for (int i = 1; i < n; 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]), fa[i] = i, siz[i] = 1, s += x[i];
sort(e + 1, e + n, cmp);
for (int i = 1; i < n; i++) {
int fx = findf(e[i].u), fy = findf(e[i].v);
if (fx == fy) continue;
fa[fx] = fy, siz[fy] += siz[fx], x[fy] += x[fx];
if (siz[fy] > s - x[fy]) {
printf("%d", e[i].w);
return 0;
}
}
printf("%d", e[n - 1].w);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int n, x[N], f[N], sz[N], v[N];
inline int getf(int v) { return f[v] == v ? v : f[v] = getf(f[v]); }
struct Edge {
int u, v, w;
} e[N];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) cin >> e[i].u >> e[i].v >> e[i].w;
sort(e + 1, e + n, [](Edge a, Edge b) { return a.w < b.w; });
int sum = 0;
for (int i = 1; i <= n; i++) cin >> x[i], sum += x[i];
for (int i = 1; i <= n; i++) f[i] = i, sz[i] = 1, v[i] = x[i];
for (int i = 1; i < n; i++) {
int fx = getf(e[i].u), fy = getf(e[i].v);
f[fx] = fy;
sz[fy] += sz[fx];
v[fy] += v[fx];
if (sz[fy] > sum - v[fy]) {
cout << e[i].w << endl;
return 0;
}
}
cout << e[n - 1].w << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void RI() {}
template <typename... T>
void RI(int& head, T&... tail) {
scanf("%d", &head);
RI(tail...);
}
inline int min(int a, int b) { return a < b ? a : b; }
struct Maxflow {
static const short INF = 2e4;
struct E {
short to, cap, rev;
E() {}
E(short _to, short _cap, short _rev) : to(_to), cap(_cap), rev(_rev) {}
};
int n;
vector<vector<E> > e;
vector<vector<E>::iterator> cur;
vector<short> dis;
void init(int _n) {
n = _n;
e.resize(n);
cur.resize(n);
dis.resize(n);
for (int i = 0; i < int(n); i++) e[i].clear();
}
void add(int a, int b, int c) {
if (a == b) return;
e[a].push_back(E(b, c, e[b].size()));
e[b].push_back(E(a, 0, e[a].size() - 1));
}
bool bfs() {
fill(dis.begin(), dis.end(), -1);
queue<int> q;
dis[0] = 0;
q.push(0);
while (!q.empty() && dis[n - 1] == -1) {
int p = q.front();
q.pop();
for (auto it = (e[p]).begin(); it != (e[p]).end(); it++) {
if (it->cap == 0 || dis[it->to] != -1) continue;
dis[it->to] = dis[p] + 1;
q.push(it->to);
}
}
return dis[n - 1] != -1;
}
short go(int p, short c) {
if (p == n - 1) return c;
short ret = 0;
for (auto& it = cur[p]; it != e[p].end(); it++) {
if (it->cap == 0 || dis[it->to] != dis[p] + 1) continue;
short now = go(it->to, min(it->cap, c - ret));
ret += now;
it->cap -= now;
e[it->to][it->rev].cap += now;
if (ret == c) break;
}
if (ret == 0) dis[p] = -1;
return ret;
}
int maxflow() {
int ret = 0;
while (bfs()) {
for (int i = 0; i < int(n); i++) cur[i] = e[i].begin();
ret += go(0, INF);
}
return ret;
}
} flow;
int n, ea[3010], eb[3010], ec[3010], ub[3010];
vector<int> e[3010];
short dis[3010][3010];
bool vis[3010];
void dfs(int st, int p, int d, short _dis[3010]) {
_dis[p] = d;
for (auto it = (e[p]).begin(); it != (e[p]).end(); it++) {
int to = ea[*it] ^ eb[*it] ^ p;
if (!vis[to]) {
vis[to] = 1;
dfs(st, to, max(d, ec[*it]), _dis);
}
}
}
bool chk(int m) {
flow.init(2 * n + 2);
for (int i = (1); i <= int(n); i++) flow.add(0, i, 1);
for (int i = (1); i <= int(n); i++)
for (int j = (1); j <= int(n); j++)
if (dis[i][j] >= m) flow.add(i, j + n, 1);
for (int i = (1); i <= int(n); i++) flow.add(i + n, n + n + 1, ub[i]);
return flow.maxflow() == n;
}
int main() {
RI(n);
for (int i = 0; i < int(n - 1); i++) {
RI(ea[i], eb[i], ec[i]);
e[ea[i]].push_back(i);
e[eb[i]].push_back(i);
}
for (int i = (1); i <= int(n); i++) RI(ub[i]);
for (int i = (1); i <= int(n); i++) {
memset(vis, 0, sizeof(vis));
dfs(i, i, 0, dis[i]);
}
int l = 0, r = 10000;
while (l != r) {
int m = (l + r + 1) / 2;
if (chk(m))
l = m;
else
r = m - 1;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > G[3000];
int x[3000];
int n;
bool mark[3000];
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
return make_pair(a.first + b.first, a.second + b.second);
}
pair<int, int> dfs(int v, int d) {
if (mark[v]) return make_pair(0, 0);
pair<int, int> as(1, x[v]);
mark[v] = true;
for (int i = 0; i < G[v].size(); i++)
if (G[v][i].second < d) as = as + dfs(G[v][i].first, d);
return as;
}
bool check(int l) {
vector<pair<int, int> > vv;
memset(mark, 0, sizeof mark);
for (int i = 0; i < n; i++) {
pair<int, int> p = dfs(i, l);
if (p != make_pair(0, 0)) vv.push_back(p);
}
int sm = 0;
for (int i = 0; i < vv.size(); i++) sm += vv[i].second;
for (int i = 0; i < vv.size(); i++) {
if (sm - vv[i].second < vv[i].first) {
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b, c;
cin >> 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++) cin >> x[i];
int l = 0, r = 100000;
while (l + 1 < r) {
int m = (l + r) / 2;
if (check(m))
l = m;
else
r = m;
}
cout << l << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &x, T y) {
if (y > x) x = y;
}
template <class T>
inline void umin(T &x, T y) {
if (y < x) x = y;
}
const int N = 2e5 + 5, B = 0x7fffffff;
pair<int, pair<int, int> > edge[N];
int cap[N], siz[N], root[N];
int n;
int pq;
int ans;
int finds(int x) {
if (root[x] == x) return x;
return root[x] = finds(root[x]);
}
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", &cap[i]);
siz[i] = 1;
root[i] = i;
pq += cap[i];
}
sort(edge + 1, edge + n);
for (int i = 1; i <= n; i++) {
int x = finds(edge[i].second.first);
int y = finds(edge[i].second.second);
siz[x] += siz[y];
cap[x] += cap[y];
root[y] = root[x];
if (edge[i].first == edge[i + 1].first) continue;
if (siz[x] > pq - cap[x]) {
ans = i;
break;
}
}
printf("%d\n", max(0, edge[ans].first));
return !!0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int gi() {
char c;
int w;
bool q = true;
while (((c = getchar()) < '0' || '9' < c) && c != '-')
;
if (c == '-')
q = false, w = 0;
else
w = c - '0';
while ('0' <= (c = getchar()) && c <= '9') w = (w << 1) + (w << 3) + c - '0';
return q ? w : -w;
}
struct E {
int u, v, w;
inline void in() {
u = gi();
v = gi();
w = gi();
}
bool operator<(const E &b) const { return w < b.w; }
} e[N];
int fa[N];
inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int siz[N], in[N];
int main() {
int n = gi(), i, a, b, all = 0;
for (i = 1; i < n; i++) e[i].in();
for (i = 1; i <= n; i++) siz[i] = 1, all += in[fa[i] = i] = gi();
sort(e + 1, e + n);
for (i = 1; i < n; i++) {
a = find(e[i].u), b = find(e[i].v);
siz[a] += siz[b], in[a] += in[b], fa[b] = a;
if (all - in[a] < siz[a]) break;
}
printf("%d\n", e[i].w);
}
|
#include <bits/stdc++.h>
const int oo = 0x3f3f3f3f;
template <typename T>
inline bool chkmax(T &a, T b) {
return a < b ? a = b, true : false;
}
template <typename T>
inline bool chkmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <typename T>
T read(T &x) {
int f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (x = 0; isdigit(ch); ch = getchar()) x = 10 * x + ch - '0';
return x *= f;
}
const int MAXN = 3005;
struct Edge {
int u, v;
int w;
bool operator<(const Edge &rhs) const { return w < rhs.w; }
};
int N, M;
int first[MAXN];
Edge E[MAXN];
int fa[MAXN];
int size[MAXN];
int sumx[MAXN];
int glbsumx;
int getFather(int u) { return fa[u] == u ? u : fa[u] = getFather(fa[u]); }
void input() {
read(N);
M = N - 1;
for (int i = 0; i < M; ++i) {
read(E[i].u);
read(E[i].v);
read(E[i].w);
}
for (int i = 1; i <= N; ++i) {
read(first[i]);
glbsumx += first[i];
}
}
void solve() {
memcpy(sumx + 1, first + 1, N * sizeof(*sumx));
for (int i = 1; i <= N; ++i) {
fa[i] = i;
size[i] = 1;
}
std::sort(E, E + M);
int i;
for (i = 0; i < M; ++i) {
int fu = getFather(E[i].u);
int fv = getFather(E[i].v);
assert(fu != fv);
fa[fu] = fv;
size[fv] += size[fu];
sumx[fv] += sumx[fu];
if (size[fv] > glbsumx - sumx[fv]) break;
}
printf("%d\n", E[i].w);
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3050;
struct node {
int x, y, c;
} E[N];
bool cmp(node x, node y) { return x.c < y.c; }
int fa[N], s[N], x[N];
int getf(int v) {
if (v == fa[v]) return v;
return fa[v] = getf(fa[v]);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) scanf("%d%d%d", &E[i].x, &E[i].y, &E[i].c);
sort(E + 1, E + n, cmp);
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
sum += x[i];
fa[i] = i;
s[i] = 1;
}
for (int i = 1; i < n; i++) {
int u = getf(E[i].x), v = getf(E[i].y);
fa[u] = v;
s[v] += s[u];
x[v] += x[u];
if (s[v] > sum - x[v]) {
printf("%d\n", E[i].c);
return 0;
}
}
printf("0");
}
|
#include <bits/stdc++.h>
using namespace std;
const int NR = 3005;
int n;
int sum;
struct Nd {
int x, y, val;
bool operator<(const Nd& A) const { return val < A.val; }
} t[NR];
int fa[NR], siz[NR], d[NR];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
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 << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) siz[i] = 1, fa[i] = i;
for (int i = 1; i < n; i++)
t[i].x = read(), t[i].y = read(), t[i].val = read();
for (int i = 1; i <= n; i++) d[i] = read(), sum += d[i];
sort(t + 1, t + n);
for (int i = 1; i < n; i++) {
int fx = find(t[i].x), fy = find(t[i].y);
siz[fx] += siz[fy], d[fx] += d[fy];
fa[fy] = fx;
if (siz[fx] > sum - d[fx]) {
printf("%d\n", t[i].val);
return 0;
}
}
printf("%d\n", t[n - 1].val);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int getch() {
static const int len = 1 << 20;
static char buf[len], *st, *ed;
if (st == ed) ed = buf + fread(st = buf, 1, len, stdin);
return st == ed ? EOF : *st++;
}
template <typename T>
inline void read(T& x) {
static int c;
x = 0, c = getch();
while (isspace(c)) c = getch();
while (isdigit(c)) x = x * 10 + c - '0', c = getch();
return;
}
template <typename T, typename... Args>
void read(T& x, Args&... args) {
return read(x), read(args...);
}
const int maxn = 3003;
tuple<int, int, int> edge[maxn];
int n, m, u, v, w, f[maxn], s[maxn], x[maxn], cur, sum, ans;
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int merge(int p, int q) {
p = find(p), q = find(q);
if (s[p] > s[q])
return s[p] += s[q], x[p] += x[q], f[q] = p;
else
return s[q] += s[p], x[q] += x[p], f[p] = q;
}
int main() {
read(n);
for (int i = 1; i < n; i++) read(u, v, w), edge[i] = tie(w, u, v);
for (int i = 1; i <= n; i++) f[i] = i, s[i] = 1, read(x[i]), sum += x[i];
sort(edge + 1, edge + n);
for (int i = 1; i < n; i++) {
tie(w, u, v) = edge[i], cur = merge(u, v);
if (s[cur] > sum - x[cur]) return printf("%d\n", w), 0;
}
return printf("%d\n", w), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3030, M = 1e4 + 100;
int n, S, ans, u[N], v[N], w[N], par[N], sz[N], cnt[N];
bool bad;
vector<int> vec[M];
int g_par(int v) { return v == par[v] ? v : par[v] = g_par(par[v]); }
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> u[i] >> v[i] >> w[i];
u[i]--;
v[i]--;
vec[w[i]].push_back(i);
}
for (int i = 0; i < n; i++) {
cin >> sz[i];
par[i] = i;
cnt[i] = 1;
S += sz[i];
}
for (int w = 0; w < M && bad == false; w++) {
ans = w;
for (int dex : vec[w]) {
int U = g_par(u[dex]), V = g_par(v[dex]);
sz[U] += sz[V];
cnt[U] += cnt[V];
par[V] = U;
if (S - sz[U] < cnt[U]) bad = true;
}
}
cout << (n == 1 ? 0 : 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 = 1e6 + 10;
int siz[N], fa[N], a[N], sum, Flag = 1;
struct Edge {
int u, v, w;
} e[N];
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>
const int MAXN = 3000 + 1000;
int n, sum;
int in[MAXN], out[MAXN];
struct Union_Find_Set {
int f[MAXN];
void Init(int N) {
for (int i = 1, _ = N; i <= _; i++) f[i] = i;
}
int Find(int x) { return x == f[x] ? x : f[x] = Find(f[x]); }
bool Union(int x, int y) {
x = Find(x);
y = Find(y);
if (x == y) return 0;
in[x] += in[y];
out[x] += out[y];
f[y] = x;
if (in[x] + out[x] > sum) return 1;
return 0;
}
} t;
struct Edge {
int u, v, w;
Edge() {}
Edge(int u, int v, int w) : u(u), v(v), w(w) {}
bool operator<(const Edge &a) const { return w < a.w; }
} G[MAXN];
void Init() {
int u, v, w;
scanf("%d", &n);
t.Init(n);
for (int i = 1, _ = n - 1; i <= _; i++) {
scanf("%d%d%d", &u, &v, &w);
G[i] = Edge(u, v, w);
}
for (int i = 1, _ = n; i <= _; i++) {
scanf("%d", &out[i]);
sum += out[i];
in[i] = 1;
}
}
void Solve() {
if (n == 1) {
puts("0");
return;
}
int u, v;
std::sort(G + 1, G + n);
for (int i = 1, _ = n - 1; i <= _; i++) {
if (t.Union(G[i].u, G[i].v)) {
printf("%d\n", G[i].w);
return;
}
}
}
int main() {
Init();
Solve();
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long k = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
k = k * 10 + ch - '0';
ch = getchar();
}
return k * f;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
const long long N = 1e5 + 10;
long long n, sum = 0;
struct ppap {
long long x, y, v;
} a[N];
inline bool cmp(ppap a, ppap b) { return a.v < b.v; }
long long fa[N], s[N], b[N];
inline long long find(long long x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
signed main() {
n = read();
for (long long i = 1; i < n; i++) {
a[i].x = read();
a[i].y = read();
a[i].v = read();
}
for (long long i = 1; i <= n; i++) {
b[i] = read();
fa[i] = i;
s[i] = 1;
sum += b[i];
}
sort(a + 1, a + n, cmp);
long long i = 1;
for (; i <= n; i++) {
long long fx = find(a[i].x), fy = find(a[i].y);
if (fx != fy) {
fa[fx] = fy;
s[fy] += s[fx];
b[fy] += b[fx];
if (s[fy] > sum - b[fy]) break;
}
}
writeln(a[i].v);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
const int INF = 1000 * 1000 * 1000;
const long long LINF = (long long)INF * INF;
int n, efrom[3030], eto[3030], ew[3030];
int ed[3030];
int bnd[3030];
int dpar[3030];
int cap[3030], sz[3030];
int getroot(int x) { return (dpar[x] == x ? x : dpar[x] = getroot(dpar[x])); }
void merge(int x, int y) {
x = getroot(x);
y = getroot(y);
if (x == y) return;
sz[y] += sz[x];
cap[y] += cap[x];
dpar[x] = y;
}
bool check(int mid) {
iota(dpar, dpar + 3030, 0);
fill(sz, sz + 3030, 1);
copy(bnd, bnd + 3030, cap);
for (int i = 0; i < n - 1 && ew[ed[i]] < mid; i++) {
merge(efrom[ed[i]], eto[ed[i]]);
}
int capsum = 0;
for (int i = (1); i < (n + 1); i++)
if (dpar[i] == i) capsum += cap[i];
for (int i = (1); i < (n + 1); i++)
if (dpar[i] == i && sz[i] > capsum - cap[i]) return false;
return (capsum >= n);
}
int32_t main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = (0); i < (n - 1); i++) {
int x, y, w;
cin >> x >> y >> w;
efrom[i] = x;
eto[i] = y;
ew[i] = w;
ed[i] = i;
}
for (int i = (1); i < (n + 1); i++) cin >> bnd[i];
sort(ed, ed + n - 1, [&](int x, int y) { return ew[x] < ew[y]; });
int l = 0, r = 1e5;
while (r - l > 1) {
int mid = (r + l) / 2;
if (check(mid))
l = mid;
else
r = mid;
}
cout << l << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, u, v, w;
struct node {
int l, r, v;
bool operator<(const node& other) const { return v < other.v; }
} edge[101000];
struct no {
int fa, val, l, r, num, son;
} wjr[201000];
int to[201000], cnt;
inline int find(int x) { return x == to[x] ? x : to[x] = find(to[x]); }
void kruscal() {
for (int i = 1; i < n; ++i) {
int t1 = find(edge[i].l), t2 = find(edge[i].r);
if (t1 != t2) {
cnt++;
to[t1] = to[t2] = cnt;
wjr[cnt].l = t1;
wjr[cnt].r = t2;
wjr[t1].fa = wjr[t2].fa = cnt;
wjr[cnt].val = edge[i].v;
wjr[cnt].num = wjr[t1].num + wjr[t2].num;
wjr[cnt].son = wjr[t1].son + wjr[t2].son;
}
}
}
int fa[201000][24];
inline void dfs(int x, int last) {
fa[x][0] = last;
for (int i = 1; i <= 20; ++i) {
fa[x][i] = fa[fa[x][i - 1]][i - 1];
}
if (wjr[x].l) dfs(wjr[x].l, x);
if (wjr[x].r) dfs(wjr[x].r, x);
}
bool f[201000];
int maxn;
inline int check(int x) {
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; ++i) {
int now = i;
for (int j = 20; j >= 0; --j) {
int nxt = fa[now][j];
if (nxt && wjr[nxt].val < x) {
now = fa[now][j];
}
}
if (!f[now] && now > n) {
f[now] = 1;
if (wjr[now].son > maxn - wjr[now].num) return 0;
}
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d%d%d", &u, &v, &w);
edge[i].l = u;
edge[i].r = v;
edge[i].v = w;
}
for (int i = 1; i <= n; ++i)
scanf("%d", &wjr[i].num), wjr[i].son = 1, maxn += wjr[i].num;
sort(edge + 1, edge + n);
for (int i = 1; i <= 2 * n + 5; ++i) to[i] = i;
cnt = n;
kruscal();
dfs(cnt, 0);
int l = 0, r = n, ans = 0;
edge[0].v = 0;
edge[n].v = edge[n - 1].v + 1000;
while (l < r) {
int mid = (l + r) >> 1;
if (check(edge[mid].v)) {
l = mid + 1;
ans = edge[mid].v;
} else {
r = mid;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MX = 3009;
long long x[MX], par[MX], num[MX], ans = 0;
pair<long long, pair<long long, long long> > edg[MX];
void MS(long long v) {
par[v] = -1;
num[v] = x[v];
}
long long FS(long long v) {
if (par[v] < 0) return v;
return par[v] = FS(par[v]);
}
void US(long long a, long long b) {
a = FS(a), b = FS(b);
if (a == b) return;
if (par[a] > par[b]) swap(a, b);
par[a] += par[b];
par[b] = a;
num[a] += num[b];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long u, v, w;
cin >> u >> v >> w;
edg[i] = {w, {u, v}};
}
for (long long i = 1; i <= n; i++) cin >> x[i];
for (long long i = 1; i <= n; i++) MS(i);
sort(edg, edg + n - 1);
for (long long i = 0; i < n - 1; i++) {
long long u = edg[i].second.first, v = edg[i].second.second,
w = edg[i].first;
long long maxx = 0, sum = 0, res = 1;
for (long long j = 1; j <= n; j++) {
if (par[j] < 0) {
maxx = max(maxx, -par[j]);
sum += num[j];
}
}
for (long long j = 1; j <= n; j++) {
if (par[j] < 0) {
if (sum - num[j] < -par[j]) res = 0;
}
}
if (res) ans = w;
US(u, v);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char xB[1 << 15], *xS = xB, *xT = xB;
inline long long read() {
long long x = 0;
int f = 1;
char ch =
(xS == xT && (xT = (xS = xB) + fread(xB, 1, 1 << 15, stdin), xS == xT)
? 0
: *xS++);
for (; ch < '0' || ch > '9';
f = (ch == '-') ? -1 : 1,
ch = (xS == xT &&
(xT = (xS = xB) + fread(xB, 1, 1 << 15, stdin), xS == xT)
? 0
: *xS++))
;
for (; ch >= '0' && ch <= '9';
x = x * 10 + ch - '0',
ch = (xS == xT &&
(xT = (xS = xB) + fread(xB, 1, 1 << 15, stdin), xS == xT)
? 0
: *xS++))
;
return f * x;
}
inline void timer() {}
const int N = 3000 + 5;
int n;
int tot;
int head[N];
struct edge {
int u;
int v;
int w;
bool operator<(const edge &rhs) const { return w < rhs.w; }
};
edge e[N];
int x[N];
int siz[N];
int s[N];
int b[N];
int fa[N];
inline int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
inline bool check() {
for (int i = (0); i < (n); ++i) {
if (siz[find(i)] > s[find(i)]) {
return true;
}
}
return false;
}
int main() {
n = read();
for (int i = (0); i < (n - 1); ++i) {
e[i].u = read() - 1;
e[i].v = read() - 1;
e[i].w = read();
}
sort(e, e + n - 1);
for (int i = (0); i < (n); ++i) {
x[i] = read();
}
for (int i = (0); i < (n); ++i) {
fa[i] = i;
siz[i] = 1;
for (int j = (0); j < (n); ++j) {
if (i == j) {
b[i] = x[i];
continue;
}
s[i] += x[j];
}
}
for (int i = (0), fu, fv; i < (n - 1); ++i) {
edge p = e[i];
fu = find(p.u);
fv = find(p.v);
fa[fv] = fu;
siz[fu] += siz[fv];
s[fu] -= b[fv];
b[fu] += b[fv];
if (check()) {
printf("%d\n", e[i].w);
return 0;
}
}
printf("%d\n", e[n - 2].w);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.14159265359;
const long long MOD = (long long)998244353ll;
const long long MAXN = (long long)3e3 + 10;
const long long INF = (long long)2242545357980376863;
const long double EPS = (long double)1e-8;
long long n, par[MAXN], w[MAXN], sz[MAXN], wsz[MAXN];
vector<pair<pair<long long, long long>, long long> > E;
long long get_par(long long node) {
if (par[node] == node) return node;
par[node] = get_par(par[node]);
return par[node];
}
void merge(long long u, long long v) {
u = get_par(u);
v = get_par(v);
if (u == v) return;
par[u] = v;
sz[v] += sz[u];
wsz[v] += wsz[u];
return;
}
vector<pair<long long, long long> > v;
bool valid() {
long long ind = 0;
long long wsum = 0;
long long szsum = 0;
for (int i = 0; i < v.size(); i++) {
if (v[i].first > v[ind].first) {
ind = i;
}
szsum += v[i].first;
wsum += v[i].second;
}
if (2 * v[ind].first <= szsum) return true;
if (wsum - v[ind].second >= v[ind].first) return true;
return false;
}
bool check(long long weight) {
fill(sz, sz + MAXN, 1);
for (int i = 0; i < MAXN; i++) wsz[i] = w[i];
for (int i = 1; i < MAXN; i++) par[i] = i;
v.clear();
for (auto edge : E) {
if (edge.second < weight) {
merge(edge.first.first, edge.first.second);
}
}
for (int i = 1; i <= n; i++) {
if (get_par(i) == i) {
v.push_back({sz[i], wsz[i]});
}
}
return valid();
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
long long u, v, we;
for (int i = 1; i < n; i++) {
cin >> u >> v >> we;
E.push_back({{u, v}, we});
}
for (int i = 1; i <= n; i++) cin >> w[i];
long long dw = 0;
long long up = 10001;
long long mid;
while (dw + 1 < up) {
mid = (dw + up) / 2;
if (check(mid))
dw = mid;
else
up = mid;
}
cout << dw << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 4e18;
const long double pai = acos(-1);
int n, all, bad;
pair<int, pair<int, int> > e[3009];
int p[100090], need[100009], give[100009];
int get(int node) {
if (p[node] == node) return node;
return p[node] = get(p[node]);
}
void merge(int a, int b) {
a = get(a), b = get(b);
if (a == b) return;
p[b] = a;
need[a] += need[b];
give[a] += give[b];
if (need[a] > all - give[a]) bad = 1;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
e[i] = {c, {a, b}};
}
sort(e, e + n - 1);
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> give[i];
all += give[i];
p[i] = i;
need[i] = 1;
}
for (int i = 0; i < n; i++) {
if (need[i] > all - give[i]) bad = 1;
}
if (!bad && n > 1) ans = e[0].first;
for (int i = 0; i < n - 1; i++) {
int j = i;
while (j < n - 1 && e[i].first == e[j].first) {
merge(e[j].second.first, e[j].second.second);
j++;
}
if (!bad && j < n) ans = e[j].first;
i = j - 1;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long nm = 0;
bool fh = true;
char cw = getchar();
for (; !isdigit(cw); cw = getchar()) fh ^= (cw == '-');
for (; isdigit(cw); cw = getchar()) nm = nm * 10 + (cw - '0');
return fh ? nm : -nm;
}
int n, hv[200200], all, F[200200], sz[200200];
struct Edge {
int x, y, z;
inline void gtin() { x = read(), y = read(), z = read(); }
inline bool operator<(const Edge b) const { return z < b.z; }
} e[200200];
inline int fd(int x) { return (F[x] == x) ? x : (F[x] = fd(F[x])); }
int main() {
n = read();
for (int i = 1; i < n; i++) e[i].gtin();
for (int i = 1; i <= n; i++)
hv[i] = read(), all += hv[i], F[i] = i, sz[i] = 1;
sort(e + 1, e + n);
for (int i = 1, x, y, fx, fy; i < n; i++) {
x = e[i].x, y = e[i].y, fx = fd(x), fy = fd(y);
if (fx ^ fy) {
hv[fx] += hv[fy], sz[fx] += sz[fy], F[fy] = fx;
if (all - hv[fx] < sz[fx]) {
printf("%d\n", e[i].z);
return 0;
}
}
}
printf("%d\n", e[n - 1].z);
return 0;
}
|
#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]) break;
}
printf("%d", ans);
}
|
#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;
}
if (n == 1) {
puts("0");
} else {
sort(lis, lis + (n - 1));
for (int i = 0; i < n - 1; ++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;
const int MAXN = 1e5 + 10;
inline int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
int N, fa[MAXN], x[MAXN], siz[MAXN], sum;
struct Edge {
int u, v, w;
bool operator<(const Edge &rhs) const { return w < rhs.w; }
} E[MAXN];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int main() {
N = read();
for (int i = 1; i <= N; i++) fa[i] = i, siz[i] = 1;
for (int i = 1; i <= N - 1; 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++) x[i] = read(), sum += x[i];
for (int i = 1; i <= N - 1; i++) {
int fx = find(E[i].u), fy = find(E[i].v);
if (fx == fy) continue;
fa[fy] = fx;
siz[fx] += siz[fy];
x[fx] += x[fy];
if (siz[fx] > sum - x[fx]) {
printf("%d\n", E[i].w);
return 0;
}
}
printf("%d\n", E[N - 1].w);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct E {
int u, v, w;
} e[3005];
int f[3005], size[3005], val[3005], sum, n;
bool cmp(E x, E y) { return x.w < y.w; }
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
for (int i = 1; i <= n; i++)
scanf("%d", val + i), sum += val[i], size[i] = 1, f[i] = i;
sort(e + 1, e + n, cmp);
for (int i = 1; i < n; i++) {
int x = e[i].u, y = e[i].v, fx = find(x), fy = find(y);
f[fx] = fy, size[fy] += size[fx], val[fy] += val[fx];
if (size[fy] > sum - val[fy]) return printf("%d", e[i].w), 0;
}
return printf("%d", e[n - 1].w), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
int n;
int ans;
int u[maxn];
int v[maxn];
int w[maxn];
int O[maxn];
int par[maxn];
int num[maxn];
void in();
void solve();
int dsu(int, int);
bool cmp(int, int);
int root(int);
void out();
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
in();
solve();
out();
}
void in() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> u[i] >> v[i] >> w[i];
u[i]--;
v[i]--;
}
for (int i = 0; i < n; i++) cin >> num[i];
}
void solve() {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += num[i];
par[i] = -1;
O[i] = i;
}
sort(O, O + n - 1, cmp);
ans = w[O[0]];
int ded = 0;
for (int i = 0; i < n - 1; i++) {
int x = dsu(u[O[i]], v[O[i]]);
if (par[x] + sum - num[x] < 0) ded = 1;
if (!ded) ans = w[O[i + 1]];
}
}
int dsu(int u, int v) {
u = root(u);
v = root(v);
if (par[u] < par[v]) swap(u, v);
par[u] += par[v];
num[u] += num[v];
par[v] = u;
return u;
}
int root(int u) { return par[u] < 0 ? u : par[u] = root(par[u]); }
bool cmp(int i, int j) { return w[i] < w[j]; }
void out() { cout << ans; }
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v, a;
bool operator<(const edge& c) const { return a < c.a; }
} Set[3001];
int f[3001], sz[3001], out[3001], 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;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T>
inline T abs(T x) {
return x > T() ? x : -x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 3000;
struct Input {
int n;
int a[N], b[N], c[N];
int x[N];
void init(const Input& input) { *this = input; }
};
struct Data : Input {
bool read() {
if (!(cin >> n)) {
return 0;
}
for (int i = 0; i < int(n - 1); ++i) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
--a[i];
--b[i];
}
for (int i = 0; i < int(n); ++i) {
scanf("%d", &x[i]);
}
return 1;
}
int ans;
void write() { cout << ans << endl; }
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct Solution : Data {
int p[N], s[N], t[N];
int P(int x) {
if (p[x] == x) {
return x;
}
return p[x] = P(p[x]);
}
void uni(int x, int y) {
x = P(x);
y = P(y);
if (s[x] > s[y]) {
swap(x, y);
}
p[x] = y;
s[y] += s[x];
t[y] += t[x];
}
void solve() {
int m = accumulate(x, x + n, 0);
for (int i = 0; i < int(n); ++i) {
p[i] = i;
s[i] = 1;
t[i] = x[i];
}
vector<pair<int, pair<int, int> > > v;
for (int i = 0; i < int(n - 1); ++i) {
v.push_back(make_pair(c[i], make_pair(a[i], b[i])));
}
sort((v).begin(), (v).end());
for (int i = 0; i < int(n - 1); ++i) {
uni(v[i].second.first, v[i].second.second);
int k = P(v[i].second.first);
if (s[k] > m - t[k]) {
ans = v[i].first;
return;
}
}
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream &operator>>(std::istream &i, pair<T, U> &p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream &operator>>(std::istream &i, vector<T> &t) {
for (auto &v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream &operator<<(std::ostream &o, const pair<T, U> &p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream &operator<<(std::ostream &o, const vector<T> &t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(int first) {
return 8 * sizeof(int) - __builtin_clz(first);
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U> &p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F &f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F &f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F &f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F &f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
template <typename T>
struct bounded_priority_queue {
inline bounded_priority_queue(unsigned int X) : A(X), B(0), s(0) {}
inline void push(unsigned int L, T V) {
B = max(B, L);
A[L].push(V);
++s;
}
inline const T &top() const { return A[B].front(); }
inline void pop() {
--s;
A[B].pop();
while (B > 0 && A[B].empty()) --B;
}
inline bool empty() const { return A[B].empty(); }
inline void clear() {
s = B = 0;
for (auto &a : A) a = queue<T>();
}
inline unsigned int size() const { return s; }
private:
vector<queue<T>> A;
unsigned int B;
int s;
};
struct UnionFind {
UnionFind(size_t N) : P(N, -1), comp(N) {}
int find(int first) {
while (P[first] >= 0) {
first = P[first];
}
return first;
}
bool united(int first, int second) { return find(first) == find(second); }
bool unite(int first, int second) {
first = find(first);
second = find(second);
if (first == second) {
return false;
}
--comp;
if (P[first] > P[second]) {
swap(first, second);
}
P[first] += P[second];
P[second] = first;
return true;
}
vector<int> P;
size_t comp;
};
unsigned long long mulull(unsigned long long a, unsigned long long z,
unsigned long long mod) {
__int128 result = ((__int128)a * (__int128)z) % (__int128)mod;
return (unsigned long long)result;
}
pair<unsigned long long, unsigned long long> mulull(unsigned long long a,
unsigned long long b) {
__int128 result = (__int128)a * (__int128)b;
return {(unsigned long long)(result >> 64), (unsigned long long)result};
}
bool fractionGreaterOrEqual(long long a, long long b, long long c,
long long d) {
if (b < 0) {
b = -b;
a = -a;
}
if (d < 0) {
d = -d;
c = -c;
}
return a < 0 && c < 0 ? mulull(-a, d) <= mulull(-c, b)
: (a >= 0) && (c < 0 || mulull(a, d) >= mulull(c, b));
}
bool fractionGreaterOrEqual(pair<long long, long long> a,
pair<long long, long long> b) {
return fractionGreaterOrEqual(a.first, a.second, b.first, b.second);
}
bool fractionGreaterOrEqual(double a, double b, double c, double d) {
return a / b >= c / d;
}
namespace Envelope {
template <typename T>
struct Line {
T m, b;
mutable function<const Line<T> *()> succ;
bool operator<(const Line &rhs) const {
if (rhs.b != numeric_limits<T>::min()) return m < rhs.m;
const Line *s = succ();
if (!s) return 0;
return b - s->b < (s->m - m) * rhs.m;
}
};
template <typename T>
struct Upper : public multiset<Envelope::Line<T>> {
using parent = multiset<Line<T>>;
bool bad(typename parent::iterator second) {
auto z = next(second);
if (second == parent::begin()) {
return z != parent::end() && second->m == z->m && second->b <= z->b;
} else {
auto first = prev(second);
if (z == parent::end()) {
return second->m == first->m && second->b <= first->b;
} else {
return fractionGreaterOrEqual(first->b - second->b,
second->m - first->m, second->b - z->b,
z->m - second->m);
}
}
}
void insert_line(T m, T b) {
auto second = parent::insert({m, b});
second->succ = [=] {
return next(second) == parent::end() ? 0 : &*next(second);
};
if (bad(second)) {
parent::erase(second);
return;
}
while (next(second) != parent::end() && bad(next(second)))
parent::erase(next(second));
while (second != parent::begin() && bad(prev(second)))
parent::erase(prev(second));
}
T operator[](T first) const {
auto l = parent::lower_bound({first, numeric_limits<T>::min()});
return l == parent::end() ? numeric_limits<T>::min() : l->m * first + l->b;
}
};
template <typename T>
struct Lower : public Upper<T> {
void insert_line(T m, T b) { Upper<T>::insert_line(-m, -b); }
T operator[](T first) const { return -Upper<T>::operator[](first); }
};
} // namespace Envelope
class dzylovesplanting {
public:
void solve(istream &cin, ostream &cout) {
int N;
vector<int> X;
vector<vector<std::pair<int, int>>> E;
cin >> N;
X.resize(N);
E.resize(10001);
for (int i = 0; i < N - 1; ++i) {
int u, v, c;
cin >> u >> v >> c;
E[c].push_back({u - 1, v - 1});
}
cin >> X;
int T = 0;
UnionFind U(N);
vector<int> S(N, 1);
for (int i = 0; i < N; ++i) T += X[i];
int ans = 0;
for (int c = 0; c <= 10000; ++c) {
bool ok = true;
for (int i = 0; i < N; ++i) {
if (U.find(i) == i && T - X[i] < S[i]) ok = false;
}
if (ok) ans = c;
for (std::pair<int, int> e : E[c]) {
int a = U.find(e.first);
int b = U.find(e.second);
U.unite(a, b);
S[a] = S[b] = S[a] + S[b];
X[a] = X[b] = X[a] + X[b];
}
}
cout << ans << '\n';
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
dzylovesplanting solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++i) {
if (i != v.begin()) os << ", ";
os << *i;
}
os << "]";
return os;
}
vector<int> dad;
vector<int> X;
int find_set(int x) { return dad[x] < 0 ? x : dad[x] = find_set(dad[x]); }
void union_sets(int x, int y) {
x = find_set(x);
y = find_set(y);
if (x == y) return;
if (dad[x] > dad[y]) swap(x, y);
dad[x] += dad[y];
X[x] += X[y];
dad[y] = x;
}
int main() {
int n;
scanf("%d", &n);
vector<pair<int, pair<int, int> > > E(n - 1);
for (int i = 0; i < (int)(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;
}
X.resize(n);
for (int i = 0; i < (int)(n); ++i) scanf("%d", &X[i]);
dad.resize(n, -1);
int C = accumulate(X.begin(), X.end(), 0);
sort(E.begin(), E.end());
int res = 0;
for (__typeof((E).begin()) e = (E).begin(); e != (E).end(); ++e) {
union_sets(e->second.first, e->second.second);
int i = find_set(e->second.first);
if (-dad[i] > C - X[i]) {
res = e->first;
break;
}
}
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
const int maxn = 10100;
int n, ans;
int sum = 0;
struct edge {
int u, v, w;
} a[maxn];
int fa[maxn], size[maxn], can[maxn];
inline int find(int x) { return fa[x] == x ? fa[x] : fa[x] = find(fa[x]); }
inline int cmp0(const edge& x, const edge& y) { return x.w < y.w; }
inline int check(int x) { return size[find(x)] > sum - can[find(x)]; }
int main() {
std::ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 1; i < n; ++i) {
cin >> a[i].u >> a[i].v >> a[i].w;
}
for (int i = 1; i <= n; ++i) {
cin >> can[i];
sum += can[i];
fa[i] = i;
size[i] = 1;
}
std::sort(a + 1, a + n, cmp0);
for (int i = 1; i <= n; ++i) {
ans += check(i);
}
for (int i = 1; i < n; ++i) {
int x = find(a[i].u), y = find(a[i].v);
ans -= check(x) + check(y);
fa[x] = y;
size[y] += size[x];
can[y] += can[x];
ans += check(x);
if (ans) {
cout << a[i].w << '\n';
return 0;
}
}
cout << a[n - 1].w << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, num;
};
node e[3001];
int n;
int ans = 0;
int father[3001];
int s[3001];
int outlet[3001];
int sum_out = 0;
bool cmp1(node xx, node yy) { return xx.num < yy.num; }
int find(int x) {
if (father[x] != x) {
father[x] = find(father[x]);
}
return father[x];
}
void unionset(int x, int y) {
father[x] = y;
s[y] += s[x];
outlet[y] += outlet[x];
return;
}
int main() {
int i, j, k;
int xx, yy;
cin >> n;
for (i = 1; i <= n - 1; i++) {
cin >> e[i].x >> e[i].y >> e[i].num;
}
sort(e + 1, e + n, cmp1);
for (i = 1; i <= n; i++) {
father[i] = i;
s[i] = 1;
cin >> outlet[i];
sum_out += outlet[i];
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
ans = e[1].num;
for (i = 1; i <= n - 2; i++) {
xx = find(e[i].x);
yy = find(e[i].y);
unionset(xx, yy);
if (sum_out - outlet[yy] < s[yy]) {
break;
} else {
ans = e[i + 1].num;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3010;
int i, j, n, fa[N], sum[N], num[N], tot;
struct E {
int u, v, w;
bool operator<(const E& a) const { return w < a.w; }
} e[N];
int get(int x) {
if (fa[x] == x) return x;
return fa[x] = get(fa[x]);
}
int main() {
scanf("%d", &n);
for (i = 1; i < n; i++) scanf("%d %d %d", &e[i].u, &e[i].v, &e[i].w);
for (i = 1; i <= n; i++) scanf("%d", sum + i);
for (i = 1; i <= n; i++) fa[i] = i, num[i] = 1, tot += sum[i];
sort(e + 1, e + n);
for (i = 1; i < n; i++) {
static int x, y;
for (j = 1; j <= n; j++)
if (fa[j] == j && num[j] > n / 2) break;
if (num[j] > tot - sum[j]) break;
x = get(e[i].u), y = get(e[i].v);
if (x != y) {
num[y] += num[x];
sum[y] += sum[x];
fa[x] = y;
}
}
cout << e[i - 1].w << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3008;
int n, fa[N], sz[N], sum[N], all, ans;
struct Edge {
int u, v, d;
bool operator<(const Edge &b) const { return d < b.d; }
} L[N];
int find(int x) { return x == fa[x] ? fa[x] : fa[x] = find(fa[x]); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d%d", &L[i].u, &L[i].v, &L[i].d);
}
for (int i = 1; i <= n; i++)
scanf("%d", &sum[i]), fa[i] = i, sz[i] = 1, all += sum[i];
sort(L + 1, L + n);
ans = L[1].d;
for (int i = 1; i <= n - 1; i++) {
int u = find(L[i].u), v = find(L[i].v);
sz[u] += sz[v];
sum[u] += sum[v];
fa[v] = u;
if (sz[u] + sum[u] > all) break;
if (L[i].d != L[i + 1].d) ans = L[i + 1].d;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, z;
} e[5010];
bool cmp(const node& a, const node& b) { return a.z < b.z; }
int f[5010];
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int n, bz[5010], sz[5010];
int main() {
cin >> n;
for (int i = 1; i < n; i++) cin >> e[i].x >> e[i].y >> e[i].z;
int tot = 0;
for (int i = 1; i <= n; i++) cin >> sz[i], f[i] = i, tot += sz[i], bz[i] = 1;
sort(e + 1, e + n, cmp);
int ans = e[n - 1].z;
bool flag = true;
for (int i = 1; i < n;) {
int j = i;
for (; i < n && e[i].z == e[j].z; i++) {
int fx = find(e[i].x), fy = find(e[i].y);
f[fy] = fx;
sz[fx] += sz[fy];
bz[fx] += bz[fy];
if (bz[fx] > tot - sz[fx]) flag = false;
}
if (!flag) {
ans = e[j].z;
break;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
struct data {
int x, y, w;
} a[N];
int n, f[N], x[N], sz[N];
bool cmp(const data &p, const data &q) { return p.w < q.w; }
int find(int x) { return f[x] == x ? f[x] : find(f[x]); }
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].w);
sort(a + 1, a + n, cmp);
int sum = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &x[i]);
sum += x[i];
f[i] = i;
sz[i] = 1;
}
bool flag = false;
for (int i = 1; i < n; ++i) {
int fx = find(a[i].x), fy = find(a[i].y);
f[fx] = fy, x[fy] += x[fx], sz[fy] += sz[fx];
if (sz[fy] > sum - x[fy]) {
printf("%d\n", a[i].w);
flag = true;
break;
}
}
if (!flag) puts("0");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct vvert {
int u, v, w;
void read() { scanf("%d %d %d", &u, &v, &w); }
bool operator<(const vvert &e) const { return w < e.w; }
};
int N, X[3010];
vvert vverts[3010];
int rent[3010], skunk[3010], zeta[3010];
int dara(int x) { return x == rent[x] ? x : rent[x] = dara(rent[x]); }
int main() {
scanf("%d", &N);
for (int i = 0; i < N - 1; i++) {
vverts[i].read();
}
sort(vverts, vverts + (N - 1));
for (int i = 1; i <= N; i++) {
scanf("%d", &X[i]);
rent[i] = i;
}
copy(X + 1, X + N + 1, skunk + 1);
fill(zeta + 1, zeta + N + 1, 1);
int skunkx = accumulate(X + 1, X + N + 1, 0);
for (int i = 0; i < N - 1; i++) {
int a = dara(vverts[i].u), b = dara(vverts[i].v);
if (a != b) {
rent[a] = b;
zeta[b] += zeta[a];
skunk[b] += skunk[a];
if (zeta[b] > skunkx - skunk[b]) {
printf("%d\n", vverts[i].w);
return 0;
}
}
}
printf("0");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x[5000], sum, fa[5000], size[5000];
struct node {
int u, v, 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].v, &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].v);
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;
struct edge {
int fr, to, val;
bool operator<(const edge &o) const { return val < o.val; }
} e[2000100];
int n, m, x, y, z, fa[2000100], cnt[2000100], sum, siz[2000100], ans, flag = 1;
int gf(int u) { return u == fa[u] ? u : fa[u] = gf(fa[u]); }
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) scanf("%d %d %d", &e[i].fr, &e[i].to, &e[i].val);
for (int i = 1; i <= n; i++)
scanf("%d", &cnt[i]), sum += cnt[i], fa[i] = i, siz[i] = 1;
sort(e + 1, e + n);
for (int i = 1; i < n; i++) {
if (flag) ans = e[i].val;
int f1 = gf(e[i].fr), f2 = gf(e[i].to);
fa[f1] = f2, siz[f2] += siz[f1], cnt[f2] += cnt[f1];
if (siz[f2] > sum - cnt[f2]) flag = 0;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <typename T>
void chmin(T &t, const T &f) {
if (t > f) t = f;
}
template <typename T>
void chmax(T &t, const T &f) {
if (t < f) t = f;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
namespace MF {
const int LIM_N = 6005;
const int LIM_M = 10000005;
const int wEPS = 0;
const int wINF = 1001001001;
int n, m, ptr[LIM_N], nxt[LIM_M * 2], zu[LIM_M * 2];
int capa[LIM_M * 2], tof;
int lev[LIM_N], see[LIM_N], que[LIM_N], *qb, *qe;
void init(int _n) {
n = _n;
m = 0;
fill(ptr, ptr + n, -1);
}
void ae(int u, int v, int w0, int w1 = 0) {
nxt[m] = ptr[u];
ptr[u] = m;
zu[m] = v;
capa[m] = w0;
++m;
nxt[m] = ptr[v];
ptr[v] = m;
zu[m] = u;
capa[m] = w1;
++m;
}
int augment(int src, int ink, int flo) {
if (src == ink) return flo;
for (int &i = see[src]; ~i; i = nxt[i])
if (capa[i] > wEPS && lev[src] < lev[zu[i]]) {
const int f = augment(zu[i], ink, min(flo, capa[i]));
if (f > wEPS) {
capa[i] -= f;
capa[i ^ 1] += f;
return f;
}
}
return 0;
}
bool solve(int src, int ink, int flo = wINF) {
for (tof = 0; tof + wEPS < flo;) {
qb = qe = que;
fill(lev, lev + n, -1);
for (lev[ *qe++ = src] = 0, see[src] = ptr[src]; qb != qe;) {
const int u = *qb++;
for (int i = ptr[u]; ~i; i = nxt[i])
if (capa[i] > wEPS) {
const int v = zu[i];
if (lev[v] == -1) {
lev[ *qe++ = v] = lev[u] + 1;
see[v] = ptr[v];
if (v == ink) goto au;
}
}
}
return false;
au:
for (int f; (f = augment(src, ink, flo - tof)) > wEPS; tof += f)
;
}
return true;
}
} // namespace MF
int uf[3010];
int root(int u) { return (uf[u] < 0) ? u : (uf[u] = root(uf[u])); }
void conn(int u, int v) {
u = root(u);
v = root(v);
if (u == v) return;
if (uf[u] > uf[v]) swap(u, v);
uf[u] += uf[v];
uf[v] = u;
}
int N;
int A[3010], B[3010], C[3010];
int X[3010];
int numCompos;
int us[3010];
int ids[3010];
int sumX[3010];
bool check(int threshold) {
fill(uf, uf + N, -1);
for (int i = 0; i < N - 1; ++i) {
if (C[i] < threshold) {
conn(A[i], B[i]);
}
}
numCompos = 0;
for (int u = 0; u < N; ++u)
if (uf[u] < 0) {
us[numCompos] = u;
ids[u] = numCompos++;
}
fill(sumX, sumX + numCompos, 0);
for (int u = 0; u < N; ++u) {
chmin(sumX[ids[root(u)]] += X[u], N);
}
MF::init(2 + numCompos + numCompos);
for (int a = 0; a < numCompos; ++a) {
MF::ae(0, 2 + a, -uf[us[a]]);
MF::ae(2 + numCompos + a, 1, sumX[a]);
}
for (int a = 0; a < numCompos; ++a)
for (int b = 0; b < numCompos; ++b)
if (a != b) {
MF::ae(2 + a, 2 + numCompos + b, -uf[us[a]]);
}
const bool res = MF::solve(0, 1, N);
return res;
}
int csLen;
int cs[3010];
int main() {
for (; ~scanf("%d", &N);) {
for (int i = 0; i < N - 1; ++i) {
A[i] = in() - 1;
B[i] = in() - 1;
C[i] = in();
}
for (int u = 0; u < N; ++u) {
X[u] = in();
}
copy(C, C + N - 1, cs);
sort(cs, cs + N - 1);
csLen = unique(cs, cs + N - 1) - cs;
int lo = 0, ho = csLen;
for (; lo + 1 < ho;) {
const int mo = (lo + ho) / 2;
(check(cs[mo]) ? lo : ho) = mo;
}
printf("%d\n", cs[lo]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int n;
vector<pair<int, int> > edge[N];
int c[N];
int fa[N];
int cnt[N], sigma[N];
int find(int u) { return u == fa[u] ? u : fa[u] = find(fa[u]); }
void merge(int u, int v) { fa[v] = u; }
void dfs(int u, int bar, int fa = -1) {
for (int i = 0; i < (int)edge[u].size(); ++i) {
int v = edge[u][i].first, d = edge[u][i].second;
if (v == fa) {
continue;
}
dfs(v, bar, u);
if (d < bar) {
merge(find(v), find(u));
}
}
}
bool check(int bar) {
for (int i = 0; i < n; ++i) {
fa[i] = i;
}
dfs(0, bar);
for (int i = 0; i < n; ++i) {
cnt[i] = 0, sigma[i] = 0;
}
for (int i = 0; i < n; ++i) {
++cnt[find(i)], sigma[find(i)] += c[i];
}
int maxcnt = find(0), sum = 0;
for (int i = 0; i < n; ++i) {
if (find(i) == i) {
if (cnt[i] > cnt[maxcnt]) {
maxcnt = i;
}
sum += sigma[i];
}
}
return sum - sigma[maxcnt] >= cnt[maxcnt];
}
int main() {
scanf("%d", &n);
if (n == 1) {
printf("0\n");
return 0;
}
vector<int> val;
for (int i = 1; i < n; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
--u, --v;
edge[u].push_back(make_pair(v, w));
edge[v].push_back(make_pair(u, w));
val.push_back(w);
}
sort(val.begin(), val.end());
val.erase(unique(val.begin(), val.end()), val.end());
for (int i = 0; i < n; ++i) {
scanf("%d", c + i);
}
int l = 0, r = (int)val.size() - 1;
while (l < r) {
int m = l + r + 1 >> 1;
if (check(val[m])) {
l = m;
} else {
r = m - 1;
}
}
printf("%d\n", val[l]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 3000 + 10;
constexpr int LG = 20;
constexpr int MOD = 1e9 + 7;
constexpr int MOD2 = 1e9 + 9;
int n, par[N], u, v, w, sz[N], sum[N], ans, sumall;
vector<pair<int, pair<int, int>>> e;
int get_par(int v) {
if (par[v] == v) return v;
return par[v] = get_par(par[v]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> u >> v >> w;
e.push_back({w, {u, v}});
}
for (int i = 1; i <= n; i++)
cin >> sum[i], par[i] = i, sz[i] = 1, sumall += sum[i];
sort(e.begin(), e.end());
for (int i = 0; i < (int)e.size(); i++) {
u = e[i].second.first;
v = e[i].second.second;
par[u] = get_par(u);
par[v] = get_par(v);
sum[par[u]] += sum[par[v]];
sz[par[u]] += sz[par[v]];
par[par[v]] = par[u];
ans = e[i].first;
if (sz[par[u]] >= (n + 1) / 2)
if (sz[par[u]] > sumall - sum[par[u]]) break;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 3e3 + 9;
int n, ans;
pair<int, pair<int, int> > edge[MAX_N];
int par[MAX_N];
int len[MAX_N];
int val[MAX_N];
int sum;
int root(int v) { return par[v] == v ? v : par[v] = root(par[v]); }
int main() {
ios::sync_with_stdio(false), cin.tie(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--;
}
sort(edge, edge + n - 1);
for (int i = 0; i < n; i++) {
par[i] = i;
len[i] = 1;
cin >> val[i];
sum += val[i];
}
ans = edge[0].first;
for (int i = 0; i < n; i++) {
int v = edge[i].second.first;
int u = edge[i].second.second;
val[root(u)] += val[root(v)];
len[root(u)] += len[root(v)];
par[root(v)] = root(u);
if (sum - val[root(v)] < len[root(v)]) break;
ans = edge[i + 1].first;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
struct edge {
int u, v, w;
} e[N];
int fa[N], siz[N], x[N], s;
inline int findf(int x) { return fa[x] == x ? x : fa[x] = findf(fa[x]); }
inline bool cmp(const edge& a, const edge& b) { return a.w < b.w; }
int main() {
scanf("%d", &n);
for (int i = 1; i < n; 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]), fa[i] = i, siz[i] = 1, s += x[i];
sort(e + 1, e + n, cmp);
for (int i = 1; i < n; i++) {
int fx = findf(e[i].u), fy = findf(e[i].v);
if (fx == fy) continue;
fa[fx] = fy, siz[fy] += siz[fx], x[fy] += x[fx];
if (siz[fy] > s - x[fy]) {
printf("%d", e[i].w);
return 0;
}
}
printf("0");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long counter = 0;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
if (y - x >= 2) counter++;
}
cout << counter;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n][2];
int i, j, x = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < 2; j++) {
cin >> a[i][j];
}
if (a[i][0] + 1 < a[i][1]) {
x++;
}
}
cout << x;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, ans = 0;
int main() {
cin >> n;
for (int i = 0; i < (n); i++) {
int p, q;
cin >> p >> q;
if (q - p >= 2) ans++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p[105][105], ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
cin >> p[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (p[i][j + 1] - p[i][j] >= 2) ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x = 0;
cin >> n;
int a[n][2];
for (int i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][1];
}
for (int i = 0; i < n; i++) {
if (a[i][1] - a[i][0] > 1) x++;
}
cout << x;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, q;
int cont = 0;
cin >> n;
while (n--) {
cin >> p >> q;
if ((q - p) >= 2) {
cont++;
}
}
cout << cont << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int a[n][2];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
scanf("%d", &a[i][j]);
}
}
int c = 0, k = 0, m = 0;
for (int i = 0; i < n; i++) {
if (a[i][0] == a[i][1])
c++;
else if (a[i][0] == a[i][1] - 1)
m++;
else
k++;
}
if (c == n || m == n)
printf("0");
else
printf("%d", k);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int low[n], high[n];
for (int i = 0; i < n; i++) {
cin >> low[i] >> high[i];
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (high[i] - low[i] >= 2) {
ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
int a = abs(x - y);
if (a >= 2) ans++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m = 0;
int p[101];
int q[101];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i] >> q[i];
}
for (int i = 0; i < n; i++) {
if ((q[i] - p[i]) >= 2) {
m++;
}
}
cout << m;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, c, sum = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> p >> c;
if ((c - p) >= 2) sum++;
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, q, s, i;
cin >> n;
s = 0;
for (i = 1; i <= n; i++) {
cin >> p >> q;
if ((q - p) >= 2) s++;
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int number, i;
int result = 0;
scanf("%d", &number);
for (i = 0; i < number; i++) {
int people, size;
scanf("%d %d", &people, &size);
if ((size - people) >= 2) result = result + 1;
}
printf("%d", result);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n * 2];
for (int i = 0; i < n * 2; i++) {
cin >> a[i];
}
int room = 0;
for (int i = 0; i < n * 2; i++) {
if (i % 2 == 0) {
if (a[i + 1] - a[i] >= 2) {
room++;
}
}
}
cout << room;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a, b;
int total = 0;
while (n > 0) {
cin >> a >> b;
if (b - a >= 2) total++;
n--;
}
cout << total;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, q, ans = 0;
cin >> n;
while (n--) {
cin >> p >> q;
if (p < q && (abs(p - q) >= 2)) ans++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, total = 0;
cin >> n;
while (n--) {
int a, b;
cin >> a >> b;
if (b - a >= 2) total++;
}
cout << total << endl;
return 0;
}
|
#include <bits/stdc++.h>
struct room {
int p;
int s;
};
int main() {
int n;
scanf("%d", &n);
struct room a[n];
int i;
for (i = 0; i < n; i++) {
scanf("%d", &a[i].p);
scanf("%d", &a[i].s);
}
int sum = 0;
for (i = 0; i < n; i++) {
if ((a[i].p) + 1 < a[i].s) {
sum = sum + 1;
}
}
printf("%d", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char str[110];
while (scanf("%d", &n) != EOF) {
int res = 0;
for (int i = 0; i < n; i++) {
int p, q;
scanf("%d %d", &p, &q);
if (p < q - 1) res++;
}
printf("%d\n", res);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r = 0;
cin >> n;
for (n; n >= 1; n--) {
int a, b;
cin >> a >> b;
if ((b - a) >= 2) r++;
}
cout << r << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, p, q, counter = 0;
cin >> a;
while (a--) {
cin >> p >> q;
if (p + 1 < q) counter++;
}
cout << counter;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, p, q, c = 0;
while (cin >> n) {
c = 0;
for (i = 0; i < n; i++) {
cin >> p >> q;
if (q - p >= 2) c++;
}
cout << c << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c = 0;
int n;
cin >> n;
int arr[n], ar2[n];
for (int i = 0; i < n; i++) {
cin >> arr[i] >> ar2[i];
if (arr[i] < ar2[i] - 1) c++;
}
cout << c;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int i, count = 0;
int p, q, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &p, &q);
if ((q - p) >= 2) {
count++;
}
}
printf("%d", count);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, k = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a >> b;
if (b - 2 >= a) k++;
}
cout << k << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, a, b, count = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a >> b;
if (b - a >= 2) count++;
}
cout << count;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int p, q;
scanf("%d %d", &p, &q);
if ((q - p) >= 2) ans++;
}
printf("%d", ans);
return (0);
}
|
#include <bits/stdc++.h>
int main() {
int n, i, j, sum = 0;
scanf("%d", &n);
int a[n][2];
for (i = 0; i < n; i++) {
for (j = 0; j < 2; j++) scanf("%d", &a[i][j]);
}
for (i = 0; i < n; i++) {
if ((a[i][1] - a[i][0]) >= 2) sum++;
}
printf("%d \n", sum);
}
|
#include <bits/stdc++.h>
int main() {
int n, i, j, k, count = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d %d", &j, &k);
if ((k - j) >= 2) {
count++;
}
}
printf("%d\n", count);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n];
int c = 0;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
if (b[i] - a[i] >= 2) c++;
}
cout << c;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, q, count = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p >> q;
if (q - p >= 2) count++;
}
cout << count;
}
|
#include <bits/stdc++.h>
int main() {
int n, p, q, i, j, t = 1, count = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &p, &q);
if (p == q || p == (q - 1)) {
t = 0;
}
if (p < (q - 1)) {
t = 1;
count++;
}
}
printf("%d", count);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.