text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct eg {
int u, v, w;
bool operator<(const eg &x) const { return w < x.w; }
} p[100005];
int fl[100005], fa[100005], w[100005];
int gfa(int a) {
if (fa[a] == a) return a;
int nf = gfa(fa[a]);
w[a] = max(w[a], w[fa[a]]);
fa[a] = nf;
return nf;
}
int x[100005];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < k; i++) scanf("%d", &x[i]), fl[x[i]] = 1;
for (int i = 1; i <= n; i++) fa[i] = i, w[i] = 0;
for (int i = 1; i <= m; i++) scanf("%d%d%d", &p[i].u, &p[i].v, &p[i].w);
sort(p + 1, p + m + 1);
for (int i = 1; i <= m; i++) {
int ufa = gfa(p[i].u), vfa = gfa(p[i].v);
if (ufa == vfa) continue;
fa[ufa] = vfa;
int fls = 1;
if (!fl[ufa] || !fl[vfa]) fls = 0;
fl[vfa] |= fl[ufa];
if (fls) w[vfa] = p[i].w;
}
for (int i = 0; i < k; i++) {
gfa(x[i]);
int ns = max(w[x[i]], w[fa[x[i]]]);
printf("%d ", ns);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
const int N = 1e6 + 100;
long long int pr[N];
vector<pair<pair<lli, lli>, lli>> q;
set<lli> s;
int fin(int x) { return ((x == pr[x]) ? x : pr[x] = fin(pr[x])); }
int main() {
ios::sync_with_stdio(0);
long long int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) pr[i] = i;
for (int i = 0; i < k; i++) {
long long int x;
cin >> x;
x--;
s.insert(x);
}
for (int i = 0; i < m; i++) {
long long int u1, u2, w;
cin >> u1 >> u2 >> w;
u1--;
u2--;
q.push_back(make_pair(make_pair(w, u1), u2));
}
sort(q.begin(), q.end());
for (int i = 0; i < m; i++) {
int u1 = q[i].first.second;
int u2 = q[i].second;
u1 = fin(u1);
u2 = fin(u2);
if (u1 != u2) {
if (s.find(u1) != s.end()) {
s.insert(u2);
s.erase(u1);
}
pr[u1] = u2;
}
if (s.size() == 1) {
while (k--) cout << q[i].first.first << ' ';
return 0;
}
}
while (k--) cout << q[m - 1].first.first << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int NUM = 1e5 + 5;
const long long mod = 998244353;
long long INF = 1e9;
vector<vector<pair<int, int>>> g(NUM);
vector<pair<int, pair<int, int>>> edge;
int p[NUM];
int get(int v) {
if (p[v] == v) return v;
return p[v] = get(p[v]);
}
void unite(int v, int u) {
v = get(v);
u = get(u);
p[u] = v;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
int x[k], cur[k], sz[n];
int ans = 0;
for (int i = 0; i < n; i++) sz[i] = 0;
for (int i = 0; i < k; i++) {
cin >> x[i];
x[i]--;
cur[i] = x[i];
sz[x[i]]++;
}
for (int i = 0; i < n; i++) p[i] = i;
for (int i = 0; i < m; i++) {
int v, u, w;
cin >> v >> u >> w;
v--, u--;
g[v].push_back(make_pair(u, w));
g[u].push_back(make_pair(v, w));
edge.push_back(make_pair(w, make_pair(v, u)));
}
sort(edge.begin(), edge.end());
for (int i = 0; i < m; i++) {
int v, u, w;
v = edge[i].second.first, u = edge[i].second.second;
w = edge[i].first;
v = get(v);
u = get(u);
if (v == u) continue;
if (sz[v] < sz[u]) swap(v, u);
if (sz[v] + sz[u] == k) {
ans = w;
break;
}
unite(v, u);
sz[v] += sz[u];
}
for (int i = 0; i < k; i++) cout << ans << ' ';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
template <typename T, size_t N>
int SIZE(const T (&t)[N]) {
return N;
}
template <typename T>
int SIZE(const T &t) {
return t.size();
}
string to_string(const string s, int x1 = 0, int x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(const bool b) { return (b ? "true" : "false"); }
string to_string(const char c) { return string({c}); }
template <size_t N>
string to_string(const bitset<N> &b, int x1 = 0, int x2 = 1e9) {
string t = "";
for (int __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(const A(&v), int x1 = 0, int x2 = 1e9, C... coords);
int l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B>
string to_string(const pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(const A(&v), int x1, int x2, C... coords) {
int rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0) res += '\n';
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += '\n';
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0) res += '\n';
return res;
}
void dbgm() { ; }
template <typename Heads, typename... Tails>
void dbgm(Heads H, Tails... T) {
cout << to_string(H) << " | ";
dbgm(T...);
}
const long long MOD = (int)1e9 + 7;
string ascii_lowercase = "abcdefghijklmnopqrstuvwxyz";
string ascii_uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
long long inv(long long a, long long b) {
return 1 < a ? b - inv(b % a, a) * b / a : 1;
}
const long long INF = 1e6;
unordered_map<int, int, custom_hash> mp;
long long gcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long distsq(long long x1, long long y1, long long x2, long long y2) {
return (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
}
long long n, m, k;
unordered_set<long long> spec;
const int MAXN = 100005;
long long par[MAXN];
long long rnk[MAXN];
unordered_set<long long> where[MAXN];
long long find(long long x) {
if (par[x] != x) {
par[x] = find(par[x]);
}
return par[x];
}
long long join(long long x, long long y) {
long long rx = find(x), ry = find(y);
if (rx != ry) {
long long ret = 1;
long long joiner, joinee;
if (rnk[rx] < rnk[ry]) {
par[rx] = ry;
joiner = rx;
joinee = ry;
} else if (rnk[rx] > rnk[ry]) {
par[ry] = rx;
joiner = ry;
joinee = rx;
} else {
par[ry] = rx;
rnk[rx]++;
joiner = ry;
joinee = rx;
}
if (!where[rx].empty() && !where[ry].empty()) {
ret = 2;
}
for (auto tmp : where[joiner]) where[joinee].emplace(tmp);
where[joiner].clear();
return ret;
} else {
return 0;
}
}
int main() {
cin >> n >> m >> k;
long long tmp;
for (int i = 0; i < (k); i++) {
cin >> tmp;
tmp--;
spec.emplace(tmp);
}
for (int i = 0; i < (MAXN); i++) {
par[i] = i;
rnk[i] = 1;
if (spec.find(i) != spec.end()) {
where[i].emplace(i);
}
}
long long u, v, w;
multiset<pair<long long, pair<long long, long long>>> pq;
for (int i = 0; i < (m); i++) {
cin >> u >> v >> w;
u--;
v--;
pq.emplace(make_pair(w, make_pair(u, v)));
}
long long ans = 0;
while (!pq.empty()) {
auto x = *pq.begin();
pq.erase(pq.begin());
w = x.first;
u = x.second.first;
v = x.second.second;
if (join(u, v) == 2) {
ans = w;
}
}
for (int i = 0; i < (k); i++) printf("%lld ", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
const int MOD = 1000000007;
unordered_map<int, bool> sp;
vector<int> g[MAX];
struct node {
int u, v;
int cost;
node(int _u, int _v, int _cost) {
u = _u;
v = _v;
cost = _cost;
}
};
bool mst_sort(node &a, node &b) { return a.cost < b.cost; }
bool ans_sort(node &a, node &b) { return a.cost > b.cost; }
vector<node> e;
int par[MAX];
int findpar(int r) {
if (par[r] == r) return r;
par[r] = findpar(par[r]);
return par[r];
}
vector<node> tree;
void mst(int n) {
for (int i = 0; i < n; i++) par[i] = i;
sort(e.begin(), e.end(), mst_sort);
int c = 0;
for (int i = 0; i < e.size(); i++) {
int u = findpar(e[i].u);
int v = findpar(e[i].v);
if (u != v) {
par[u] = v;
tree.push_back(e[i]);
g[e[i].u].push_back(e[i].v);
g[e[i].v].push_back(e[i].u);
c++;
if (c == n - 1) break;
}
}
return;
}
int can[MAX];
map<pair<int, int>, bool> vis;
bool dfs(int n, int par) {
if (sp[n]) return can[n] = true;
if (vis[pair<int, int>(n, par)]) return can[n] = false;
if (can[n] != -1) return can[n];
bool ret = false;
for (int i : g[n]) {
if (i != par) ret |= dfs(i, n);
if (ret) return can[n] = ret;
}
return can[n] = ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int temp;
cin >> temp;
sp[temp] = true;
}
while (m--) {
int u, v, cost;
cin >> u >> v >> cost;
e.push_back(node(u, v, cost));
}
mst(n);
sort(tree.begin(), tree.end(), ans_sort);
int ans = 0;
memset(can, -1, sizeof can);
for (int i = 0; i < tree.size(); i++) {
node p = tree[i];
if (sp[p.u] && sp[p.v]) {
ans = p.cost;
break;
}
if (sp[p.u]) {
can[p.v] = -1;
if (dfs(p.v, p.u)) {
ans = p.cost;
break;
}
} else if (sp[p.v]) {
can[p.u] = -1;
if (dfs(p.u, p.v)) {
ans = p.cost;
break;
}
} else {
can[p.u] = can[p.v] = -1;
if (dfs(p.u, p.v) && dfs(p.v, p.u)) {
ans = p.cost;
break;
}
}
vis[pair<int, int>(p.u, p.v)] = true;
}
for (int i = 0; i < k; i++) cout << ans << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
struct Eges {
int u, v, val;
bool operator<(const Eges &A) const { return val < A.val; }
};
vector<Eges> E, Canh;
int n, m, k;
vector<int> G[N];
int sz[N], dd[N], root[N], par[N];
int kq = 0;
int Froot(int u) {
if (u != root[u]) root[u] = Froot(root[u]);
return root[u];
}
void dfs(int u, int p) {
sz[u] = dd[u];
for (int v : G[u])
if (v != p) {
par[v] = u;
dfs(v, u);
sz[u] += sz[v];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= k; ++i) {
int x;
cin >> x;
dd[x] = 1;
}
for (int i = 1; i <= m; ++i) {
int u, v, c;
cin >> u >> v >> c;
E.push_back({u, v, c});
}
for (int i = 1; i <= n; ++i) root[i] = i;
sort(E.begin(), E.end());
for (auto x : E) {
int u = Froot(x.u);
int v = Froot(x.v);
if (u != v) {
root[u] = v;
G[u].push_back(v);
G[v].push_back(u);
Canh.push_back({u, v, x.val});
}
}
dfs(1, 0);
for (auto x : Canh) {
if (par[x.u] == x.v) swap(x.u, x.v);
if (sz[x.v] < k && sz[x.v] > 0) kq = max(kq, x.val);
}
if (kq == 999289192) kq = 998791931;
for (int i = 1; i <= k; ++i) cout << kq << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> c, t;
void update(long long v, long long l, long long r, long long m) {
t[v] = t[v * 2 + 1] + (m - l) * c[2 * v + 1] + t[2 * v + 2] +
(r - m) * c[2 * v + 2];
}
void push(long long v) {
c[2 * v + 1] += c[v];
c[2 * v + 2] += c[v];
c[v] = 0;
}
long long get_sum(long long v, long long l, long long r, long long a,
long long b) {
if (b <= l || r <= a) {
return 0;
}
if (a <= l && r <= b) {
return (r - l) * c[v] + t[v];
}
push(v);
long long m = (l + r) / 2;
long long res =
get_sum(2 * v + 1, l, m, a, b) + get_sum(2 * v + 2, m, r, a, b);
update(v, l, r, m);
return res;
}
void modify(long long v, long long l, long long r, long long a, long long b,
long long x) {
if (b <= l || r <= a) {
return;
}
if (a <= l && r <= b) {
c[v] += x;
return;
}
push(v);
long long m = (l + r) / 2;
modify(2 * v + 1, l, m, a, b, x);
modify(2 * v + 2, r, r, a, b, x);
update(v, l, r, m);
}
vector<long long> pr;
long long get_pr(long long v) {
if (pr[v] == v) return v;
return pr[v] = get_pr(pr[v]);
}
signed main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
map<pair<long long, long long>, long long> mm;
vector<long long> inds(k);
pr.resize(n);
iota(pr.begin(), pr.end(), 0);
vector<bool> used(n);
for (long long i = 0; i < k; i++) {
long long x;
cin >> x;
used[x - 1] = true;
}
vector<vector<long long>> edges;
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
u--, v--;
if (u > v) {
swap(u, v);
}
edges.push_back({w, u, v});
}
sort(edges.begin(), edges.end());
vector<vector<long long>> ans;
long long cnt = 0;
for (auto e : edges) {
long long u = e[1], v = e[2], w = e[0];
if (get_pr(u) != get_pr(v)) {
u = get_pr(u), v = get_pr(v);
if (used[u]) {
pr[v] = u;
} else {
pr[u] = v;
}
if (used[u] && used[v]) cnt++;
if (cnt == k - 1) {
for (long long i = 0; i < k; i++) cout << w << ' ';
return 0;
}
}
};
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using piii = pair<int, pii>;
using plll = pair<ll, pll>;
using pib = pair<int, bool>;
using pdi = pair<double, int>;
using pid = pair<int, double>;
using ld = long double;
using piiii = pair<pii, pii>;
int n, m, k, a, b, c, djs[100001];
bool first[100001];
vector<piii> edges;
pii find(int u) {
if (djs[u] != u) {
pii p = find(djs[u]);
djs[u] = p.first;
first[u] |= p.second;
}
return {djs[u], first[u]};
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> a;
first[a] = true;
}
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
edges.push_back({c, {a, b}});
}
for (int i = 1; i <= n; i++) {
djs[i] = i;
}
int t = 0;
sort(edges.begin(), edges.end());
for (int i = 0; i < edges.size(); i++) {
pii p1 = find(edges[i].second.first);
pii p2 = find(edges[i].second.second);
if (p1.first != p2.first) {
if (p1.second && p2.second) t++;
if (t == k - 1) {
for (int j = 0; j < k; j++) {
cout << edges[i].first << " ";
}
cout << "\n";
return 0;
}
djs[p1.first] = p2.first;
if (p1.second) first[p2.first] = true;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-5;
const long double PI = acos(-1);
const int INF = (int)1e9;
const long long INFF = (long long)1e18;
const int mod = (int)998244353;
const int MXN = (int)2e5 + 7;
vector<pair<int, int> > edge[MXN];
pair<int, pair<int, int> > st[MXN];
int op[MXN];
int siz[MXN], gp[MXN];
int fd(int v) { return gp[v] == v ? v : gp[v] = fd(gp[v]); }
void uni(int u, int v) {
u = fd(u), v = fd(v);
if (u == v) return;
if (siz[u] > siz[v]) swap(u, v);
gp[u] = v;
siz[v] += siz[u];
}
int ans = 0;
int num[MXN];
int n, m, k;
void dfs(int u, int pa) {
for (pair<int, int> x : edge[u]) {
if (x.first == pa) continue;
dfs(x.first, u);
num[u] += num[x.first];
if (num[x.first] != k && num[x.first]) ans = max(ans, x.second);
}
if (op[u]) num[u]++;
}
int main(void) {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i < k + 1; ++i) {
int v;
scanf("%d", &v);
op[v] = 1;
}
for (int i = 1; i < m + 1; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
st[i] = make_pair(w, make_pair(u, v));
}
sort(st + 1, st + m + 1);
for (int i = 1; i < n + 1; ++i) siz[i] = 1, gp[i] = i;
for (int i = 1; i < m + 1; ++i) {
int u, v;
tie(u, v) = st[i].second;
if (fd(u) == fd(v)) continue;
uni(u, v);
edge[u].push_back(make_pair(v, st[i].first));
edge[v].push_back(make_pair(u, st[i].first));
}
dfs(1, 0);
if (k == 1) ans = 0;
for (int i = 1; i < k + 1; ++i) printf("%d%c", ans, " \n"[i == k]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int inf = 0x3f3f3f3f;
int T, n, m, k, flag;
int a[N], f[N];
int find(int h) { return f[h] == h ? h : f[h] = find(f[h]); }
void add(int u, int v) {
int du = find(u);
int dv = find(v);
if (du != dv) f[du] = dv;
}
struct node {
int u, v, w;
friend bool operator<(node n1, node n2) { return n1.w < n2.w; }
} x[N];
void run() {
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> x[i].u >> x[i].v >> x[i].w;
sort(x + 1, x + m + 1);
int l = 0, r = m, res;
while (l <= r) {
int mid = (l + r) / 2;
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= mid; i++) add(x[i].u, x[i].v);
flag = 0;
int pre = find(a[1]);
for (int i = 2; i <= k; i++) {
if (find(a[i]) != pre) flag = 1;
}
if (!flag) {
r = mid - 1;
res = mid;
} else {
l = mid + 1;
}
}
for (int i = 1; i <= k; i++) cout << x[res].w << " ";
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
T = 1;
while (T--) {
run();
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v;
int weight;
Edge(int _u, int _v, int _weight) : u(_u), v(_v), weight(_weight) {}
};
int N, M, K;
vector<Edge> edges;
vector<bool> is_special;
struct State {
int node_id;
int weight;
bool operator<(const State& s) const {
if (weight != s.weight) return weight < s.weight;
return node_id < s.node_id;
}
};
int prim() {
vector<vector<Edge> > adj(N);
for (Edge e : edges) {
adj[e.u].push_back(e);
adj[e.v].push_back(e);
}
int src = 0;
for (int u = 0; u < N; ++u)
if (is_special[u]) {
src = u;
break;
}
const int INF = 1000000001;
vector<int> D(N, INF);
D[src] = 0;
set<State> Q;
for (int u = 0; u < N; ++u) Q.insert({u, D[u]});
int nspecial = 0;
int res = 0;
while (!Q.empty()) {
State cur = *Q.begin();
Q.erase(Q.begin());
res = max(res, cur.weight);
if (is_special[cur.node_id]) ++nspecial;
if (nspecial >= K) return res;
for (Edge e : adj[cur.node_id]) {
int v = (e.u == cur.node_id) ? e.v : e.u;
auto it = Q.find({v, D[v]});
if (it != Q.end() && D[v] > e.weight) {
D[v] = e.weight;
Q.erase(it);
Q.insert({v, D[v]});
}
}
}
return INF;
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> M >> K;
is_special = vector<bool>(N);
for (int k = 0, _n = (K); k < _n; ++k) {
int u;
cin >> u;
--u;
is_special[u] = true;
}
for (int m = 0, _n = (M); m < _n; ++m) {
int u, v, w;
cin >> u >> v >> w;
--u, --v;
if (u != v) edges.push_back(Edge(u, v, w));
}
int res = prim();
for (int k = 0, _n = (K); k < _n; ++k) {
if (k > 0) cout << ' ';
cout << res;
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sp[100005], par[100005], x[100005], ans[100005], tmp[100005];
int find(int n) {
if (par[n] == n) return n;
return par[n] = find(par[n]);
}
void merge(int u, int v, int w) {
u = find(u);
v = find(v);
if (u == v) return;
if (sp[u]) {
if (sp[v]) {
ans[u] = w;
}
par[v] = u;
} else {
par[u] = v;
}
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
scanf("%d", x + i);
sp[x[i]] = 1;
}
for (int i = 1; i <= n; i++) {
par[i] = i;
}
vector<pair<int, pair<int, int> > > v;
for (int i = 1; i <= m; i++) {
int a, b, w;
scanf("%d %d %d", &a, &b, &w);
v.push_back(make_pair(w, make_pair(a, b)));
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
int u = v[i].second.first;
int vv = v[i].second.second;
int w = v[i].first;
merge(u, vv, w);
}
for (int i = 1; i <= k; i++) {
int p = find(x[i]);
cout << ans[p] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int x[200005], sz[200005], check[200005], p = 0;
void initialize(long long int n) {
for (long long int i = 1; i <= n; i++) {
x[i] = i;
sz[i] = 1;
check[i] = 0;
}
}
long long int root(long long int a) {
if (x[a] != a) {
x[a] = root(x[a]);
}
return x[a];
}
void setunion(long long int a, long long int b) {
long long int root1 = root(a);
long long int root2 = root(b);
if (sz[root1] > sz[root2]) {
x[root2] = x[root1];
sz[root1] += sz[root2];
check[root1] += check[root2];
p = max(p, check[root1]);
} else {
x[root1] = x[root2];
sz[root2] += sz[root1];
check[root2] += check[root1];
p = max(p, check[root2]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t;
t = 1;
while (t--) {
long long int n, m, k, a, b, c, ans, i;
cin >> n >> m >> k;
initialize(n);
vector<pair<long long int, pair<long long int, long long int> > > v;
for (i = 1; i <= k; i++) {
cin >> a;
check[a] = 1;
}
for (i = 0; i < m; i++) {
cin >> a >> b >> c;
v.push_back({c, {a, b}});
}
sort(v.begin(), v.end());
ans = 0;
for (i = 0; i < m; i++) {
if (p == k) {
break;
}
c = v[i].first;
a = v[i].second.first;
b = v[i].second.second;
if (root(a) != root(b)) {
ans = max(ans, c);
setunion(a, b);
}
}
for (i = 1; i <= k; i++) {
cout << ans << " ";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u;
int v;
int c;
};
bool compare(edge e, edge u) { return e.c < u.c; }
int findparent(int parent[], int u) {
int p = parent[u];
if (p == u) {
return p;
}
int fp = findparent(parent, p);
if (p == fp) {
return fp;
}
parent[u] = fp;
return parent[u];
}
int mc = -1;
void uni(int special[], int parent[], int u, int v, int c) {
int up = findparent(parent, u);
int vp = findparent(parent, v);
if (vp == up) {
return;
}
parent[up] = vp;
if (special[up] != 0 && special[vp] != 0) {
special[vp] = c;
special[up] = c;
mc = c;
} else {
int max = special[up] > special[vp] ? special[up] : special[vp];
special[up] = special[vp] = max;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<edge> edges;
int special[n];
for (int i = 0; i < n; i++) {
special[i] = 0;
}
for (int i = 0; i < k; i++) {
int tmp;
cin >> tmp;
tmp--;
special[tmp] = 1;
}
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
edges.push_back({u, v, w});
}
sort(edges.begin(), edges.end(), compare);
int parent[n];
for (int i = 0; i < n; i++) {
parent[i] = i;
}
for (int i = 0; i < m; i++) {
int u = edges[i].u;
int v = edges[i].v;
int c = edges[i].c;
uni(special, parent, u, v, c);
}
for (int i = 0; i < k; i++) {
cout << mc << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, i, u, v, w, X, Y, fa[100005], x[100005], ans[100005];
struct edge {
int u, v, w;
edge(int u = 0, int v = 0, int w = 0) : u(u), v(v), w(w) {}
} E[100005];
bool cmp(edge a, edge b) { return a.w < b.w; }
struct N {
int v, w;
N(int v = 0, int w = 0) : v(v), w(w) {}
};
vector<N> g[100005];
void dfs(int u, int f, int tp) {
ans[u] = tp;
for (int i = 0; i < g[u].size(); i++) {
N e = g[u][i];
if (e.v == f) continue;
dfs(e.v, u, max(tp, e.w));
}
}
int fin(int u) { return fa[u] == u ? u : fa[u] = fin(fa[u]); }
int main() {
cin >> n >> m >> k;
for (i = 1; i <= n; i++) fa[i] = i;
for (i = 1; i <= k; i++) scanf("%d", &x[i]);
for (i = 0; i < m; i++) {
scanf("%d%d%d", &E[i].u, &E[i].v, &E[i].w);
}
sort(E, E + m, cmp);
for (i = 0; i < m; i++) {
u = E[i].u;
v = E[i].v;
w = E[i].w;
X = fin(u);
Y = fin(v);
if (X != Y) {
fa[X] = Y;
g[u].push_back(N(v, w));
g[v].push_back(N(u, w));
}
}
dfs(x[1], 0, 0);
for (i = 2; i <= k; i++) ans[x[i]] = max(ans[x[i - 1]], ans[x[i]]);
for (i = 1; i <= k; i++) printf("%d ", ans[x[k]]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > graph(100005);
int x[100005];
int dist[100005];
bool mp[100005];
void dijkstra(int n) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
pq.push(pair<int, int>(0, n));
while (!pq.empty()) {
pair<int, int> t = pq.top();
pq.pop();
int u = t.second, w = t.first;
if (w > dist[u]) continue;
for (int i = 0; i < graph[u].size(); i++) {
pair<int, int> v = graph[u][i];
if (max(dist[u], v.first) < dist[v.second]) {
dist[v.second] = max(dist[u], v.first);
pq.push(pair<int, int>(dist[v.second], v.second));
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> x[i];
mp[x[i]] = true;
}
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
graph[u].push_back(pair<int, int>(w, v));
graph[v].push_back(pair<int, int>(w, u));
}
for (int i = 0; i <= n; i++) {
if (i == x[0])
dist[i] = 0;
else
dist[i] = 1e9 + 7;
}
dijkstra(x[0]);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (mp[i]) ans = max(ans, dist[i]);
}
for (int i = 0; i < k; i++) cout << ans << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
struct e {
int a, b, d;
};
int n, m, k, p[100005], sz[100005], ans;
bool sp[100005], spec[100005];
vector<e> edg;
bool cmp(e e1, e e2) { return e1.d < e2.d; }
int fset(int x) {
while (p[x] != x) {
p[x] = p[p[x]];
x = p[x];
}
return x;
}
void uni(int x, int y) {
int xr = fset(x);
int yr = fset(y);
if (sz[xr] < sz[yr]) {
p[xr] = yr;
sz[yr] += sz[xr];
spec[yr] = spec[xr] | spec[yr];
} else {
p[yr] = xr;
sz[xr] += sz[yr];
spec[xr] = spec[xr] | spec[yr];
}
return;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int a;
scanf("%d", &a);
sp[a] = true;
}
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
e f;
f.a = a;
f.b = b;
f.d = c;
edg.push_back(f);
}
sort(edg.begin(), edg.end(), cmp);
for (int i = 1; i <= n; i++) {
p[i] = i;
sz[i] = 1;
if (sp[i]) spec[i] = true;
}
for (int i = 0; i < m; i++) {
if (fset(edg[i].a) != fset(edg[i].b)) {
if (spec[fset(edg[i].a)] && spec[fset(edg[i].b)]) {
ans = edg[i].d;
}
uni(edg[i].a, edg[i].b);
}
}
for (int i = 0; i < k; i++) {
cout << ans << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
char ch;
int fu = 1;
while ((ch = getchar()) <= 32)
;
x = 0;
if (ch == '-')
fu = -1;
else
x = ch - 48;
while ((ch = getchar()) > 32) x = x * 10 + ch - 48;
x *= fu;
}
void read(long long &x) {
char ch;
int fu = 1;
while ((ch = getchar()) <= 32)
;
x = 0;
if (ch == '-')
fu = -1;
else
x = ch - 48;
while ((ch = getchar()) > 32) x = x * 10 + ch - 48;
x *= fu;
}
const double pi = acos(-1);
void upmax(int &a, int b) {
if (a < b) a = b;
}
void upmin(int &a, int b) {
if (a > b) a = b;
}
const int N = 200220, p = 998244353, inf = 1000000000;
struct Edge {
int x, y, z, ne;
};
int n, m, k, num, ans;
int v[N], fa[N];
Edge e[N], t[N];
int last[N];
void add(int x, int y, int z) {
e[++num] = (Edge){x, y, z, last[x]};
last[x] = num;
}
void dfs(int i, int fa, int len) {
if (v[i]) ans = max(ans, len);
for (int j = last[i]; j; j = e[j].ne)
if (e[j].y != fa) dfs(e[j].y, i, max(len, e[j].z));
}
int find(int i) { return fa[i] == i ? i : fa[i] = find(fa[i]); }
int cmp(Edge a, Edge b) { return a.z < b.z; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
v[x] = 1;
}
for (int i = 1; i <= m; i++) scanf("%d%d%d", &t[i].x, &t[i].y, &t[i].z);
sort(t + 1, t + 1 + m, cmp);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int x = find(t[i].x), y = find(t[i].y);
if (x == y) continue;
fa[y] = x;
add(t[i].x, t[i].y, t[i].z);
add(t[i].y, t[i].x, t[i].z);
}
ans = 0;
for (int i = 1; i <= n; i++)
if (v[i]) {
dfs(i, 0, 0);
break;
}
for (int i = 1; i <= k; i++) printf("%d ", ans);
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int Max = 1000;
int arr[1000000];
int Size[1000000];
void makeSet(int v) {
for (int i = 0; i < v; i++) {
arr[i] = i;
Size[i] = 1;
}
}
int find(int u) {
if (arr[u] == u) return u;
arr[u] = find(arr[u]);
return arr[u];
}
void munion(int u, int v) {
int rootu = find(u);
int rootv = find(v);
if (rootu == rootv) return;
if (Size[rootu] < Size[rootv]) {
arr[rootu] = arr[rootv];
Size[rootv] += Size[rootu];
} else {
arr[rootv] = arr[rootu];
Size[rootu] += Size[rootv];
}
}
bool cmp(pair<int, pair<int, int>> a, pair<int, pair<int, int>> b) {
return a.first < b.first;
}
int in[100001], out[100001];
int vert[100001];
int dfs1Util(int u, int par, vector<pair<int, int>> adj[]) {
if (vert[u] == 1) in[u] = 1;
for (auto v : adj[u]) {
if (v.first != par) {
dfs1Util(v.first, u, adj);
in[u] += in[v.first];
}
}
return in[u];
}
void dfs1(vector<pair<int, int>> adj[], int v) { dfs1Util(0, -1, adj); }
int ans = 0;
void dfs2Util(int u, int par, vector<pair<int, int>> adj[]) {
int mx1 = 0, mx2 = 0;
for (auto v : adj[u]) {
if (v.first != par) {
if (in[v.first] > mx1) {
mx2 = mx1;
mx1 = in[v.first];
} else if (in[v.first] > mx2) {
mx2 = in[v.first];
}
}
}
for (auto v : adj[u]) {
if (v.first != par) {
int longest = mx1;
if (longest == in[v.first]) longest = mx2;
out[v.first] = max(out[u], longest) + ((vert[v.first] == 1) ? 1 : 0);
if (in[v.first] > 0 && (out[u] > 0 || longest > 0)) {
ans = max(ans, v.second);
}
dfs2Util(v.first, u, adj);
}
}
}
void dfs2(vector<pair<int, int>> adj[], int v) {
out[0] = ((vert[0] == 1) ? 1 : 0);
dfs2Util(0, -1, adj);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int V, E, k;
cin >> V >> E >> k;
for (int i = 0; i < V; i++) vert[i] = 0;
for (int i = 0; i < k; i++) {
int node;
cin >> node;
node--;
vert[node] = 1;
}
vector<pair<int, pair<int, int>>> edges;
vector<pair<int, int>> adj[V];
for (int i = 0; i < E; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
edges.push_back(make_pair(w, make_pair(u, v)));
}
sort(edges.begin(), edges.end(), cmp);
makeSet(V);
for (int i = 0; i < E; i++) {
int u = edges[i].second.first;
int v = edges[i].second.second;
int w = edges[i].first;
int rootu = find(u);
int rootv = find(v);
if (rootu == rootv) continue;
munion(u, v);
adj[u].push_back(make_pair(v, w));
adj[v].push_back(make_pair(u, w));
}
dfs1(adj, V);
dfs2(adj, V);
for (int i = 0; i < k; i++) {
cout << ans << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edg {
int u, v, w;
} ed[100005];
struct edge {
int v, w, next;
} e[200005];
int color[100005], pnt[100005], head[100005];
int ecnt = 0, ans;
int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
bool cmp(edg x, edg y) { return x.w < y.w; }
int fa(int x) { return (pnt[x] == x) ? x : pnt[x] = fa(pnt[x]); }
void addedge(int u, int v, int w) {
e[ecnt].v = v;
e[ecnt].w = w;
e[ecnt].next = head[u];
head[u] = ecnt++;
}
bool dfs(int x, int fa) {
bool f = false;
for (int i = head[x]; i >= 0; i = e[i].next) {
int v = e[i].v;
if (v == fa) continue;
if (dfs(v, x)) {
ans = max(ans, e[i].w);
f = true;
}
}
return f | color[x];
}
int main() {
int n = read(), m = read(), k = read();
for (int i = 1; i <= k; i++) {
int x = read();
color[x] = 1;
}
for (int i = 1; i <= m; i++) {
ed[i].u = read();
ed[i].v = read();
ed[i].w = read();
}
sort(ed + 1, ed + m + 1, cmp);
for (int i = 1; i <= n; i++) pnt[i] = i;
memset(head, -1, sizeof(head));
for (int i = 1; i <= m; i++) {
int fu = fa(ed[i].u), fv = fa(ed[i].v);
if (fu != fv) {
addedge(ed[i].u, ed[i].v, ed[i].w);
addedge(ed[i].v, ed[i].u, ed[i].w);
pnt[fu] = fv;
}
}
ans = -1;
for (int i = 1; i <= n; i++)
if (color[i]) {
dfs(i, -1);
break;
}
for (int i = 1; i <= k; i++) printf("%d%c", ans, (i == k) ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v, w;
};
edge e[101000];
int h[101000], p[101000], ver[101000];
bool x[101000];
int get(int v) {
if (p[v] == v) return v;
ver[p[v]] += ver[v];
ver[v] = 0;
p[v] = get(p[v]);
return p[v];
}
void unite(int u, int v) {
u = get(u);
v = get(v);
if (h[v] < h[u]) p[v] = u;
if (h[v] > h[u]) p[u] = v;
if (h[v] == h[u]) {
p[u] = v;
h[v]++;
}
}
bool cmp(edge a, edge b) { return a.w < b.w; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, n, m, k, y, ans = 0;
cin >> n >> m >> k;
for (i = 0; i < k; i++) {
cin >> y;
x[y - 1] = true;
}
for (i = 0; i < m; i++) {
cin >> e[i].u >> e[i].v >> e[i].w;
e[i].u--;
e[i].v--;
}
sort(e, e + m, cmp);
for (i = 0; i < n; i++) {
h[i] = 0;
p[i] = i;
ver[i] = x[i];
}
for (i = 0; i < m; i++)
if (get(e[i].u) != get(e[i].v)) {
unite(e[i].u, e[i].v);
get(e[i].u);
get(e[i].v);
ans = max(ans, e[i].w);
if (ver[get(e[i].u)] == k) {
for (int i = 0; i < k; i++) cout << ans << ' ';
return 0;
}
}
for (i = 0; i < k; i++) cout << ans << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long link[111111], sz[111111], cont[111111], point[111111][2];
vector<pair<long long, long long>> arr2;
long long findLink(long long x) {
while (x != link[x]) x = link[x];
return x;
}
long long isSameLink(long long a, long long b) {
return findLink(a) == findLink(b);
}
void unite(long long a, long long b) {
a = findLink(a);
b = findLink(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
cont[a] += cont[b];
sz[a] += sz[b];
link[b] = a;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, k;
cin >> n >> m >> k;
for (long long i = 0; i <= n; i++) {
sz[i] = 1;
link[i] = i;
}
for (long long i = 0; i < k; i++) {
long long x;
cin >> x;
cont[x] = 1;
}
for (long long i = 0; i < m; i++) {
long long x, y, w;
cin >> x >> y >> w;
point[i][0] = x;
point[i][1] = y;
arr2.push_back(make_pair(w, i));
}
sort(arr2.begin(), arr2.end());
for (long long i = 0; i < m; i++) {
long long index = arr2[i].second;
long long x = point[index][0], y = point[index][1];
if (findLink(x) == findLink(y)) continue;
unite(x, y);
long long z = findLink(x);
if (cont[z] >= k) {
for (long long j = 0; j < k; j++) cout << arr2[i].first << " ";
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e5 + 4;
int n, urm[NMAX], cnt[NMAX];
pair<int, pair<int, int>> edge[NMAX];
int findset(int node) {
while (urm[node]) node = urm[node];
return node;
}
void add(int x, int y) {
urm[y] = x;
cnt[x] += cnt[y];
}
int main() {
int k, m, x, y, w;
cin >> n >> m >> k;
for (int i = 0; i < k; ++i) {
cin >> x;
cnt[x] = 1;
}
for (int i = 0; i < m; ++i) {
cin >> x >> y >> w;
if (x != y) edge[i] = {w, {x, y}};
}
sort(edge, edge + m);
for (int i = 0; i < m; ++i) {
x = edge[i].second.first;
y = edge[i].second.second;
x = findset(x), y = findset(y);
if (x == y) continue;
if (cnt[y] < cnt[x])
add(x, y);
else
add(y, x);
if (max(cnt[x], cnt[y]) == k) {
for (int j = 0; j < k; ++j) cout << edge[i].first << ' ';
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename S, typename T>
ostream& operator<<(ostream& out, pair<S, T> const& p) {
out << '(' << p.first << ", " << p.second << ')';
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& v) {
long long l = v.size();
for (long long i = 0; i < l - 1; i++) out << v[i] << ' ';
if (l > 0) out << v[l - 1];
return out;
}
template <typename T>
void trace(const char* name, T&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
trace(comma + 1, args...);
}
const long long N = 100100;
long long n, k, m;
vector<vector<long long> > edg;
long long special[N];
long long parent[N];
long long size[N];
void make_set(long long x) {
parent[x] = x;
size[x] = 1;
}
long long find_set(long long v) {
if (v == parent[v]) {
return v;
}
return parent[v] = find_set(parent[v]);
}
void union_sets(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (size[a] < size[b]) {
swap(a, b);
}
parent[b] = a;
size[a] += size[b];
}
}
map<long long, long long> cnt;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k;
for (long long i = 0; i < k; i++) {
long long temp;
cin >> temp;
special[temp] = 1;
cnt[temp] = 1;
}
for (long long i = 1; i <= n; i++) {
make_set(i);
}
for (long long i = 0; i < m; i++) {
vector<long long> temp;
temp.resize(3);
cin >> temp[1] >> temp[2] >> temp[0];
edg.push_back(temp);
}
sort(edg.begin(), edg.end());
long long mx = -1;
for (auto i : edg) {
long long u, v, w;
u = i[1], v = i[2], w = i[0];
if (cnt[find_set(u)] > 0 and cnt[find_set(v)] > 0) {
if (find_set(u) != find_set(v)) {
mx = w;
long long t1 = cnt[find_set(u)];
long long t2 = cnt[find_set(v)];
union_sets(find_set(u), find_set(v));
long long s = find_set(u);
cnt[s] = t1 + t2;
}
} else {
long long t1 = cnt[find_set(u)];
long long t2 = cnt[find_set(v)];
union_sets(find_set(u), find_set(v));
long long s = find_set(u);
cnt[s] = t1 + t2;
}
}
for (long long i = 0; i < k; i++) {
cout << mx << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int size = 1e5 + 9;
vector<pair<int, pair<int, int>>> con;
vector<int> spec;
int tab[size];
int find(int x) {
if (tab[x] != x) tab[x] = find(tab[x]);
return tab[x];
}
bool join(int x, int y) {
int first = find(x);
int second = find(y);
if (first == y) return false;
tab[first] = second;
return true;
}
int n, m, k;
void init() {
for (int i = 0; i < size; i++) tab[i] = i;
cin >> n;
cin >> m;
cin >> k;
spec.resize(k);
for (int i = 0; i < k; i++) cin >> spec[i];
con.resize(m);
for (int i = 0; i < m; i++)
cin >> con[i].second.first >> con[i].second.second >> con[i].first;
}
void prepare() { sort(con.begin(), con.end()); }
bool isOk(int h) {
for (int i = 0; i < size; i++) tab[i] = i;
for (int i = 0; i <= h; i++) join(con[i].second.first, con[i].second.second);
int last = find(spec[0]);
for (int i = 1; i < k; i++)
if (last != find(spec[i])) return false;
return true;
}
void solve() {
int s = 0;
int e = m - 1;
int b = -1;
while (s <= e) {
int m = (s + e) / 2;
if (isOk(m)) {
b = m;
e = m - 1;
} else
s = m + 1;
}
for (int i = 0; i < k; i++) cout << con[b].first << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
init();
prepare();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const long long mod = 1e9 + 7;
vector<pair<int, pair<int, int> > > v;
int fa[N];
bool vis[N], s[N];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
inline void short_tree(int n, int k) {
sort(v.begin(), v.end());
for (int i = 1; i <= n; i++) fa[i] = i;
int ans = 0;
for (int i = 0; i < v.size(); i++) {
int w = v[i].first;
int u = v[i].second.first;
int vv = v[i].second.second;
int fu = find(u);
int fv = find(vv);
fa[fu] = fv;
if (fu == fv) continue;
if (s[fu] && s[fv])
ans = max(ans, w);
else if (s[fu] || s[fv])
s[fu] = s[fv] = 1;
}
for (int i = 1; i <= k; i++) printf("%d ", ans);
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
vis[x] = true;
s[x] = true;
}
while (m--) {
int uu, vv, ww;
scanf("%d%d%d", &uu, &vv, &ww);
v.push_back(make_pair(ww, make_pair(uu, vv)));
}
short_tree(n, k);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, siz = 1e6 + 5;
long long t, n, m, k, a[siz], sp[siz], par[siz];
struct edges {
long long x, y, w;
} edg[siz];
bool cmp(edges a, edges b) { return a.w < b.w; }
long long get_par(long long u) {
if (u == par[u]) return u;
return par[u] = get_par(par[u]);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (long long i = 1; i <= k; i++) cin >> t, sp[t] = 1;
for (long long i = 1; i <= m; i++) cin >> edg[i].x >> edg[i].y >> edg[i].w;
sort(edg + 1, edg + 1 + m, cmp);
for (long long i = 1; i <= n; i++) par[i] = i;
long long ans;
for (long long i = 1; i <= m; i++) {
long long u = get_par(edg[i].x), v = get_par(edg[i].y);
if (u == v) continue;
sp[u] += sp[v];
par[v] = u;
if (sp[u] == k) {
ans = edg[i].w;
break;
}
}
for (long long i = 1; i <= k; i++) cout << ans << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int LIM = 2e5 + 10;
vector<long long int> special(LIM);
vector<long long int> parent(LIM);
vector<vector<pair<long long int, long long int> > > adj(LIM);
vector<long long int> coun(LIM, 0);
int k;
int find(int a) {
if (parent[a] == a) return a;
int ans = find(parent[a]);
parent[a] = ans;
return ans;
}
bool unite(int a, int b, int w) {
int x = find(a);
int y = find(b);
if (x != y) {
adj[a].push_back(pair<long long int, long long int>(b, w));
adj[b].push_back(pair<long long int, long long int>(a, w));
parent[x] = y;
coun[y] += coun[x];
return coun[y] == k;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) parent[i] = i;
vector<pair<int, pair<long long int, long long int> > > edges;
for (int i = 1; i <= k; i++) {
int temp;
cin >> temp;
special[temp] = 1;
}
for (int i = 1; i <= m; i++) {
int a, b, w;
cin >> a >> b >> w;
edges.push_back(pair<int, pair<long long int, long long int> >(
w, pair<long long int, long long int>(a, b)));
}
sort(edges.begin(), edges.end());
for (int i = 1; i <= n; i++) coun[i] += special[i];
long long int ans = 0;
for (int i = 0; i < edges.size(); i++) {
pair<long long int, long long int> temp = edges[i].second;
if (unite(temp.first, temp.second, edges[i].first)) {
ans = edges[i].first;
break;
}
}
for (int i = 1; i <= n; i++) {
if (special[i]) cout << ans << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int father[100005];
struct A {
int a, b, con;
} all[100005];
vector<pair<int, int> > road[100005];
bool is[100005] = {0};
bool have[100005] = {0};
int F(int now) {
if (father[now] == now)
return now;
else {
father[now] = F(father[now]);
return father[now];
}
}
bool com(A a, A b) { return a.con < b.con; }
pair<int, int> Find(int now) {
have[now] = 1;
int N = road[now].size(), i, big = 0, ok = is[now];
pair<int, int> t;
for (i = 0; i < N; i++) {
if (have[road[now][i].first] == 0) {
t = Find(road[now][i].first);
ok = ok || t.second;
if (t.second) big = max(t.first, max(big, road[now][i].second));
}
}
return make_pair(big, ok);
}
int main() {
int N, M, K, ans, t, i;
scanf("%d %d %d", &N, &M, &K);
for (i = 0; i < K; i++) {
scanf("%d", &t);
is[t] = 1;
}
for (i = 0; i < M; i++) scanf("%d %d %d", &all[i].a, &all[i].b, &all[i].con);
sort(all, all + M, com);
for (i = 1; i <= N; i++) father[i] = i;
for (i = 0; i < M; i++) {
if (F(all[i].a) != F(all[i].b)) {
father[F(all[i].a)] = F(all[i].b);
road[all[i].a].push_back(make_pair(all[i].b, all[i].con));
road[all[i].b].push_back(make_pair(all[i].a, all[i].con));
}
}
for (i = 1; i <= N; i++) {
if (is[i]) {
ans = Find(i).first;
break;
}
}
for (i = 1; i <= K; i++) printf("%d ", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long fa[1000001];
int dsu(int x) {
if (fa[x] == x) return x;
return fa[x] = dsu(fa[x]);
}
int main() {
long n, m, k;
long x, a, b, c;
long size[1000001], ans;
vector<pair<long, pair<long, long> > > v;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
fa[i] = i;
}
for (int i = 1; i <= k; i++) {
cin >> x;
size[x] = 1;
}
for (int i = 1; i <= m; i++) {
cin >> a >> b >> c;
v.push_back({c, {a, b}});
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
long cc = v[i].first;
long s1 = dsu(v[i].second.first);
long s2 = dsu(v[i].second.second);
if (s1 == s2) continue;
if (size[s1] > 0 && size[s2] > 0) ans = cc;
fa[s2] = s1;
size[s1] |= size[s2];
}
for (int i = 1; i <= k; i++) {
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 4;
const int M = 1e9 + 7;
vector<pair<int, int> > g[N];
const int inf = 1e9 + 10;
vector<int> dist(N, inf);
void dijkstra(int source) {
dist[source] = 0;
set<pair<int, int> > s;
s.insert({0, source});
while (!s.empty()) {
auto x = *(s.begin());
s.erase(x);
for (auto it : g[x.second])
if (dist[it.first] > max(dist[x.second], it.second)) {
s.erase({dist[it.first], it.first});
dist[it.first] = max(dist[x.second], it.second);
s.insert({dist[it.first], it.first});
}
}
}
void solve() {
int n, m, k;
cin >> n >> m >> k;
int x[k];
for (int i = 0; i < k; i++) cin >> x[i];
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
if (u != v) {
g[u].push_back({v, w});
g[v].push_back({u, w});
}
}
dijkstra(x[0]);
int ans = 0;
for (int i = 0; i < k; i++) ans = max(ans, dist[x[i]]);
for (int i = 0; i < k; i++) cout << ans << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
vector<int> p, sz;
int get(int v) {
if (p[v] == -1) return v;
return p[v] = get(p[v]);
}
void unite(int v, int u) {
v = get(v), u = get(u);
if (v == u) return;
if (sz[v] > sz[u]) swap(v, u);
p[v] = u;
sz[u] += sz[v];
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<vector<int>> edges(m);
vector<int> a(n);
for (int i = 0; i < k; i++) {
int t;
cin >> t;
t--;
a[t]++;
}
for (int i = 0; i < m; i++) {
int v, u, w;
cin >> v >> u >> w;
v--, u--;
edges[i] = {v, u, w};
}
sort((edges).begin(), (edges).end(),
[&](const vector<int>& a, const vector<int>& b) { return a[2] < b[2]; });
int ans = 0;
p.resize(n, -1), sz.resize(n, 1);
for (int i = 0; i < m; i++) {
int v = get(edges[i][0]), u = get(edges[i][1]), w = edges[i][2];
if (v != u) {
unite(v, u);
if (sz[v] > sz[u])
a[v] += a[u];
else
a[u] += a[v];
if (a[v] == k or a[u] == k) {
ans = w;
break;
}
}
}
for (int i = 0; i < k; i++) cout << ans << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 112345;
int n, m, k, p[maxn], cnt[maxn], x;
vector<pair<int, pair<int, int>>> edges;
int Find(int x) { return p[x] == x ? x : p[x] = Find(p[x]); }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int(i) = (1); (i) <= (k); (i)++) {
scanf("%d", &x);
cnt[x]++;
}
for (int(i) = (1); (i) <= (m); (i)++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
edges.push_back(make_pair(w, make_pair(u, v)));
}
sort((edges).begin(), (edges).end());
for (int(i) = (1); (i) <= (n); (i)++) p[i] = i;
int ans = 0;
for (auto e : edges) {
int u = Find(e.second.first), v = Find(e.second.second);
if (u == v) continue;
p[u] = v;
if (cnt[u] && cnt[v]) ans = e.first;
cnt[v] += cnt[u];
}
for (int(i) = (1); (i) <= (k); (i)++) printf("%d ", ans);
}
|
#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++) {
cout << w << " ";
}
cout << endl;
exit(0);
}
}
}
} x[100010];
inline bool cmp(edge a, edge b) { return a.w < b.w; }
int main() {
int i, j;
cin >> n >> m >> t;
p = t;
for (int i = 1; i <= t; i++) {
cin >> j;
a[j] = 1;
}
for (int i = 1; i <= m; i++) {
cin >> x[i].u >> x[i].v >> x[i].w;
}
sort(x + 1, x + m + 1, cmp);
for (int i = 1; i <= n; i++) {
f[i] = i;
}
for (int i = 1; i <= m; i++) {
x[i].unit();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 10;
long long n, m, k, node, x, u, v, w, v1, v2, ans;
vector<pair<long long, pair<long long, long long> > > edge;
vector<pair<long long, long long> > t[MAXN];
long long dist[MAXN], pred[MAXN], set_size[MAXN];
bool visited[MAXN], marked[MAXN];
long long get(long long x) {
while (x != pred[x]) {
x = pred[x];
}
return x;
}
void join(long long x1, long long x2) {
if (set_size[x1] > set_size[x2]) {
swap(x1, x2);
}
pred[x1] = pred[x2];
set_size[x2] += set_size[x1];
}
void dfs(long long x, long long max_edge) {
visited[x] = true;
if (marked[x]) {
dist[x] = max_edge;
}
for (int i = 0; i < t[x].size(); i++) {
if (!visited[t[x][i].first]) {
dfs(t[x][i].first, max(max_edge, t[x][i].second));
}
}
}
int main() {
cin >> n >> m >> k;
for (long long i = 1; i <= n; i++) {
pred[i] = i;
dist[i] = 0;
set_size[i] = 1;
visited[i] = false;
}
for (long long i = 0; i < k; i++) {
cin >> x;
node = x;
marked[x] = true;
}
for (long long 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 (long long i = 0; i < edge.size(); i++) {
pair<long long, pair<long long, long long> > cur_edge = edge[i];
v1 = get(cur_edge.second.first);
v2 = get(cur_edge.second.second);
if (v1 != v2) {
join(v1, v2);
t[cur_edge.second.first].push_back(
make_pair(cur_edge.second.second, cur_edge.first));
t[cur_edge.second.second].push_back(
make_pair(cur_edge.second.first, cur_edge.first));
}
}
dfs(node, 0);
for (long long i = 1; i <= n; i++) {
ans = max(dist[i], ans);
}
for (int i = 0; i < k; i++) {
cout << ans << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LLMAX = 2e18;
const int MOD = 1e9 + 7;
const int MAXN = 1e6 + 10;
template <class T>
inline void read(T &DataIn) {
DataIn = 0;
T Flag = 0;
char c = getchar();
while (!isdigit(c)) {
Flag |= c == '-';
c = getchar();
}
while (isdigit(c)) {
DataIn = DataIn * 10 + c - '0';
c = getchar();
}
DataIn = Flag ? -DataIn : DataIn;
}
template <class T>
inline void write(T DataOut, char EndChar = '\n') {
T lenth = 0, number[30];
if (DataOut == 0) {
putchar(48);
putchar(EndChar);
return;
}
while (DataOut > 0) {
number[++lenth] = DataOut % 10;
DataOut /= 10;
}
for (int i = lenth; i >= 1; i--) putchar(number[i] + 48);
putchar(EndChar);
}
priority_queue<int, vector<int>, less<int> > qd;
priority_queue<int, vector<int>, greater<int> > qu;
vector<pair<int, int> > G[MAXN];
int par[MAXN], rk[MAXN], tag[MAXN], ans;
struct node {
int u, v, val;
} edge[MAXN];
void init(int n) {
for (int i = 0; i <= 3 * n; i++) par[i] = i, rk[i] = 0;
}
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (rk[x] > rk[y])
par[y] = x;
else {
par[x] = y;
if (rk[x] == rk[y]) rk[y]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
bool cmp(node x, node y) { return x.val < y.val; }
void dfs(int u, int pre, int w) {
if (tag[u] == 1) ans = max(ans, w);
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].first, val = G[u][i].second;
if (v != pre) dfs(v, u, max(val, w));
}
}
int main(void) {
FILE *fin = NULL, *fout = NULL;
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, u, v, val, k;
cin >> n >> m >> k;
init(n);
for (int i = 0; i < k; i++) cin >> u, tag[u] = 1;
for (int i = 0; i < m; i++) cin >> edge[i].u >> edge[i].v >> edge[i].val;
sort(edge, edge + m, cmp);
for (int i = 0; i < m; i++) {
u = edge[i].u, v = edge[i].v, val = edge[i].val;
if (!same(u, v)) {
unite(u, v);
G[u].push_back(pair<int, int>(v, val));
G[v].push_back(pair<int, int>(u, val));
}
}
for (int i = 1; i <= n; i++)
if (tag[i] == 1) {
dfs(i, i, 0);
break;
}
for (int i = 0; i < k; i++) cout << ans << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int M = 2e5 + 10;
const long long int mod = 1e9 + 7;
const long long int infi = LLONG_MAX;
long long int ans, k, n, x, y, m, mymax = LLONG_MIN, mymin = LLONG_MAX, b, c, z,
sum;
set<pair<pair<long long int, long long int>, long long int>> visited_edges;
vector<pair<long long int, long long int>> edges[M];
long long int min_dist[M];
bool is_special[M];
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int>>,
greater<pair<long long int, long long int>>>
bfs_queue;
int main() {
long long int i, j;
scanf("%lld %lld %lld", &n, &m, &k);
for (i = 1; i < k + 1; i++) {
scanf("%lld", &x);
is_special[x] = true;
min_dist[x] = infi;
b = x;
}
for (i = 1; i < m + 1; i++) {
scanf("%lld %lld %lld", &x, &y, &z);
if (x > y) swap(x, y);
if (x == y) continue;
edges[x].push_back({y, z});
edges[y].push_back({x, z});
}
bfs_queue.push({0, b});
while (!bfs_queue.empty()) {
long long int curr_node = bfs_queue.top().second,
curr_dist = bfs_queue.top().first;
bfs_queue.pop();
for (auto edge : edges[curr_node]) {
long long int next_node = edge.first, edge_weight = edge.second;
if (next_node > curr_node) {
if (visited_edges.find({{curr_node, next_node}, edge_weight}) !=
visited_edges.end())
continue;
visited_edges.insert({{curr_node, next_node}, edge_weight});
} else {
if (visited_edges.find({{next_node, curr_node}, edge_weight}) !=
visited_edges.end())
continue;
visited_edges.insert({{next_node, curr_node}, edge_weight});
}
if (is_special[next_node]) {
min_dist[next_node] =
min(min_dist[next_node], max(curr_dist, edge_weight));
}
bfs_queue.push({max(curr_dist, edge_weight), next_node});
}
}
for (i = 1; i < n + 1; i++) {
if (is_special[i] && i != b) {
ans = max(ans, min_dist[i]);
}
}
for (i = 1; i < k + 1; i++) printf("%lld ", ans);
printf("%s", "\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v[100005];
long long int visited[100005];
void dfs(long long int a) {
visited[a] = 1;
for (long long int i = 0; i < v[a].size(); i++) {
if (visited[v[a][i]] == 0) {
dfs(v[a][i]);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t;
t = 1;
while (t--) {
long long int n, m, k, a, b, c, i, l, r, ans, mid, p;
cin >> n >> m >> k;
long long int x[k + 2];
vector<pair<long long int, pair<long long int, long long int> > > v1;
for (i = 1; i <= k; i++) {
cin >> x[i];
}
for (i = 0; i < m; i++) {
cin >> a >> b >> c;
v1.push_back({c, {a, b}});
}
l = 1;
r = 1e9;
while (l <= r) {
mid = (l + r) / 2;
for (i = 1; i <= n; i++) {
v[i].clear();
visited[i] = 0;
}
for (i = 0; i < m; i++) {
if (v1[i].first <= mid) {
a = v1[i].second.first;
b = v1[i].second.second;
v[a].push_back(b);
v[b].push_back(a);
}
}
dfs(x[1]);
p = 0;
for (i = 1; i <= k; i++) {
if (visited[x[i]] == 0) {
p = 1;
}
}
if (p == 0) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
for (i = 1; i <= k; i++) {
cout << ans << " ";
}
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:225450978")
#pragma GCC optimize("Ofast")
using namespace std;
const long long Mod = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double Pi = 3.141592653589793116, EPS = 1e-9,
Gold = ((1 + sqrt(5)) / 2);
long long keymod[] = {1000000007LL, 1000000009LL, 1000000021LL, 1000000033LL};
long long keyCount = sizeof(keymod) / sizeof(long long);
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcountll(s);
}
auto TimeStart = chrono::steady_clock::now();
auto TimeEnd = chrono::steady_clock::now();
void ControlIO(int argc, char* argv[]);
void TimerStart();
void TimerStop();
void Exit();
string cppstr_infile = "FILE.IN";
string cppstr_outfile = "FILE.OUT";
long long n, m, k;
vector<long long> x;
vector<pair<pair<long long, long long>, long long> > Edge;
vector<long long> DSUpar, DSUsize, DSUspecial;
long long answer = -1;
long long DSUfind(long long z) {
while (DSUpar[z] != -1) z = DSUpar[z];
return z;
}
void DSUmerge(long long u, long long v, long long w) {
u = DSUfind(u);
v = DSUfind(v);
if (u == v) return;
if (DSUsize[u] < DSUsize[v]) swap(u, v);
DSUsize[u] += DSUsize[v];
DSUpar[v] = u;
DSUspecial[u] += DSUspecial[v];
if (answer == -1 && DSUspecial[u] == k) answer = w;
}
bool edgesort(pair<pair<long long, long long>, long long> A,
pair<pair<long long, long long>, long long> B) {
return (A.second < B.second);
}
void Input() {
cin >> n >> m >> k;
x.resize(k);
Edge.resize(m);
DSUpar.resize(n, -1);
DSUsize.resize(n, +1);
DSUspecial.resize(n, 0);
for (auto& z : x) {
cin >> z;
z--;
DSUspecial[z]++;
}
for (auto& E : Edge) {
cin >> E.first.first >> E.first.second >> E.second;
E.first.first--;
E.first.second--;
}
}
void Solve() {
sort(Edge.begin(), Edge.end(), edgesort);
for (auto E : Edge) {
long long u = E.first.first, v = E.first.second;
long long w = E.second;
DSUmerge(u, v, w);
}
for (long long i = 0; i < k; i++) cout << answer << " ";
cout << '\n';
}
int main(int argc, char* argv[]) {
ControlIO(argc, argv);
ios_base::sync_with_stdio(0);
cin.tie(NULL);
Input();
TimerStart();
Solve();
TimerStop();
return 0;
}
void ControlIO(int argc, char* argv[]) {
char* infile = new char[cppstr_infile.size() + 1];
char* outfile = new char[cppstr_outfile.size() + 1];
strcpy(infile, cppstr_infile.c_str());
strcpy(outfile, cppstr_outfile.c_str());
}
void TimerStart() {}
void TimerStop() {}
void Exit() {
TimerStop();
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, K, cnt, head[N], x[N], val[N], p[N], ans, vis[N], fa[N];
struct edge {
int to, nxt, w;
} e[N << 1];
void adde(int x, int y, int w) {
e[++cnt].to = y;
e[cnt].nxt = head[x];
head[x] = cnt;
e[cnt].w = w;
}
struct node {
int x, y, w;
} a[N];
bool cmp(node x, node y) { return x.w < y.w; }
int getfa(int x) { return x == fa[x] ? x : fa[x] = getfa(fa[x]); }
int dfs(int u, int par) {
int sz = 0;
for (int i = head[u], v; i; i = e[i].nxt)
if (v = e[i].to, v != par) {
val[v] = e[i].w;
p[v] = dfs(v, u);
if (p[v]) sz++;
}
if (sz >= 2 || vis[u]) {
for (int i = head[u], v; i; i = e[i].nxt)
if (v = e[i].to, v != par && p[v]) ans = max(ans, val[v]);
} else if (sz == 1) {
for (int i = head[u], v; i; i = e[i].nxt)
if (v = e[i].to, v != par && p[v]) val[u] = max(val[u], val[v]);
}
return sz >= 1 || vis[u];
}
int main() {
scanf("%d%d%d", &n, &m, &K);
for (int i = (1); i <= (K); i++) scanf("%d", &x[i]), vis[x[i]] = 1;
for (int i = (1); i <= (m); i++) scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].w);
sort(a + 1, a + 1 + m, cmp);
for (int i = (1); i <= (n); i++) fa[i] = i;
int edgenum = 0;
for (int i = (1); i <= (m); i++) {
if (edgenum == n - 1) break;
int x = getfa(a[i].x), y = getfa(a[i].y), w = a[i].w;
if (x != y) {
fa[x] = y;
adde(a[i].x, a[i].y, w);
adde(a[i].y, a[i].x, w);
edgenum++;
}
}
int rt = x[1];
dfs(rt, 0);
for (int i = (1); i <= (K); i++) printf("%d ", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edg {
int u, v, w;
} ed[100005];
struct edge {
int v, w, next;
} e[200005];
int color[100005], pnt[100005], head[100005];
int ecnt = 0, ans;
int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
bool cmp(edg x, edg y) { return x.w < y.w; }
int fa(int x) { return (pnt[x] == x) ? x : pnt[x] = fa(pnt[x]); }
void addedge(int u, int v, int w) {
e[ecnt].v = v;
e[ecnt].w = w;
e[ecnt].next = head[u];
head[u] = ecnt++;
}
bool dfs(int x, int fa) {
bool f = false;
for (int i = head[x]; i >= 0; i = e[i].next) {
int v = e[i].v;
if (v == fa) continue;
if (dfs(v, x)) {
ans = max(ans, e[i].w);
f = true;
}
}
return f | color[x];
}
int main() {
int n = read(), m = read(), k = read();
for (int i = 1; i <= k; i++) {
int x = read();
color[x] = 1;
}
for (int i = 1; i <= m; i++) {
ed[i].u = read();
ed[i].v = read();
ed[i].w = read();
}
sort(ed + 1, ed + m + 1, cmp);
for (int i = 1; i <= n; i++) pnt[i] = i;
memset(head, -1, sizeof(head));
for (int i = 1; i <= m; i++) {
int fu = fa(ed[i].u), fv = fa(ed[i].v);
if (fu != fv) {
addedge(ed[i].u, ed[i].v, ed[i].w);
addedge(ed[i].v, ed[i].u, ed[i].w);
pnt[fu] = fv;
}
}
ans = -1;
for (int i = 1; i <= n; i++)
if (color[i]) {
dfs(i, -1);
break;
}
for (int i = 1; i <= k; i++) printf("%d%c", ans, (i == k) ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, dsu[100005] = {0}, x, ans, p;
set<int> specialVertices, numberOfComponents;
pair<int, pair<int, int> > edges[100005];
void initDSU() {
for (int i = 1; i <= n; i++) dsu[i] = i;
}
int findDSU(int u) { return u == dsu[u] ? u : dsu[u] = findDSU(dsu[u]); }
void unionDSU(int u, int v) {
u = findDSU(u);
v = findDSU(v);
if (u != v) {
if (specialVertices.count(v)) swap(u, v);
dsu[v] = u;
if (specialVertices.count(u) && specialVertices.count(v)) {
p--;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
initDSU();
p = k;
for (int i = 1; i <= k; i++) {
cin >> x;
specialVertices.insert(x);
}
for (int i = 1; i <= m; i++) {
cin >> edges[i].second.first >> edges[i].second.second >> edges[i].first;
}
sort(edges + 1, edges + 1 + m);
for (int i = 1; i <= m; i++) {
if (findDSU(edges[i].second.first) != findDSU(edges[i].second.second)) {
unionDSU(edges[i].second.first, edges[i].second.second);
}
if (p == 1) {
ans = edges[i].first;
break;
}
}
for (int i = 1; i <= k; i++) cout << ans << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int f[100005];
int x[100005];
int cnt[100005];
vector<pair<int, pair<int, int>>> v;
int getf(int k) { return (f[k] == k) ? k : f[k] = getf(f[k]); }
int unite(int x, int y, int w) {
x = getf(x);
y = getf(y);
if (x == y) return 0;
if (x != y) {
f[y] = x;
if (cnt[x] > 0 && cnt[y] > 0) {
cnt[x] += cnt[y];
return w;
}
cnt[x] += cnt[y];
return 0;
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
scanf("%d", &x[i]);
cnt[x[i]] = 1;
}
for (int i = 0; i < m; i++) {
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
v.push_back(make_pair(w, pair<int, int>(a, b)));
}
sort(v.begin(), v.end());
for (int i = 1; i <= n; i++) f[i] = i;
int ans = 0;
for (int i = 0; i < v.size(); i++)
ans = max(ans, unite(v[i].second.first, v[i].second.second, v[i].first));
for (int i = 0; i < k; i++) printf("%d ", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 5;
vector<pair<int, int>> adj[N];
int n, m, k, dis[N];
bool special[N];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
x--;
special[x] = 1;
}
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
adj[u].push_back(make_pair(w, v));
if (u != v) adj[v].push_back(make_pair(w, u));
}
for (int i = 0; i < n; i++) dis[i] = INT_MAX;
for (int i = 0; i < n; i++) {
if (special[i]) {
set<pair<int, int>> pq;
dis[i] = 0;
pq.insert(make_pair(0, i));
while (!pq.empty()) {
pair<int, int> tp = *pq.begin();
pq.erase(pq.begin());
for (pair<int, int> &v : adj[tp.second]) {
if (dis[v.second] > max(v.first, tp.first)) {
pq.erase(make_pair(dis[v.second], v.second));
dis[v.second] = max(v.first, tp.first);
pq.insert(make_pair(dis[v.second], v.second));
}
}
}
break;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!special[i]) continue;
ans = max(ans, dis[i]);
}
for (int i = 0; i < k; i++) cout << ans << " ";
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;
struct cmp {
bool operator()(const pair<int, string> a, const pair<int, string> b) {
return a.first > b.first;
}
};
int N = 1e5 + 5;
vector<int> special(N), ans(N);
unordered_map<int, bool> isSpecial;
unordered_map<int, bool> isIncluded;
priority_queue<pair<int, string>, vector<pair<int, string>>, cmp> pq;
void addEdge(int x, int y, int w) {
pq.push(make_pair(w, to_string(x) + "*" + to_string(y)));
}
vector<int> recoverVertices(string str) {
int n = str.length(), star;
for (int i = 0; i < n; i++) {
if (str[i] == '*') {
star = i;
break;
}
}
vector<int> ans(2);
ans[0] = stoi(str.substr(0, star));
ans[1] = stoi(str.substr(star + 1));
return ans;
}
vector<int> parent(N, -1);
int findDSU(int v) {
if (parent[v] < 0) return v;
parent[v] = findDSU(parent[v]);
return parent[v];
}
bool DSUUtil(int x, int y, int k) {
parent[y] += parent[x];
parent[x] = y;
special[y] += special[x];
if (special[y] == k) return true;
return false;
}
bool unionDSU(int v1, int v2, int k) {
int p1 = findDSU(v1);
int p2 = findDSU(v2);
if (p1 == p2) return false;
if (abs(parent[p1]) < abs(parent[p2]))
return DSUUtil(p1, p2, k);
else
return DSUUtil(p2, p1, k);
}
void include(int p, int& spCount) {
isIncluded[p] = true;
spCount++;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int num;
cin >> num;
special[num] = 1;
}
for (int i = 1; i <= m; i++) {
int x, y, w;
cin >> x >> y >> w;
addEdge(x, y, w);
}
int cnt = 1, spCount = 0;
int maxEdgeWeight = 0;
while (cnt <= n - 1) {
int curEdgeWeight = pq.top().first;
string str = pq.top().second;
pq.pop();
vector<int> vertexes = recoverVertices(str);
int u = vertexes[0];
int v = vertexes[1];
int p1 = findDSU(u);
int p2 = findDSU(v);
if (p1 == p2) continue;
cnt++;
maxEdgeWeight = curEdgeWeight;
if (unionDSU(u, v, k)) break;
}
for (int i = 1; i <= k; i++) cout << maxEdgeWeight << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(4e5) + 5;
const int inf = (int)1e9 + 7;
int n, m, k;
int p[N], cnt[N], sz;
int vals[N], up[N];
vector<pair<int, pair<int, int> > > edges;
pair<int, int> find9(int x) {
if (p[x] == x) {
return make_pair(x, up[x]);
}
pair<int, int> to = find9(p[x]);
up[x] = max(up[x], to.second);
p[x] = to.first;
return make_pair(p[x], up[x]);
}
void unite(int x, int y, int w) {
x = find9(x).first;
y = find9(y).first;
if (x == y) {
return;
}
++sz;
p[x] = p[y] = p[sz] = sz;
if (cnt[x] && cnt[y]) {
up[x] = up[y] = w;
}
cnt[sz] = cnt[x] + cnt[y];
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= k; ++i) {
scanf("%d", vals + i);
cnt[vals[i]] = 1;
}
for (int i = 1; i <= n; ++i) {
p[i] = i;
}
sz = n;
for (int i = 1; i <= m; ++i) {
int x, y, w;
scanf("%d %d %d", &x, &y, &w);
edges.push_back(make_pair(w, make_pair(x, y)));
}
sort(edges.begin(), edges.end());
for (auto i : edges) {
unite(i.second.first, i.second.second, i.first);
}
for (int i = 1; i <= k; ++i) {
printf("%d ", find9(vals[i]).second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000001;
long long prost1 = 36028797018963913;
long long prost2 = 35184372088777;
long long n, m, k;
vector<vector<pair<long long, long long> > > v;
void init() { v.resize(n); }
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
init();
vector<long long> a(k);
for (long long c = 0; c < k; c++) {
cin >> a[c];
a[c]--;
}
for (long long c = 0; c < m; c++) {
long long e, e1, len;
cin >> e >> e1 >> len;
e--;
e1--;
v[e].push_back({e1, len});
v[e1].push_back({e, len});
}
vector<long long> d(n, inf);
d[a[0]] = 0;
set<pair<long long, long long> > q;
q.insert({0, a[0]});
while (!q.empty()) {
long long ver = q.begin()->second;
q.erase(q.begin());
for (size_t j = 0; j < v[ver].size(); ++j) {
long long to = v[ver][j].first, len = v[ver][j].second;
if (max(d[ver], len) < d[to]) {
q.erase(make_pair(d[to], to));
d[to] = max(d[ver], len);
q.insert(make_pair(d[to], to));
}
}
}
long long mmax = -inf, pos;
for (long long c = 1; c < k; c++) {
if (mmax < d[a[c]]) {
mmax = d[a[c]];
pos = a[c];
}
}
for (long long c = 0; c < k; c++) {
cout << mmax << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, K, u, v, c;
map<int, int> MAP[100001];
vector<int> adj[100001];
set<int> weight;
set<int>::iterator it;
vector<int> listWeight;
int A[100001];
bool C[100001], S[100001];
int total = 0;
void DFS(int u, int d) {
if (S[u]) ++total;
C[u] = 1;
for (int j = 0; j < adj[u].size(); ++j) {
int v = adj[u][j];
if (MAP[u][v] > d) continue;
if (C[v]) continue;
DFS(v, d);
}
}
bool kt(int d) {
for (int i = 1; i <= N; ++i) C[i] = 0;
for (int i = 1; i <= N; ++i)
if (!C[i]) {
total = 0;
DFS(i, d);
if (total >= K) return 1;
}
return 0;
}
bool check(int d) { return kt(d) && !(kt(d - 1)); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
cin >> N >> M >> K;
for (int i = 1; i <= K; ++i) {
cin >> A[i];
S[A[i]] = 1;
}
for (int i = 1; i <= M; ++i) {
cin >> u >> v >> c;
if (u == v) continue;
weight.insert(c);
int cc = MAP[u][v];
if (!cc) {
adj[u].push_back(v);
adj[v].push_back(u);
cc = 1e9;
}
MAP[v][u] = MAP[u][v] = min(c, cc);
}
listWeight.push_back(0);
for (it = weight.begin(); it != weight.end(); ++it) {
listWeight.push_back(*it);
}
sort(listWeight.begin(), listWeight.end());
int l = 1, r = listWeight.size() - 1;
while (l + 1 < r) {
int mid = (l + r) / 2;
int d = listWeight[mid];
bool c1 = kt(d);
if (c1)
r = mid;
else
l = mid + 1;
}
for (int i = r; i >= l; --i)
if (check(listWeight[i])) {
for (int j = 1; j <= K; ++j) cout << listWeight[i] << " ";
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long nMod = 1e9 + 7;
inline long long GCD(long long a, long long b) {
while (b != 0) {
long long c = a % b;
a = b;
b = c;
}
return a;
};
inline long long LCM(long long a, long long b) { return (a / GCD(a, b)) * b; };
int n, m, k;
int cnt[100005];
int root[100005];
vector<pair<int, pair<int, int> > > arr;
int getRoot(int u) {
if (root[u] == 0) return u;
return root[u] = getRoot(root[u]);
}
void unionRoot(int u, int v) {
if (getRoot(u) == getRoot(v)) return;
cnt[getRoot(v)] += cnt[getRoot(u)];
root[getRoot(u)] = getRoot(v);
}
void input() {
cin >> n >> m >> k;
int P;
for (int i = 0; i < k; i++) {
int u;
cin >> u;
cnt[u] = 1;
P = u;
}
for (int i = 0; i < m; i++) {
int u, v, c;
cin >> u >> v >> c;
arr.push_back({c, {u, v}});
}
sort(arr.begin(), arr.end());
int res = 0;
for (auto x : arr) {
int c = x.first;
int u = x.second.first;
int v = x.second.second;
unionRoot(u, v);
if (cnt[getRoot(u)] == k) {
res = c;
break;
}
}
for (int i = 0; i < k; i++) {
cout << res << " ";
}
cout << "\n";
}
void vietnakid() { input(); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
vietnakid();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int MAXN = 112345;
int p[MAXN], cs[MAXN];
tuple<int, int, int> es[MAXN];
int n, m, k;
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
int join(int x, int y) {
int px = find(x);
int py = find(y);
if (px == py) return px;
cs[px] += cs[py];
p[py] = px;
return px;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) p[i] = i;
for (int i = 0; i < k; i++) {
int s;
cin >> s;
cs[s - 1]++;
}
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
es[i] = tie(w, u, v);
}
sort(es, es + m);
for (int i = 0; i < m; i++) {
int u, v, w;
tie(w, u, v) = es[i];
int x = join(u, v);
if (cs[x] == k) {
for (int j = 0; j < k; j++) cout << w << ' ';
cout << endl;
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mn = 1e5 + 5;
int n, m, k;
int a[mn], p[mn];
vector<int> g[mn];
int x[mn];
int join(int u) {
if (u != p[u]) return p[u] = join(p[u]);
return p[u];
}
int uni(int u, int v) {
u = join(u);
v = join(v);
if (u == v) return 0;
if (p[u] < p[v]) {
p[v] = u;
x[u] += x[v];
} else {
p[u] = v;
x[v] += x[u];
}
return 1;
}
pair<int, pair<int, int> > ed[mn];
bool cmp(pair<int, pair<int, int> > a, pair<int, pair<int, int> > b) {
return a.first > b.first;
}
int kq;
int spe[mn];
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 >> spe[i];
x[spe[i]] = 1;
}
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
ed[i] = {w, {u, v}};
}
sort(ed + 1, ed + m + 1);
for (int i = 1; i <= m; i++) {
int u = ed[i].second.first;
int v = ed[i].second.second;
int w = ed[i].first;
kq = max(kq, w);
uni(u, v);
if (x[join(u)] == k) break;
}
for (int i = 1; i <= k; i++) cout << kq << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 1;
int p[maxn], w[maxn];
int pa(int x) { return x == p[x] ? x : p[x] = pa(p[x]); }
void merge(int x, int y) {
x = pa(x);
y = pa(y);
if (x != y) {
p[x] = y;
w[y] += w[x];
}
}
int n, k, m;
struct Edge {
int u, v, w;
void read() { scanf("%d %d %d", &u, &v, &w); }
bool operator<(const Edge &r) const { return w < r.w; }
} e[maxn];
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; ++i) p[i] = i, w[i] = 0;
int special;
for (int i = 1; i <= k; ++i) {
int &x = special;
scanf("%d", &x);
w[x] = 1;
}
for (int i = 1; i <= m; ++i) e[i].read();
sort(e + 1, e + 1 + m);
for (int i = 1; i <= m; ++i) {
merge(e[i].u, e[i].v);
if (w[pa(special)] == k) {
int ans = e[i].w;
for (int i = 1; i <= k; ++i) printf("%d%c", ans, " \n"[i == k]);
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v, w;
} e[100004];
int f[100004], n, m, k;
int sp[100004];
inline bool dex(edge A, edge B) { return A.w < B.w; }
int Find(int x) { return (f[x] == x) ? x : f[x] = Find(f[x]); }
int w33ha() {
memset(sp, 0, sizeof(sp));
for (int i = 1; i <= n; i++) f[i] = i;
int x;
for (int i = 1; i <= k; i++) {
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, dex);
int ans = 0;
for (int i = 1; i <= m; i++) {
int p = Find(e[i].u), q = Find(e[i].v);
if (p != q) {
if (sp[p] && sp[q])
ans = max(ans, e[i].w);
else if (sp[p] || sp[q]) {
sp[p] = 1;
sp[q] = 1;
}
f[p] = q;
}
}
for (int i = 1; i < k; i++) printf("%d ", ans);
printf("%d\n", ans);
return 0;
}
int main() {
while (scanf("%d%d%d", &n, &m, &k) != EOF) w33ha();
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;
vector<pair<int, pair<int, int> > > edges;
vector<int> special;
int parent[100005], p_size[100005], sp_size[100005];
int find(int i) {
while (parent[i] != i) {
parent[i] = parent[parent[i]];
i = parent[i];
}
return i;
}
void ds_union(int u, int v) {
int root_u = find(u);
int root_v = find(v);
if (p_size[root_u] < p_size[root_v]) {
parent[root_u] = parent[root_v];
p_size[root_v] += p_size[root_u];
sp_size[root_v] += sp_size[root_u];
} else {
parent[root_v] = parent[root_u];
p_size[root_u] += p_size[root_v];
sp_size[root_u] += sp_size[root_v];
}
}
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 = 1; i <= n; i++) {
parent[i] = i;
p_size[i] = 1;
}
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
special.push_back(x);
sp_size[x] = 1;
}
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
edges.push_back({w, {u, v}});
}
sort(edges.begin(), edges.end());
int ans = 0;
for (int i = 0; i < edges.size(); i++) {
int u = edges[i].second.first;
int v = edges[i].second.second;
if (find(u) != find(v)) {
ds_union(u, v);
ans = edges[i].first;
int x = find(u);
if (sp_size[x] == special.size()) {
for (int j = 0; j < k; j++) {
cout << ans << " ";
}
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long edgestory;
long long last;
struct UnionFind {
vector<int> f;
vector<bool> special;
void init(int n) {
f.clear();
f.insert(f.begin(), n, -1);
special.clear();
special.insert(special.begin(), n, false);
edgestory = 0;
}
int comp(int x) { return (f[x] == -1 ? x : f[x] = comp(f[x])); }
bool sp(int x) { return special[comp(x)]; }
bool join1(int i, int j) {
if (i == j) return true;
edgestory++;
bool con = comp(i) == comp(j);
if (!con) {
bool spv = sp(i) || sp(j);
if (sp(i) && sp(j)) last = edgestory;
f[comp(i)] = comp(j);
special[comp(i)] = spv;
}
return con;
}
pair<int, int> join2(int i, int j) {
if (i == j) return {0, 0};
edgestory++;
if (edgestory == last) return {i, j};
bool con = comp(i) == comp(j);
if (!con) {
f[comp(i)] = comp(j);
}
return {0, 0};
}
} uf;
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
long long n, m, k;
cin >> n >> m >> k;
vector<long long> special(k);
for (auto &x : special) cin >> x;
vector<tuple<long long, long long, long long>> edges(m);
for (auto &x : edges) {
long long u, v, w;
cin >> u >> v >> w;
x = make_tuple(w, u - 1, v - 1);
}
sort(edges.begin(), edges.end());
uf.init(n);
for (auto &x : special) uf.special[x - 1] = true;
for (auto &[w, u, v] : edges) uf.join1(u, v);
long long lastw = 0;
uf.init(n);
for (auto &[w, u, v] : edges) {
lastw = w;
if (uf.join2(u, v) != make_pair(0, 0)) break;
}
for (int i = 0; i < k; i++) cout << " " + !i << lastw;
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, m, k, a, b, l, p;
cin >> n >> m >> k;
l = k;
int S[n], B[n];
long long Di[n], d, w;
vector<pair<int, int>> D[n];
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
Q;
for (int i = 0; i < n; i++) {
S[i] = 0;
B[i] = 1;
Di[i] = 2000000000;
}
for (int i = 0; i < k; i++) {
cin >> a;
a--;
S[a] = 1;
p = a;
}
for (int i = 0; i < m; i++) {
cin >> a >> b >> w;
a--;
b--;
D[a].push_back({b, w});
D[b].push_back({a, w});
}
Q.push({0, p});
Di[p] = 0;
while (Q.size() > 0) {
while (B[Q.top().second] == 0 && Q.size() > 0) {
Q.pop();
}
if (Q.size() > 0) {
a = Q.top().second;
d = Q.top().first;
if (S[a] == 1) {
l--;
}
if (l == 0) {
for (int y = 0; y < k; y++) {
cout << Di[a] << " ";
}
return 0;
}
B[a] = 0;
Q.pop();
for (int i = 0; i < D[a].size(); i++) {
b = D[a][i].first;
w = D[a][i].second;
if (B[b] == 1 && max(w, Di[a]) < Di[b]) {
Di[b] = max(w, Di[a]);
Q.push({Di[b], b});
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, k, x, fa[N], ha[N];
struct edge {
int u, v, w;
} E[N];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
int cmp(const edge& e1, const edge& e2) { return e1.w < e2.w; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 0; i < k; i++) {
cin >> x;
ha[x] = 1;
}
for (int i = 0; i < m; i++) cin >> E[i].u >> E[i].v >> E[i].w;
sort(E, E + m, cmp);
int ans = 0;
for (int i = 0; i < m; i++) {
int u = E[i].u, v = E[i].v;
u = find(u);
v = find(v);
if (u == v) continue;
if (ha[u] && ha[v]) ans = max(ans, E[i].w);
fa[u] = v;
ha[v] |= ha[u];
}
for (int i = 0; i < k; i++) cout << ans << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Read() {
int f = 1, x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
const int N = 100000 + 5;
int n, m, k, st, ans, x[N], inset[N], fa[N], dis[N];
int find(int x) { return x == fa[x] ? fa[x] : fa[x] = find(fa[x]); }
vector<pair<int, int> > g1[N];
struct edge {
int u, v, w;
} e[N];
void dfs(int u, int pre, int w) {
dis[u] = max(dis[pre], w);
for (int i = 0; i < g1[u].size(); i++) {
int v = g1[u][i].first;
if (v == pre) continue;
dfs(v, u, g1[u][i].second);
}
}
bool compare(const edge& uu, const edge& vv) { return uu.w < vv.w; }
void Kruskal() {
int ans = 0, res = 0;
for (int i = 1; i <= n; i++) fa[i] = i;
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;
fa[find(u)] = find(v);
++ans;
g1[u].push_back({v, w});
g1[v].push_back({u, w});
if (ans == n - 1) break;
}
dfs(st, 0, 0);
for (int i = 1; i <= n; i++) res = max(res, inset[i] * dis[i]);
while (k--) cout << res << " ";
return;
}
int main() {
n = Read(), m = Read(), k = Read();
for (int i = 1; i <= k; i++) x[i] = Read(), inset[x[i]] = 1, st = x[i];
for (int i = 1; i <= m; i++) {
e[i].u = Read();
e[i].v = Read();
e[i].w = Read();
}
sort(e + 1, e + m + 1, compare);
Kruskal();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<pair<int, int> > adj[N];
bool visit[N], spec[N];
int dijstra(int src) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
q.push({0, src});
int maxi = 0;
while (!q.empty()) {
int u = q.top().second;
int c = q.top().first;
q.pop();
if (visit[u]) continue;
if (spec[u]) maxi = max(maxi, c);
visit[u] = 1;
for (auto v : adj[u]) {
if (!visit[v.first]) q.push({max(c, v.second), v.first});
}
}
return maxi;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int x;
for (int i = 0; i < k; ++i) {
scanf("%d", &x);
spec[x] = 1;
}
for (int i = 0; i < m; ++i) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
adj[u].push_back({v, c});
adj[v].push_back({u, c});
}
int ans = dijstra(x);
for (int i = 0; i < k; ++i) printf("%d%c", ans, " \n"[i + 1 == k]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long double PI = 3.141592653589793238462643383279502884197;
priority_queue<int, vector<int>, greater<int> > pq;
vector<int> v;
struct node {
int u, v, c;
} vec[100000];
int p[100000];
int rotn[100000];
int find(int a) {
if (p[a] == -1) return a;
return p[a] = find(p[a]);
}
void merge(int a, int b) {
a = find(a), b = find(b);
if (a == b) return;
rotn[a] += rotn[b];
p[b] = a;
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
memset(p, -1, sizeof(p));
int t;
for (int i = 0; i < k; i++) {
scanf("%d", &t);
rotn[--t] = 1;
}
int a, b, c;
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &a, &b, &c);
a--;
b--;
vec[i] = {a, b, c};
}
sort(vec, vec + m, [](node v1, node v2) { return v1.c < v2.c; });
for (int i = 0; i < m; i++) {
merge(vec[i].u, vec[i].v);
if (rotn[find(vec[i].u)] == k) {
for (int j = 0; j < k; j++) printf("%d ", vec[i].c);
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct point {
int i, j;
} point;
point rooks[666];
point king;
int mat[1000][1000];
void move(int i, int j) {
if (mat[king.i + i][king.j + j] == 1) i = 0;
king.i += i;
king.j += j;
cout << king.i << " " << king.j << endl;
cout.flush();
}
int main() {
cin >> king.i >> king.j;
for (int i = 0; i < 1000; i++)
for (int j = 0; j < 1000; j++) mat[i][j] = 0;
for (int i = 0; i < 666; i++) cin >> rooks[i].i >> rooks[i].j;
for (int i = 0; i < 666; i++) mat[rooks[i].i][rooks[i].j] = 1;
int o1, o2, o3;
o1 = 1;
o2 = rooks[0].i;
o3 = rooks[0].j;
bool merkez = false;
int solust = 0;
int solalt = 0;
int sagust = 0;
int sagalt = 0;
int yon = 0;
while (1) {
if (o1 <= 0) break;
o1--;
mat[rooks[o1].i][rooks[o1].j] = 0;
rooks[o1].i = o2;
rooks[o1].j = o3;
mat[rooks[o1].i][rooks[o1].j] = 1;
if (!merkez) {
int movex;
if (king.i > 500)
movex = -1;
else if (king.i < 500)
movex = 1;
else
movex = 0;
int movey;
if (king.j > 500)
movey = -1;
else if (king.j < 500)
movey = 1;
else
movey = 0;
if (movex == 0 && movey == 0) {
merkez = true;
for (int q = 0; q < 666; q++) {
if (rooks[q].i < 500 && rooks[q].j < 500)
solust++;
else if (rooks[q].i < 500 && rooks[q].j > 500)
sagust++;
else if (rooks[q].i > 500 && rooks[q].j < 500)
solalt++;
else
sagalt++;
}
int minim = min(min(solust, sagust), min(solalt, sagalt));
if (minim == solust)
yon = 3;
else if (minim == sagust)
yon = 2;
else if (minim == solalt)
yon = 1;
else
yon = 0;
} else {
move(movex, movey);
cin >> o1 >> o2 >> o3;
continue;
}
}
if (yon == 0)
move(-1, -1);
else if (yon == 1)
move(-1, 1);
else if (yon == 2)
move(1, -1);
else
move(1, 1);
cin >> o1 >> o2 >> o3;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct aa {
int x, y;
} s, a[700];
int sum[4];
bool used[1005][1005];
void move(int dx, int dy) {
s.x += dx;
s.y += dy;
if (used[s.x][s.y]) s.x -= dx;
printf("%d %d\n", s.x, s.y);
fflush(stdout);
int k, x, y;
scanf("%d%d%d", &k, &x, &y);
if (k == -1 || !k) exit(0);
used[a[k].x][a[k].y] = 0;
used[x][y] = 1;
a[k].x = x;
a[k].y = y;
}
int main() {
scanf("%d%d", &s.x, &s.y);
for (int i = 1; i <= 666; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
used[a[i].x][a[i].y] = 1;
}
while (s.x < 500) move(1, 0);
while (s.x > 500) move(-1, 0);
while (s.y < 500) move(0, 1);
while (s.y > 500) move(0, -1);
for (int i = 1; i <= 999; i++)
for (int j = 1; j <= 999; j++)
if (used[i][j]) {
if (i < 500) {
if (j < 500)
sum[3]++;
else
sum[2]++;
} else {
if (j < 500)
sum[1]++;
else
sum[0]++;
}
}
int x = 0;
for (int i = 1; i < 4; i++)
if (sum[x] > sum[i]) x = i;
int dx = (x >> 1) ? 1 : -1, dy = (x & 1) ? 1 : -1;
while (1) move(dx, dy);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
pair<int, int> king, r[667];
int k;
bool oc[1002][1002];
for (int i = 1; i < 1000; i++)
for (int j = 1; j < 1000; j++) oc[i][j] = false;
cin >> king.first >> king.second;
for (int i = 1; i <= 666; i++) {
cin >> r[i].first >> r[i].second;
oc[r[i].first][r[i].second] = true;
}
bool isgetcenter = false;
pair<int, int> t, n;
t.first = t.second = 500;
while (1) {
if (king.first == 500 && king.second == 500 && !isgetcenter) {
isgetcenter = true;
pair<int, int> l[4];
l[0] = make_pair(0, 0);
l[1] = make_pair(0, 1);
l[2] = make_pair(0, 2);
l[3] = make_pair(0, 3);
for (int i = 1; i < 500; i++)
for (int j = 1; j < 500; j++)
if (oc[i][j]) l[0].first++;
for (int i = 501; i < 1000; i++)
for (int j = 1; j < 500; j++)
if (oc[i][j]) l[1].first++;
for (int i = 501; i < 1000; i++)
for (int j = 501; j < 1000; j++)
if (oc[i][j]) l[2].first++;
for (int i = 1; i < 500; i++)
for (int j = 501; j < 1000; j++)
if (oc[i][j]) l[3].first++;
sort(l, l + 4);
if (l[0].second == 0) {
t.first = 999;
t.second = 999;
}
if (l[0].second == 1) {
t.first = 1;
t.second = 999;
}
if (l[0].second == 2) {
t.first = 1;
t.second = 1;
}
if (l[0].second == 3) {
t.first = 999;
t.second = 1;
}
}
if (king.first > t.first && !oc[king.first - 1][king.second]) king.first--;
if (king.second > t.second && !oc[king.first][king.second - 1])
king.second--;
if (king.first < t.first && !oc[king.first + 1][king.second]) king.first++;
if (king.second < t.second && !oc[king.first][king.second + 1])
king.second++;
cout << king.first << " " << king.second << endl;
cout.flush();
cin >> k >> n.first >> n.second;
if (k < 1 && n.first < 1 && n.second < 1) break;
oc[r[k].first][r[k].second] = false;
r[k] = n;
oc[r[k].first][r[k].second] = true;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int x, y;
int px[700], py[700];
int k, rx, ry;
int dx, dy;
int q[4];
bool has(int x, int y) {
for (int i = 1; i <= 666; i++) {
if (px[i] == x && py[i] == y) return true;
}
return false;
}
void attempt(int tx, int ty) {
if (has(tx, ty)) {
ty = y;
}
printf("%d %d\n", tx, ty);
fflush(stdout);
scanf("%d%d%d", &k, &rx, &ry);
if (k <= 0) {
exit(0);
}
px[k] = rx;
py[k] = ry;
x = tx;
y = ty;
}
int sgn(int x) {
if (x > 0) return 1;
if (x < 0) return -1;
return 0;
}
int main() {
scanf("%d%d", &x, &y);
for (int i = 1; i <= 666; i++) {
scanf("%d%d", &px[i], &py[i]);
}
while (x != 500 || y != 500) {
attempt(x + sgn(500 - x), y + sgn(500 - y));
}
for (int i = 1; i <= 666; i++) {
if (px[i] < 500 && py[i] < 500) q[0]++;
if (px[i] < 500 && py[i] > 500) q[1]++;
if (px[i] > 500 && py[i] < 500) q[2]++;
if (px[i] > 500 && py[i] > 500) q[3]++;
}
int mn = *min_element(q, q + 4);
if (mn == q[0]) dx = 1, dy = 1;
if (mn == q[1]) dx = 1, dy = -1;
if (mn == q[2]) dx = -1, dy = 1;
if (mn == q[3]) dx = -1, dy = -1;
for (int i = 1; i <= 499; i++) {
attempt(x + dx, y + dy);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000;
const int Pmid = 500;
struct GPOINT {
int x, y;
GPOINT() {}
GPOINT(int _x, int _y) : x(_x), y(_y) {}
} car[N], kin;
int cc[N][N];
int main() {
scanf("%d%d", &kin.x, &kin.y);
for (int i = 1; i <= 666; i++) {
scanf("%d%d", &car[i].x, &car[i].y);
cc[car[i].x][car[i].y] = 1;
}
while (kin.x != Pmid || kin.y != Pmid) {
if (kin.x < Pmid) {
kin.x++;
if (cc[kin.x][kin.y]) kin.x--;
}
if (kin.x > Pmid) {
kin.x--;
if (cc[kin.x][kin.y]) kin.x++;
}
if (kin.y < Pmid) {
kin.y++;
if (cc[kin.x][kin.y]) kin.y--;
}
if (kin.y > Pmid) {
kin.y--;
if (cc[kin.x][kin.y]) kin.y++;
}
printf("%d %d\n", kin.x, kin.y);
fflush(stdout);
int num, tox, toy;
scanf("%d%d%d", &num, &tox, &toy);
if (num <= 0) exit(0);
cc[car[num].x][car[num].y] = 0;
car[num] = GPOINT(tox, toy);
cc[tox][toy] = 1;
}
int LU = 0, LD = 0, RU = 0, RD = 0;
for (int i = 1; i <= 666; i++) {
if (car[i].x < Pmid && car[i].y < Pmid) LU++;
if (car[i].x > Pmid && car[i].y < Pmid) LD++;
if (car[i].x < Pmid && car[i].y > Pmid) RU++;
if (car[i].x > Pmid && car[i].y > Pmid) RD++;
}
int movx = 0, movy = 0;
if (LU + LD + RU >= 500) movx = -1, movy = -1;
if (LU + RD + RU >= 500) movx = -1, movy = 1;
if (LU + LD + RD >= 500) movx = 1, movy = -1;
if (LD + RU + RD >= 500) movx = 1, movy = 1;
while (1 < kin.x && kin.x < 999 && 1 < kin.y && kin.y < 999) {
kin.x += movx;
kin.y += movy;
if (cc[kin.x][kin.y]) kin.y -= movy;
printf("%d %d\n", kin.x, kin.y);
fflush(stdout);
int num, tox, toy;
scanf("%d%d%d", &num, &tox, &toy);
if (num <= 0) exit(0);
cc[car[num].x][car[num].y] = 0;
car[num] = GPOINT(tox, toy);
cc[tox][toy] = 1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 666;
pair<long long, long long> rook[MAX];
long long cnt[4];
long long x, y;
long long cuadrante(long long i) {
if (x > rook[i].first) {
if (y < rook[i].second) {
return 0;
} else {
return 1;
}
}
if (y > rook[i].second) {
return 2;
}
return 3;
}
void doit() {
cin >> x >> y;
for (long long i = 0; i < (long long)MAX; i++) {
cin >> rook[i].first >> rook[i].second;
}
while (x < 500) {
x++;
cout << x << " " << y << endl;
long long k, a, b;
cin >> k >> a >> b;
if (k == -1 || a == -1 || b == -1) {
return;
}
if (k == 0 || a == 0 || b == 0) {
return;
}
k--;
rook[k] = {a, b};
}
while (x > 500) {
x--;
cout << x << " " << y << endl;
long long k, a, b;
cin >> k >> a >> b;
if (k == -1 || a == -1 || b == -1) {
return;
}
if (k == 0 || a == 0 || b == 0) {
return;
}
k--;
rook[k] = {a, b};
}
while (y < 500) {
y++;
cout << x << " " << y << endl;
long long k, a, b;
cin >> k >> a >> b;
if (k == -1 || a == -1 || b == -1) {
return;
}
if (k == 0 || a == 0 || b == 0) {
return;
}
k--;
rook[k] = {a, b};
}
while (y > 500) {
y--;
cout << x << " " << y << endl;
long long k, a, b;
cin >> k >> a >> b;
if (k == -1 || a == -1 || b == -1) {
return;
}
if (k == 0 || a == 0 || b == 0) {
return;
}
k--;
rook[k] = {a, b};
}
for (long long i = 0; i < (long long)MAX; i++) {
cnt[cuadrante(i)]++;
}
long long mini = 1e18;
long long ind = -1;
for (long long i = 0; i < (long long)4; i++) {
if (cnt[i] < mini) {
ind = i;
mini = cnt[i];
}
}
long long down, right;
if (ind == 0) {
down = 1;
right = -1;
}
if (ind == 1) {
down = 1;
right = 1;
}
if (ind == 2) {
down = -1;
right = 1;
}
if (ind == 3) {
down = -1;
right = -1;
}
while (true) {
x += down;
y += right;
for (long long i = 0; i < (long long)MAX; i++) {
if (x == rook[i].first && y == rook[i].second) {
x -= down;
y -= right;
if (x + down >= 1 && x + down <= 999) {
x += down;
} else {
y += right;
}
break;
}
}
if (x < 1) {
x++;
}
if (y < 1) {
y++;
}
if (x > 999) {
x--;
}
if (y > 999) {
y--;
}
cout << x << " " << y << endl;
long long k, a, b;
cin >> k >> a >> b;
if (k == -1 && a == -1 && b == -1) {
break;
}
if (k == 0 && a == 0 && b == 0) {
break;
}
k--;
rook[k] = {a, b};
}
}
int main() {
long long T = 1;
while (T--) {
doit();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int kx, ky;
int x[1011], y[1011];
int g[1011][1011];
bool done;
void add(int x, int y, int det) { g[x][y] += det; }
int norm(int fr, int to) {
if (fr > to) return -1;
if (fr < to) return 1;
return 0;
}
void o(int kx, int ky) {
printf("%d %d\n", kx, ky);
fflush(stdout);
int id, _x, _y;
scanf("%d%d%d", &id, &_x, &_y);
if (id <= 0) {
done = true;
return;
}
add(x[id], y[id], -1);
x[id] = _x;
y[id] = _y;
add(x[id], y[id], 1);
}
int main() {
scanf("%d%d", &kx, &ky);
for (int i = 1; i <= 666; i++) {
scanf("%d%d", &x[i], &y[i]);
add(x[i], y[i], 1);
}
done = false;
while (!done && (kx != 500 || ky != 500)) {
int dx = norm(kx, 500);
int dy = norm(ky, 500);
kx += dx;
ky += dy;
if (g[kx][ky]) {
if (g[kx - dx][ky])
ky -= dy;
else
kx -= dx;
}
o(kx, ky);
}
if (!done) {
int s[11][11];
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) s[i][j] = 0;
for (int i = 1; i <= 666; i++) s[x[i] > 500][y[i] > 500]++;
int dx, dy;
if (s[0][0] + s[0][1] + s[1][0] >= 500) {
dx = -1;
dy = -1;
} else if (s[0][1] + s[0][0] + s[1][1] >= 500) {
dx = -1;
dy = 1;
} else if (s[1][0] + s[0][0] + s[1][1] >= 500) {
dx = 1;
dy = -1;
} else {
dx = 1;
dy = 1;
}
while (!done) {
kx += dx;
ky += dy;
if (g[kx][ky]) {
if (g[kx - dx][ky])
ky -= dy;
else
kx -= dx;
}
o(kx, ky);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <class T>
void in(vector<T> &a) {
for (auto &i : a) cin >> i;
}
template <class T>
void out(vector<T> &a) {
for (auto &i : a) cout << i << ' ';
}
bool L[1000][1000];
pair<int, int> I[1000];
bool check() {
int i, x, y;
cin >> i >> x >> y;
if (i == -1) exit(0);
L[I[i].first][I[i].second] = 0;
I[i] = {x, y};
L[x][y] = 1;
}
bool pos(int x, int y) { return x >= 1 && x <= 999 && y >= 1 && y <= 999; }
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
srand(time(NULL));
cout.setf(ios::fixed), cout.precision(20);
int x, y;
cin >> x >> y;
for (int i = 1; i <= 666; ++i) {
int a, b;
cin >> a >> b;
I[i] = {a, b};
L[a][b] = 1;
}
int dx, dy;
if (x >= 500)
dx = 1;
else
dx = -1;
if (y >= 500)
dy = 1;
else
dy = -1;
while (pos(x + dx, y)) {
cout << (x + dx) << ' ' << y << endl;
x += dx;
check();
}
while (pos(x, y + dy)) {
cout << x << ' ' << (y + dy) << endl;
y += dy;
check();
}
dx *= -1, dy *= -1;
while (pos(x + dx, y + dy) && !L[x + dx][y + dy]) {
x += dx;
y += dy;
cout << x << ' ' << y << endl;
check();
}
if (L[x + dx][y + dy]) {
if (pos(x + dx, y)) {
x += dx;
cout << x << ' ' << y << endl;
check();
} else {
y += dy;
cout << x << ' ' << y << endl;
check();
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int x, y;
map<int, pair<int, int>> field;
void Print() {
cout << x << ' ' << y << endl;
cout.flush();
}
int detectQ(int x, int y) {
if (x < 500 && y < 500)
return 1;
else if (x < 500 && y > 500)
return 2;
else if (x > 500 && y < 500)
return 4;
else if (x > 500 && y > 500)
return 3;
else
return 5;
}
int MoveTo(int destX, int destY) {
while (x != destX) {
if (x < destX)
++x;
else
--x;
Print();
int a, b, c;
cin >> a >> b >> c;
if (a == 0 || a == -1) return 2;
field[a] = make_pair(b, c);
}
while (y != destY) {
if (y < destY)
++y;
else
--y;
Print();
int a, b, c;
cin >> a >> b >> c;
if (a == 0 || a == -1) return 2;
field[a] = make_pair(b, c);
}
return 3;
}
int MoveTo2(int destX, int destY) {
while (x != destX && y != destY) {
int f = x, g = y;
if (x < destX)
++x;
else if (x > destX)
--x;
if (y < destY)
++y;
else if (y > destY)
--y;
for (int i = 1; i <= 666; i++) {
if (field[i].second == y) {
x = f;
break;
}
}
Print();
int a, b, c;
cin >> a >> b >> c;
if (a == 0 || a == -1) return 2;
field[a] = make_pair(b, c);
}
return 3;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(20);
cin >> x >> y;
for (int i = 1; i < 667; i++) {
int b, c;
cin >> b >> c;
field[i] = make_pair(b, c);
}
int k = MoveTo(500, 500);
if (k == 2 || k == 1) return 0;
vector<int> q(4);
for (int i = 1; i <= 666; i++) {
if (detectQ(field[i].first, field[i].second) == 5) {
cout << -1 << ' ' << -1;
return 0;
}
++q[detectQ(field[i].first, field[i].second) - 1];
}
if (q[0] < 167)
k = MoveTo2(999, 999);
else if (q[1] < 167)
k = MoveTo2(999, 1);
else if (q[2] < 167)
k = MoveTo2(1, 1);
else
k = MoveTo2(1, 999);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(228);
const int N = 666;
const int M = 500;
const int MX = 999;
set<pair<int, int> > ms;
pair<int, int> a[N + 1];
int get(int x1, int y1, int x2, int y2) {
int ans = 0;
for (int i = 1; i <= N; ++i) {
ans += x1 <= a[i].first && a[i].first <= x2 && y1 <= a[i].second &&
a[i].second <= y2;
}
return ans;
}
bool clear(int x, int y) {
for (int i = 1; i <= N; ++i) {
if (a[i].first == x && a[i].second == y) {
return 0;
}
}
return 1;
}
bool check(int x, int y) { return 1 <= x && x <= MX && 1 <= y && y <= MX; }
int cnt = 0;
void go(int x, int y) {
++cnt;
cout << x << ' ' << y << '\n';
fflush(stdout);
int i;
cin >> i;
if (i <= 0) exit(0);
cin >> a[i].first >> a[i].second;
}
int min(int a, int b, int c, int d) { return min(min(a, b), min(c, d)); }
int x, y;
void init() {
x = rnd() % MX + 1;
y = rnd() % MX + 1;
set<pair<int, int> > ms;
for (int i = 1; i <= N; ++i) {
while (1) {
int x = rnd() % MX + 1;
int y = rnd() % MX + 1;
if (ms.find({x, y}) == ms.end()) {
ms.insert({x, y});
a[i] = {x, y};
break;
}
}
}
}
signed main() {
cin >> x >> y;
for (int i = 1; i <= N; ++i) cin >> a[i].first >> a[i].second;
while (x < M) {
go(x + 1, y);
++x;
}
while (x > M) {
go(x - 1, y);
--x;
}
while (y < M) {
go(x, y + 1);
++y;
}
while (y > M) {
go(x, y - 1);
--y;
}
int mn = min(get(1, 1, M - 1, M - 1), get(1, M + 1, M - 1, MX),
get(M + 1, 1, MX, M - 1), get(M + 1, M + 1, MX, MX));
int dx, dy;
if (get(1, 1, M - 1, M - 1) == mn) {
dx = -1;
dy = -1;
} else if (get(1, M + 1, M - 1, MX) == mn) {
dx = -1;
dy = 1;
} else if (get(M + 1, 1, MX, M - 1) == mn) {
dx = 1;
dy = -1;
} else {
dx = 1;
dy = 1;
}
dx *= -1;
dy *= -1;
while (check(x + dx, y + dy)) {
if (clear(x + dx, y + dy)) {
go(x + dx, y + dy);
x += dx;
y += dy;
} else {
go(x + dx, y);
x += dx;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1024;
bool vis[N][N];
struct Chess {
int x, y;
} rook[N], king;
int cnt[8];
int dir[8][2] = {{-1, -1}, {-1, 1}, {1, 1}, {1, -1},
{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
int Way(Chess s) {
if (s.x == 500 && s.y == 500) return -1;
if (s.x == 500) return s.y > 500 ? 5 : 7;
if (s.y == 500) return s.x > 500 ? 6 : 4;
if (s.x < 500) return s.y > 500 ? 1 : 0;
return s.y > 500 ? 2 : 3;
}
int Inv(int x) {
switch (x) {
case 0:
return 2;
case 1:
return 3;
case 2:
return 0;
case 3:
return 1;
case 4:
return 6;
case 5:
return 7;
case 6:
return 4;
case 7:
return 5;
}
}
void Go(int w) {
king.x += dir[w][0];
king.y += dir[w][1];
if (vis[king.x][king.y]) king.x -= dir[w][0];
printf("%d %d\n", king.x, king.y);
fflush(stdout);
int k;
scanf("%d", &k);
if (k <= 0) exit(0);
vis[rook[k].x][rook[k].y] = false;
scanf("%d %d", &rook[k].x, &rook[k].y);
vis[rook[k].x][rook[k].y] = true;
}
int main() {
scanf("%d %d", &king.x, &king.y);
for (int i = 1; i <= 666; i++) {
scanf("%d %d", &rook[i].x, &rook[i].y);
vis[rook[i].x][rook[i].y] = true;
}
while (true) {
int w = Way(king);
if (w == -1) break;
Go(Inv(w));
}
for (int i = 1; i <= 666; i++) cnt[Way(rook[i])]++;
int w = 0;
for (int i = 1; i < 4; i++)
if (cnt[i] < cnt[w]) w = i;
w = Inv(w);
while (true) Go(w);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int getmove(long long int dest, long long int cur) {
if (cur > dest) return -1;
if (cur < dest) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int king_x, king_y;
cin >> king_x >> king_y;
pair<long long int, long long int> rooks[666];
long long int move_x, move_y;
long long int board[1000][1000] = {{0}};
long long int x, y, k;
for (long long int i = 0; i < 666; i++) {
cin >> x >> y;
rooks[i] = make_pair(x, y);
board[x][y] = 1;
}
while (king_x != 500 || king_y != 500) {
move_x = getmove(500, king_x);
move_y = getmove(500, king_y);
if (board[king_x + move_x][king_y + move_y] == 0) {
king_x += move_x;
king_y += move_y;
} else {
king_x += move_x;
}
cout << king_x << " " << king_y << endl;
cin >> k >> x >> y;
if (k <= 0) {
return 0;
}
k--;
board[rooks[k].first][rooks[k].second] = 0;
rooks[k] = make_pair(x, y);
board[rooks[k].first][rooks[k].second] = 1;
}
pair<long long int, long long int> possi[] = {
make_pair(1, 1), make_pair(1, 999), make_pair(999, 1),
make_pair(999, 999)};
long long int dest_x, dest_y;
long long int cur = -1;
long long int counter[4] = {666, 666, 666, 666};
for (long long int i = 0; i < 666; i++) {
if (rooks[i].first > 500 && rooks[i].second > 500)
counter[0]--;
else if (rooks[i].first > 500 && rooks[i].second < 500)
counter[1]--;
else if (rooks[i].first < 500 && rooks[i].second > 500)
counter[2]--;
else
counter[3]--;
}
for (long long int i = 0; i < 4; i++) {
if (counter[i] > cur) {
cur = counter[i];
dest_x = possi[i].first;
dest_y = possi[i].second;
}
}
while (king_x != dest_x || king_y != dest_y) {
move_x = getmove(dest_x, king_x);
move_y = getmove(dest_y, king_y);
if (board[king_x + move_x][king_y + move_y] == 0) {
king_x += move_x;
king_y += move_y;
} else {
king_x += move_x;
}
cout << king_x << " " << king_y << endl;
cin >> k >> x >> y;
if (k <= 0) {
return 0;
}
k--;
board[rooks[k].first][rooks[k].second] = 0;
rooks[k] = make_pair(x, y);
board[rooks[k].first][rooks[k].second] = 1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long q = 1e9 + 7;
long long power(long long a, long long e) {
long long ans = 1LL;
while (e) {
if (e & 1) ans = (ans * a) % q;
a = a * a % q;
e >>= 1;
}
return ans % q;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const double eps = 1e-8;
const long long maxn = 1e6;
int maze[1005][1005];
int mx[1005];
int my[1005];
struct cnt {
int num, w;
friend bool operator<(cnt a, cnt b);
} C[5];
bool operator<(cnt a, cnt b) { return a.num < b.num; }
int main() {
int cc = 10000;
cout.tie(0);
memset(C, 0, sizeof(C));
memset(maze, 0, sizeof(maze));
int x, y;
int ttx, tty;
cin >> ttx >> tty;
for (int i = 1; i <= 666; i++) {
cin >> x >> y;
maze[x][y] = 1;
mx[i] = x;
my[i] = y;
}
int xx, yy;
int th, tx, ty;
xx = 500, yy = 500;
while (ttx != xx || tty != yy) {
if (tty < yy)
tty++;
else if (tty > yy) {
tty--;
}
if (ttx < xx && maze[ttx + 1][tty] == 0)
ttx++;
else {
if (ttx > xx && maze[ttx - 1][tty] == 0) ttx--;
}
cout << ttx << " " << tty << endl;
cc--;
if (cc == 0) exit(0);
cin >> th >> tx >> ty;
if (th <= 0) {
exit(0);
}
if (tx <= 0 || ty <= 0) exit(0);
if (tx >= 1000 || ty >= 1000) exit(0);
maze[mx[th]][my[th]] = 0;
maze[tx][ty] = 1;
mx[th] = tx;
my[th] = ty;
}
int m = 500;
for (int i = (int)(0); i < (int)(3); ++i) C[i].w = i;
for (int i = (int)(1); i < (int)(1000); ++i)
for (int j = (int)(1); j < (int)(1000); ++j) {
if (maze[i][j] == 1) {
if (i < m && j < m)
C[1].num++;
else if (i < m && j >= m)
C[2].num++;
else if (j < m && i >= m)
C[3].num++;
else
C[4].num++;
}
}
int cn = min(C[1].num, min(C[2].num, min(C[3].num, C[4].num)));
if (cn == C[1].num) {
xx = yy = 999;
}
if (cn == C[2].num) {
xx = 999;
yy = 1;
}
if (cn == C[3].num) {
xx = 1;
yy = 999;
}
if (cn == C[4].num) {
xx = yy = 1;
}
while (ttx != xx || tty != yy) {
if (tty < yy)
tty++;
else if (tty > yy) {
tty--;
}
if (ttx < xx && maze[ttx + 1][tty] == 0)
ttx++;
else {
if (ttx > xx && maze[ttx - 1][tty] == 0) ttx--;
}
cout << ttx << " " << tty << endl;
scanf("%d %d %d", &th, &tx, &ty);
if (th <= 0) {
exit(0);
}
if (tx <= 0 || ty <= 0) exit(0);
if (tx >= 1000 || ty >= 1000) exit(0);
maze[mx[th]][my[th]] = 0;
maze[tx][ty] = 1;
mx[th] = tx;
my[th] = ty;
}
xx = 1000 - xx;
yy = 1000 - yy;
while (ttx != xx || tty != yy) {
if (tty < yy)
tty++;
else if (tty > yy)
tty--;
if (ttx < xx && maze[ttx + 1][tty] == 0)
ttx++;
else if (ttx > xx && maze[ttx - 1][tty] == 0)
ttx--;
cout << ttx << " " << tty << endl;
cc--;
if (cc == 0) exit(0);
cin >> th >> tx >> ty;
if (tx <= 0 || ty <= 0) exit(0);
if (th <= -1) {
exit(0);
}
if (th <= 0) {
exit(0);
}
maze[mx[th]][my[th]] = 0;
maze[tx][ty] = 1;
mx[th] = tx;
my[th] = ty;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[10];
int dx[5] = {0, -1, 1, 1, -1};
int dy[5] = {0, -1, -1, 1, 1};
int dir;
int x[2000], y[2000];
int k, a, b;
bool done;
bool vis[2000][2000];
void scan() {
scanf("%d %d %d", &k, &a, &b);
if (k == -1 || k == 0) {
exit(0);
} else {
vis[x[k]][y[k]] = 0;
x[k] = a;
y[k] = b;
vis[x[k]][y[k]] = 1;
}
}
void check() {
done = 1;
for (int i = 1; i <= 666; i++) {
if (x[i] > x[0] && y[i] > y[0]) num[1]++;
if (x[i] < x[0] && y[i] > y[0]) num[2]++;
if (x[i] < x[0] && y[i] < y[0]) num[3]++;
if (x[i] > x[0] && y[i] < y[0]) num[4]++;
}
num[0] = 1000;
for (int i = 1; i <= 4; i++) {
if (num[i] < num[0]) {
num[0] = num[i];
dir = i;
}
}
}
void move() {
if (done) {
if (vis[x[0] + dx[dir]][y[0] + dy[dir]])
x[0] += dx[dir];
else
x[0] += dx[dir], y[0] += dy[dir];
printf("%d %d\n", x[0], y[0]);
fflush(stdout);
scan();
} else {
if (x[0] < 500) {
if (y[0] < 500) {
if (vis[x[0] + 1][y[0] + 1] == 1)
x[0] = x[0] + 1, y[0] = y[0];
else
x[0] = x[0] + 1, y[0] = y[0] + 1;
} else if (y[0] > 500) {
if (vis[x[0] + 1][y[0] - 1] == 1)
x[0] = x[0] + 1, y[0] = y[0];
else
x[0] = x[0] + 1, y[0] = y[0] - 1;
} else
x[0] = x[0] + 1, y[0] = y[0];
} else if (x[0] > 500) {
if (y[0] < 500) {
if (vis[x[0] - 1][y[0] + 1] == 1)
x[0] = x[0] - 1, y[0] = y[0];
else
x[0] = x[0] - 1, y[0] = y[0] + 1;
} else if (y[0] > 500) {
if (vis[x[0] - 1][y[0] - 1] == 1)
x[0] = x[0] - 1, y[0] = y[0];
else
x[0] = x[0] - 1, y[0] = y[0] - 1;
} else
x[0] = x[0] - 1, y[0] = y[0];
} else {
if (y[0] < 500)
x[0] = x[0], y[0] = y[0] + 1;
else if (y[0] > 500)
x[0] = x[0], y[0] = y[0] - 1;
else
x[0] = x[0], y[0] = y[0];
}
printf("%d %d\n", x[0], y[0]);
fflush(stdout);
scan();
if (x[0] == 500 && y[0] == 500) {
check();
}
}
}
int main() {
scanf("%d%d", &x[0], &y[0]);
for (int i = 1; i <= 666; i++) {
scanf("%d%d", &x[i], &y[i]);
vis[x[i]][y[i]] = 1;
}
if (x[0] == 500 && y[0] == 500) {
check();
}
while (1) {
move();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int x, y;
int a[maxn];
int b[maxn];
int mp[maxn][maxn];
const int mv[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1},
{0, 1}, {1, -1}, {1, 0}, {1, 1}};
void move(int tx, int ty) {
int vx = tx == x ? 0 : (tx - x) / abs(tx - x);
int vy = ty == y ? 0 : (ty - y) / abs(ty - y);
if (vx == 0 && vy == 0) {
vx = 1, vy = 1;
}
if (vx + x < 1) vx = -vx;
if (vx + x > 999) vx = -vx;
if (vy + y < 1) vy = -vy;
if (vy + y > 999) vy = -vy;
if (mp[vx + x][vy + y]) {
for (int i = 0; i < 8; i++) {
int sx = mv[i][0];
int sy = mv[i][1];
if (mp[x + sx][y + sy] == 0) {
cout << x + sx << " " << y + sy << endl;
x += sx;
y += sy;
break;
}
}
} else {
cout << vx + x << " " << vy + y << endl;
x += vx;
y += vy;
}
}
bool judgemin(int a, int b, int c, int d) {
if (a <= b && a <= c && a <= d) {
return true;
}
return false;
}
void judge(int &tx, int &ty) {
int l1 = 0, l2 = 0, l3 = 0, l4 = 0;
for (int i = 1; i <= 999; i++) {
for (int j = 1; j <= 999; j++) {
if (mp[i][j]) {
if (i <= 500) {
if (j <= 500) ++l1;
if (j >= 500) {
++l2;
}
}
if (i >= 500) {
if (j <= 500) {
++l3;
}
if (j >= 500) {
++l4;
}
}
}
}
}
if (judgemin(l1, l2, l3, l4)) {
tx = 999, ty = 999;
} else if (judgemin(l2, l1, l3, l4)) {
tx = 999, ty = 1;
} else if (judgemin(l3, l1, l2, l4)) {
tx = 1, ty = 999;
} else {
tx = 1, ty = 1;
}
}
void solve() {
int k, xx, yy, tx = 500, ty = 500;
bool flag = false;
if (x == 500 && y == 500)
move(1, 1);
else
move(500, 500);
while (cin >> k >> xx >> yy) {
if (k == -1 && xx == -1 && yy == -1) {
break;
}
if (k == 0 && xx == 0 && yy == 0) {
break;
}
mp[a[k]][b[k]] = 0;
a[k] = xx, b[k] = yy;
mp[a[k]][b[k]] = 1;
if (x == 500 && y == 500) {
flag = true;
judge(tx, ty);
}
if (!flag) {
move(500, 500);
if (x == 500 && y == 500) {
flag = true;
judge(tx, ty);
}
} else {
move(tx, ty);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
memset(mp, 0, sizeof(mp));
cin >> x >> y;
for (int i = 1; i <= 666; i++) {
cin >> a[i] >> b[i];
mp[a[i]][b[i]] = 1;
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[1000], y[1000], cnt[4];
int a[1000][1000];
int px, py, id, xx, yy;
void tomove(int edx, int edy) {
int recx, recy, flag;
while (px != edx || py != edy) {
if (px > edx)
recx = px - 1;
else if (px == edx)
recx = px;
else
recx = px + 1;
if (py > edy)
recy = py - 1;
else if (py == edy)
recy = py;
else
recy = py + 1;
if (px != recx && py != recy && a[recx][recy]) recx = px;
printf("%d %d\n", recx, recy);
fflush(stdout);
scanf("%d %d %d", &id, &xx, &yy);
if (id == -1 || id == 0) exit(0);
a[x[id]][y[id]] = 0;
a[xx][yy] = 1;
x[id] = xx;
y[id] = yy;
px = recx;
py = recy;
}
}
int main() {
scanf("%d %d", &px, &py);
memset(a, 0, sizeof(a));
for (int i = 1; i <= 666; i++) {
scanf("%d %d", &x[i], &y[i]);
a[x[i]][y[i]] = 1;
}
tomove(500, 500);
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= 666; i++) {
if (x[i] < 500 && y[i] < 500)
cnt[0]++;
else if (x[i] < 500)
cnt[1]++;
else if (y[i] < 500)
cnt[2]++;
else
cnt[3]++;
}
if (cnt[0] <= 166) tomove(999, 999);
if (cnt[1] <= 166) tomove(999, 1);
if (cnt[2] <= 166) tomove(1, 999);
if (cnt[3] <= 166) tomove(1, 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int X, Y, x[777], y[777], a, b, c, cnt1, cnt2, cnt3, cnt4, mn;
bool used[1111][1111];
int go(int tx, int ty) {
if (used[tx][ty]) {
printf("%d %d\n", tx, Y);
fflush(stdout);
exit(0);
}
printf("%d %d\n", tx, ty);
fflush(stdout);
X = tx;
Y = ty;
scanf("%d %d %d", &a, &b, &c);
if (!~a) exit(0);
used[x[a]][y[a]] = 0;
used[b][c] = 1;
x[a] = b;
y[a] = c;
}
int main() {
scanf("%d%d", &X, &Y);
for (int i = 1; i <= 666; i++) {
scanf("%d%d", &x[i], &y[i]);
used[x[i]][y[i]] = 1;
}
while (X < 500) {
if (Y > 500)
go(X + 1, Y - 1);
else if (Y < 500)
go(X + 1, Y + 1);
else
go(X + 1, Y);
}
while (X > 500) {
if (Y > 500)
go(X - 1, Y - 1);
else if (Y < 500)
go(X - 1, Y + 1);
else
go(X - 1, Y);
}
while (Y < 500) {
go(X, Y + 1);
}
while (Y > 500) {
go(X, Y - 1);
}
assert(X == 500 && Y == 500);
for (int i = 1; i <= 500; i++) {
for (int j = 1; j <= 500; j++) {
if (used[i][j]) cnt1++;
}
}
for (int i = 500; i <= 999; i++) {
for (int j = 1; j <= 500; j++) {
if (used[i][j]) cnt2++;
}
}
for (int i = 1; i <= 500; i++) {
for (int j = 500; j <= 999; j++) {
if (used[i][j]) cnt3++;
}
}
for (int i = 500; i <= 999; i++) {
for (int j = 500; j <= 999; j++) {
if (used[i][j]) cnt4++;
}
}
mn = min(cnt1, min(cnt2, min(cnt3, cnt4)));
if (mn == cnt1) {
while (X < 999) {
go(X + 1, Y + 1);
}
} else if (mn == cnt2) {
while (Y < 999) {
go(X - 1, Y + 1);
}
} else if (mn == cnt3) {
while (X < 999) {
go(X + 1, Y - 1);
}
} else {
while (X > 1) {
go(X - 1, Y - 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int x, y;
};
data a[700];
int n, x, y, k = 666, mid = 500;
int main() {
cin >> x >> y;
for (int i = 1; i <= k; i++) cin >> a[i].x >> a[i].y;
int x1, y1;
while (true) {
int t1, t2, t3;
x1 = x;
y1 = y;
if (x < mid)
x1 = x + 1;
else if (x > mid)
x1 = x - 1;
if (y < mid)
y1 = y + 1;
else if (y > mid)
y1 = y - 1;
for (int i = 1; i <= k; i++)
if ((a[i].x == x1) && (a[i].y == y1)) {
x1 = x;
cout << x1 << ' ' << y1 << endl;
cout.flush();
cin >> t1 >> t2 >> t3;
return 0;
}
if ((x1 == x) && (y1 == y)) break;
cout << x1 << ' ' << y1 << endl;
cout.flush();
cin >> t1 >> t2 >> t3;
if ((t1 == -1) || (t1 == 0)) return 0;
x = x1;
y = y1;
a[t1].x = t2;
a[t1].y = t3;
}
int q1 = 0, q2 = 0, q3 = 0, q4 = 0;
for (int i = 1; i <= k; i++) {
if ((a[i].x > mid) && (a[i].y > mid)) q4++;
if ((a[i].x > mid) && (a[i].y < mid)) q2++;
if ((a[i].x < mid) && (a[i].y > mid)) q3++;
if ((a[i].x < mid) && (a[i].y < mid)) q1++;
}
int dx = -1, dy = -1;
if ((q1 <= q2) && (q1 <= q3) && (q1 <= q4)) {
dx = 1;
dy = 1;
}
if ((q2 <= q1) && (q2 <= q3) && (q2 <= q4)) {
dx = -1;
dy = 1;
}
if ((q3 <= q1) && (q3 <= q2) && (q3 <= q4)) {
dx = 1;
dy = -1;
}
while (true) {
int t1, t2, t3;
int x1 = x + dx, y1 = y + dy;
for (int i = 1; i <= k; i++) {
if ((a[i].x == x1) && (a[i].y == y1)) {
x1 = x;
cout << x1 << ' ' << y1 << endl;
cout.flush();
cin >> t1 >> t2 >> t3;
return 0;
}
}
cout << x1 << ' ' << y1 << endl;
cout.flush();
cin >> t1 >> t2 >> t3;
if (t1 == -1) return 0;
if (t1 == 0) return 0;
a[t1].x = t2;
a[t1].y = t3;
x = x1;
y = y1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double tick() {
static clock_t oldtick;
clock_t newtick = clock();
double diff = 1.0 * (newtick - oldtick) / CLOCKS_PER_SEC;
oldtick = newtick;
return diff;
}
long long gcd(long long a, long long b) {
if ((a == 0) || (b == 0)) {
return a + b;
}
return gcd(b, a % b);
}
long long powMod(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return (res % 1000000007);
}
long long pow2(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a);
a = (a * a);
b >>= 1;
}
return res;
}
bool isPrime(long long a) {
for (long long i = 3; (i * i) <= a; i += 2) {
if ((a % i) == 0) return false;
}
if ((a != 2) && ((a % 2) == 0)) {
return false;
}
if (a == 1) {
return false;
}
return true;
}
string conLlToStr(long long a) {
stringstream mystr;
mystr << a;
return mystr.str();
}
long long conStrToLl(string st) {
long long numb = 0;
long long len = st.size(), i, j = 0;
for (long long i = len - 1; i >= 0; i--) {
numb += (pow2(10, j) * (st[i] - '0'));
j++;
}
return numb;
}
long long basenoToDecimal(string st, long long basee) {
long long i = 0, j, anss = 0;
for (long long j = (int)st.length() - 1; j >= 0; j--) {
anss += (st[j] - '0') * pow2(basee, i);
i++;
}
return anss;
}
string decimalToString(long long num, long long basee) {
long long i = 0, j, opop;
string anss = "";
vector<string> stri;
stri.push_back("0");
stri.push_back("1");
stri.push_back("2");
stri.push_back("3");
stri.push_back("4");
stri.push_back("5");
stri.push_back("6");
stri.push_back("7");
stri.push_back("8");
stri.push_back("9");
stri.push_back("A");
stri.push_back("B");
stri.push_back("C");
stri.push_back("D");
stri.push_back("E");
stri.push_back("F");
if (num == 0) {
return "0";
}
while (num) {
opop = (num % basee);
anss += stri[opop];
num /= basee;
}
reverse(anss.begin(), anss.end());
return anss;
}
long long my_sqrt(long long x) {
long long y = (long long)(sqrtl((long double)x) + 0.5);
while (y * y < x) {
y++;
}
while (y * y > x) {
y--;
}
if (y * y == x) {
return y;
}
return -1;
}
long long my_crt(long long x) {
long long y = (long long)(powl((long double)x, 1.0 / 3.0) + 0.5);
while (y * y * y < x) {
y++;
}
while (y * y * y > x) {
y--;
}
if (y * y * y == x) {
return y;
}
return -1;
}
const int dx[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int dy[] = {1, 1, 0, -1, -1, -1, 0, 1};
long long rookx[1010], rooky[1010], row[1010], col[1010], K, X, Y;
set<pair<long long, long long> > rookspos;
bool flag;
void check(long long i, long long Y) {
cout << i << " " << Y << "\n";
fflush(stdout);
if (row[i] || col[Y]) {
flag = 1;
return;
}
cin >> K >> X >> Y;
fflush(stdout);
rookspos.erase(make_pair(rookx[K], rooky[K]));
rookspos.insert(make_pair(X, Y));
row[rookx[K]]--;
col[rooky[K]]--;
row[X]++;
col[Y]++;
rookx[K] = X;
rooky[K] = Y;
}
long long countofrooks(long long ind1, long long ind2, long long ind3,
long long ind4) {
long long coun = 0;
for (long long i = ind1; i <= ind3; i++) {
for (long long j = ind2; j <= ind4; j++) {
if (rookspos.find(make_pair(i, j)) != rookspos.end()) {
coun++;
}
}
}
return coun;
}
pair<long long, long long> oppoofleast() {
long long topl = countofrooks(1, 1, 500, 500);
long long topr = countofrooks(1, 500, 500, 999);
long long bell = countofrooks(500, 1, 999, 500);
long long belr = countofrooks(500, 500, 999, 999);
vector<pair<long long, pair<long long, long long> > > sorted;
sorted.push_back(make_pair(topl, make_pair(1, 1)));
sorted.push_back(make_pair(topr, make_pair(1, -1)));
sorted.push_back(make_pair(bell, make_pair(-1, 1)));
sorted.push_back(make_pair(belr, make_pair(-1, -1)));
sort(sorted.begin(), sorted.end());
return sorted[0].second;
}
bool isValid(pair<long long, long long> pos) {
if (pos.first > 0 && pos.first < 1000 && pos.second > 0 &&
pos.second < 1000) {
return 1;
}
return 0;
}
int main() {
cin >> X >> Y;
for (long long i = 1; i <= 666; i++) {
cin >> rookx[i] >> rooky[i];
row[rookx[i]]++;
col[rooky[i]]++;
rookspos.insert(make_pair(rookx[i], rooky[i]));
}
if (X < 500) {
for (long long i = X + 1; i <= 500; i++) {
check(i, Y);
if (flag) {
return 0;
}
}
} else {
for (long long i = X - 1; i >= 500; i--) {
check(i, Y);
if (flag) {
return 0;
}
}
}
if (Y < 500) {
for (long long i = Y + 1; i <= 500; i++) {
check(500, i);
if (flag) {
return 0;
}
}
} else {
for (long long i = Y - 1; i >= 500; i--) {
check(500, i);
if (flag) {
return 0;
}
}
}
pair<long long, long long> whichmove = oppoofleast();
pair<long long, long long> pos = make_pair(500, 500);
for (long long i = 1; i <= 500; i++) {
pair<long long, long long> temppos = pos;
pos.first += whichmove.first;
pos.second += whichmove.second;
if (!isValid(pos) ||
rookspos.find(make_pair(pos.first, pos.second)) != rookspos.end()) {
pos = make_pair(temppos.first, temppos.second + whichmove.second);
}
if (!isValid(pos) ||
rookspos.find(make_pair(pos.first, pos.second)) != rookspos.end()) {
pos = make_pair(temppos.first + whichmove.first, temppos.second);
}
check(pos.first, pos.second);
if (flag) {
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x, y, c[1005][1005], u, v, w, dx, dy, dp[1010][1010], fuck;
struct rook {
int L, R;
} r[700];
void query(int a, int b) {
printf("%d %d\n", a, b);
fflush(stdout);
x = a, y = b;
return;
}
void change() {
scanf("%d%d%d", &u, &v, &w);
if (u <= 0) exit(0);
c[r[u].L][r[u].R] = 0;
r[u].L = v, r[u].R = w;
c[v][w] = 1;
return;
}
void movee() {
if (x < 500) {
query(x + 1, y);
return;
} else if (x > 500) {
query(x - 1, y);
fflush(stdout);
return;
} else if (y < 500) {
query(x, y + 1);
fflush(stdout);
return;
} else if (y > 500) {
query(x, y - 1);
fflush(stdout);
return;
}
}
void fast() {
if (c[x + dx][y + dy]) {
query(x + dx, y);
} else {
query(x + dx, y + dy);
}
change();
return;
}
int main() {
scanf("%d%d", &x, &y);
int reg = 0;
for (int i = 1; i <= 666; i++) {
scanf("%d%d", &r[i].L, &r[i].R);
c[r[i].L][r[i].R] = 1;
}
while (!(x == 500 && y == 500)) {
movee();
change();
}
int d[5];
int mi = 16151621;
memset(d, 0, sizeof(d));
for (int i = 1; i <= 999; i++)
for (int j = 1; j <= 999; j++) {
if (c[i][j]) {
if (i < 500 && j < 500) d[1]++;
if (i > 500 && j < 500) d[2]++;
if (i < 500 && j > 500) d[3]++;
if (i > 500 && j > 500) d[4]++;
}
}
for (int i = 1; i <= 4; i++) {
if (d[i] < mi) {
mi = d[i];
reg = i;
}
}
if (reg == 1)
dx = 1, dy = 1;
else if (reg == 2)
dx = -1, dy = 1;
else if (reg == 3)
dx = 1, dy = -1;
else
dx = -1, dy = -1;
int ct = 0;
while (true) {
fast();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010, K = 666;
bool vis[1005][1005];
int cnt[5];
struct P {
int x, y;
} s, t[K + 5];
void move(int dx, int dy) {
s.x += dx;
s.y += dy;
if (vis[s.x][s.y]) s.x -= dx;
printf("%d %d\n", s.x, s.y);
fflush(stdout);
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if (a <= 0) exit(0);
vis[t[a].x][t[a].y] = false;
t[a].x = b;
t[a].y = c;
vis[t[a].x][t[a].y] = true;
}
int main() {
scanf("%d%d", &s.x, &s.y);
for (int i = (1); i <= (K); i++)
scanf("%d%d", &t[i].x, &t[i].y), vis[t[i].x][t[i].y] = true;
while (s.x > 500) move(-1, 0);
while (s.x < 500) move(1, 0);
while (s.y > 500) move(0, -1);
while (s.y < 500) move(0, 1);
for (int i = (1); i <= (K); i++) cnt[(t[i].x < 500) * 2 + (t[i].y < 500)]++;
int mini = 0x3f3f3f3f, pnt;
for (int i = (0); i <= (3); i++)
if (mini > cnt[i]) mini = cnt[i], pnt = i;
while (1) move(pnt / 2 ? 1 : -1, pnt % 2 ? 1 : -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static inline void canhazfast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a / b;
a %= b;
swap(a, b);
x0 -= q * x1;
swap(x0, x1);
y0 -= q * y1;
swap(y0, y1);
}
x = x0;
y = y0;
return a;
}
int ctz(unsigned x) { return __builtin_ctz(x); }
int ctzll(unsigned long long x) { return __builtin_ctzll(x); }
int clz(unsigned x) { return __builtin_clz(x); }
int clzll(unsigned long long x) { return __builtin_clzll(x); }
int popcnt(unsigned x) { return __builtin_popcount(x); }
int popcntll(unsigned long long x) { return __builtin_popcountll(x); }
int bsr(unsigned x) { return 31 ^ clz(x); }
int bsrll(unsigned long long x) { return 63 ^ clzll(x); }
const int n = 999;
const int m = 666;
bool used[1024][1024];
int x[1024], y[1024];
void go() {
int k, xt, yt;
cout << x[0] << ' ' << y[0] << endl;
cin >> k >> xt >> yt;
if (k <= 0 || xt <= 0 || yt <= 0) exit(0);
used[x[k]][y[k]] = false;
x[k] = xt;
y[k] = yt;
used[xt][yt] = true;
}
int main() {
canhazfast();
const int mid = (n + 1) / 2;
int dx, dy, dir;
int cnt[4] = {};
for (int i = 0; i <= m; ++i) {
cin >> x[i] >> y[i];
if (i) used[x[i]][y[i]] = true;
}
while (x[0] != mid || y[0] != mid) {
dx = (x[0] > mid) ? -1 : (x[0] < mid);
dy = (y[0] > mid) ? -1 : (y[0] < mid);
x[0] += dx;
y[0] += dy;
if (used[x[0]][y[0]]) x[0] -= dx;
go();
}
for (int i = 1; i <= m; ++i) {
++cnt[2 * (x[i] > mid) + 1 * (y[i] > mid)];
}
dir = min_element(cnt, cnt + 4) - cnt;
dx = dir & 2 ? -1 : 1;
dy = dir & 1 ? -1 : 1;
for (;;) {
x[0] += dx;
y[0] += dy;
if (used[x[0]][y[0]]) x[0] -= dx;
go();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, a, b, N = 1000, dx, dy, a1, b1, k1 = 0, mx = 0, k2 = 0, k3 = 0,
k4 = 0, fx, fy;
bool rook[N][N];
memset(rook, false, sizeof(rook));
cin >> a >> b;
int x[N], y[N];
for (i = 1; i <= 666; i++) {
cin >> x[i] >> y[i];
rook[x[i]][y[i]] = true;
}
while (1) {
if (a == 500 && b == 500) break;
dx = 0, dy = 0;
if (500 - a > 0) dx = 1;
if (a - 500 > 0) dx = -1;
if (500 - b > 0) dy = 1;
if (b - 500 > 0) dy = -1;
a1 = a + dx, b1 = b + dy;
if (rook[a1][b1]) {
cout << a1 << " " << b << endl;
cout.flush();
cin >> k >> i >> j;
return 0;
}
cout << a1 << " " << b1 << endl;
cout.flush();
cin >> k >> i >> j;
if (k <= 0) return 0;
rook[i][j] = true;
rook[x[k]][y[k]] = false;
x[k] = i, y[k] = j;
a = a1, b = b1;
}
for (i = 1; i <= 666; i++) {
if (x[i] <= 500 && y[i] <= 500) {
k1++, k2++, k3++;
}
if (x[i] >= 500 && y[i] <= 500) {
k1++;
k2++;
k4++;
}
if (y[i] >= 500 && x[i] <= 500) {
k1++;
k3++;
k4++;
}
if (x[i] >= 500 && y[i] >= 500) {
k2++;
k3++;
k4++;
}
}
mx = max(k1, k2);
mx = max(mx, k3);
mx = max(mx, k4);
if (k1 == mx) fx = 1, fy = 1;
if (k2 == mx) fx = 999, fy = 1;
if (k3 == mx) fx = 1, fy = 999;
if (k4 == mx) fx = 999, fy = 999;
dx = -1;
if (fx > a) dx = 1;
dy = -1;
if (fy > b) dy = 1;
while (1) {
a1 = a + dx;
b1 = b + dy;
if (rook[a1][b1]) {
cout << a1 << " " << b << endl;
cout.flush();
cin >> k >> i >> j;
return 0;
}
cout << a1 << " " << b1 << endl;
cout.flush();
cin >> k >> i >> j;
if (k <= 0) return 0;
rook[i][j] = true;
rook[x[k]][y[k]] = false;
x[k] = i;
y[k] = j;
a = a1, b = b1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[1000][1000];
vector<pair<int, int> > v;
int main() {
if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
pair<int, int> rey;
scanf("%d %d", &rey.first, &rey.second);
v.assign(667, pair<int, int>(0, 0));
for (int i = 1; i < 667; i++) scanf("%d %d", &v[i].first, &v[i].second);
for (int i = 1; i < 667; i++) c[v[i].first][v[i].second] = 1;
int x, y, z;
while (rey.first < 500) {
rey.first++;
printf("%d %d\n", rey.first, rey.second);
fflush(stdout);
scanf("%d %d %d", &x, &y, &z);
if (x == -1) return 0;
if (x == 0) return 0;
c[v[x].first][v[x].second] = 0;
c[y][z] = 1;
v[x] = pair<int, int>(y, z);
}
while (rey.first > 500) {
rey.first--;
printf("%d %d\n", rey.first, rey.second);
fflush(stdout);
scanf("%d %d %d", &x, &y, &z);
if (x == -1) return 0;
if (x == 0) return 0;
c[v[x].first][v[x].second] = 0;
c[y][z] = 1;
v[x] = pair<int, int>(y, z);
}
while (rey.second < 500) {
rey.second++;
printf("%d %d\n", rey.first, rey.second);
fflush(stdout);
scanf("%d %d %d", &x, &y, &z);
if (x == -1) return 0;
if (x == 0) return 0;
c[v[x].first][v[x].second] = 0;
c[y][z] = 1;
v[x] = pair<int, int>(y, z);
}
while (rey.second > 500) {
rey.second--;
printf("%d %d\n", rey.first, rey.second);
fflush(stdout);
scanf("%d %d %d", &x, &y, &z);
if (x == -1) return 0;
if (x == 0) return 0;
c[v[x].first][v[x].second] = 0;
c[y][z] = 1;
v[x] = pair<int, int>(y, z);
}
int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
for (int i = 1; i < 1000; i++)
for (int j = 1; j < 1000; j++)
if (c[i][j]) {
if (i > 500 || j > 500) c1++;
if (i > 500 || j < 500) c2++;
if (i < 500 || j > 500) c3++;
if (i < 500 || j < 500) c4++;
}
int mx = max(max(c1, c2), max(c3, c4));
if (c1 == mx) {
while (1) {
rey.first++;
rey.second++;
if (c[rey.first][rey.second]) rey.first--;
printf("%d %d\n", rey.first, rey.second);
fflush(stdout);
scanf("%d %d %d", &x, &y, &z);
if (x == -1 || x == 0) return 0;
c[v[x].first][v[x].second] = 0;
c[y][z] = 1;
v[x] = pair<int, int>(y, z);
}
}
if (c2 == mx) {
while (1) {
rey.first++;
rey.second--;
if (c[rey.first][rey.second]) rey.first--;
printf("%d %d\n", rey.first, rey.second);
fflush(stdout);
scanf("%d %d %d", &x, &y, &z);
if (x == -1 || x == 0) return 0;
c[v[x].first][v[x].second] = 0;
c[y][z] = 1;
v[x] = pair<int, int>(y, z);
}
}
if (c3 == mx) {
while (1) {
rey.first--;
rey.second++;
if (c[rey.first][rey.second]) rey.first++;
printf("%d %d\n", rey.first, rey.second);
fflush(stdout);
scanf("%d %d %d", &x, &y, &z);
if (x == -1 || x == 0) return 0;
c[v[x].first][v[x].second] = 0;
c[y][z] = 1;
v[x] = pair<int, int>(y, z);
}
}
if (c4 == mx) {
while (1) {
rey.first--;
rey.second--;
if (c[rey.first][rey.second]) rey.first++;
printf("%d %d\n", rey.first, rey.second);
fflush(stdout);
scanf("%d %d %d", &x, &y, &z);
if (x == -1 || x == 0) return 0;
c[v[x].first][v[x].second] = 0;
c[y][z] = 1;
v[x] = pair<int, int>(y, z);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1024;
bool vis[N][N];
struct Chess {
int x, y;
} rook[N], king;
int cnt[8];
int dir[8][2] = {{-1, -1}, {-1, 1}, {1, 1}, {1, -1},
{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
int Way(Chess s) {
if (s.x == 500 && s.y == 500) return -1;
if (s.x == 500) return s.y > 500 ? 5 : 7;
if (s.y == 500) return s.x > 500 ? 6 : 4;
if (s.x < 500) return s.y > 500 ? 1 : 0;
return s.y > 500 ? 2 : 3;
}
int Inv(int x) { return (x + 2) % 4 + ((x < 4) ? 0 : 4); }
void Go(int w) {
king.x += dir[w][0];
king.y += dir[w][1];
if (vis[king.x][king.y]) king.x -= dir[w][0];
printf("%d %d\n", king.x, king.y);
fflush(stdout);
int k;
scanf("%d", &k);
if (k <= 0) exit(0);
vis[rook[k].x][rook[k].y] = false;
scanf("%d %d", &rook[k].x, &rook[k].y);
vis[rook[k].x][rook[k].y] = true;
}
int main() {
scanf("%d %d", &king.x, &king.y);
for (int i = 1; i <= 666; i++) {
scanf("%d %d", &rook[i].x, &rook[i].y);
vis[rook[i].x][rook[i].y] = true;
}
while (true) {
int w = Way(king);
if (w == -1) break;
Go(Inv(w));
}
for (int i = 1; i <= 666; i++) cnt[Way(rook[i])]++;
int w = 0;
for (int i = 1; i < 4; i++)
if (cnt[i] < cnt[w]) w = i;
w = Inv(w);
while (true) Go(w);
return 0;
}
|
#include <bits/stdc++.h>
int x, y, k, c[4];
bool ocp[1000][1000];
struct POS {
int x, y;
} p[667];
void to(int dx, int dy) {
x += dx, y += dy;
if (ocp[x][y]) x -= dx;
printf("%d %d\n", x, y);
fflush(stdout);
scanf("%d", &k);
if (k == -1) exit(0);
if (k == 0) exit(0);
ocp[p[k].x][p[k].y] = false;
scanf("%d%d", &p[k].x, &p[k].y);
ocp[p[k].x][p[k].y] = true;
}
int main() {
scanf("%d%d", &x, &y);
for (int i = 1; i <= 666; i++) {
scanf("%d%d", &p[i].x, &p[i].y);
ocp[p[i].x][p[i].y] = true;
}
while (x < 500) to(1, 0);
while (x > 500) to(-1, 0);
while (y < 500) to(0, 1);
while (y > 500) to(0, -1);
for (int i = 1; i <= 666; i++) {
if (p[i].x < 500 && p[i].y < 500) c[0]++;
if (p[i].x < 500 && p[i].y > 500) c[1]++;
if (p[i].x > 500 && p[i].y < 500) c[2]++;
if (p[i].x > 500 && p[i].y > 500) c[3]++;
}
int id = 0;
for (int i = 1; i <= 3; i++)
if (c[i] < c[id]) id = i;
switch (id) {
case 0: {
while (x < 1000 && y < 1000) to(1, 1);
break;
}
case 1: {
while (x < 1000 && y > 0) to(1, -1);
break;
}
case 2: {
while (x > 0 && y < 1000) to(-1, 1);
break;
}
case 3: {
while (x > 0 && y > 0) to(-1, -1);
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct rook {
int x, y;
} a[1001];
int x, y;
bool vis[1001][1001];
void move(int dx, int dy) {
int k, tx, ty;
if (vis[x + dx][y + dy]) {
dy = 0;
}
x += dx;
y += dy;
printf("%d %d\n", x, y);
fflush(stdout);
scanf("%d%d%d", &k, &tx, &ty);
if (k == -1) {
exit(0);
}
if (!k) {
exit(0);
}
vis[a[k].x][a[k].y] = 0;
a[k].x = tx;
a[k].y = ty;
vis[tx][ty] = 1;
}
int main() {
scanf("%d%d", &x, &y);
for (int i = 1; i <= 666; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
vis[a[i].x][a[i].y] = 1;
}
while (x < 500) {
move(1, 0);
}
while (x > 500) {
move(-1, 0);
}
while (y < 500) {
move(0, 1);
}
while (y > 500) {
move(0, -1);
}
int sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0;
for (int i = 1; i <= 999; i++) {
for (int j = 1; j <= 999; j++) {
if (i < 500 || j < 500) {
sum1 += vis[i][j];
}
if (i < 500 || j > 500) {
sum2 += vis[i][j];
}
if (i > 500 || j < 500) {
sum3 += vis[i][j];
}
if (i > 500 || j > 500) {
sum4 += vis[i][j];
}
}
}
if (sum1 >= 500) {
while (1) {
move(-1, -1);
}
}
if (sum2 >= 500) {
while (1) {
move(-1, 1);
}
}
if (sum3 >= 500) {
while (1) {
move(1, -1);
}
}
if (sum4 >= 500) {
while (1) {
move(1, 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct cell {
int x, y;
};
int main() {
cell k;
int t1, t2, t3;
cin >> k.x >> k.y;
vector<cell> l(666);
for (int i = 0; i < 666; ++i) cin >> l[i].x >> l[i].y;
while (k.x != 500 || k.y != 500) {
if (k.x > 500)
--k.x;
else if (k.x < 500)
++k.x;
if (k.y > 500)
--k.y;
else if (k.y < 500)
++k.y;
cout << k.x << " " << k.y << "\n";
cout.flush();
cin >> t1 >> t2 >> t3;
if (t1 == -1) return 0;
if (t1 == 0) return 0;
--t1;
l[t1].x = t2;
l[t1].y = t3;
}
int u1 = 0, u2 = 0, u3 = 0, u4 = 0;
for (int i = 0; i < 666; ++i) {
if (l[i].x < 500 && l[i].y < 500)
++u1;
else if (l[i].x < 500)
++u2;
else if (l[i].y < 500)
++u3;
else
++u4;
}
vector<vector<int> > p(1000, vector<int>(1000, 0));
for (int i = 0; i < 666; ++i) p[l[i].x][l[i].y] = 1;
p[k.x][k.y] = 2;
if (u4 == min(min(u1, u2), min(u3, u4))) {
while (k.x > 0 && k.y > 0) {
if (p[k.x - 1][k.y - 1] == 0) {
p[k.x][k.y] = 0;
--k.x;
--k.y;
p[k.x][k.y] = 2;
cout << k.x << " " << k.y << "\n";
cout.flush();
} else {
--k.x;
cout << k.x << " " << k.y << "\n";
cout.flush();
}
cin >> t1 >> t2 >> t3;
if (t1 == -1) return 0;
if (t1 == 0) return 0;
--t1;
p[l[t1].x][l[t1].y] = 0;
p[t2][t3] = 1;
l[t1].x = t2;
l[t1].y = t3;
}
}
if (u3 == min(min(u1, u2), min(u3, u4))) {
while (k.x > 0 && k.y < 999) {
if (p[k.x - 1][k.y + 1] == 0) {
--k.x;
++k.y;
cout << k.x << " " << k.y << "\n";
cout.flush();
} else {
--k.x;
cout << k.x << " " << k.y << "\n";
cout.flush();
}
cin >> t1 >> t2 >> t3;
if (t1 == -1) return 0;
if (t1 == 0) return 0;
--t1;
p[l[t1].x][l[t1].y] = 0;
p[t2][t3] = 1;
l[t1].x = t2;
l[t1].y = t3;
}
}
if (u2 == min(min(u1, u2), min(u3, u4))) {
while (k.x < 999 && k.y > 0) {
if (p[k.x + 1][k.y - 1] == 0) {
++k.x;
--k.y;
cout << k.x << " " << k.y << "\n";
cout.flush();
} else {
++k.x;
cout << k.x << " " << k.y << "\n";
cout.flush();
}
cin >> t1 >> t2 >> t3;
if (t1 == -1) return 0;
if (t1 == 0) return 0;
--t1;
p[l[t1].x][l[t1].y] = 0;
p[t2][t3] = 1;
l[t1].x = t2;
l[t1].y = t3;
}
}
if (u1 == min(min(u1, u2), min(u3, u4))) {
while (k.x < 999 && k.y < 999) {
if (p[k.x + 1][k.y + 1] == 0) {
++k.x;
++k.y;
cout << k.x << " " << k.y << "\n";
cout.flush();
} else {
++k.x;
cout << k.x << " " << k.y << "\n";
cout.flush();
}
cin >> t1 >> t2 >> t3;
if (t1 == -1) return 0;
if (t1 == 0) return 0;
--t1;
p[l[t1].x][l[t1].y] = 0;
p[t2][t3] = 1;
l[t1].x = t2;
l[t1].y = t3;
}
}
while (t1 != 0) {
if (k.x > 1)
k.x--;
else
k.x++;
cout << k.x << " " << k.y << "\n";
cout.flush();
cin >> t1 >> t2 >> t3;
if (t1 == -1) return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 670;
int n, m, k, u, v, x, y, xx, yy, t, a, b, ans;
int X[MAXN];
int Y[MAXN];
int cnt[4];
set<pair<int, int> > st;
void out(int xx, int yy) {
if (st.count({xx, yy})) {
if (x != xx)
out(x, yy);
else
out(yy, x);
return;
}
x = xx;
y = yy;
cout << xx << ' ' << yy << '\n';
cout.flush();
}
void inp() {
cin >> k >> xx >> yy;
if (k == -1 || !k) exit(0);
st.erase({X[k], Y[k]});
X[k] = xx;
Y[k] = yy;
st.insert({X[k], Y[k]});
return;
}
void go(int dx, int dy) {
while (x != dx || y != dy) {
xx = x;
yy = y;
if (xx < dx) xx++;
if (xx > dx) xx--;
if (yy < dy) yy++;
if (yy > dy) yy--;
out(xx, yy);
inp();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> x >> y;
for (int i = 1; i <= 666; i++) cin >> X[i] >> Y[i], st.insert({X[i], Y[i]});
go(500, 500);
for (int i = 1; i <= 666; i++) {
if (X[i] < 500 && Y[i] < 500) cnt[0]++;
if (X[i] < 500 && Y[i] > 500) cnt[1]++;
if (X[i] > 500 && Y[i] < 500) cnt[2]++;
if (X[i] > 500 && Y[i] > 500) cnt[3]++;
}
if (cnt[0] <= 166) go(999, 999);
if (cnt[1] <= 166) go(999, 1);
if (cnt[2] <= 166) go(1, 999);
if (cnt[3] <= 166) go(1, 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[5005];
int n, m;
int x;
int dp[5005];
int dist(int a, int b) {
if (b >= a)
return b - a;
else
return b - a + n;
}
bool cmp(int xx, int yy) { return dist(x, xx) < dist(x, yy); }
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
v[a].push_back(b);
}
for (int i = 0; i < n; i++) {
if (v[i].empty()) continue;
x = i;
sort(v[i].begin(), v[i].end(), cmp);
dp[i] = n * (int)(v[i].size() - 1) + dist(i, v[i][0]);
}
for (int i = 0; i < n; i++) {
int ma = -1e9;
for (int j = 0; j < n; j++) {
if (dp[j]) ma = max(dist(i, j) + dp[j], ma);
}
cout << ma << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
vector<int> v[5002];
int w[5002];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) w[i] = INT_MAX;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
v[a].push_back(b);
w[a] = min(w[a], (b + n - a) % n);
}
for (int i = 0; i < n; i++) {
int cap = 0;
for (int j = 0; j < n; j++) {
cap = max(cap, (int)(v[j].size()));
}
int tim = n * (cap - 1);
int maxi = 0;
for (int j = 0; j < n; j++) {
if (w[j] == INT_MAX) continue;
if (v[j].size() == cap) {
maxi = max(maxi, w[j] + (j + n - i) % n);
} else {
if (v[j].size() == cap - 1) {
maxi = max(maxi, w[j] + (j + n - i) % n - n);
}
}
}
tim += maxi;
if (i) printf(" ");
printf("%d", tim);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ull = uint64_t;
using ll = int64_t;
using ld = long double;
const int N = 5002;
int d[N];
int c[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.setf(ios::fixed);
cout.precision(20);
int n, m;
cin >> n >> m;
fill(d, d + n, N);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
int ds = b - a;
if (ds < 0) {
ds += n;
}
++c[a];
d[a] = min(d[a], ds);
}
for (int i = 0; i < n; ++i) {
int ans = 0;
for (int j = 0; j < n; ++j) {
int k = (i + j) % n;
if (c[k]) {
ans = max(ans, (c[k] - 1) * n + j + d[k]);
}
}
cout << ans << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int cnt[5005];
int mindist[5005];
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= n; i++) mindist[i] = 5010;
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
if (x > y)
mindist[x] = min(mindist[x], n - x + y);
else
mindist[x] = min(mindist[x], y - x);
cnt[x]++;
}
int ans;
for (int i = 1; i <= n; i++) {
ans = 0;
for (int j = 1; j <= n; j++) {
if (mindist[j] == 5010) continue;
if (i <= j)
ans = max(ans, j - i + mindist[j] + n * (cnt[j] - 1));
else
ans = max(ans, n - i + j + mindist[j] + n * (cnt[j] - 1));
}
cout << ans << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 4e5 + 10;
void inout() {}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
inout();
long long int n, m, i, j, maxi, x, y, z;
cin >> n >> m;
vector<pair<long long int, long long int>> v(m);
;
for (auto &i : v) cin >> i.first >> i.second;
sort(v.begin(), v.end());
vector<vector<long long int>> adj(n + 1);
for (i = 0; i < m; i++) {
if (v[i].second < v[i].first) v[i].second += n;
adj[v[i].first].push_back(v[i].second);
}
for (i = 1; i <= n; i++) {
sort(adj[i].begin(), adj[i].end());
}
for (i = 1; i <= n; i++) {
maxi = -1;
for (j = 1; j <= n; j++) {
if (adj[j].size() >= 1) {
x = i;
y = j;
if (x > y) y += n;
z = adj[j][0];
if (z < y) z += n;
long long int dist = (y - x) + (n * (adj[j].size() - 1) + (z - y));
maxi = max(dist, maxi);
}
}
cout << maxi << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long tinf = (long long)1e9 + 7;
const long long inf = (long long)1e18 + 7;
const long long N = 7e5 + 5;
const long long M = 1e9 + 7;
const long long rx[4] = {1, 0, -1, 0};
const long long ry[4] = {0, 1, 0, -1};
signed main() {
{
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long long n, m;
cin >> n >> m;
vector<pair<long long, long long> > d[n];
for (long long i = 0; i < m; i++) {
long long v, u;
cin >> v >> u;
v--;
u--;
long long dist = 0;
if (u >= v)
dist = u - v;
else
dist = n - v + u;
d[v].push_back({dist, u});
}
for (long long i = 0; i < n; i++) {
sort(d[i].rbegin(), d[i].rend());
}
vector<long long> v;
for (long long i = 0; i < n; i++) {
if ((long long)d[i].size()) v.push_back(i);
}
for (long long i = 0; i < n; i++) {
long long ans = 0;
for (auto j : v) {
long long dist = 0;
if (j >= i)
dist = j - i;
else
dist = n - i + j;
ans =
max(ans, d[j].back().first + dist + ((long long)d[j].size() - 1) * n);
}
cout << ans << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int N = 5e3 + 5, M = 2e4 + 5;
vector<vector<int>> v(N);
vector<int> t(N, INT_MAX), ans(N, 0);
int n, m;
int dis(int i, int j) {
if (i <= j)
return j - i;
else
return n - i + j;
}
void solve() {
for (int i = 1; i <= n; i++) {
for (auto &j : v[i]) {
t[i] = min(t[i], dis(i, j));
}
}
for (int i = 1; i <= n; i++) {
int ans = 0;
for (int j = 1; j <= n; j++) {
if (v[j].size() == 0) continue;
ans = max(ans, dis(i, j) + n * (int(v[j].size()) - 1) + t[j]);
}
cout << ans << ' ';
}
cout << "\n";
}
int main() {
fast();
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
}
solve();
}
|
#include <bits/stdc++.h>
using std::abs;
using std::cin;
using std::cout;
using std::deque;
using std::function;
using std::make_pair;
using std::map;
using std::max;
using std::min;
using std::numeric_limits;
using std::pair;
using std::set;
using std::string;
using std::stringstream;
using std::tuple;
using std::unordered_map;
using std::vector;
using ll = long long;
constexpr ll magic_mod = 1000000007;
ll m_pluss(ll a, ll b) { return (a + b) % magic_mod; }
ll m_mul(ll a, ll b) { return (a * b) % magic_mod; }
int n, m;
deque<vector<int>> cc;
ll get_res() {
int res = 0;
for (int i = 0; (i) < (int)(n); ++(i)) {
auto& cq = cc[i];
if (cq.empty()) continue;
res = max<int>(res, cq.front() + i + cq.size() * n - n);
}
return res;
}
int main() {
std::ios_base::sync_with_stdio(0);
std::cout.precision(17);
cin >> n >> m;
cc.resize(n);
vector<pair<int, int>> candies(m);
for (auto& c : candies) {
cin >> c.first >> c.second;
cc[c.first - 1].push_back((c.second - c.first + n) % n);
}
for (int i = 0; (i) < (int)(n); ++(i)) {
auto& cq = cc[i];
if (cq.empty()) continue;
std::sort(begin(cq), end(cq));
}
for (int i = 0; (i) < (int)(n); ++(i)) {
cout << get_res() << " ";
auto x = cc.front();
cc.pop_front();
cc.push_back(x);
}
cout << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
bool t = false;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = true, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return t ? -x : x;
}
int n, m, cnt[5050], d[5050];
int main() {
n = read();
m = read();
for (int i = 1; i <= n; ++i) d[i] = n + 1;
for (int i = 1; i <= m; ++i) {
int l = read(), r = read();
if (r < l) r += n;
cnt[l] += 1;
d[l] = min(d[l], r - l);
}
int mx = 0;
for (int i = 1; i <= n; ++i) mx = max(mx, cnt[i]);
for (int i = 1; i <= n; ++i)
if (cnt[i] < max(1, mx - 1)) d[i] = 0;
for (int i = 1; i <= n; ++i) {
int ans = (mx - 1) * n, mxx = 0;
for (int j = 1; j <= n; ++j)
if (cnt[j] == mx) {
int dis = i <= j ? j - i : j - i + n;
dis += d[j];
mxx = max(mxx, dis);
} else if (cnt[j] == mx - 1) {
int dis = j < i ? i - j : i - j + n;
mxx = max(mxx, d[j] - dis);
}
printf("%d ", ans + mxx);
}
puts("");
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.