text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > graph[(long long int)200006];
bool arr[(long long int)200006];
long long int p;
long long int i, n, m, x, y, k, w;
bool cmp(pair<long long int, pair<long long int, long long int> > a,
pair<long long int, pair<long long int, long long int> > b) {
return (a.first < b.first);
}
class MST {
public:
long long int parent[(long long int)200006];
public:
MST() {
for (i = 0; i <= n; i++) {
parent[i] = i;
}
}
public:
long long int findParent(long long int a) {
if (parent[a] != a) {
return parent[a] = findParent(parent[a]);
}
return a;
}
public:
bool unionn(pair<long long int, pair<long long int, long long int> > edge) {
long long int a = edge.second.first;
long long int b = edge.second.second;
long long int p1 = findParent(a);
long long int p2 = findParent(b);
if (p1 != p2) {
if (arr[p1]) {
parent[p2] = p1;
} else {
parent[p1] = p2;
}
if (arr[p1] && arr[p2]) {
p--;
}
if (p == 1) {
for (i = 0; i < k; i++) {
cout << edge.first << " ";
}
exit(0);
}
return true;
} else {
return false;
}
}
};
int main() {
cin >> n >> m >> k;
p = k;
for (i = 0; i < k; i++) {
cin >> x;
arr[x] = true;
}
vector<pair<long long int, pair<long long int, long long int> > > vc;
for (i = 0; i < m; i++) {
cin >> x >> y >> w;
graph[x].push_back({y, w});
graph[y].push_back({x, w});
vc.push_back({w, {x, y}});
}
sort(vc.begin(), vc.end(), cmp);
MST tree;
for (i = 0; i < m; i++) {
tree.unionn(vc[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
struct node {
int u, v, w;
};
bool cmp(node a1, node b1) { return a1.w < b1.w; }
node edg[maxn];
long long n, m, siz[maxn], ufs[maxn], k;
int find(int u) {
if (ufs[u] == u) return u;
return ufs[u] = find(ufs[u]);
}
void join(int a, int b) {
siz[find(a)] += siz[find(b)];
ufs[find(b)] = find(a);
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int u;
scanf("%d", &u);
siz[u] = 1;
}
for (int i = 1; i <= n; i++) ufs[i] = i;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &edg[i].u, &edg[i].v, &edg[i].w);
}
sort(edg + 1, edg + 1 + m, cmp);
for (int i = 1; i <= m; i++) {
int u = edg[i].u, v = edg[i].v, w = edg[i].w;
if (find(u) != find(v)) {
join(u, v);
if (siz[find(u)] == k) {
for (int i = 1; i <= k; i++) cout << w << ' ';
return 0;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const int mod = 1e9 + 7;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
int n, m, k, X[maxn], sp[maxn], par[maxn], mx[maxn];
vector<pair<int, pair<long long, long long> > > edges;
int root(int v) { return v == par[v] ? v : par[v] = root(par[v]); }
void unite(int a, int b, int w) {
if ((a = root(a)) == (b = root(b))) return;
if (sp[a] && sp[b]) mx[a] = w;
mx[a] = max(mx[a], mx[b]);
par[b] = a;
sp[a] |= sp[b];
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int a;
cin >> a;
X[i] = a;
sp[a] = 1;
}
for (int i = 1; i <= n; i++) par[i] = i;
for (int i = 0; i < m; i++) {
int a, b, w;
cin >> a >> b >> w;
edges.push_back({w, {a, b}});
}
sort(edges.begin(), edges.end());
for (auto edge : edges)
unite(edge.second.first, edge.second.second, edge.first);
for (int i = 1; i <= k; i++) cout << mx[root(i)] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int INF = 1e9 + 7;
int sp[N], p[N];
int n, m, k, ex;
struct edge {
int v, u, w;
};
edge e[N];
inline bool cmp(edge a, edge b) { return a.w < b.w; }
int findp(int v) {
if (p[v] == v) return v;
return p[v] = findp(p[v]);
}
void unite(int id) {
int v = findp(e[id].v), u = findp(e[id].u), w = e[id].w;
if (v != u) {
if (sp[v] == 1 && sp[u] == 1) {
ex--;
if (ex == 1) {
for (int i = 1; i <= k; i++) printf("%d ", w);
exit(0);
}
}
if (sp[v] == 1)
p[u] = v;
else
p[v] = u;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
ex = k;
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
sp[x] = 1;
}
for (int i = 1; i <= m; i++) scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
sort(e + 1, e + m + 1, cmp);
for (int i = 1; i <= m; i++) unite(i);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 5;
const int maxm = (int)1e5 + 5;
int n, m, k;
int cnt[maxn];
struct edge {
int u, v, w;
void read() { scanf("%d%d%d", &u, &v, &w); }
bool operator<(const edge &rhs) const { return w < rhs.w; }
} e[maxm];
int ans;
int lab[maxn];
int root(int x) { return lab[x] < 0 ? x : lab[x] = root(lab[x]); }
void unite(int u, int v, int w) {
u = root(u);
v = root(v);
if (u != v) {
if (lab[u] > lab[v]) {
swap(u, v);
}
if (cnt[u] && cnt[v]) {
ans = w;
}
lab[u] += lab[v];
lab[v] = u;
cnt[u] += cnt[v];
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; ++i) {
int x;
scanf("%d", &x);
cnt[x]++;
}
for (int i = 1; i <= m; ++i) {
e[i].read();
}
memset(lab, -1, sizeof(lab));
sort(e + 1, e + m + 1);
for (int i = 1; i <= m; ++i) {
unite(e[i].u, e[i].v, e[i].w);
}
for (int i = 1; i <= k; ++i) {
printf("%d ", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> operator+(const pair<long long, long long>& a,
const pair<long long, long long>& b) {
return make_pair(a.first + b.first, a.second + b.second);
}
pair<long long, long long> operator-(const pair<long long, long long>& a,
const pair<long long, long long>& b) {
return make_pair(a.first - b.first, a.second - b.second);
}
pair<long long, long long> operator*(const pair<long long, long long>& a,
const pair<long long, long long>& b) {
return make_pair(a.first * b.first, a.second * b.second);
}
pair<long long, long long> operator%(const pair<long long, long long>& a,
const pair<long long, long long>& b) {
return make_pair(a.first % b.first, a.second % b.second);
}
template <class T>
inline T lowbit(T x) {
return x & (-x);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 1e5 + 10;
int n, m, k, v[N];
bool flg[N];
struct edge {
int u, v, w;
} e[N];
bool comp(edge a, edge b) { return a.w < b.w; };
struct ufset {
int par[N], siz[N], cnt[N], ans[N];
void init(int n) {
for (int i = (1); i <= (n); i++) par[i] = i, siz[i] = 1, cnt[i] = flg[i];
}
int find(int u) { return par[u] == u ? u : par[u] = find(par[u]); }
void unite(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return;
par[u] = v;
siz[v] += siz[u];
cnt[v] += cnt[u];
}
bool same(int u, int v) { return find(u) == find(v); }
} s, t;
int main() {
n = read();
m = read();
k = read();
for (int i = (1); i <= (k); i++) flg[v[i] = read()] = 1;
for (int i = (1); i <= (m); i++) {
e[i].u = read();
e[i].v = read();
e[i].w = read();
}
s.init(n);
t.init(n);
sort(e + 1, e + 1 + m, comp);
bool b = 0;
for (int i = (1); i <= (m); i++) {
int u = e[i].u, v = e[i].v;
if (s.same(u, v)) continue;
if (b) {
if (s.cnt[s.find(u)] == k)
t.ans[t.find(v)] = e[i].w;
else if (s.cnt[s.find(v)] == k)
t.ans[t.find(u)] = e[i].w;
else
t.unite(u, v);
} else if (s.cnt[s.find(u)] + s.cnt[s.find(v)] == k) {
b = 1;
t.ans[t.find(u)] = t.ans[t.find(v)] = e[i].w;
}
s.unite(u, v);
if (!b) t.unite(u, v);
if (s.siz[s.find(u)] == n) break;
}
for (int i = (1); i <= (k); i++) printf("%d ", t.ans[t.find(v[i])]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 2 * acos(0.0);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
vector<vector<long long>> graph(n + 1);
map<pair<long long, long long>, long long> edge;
vector<long long> x(n + 1, 0);
for (long long i = 0; i < k; i++) {
cin >> x[i];
x[i]--;
}
for (long long i = 0; i < m; i++) {
long long a, b, c;
cin >> a >> b >> c;
a--;
b--;
if (a == b) continue;
if (edge.count(make_pair(a, b)) != 1) {
graph[a].push_back(b);
graph[b].push_back(a);
edge[make_pair(a, b)] = c;
edge[make_pair(b, a)] = c;
} else {
edge[make_pair(a, b)] = min(edge[make_pair(a, b)], c);
edge[make_pair(b, a)] = edge[make_pair(a, b)];
}
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
que;
vector<long long> dis(n + 1, 10000000000);
que.push(make_pair(0, x[0]));
while (!que.empty()) {
long long u = que.top().second;
long long d = que.top().first;
que.pop();
if (dis[u] == 10000000000) {
dis[u] = d;
for (auto i : graph[u]) {
int ans = max(dis[u], edge[make_pair(u, i)]);
que.push(make_pair(ans, i));
}
}
}
long long md = 0;
for (long long i = 0; i < k; i++) {
if (md < dis[x[i]]) md = dis[x[i]];
}
for (long long i = 0; i < k; i++) cout << md << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200025;
int vis[MAX_N];
int fa[MAX_N], eid = 0;
struct node {
int u, v, len;
bool operator<(const node other) const { return len < other.len; }
} e[MAX_N], arr[MAX_N];
int get(int x) {
if (fa[x] == x) return x;
return fa[x] = get(fa[x]);
}
void Merge(int x, int y) {
x = get(x), y = get(y);
if (x != y) {
fa[x] = y;
}
}
int main() {
int n, m, k, a, k_;
scanf("%d%d%d", &n, &m, &k);
k_ = k;
for (int i = 1; i <= k; ++i) {
scanf("%d", &a);
vis[a] = true;
}
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &arr[i].u, &arr[i].v, &arr[i].len);
if (arr[i].u == arr[i].v) continue;
e[eid].u = arr[i].u;
e[eid].v = arr[i].v;
e[eid++].len = arr[i].len;
}
for (int i = 1; i <= n; ++i) fa[i] = i;
sort(e, e + eid);
int mst = n, ans = -1;
for (int i = 0; i < eid; i++) {
int x = get(e[i].u), y = get(e[i].v);
if (x == y) {
continue;
} else {
vis[y] += vis[x];
Merge(x, y);
ans = e[i].len;
if (vis[y] == k) break;
}
}
for (int i = 1; i <= k_; ++i)
i == k_ ? printf("%d\n", ans) : printf("%d ", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long par[N], spec[N];
pair<long long, long long> siz[N];
long long root(long long x) {
while (par[x] != -1) x = par[x];
return x;
}
void merge(long long x, long long y) {
x = root(x);
y = root(y);
if (x == y) return;
if (siz[y] < siz[x]) swap(x, y);
siz[y].first += siz[x].first;
siz[y].second += siz[x].second;
par[x] = y;
}
vector<pair<long long, pair<long long, long long> > > edges;
void solve() {
memset(par, -1, sizeof par);
long long n, m, k;
cin >> n >> m >> k;
for (long long i = 0; i < k; ++i) {
long long x;
cin >> x;
spec[x] = 1;
}
for (long long i = 0; i < N; ++i) {
if (spec[i])
siz[i] = make_pair(1, 1);
else
siz[i] = make_pair(1, 0);
}
for (long long i = 0; i < m; ++i) {
long long x, y, w;
cin >> x >> y >> w;
edges.push_back(make_pair(w, make_pair(x, y)));
}
long long ans = -1;
sort(edges.begin(), edges.end());
for (auto i : edges) {
long long x = i.second.first;
long long y = i.second.second;
if (root(x) != root(y)) {
merge(x, y);
if (siz[root(x)].second == k) {
ans = i.first;
break;
}
}
}
for (long long i = 0; i < k; ++i) cout << ans << ' ';
cout << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class T2>
inline int chkmax(T &x, const T2 &y) {
return x < y ? x = y, 1 : 0;
}
template <class T, class T2>
inline int chkmin(T &x, const T2 &y) {
return x > y ? x = y, 1 : 0;
}
const int MAXN = (1 << 20);
struct dsu {
int sz;
vector<int> par, psz;
void init(int n) {
sz = n;
par.assign(sz + 1, 0);
psz.assign(sz + 1, 0);
for (int i = 0; i <= sz; i++) par[i] = i, psz[i] = 1;
}
int root(int u) { return par[u] = ((u == par[u]) ? u : root(par[u])); }
bool connected(int x, int y) { return root(x) == root(y); }
void unite(int x, int y) {
x = root(x), y = root(y);
if (x == y) return;
if (psz[x] > psz[y]) swap(x, y);
par[x] = y, psz[y] += psz[x];
}
};
int n, m, k;
vector<pair<int, pair<int, int> > > ed;
int answer[MAXN];
vector<int> special;
bool sp[MAXN];
void read() {
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int v;
cin >> v;
special.push_back(v);
sp[v] = 1;
}
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
ed.push_back({w, {u, v}});
}
}
dsu mst_d;
vector<pair<int, int> > adj[MAXN];
void add_edge(int u, int v, int w) {
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
int has_ver[MAXN];
int cnt[MAXN];
pair<int, pair<int, int> > best_edge = {-1, {-1, -1}};
void pre_dfs(int u, int pr) {
has_ver[u] = sp[u] ? u : -1;
cnt[u] = has_ver[u] != -1;
for (auto v : adj[u])
if (v.first != pr) {
pre_dfs(v.first, u);
cnt[u] += cnt[v.first];
if (has_ver[v.first] != -1) {
has_ver[u] = has_ver[v.first];
if (cnt[v.first] != k)
chkmax(best_edge, make_pair(v.second, make_pair(u, v.first)));
}
}
}
bool vis[MAXN];
void solve() {
mst_d.init(n);
sort(ed.begin(), ed.end());
for (auto e : ed)
if (!mst_d.connected(e.second.first, e.second.second)) {
mst_d.unite(e.second.first, e.second.second);
add_edge(e.second.first, e.second.second, e.first);
}
pre_dfs(1, 1);
for (int i = 0; i < k; i++) cout << best_edge.first << " ";
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fa[100005], b[100005], n, m, k;
struct node {
int x, y, v;
} a[100005];
inline bool cmp(node x, node y) { return x.v < y.v; }
inline int get(int x) {
if (fa[x] == x) return x;
return fa[x] = get(fa[x]);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
int x;
for (int i = 1; i <= k; i++) scanf("%d", &x), b[x] = 1;
for (int i = 1; i <= m; i++) scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].v);
sort(a + 1, a + 1 + m, cmp);
for (int i = 1; i <= n; i++) fa[i] = i;
int ans;
for (int i = 1; i <= m; i++) {
int x = get(a[i].x), y = get(a[i].y);
if (x == y) continue;
b[x] += b[y];
fa[y] = x;
if (b[x] == k) {
ans = a[i].v;
break;
}
}
for (int i = 1; i <= k; i++) printf("%d ", ans);
}
|
#include <bits/stdc++.h>
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T lcm(T a, T b) {
return a / __gcd(a, b) * b;
}
template <class T>
T minimize(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
T maximize(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long mod = 1e9 + 7, oo = 1e12, N = 2e5 + 5;
using namespace std;
long long n, m, n_special;
long long res;
long long root[N];
bool special[N];
vector<pair<long long, pair<long long, long long> > > edge;
long long getroot(long long u) {
if (!root[u]) return u;
root[u] = getroot(root[u]);
return root[u];
}
void kruskal() {
sort((edge).begin(), (edge).end());
for (__typeof((edge).begin()) it = (edge).begin(); it != (edge).end(); ++it) {
long long u = getroot(it->second.first);
long long v = getroot(it->second.second);
if (u == v) continue;
root[u] = v;
if (special[u] && special[v])
if (res < (it->first)) res = (it->first);
if (special[u] || special[v]) special[u] = special[v] = 1;
}
for (__typeof(n_special) i = (1); i <= (n_special); ++i) cout << res << ' ';
cout << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n >> m >> n_special;
for (__typeof(n_special) i = (1); i <= (n_special); ++i) {
long long x;
cin >> x;
special[x] = 1;
}
while (m--) {
long long u, v, c;
cin >> u >> v >> c;
edge.push_back(pair<long long, pair<long long, long long> >(
c, pair<long long, long long>(u, v)));
}
kruskal();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
vector<pair<int, int>> g[N];
bool used[N];
void dfs(int u, int b) {
used[u] = 1;
for (auto &[v, w] : g[u]) {
if (w <= b && !used[v]) {
dfs(v, b);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
int n, m, k;
cin >> n >> m >> k;
vector<int> kek(k);
for (int i = 0; i < k; ++i) {
cin >> kek[i];
--kek[i];
}
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
--u, --v;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
int l = 0, r = 1e9 + 2;
while (r - l > 1) {
int m = (l + r) >> 1;
for (int i = 0; i < n; ++i) {
used[i] = 0;
}
dfs(kek[0], m);
bool bad = false;
for (auto x : kek) {
if (!used[x]) {
bad = true;
break;
}
}
if (!bad) {
r = m;
} else {
l = m;
}
}
for (int i = 0; i < k; ++i) {
cout << r << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MaxN = 1 + 1e5;
long long n, a[MaxN], m, k, x, t, y, z, root[MaxN], nt, query, vis[MaxN], ma,
f[MaxN], d[MaxN];
vector<pair<long long, long long> > q[MaxN];
template <typename T>
void read(T& t) {
t = 0;
char ch = getchar();
int f = 1;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while (isdigit(ch));
t *= f;
}
struct Edge {
long long u, v, len;
Edge(long long _u = 0, long long _v = 0, long long _len = 0)
: u(_u), v(_v), len(_len) {}
bool operator<(const Edge& op) const { return len < op.len; }
} e[MaxN];
long long getRoot(long long u) {
if (u == root[u]) return u;
return root[u] = getRoot(root[u]);
}
void DFS(long long u) {
vis[u] = 1;
for (auto i : q[u])
if (!vis[i.first]) {
f[i.first] = max(f[u], i.second);
if (d[i.first]) ma = max(ma, f[i.first]);
DFS(i.first);
}
}
void InOut() {
freopen(
"ABC"
".inp",
"r", stdin);
freopen(
"ABC"
".out",
"w", stdout);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
read(n);
read(m);
read(t);
for (int i = 0; i < t; ++i) {
read(x);
x--;
d[x] = 1;
query = x;
}
for (int i = 0; i < m; ++i) {
read(x);
read(y);
read(z);
x--;
y--;
e[i] = Edge(x, y, z);
}
sort(e, e + m);
for (int i = 0; i < n; ++i) root[i] = i;
for (int i = 0; i < m; ++i) {
long long u = e[i].u, v = e[i].v, len = e[i].len;
long long ru = getRoot(u), rv = getRoot(v);
if (ru == rv) continue;
root[ru] = rv;
q[u].push_back({v, len});
q[v].push_back({u, len});
}
DFS(query);
for (int i = 0; i < t; ++i) cout << ma << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct vode {
int x;
int y;
int z;
} a[100005];
int check[100005];
int father[100005];
int Find(int x) {
if (father[x] != x) {
father[x] = Find(father[x]);
}
return father[x];
}
bool cmp(vode s1, vode s2) { return s1.z < s2.z; }
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
int p;
scanf("%d", &p);
check[p] = 1;
}
for (int i = 1; i <= n; i++) father[i] = i;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].z);
}
sort(a + 1, a + 1 + m, cmp);
int ans;
for (int i = 1; i <= m; i++) {
int now1 = Find(a[i].x);
int now2 = Find(a[i].y);
if (now1 == now2) continue;
father[now1] = now2;
if (check[now1] && check[now2]) ans = a[i].z;
if (check[now1]) check[now2] |= 1;
}
for (int i = 1; i <= k; i++) printf("%d ", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, m, k, par[maxn], ans[maxn];
bool arr[maxn];
pair<int, pair<int, int>> e[maxn];
int get_path(int v) { return par[v] < 0 ? v : (par[v] = get_path(par[v])); }
void merge(int v, int u) {
if ((v = get_path(v)) == (u = get_path(u))) return;
if (par[v] < par[u]) swap(v, u);
par[u] += par[v];
par[v] = u;
arr[u] = arr[u] || arr[v];
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
arr[x] = 1;
}
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
e[i] = {w, {u, v}};
}
sort(e, e + m);
int ind;
memset(par, -1, sizeof(par));
for (int i = 0; i < m; i++) {
int u = e[i].second.first, v = e[i].second.second;
if ((u = get_path(u)) != (v = get_path(v)) && arr[u] && arr[v]) {
ind = i;
}
merge(u, v);
}
for (int i = 0; i < k; i++) {
cout << e[ind].first << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3ffffff;
const long long LL_INF = 0x3fffffffffffffffll;
const int MOD = 1e9 + 7;
const long long HASH_KEY = 6151;
const long long HASH_MOD = 1610612741;
const int MAXN = 1e5 + 3;
int fa[MAXN];
tuple<int, int, int> edges[MAXN];
bool special[MAXN];
int gf(int x) { return fa[x] == x ? x : fa[x] = gf(fa[x]); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
int n, m, k;
cin >> n >> m >> k;
iota(fa, fa + n, 0);
for (int i = int(0); i < int(k); ++i) {
int x;
cin >> x;
special[x - 1] = true;
}
for (int i = int(0); i < int(m); ++i) {
int u, v, w;
cin >> u >> v >> w;
edges[i] = {w, u - 1, v - 1};
}
sort(edges, edges + m);
int con = 1;
for (int i = int(0); i < int(m); ++i) {
int u, v, w;
tie(w, u, v) = edges[i];
u = gf(u);
v = gf(v);
if (u != v) {
fa[u] = v;
if (special[u] && special[v]) {
++con;
if (con == k) {
for (int _ = int(0); _ < int(k); ++_) {
cout << w << " ";
}
break;
}
}
special[v] |= special[u];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > gr[100002];
int n, m, k;
int sv[100002];
bool sp[100002];
bool v[100002];
int nr;
void dfs(int u, int mx) {
if (sp[u]) nr++;
v[u] = 1;
for (auto e : gr[u])
if (!v[e.first] && e.second <= mx) dfs(e.first, mx);
}
int main() {
cin >> n >> m >> k;
int mxc = -1;
for (int i = 1; i <= k; i++) {
cin >> sv[i];
sp[sv[i]] = 1;
}
for (int i = 1; i <= m; i++) {
int u, v, c;
cin >> u >> v >> c;
gr[u].push_back({v, c});
gr[v].push_back({u, c});
mxc = max(mxc, c);
}
int l = 1, r = mxc, mid;
while (l < r) {
mid = (l + r) / 2;
memset(v, 0, sizeof(v));
nr = 0;
dfs(sv[1], mid);
if (nr < k)
l = mid + 1;
else
r = mid;
}
for (int i = 1; i <= k; i++) cout << l << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
struct node {
int u, v, w;
} f[N];
bool cmp(node x, node y) { return x.w < y.w; }
int lab[N], sz[N];
int get(int u) { return lab[u] == u ? u : lab[u] = get(lab[u]); }
int n, m, res, u, v, w, x, k;
int main() {
scanf("%d%d%d", &n, &m, &k);
int x;
for (int i = 1; i <= k; ++i) {
scanf("%d", &x);
sz[x] = 1;
}
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &u, &v, &w);
f[i] = {u, v, w};
}
sort(f + 1, f + m + 1, cmp);
for (int i = 1; i <= n; ++i) lab[i] = i;
for (int i = 1; i <= m; ++i) {
u = get(f[i].u);
v = get(f[i].v);
if (u != v) {
if (sz[u] && sz[v]) res = f[i].w;
lab[v] = u;
sz[u] += sz[v];
}
}
for (int i = 1; i <= k; ++i) printf("%d ", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double tick() {
static clock_t oldt, newt = clock();
double diff = 1.0 * (newt - oldt) / CLOCKS_PER_SEC;
oldt = newt;
return diff;
}
struct edge {
int u;
int v;
int w;
};
vector<edge> edges(100005);
vector<int> P(100005);
unordered_map<int, int> mapp;
int kp, kpp, mpp;
int dsufind(int x) {
if (x != P[x]) return P[x] = dsufind(P[x]);
return P[x];
}
void solve() {
for (int i = 0; i < mpp; i++) {
edge e = edges[i];
int u = e.u;
int v = e.v;
int w = e.w;
int fu = dsufind(u);
int fv = dsufind(v);
if (fu != fv) {
if (mapp[fu])
P[fv] = fu;
else
P[fu] = fv;
if (mapp[fu] && mapp[fv]) kp--;
if (kp == 1) {
for (int i = 0; i < kpp; i++) cout << w << " ";
return;
}
}
}
}
bool compare(edge a, edge b) { return a.w < b.w; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
kp = k, kpp = k, mpp = m;
for (int i = 1; i < n + 1; i++) P[i] = i;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
mapp[x]++;
}
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
edges[i].u = u;
edges[i].v = v;
edges[i].w = w;
}
sort(edges.begin(), edges.begin() + m, compare);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long pow(long long B, long long P) {
long long S = 1;
for (long long i = 1; i <= P; i++) S = S * B;
return S;
}
long long fx4[] = {1, -1, 0, 0};
long long fy4[] = {0, 0, 1, -1};
struct edge {
int V, W;
edge(int a, int b) {
V = a;
W = b;
}
};
struct node {
int At, Cost;
node(int a, int b) {
At = a;
Cost = b;
}
};
bool operator<(node a, node b) { return a.Cost > b.Cost; }
vector<edge> G[400005];
priority_queue<node> PQ;
long long Dist[400005], Dist1[400005];
void Dijkstra(int S, int N) {
for (int i = 1; i <= N; i++) Dist[i] = INT_MAX;
Dist[S] = 0;
PQ.push(node(S, 0));
while (!PQ.empty()) {
node U = PQ.top();
PQ.pop();
if (U.Cost != Dist[U.At]) continue;
for (int i = 0; i < G[U.At].size(); i++) {
edge V = G[U.At][i];
if (max(Dist[U.At], V.W) < Dist[V.V]) {
long long X = max(Dist[U.At], V.W);
Dist[V.V] = min(Dist[V.V], X);
PQ.push(node(V.V, Dist[V.V]));
}
}
}
}
long long SP[400005];
int main() {
long long T, N, M, K, X, Y, W;
cin >> N >> M >> K;
for (int i = 1; i <= K; i++) cin >> SP[i];
for (int i = 1; i <= M; i++) {
cin >> X >> Y >> W;
G[X].push_back(edge(Y, W));
G[Y].push_back(edge(X, W));
}
Dijkstra(SP[1], N);
long long MAX = 0, S = SP[1];
for (int i = 1; i <= K; i++) {
X = Dist[SP[i]];
if (X > MAX) {
MAX = X;
S = SP[i];
}
}
for (int i = 1; i <= N; i++) Dist1[i] = Dist[i];
Dijkstra(S, N);
for (int i = 1; i <= K; i++) {
long long ans = max(Dist[SP[i]], Dist1[SP[i]]);
cout << ans << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, u[200005], v[200005], first[100005], nxt[200005], book[100005];
struct node {
int u, v, w;
} e[100005];
int a[100005], q[100005], head, tail;
bool cmp(node a, node b) { return a.w < b.w; }
bool check(int x) {
memset(first, 0, sizeof(first));
memset(nxt, 0, sizeof(nxt));
memset(book, 0, sizeof(book));
for (int i = 1; i <= x; i++) {
u[i] = e[i].u, v[i] = e[i].v;
nxt[i] = first[u[i]], first[u[i]] = i;
u[i + m] = v[i], v[i + m] = u[i];
nxt[i + m] = first[u[i + m]], first[u[i + m]] = i + m;
}
q[head = tail = 1] = a[1];
book[a[1]] = 1;
while (head <= tail) {
int now = q[head];
for (int i = first[now]; i; i = nxt[i])
if (book[v[i]] == 0) book[v[i]] = 1, q[++tail] = v[i];
head++;
}
for (int i = 1; i <= k; i++)
if (book[a[i]] == 0) return 0;
return 1;
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
sort(e + 1, e + 1 + m, cmp);
int l = 1, r = m, ans = 1000000000;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid))
ans = e[mid].w, r = mid - 1;
else
l = mid + 1;
}
for (int i = 1; i <= k; i++) printf("%d ", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int par[100001], sz[100001];
int p(int u) {
if (par[u] == u) return u;
par[u] = p(par[u]);
return par[u];
}
void un(int u, int v) {
int pu = p(u), pv = p(v);
if (pu != pv) {
par[pu] = pv;
sz[pv] += sz[pu];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
int sp[k], spB[n + 1];
memset(spB, false, sizeof spB);
for (int i = 0; i < k; i++) {
cin >> sp[i];
spB[sp[i]] = true;
}
pair<int, pair<int, int>> a[m];
for (int i = 0; i < m; i++)
cin >> a[i].second.first >> a[i].second.second >> a[i].first;
sort(a, a + m);
int l = 0, r = m - 1, ind = m - 1;
while (l <= r) {
int mid = (l + r) / 2;
vector<int> b[n + 1];
for (int i = 0; i < mid + 1; i++) {
int u = a[i].second.first, v = a[i].second.second;
b[u].push_back(v);
b[v].push_back(u);
}
int t = 0;
queue<int> q;
bool vis[n + 1];
memset(vis, false, sizeof vis);
q.push(sp[0]);
vis[sp[0]] = true;
while (!q.empty()) {
int f = q.front();
q.pop();
if (spB[f]) ++t;
for (int e : b[f]) {
if (!vis[e]) {
q.push(e);
vis[e] = true;
}
}
}
if (t == k) {
ind = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
while (k--) cout << a[ind].first << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v, len;
};
struct DSU_item {
int father;
int size;
int num_selected_inside;
bool is_root;
DSU_item(int f, int sz, int sl, bool r = true)
: father(f), size(sz), num_selected_inside(sl), is_root(r){};
};
struct DSU {
int n;
int tot_selected_number;
vector<DSU_item> data;
DSU(const vector<short> &is_selected) {
n = (int)is_selected.size();
data.reserve(n);
tot_selected_number = 0;
for (int i = 0; i < n; i++) {
data.push_back(DSU_item(i, 1, is_selected[i], true));
tot_selected_number += is_selected[i];
}
}
int join(int u, int v) {
int u_root = u;
while (!data[u_root].is_root) {
u_root = data[u_root].father;
}
data[u].father = u_root;
int v_root = v;
while (!data[v_root].is_root) {
v_root = data[v_root].father;
}
data[v].father = v_root;
if (u_root == v_root) return 0;
if (data[u_root].size > data[v_root].size) swap(u_root, v_root);
data[u_root].is_root = false;
data[u_root].father = v_root;
data[v_root].num_selected_inside += data[u_root].num_selected_inside;
data[v_root].size += data[u_root].size;
if (data[v_root].num_selected_inside >= tot_selected_number) {
return 2;
} else {
return 1;
}
}
};
bool cmp_len(const Edge &e1, const Edge &e2) { return e1.len < e2.len; }
int main(int argc, char *argv[]) {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
int N_vertices, M_edges, K_selected;
cin >> N_vertices >> M_edges >> K_selected;
vector<short> is_selected(N_vertices, 0);
for (int k = 0; k < K_selected; k++) {
int v;
cin >> v;
v--;
is_selected[v] = 1;
}
DSU the_dsu(is_selected);
vector<Edge> egdes_one_list(M_edges);
for (int m = 0; m < M_edges; m++) {
cin >> egdes_one_list[m].u >> egdes_one_list[m].v >> egdes_one_list[m].len;
egdes_one_list[m].u--;
egdes_one_list[m].v--;
}
sort(egdes_one_list.begin(), egdes_one_list.end(), cmp_len);
int main_res = -1;
for (size_t i = 0; i < egdes_one_list.size(); i++) {
if (the_dsu.join(egdes_one_list[i].u, egdes_one_list[i].v) == 2) {
main_res = egdes_one_list[i].len;
break;
}
}
for (int i = 0; i < K_selected; i++) cout << main_res << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int R[N], I[N], S[N];
int Find(int u) {
if (R[u] == u) return u;
R[u] = Find(R[u]);
return R[u];
}
void Union(int u, int v) {
int ru = Find(u), rv = Find(v);
if (ru == rv) return;
if (I[ru] < R[rv]) swap(ru, rv);
R[rv] = ru;
I[ru] += I[rv];
S[ru] += S[rv];
}
int main() {
ios_base::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
R[i] = i;
I[i] = 1;
S[i] = 0;
}
for (int i = 0; i < k; i++) {
int a;
cin >> a;
S[a] = 1;
}
vector<vector<int>> E(m, vector<int>(3));
for (int i = 0; i < m; i++) {
cin >> E[i][1] >> E[i][2] >> E[i][0];
}
sort(E.begin(), E.end());
int result;
for (int i = 0; i < m; i++) {
Union(E[i][1], E[i][2]);
int r = Find(E[i][1]);
if (S[r] == k) {
result = E[i][0];
break;
}
}
while (k--) cout << result << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 7;
const int MOD = (int)998244353;
const int infint = (long long)1e9 + 3;
const long long inf = (long long)1e18;
int n, m, k, par[MAXN], a[MAXN];
int get(int u) {
if (par[u] < 0) return u;
return par[u] = get(par[u]);
}
void merge(int u, int v) {
if ((u = get(u)) == (v = get(v))) return;
if (par[u] > par[v]) swap(u, v);
par[u] += par[v];
par[v] = u;
}
struct edge {
int u, v, w;
} e[MAXN];
bool cmp(edge e, edge f) { return e.w < f.w; }
bool check(int mid) {
memset(par, -1, sizeof par);
for (int j = 0; j <= mid; j++) merge(e[j].u, e[j].v);
int g = get(a[0]);
for (int i = 0; i < k; i++)
if (get(a[i]) != g) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < k; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> e[i].u >> e[i].v >> e[i].w;
sort(e, e + m, cmp);
memset(par, -1, sizeof par);
int L = -1, R = m;
while (R - L > 1) {
int mid = (L + R) >> 1;
if (check(mid))
R = mid;
else
L = mid;
}
for (int i = 0; i < k; i++) cout << e[R].w << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mx = 1e5 + 1;
vector<long long> par(mx);
long long find(long long a) {
if (a != par[a]) par[a] = find(par[a]);
return par[a];
}
int main() {
vector<long long> size(mx);
long long n, m, k, u, v, w, a, b, x, y;
cin >> n >> m >> k;
vector<long long> spnode(k);
for (long long i = 0; i < k; i++) {
cin >> spnode[i];
size[spnode[i]]++;
}
vector<tuple<long long, long long, long long>> edge(m);
for (long long i = 0; i < m; i++) {
cin >> u >> v >> w;
edge[i] = make_tuple(w, u, v);
}
sort(edge.begin(), edge.end());
for (long long i = 1; i <= n; i++) par[i] = i;
for (long long i = 0; i < m; i++) {
a = get<1>(edge[i]);
b = get<2>(edge[i]);
a = find(a);
b = find(b);
if (a == b) continue;
if (size[a] + size[b] == k) {
for (long long j = 0; j < k; j++) cout << get<0>(edge[i]) << ' ';
cout << endl;
break;
}
size[b] += size[a];
par[find(a)] = find(b);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 5, inf = 2e9;
int n, vr[mx], m, k, maxx, dis[mx], cnt;
vector<pair<int, int> > adj[mx];
set<pair<int, int> > st;
bool mark[mx], boo[mx];
void dks(int v) {
dis[v] = 0;
st.insert(make_pair(0, v));
while (cnt != n) {
auto at = st.begin();
int ver = (*at).second;
st.erase(st.begin());
if (mark[ver]) continue;
mark[ver] = 1;
cnt++;
if (boo[ver] == 1)
if (maxx < dis[ver]) maxx = dis[ver];
for (int i = 0; i < adj[ver].size(); i++) {
int u = adj[ver][i].first;
int w = adj[ver][i].second;
if (!mark[u]) {
w = max(w, dis[ver]);
if (dis[u] > w) {
dis[u] = w;
st.insert(make_pair(w, u));
}
}
}
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < mx; i++) dis[i] = inf;
for (int i = 0; i < k; i++) {
cin >> vr[i];
boo[vr[i]] = 1;
}
for (int i = 0; i < m; i++) {
int v, u, w;
cin >> v >> u >> w;
adj[v].push_back(make_pair(u, w)), adj[u].push_back(make_pair(v, w));
}
dks(vr[0]);
for (int i = 0; i < k; i++) {
cout << maxx << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 10;
int n, m, k, par[M], sp[M];
vector<pair<int, pair<int, int> > > e;
int root(int v) {
if (par[v] == v) return v;
return par[v] = root(par[v]);
}
void join(int u, int v) {
int ru = root(u), rv = root(v);
if (ru == rv) return;
par[ru] = rv;
}
bool check(int mid) {
for (int i = 1; i <= n; i++) par[i] = i;
for (int i = 0; i < mid; i++) join(e[i].second.first, e[i].second.second);
int bef = root(sp[1]);
for (int i = 2; i <= k; i++)
if (root(sp[i]) != bef) return false;
return true;
}
int32_t main() {
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) scanf("%d", sp + i);
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
e.push_back({w, {u, v}});
}
sort(e.begin(), e.end());
int l = 0, r = m, mid;
while (r - l > 1) {
mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
for (int i = 1; i <= k; i++) printf("%d ", e[r - 1].first);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
map<pair<long long, long long>, long long> ves;
vector<long long> met, parent, ran, w;
void make_set(int v) {
parent[v] = v;
ran[v] = 0;
}
long long find_set(long long v) {
if (v == parent[v]) return v;
return find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (ran[a] < ran[b]) swap(a, b);
parent[b] = a;
if (ran[a] == ran[b]) ++ran[a];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long m, k;
cin >> n >> m >> k;
w.resize(n + 1, 0);
met.resize(n + 1, 0);
parent.resize(n + 1, 0);
ran.resize(n + 1, 0);
vector<pair<long long, pair<long long, long long> > > b;
set<long long> first;
for (long long i = 1; i <= k; i++) {
long long t;
cin >> t;
first.insert(t);
}
for (long long i = 1; i <= m; i++) {
long long x, y, z;
cin >> x >> y >> z;
if (x > y) swap(x, y);
if (x == y) continue;
if (ves[{x, y}] == 0)
ves[{x, y}] = z;
else
ves[{x, y}] = min(ves[{x, y}], z);
}
for (auto it = ves.begin(); it != ves.end(); it++) {
pair<long long, long long> t = it->first;
long long r = it->second;
b.push_back({r, t});
}
for (long long i = 1; i <= n; i++) {
make_set(i);
if (first.find(i) != first.end()) w[i] = 1;
}
sort(b.begin(), b.end());
long long mx = -1;
long long pp = 1;
for (long long i = 0; i < b.size(); i++) {
long long x = b[i].second.first, y = b[i].second.second, z = b[i].first;
if (find_set(x) == find_set(y)) continue;
mx = z;
long long r = w[find_set(x)] + w[find_set(y)];
union_sets(x, y);
w[find_set(x)] = r;
if (w[find_set(x)] == k) break;
}
for (long long i = 1; i <= k; i++) cout << mx << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
inline bool is_palindrome(const string& s) {
return std::equal(s.begin(), s.end(), s.rbegin());
}
const long long MOD = 1000000007;
const long long INF = 1e9 + 5;
const double eps = 1e-7;
const double PI = acos(-1.0);
int n, m, k, u, v, w;
const int N = 1e5 + 5;
bool special[N];
vector<pair<int, pair<int, int> > > edges;
const int FINDSIZE = N;
int p[FINDSIZE], sizes[FINDSIZE], cnt[FINDSIZE];
bool done = false;
int findSet(int i) { return (p[i] == i) ? i : p[i] = findSet(p[i]); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
bool join(int i, int j) {
if (!isSameSet(i, j)) {
int x = findSet(i), y = findSet(j);
if (sizes[x] < sizes[y]) {
p[x] = y;
sizes[y] += sizes[x];
cnt[y] += cnt[x];
} else {
p[y] = x;
sizes[x] += sizes[y];
cnt[x] += cnt[y];
}
if (cnt[x] == k || cnt[y] == k) {
done = true;
}
return true;
}
return false;
}
void initialiseUnionFind() {
for (int i = 0; i < FINDSIZE; i++) {
p[i] = i;
sizes[i] = 1;
cnt[i] = (special[i]) ? 1 : 0;
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k;
memset(special, false, sizeof(special));
for (long long i = (long long)(0); i < (long long)(k); i++) {
cin >> u;
u--;
special[u] = true;
}
for (long long i = (long long)(0); i < (long long)(m); i++) {
cin >> u >> v >> w;
u--;
v--;
edges.push_back({w, {u, v}});
}
sort(edges.begin(), edges.end());
initialiseUnionFind();
long long ans = -1;
for (long long i = (long long)(0); i < (long long)(m); i++) {
if (done) {
break;
}
u = edges[i].second.first, v = edges[i].second.second;
w = edges[i].first;
if (join(u, v)) {
ans = w;
}
}
for (long long i = (long long)(0); i < (long long)(k); i++) {
if (i) {
cout << " ";
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7, LINF = 1e18 + 1e16;
const int INF = 1e9 + 1;
const double EPS = 1e-10;
const int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
const int N = 1e5 + 5;
class TaskD {
private:
int n, m, k;
int pos[N];
int par[N];
int ans[N];
vector<tuple<int, int, int> > vec;
int find(int u) { return par[u] = par[u] == u ? u : find(par[u]); }
public:
void solve(istream& cin, ostream& cout) {
for (int i = 0; i < N; ++i) par[i] = i;
cin >> n >> m >> k;
for (int i = 1, val; i <= k; ++i) {
cin >> val;
pos[val] = i;
}
for (int i = 0, u, v, w; i < m; ++i) {
cin >> u >> v >> w;
vec.emplace_back(w, u, v);
}
sort((vec).begin(), (vec).end());
int ans0;
for (auto first : vec) {
int w, u, v;
tie(w, u, v) = first;
int a = find(u);
int b = find(v);
if (a == b) continue;
if (pos[a] && pos[b]) ans0 = w;
if (pos[a] && pos[b]) {
if (!ans[pos[a]]) ans[pos[a]] = w;
if (!ans[pos[b]]) ans[pos[b]] = w;
}
if (pos[a])
par[b] = a;
else
par[a] = b;
}
for (int i = 1; i <= k; ++i) cout << ans0 << ' ';
cout << endl;
}
};
class Solver {
public:
void solve(std::istream& in, std::ostream& out) {
TaskD* obj = new TaskD();
obj->solve(in, out);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
Solver solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
struct Edge {
int v, u, w;
Edge() : v(), u(), w() {}
void scan() {
scanf("%d%d%d", &v, &u, &w);
v--;
u--;
}
bool operator<(const Edge &e) const { return w < e.w; }
};
const int N = 100100;
int n, m, k;
int par[N];
int sz[N];
int a[N];
int S, T;
int x[N];
Edge ed[N];
int getPar(int v) { return par[v] == -1 ? v : par[v] = getPar(par[v]); }
void unite(int v, int u) {
v = getPar(v);
u = getPar(u);
if (v == u) return;
if (sz[v] < sz[u]) swap(v, u);
sz[v] += sz[u];
a[v] += a[u];
par[u] = v;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int v = 0; v < n; v++) {
par[v] = -1;
sz[v] = 0;
a[v] = 0;
}
for (int i = 0; i < k; i++) {
scanf("%d", &x[i]);
x[i]--;
a[x[i]] = 1;
}
for (int i = 0; i < m; i++) ed[i].scan();
sort(ed, ed + m);
for (int i = 0; i < m; i++) {
unite(ed[i].v, ed[i].u);
if (a[getPar(ed[i].v)] == k) {
for (int j = 0; j < k; j++) printf("%d ", ed[i].w);
printf("\n");
return 0;
}
}
throw;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 4 * atan((long double)1);
const long long mod = 1e9 + 7;
const long long inf = 922337203685477;
const long long nax = 1e5 + 5;
struct info {
long long u, v, w;
};
bool cmp(info x, info y) { return x.w < y.w; }
long long n, m, k;
long long uniq[nax], par[nax];
long long f(long long idx) {
if (idx == par[idx]) {
return idx;
}
return par[idx] = f(par[idx]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k;
for (long long i = 1; i <= k; i++) {
long long x;
cin >> x;
uniq[x] = 1;
}
vector<info> edge;
for (long long i = 1; i <= m; i++) {
long long u, v, w;
cin >> u >> v >> w;
edge.push_back({u, v, w});
}
sort(edge.begin(), edge.end(), cmp);
for (long long i = 1; i <= n; i++) {
par[i] = i;
}
long long ans = 0;
for (auto cur : edge) {
long long u = f(cur.u);
long long v = f(cur.v);
if (u != v) {
par[v] = u;
uniq[u] += uniq[v];
if (uniq[u] == k) {
ans = cur.w;
break;
}
}
}
for (long long i = 1; i <= k; i++) {
cout << ans << " ";
}
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int Dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
int Dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long powm(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2) res *= a;
a *= a;
b /= 2;
}
return res;
}
int par[N];
int sz[N];
struct kruskal {
void inti(int n) {
for (int i = 0; i <= n; i++) {
par[i] = i;
sz[i] = 1;
}
}
int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
bool same(int a, int b) { return find(a) == find(b); }
void unite(int a, int b) {
int apar = find(a);
int bpar = find(b);
if (sz[apar] < sz[bpar]) swap(apar, bpar);
sz[bpar] += sz[apar];
par[apar] = bpar;
}
};
bool vis[N];
int dis[N];
vector<pair<int, int>> adj[N];
void dfs(int x) {
vis[x] = 1;
for (auto a : adj[x]) {
if (vis[a.first]) continue;
dis[a.first] = max(dis[x], a.second);
dfs(a.first);
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int spial[N];
for (int i = 1; i <= k; i++) cin >> spial[i];
vector<pair<long long, pair<int, int>>> edg;
for (int i = 1; i <= m; i++) {
long long a, b, c;
cin >> a >> b >> c;
edg.push_back({c, {a, b}});
}
sort(edg.begin(), edg.end());
kruskal obj;
obj.inti(n);
for (auto a : edg) {
if (!obj.same(a.second.first, a.second.second)) {
obj.unite(a.second.first, a.second.second);
adj[a.second.first].push_back({a.second.second, a.first});
adj[a.second.second].push_back({a.second.first, a.first});
}
}
fill(dis, dis + N, 1e9 + 9);
dis[spial[1]] = 0;
dfs(spial[1]);
int ans = 0;
for (int i = 2; i <= k; i++) ans = max(ans, dis[spial[i]]);
for (int i = 1; i <= k; i++) cout << ans << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct DisjointSet {
int par[100001], num[100001];
DisjointSet() {
for (int i = 0; i < 100001; i++) {
par[i] = i;
num[i] = 0;
}
}
int find(int u) {
if (par[u] == u) return u;
return par[u] = find(par[u]);
}
void merge(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return;
par[v] = u;
num[u] += num[v];
}
} disj;
int x[100001];
struct Edge {
int u, v, w;
bool operator<(const Edge &e) const { return w < e.w; }
} E[100001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> x[i];
disj.num[x[i]]++;
}
for (int i = 0; i < m; i++) {
cin >> E[i].u >> E[i].v >> E[i].w;
}
sort(E, E + m);
int ans = 0;
for (int i = 0; i < m; i++) {
ans = E[i].w;
disj.merge(E[i].u, E[i].v);
if (disj.num[disj.find(x[0])] == k) break;
}
for (int i = 0; i < k; i++) cout << ans << ' ';
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[100005];
int sz[100005];
bool com(pair<int, pair<int, int> > a, pair<int, pair<int, int> > b) {
return a.first < b.first;
}
int findd(int u) {
if (u == p[u]) return u;
return p[u] = findd(p[u]);
}
vector<pair<int, pair<int, int> > > op;
int main() {
int n, m, k, i, j;
cin >> n >> m >> k;
for (i = 0; i < k; i++) {
int x;
cin >> x;
sz[x] = 1;
}
for (i = 0; i <= n; i++) p[i] = i;
for (i = 0; i < m; i++) {
int x, y, z;
cin >> x >> y >> z;
op.push_back(make_pair(z, make_pair(x, y)));
}
sort(op.begin(), op.end(), com);
for (i = 0; i < op.size(); i++) {
int x = findd(op[i].second.first);
int y = findd(op[i].second.second);
if (x != y) {
p[y] = x;
sz[x] += sz[y];
if (sz[x] >= k) {
for (j = 0; j < k; j++) cout << op[i].first << " ";
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int L, R, W;
} e[100010];
int fa[100010], s[100010];
int N, M, K;
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
bool cmp(edge a, edge b) { return a.W < b.W; }
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 1; i <= K; i++) {
int tmp;
scanf("%d", &tmp);
s[tmp] = 1;
}
for (int i = 1; i <= N; i++) fa[i] = i;
for (int i = 1; i <= M; i++) {
scanf("%d%d%d", &e[i].L, &e[i].R, &e[i].W);
}
sort(e + 1, e + M + 1, cmp);
for (int i = 1; i <= M; i++) {
int u = e[i].L, v = e[i].R;
u = find(u);
v = find(v);
if (u == v) continue;
fa[v] = u;
s[u] += s[v];
if (s[u] == K) {
for (int j = 1; j <= K; j++) printf("%d%c", e[i].W, " \n"[j == N]);
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3F3F3F3F;
const unsigned long long int mod = 1e9 + 7;
const int N = 100005;
int tam[N], pai[N], esp[N], see[N], vis[N], ans = 0;
vector<pair<int, int>> adj[N];
void init() {
for (int i = 0; i <= N; i++) pai[i] = i, tam[i] = 1;
}
int find(int x) {
if (pai[x] == x)
return x;
else
return pai[x] = find(pai[x]);
}
void unite(int x, int y) {
int lx = find(x);
int ly = find(y);
if (tam[ly] > tam[lx]) swap(lx, ly);
pai[ly] = lx;
tam[lx] += tam[ly];
}
void dfs(int x, int cost) {
vis[x] = 1;
for (auto i : adj[x]) {
cost = max(cost, i.second);
if (!vis[i.first]) {
if (see[i.first]) ans = max(ans, cost);
dfs(i.first, cost);
}
}
}
void solve() {
init();
vector<tuple<int, int, int>> edges;
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> esp[i];
see[esp[i]] = 1;
}
while (m--) {
int u, v, p;
cin >> u >> v >> p;
edges.push_back(make_tuple(p, u, v));
}
sort(edges.begin(), edges.end());
for (auto i : edges) {
int u, v, p;
tie(p, u, v) = i;
if (find(u) != find(v)) {
unite(u, v);
adj[u].push_back({v, p});
adj[v].push_back({u, p});
}
}
dfs(esp[0], 0);
for (int i = 0; i < k; i++) cout << ans << " ";
cout << '\n';
}
int main() {
cin.tie(NULL), cout.sync_with_stdio(true);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void setmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
inline void setmax(T &x, T y) {
if (y > x) x = y;
}
template <typename T>
inline T gcd(T a, T b) {
while (b) swap(a %= b, b);
return a;
}
const int MAX = 1e5 + 7;
const int T = 1 << 20;
const int INF = 1e9 + 7;
const long long BIG_INF = 1e18 + 5;
long double e = 2.7182818284590452353602874713526624;
long double PI = acos(-1);
long double eps = 1e-19;
long long mod = 998244353;
long long n, m, k, t;
long long wynik;
int REP[MAX];
int ROZ[MAX];
int wazny[MAX];
priority_queue<pair<int, pair<int, int> > > kol;
int fajnd(int x) { return REP[x] == x ? x : REP[x] = fajnd(REP[x]); }
void onion(int a, int b) {
ROZ[fajnd(b)] += ROZ[fajnd(a)];
if (ROZ[fajnd(b)] == k) {
for (int i = 1; i <= k; ++i) {
cout << wynik << ' ';
}
exit(0);
}
REP[fajnd(a)] = fajnd(b);
}
void elo() {
while (int((kol).size())) {
auto CAR = kol.top();
kol.pop();
int koszt = -CAR.first;
int jeden = CAR.second.first;
int dwa = CAR.second.second;
if (fajnd(jeden) != fajnd(dwa)) {
wynik = max(wynik, (long long)koszt);
onion(jeden, dwa);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> k;
wazny[0] = 1;
for (int i = 1; i <= n; i++) {
REP[i] = i;
}
for (int i = 0; i < k; i++) {
cin >> t;
wazny[t] = 1;
ROZ[t] = 1;
}
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
if (a == b) {
continue;
}
kol.push({-c, {a, b}});
}
elo();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m, k;
int ans;
struct edge {
int x, y, z;
edge() {}
void input() { scanf("%d %d %d", &x, &y, &z); }
bool operator<(const edge &a) const { return z < a.z; }
} E[N];
int fa[N], sz[N];
int find(int x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= k; ++i) {
int x;
scanf("%d", &x);
sz[x] = 1;
}
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1; i <= m; ++i) E[i].input();
sort(E + 1, E + 1 + m);
for (int i = 1; i <= m; ++i) {
int x = E[i].x, y = E[i].y, z = E[i].z;
int a = find(x), b = find(y);
if (a == b) continue;
fa[a] = b;
if (sz[a] && sz[b]) ans = z;
sz[b] += sz[a];
}
for (int i = 1; i <= k; ++i) printf("%d ", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, k;
cin >> n >> m >> k;
vector<int> sv(k);
for (int i = 0; i < k; sv[i]--, i++) cin >> sv[i];
vector<vector<pair<int, int>>> adjl(n);
vector<int> wt(n, -1);
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
adjl[u].push_back({v, w});
adjl[v].push_back({u, w});
}
set<pair<int, int>> pq;
vector<int> dis(n, INT_MAX);
dis[sv[0]] = 0;
pq.insert({wt[sv[0]], sv[0]});
while (!pq.empty()) {
int dist = pq.begin()->first;
int node = pq.begin()->second;
pq.erase(pq.begin());
if (dis[node] < dist) continue;
for (int i = 0; i < adjl[node].size(); i++) {
pair<int, int> tmp = adjl[node][i];
int v = tmp.first;
int wg = tmp.second;
if (dis[v] == INT_MAX)
pq.insert({dis[v] = max(dist, wg), v});
else if (dis[v] > max(dist, wg)) {
pq.erase({dis[v], v});
pq.insert({dis[v] = max(dist, wg), v});
}
}
}
int maxd = INT_MIN;
for (int i = 0; i < k; i++) maxd = max(maxd, dis[sv[i]]);
while (k--) cout << maxd << " ";
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int INF = 1e9 + 9;
const long long INF1 = 1e18 + 9;
const long long MAXN = 4e5 + 7;
const long long MAXN1 = 1 << 11;
const long long MAXN2 = 2e7 + 9;
const long long MOD = 998244353;
const long long MOD1 = 1e9 + 9;
const long long ALPH = 50;
const long long PW1 = 239;
const long long PW2 = 199;
const long long PW3 = 193;
const long long PW4 = 117;
const long double EPS = 1e-9;
const long long BLOCK = 3684;
const long long BLOCK1 = 1 << 9;
void solve();
signed main() {
srand('a' + 'l' + 'e' + 'x' + 'X' + '5' + '1' + '2');
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q = 1;
if (0) cin >> q;
while (q--) solve();
}
vector<pair<int, int> > g[MAXN];
bool used[MAXN];
void dfs(int vert, int x) {
used[vert] = 1;
for (auto &i : g[vert]) {
if (!used[i.first] && i.second <= x) {
dfs(i.first, x);
}
}
}
bool f(int x, vector<int> &v) {
memset(used, 0, sizeof used);
int cnt = 0;
for (auto &i : v) {
if (!used[i]) {
++cnt;
dfs(i, x);
}
}
return cnt != 1;
}
void solve() {
int n, m, k;
cin >> n >> m >> k;
vector<int> v(k);
for (auto &i : v) cin >> i;
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
g[a].emplace_back(b, c);
g[b].emplace_back(a, c);
}
int l = 0, r = INF;
while (r - l > 1) {
int m1 = (r + l) >> 1;
if (f(m1, v))
l = m1;
else
r = m1;
}
for (int i = 0; i < k; ++i) cout << r << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
struct Edge {
int u, v, w;
} e[maxn];
inline bool cmp(const Edge &a, const Edge &b) { return a.w < b.w; }
int fa[maxn];
bool flag[maxn];
inline int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
int mxedge;
inline void Merge(int x, int y, int val) {
if (flag[x] == 1 && flag[y] == 1) {
mxedge = max(mxedge, val);
}
fa[x] = y;
flag[y] |= flag[x];
}
inline int getans(int x) { return mxedge; }
int n, m, x[maxn];
int main() {
int k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= k; i++) scanf("%d", x + i), flag[x[i]] = 1;
for (int i = 1; i <= m; i++) scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
sort(e + 1, e + m + 1, cmp);
for (int i = 1; i <= m; i++) {
int u = e[i].u, v = e[i].v, w = e[i].w;
if (find(u) == find(v)) continue;
Merge(find(u), find(v), w);
}
for (int i = 1; i <= k; i++) printf("%d ", getans(x[i]));
}
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> p;
int n;
UnionFind(int n) : p(n, -1), n(n) {}
int find(int v) { return (p[v] < 0 ? v : p[v] = find(p[v])); }
bool join(int i, int j) {
i = find(i), j = find(j);
if (i == j) return false;
if (p[i] > p[j]) swap(i, j);
p[i] += p[j];
p[j] = i;
return true;
}
};
vector<vector<pair<int, int>>> mst;
vector<bool> isSpecial;
int getMaxEdgeBetween(int v, int p, int etp) {
int runningMax = -1;
for (auto next : mst[v]) {
if (next.first != p) {
runningMax =
max(runningMax, getMaxEdgeBetween(next.first, v, next.second));
}
}
if (runningMax > -1 || isSpecial[v]) {
runningMax = max(runningMax, etp);
}
return runningMax;
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
isSpecial = vector<bool>(n);
vector<int> specials(k);
for (int i = 0; i < k; ++i) {
scanf("%d", &specials[i]);
isSpecial[--specials[i]] = true;
}
vector<pair<int, pair<int, int>>> eList;
for (int i = 0; i < m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
--u;
--v;
eList.emplace_back(w, make_pair(u, v));
}
mst = vector<vector<pair<int, int>>>(n);
sort(eList.begin(), eList.end());
UnionFind onion(n);
for (auto e : eList) {
if (onion.join(e.second.first, e.second.second)) {
mst[e.second.first].emplace_back(e.second.second, e.first);
mst[e.second.second].emplace_back(e.second.first, e.first);
}
}
int ans = getMaxEdgeBetween(specials[0], -1, -1);
for (int i = 0; i < k; ++i) {
printf("%d ", ans);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int par[100001], sz[100001];
int ans[100001], sps[100001];
int p(int u) {
if (par[u] == u) return u;
par[u] = p(par[u]);
return par[u];
}
void un(int u, int v) {
int pu = p(u), pv = p(v);
if (pu != pv) {
par[pu] = pv;
if (ans[pu] > ans[pv]) ans[pv] = ans[pu];
sz[pv] += sz[pu];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
int sp[k];
bool spB[n + 1];
memset(spB, false, sizeof spB);
for (int i = 0; i < k; i++) {
cin >> sp[i];
spB[sp[i]] = true;
}
memset(ans, -1, sizeof ans);
pair<int, pair<int, int>> a[m];
for (int i = 0; i < m; i++)
cin >> a[i].second.first >> a[i].second.second >> a[i].first;
sort(a, a + m);
for (int i = 1; i < n + 1; i++) {
par[i] = i;
sz[i] = 1;
}
for (int i = 1; i < n + 1; i++) sps[i] = spB[i];
for (auto e : a) {
int u = e.second.first, v = e.second.second, w = e.first;
int pu = p(u), pv = p(v);
if (pu != pv) {
if (sps[pu] && sps[pv]) ans[pv] = w;
}
un(u, v);
if (sps[pu]) sps[pv] = true;
}
for (int e : sp) cout << ans[p(e)] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct Edge {
int u, v, c;
bool operator<(const Edge &o) const { return c < o.c; }
};
vector<Edge> es;
int n, m, k, P[N], specials[N];
bool is_sp[N];
int find(int i) { return i == P[i] ? i : P[i] = find(P[i]); }
vector<pair<int, int> > g[N], g2[N];
pair<int, pair<int, int> > best = {-1, {-1, -1}};
void dfs(int u, int p, int f, int c) {
if (is_sp[u]) {
if (f >= 0) {
g2[f].push_back({u, c});
g2[u].push_back({f, c});
best = max(best, {c, {u, f}});
}
for (auto e : g[u])
if (e.first != p) {
dfs(e.first, u, u, e.second);
}
} else {
for (auto e : g[u])
if (e.first != p) {
dfs(e.first, u, f, max(c, e.second));
}
}
}
int ans[N];
void dfs1(int u, int p) {
ans[u] = best.second.second;
for (auto e : g[u])
if (e.first != p) {
dfs1(e.first, u);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset((ans), (-1), sizeof(ans));
cin >> n >> m >> k;
for (int x = (0), qwerty = (n); x < qwerty; x++) P[x] = x;
for (int x = (0), qwerty = (k); x < qwerty; x++)
cin >> specials[x], specials[x]--, is_sp[specials[x]] = 1;
for (int x = (0), qwerty = (m); x < qwerty; x++) {
int u, v, c;
cin >> u >> v >> c;
u--;
v--;
es.push_back({u, v, c});
}
sort((es).begin(), (es).end());
for (auto e : es) {
if (find(e.u) != find(e.v)) {
g[e.u].push_back({e.v, e.c});
g[e.v].push_back({e.u, e.c});
P[find(e.u)] = find(e.v);
}
}
dfs(specials[0], -1, -1, -1);
dfs1(best.second.first, best.second.second);
for (int x = (0), qwerty = (k); x < qwerty; x++)
cout << best.first << " \n"[x + 1 == k];
}
|
#include <bits/stdc++.h>
using namespace std;
void yes() {
cout << "YES"
<< "\n";
}
void no() {
cout << "NO"
<< "\n";
}
vector<pair<long long, pair<int, int>>> v;
vector<int> dsu(100001);
vector<int> s(100001);
vector<pair<long long, long long>> v2[100001];
int find(int i) {
if (i == dsu[i]) return i;
dsu[i] = find(dsu[i]);
return dsu[i];
}
void combine(int a, int b) {
int x = find(a), y = find(b);
if (s[x] < s[y]) {
s[y] += s[x];
dsu[x] = y;
} else {
s[x] += s[y];
dsu[y] = x;
}
}
long long mi = 0;
set<int> v1;
bool dfs(int i, int p) {
bool b1 = 0;
for (auto j : v2[i]) {
if (j.second != p) {
bool b = dfs(j.second, i);
if (b) {
b1 = 1;
mi = max(j.first, mi);
}
}
}
if (v1.find(i) != v1.end()) return true;
return b1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, k, a, b, x, y, c;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> a;
v1.insert(a);
}
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
v.push_back(make_pair(c, make_pair(a, b)));
}
sort(v.begin(), v.end());
for (int i = 1; i <= n; i++) {
dsu[i] = i;
s[i] = 1;
}
for (auto j : v) {
c = j.first;
x = j.second.first;
y = j.second.second;
a = find(x);
b = find(y);
if (a == b)
continue;
else {
combine(a, b);
v2[x].push_back(make_pair(c, y));
v2[y].push_back(make_pair(c, x));
}
}
dfs(*v1.begin(), -1);
for (int i = 0; i < k; i++) cout << mi << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 1000010;
const int INF = 2147483600;
struct data {
int x, y, val;
} a[MAXN + 1];
int fa[MAXN + 1], s[MAXN + 1], vis[MAXN + 1], N, M, Kf, flag;
bool cmp(data x, data y) { return x.val < y.val; }
inline int find(int x) { return (x == fa[x] ? x : (fa[x] = find(fa[x]))); }
inline void merge(int x, int y) {
int X = find(x), Y = find(y);
if (X == Y) return;
fa[X] = Y;
s[Y] += s[X];
if (s[Y] == Kf) flag = 1;
}
inline void solve() {
for (int i = 1; i <= M; i++) {
merge(a[i].x, a[i].y);
if (flag == 1) {
for (int j = 1; j <= Kf; j++) cout << a[i].val << " ";
return;
}
}
for (int i = 1; i <= M; i++) {
merge(a[i].x, a[i].y);
if (flag == 1) {
for (int j = 1; j <= Kf; j++) cout << a[i].val << " ";
return;
}
}
for (int i = 1; i <= M; i++) {
merge(a[i].x, a[i].y);
if (flag == 1) {
for (int j = 1; j <= Kf; j++) cout << a[i].val << " ";
return;
}
}
}
int main() {
N = read(), M = read(), Kf = read();
for (int i = 1; i <= Kf; i++) {
int x = read();
vis[x] = 1;
}
for (int i = 1; i <= N; i++) {
fa[i] = i;
if (vis[i]) s[i] = 1;
}
for (int i = 1; i <= M; i++)
a[i].x = read(), a[i].y = read(), a[i].val = read();
sort(a + 1, a + M + 1, cmp);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int parent[200005], arr[200005];
vector<pair<int, pair<int, int> > > v;
int find_parent(int x) {
if (x != parent[x]) {
parent[x] = find_parent(parent[x]);
}
return parent[x];
}
int main() {
int n, m, k, i, ans = 0, a, b, w, rootA, rootB;
cin >> n >> m >> k;
for (i = 0; i < k; i++) {
cin >> a;
arr[a] = 1;
}
for (i = 0; i < m; i++) {
cin >> a >> b >> w;
v.push_back({w, {a, b}});
}
sort(v.begin(), v.end());
for (i = 0; i <= n; i++) {
parent[i] = i;
}
for (auto x : v) {
w = x.first;
a = x.second.first;
b = x.second.second;
rootA = find_parent(a);
rootB = find_parent(b);
if (rootA != rootB) {
parent[rootA] = rootB;
if (arr[rootA] > 0 && arr[rootB] > 0) {
ans = max(ans, w);
}
arr[rootB] = max(arr[rootA], arr[rootB]);
}
}
for (i = 0; i < k; i++) {
cout << ans << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, MOD = 1e9 + 7;
vector<pair<int, int> > adj[N];
int d[N], ans[N], sp[N], cnt = 4 * N, vis[N];
void dij(int s) {
for (int i = 0; i < N; i++) ans[i] = MOD;
ans[s] = 0;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
pq.push(pair<int, int>(0, s));
ans[s] = 0;
while (!pq.empty()) {
pair<int, int> front = pq.top();
pq.pop();
int val = front.first, u = front.second;
if (vis[u]) continue;
vis[u] = 1;
for (auto v : adj[u]) {
int w = v.second, nd = v.first;
if (max(ans[u], w) < ans[nd]) {
ans[nd] = max(ans[u], w);
pq.push({max(ans[u], w), nd});
}
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) cin >> sp[i];
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
dij(sp[1]);
int maxx = -1;
for (int i = 1; i <= k; i++) {
maxx = max(maxx, ans[sp[i]]);
}
for (int i = 1; i <= k; i++) cout << maxx << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd1(int a, int b) {
if (a == 0) return b;
return gcd1(b % a, a);
}
long long modx(long long base, long long ex) {
long long ans = 1LL, val = base;
while (ex > 0LL) {
if (ex & 1LL) ans = (ans * val) % 1000000009LL;
val = (val * val) % 1000000009LL;
ex = ex >> 1LL;
}
return ans;
}
int n, m, k, x, y, start;
long long w;
vector<pair<int, long long> > adj[300005];
set<pair<long long, int> > s;
bool visit[300005];
long long dist[300005];
vector<int> spcl;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
cin >> x;
spcl.push_back(x);
}
for (int i = 1; i <= n; i++) dist[i] = 20000000000000LL;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> w;
adj[x].push_back(make_pair(y, w));
adj[y].push_back(make_pair(x, w));
}
int start = spcl[0];
dist[start] = 0;
s.insert(make_pair(dist[start], start));
while (!s.empty()) {
pair<long long, int> p = *s.begin();
s.erase(s.begin());
int f = p.second;
long long d = p.first;
if (visit[f]) continue;
visit[f] = true;
for (int i = 0; i < adj[f].size(); i++) {
long long nd = max(d, adj[f][i].second);
int node = adj[f][i].first;
if (visit[node] || dist[node] < nd) continue;
dist[node] = nd;
s.insert(make_pair(nd, node));
}
}
for (int i = 1; i < k; i++) dist[start] = max(dist[start], dist[spcl[i]]);
for (int i = 0; i < k; i++) cout << dist[start] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 120000;
struct Edge {
int from, to, cost;
} E[N];
const int inf = (int)1e9 + 2;
int n, m, k, a[N];
int fa[N];
int getfather(int x) {
if (x == fa[x]) return x;
return fa[x] = getfather(fa[x]);
}
void unite(int x, int y) {
x = getfather(x);
y = getfather(y);
fa[y] = fa[x];
}
bool same(int x, int y) { return getfather(x) == getfather(y); }
bool check(int mid) {
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
if (E[i].cost >= mid) continue;
unite(E[i].from, E[i].to);
}
for (int i = 2; i <= k; i++)
if (!same(a[i], a[1])) return 1;
return 0;
}
void init() {}
void solve() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &E[i].from, &E[i].to, &E[i].cost);
}
int l = 1, r = inf, mid, best;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
l = mid + 1, best = mid;
else
r = mid - 1;
}
for (int i = 1; i <= k; i++) printf("%d ", best);
puts("");
}
int main() {
int TTT = 1;
while (TTT--) {
init();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, pair<int, int> > > v;
int par[100005];
int spec[100005];
int parent(int x) {
if (par[x] != x) par[x] = parent(par[x]);
return par[x];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
int ele, x, y, w, parx, pary, n, m, k;
cin >> n >> m >> k;
for (int i = 1; i < n + 1; i++) par[i] = i;
for (int i = 0; i < k; i++) {
cin >> ele;
spec[ele] = 1;
}
for (int i = 0; i < m; i++) {
cin >> x >> y >> w;
v.push_back(make_pair(w, make_pair(x, y)));
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
x = v[i].second.first;
y = v[i].second.second;
w = v[i].first;
parx = parent(x);
pary = parent(y);
if (parx == pary) continue;
spec[parx] += spec[pary];
par[pary] = parx;
if (spec[parx] == k) {
for (int j = 0; j < k; j++) {
cout << w << " ";
}
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e5 + 4;
int n, k, q[NMAX], cost[NMAX], last;
bool used[NMAX], special[NMAX];
vector<pair<int, int>> g[NMAX];
set<pair<int, int>> pq;
int main() {
int m, x, y, w, node, nr = 0, last = 0;
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) cost[i] = 2e9;
for (int i = 0; i < k; ++i) {
cin >> node;
special[node] = 1;
}
for (int i = 0; i < m; ++i) {
cin >> x >> y >> w;
if (x != y) g[x].push_back({y, w}), g[y].push_back({x, w});
}
pq.insert({0, node});
while (!pq.empty()) {
node = (*pq.begin()).second;
w = (*pq.begin()).first;
pq.erase(pq.begin());
used[node] = 1;
last = max(last, w);
if (special[node]) ++nr;
if (nr == k) break;
for (auto it : g[node]) {
if (!used[it.first] && cost[it.first] > it.second) {
if (cost[it.first] != 2e9)
pq.erase(pq.find({cost[it.first], it.first}));
cost[it.first] = it.second;
pq.insert({it.second, it.first});
}
}
}
for (int i = 0; i < k; ++i) cout << last << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, m, k, ans;
int fa[maxn];
bool hav[maxn];
struct edge_t {
int u, v, w;
bool operator<(const edge_t &rhs) const { return w < rhs.w; }
} E[maxn];
int getf(int u) { return (fa[u] == u) ? u : (fa[u] = getf(fa[u])); }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int p, i = 1; i <= k; i++) scanf("%d", &p), hav[p] = true;
for (int i = 1; i <= m; i++) scanf("%d%d%d", &E[i].u, &E[i].v, &E[i].w);
sort(E + 1, E + 1 + m);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int r1 = getf(E[i].u), r2 = getf(E[i].v);
if (r1 == r2) continue;
if (hav[r1] && hav[r2]) ans = E[i].w;
hav[r2] |= hav[r1];
fa[r1] = r2;
}
for (int i = 1; i <= k; i++) printf("%d ", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<long long, long long> > > adj;
vector<long long> x;
vector<bool> vis;
long long n, m, k;
void dfs(long long r, long long val) {
vis[r] = true;
for (long long i = 0; i < adj[r].size(); i++) {
long long c = adj[r][i].first;
long long w = adj[r][i].second;
if (w >= val) continue;
if (vis[c]) continue;
dfs(c, val);
}
}
bool check(long long val) {
vis.clear();
vis.resize(n, false);
dfs(x[0], val);
for (long long i = 0; i < k; i++) {
if (!vis[x[i]]) return true;
}
return false;
}
long long solve(long long l, long long r) {
while (true) {
long long len = (r - l) + 1;
if (len == 1) {
return l;
} else if (len == 2) {
if (check(r))
return r;
else
return l;
} else {
long long mid = (l + r) / 2;
if (check(mid)) {
if (!check(mid + 1))
return mid;
else
l = mid + 1;
} else {
r = mid - 1;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
adj.resize(n);
x.resize(k);
for (long long i = 0; i < k; i++) {
cin >> x[i];
x[i]--;
}
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
u--;
v--;
adj[u].push_back(make_pair(v, w));
adj[v].push_back(make_pair(u, w));
}
long long val = solve(1, 1e9);
for (long long i = 0; i < k; i++) {
cout << val << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = (int)1e5 + 5;
struct info {
int l, r, w;
inline bool operator<(const info &x) const { return this->w < x.w; }
} E[N];
int n, m, k, x, y, z, fa[N];
bool spe[N];
int get_fa(int x) { return (fa[x] == x) ? x : fa[x] = get_fa(fa[x]); }
inline int kruscal() {
int ret = 0;
std::sort(E + 1, E + 1 + m);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int fx = get_fa(E[i].l), fy = get_fa(E[i].r);
if (fx == fy) continue;
fa[fx] = fy;
if (spe[fx] || spe[fy]) {
if (spe[fx] && spe[fy]) ret = E[i].w;
spe[fx] = spe[fy] = true;
}
}
return ret;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= k; i++) scanf("%d", &x), spe[x] = true;
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &x, &y, &z);
if (x == y) continue;
E[i].l = x, E[i].r = y, E[i].w = z;
}
int res = kruscal();
while (k--) printf("%d ", res);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 100;
long long len[N], n, m, parent[N], u, v, ww, ans;
vector<pair<long long, pair<long long, long long> > > arr;
vector<long long> g[N];
void make_set() {
for (long long i = 1; i <= n; i++) parent[i] = i;
}
long long find_set(long long v) {
if (parent[v] == v) return v;
return parent[v] = find_set(parent[v]);
}
long long union_set(long long a, long long b) {
long long x = find_set(a);
long long y = find_set(b);
long long c = len[x];
long long d = len[y];
if (x != y) {
if (len[x] < len[y]) swap(x, y);
parent[y] = x;
if (len[y] != 0 && len[x] != 0) len[x] += len[y];
if (len[x] == ww || len[y] == ww) return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long c, s, mx;
cin >> n >> m >> ww;
make_set();
for (long long i = 0; i < ww; i++) {
cin >> s;
len[s] = 1;
}
for (long long i = 1; i <= m; i++) {
cin >> u >> v >> c;
arr.push_back({c, {u, v}});
}
sort(arr.begin(), arr.end());
for (long long i = 0; i < arr.size(); i++) {
long long w = arr[i].first;
long long a = arr[i].second.first;
long long b = arr[i].second.second;
long long x = find_set(a);
long long y = find_set(b);
if (x != y) {
long long k = union_set(a, b);
if (k) {
for (long long i = 0; i < ww; i++) cout << w << " ";
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
int u[maxn];
void Start() {
for (int i = 0; i < maxn; i++) u[i] = i;
}
int Find(int x) {
if (x == u[x]) return x;
return u[x] = Find(u[x]);
}
int xk[maxn], vk[maxn], mx = 0;
vector<pair<int, int> > e[maxn];
int dfs(int s) {
vk[s] = 1;
int sx = xk[s];
for (auto n : e[s]) {
if (!vk[n.first]) {
int u = dfs(n.first);
if (u > 0) mx = max(mx, n.second);
sx += u;
}
}
return sx;
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
int rt;
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
xk[x] = 1;
rt = x;
}
vector<tuple<int, int, int> > ee;
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
ee.push_back(make_tuple(w, u, v));
}
Start();
sort(ee.begin(), ee.end());
for (int i = 0; i < m; i++) {
int u, v, w;
tie(w, u, v) = ee[i];
if (Find(u) != Find(v)) {
::u[Find(u)] = Find(v);
e[u].push_back({v, w});
e[v].push_back({u, w});
}
}
dfs(rt);
for (int i = 0; i < k; i++) printf("%d ", mx);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long power(long long a, long long b) {
long long x = 1;
a = a % 1000000007ULL;
while (b) {
if (b & 1) x = (x * a) % 1000000007ULL;
a = (a * a) % 1000000007ULL;
b >>= 1;
}
return x;
}
inline long long inv(long long a) { return power(a, 1000000007ULL - 2); }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
const int N = 1e5 + 5;
int n, m, k;
vector<pair<int, pair<int, int> > > edge;
set<int> special;
int par[N], spcl[N], res[N];
int node[N];
int find(int a) { return a == par[a] ? a : par[a] = find(par[a]); }
void join(int a, int b) { par[find(b)] = find(a); }
map<int, int> mpp;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
int u, v, w;
for (int i = 0; i < k; i++) {
cin >> node[i];
spcl[node[i]] = node[i];
}
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
edge.push_back(make_pair(w, make_pair(u, v)));
}
sort(edge.begin(), edge.end());
for (int i = 1; i <= n; i++) par[i] = i;
for (int i = 0; i < m; i++) {
u = find(edge[i].second.first);
v = find(edge[i].second.second);
if (spcl[u] != 0 && spcl[v] != 0 && spcl[u] != spcl[v]) {
res[spcl[u]] = edge[i].first;
res[spcl[v]] = edge[i].first;
}
join(edge[i].second.first, edge[i].second.second);
if (spcl[u] != 0)
spcl[find(edge[i].second.first)] = spcl[u];
else if (spcl[v] != 0)
spcl[find(edge[i].second.first)] = spcl[v];
}
for (int i = 1; i <= n; i++) {
par[i] = find(i);
}
for (int i = 0; i < k; i++) {
if (mpp.find(par[node[i]]) == mpp.end()) mpp[par[node[i]]] = 0;
mpp[par[node[i]]] = max(mpp[par[node[i]]], res[node[i]]);
}
for (int i = 0; i < k; i++) cout << mpp[par[node[i]]] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct qq {
int u;
int v;
int d;
};
bool compare(qq a, qq b) { return (a.d < b.d); }
int n, m, k;
qq a[100005];
int Size[100005];
int Root[100005];
int Find_Root(int x) {
while (Root[x] != x) {
Root[x] = Root[Root[x]];
x = Root[x];
}
return x;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
memset(Size, 0, sizeof(Size));
for (int i = 1; i <= n; i++) Root[i] = i;
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
Size[x] = 1;
}
for (int i = 1; i <= m; i++) cin >> a[i].u >> a[i].v >> a[i].d;
sort(a + 1, a + 1 + m, compare);
for (int i = 1; i <= m; i++) {
int u = a[i].u;
int v = a[i].v;
int d = a[i].d;
int ru = Find_Root(u);
int rv = Find_Root(v);
if (ru == rv) continue;
Root[rv] = ru;
Size[ru] += Size[rv];
if (Size[ru] >= k) {
for (int j = 1; j <= k; j++) cout << a[i].d << " ";
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Input {
const int BUF = 65536;
char buf[BUF + 1], *head = buf, *tail = buf;
inline char inputChar() {
if (head == tail) *(tail = (head = buf) + fread(buf, 1, BUF, stdin)) = 0;
return *head++;
}
inline void inputNum(int &x) {
char c = inputChar();
while (c < '0' || c > '9') c = inputChar();
for (x = 0; c >= '0' && c <= '9'; c = inputChar()) x = x * 10 + c - '0';
}
} // namespace Input
using Input::inputNum;
const int MAXN = 101010;
int n, m, k, x0, f[MAXN], ans = 0;
bool mark[MAXN] = {0};
vector<pair<int, int> > ch[MAXN];
struct edge {
int x, y, v;
bool operator<(const edge &E) const { return v < E.v; }
} e[MAXN];
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int dfs(int x, int fa) {
int cnt = mark[x];
int num = ch[x].size();
int v = 0;
for (int i = 0; i < num; ++i) {
int t = ch[x][i].first;
if (t != fa)
cnt += dfs(t, x);
else
v = ch[x][i].second;
}
if (cnt) ans = max(ans, v);
return cnt;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < k; ++i) cin >> x0, mark[x0] = true;
for (int i = 0; i < m; ++i) cin >> e[i].x >> e[i].y >> e[i].v;
sort(e, e + m);
for (int i = 1; i <= n; ++i) f[i] = i;
for (int i = 0, x, y; i < m; ++i)
if (find(x = e[i].x) != find(y = e[i].y)) {
ch[x].push_back(make_pair(y, e[i].v));
ch[y].push_back(make_pair(x, e[i].v));
f[f[x]] = f[y];
}
dfs(x0, -1);
while (k--) cout << ans << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A, typename B>
istream &operator>>(istream &cin, pair<A, B> &p) {
cin >> p.first;
return cin >> p.second;
}
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
const long long N = 1e7 + 7;
const long long mod = 1e9 + 7;
const long long inf = 1e17;
const long double pi = 3.14159265358979323846;
vector<pair<long long, pair<long long, long long>>> elist;
vector<pair<long long, long long>> edges[100005];
long long dp[100005];
long long check[100005];
long long parent[100005];
long long sz[100005];
long long ans, k;
long long find_set(long long v) {
if (v == parent[v]) {
return v;
}
return parent[v] = find_set(parent[v]);
}
bool merge(long long u, long long v) {
u = find_set(u);
v = find_set(v);
if (u == v) {
return 0;
}
if (sz[u] < sz[v]) swap(u, v);
parent[v] = u;
sz[u] += sz[v];
return 1;
}
void dfs(long long v, long long p, long long wt) {
dp[v] = check[v];
for (auto y : edges[v]) {
if (y.first != p) {
dfs(y.first, v, y.second);
dp[v] += dp[y.first];
}
}
if (min(dp[v], k - dp[v])) ans = max(ans, wt);
}
void test_case() {
long long n, m;
cin >> n >> m >> k;
long long a[k];
for (long long i = 0; i < k; i++) {
cin >> a[i];
a[i]--;
check[a[i]] = 1;
}
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
u--, v--;
elist.push_back({w, {u, v}});
}
sort(elist.begin(), elist.end());
for (long long i = 0; i < n; i++) {
parent[i] = i;
sz[i] = 1;
}
for (auto x : elist) {
if (merge(x.second.first, x.second.second)) {
edges[x.second.first].push_back({x.second.second, x.first});
edges[x.second.second].push_back({x.second.first, x.first});
}
}
dfs(0, -1, 0);
for (long long i = 0; i < k; i++) cout << ans << " ";
cout << "\n";
}
int main() {
{ ios_base::sync_with_stdio(false); }
{
cin.tie(NULL);
cout.tie(NULL);
}
int t = 1;
cout << setprecision(12) << fixed;
for (long long i = 0; i < t; i++) {
test_case();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e14 + 9;
vector<pair<long long, long long> > adj[200009];
long long n, m;
long long dis[200009];
void addedge(long long a, long long b, long long c) {
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
void INFINITAR() {
for (long long i = 0; i <= n; i++) {
dis[i] = INF;
}
}
void dijkstra(int x) {
INFINITAR();
dis[x] = 0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
pq.push({0, x});
while (!pq.empty()) {
auto f = pq.top();
pq.pop();
if (dis[f.second] < f.first) continue;
for (auto e : adj[f.second]) {
if (max(f.first, e.second) < dis[e.first]) {
dis[e.first] = max(f.first, e.second);
pq.push({dis[e.first], e.first});
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long k;
cin >> n >> m >> k;
int sp[200009];
memset(sp, 0, sizeof sp);
long long spini = -1;
for (long long i = 0; i < (k); ++i) {
long long a;
cin >> a;
a--;
spini = a;
sp[a] = 1;
}
while (m--) {
long long a, b, c;
cin >> a >> b >> c;
a--;
b--;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
long long ans = 0;
dijkstra(spini);
for (long long i = 0; i < (n); ++i) {
if (sp[i] == 1) ans = max(ans, dis[i]);
}
for (long long i = 0; i < (k); ++i) {
cout << ans << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T>
int chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
int chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T mmin(T a, T b) {
return a < b ? a : b;
}
template <class T>
T mmax(T a, T b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
int dcmp(T a, T b) {
return a > b;
}
template <int *a>
int cmp_a(int first, int second) {
return a[first] < a[second];
}
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
inline void read(int &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
}
inline void read(char &first) {
first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
inline void read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
;
while (!(*first == '\n' || *first == ' ' || *first == '\r'))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
template <typename A, typename... B>
inline void read(A &first, B &...second) {
read(first);
read(second...);
}
inline void write(int first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
}
inline void write(char first) { putc(first); }
inline void write(const char *first) {
while (*first) {
putc(*first);
++first;
}
}
inline void write(char *first) {
while (*first) {
putc(*first);
++first;
}
}
template <typename A, typename... B>
inline void write(A first, B... second) {
write(first);
write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
int fa[200005], ans[200005], w[200005];
struct edg {
int u, v, w;
} e[200005];
int cmp(edg a, edg b) { return a.w < b.w; }
int find(int first) {
return first == fa[first] ? first : fa[first] = find(fa[first]);
}
int main() {
int n, m, k, first;
read(n, m, k);
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1; i <= k; ++i) {
read(first);
w[first] = 1;
}
for (int i = 1; i <= m; ++i) {
read(e[i].u, e[i].v, e[i].w);
}
sort(e + 1, e + m + 1, cmp);
int t = n, u, v;
for (int i = 1; i <= m; ++i)
if (find(e[i].u) != find(e[i].v)) {
u = find(e[i].u);
v = find(e[i].v);
w[u] += w[v];
fa[v] = u;
if (w[u] == k) {
for (int j = 1; j <= k; ++j)
printf("%d%c", e[i].w, j == k ? '\n' : ' ');
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
int n, m, k, x[maxn], tot, fa[maxn], ans, no[maxn];
struct node {
int u, v, w;
bool operator<(const node &rhs) const { return w > rhs.w; }
};
priority_queue<node> Q;
inline int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void merge(const node &t) {
int x = find(t.u), y = find(t.v);
if (x == y) return;
tot--;
if (no[x] && no[y]) ans = max(ans, t.w);
if (no[x]) no[y] = 1;
fa[x] = y;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; ++i) scanf("%d", &x[i]), no[x[i]] = 1;
for (int i = 1, u, v, w; i <= m; ++i)
scanf("%d%d%d", &u, &v, &w), Q.push({u, v, w});
for (int i = 1; i <= n; ++i) fa[i] = i;
tot = n;
while (tot > 1) merge(Q.top()), Q.pop();
for (int i = 1; i <= k; ++i) printf("%d ", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
class edge {
public:
int u, v, w;
edge(int U, int V, int W) {
u = U;
v = V;
w = W;
}
};
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> v(k, 0);
vector<edge> e;
for (int i = 0; i < k; i++) cin >> v[i];
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
e.push_back(edge(u, v, w));
}
sort(e.begin(), e.end(), [&](edge e1, edge e2) { return e1.w < e2.w; });
vector<int> score(n, 0), parent(n, 0);
for (int i = 0; i < n; i++) parent[i] = i;
for (int i = 0; i < k; i++) {
score[v[i] - 1] = 1;
}
function<int(int)> par = [&](int u) {
if (parent[u] == u)
return u;
else
return parent[u] = par(parent[u]);
};
function<void(int, int)> merg = [&](int x, int y) {
int p1 = par(x), p2 = par(y);
if (p1 == p2) return;
parent[p1] = p2;
score[p2] += score[p1];
return;
};
int ans = -1;
for (int i = 0; i < m; i++) {
int x = e[i].u, y = e[i].v;
merg(x, y);
int p1 = par(x);
if (score[p1] == k) {
ans = e[i].w;
break;
}
}
for (int i = 0; i < k; i++) cout << ans << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct node {
long long int u, v, w;
} edge[N];
bool cmp(node a, node b) { return a.w < b.w; }
long long int n, m, k, v, ans = 0;
bool special[N];
long long int root[N];
long long int find_root(long long int x) {
if (root[x] == x) return x;
return root[x] = find_root(root[x]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (long long int i = 0; i <= k - 1; ++i) {
cin >> v;
special[v] = true;
}
for (long long int i = 0; i <= m - 1; ++i) {
cin >> edge[i].u >> edge[i].v >> edge[i].w;
}
sort(edge, edge + m, cmp);
for (long long int i = 1; i <= n; ++i) root[i] = i;
for (long long int i = 0; i <= m - 1; ++i) {
long long int root_u = find_root(edge[i].u);
long long int root_v = find_root(edge[i].v);
if (root_u != root_v) {
if (special[root_u] && special[root_v]) {
ans = max(ans, edge[i].w);
}
if (special[root_u])
root[root_v] = root_u;
else
root[root_u] = root_v;
}
}
for (long long int j = 1; j <= n; ++j) {
if (special[j]) cout << ans << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int n, m, k;
int x[N], chk[N], vis[N];
vector<pair<int, int> > con[N];
int dfs(int u, int mid) {
vis[u] = 1;
int res = chk[u];
for (auto it : con[u])
if (!vis[it.first] && it.second <= mid) res += dfs(it.first, mid);
return res;
}
bool can(int mid, int n, int k) {
for (int i = 1; i <= n; i++) vis[i] = 0;
return dfs(x[1], mid) == k;
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
cin >> x[i];
chk[x[i]] = 1;
}
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
con[u].push_back({v, w});
con[v].push_back({u, w});
}
int st = 0, en = 1e9 + 10, mid, ans = en;
while (st <= en) {
mid = st + en >> 1;
if (can(mid, n, k)) {
ans = mid;
en = mid - 1;
} else
st = mid + 1;
}
for (int i = 1; i <= k; i++) cout << ans << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = vector<V<T>>;
template <typename T>
using Mi = map<long long, T>;
template <typename T>
using MMi = map<long long, Mi<T>>;
vector<long long> tree;
void build(vector<long long> &arr, long long ind, long long l, long long r) {
if (l == r) {
tree[ind] = arr[l];
return;
}
long long mid = (l + r) / 2;
build(arr, ind * 2, l, mid);
build(arr, ind * 2 + 1, mid + 1, r);
tree[ind] = max(tree[ind * 2], tree[ind * 2 + 1]);
}
long long getMax(long long ind, long long tl, long long tr, long long l,
long long r) {
if (l > r) return 0;
if (l == tl && r == tr) return tree[ind];
long long tm = (tl + tr) / 2;
long long a = getMax(ind * 2, tl, tm, l, min(r, tm));
long long b = getMax(ind * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
return max(a, b);
}
vector<bool> prim;
void er() {
long long n = 1e6;
prim = vector<bool>(n + 1, true);
prim[0] = prim[1] = false;
for (long long i = 2; i <= n; i++) {
if (prim[i]) {
for (long long j = i * i; j <= n; j += i) {
prim[j] = false;
}
}
}
}
vector<long long> topSort(long long v, V<set<long long>> &g) {
vector<long long> ans;
vector<bool> viz(g.size(), false);
return ans;
}
long long rast(pair<long long, long long> &a, pair<long long, long long> &b) {
return abs(a.first - b.first) + abs(a.second - b.second);
}
vector<long long> z_function(string &s) {
long long n = s.length();
vector<long long> z(n, 0);
long long l = 0, r = 0;
for (long long i = 1; i < n; i++) {
if (i <= r) {
z[i] = min(r - i + 1, z[i - l]);
}
while (i + z[i] < n && s[z[i]] == s[z[i] + i]) {
z[i]++;
}
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
return z;
}
bool comp(const string &a, const string &b) { return a.size() < b.size(); }
void printTest() {
freopen("output.txt", "w", stdout);
cout << "1000 500 1000" << '\n';
for (int i = 0; i < 500; i++) {
cout << i * 2 << " " << i * 2 + 1 << '\n';
}
for (int i = 0; i < 1000; i++) {
cout << i << " " << 1000 - i << '\n';
}
}
void dfs(long long v, long long mid, VV<pair<long long, long long>> &g,
vector<bool> &viz, long long &ans, vector<bool> &need) {
viz[v] = true;
if (need[v]) {
ans++;
}
for (pair<long long, long long> &p : g[v]) {
long long &w = p.first;
long long &u = p.second;
if (w >= mid) {
return;
}
if (!viz[u]) {
dfs(u, mid, g, viz, ans, need);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
vector<bool> need(n, false);
long long vertx;
for (long long i = 0; i < k; i++) {
long long a;
cin >> a;
a--;
need[a] = true;
vertx = a;
}
VV<pair<long long, long long>> g(n);
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
u--;
v--;
g[v].push_back({w, u});
g[u].push_back({w, v});
}
for (int i = 0; i < n; i++) {
sort(g[i].begin(), g[i].end());
}
long long l, r;
l = 1;
r = 1e9;
while (l < r) {
long long mid = (l + r + 1) / 2;
long long ans = 0;
vector<bool> viz(n, false);
dfs(vertx, mid, g, viz, ans, need);
if (ans == k) {
r = mid - 1;
} else {
l = mid;
}
}
for (int i = 0; i < k; i++) {
cout << r << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, k;
int num_spec[N];
int r[N];
int res;
int root(int u) {
if (r[u] != u) return r[u] = root(r[u]);
return u;
}
struct tp {
int u, v, w;
} edge[N];
bool cmp(tp a, tp b) { return a.w < b.w; }
int main() {
int u, v, w, ru, rv;
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
cin >> u;
num_spec[u]++;
}
for (int i = 1; i <= n; i++) r[i] = i;
for (int i = 1; i <= m; i++) cin >> edge[i].u >> edge[i].v >> edge[i].w;
sort(edge + 1, edge + 1 + m, cmp);
for (int i = 1; i <= m; i++) {
u = edge[i].u, v = edge[i].v, w = edge[i].w;
ru = root(u), rv = root(v);
if (ru != rv) {
r[ru] = rv;
num_spec[rv] += num_spec[ru];
if (num_spec[rv] == k) {
res = w;
break;
}
}
}
for (int i = 1; i <= k; i++) cout << res << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 44;
const int X[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int Y[] = {0, 1, 0, -1, 1, 1, -1, -1};
const int mod = 1e9 + 7;
const int INF = INT_MAX;
int p[N], sz[N], a[N], x[N], gr[N];
vector<pair<int, pair<int, int> > > e;
int get(int a) {
if (p[a] == a) return a;
return p[a] = get(p[a]);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> a[i];
x[--a[i]] = 1;
}
for (int i = 0; i < n; i++) {
p[i] = i;
sz[i] = 1;
gr[i] = 0;
}
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
e.push_back({w, {u, v}});
}
sort(e.begin(), e.end());
for (int i = 0; i < e.size(); i++) {
int w = e[i].first, u = e[i].second.first, v = e[i].second.second;
if (u == v) gr[u] = w;
u = get(u);
v = get(v);
if (u == v) continue;
if (x[u] && x[v]) {
gr[u] = gr[v] = w;
}
if (sz[u] < sz[v]) swap(u, v);
if (x[v]) swap(u, v);
sz[u] += sz[v];
p[v] = u;
x[u] |= x[v];
}
for (int i = 0; i < k; i++) {
cout << gr[get(a[i])] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, r[100002];
pair<int, pair<int, int> > s[100002];
int gr(int x) { return (r[x] > 0 ? r[x] = gr(r[x]) : x); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
int i;
for (i = 1; i <= k; ++i) {
int x;
cin >> x;
r[x] = -1;
}
for (i = 1; i <= m; ++i) {
int u, v, w;
cin >> u >> v >> w;
s[i] = {w, {u, v}};
}
sort(s + 1, s + m + 1);
int u, v, w;
for (i = 1; i <= m; ++i) {
u = gr(s[i].second.first), v = gr(s[i].second.second), w = s[i].first;
if (u == v) continue;
r[u] += r[v];
r[v] = u;
if (r[u] == -k) break;
}
for (i = 1; i <= k; ++i) cout << w << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt, tot, ans, dgr[200009], p[200009], h[200009], fst[200009],
pnt[200009 << 1], len[200009 << 1], nxt[200009 << 1], fa[200009];
pair<int, pair<int, int> > a[200009];
bool vis[200009], ban[200009], bo[200009];
int read() {
int x = 0;
char ch = getchar();
bool flag = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return flag ? -x : x;
}
long long readll() {
long long x = 0;
char ch = getchar();
bool flag = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return flag ? -x : x;
}
void add(int x, int y, int z) {
dgr[x]++;
pnt[++tot] = y;
len[tot] = z;
nxt[tot] = fst[x];
fst[x] = tot;
}
void ins(int x, int y, int z) {
add(x, y, z);
add(y, x, z);
}
int getfa(int x) { return x == fa[x] ? x : fa[x] = getfa(fa[x]); }
void dfs(int x) {
int i, y;
vis[x] = 1;
for (i = fst[x]; i; i = nxt[i]) {
y = pnt[i];
if (!ban[y] && !vis[y]) {
ans = max(ans, len[i]);
dfs(y);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &cnt);
int i, x, y, z;
for (i = 1; i <= cnt; i++) {
scanf("%d", &p[i]);
bo[p[i]] = 1;
}
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
a[i] = make_pair(z, make_pair(x, y));
}
sort(a + 1, a + m + 1);
for (i = 1; i <= n; i++) fa[i] = i;
for (i = 1; i <= m; i++) {
x = getfa(a[i].second.first);
y = getfa(a[i].second.second);
if (x != y) {
fa[x] = y;
ins(a[i].second.first, a[i].second.second, a[i].first);
}
}
int head = 0, tail = 0;
for (i = 1; i <= n; i++)
if (dgr[i] == 1 && !bo[i]) {
h[++tail] = i;
ban[i] = 1;
}
while (head < tail) {
x = h[++head];
for (i = fst[x]; i; i = nxt[i]) {
y = pnt[i];
if (!ban[y]) {
dgr[y]--;
if (dgr[y] == 1 && !bo[y]) {
ban[y] = 1;
h[++tail] = y;
}
}
}
}
dfs(p[1]);
while (cnt--) printf("%d%c", ans, cnt ? ' ' : '\n');
return 0;
}
|
#include <bits/stdc++.h>
using std::abs;
using std::bitset;
using std::cerr;
using std::cin;
using std::cout;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::set;
using std::sort;
using std::string;
using std::swap;
using std::unordered_map;
using std::unordered_set;
using std::vector;
using ll = long long;
using uint = unsigned int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ull = unsigned long long;
using ld = long double;
using vci = vector<int>;
using vcl = vector<ll>;
template <typename T>
void _dbg(const char* _s, T _h) {
cerr << _s << " = " << _h << "\n";
}
template <typename T, typename... Ts>
void _dbg(const char* _s, T _h, Ts... _t) {
int _b = 0;
while (((_b += *_s == '(') -= *_s == ')') != 0 || *_s != ',') cerr << *_s++;
cerr << " = " << _h << ",";
_dbg(_s + 1, _t...);
}
struct init {
init() {
cin.tie(0);
std::iostream::sync_with_stdio(0);
cout << std::fixed << std::setprecision(10);
cerr << std::fixed << std::setprecision(5);
}
~init() {}
} init;
template <typename T, typename U>
void upx(T& x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
void upn(T& x, U y) {
if (x > y) x = y;
}
const ll N = 1e5 + 1;
struct edge {
ll a, b, c;
} es[N];
ll p[N], rank[N], cnt[N];
ll get(ll x) { return x == p[x] ? x : (p[x] = get(p[x])); }
bool un(ll x, ll y) {
if ((x = get(x)) == (y = get(y))) return 0;
if (rank[x] < rank[y]) swap(x, y);
p[y] = x;
if (rank[x] == rank[y]) rank[x]++;
cnt[x] += cnt[y];
return 1;
}
int32_t main() {
ll n, m, k;
cin >> n >> m >> k;
for (ll i = 0; i < k; ++i) {
ll x;
cin >> x;
cnt[x] = 1;
}
for (ll i = 0; i < m; ++i) cin >> es[i].a >> es[i].b >> es[i].c;
sort(es, es + m, [](const edge& p1, const edge& p2) { return p1.c < p2.c; });
for (ll i = 1; i <= n; ++i) {
p[i] = i;
}
for (ll i = 0; i < m; ++i) {
;
if (un(es[i].a, es[i].b)) {
if (cnt[get(es[i].a)] == k) {
for (ll j = 0; j < k; ++j) cout << es[i].c << ' ';
cout << '\n';
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mx = 1e5 + 1;
vector<long long> par(mx);
long long find(long long a) {
if (a != par[a]) par[a] = find(par[a]);
return par[a];
}
int main() {
vector<long long> size(mx);
long long n, m, k, u, v, w, a, b, x, y;
cin >> n >> m >> k;
vector<long long> spnode(k);
for (long long i = 0; i < k; i++) {
cin >> spnode[i];
size[spnode[i]]++;
}
vector<tuple<long long, long long, long long>> edge(m);
for (long long i = 0; i < m; i++) {
cin >> u >> v >> w;
edge[i] = make_tuple(w, u, v);
}
sort(edge.begin(), edge.end());
for (long long i = 1; i <= n; i++) par[i] = i;
for (long long i = 0; i < m; i++) {
a = get<1>(edge[i]);
b = get<2>(edge[i]);
a = find(a);
b = find(b);
if (a == b) continue;
if (size[a] + size[b] == k) {
for (long long j = 0; j < k; j++) cout << get<0>(edge[i]) << ' ';
cout << endl;
break;
}
size[b] += size[a];
par[a] = par[b];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int nm = 0, fh = 1;
char cw = getchar();
for (; !isdigit(cw); cw = getchar())
if (cw == '-') fh = -fh;
for (; isdigit(cw); cw = getchar()) nm = nm * 10 + (cw - '0');
return nm * fh;
}
struct node {
int x, y, w;
} p[1000010];
int fa[1000010], cnt[1000010], vis[1000010], n, m, k;
bool cmp(node x1, node x2) { return x1.w < x2.w; }
int fd(int x) { return x == fa[x] ? x : fa[x] = fd(fa[x]); }
bool merge(int x, int y) {
int t1 = fd(x), t2 = fd(y);
if (t1 == t2) return false;
fa[t1] = t2;
cnt[t2] += cnt[t1];
if (cnt[t2] == k) return true;
return false;
}
int main() {
n = read(), m = read(), k = read();
for (int i = 1; i <= k; i++) vis[read()] = 1;
for (int i = 1; i <= n; i++) {
fa[i] = i;
if (vis[i]) cnt[i] = 1;
}
for (int i = 1; i <= m; i++)
p[i].x = read(), p[i].y = read(), p[i].w = read();
sort(p + 1, p + m + 1, cmp);
for (int i = 1; i <= m; i++) {
if (merge(p[i].x, p[i].y)) {
for (int j = 1; j <= k; j++) printf("%d ", p[i].w);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> g[100010];
struct EDGE {
int u, v, w;
friend bool operator<(const EDGE& a, const EDGE& b) { return a.w < b.w; }
} edge[100010];
int par[100010], size[100010], ans, n, m, k;
int find(int x) { return par[x] == x ? x : par[x] = find(par[x]); }
void dfs(int p, int fa) {
for (auto i : g[p])
if (i.first != fa) {
dfs(i.first, p);
size[p] += size[i.first];
if (size[i.first] != 0 && size[i.first] != k) ans = max(ans, i.second);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
size[x] = 1;
}
for (int i = 1; i <= m; i++)
scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
sort(edge + 1, edge + m + 1);
for (int i = 1; i <= n; i++) par[i] = i;
for (int i = 1; i <= m; i++) {
int a = find(edge[i].u), b = find(edge[i].v);
if (a != b) {
par[a] = b;
g[edge[i].u].push_back({edge[i].v, edge[i].w});
g[edge[i].v].push_back({edge[i].u, edge[i].w});
}
}
dfs(1, 0);
for (int i = 1; i <= k; i++) printf("%d%c", ans, " \n"[i == k]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, k;
int par[N], sp[N], check[N], res = 0, p[N], loop[N], should[N];
vector<pair<int, int> > adj[N];
queue<int> q;
pair<int, pair<int, int> > edge[N];
int root(int u) { return par[u] < 0 ? u : (par[u] = root(par[u])); }
bool join(int u, int v) {
if ((u = root(u)) == (v = root(v))) return false;
if (par[u] > par[v]) swap(u, v);
par[u] += par[v];
par[v] = u;
return true;
}
void CalcLeaf(int u, int parent) {
p[u] = parent;
should[u] = sp[u];
if (adj[u].size() == 1 && parent != -1 && !sp[u]) q.push(u);
for (pair<int, int> a : adj[u])
if (a.first != parent) CalcLeaf(a.first, u), should[u] |= should[a.first];
}
void dfs(int u, int parent) {
for (pair<int, int> a : adj[u])
if (!check[a.first] && a.first != parent)
res = max(res, a.second), dfs(a.first, u);
}
int main() {
if (fopen("train.inp", "r")) {
freopen("train.inp", "r", stdin);
freopen("train.out", "w", stdout);
}
int root;
memset(par, -1, sizeof(par));
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
sp[x] = 1;
root = x;
}
memset(loop, 60, sizeof(loop));
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &edge[i].second.first, &edge[i].second.second,
&edge[i].first);
if (edge[i].second.first == edge[i].second.second &&
sp[edge[i].second.second])
loop[edge[i].second.first] =
min(loop[edge[i].second.first], edge[i].first);
}
sort(edge + 1, edge + 1 + m);
for (int i = 1; i <= m; i++)
if (join(edge[i].second.first, edge[i].second.second))
adj[edge[i].second.first].push_back(
pair<int, int>(edge[i].second.second, edge[i].first)),
adj[edge[i].second.second].push_back(
pair<int, int>(edge[i].second.first, edge[i].first));
CalcLeaf(root, -1);
while (q.size()) {
int u = q.front();
q.pop();
check[u] = 1;
if (!check[p[u]] && !sp[p[u]] && !should[p[u]]) q.push(p[u]);
}
dfs(root, -1);
for (int i = 1; i <= k; i++) printf("%d ", res);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool fs(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
struct st {
long long int u;
long long int v;
long long int w;
};
long long int node, edge, k;
long long int isTaken[100010 + 5];
long long int special[100010 + 5];
vector<st> vv;
int par[100010 + 5];
void init() {
for (int i = 0; i < 100010; i++) {
par[i] = i;
}
}
int find_par(int a) {
if (par[a] == a) {
return a;
}
return par[a] = find_par(par[a]);
}
bool comp(st a, st b) { return a.w < b.w; }
int main() {
init();
st temp;
long long int a, u, v, w, cnt = 0, ans;
fs(node);
fs(edge);
fs(k);
for (int i = 0; i < k; i++) {
fs(a);
special[a] = 1;
}
for (int i = 0; i < edge; i++) {
fs(temp.u);
fs(temp.v);
fs(temp.w);
vv.push_back(temp);
}
sort(vv.begin(), vv.end(), comp);
for (int i = 0; i < vv.size(); i++) {
temp = vv[i];
u = temp.u;
v = temp.v;
u = find_par(u);
v = find_par(v);
if (u == v) {
continue;
}
if (special[u] + special[v] == k) {
ans = temp.w;
break;
}
par[v] = par[u];
special[u] += special[v];
}
for (int i = 0; i < k; i++) {
if (i) {
printf(" ");
}
printf("%lld", ans);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, K;
struct Edge {
int a, b, c;
bool operator<(const Edge &p) const { return c < p.c; }
} w[301000];
int UF[201000], chk[201000];
int Find(int a) {
if (a == UF[a]) return a;
return UF[a] = Find(UF[a]);
}
int main() {
int i, a;
scanf("%d%d%d", &n, &m, &K);
for (i = 0; i < K; i++) {
scanf("%d", &a);
chk[a] = 1;
}
for (i = 0; i < m; i++) {
scanf("%d%d%d", &w[i].a, &w[i].b, &w[i].c);
}
for (i = 1; i <= n; i++) UF[i] = i;
sort(w, w + m);
int M = 0;
for (i = 0; i < m; i++) {
int a = Find(w[i].a), b = Find(w[i].b);
if (a != b) {
if (chk[a] && chk[b]) M = w[i].c;
chk[b] |= chk[a];
UF[a] = b;
}
}
for (i = 0; i < K; i++) printf("%d ", M);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> p;
int findp(int x) {
if (p[x] == x) return x;
p[x] = findp(p[x]);
return p[x];
}
void unionn(int x, int y) {
x = findp(x);
y = findp(y);
p[x] = y;
}
vector<vector<pair<int, long long> > > g;
vector<int> x;
long long ans = 0;
void dfs(int v, int p = -1, long long pred = 0) {
if (x[v]) ans = max(ans, pred);
for (auto x : g[v]) {
if (x.first == p) continue;
dfs(x.first, v, max(pred, x.second));
}
}
int main() {
ios_base::sync_with_stdio(0);
int n, m, k;
cin >> n >> m >> k;
vector<pair<long long, pair<int, int> > > have(m);
x.assign(n, 0);
p.assign(n, 0);
for (int i = 0; i < n; i++) p[i] = i;
int x0 = 0;
for (int i = 0; i < k; i++) {
int a;
cin >> a;
a--;
x0 = a;
x[a] = 1;
}
for (int i = 0; i < m; i++) {
long long w;
int a, b;
cin >> a >> b >> w;
a--, b--;
have[i] = {w, {a, b}};
}
sort(have.begin(), have.end());
g = vector<vector<pair<int, long long> > >(n);
for (int i = 0; i < m; i++) {
int a = have[i].second.first, b = have[i].second.second;
if (findp(a) == findp(b)) continue;
unionn(a, b);
g[a].push_back({b, have[i].first});
g[b].push_back({a, have[i].first});
}
dfs(x0);
for (int i = 0; i < k; i++) {
cout << ans << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int par[maxn], V[maxn], U[maxn], W[maxn], X[maxn], k;
bool cmp(int a, int b) { return W[a] < W[b]; }
int root(int v) {
if (par[v] < 0) return v;
return par[v] = root(par[v]);
}
bool merge(int v, int u) {
v = root(v), u = root(u);
if (v == u) return 0;
if (par[v] > par[u]) swap(v, u);
par[v] += par[u];
X[v] += X[u];
par[u] = v;
return (X[v] == k);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m >> k;
fill(par, par + n, -1);
for (int i = 0; i < k; i++) {
int x;
cin >> x;
x--;
X[x]++;
}
vector<int> E;
for (int i = 0; i < m; i++) {
cin >> V[i] >> U[i] >> W[i];
V[i]--;
U[i]--;
E.push_back(i);
}
sort(E.begin(), E.end(), cmp);
for (auto e : E) {
if (merge(V[e], U[e])) {
while (k--) {
cout << W[e] << ' ';
}
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long maxn = (long long)1e6 + 6;
const long double EPS = 1e-9;
const long long INF = (long long)1e18 + 18;
const long long mod = (long long)998244353;
long long n, m, k;
long long special[maxn];
long long max_edge = -1;
class dsu {
public:
long long n;
vector<long long> p;
vector<long long> sz;
dsu(long long _n) : n(_n) {
p.resize(n + 1);
sz.resize(n + 1, 0);
iota(p.begin(), p.end(), 0);
}
long long get(long long x) { return (x == p[x] ? x : (p[x] = get(p[x]))); }
bool merge(long long x, long long y, long long edge) {
x = get(x);
y = get(y);
if (x != y) {
if (sz[x] < sz[y]) swap(x, y);
p[y] = x;
sz[x] += sz[y];
if (sz[x] == k) {
max_edge = edge;
}
return true;
}
return false;
}
};
signed main() {
cin >> n >> m >> k;
for (long long i = 0; i < k; i++) {
cin >> special[i];
}
vector<tuple<long long, long long, long long> > edges;
for (long long i = 0; i < m; i++) {
long long u, v, cost;
cin >> u >> v >> cost;
edges.push_back(make_tuple(cost, u, v));
}
sort(edges.begin(), edges.end());
dsu d(n);
for (long long i = 0; i < k; i++) {
d.sz[special[i]] = 1;
}
for (long long i = 0; i < m; i++) {
long long u = get<1>(edges[i]), v = get<2>(edges[i]);
long long cost = get<0>(edges[i]);
d.merge(u, v, cost);
if (max_edge != -1) {
break;
}
}
for (long long i = 0; i < k; i++) {
cout << max_edge << " ";
if (i == k - 1) {
cout << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int M = 1e9 + 7;
vector<pair<long long, pair<long long, long long> > > edges;
long long parent[N], cnt[N], degree[N];
bool special[N], visited[N];
vector<long long> graph[N];
map<pair<long long, long long>, long long> mst;
long long root(long long x) {
if (parent[x] == x) return x;
return parent[x] = root(parent[x]);
}
void join(long long u, long long v) {
if (cnt[u] >= cnt[v])
parent[v] = u, cnt[u] += cnt[v];
else
parent[u] = v, cnt[v] += cnt[u];
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, k, x;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) cin >> x, special[x] = true;
for (int i = 0; i < m; i++) {
long long u, v, d;
cin >> u >> v >> d;
edges.push_back(make_pair(d, make_pair(u, v)));
}
for (int i = 1; i <= n; i++) parent[i] = i, cnt[i] = 1;
sort((edges).begin(), (edges).end());
for (auto i : edges) {
long long d = i.first, u = i.second.first, v = i.second.second;
long long ur = root(u);
long long vr = root(v);
if (ur != vr) {
join(ur, vr);
degree[u] += 1;
degree[v] += 1;
graph[u].push_back(v);
graph[v].push_back(u);
mst[make_pair(v, u)] = d;
mst[make_pair(u, v)] = d;
}
}
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
for (int i = 1; i <= n; i++)
if (degree[i] == 1) pq.push(make_pair(degree[i], i));
while (!pq.empty()) {
auto i = pq.top();
pq.pop();
int v = i.second;
if (visited[v] | special[v]) continue;
for (auto j : graph[v]) {
if (visited[j]) continue;
degree[j] -= 1;
if (degree[j] == 1) pq.push(make_pair(degree[j], j));
}
visited[v] = true;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (visited[i]) continue;
for (auto j : graph[i]) {
if (visited[j]) continue;
ans = max(ans, mst[make_pair(i, j)]);
}
}
for (long long i = 0; i < k; i++) cout << ans << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e9;
int n, m, k;
int spec[100001];
int dist[100001];
bool o[100001];
vector<pair<int, int> > graph[100001];
priority_queue<pair<int, int> > q;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < k; i++) scanf("%d", &spec[i]);
int u, v, w;
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &u, &v, &w);
graph[u].push_back(make_pair(v, w));
graph[v].push_back(make_pair(u, w));
}
for (int i = 1; i <= n; i++) dist[i] = MX;
q.push(make_pair(0, spec[0]));
dist[spec[0]] = 0;
while (!q.empty()) {
while (!q.empty() && o[q.top().second]) q.pop();
if (q.empty()) continue;
v = q.top().second;
w = -1 * q.top().first;
o[v] = 1;
q.pop();
for (int i = 0; i < graph[v].size(); i++) {
if (!o[graph[v][i].first]) {
dist[graph[v][i].first] =
min(dist[graph[v][i].first], max(graph[v][i].second, w));
q.push(make_pair(-1 * dist[graph[v][i].first], graph[v][i].first));
}
}
}
int m1 = 0;
for (int i = 0; i < k; i++) m1 = max(m1, dist[spec[i]]);
for (int i = 0; i < k; i++) printf("%d ", m1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> parent;
vector<int> Rank;
vector<int> Count;
int root(int v) {
if (parent[v] == v) return v;
return parent[v] = root(parent[v]);
}
bool DSU(int a, int b) {
a = root(a);
b = root(b);
if (a != b) {
if (Rank[b] > Rank[a]) swap(a, b);
Rank[a] += Rank[b];
Count[a] += Count[b];
parent[b] = a;
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
vector<pair<long long int, pair<int, int> > > Edges(m);
parent.resize(n + 1);
for (int i = 1; i <= n; i++) parent[i] = i;
Rank.resize(n + 1, 1);
Count.resize(n + 1, 0);
for (int i = 0; i < k; i++) {
int a;
cin >> a;
Count[a] = 1;
}
for (int i = 0; i < m; i++) {
int a, b;
long long int w;
cin >> a >> b >> w;
Edges[i] = make_pair(w, make_pair(a, b));
}
sort(Edges.begin(), Edges.end());
long long int last = -1;
for (int i = 0; i < m; i++) {
int a = Edges[i].second.first;
int b = Edges[i].second.second;
long long int w = Edges[i].first;
if (a != b) {
DSU(a, b);
if (last == -1 && Count[root(a)] == k) {
last = w;
}
}
}
for (int i = 0; i < k; i++) {
cout << last << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> kct;
vector<int> sz;
vector<int> par;
int kcomps;
int root(int i) {
if (par[i] == i) {
return i;
}
return par[i] = root(par[i]);
}
void unite(int a, int b) {
int x = root(a), y = root(b);
if (x == y) {
return;
}
if (sz[x] > sz[y]) {
swap(x, y);
}
if (kct[x] > 0 && kct[y] > 0) {
kcomps--;
}
par[x] = y;
sz[y] += sz[x];
kct[y] += kct[x];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
kcomps = k;
for (int q = 0; q <= n; q++) {
par.push_back(q);
sz.push_back(1);
kct.push_back(0);
}
for (int q = 0; q < k; q++) {
int a;
cin >> a;
kct[a] = 1;
}
vector<tuple<int, int, int>> edges;
for (int q = 0; q < m; q++) {
int a, b, c;
cin >> a >> b >> c;
edges.emplace_back(c, a, b);
}
sort(edges.begin(), edges.end());
int best = -1;
for (int q = 0; q < m; q++) {
int w, a, b;
tie(w, a, b) = edges[q];
unite(a, b);
if (kcomps == 1) {
best = w;
break;
}
}
for (int q = 0; q < k; q++) {
cout << best << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> tree(100005);
vector<long long> siz(100005);
vector<long long> sp(100005);
long long cnt;
void ini(long long n) {
for (long long i = 1; i <= n; i++) {
if (sp[i] == 1) siz[i] = 1;
tree[i] = i;
}
}
long long root(long long n) {
while (n != tree[n]) {
tree[n] = tree[tree[n]];
n = tree[n];
}
return n;
}
long long uni(long long a, long long b) {
if (siz[a] > siz[b]) {
siz[a] += siz[b];
tree[b] = tree[a];
return siz[a];
} else {
siz[b] += siz[a];
tree[a] = tree[b];
return siz[b];
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
long long n, m, k;
cin >> n >> m >> k;
for (long long i = 0; i < k; i++) {
long long t;
cin >> t;
sp[t] = 1;
}
ini(n);
vector<pair<long long, pair<long long, long long> > > edge;
for (long long i = 0; i < m; i++) {
long long t, tt, ttt;
cin >> t >> tt >> ttt;
edge.push_back(make_pair(ttt, make_pair(t, tt)));
}
sort(edge.begin(), edge.end());
long long check = 0;
for (long long i = 0; i < m; i++) {
long long w = edge[i].first;
long long x = edge[i].second.first;
long long y = edge[i].second.second;
if (root(x) != root(y)) {
check = uni(root(x), root(y));
}
if (check == k) {
for (long long i = 0; i < k; i++) cout << w << " ";
cout << endl;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, k;
vector<pair<int, int> > edges[400000];
vector<pair<int, pair<int, int> > > forsort;
vector<int> specials;
int par[400000], cntspecial[400000], nodespecial[400000];
int idspecial[400000];
int ans[400000];
int fnd(int pos) {
if (par[pos] == pos) return pos;
return par[pos] = fnd(par[pos]);
}
int sbtree[400000], anss;
void dfs(int pos, int par) {
for (auto to : edges[pos]) {
if (to.first == par) continue;
dfs(to.first, pos);
if (sbtree[to.first] > 0 && sbtree[to.first] < k)
anss = max(anss, to.second);
sbtree[pos] += sbtree[to.first];
}
sbtree[pos] += cntspecial[pos];
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) par[i] = i, nodespecial[i] = -1;
for (int i = 1; i <= k; i++) {
scanf("%d", &x);
specials.push_back(x);
cntspecial[x] = 1;
idspecial[x] = i;
nodespecial[x] = x;
}
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &x, &y, &z);
forsort.push_back({z, {x, y}});
}
sort(forsort.begin(), forsort.end());
for (auto e : forsort) {
int xx = e.second.first;
int yy = e.second.second;
int x = xx, y = yy;
int cc = e.first;
xx = fnd(xx);
yy = fnd(yy);
if (xx == yy) continue;
par[yy] = xx;
edges[x].push_back({y, cc});
edges[y].push_back({x, cc});
}
dfs(1, 0);
for (int i = 1; i <= k; i++) {
printf("%d ", anss);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int x;
int y;
int v;
};
point a[200000];
int cmp(const point &a, const point &b) {
if (a.v < b.v)
return 1;
else
return 0;
}
int fat[200000];
int specials[200000];
int father(int x) {
if (fat[x] != x)
return fat[x] = father(fat[x]);
else
return fat[x];
}
void unionn(int x, int y) {
int fa = father(x);
int fb = father(y);
if (fa != fb) {
fat[fa] = fb;
specials[fb] = specials[fa] + specials[fb];
}
}
int main() {
int i, j, n, m, k = 0, ans = 0, cnt = 0, aa = 0, b = 0, w = 0;
cin >> n >> m >> k;
for (i = 0; i < n; i++) {
fat[i] = i;
specials[i] = 0;
}
for (i = 0; i < k; i++) {
cin >> aa;
aa--;
specials[aa] = 1;
}
for (i = 0; i < m; i++) {
cin >> aa >> b >> w;
aa--;
b--;
a[i].x = aa;
a[i].y = b;
a[i].v = w;
}
sort(a, a + m, cmp);
for (i = 0; i < m; i++) {
if (father(a[i].x) != father(a[i].y)) {
ans += a[i].v;
unionn(a[i].x, a[i].y);
if (specials[father(a[i].x)] >= k) {
for (j = 0; j < k; j++) {
if (j != k - 1) {
printf("%d ", a[i].v);
} else {
printf("%d\n", a[i].v);
}
}
return 0;
}
cnt++;
}
if (cnt == n - 1) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<vector<pair<int, int> > > edges, edges2;
vector<int> special;
bool seen[100010];
bool seen2[100010];
bool reach[100010];
bool isSpecial[100010];
int best = -1;
void MST(const vector<vector<pair<int, int> > >& edges,
vector<vector<pair<int, int> > >& MSTedges) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
Q;
MSTedges.assign((int)edges.size(), vector<pair<int, int> >());
vector<int> seen((int)edges.size(), 0);
int root = edges[0].empty() ? 1 : 0;
seen[root] = 1;
int counter = 1;
int prv = root;
for (auto& e : edges[root]) Q.push(e);
while (counter != n) {
auto curr = Q.top();
Q.pop();
if (seen[curr.second]) continue;
for (auto& e : edges[curr.second]) Q.push(e);
seen[curr.second] = 1;
MSTedges[prv].push_back(curr);
MSTedges[curr.second].push_back(pair<int, int>(curr.first, prv));
prv = curr.second;
counter++;
}
}
bool DFS(const int u) {
seen2[u] = 1;
reach[u] = isSpecial[u];
for (auto& e : edges2[u]) {
if (!seen2[e.second]) {
if (DFS(e.second)) best = max(best, e.first);
reach[u] |= reach[e.second];
}
}
return reach[u];
}
int main() {
int m, k, u, v, w;
scanf("%d %d %d", &n, &m, &k);
edges.assign(n + 5, vector<pair<int, int> >());
edges2.assign(n + 5, vector<pair<int, int> >());
for (int i = 0; i < k; i++) {
scanf("%d", &v);
special.push_back(v);
isSpecial[v] = 1;
}
while (m--) {
scanf("%d %d %d", &u, &v, &w);
edges[u].push_back(pair<int, int>(w, v));
edges[v].push_back(pair<int, int>(w, u));
}
MST(edges, edges2);
DFS(special[0]);
for (auto& sp : special) printf("%d ", best);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long input() {
long long n;
cin >> n;
return n;
}
long long pw(long long a, long long b) {
return (!b ? 1 : (b & 1 ? a * pw(a * a, b / 2) : pw(a * a, b / 2)));
}
const long long MAXN = 1e5 + 10;
vector<pair<long long, pair<long long, long long>>> edge;
vector<pair<long long, long long>> adj[MAXN];
long long n, m, k, v, u, w, ans, sp[MAXN], x[MAXN], mark[MAXN], p[MAXN];
long long Find(long long v) { return (p[v] == -1 ? v : p[v] = Find(p[v])); }
void Union(long long v, long long u) {
long long pv = Find(v), pu = Find(u);
p[pu] = pv;
}
void MST() {
sort(((edge)).begin(), ((edge)).end());
for (long long i = 0; i < edge.size(); i++) {
long long v = edge[i].second.first, u = edge[i].second.second,
w = edge[i].first;
if (Find(v) != Find(u)) {
Union(v, u);
adj[v].push_back({u, w});
adj[u].push_back({v, w});
}
}
}
void dfs(long long v, long long mx = 0) {
if (sp[v]) ans = max(ans, mx);
mark[v] = 1;
for (pair<long long, long long> i : adj[v]) {
long long u = i.first, w = i.second;
if (!mark[u]) {
dfs(u, max(mx, w));
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
fill(p, p + MAXN, -1);
cin >> n >> m >> k;
for (long long i = 0; i < k; i++) {
cin >> x[i];
sp[x[i]] = 1;
}
for (long long i = 0; i < m; i++) {
cin >> v >> u >> w;
edge.push_back({w, {v, u}});
}
MST();
dfs(x[0]);
for (long long i = 0; i < k; i++) cout << ans << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
int n, m, k, x, y;
struct node {
int x, y, z;
bool operator<(const node &o) const { return z < o.z; }
} b[N];
int fa[N], a[N], ans;
int gf(int u) { return fa[u] == u ? u : fa[u] = gf(fa[u]); }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &x);
a[x] = 1;
}
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) scanf("%d%d%d", &b[i].x, &b[i].y, &b[i].z);
sort(b + 1, b + m + 1);
for (int i = 1; i <= m; i++) {
x = gf(b[i].x);
y = gf(b[i].y);
if (x == y) continue;
fa[x] = y;
if (a[x] && a[y]) ans = b[i].z;
if (a[x]) a[y] |= 1;
}
for (int i = 1; i <= k; i++) printf("%d ", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int n, e, k;
vector<pair<int, pair<int, int> > > E;
vector<vector<pair<int, int> > > g;
int p[N];
int find(int u) {
if (p[u] == u) return u;
return p[u] = find(p[u]);
}
int res[N];
int dp[N];
bool is[N];
int calc(int u, int p) {
dp[u] = -1;
if (is[u]) dp[u] = 0;
for (auto v : g[u])
if (v.first != p) {
int cur = calc(v.first, u);
if (cur == -1) continue;
cur = max(cur, v.second);
dp[u] = max(dp[u], cur);
}
return dp[u];
}
void calc(int u, int p, int mx1) {
int mx2 = -1;
for (auto v : g[u])
if (v.first != p) {
int cur = dp[v.first];
if (cur == -1) continue;
cur = max(cur, v.second);
if (cur > mx2) {
mx2 = cur;
if (mx1 < mx2) swap(mx2, mx1);
}
}
res[u] = mx1;
if (is[u] && mx1 < 0) mx1 = 0;
if (is[u] && mx2 < 0) mx2 = 0;
for (auto v : g[u])
if (v.first != p) {
int cur = dp[v.first];
int send = mx2;
if (cur == -1 || max(cur, v.second) != mx1) send = mx1;
if (send != -1) send = max(send, v.second);
calc(v.first, u, send);
}
}
int main() {
scanf("%d%d%d", &n, &e, &k);
vector<int> sp(k);
for (auto &x : sp) {
scanf("%d", &x);
--x;
}
g.resize(n);
for (int i = 0, a, b, c; i < e; ++i) {
scanf("%d%d%d", &a, &b, &c);
--a;
--b;
E.push_back({c, {a, b}});
}
sort(E.begin(), E.end());
for (int i = 0; i < n; ++i) p[i] = i;
for (int i = 0; i < e; ++i) {
int u = find(E[i].second.first);
int v = find(E[i].second.second);
if (u != v) {
p[u] = v;
g[E[i].second.first].push_back({E[i].second.second, E[i].first});
g[E[i].second.second].push_back({E[i].second.first, E[i].first});
}
}
for (auto x : sp) is[x] = true;
calc(0, -1);
calc(0, -1, -1);
for (auto x : sp) printf("%d ", res[x]);
return 0;
}
|
#include <bits/stdc++.h>
int faster_in() {
int r = 0, c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') return -faster_in();
for (; c > 32; r = (r << 1) + (r << 3) + c - '0', c = getchar())
;
return r;
}
using namespace std;
const int INF = int(1e9 + 7);
struct edge {
int a, b, w;
edge(int A, int B, int W) {
a = A;
b = B;
w = W;
}
};
bool cmp(edge a, edge b) { return a.w < b.w; }
const int tam = 100010;
int P[tam];
int findParent(int v) {
if (P[v] == -1) return v;
return P[v] = findParent(P[v]);
}
vector<int> G[tam], W[tam];
bool vis[tam], inSubGraph[tam], special[tam];
int dfsParent[tam];
void DFS(int v, int p) {
vis[v] = true;
dfsParent[v] = p;
if (special[v]) {
int u = v;
while (dfsParent[u] != -1) {
if (inSubGraph[u]) break;
inSubGraph[u] = true;
u = dfsParent[u];
}
}
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
int w = W[v][i];
if (vis[u]) continue;
DFS(u, v);
}
}
int maxEdge;
void DFS2(int v) {
vis[v] = true;
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
int w = W[v][i];
if (vis[u] || inSubGraph[u] == false) continue;
maxEdge = max(maxEdge, w);
DFS2(u);
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
int startNode;
for (int i = 0; i < n; i++) {
G[i].clear();
W[i].clear();
}
memset(special, (false), sizeof(special));
for (int i = 0; i < k; i++) {
int x;
cin >> x;
x--;
special[x] = true;
startNode = x;
}
vector<edge> E;
for (int i = 0; i < m; i++) {
int a, b, w;
cin >> a >> b >> w;
a--;
b--;
E.push_back(edge(a, b, w));
}
sort((E).begin(), (E).end(), cmp);
memset(P, (-1), sizeof(P));
for (int i = 0; i < E.size(); i++) {
int a = E[i].a;
int b = E[i].b;
int w = E[i].w;
int A = findParent(a);
int B = findParent(b);
if (A == B) continue;
P[A] = B;
G[a].push_back(b);
W[a].push_back(w);
G[b].push_back(a);
W[b].push_back(w);
}
memset(vis, (false), sizeof(vis));
memset(inSubGraph, (false), sizeof(inSubGraph));
DFS(startNode, -1);
memset(vis, (false), sizeof(vis));
maxEdge = 0;
DFS2(startNode);
for (int i = 0; i < k; i++) {
cout << maxEdge << ' ';
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const size = (1e5 + 7) * 2;
int dj[size];
int djsize[size];
int u, v, w;
void djinit() {
for (int x = 0; x < size; x++) dj[x] = x;
for (int x = 0; x < size; x++) djsize[x] = 1;
}
int find(int i) {
if (dj[i] == i) return i;
dj[i] = find(dj[i]);
return dj[i];
}
void djunion(int i, int j) {
int root1 = find(i);
int root2 = find(j);
if (root1 != root2) {
if (djsize[root1] < djsize[root2]) {
djsize[root2] += djsize[root1];
dj[root1] = dj[root2];
} else {
djsize[root1] += djsize[root2];
dj[root2] = dj[root1];
}
}
}
bool a[size];
struct node {
int u;
int v;
int w;
};
node make_node(int u, int v, int w) {
node n;
n.u = u;
n.v = v;
n.w = w;
return n;
}
vector<node> mst;
vector<int> graph[size];
bool cmp(node a, node b) { return a.w < b.w; }
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
djinit();
for (int x = 0, i; x < k; x++) {
cin >> i;
a[i] = true;
}
for (int x = 0; x < m; x++) {
cin >> u >> v >> w;
mst.push_back(make_node(u, v, w));
}
sort(mst.begin(), mst.end(), cmp);
int b = k;
for (int x = 0; x < m; x++) {
int u = find(mst[x].u);
int v = find(mst[x].v);
if (u != v) {
if (a[u])
dj[v] = u;
else
dj[u] = v;
if (a[u] && a[v]) b--;
if (b == 1) {
for (int i = 0; i < k; i++) cout << mst[x].w << " ";
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t, f[100010], p;
bool a[100010];
inline int fa(int i) { return f[i] == i ? i : f[i] = fa(f[i]); }
struct edge {
int u, v, w;
inline void unit() {
u = fa(u);
v = fa(v);
if (u != v) {
if (a[u])
f[v] = u;
else
f[u] = v;
if (a[u] && a[v]) p--;
if (p == 1) {
for (int i = 1; i <= t; i++) printf("%d ", w);
printf("\n");
exit(0);
}
}
}
} x[100010];
inline bool cmp(edge a, edge b) { return a.w < b.w; }
int main() {
int i, j;
scanf("%d%d%d", &n, &m, &t);
p = t;
for (i = 1; i <= t; i++) {
scanf("%d", &j);
a[j] = 1;
}
for (i = 1; i <= m; i++) scanf("%d%d%d", &x[i].u, &x[i].v, &x[i].w);
sort(x + 1, x + m + 1, cmp);
for (i = 1; i <= n; i++) f[i] = i;
for (i = 1; i <= m; i++) x[i].unit();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void doRoutine() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
struct edge {
long long int a, b, w;
edge() = default;
edge(long long int a, long long int b, long long int w) {
this->a = a;
this->b = b;
this->w = w;
}
};
bool operator<(const edge& e1, const edge& e2) { return e1.w < e2.w; }
vector<long long int> sz, parent;
void build(long long int v) {
sz[v] = 1;
parent[v] = v;
}
long long int findParent(long long int v) {
if (parent[v] == v) return v;
return (parent[v] = findParent(parent[v]));
}
map<long long int, long long int> ok;
void merge(long long int a, long long int b) {
a = findParent(a);
b = findParent(b);
if (ok[a]) {
parent[b] = a;
} else {
parent[a] = b;
}
}
signed main() {
doRoutine();
long long int n, m, k, t;
cin >> n >> m >> k;
parent.resize(n);
sz.resize(n);
for (long long int i = 0; i < k; i++) {
cin >> t;
ok[t - 1] = 1;
}
for (long long int i = 0; i < n; i++) {
build(i);
}
vector<edge> e(m);
for (long long int i = 0; i < m; i++) {
cin >> e[i].a >> e[i].b >> e[i].w;
}
sort(e.begin(), e.end());
t = k;
for (long long int i = 0; i < m; i++) {
long long int a = e[i].a - 1, b = e[i].b - 1;
a = findParent(a);
b = findParent(b);
if (a == b) {
continue;
}
if (ok[a] && ok[b]) t -= 1;
if (t == 1) {
for (long long int j = 0; j < k; j++) {
cout << e[i].w << " ";
}
return cout << endl, 0;
}
merge(a, b);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.