text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 1;
int p[N];
set<int> s[N];
int get(int pos) { return p[pos] = p[pos] == pos ? pos : get(p[pos]); }
void merge(int a, int b) {
a = get(a), b = get(b);
if (a == b) return;
if (s[b].size() < s[a].size()) swap(a, b);
p[a] = b;
for (int i : s[a]) s[b].insert(i);
}
void init() {
for (int i = 0; i < N; i++) p[i] = i;
}
int idx, n;
map<pair<int, int>, int> has;
void add() {
int a, b, c;
cin >> a >> b >> c;
s[get(a)].insert(b);
s[get(b)].insert(a);
if (has[{a, c}])
merge(has[{a, c}], b);
else
merge(has[{a, c}] = idx++, b);
if (has[{b, c}])
merge(has[{b, c}], a);
else
merge(has[{b, c}] = idx++, a);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
init();
int m, c, q;
cin >> n >> m >> c >> q;
idx = n + 1;
for (int i = 0; i < m; i++) add();
for (int i = 0; i < q; i++) {
char mode;
cin >> mode;
if (mode == '+')
add();
else {
int a, b;
cin >> a >> b;
if (get(a) == get(b) or s[get(a)].find(b) != s[get(a)].end())
cout << "Yes\n";
else
cout << "No\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, c, q;
int fa[N], siz[N];
multiset<int> pbl[N];
vector<int> e[N], vex[N];
map<int, int> g[N];
int find(int x) {
for (; fa[x] != x; x = fa[x])
;
return x;
}
void reconsitution(vector<int> &v, vector<int> &x, int rt, int bt) {
for (int i = 0; i < (int)v.size(); i++) {
int u = v[i];
for (int j = 0; j < (int)e[u].size(); j++) {
int v = e[u][j];
pbl[v].erase(pbl[v].find(rt));
pbl[v].insert(bt);
}
}
x.insert(x.end(), v.begin(), v.end());
v.clear();
return;
}
void merge(int u, int v) {
u = find(u), v = find(v);
if (u == v) return;
if (siz[u] > siz[v]) swap(u, v);
fa[u] = v, siz[v] += siz[u];
reconsitution(vex[u], vex[v], u, v);
return;
}
void adde(int u, int v, int w) {
e[u].push_back(v);
pbl[v].insert(find(u));
if (!g[u].count(w)) return void(g[u][w] = v);
int l = g[u][w];
merge(v, l);
return;
}
int main() {
scanf("%d%d%d%d", &n, &m, &c, &q);
for (int i = 1; i <= n; i++) fa[i] = i, siz[i] = 1, vex[i].push_back(i);
int u, v, w;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
adde(u, v, w), adde(v, u, w);
}
char op;
for (int i = 1; i <= q; i++) {
scanf(" %c ", &op);
if (op == '+') {
scanf("%d%d%d", &u, &v, &w);
adde(u, v, w);
adde(v, u, w);
} else {
scanf("%d%d", &u, &v);
u = find(u);
if (find(v) == u)
printf("Yes\n");
else if (pbl[v].count(u))
printf("Yes\n");
else
printf("No\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-6;
inline long long lgput(long long a, long long b, long long mod) {
long long ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return (ret % mod);
}
inline long long inv(long long x, long long MOD) {
return lgput(x, MOD - 2, MOD);
}
inline bool exist(double nr) { return (nr < -eps) || (nr > eps); }
long long big_rand() { return rand() * RAND_MAX + rand(); }
map<int, int> gr[100100];
map<int, int> vec[100100];
vector<int> ap[100100];
int dad[100100];
int superdad(int a) {
if (dad[a] != a) {
dad[a] = superdad(dad[a]);
}
return dad[a];
}
void bag(int a, int b) {
for (auto &x : ap[dad[a]]) {
vec[x][dad[b]] = 1;
ap[dad[b]].push_back(x);
}
ap[dad[a]].clear();
dad[dad[a]] = dad[b];
}
void unite(int a, int b) {
superdad(a);
superdad(b);
if (dad[a] == dad[b]) {
return;
}
if (ap[dad[a]].size() < ap[dad[b]].size()) {
bag(a, b);
} else {
bag(b, a);
}
}
void edge(int x, int y, int val) {
if (gr[x][val]) {
unite(y, gr[x][val]);
}
if (gr[y][val]) {
unite(x, gr[y][val]);
}
gr[x][val] = y;
gr[y][val] = x;
superdad(x);
superdad(y);
vec[y][dad[x]] = 1;
vec[x][dad[y]] = 1;
ap[dad[x]].push_back(y);
ap[dad[y]].push_back(x);
}
bool verif(int x, int y) {
superdad(x);
superdad(y);
if (dad[x] == dad[y]) {
return 1;
}
if (vec[y][dad[x]]) {
return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << setprecision(10) << fixed;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
srand(time(nullptr));
int n, m, c, q;
cin >> n >> m >> c >> q;
for (int i = 1; i <= n; i++) {
dad[i] = i;
}
for (int i = 1; i <= m; i++) {
int x, y, val;
cin >> x >> y >> val;
edge(x, y, val);
}
while (q--) {
char ch;
cin >> ch;
if (ch == '+') {
int x, y, val;
cin >> x >> y >> val;
edge(x, y, val);
} else {
int x, y;
cin >> x >> y;
if (verif(x, y)) {
cout << "Yes" << '\n';
} else {
cout << "No" << '\n';
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > edges[100005];
set<int> cnt[100005];
map<int, int> color[100005];
vector<int> have[100005];
int pre[100005];
vector<int> chge;
int pset[100005];
int fs(int a) { return (a == pset[a]) ? a : pset[a] = fs(pset[a]); }
void update(int x, int y) {
for (auto p : have[x]) {
if (cnt[p].find(x) == cnt[p].end()) continue;
cnt[p].insert(y);
cnt[p].erase(x);
have[y].push_back(p);
}
have[x].clear();
}
void addedge(int x, int y, int z) {
if (color[x].find(z) != color[x].end()) {
int u = color[x][z];
if (fs(u) != fs(y)) {
if (have[fs(u)].size() > have[fs(y)].size()) swap(u, y);
update(fs(u), fs(y));
pset[fs(u)] = fs(y);
}
} else {
color[x][z] = y;
cnt[x].insert(fs(y));
have[fs(y)].push_back(x);
}
}
int main() {
int n, m, c, q;
scanf("%d %d %d %d", &n, &m, &c, &q);
for (int i = (1); i <= (n); i++) pset[i] = i;
for (int i = (1); i <= (m); i++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
addedge(u, v, w);
addedge(v, u, w);
}
for (int i = (1); i <= (q); i++) {
char c;
int x, y;
scanf(" %c %d %d", &c, &x, &y);
if (c == '+') {
int z;
scanf("%d", &z);
addedge(x, y, z);
addedge(y, x, z);
} else {
if (fs(x) == fs(y) || cnt[y].find(fs(x)) != cnt[y].end())
printf("Yes\n");
else
printf("No\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 1, mod = 1e9 + 7, inf = 1e18, siz = 500;
struct ds {
int t, x, y, z;
};
vector<pair<int, int> > G[maxn];
ds a[maxn];
int n, m, deg[maxn], root[maxn];
vector<int> group[maxn], near_group[maxn], Gn[maxn];
void inquery(int i) {
int x, y, c;
cin >> x >> y >> c;
a[i] = {1, x, y, c};
deg[x]++;
deg[y]++;
G[x].push_back(make_pair(c, 0));
G[y].push_back(make_pair(c, 0));
}
void read() {
int c, q, x, y;
cin >> n >> m >> c >> q;
for (int i = 1; i <= m; i++) inquery(i);
char ch;
for (int i = 1; i <= q; i++) {
cin >> ch;
if (ch == '+')
inquery(i + m);
else
cin >> x >> y, a[i + m] = {2, x, y, 0};
}
m += q;
}
void build() {
for (int i = 1; i <= n; i++) {
sort(G[i].begin(), G[i].end());
G[i].push_back(make_pair(0, 0));
vector<pair<int, int> > tmp;
for (int j = 0; j < G[i].size() - 1; j++)
if (G[i][j].first != G[i][j + 1].first)
tmp.push_back(make_pair(G[i][j].first, 0));
G[i] = tmp;
}
for (int i = 1; i <= n; i++) root[i] = i, group[i].push_back(i);
}
void merg(int x, int y) {
if (x == y) return;
if (group[x].size() < group[y].size()) swap(x, y);
for (int i = 0; i < group[y].size(); i++)
root[group[y][i]] = x, group[x].push_back(group[y][i]);
group[y].clear();
vector<int> tmp(near_group[x].size() + near_group[y].size());
merge(near_group[x].begin(), near_group[x].end(), near_group[y].begin(),
near_group[y].end(), tmp.begin());
tmp.push_back(0);
near_group[x].clear();
for (int i = 0; i < tmp.size() - 1; i++)
if (tmp[i] != tmp[i + 1]) near_group[x].push_back(tmp[i]);
near_group[y].clear();
}
void addto(int x, int y) {
int tmp = lower_bound(near_group[x].begin(), near_group[x].end(), y) -
near_group[x].begin();
if (tmp == near_group[x].size() || near_group[x][tmp] != y) {
vector<int> tt;
for (int i = 0; i < tmp; i++) tt.push_back(near_group[x][i]);
tt.push_back(y);
for (int i = tmp; i < near_group[x].size(); i++)
tt.push_back(near_group[x][i]);
near_group[x] = tt;
}
}
void update(int x, int y, int z) {
int tmp =
(lower_bound(G[x].begin(), G[x].end(), make_pair(z, 0)) - G[x].begin());
if (G[x][tmp].second)
merg(root[G[x][tmp].second], root[y]);
else
G[x][tmp].second = y;
if (deg[y] >= siz) addto(root[x], y);
Gn[x].push_back(y);
}
bool query(int x, int y) {
if (root[x] == root[y]) return true;
if (deg[y] >= siz) {
int r = root[x];
int tmp = lower_bound(near_group[r].begin(), near_group[r].end(), y) -
near_group[r].begin();
return (tmp < near_group[r].size()) && (near_group[r][tmp] == y);
} else {
for (int i = 0; i < Gn[y].size(); i++)
if (root[Gn[y][i]] == root[x]) return true;
return false;
}
}
void process() {
for (int i = 1; i <= m; i++)
if (a[i].t == 1) {
update(a[i].x, a[i].y, a[i].z);
update(a[i].y, a[i].x, a[i].z);
} else {
if (query(a[i].x, a[i].y))
printf("Yes\n");
else
printf("No\n");
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
read();
build();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
int dsu[MAXN], sum[MAXN], ex[MAXN], N, M, C, Q, bound = 500;
vector<int> heavy, adj[MAXN];
map<int, int> label[MAXN];
set<int> n[MAXN];
void init() {
for (int i = 1; i < MAXN; i++) dsu[i] = i;
}
int findPar(int x) {
if (dsu[x] == x) return x;
return dsu[x] = findPar(dsu[x]);
}
void Join(int x, int y) {
int parX = findPar(x), parY = findPar(y);
if (parX == parY) return;
for (int& nodes : heavy) {
if (n[nodes].count(parX)) {
n[nodes].insert(parY);
}
}
dsu[parX] = parY;
}
void check(int u) {
if (!ex[u]) {
if (sum[u] > bound) {
heavy.push_back(u);
for (int& nxt : adj[u]) {
n[u].insert(findPar(nxt));
}
ex[u] = true;
}
}
}
void add(int u, int v) {
if (v < u) swap(u, v);
if (ex[u]) n[u].insert(findPar(v));
if (ex[v]) n[v].insert(findPar(u));
adj[u].push_back(v);
sum[u]++;
adj[v].push_back(u);
sum[v]++;
check(u);
check(v);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> N >> M >> C >> Q;
init();
for (int i = 0; i < M; i++) {
int u, v, c;
cin >> u >> v >> c;
add(u, v);
int x = label[u][c];
if (x)
Join(v, x);
else
label[u][c] = v;
int y = label[v][c];
if (y)
Join(u, y);
else
label[v][c] = u;
}
for (int i = 0; i < Q; i++) {
char z;
int u, v;
cin >> z >> u >> v;
if (z == '?') {
int x = findPar(u);
if (x == findPar(v))
cout << "Yes" << '\n';
else {
if (ex[v]) {
if (n[v].count(x))
cout << "Yes" << '\n';
else
cout << "No" << '\n';
} else {
bool found = false;
for (int& nxt : adj[v]) {
if (x == findPar(nxt)) {
cout << "Yes" << '\n';
found = true;
break;
}
}
if (!found) cout << "No" << '\n';
}
}
} else {
int c;
cin >> c;
add(u, v);
int x = label[u][c];
if (x)
Join(v, x);
else
label[u][c] = v;
int y = label[v][c];
if (y)
Join(u, y);
else
label[v][c] = u;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int repr(vector<int>& fath, int x) {
if (fath[x] < 0) return x;
return fath[x] = repr(fath, fath[x]);
}
void merge(vector<int>& fath, vector<set<int> >& reach, int x, int y) {
x = repr(fath, x);
y = repr(fath, y);
if (x == y) return;
if (reach[x].size() > reach[y].size()) swap(x, y);
for (set<int>::iterator it = reach[x].begin(); it != reach[x].end(); ++it) {
reach[y].insert(*it);
}
reach[x].clear();
fath[x] = y;
}
void add_edge(vector<map<int, int> >& col_edge, vector<int>& fath,
vector<set<int> >& reach, int x, int y, int z) {
reach[repr(fath, x)].insert(y);
reach[repr(fath, y)].insert(x);
if (col_edge[y].find(z) != col_edge[y].end()) {
merge(fath, reach, x, col_edge[y][z]);
} else {
col_edge[y][z] = x;
}
if (col_edge[x].find(z) != col_edge[x].end()) {
merge(fath, reach, y, col_edge[x][z]);
} else {
col_edge[x][z] = y;
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n, m, c, q;
cin >> n >> m >> c >> q;
vector<map<int, int> > col_edge(n);
vector<int> fath(n, -1);
vector<set<int> > reach(n);
for (int i = 0; i < n; ++i) {
reach[i].insert(i);
}
for (int i = 0; i < m; ++i) {
int x, y, z;
cin >> x >> y >> z;
--x, --y, --z;
add_edge(col_edge, fath, reach, x, y, z);
}
for (; q > 0; --q) {
char type;
cin >> type;
if (type == '+') {
int x, y, z;
cin >> x >> y >> z;
--x, --y, --z;
add_edge(col_edge, fath, reach, x, y, z);
} else {
int x, y;
cin >> x >> y;
--x, --y;
if (reach[repr(fath, x)].count(y) > 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int par[N];
set<int> adj[N];
map<int, int> cur[N];
int root(int u) { return par[u] < 0 ? u : (par[u] = root(par[u])); }
void join(int u, int v) {
if ((u = root(u)) == (v = root(v))) return;
if (par[u] > par[v]) swap(u, v);
par[u] += par[v];
par[v] = u;
adj[u].insert(adj[v].begin(), adj[v].end());
adj[v].clear();
}
void add(int u, int v, int c) {
if (cur[u].count(c))
join(cur[u][c], v);
else
cur[u][c] = v;
if (cur[v].count(c))
join(cur[v][c], u);
else
cur[v][c] = u;
adj[root(u)].insert(v);
adj[root(v)].insert(u);
}
bool ask(int u, int v) {
int fu = root(u), fv = root(v);
return (fu == fv || adj[fu].count(v));
}
int main() {
if (fopen("exam.inp", "r"))
freopen("exam.inp", "r", stdin), freopen("exam.out", "w", stdout);
memset(par, -1, sizeof(par));
int n, m, q, x, y, z;
char type;
scanf("%d%d%d%d\n", &n, &m, &x, &q);
while (m--) {
scanf("%d%d%d\n", &x, &y, &z);
add(x, y, z);
}
while (q--) {
type = getchar();
if (type == '?') {
scanf("%d%d\n", &x, &y);
puts(ask(x, y) ? "Yes" : "No");
} else {
scanf("%d%d%d\n", &x, &y, &z);
add(x, y, z);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, c, m, q, par[N];
map<int, int> col[N];
set<int> adj[N];
int get_par(int u) { return ~par[u] ? par[u] = get_par(par[u]) : u; }
void merge(int u, int v) {
if ((u = get_par(u)) == (v = get_par(v))) return;
if (adj[u].size() < adj[v].size()) swap(u, v);
for (auto x : adj[v]) adj[u].insert(x);
par[v] = u;
}
void add(int u, int v) {
cin >> c;
if (col[u].count(c))
merge(v, col[u][c]);
else
col[u][c] = v;
if (col[v].count(c))
merge(u, col[v][c]);
else
col[v][c] = u;
adj[get_par(u)].insert(v);
adj[get_par(v)].insert(u);
}
void solve(int u, int v) {
int u1 = get_par(u), v1 = get_par(v);
cout << (u1 == v1 || adj[u1].count(v) ? "Yes\n" : "No\n");
}
int main() {
memset(par, -1, sizeof par);
cin >> n >> m >> c >> q;
while (m--) {
int u, v;
cin >> u >> v;
add(--u, --v);
}
while (q--) {
char t;
int u, v;
cin >> t >> u >> v;
t ^ '?' ? add(--u, --v) : solve(--u, --v);
}
}
|
#include <bits/stdc++.h>
const int N = 100005;
std::map<int, int> rec[N];
std::set<int> adj[N];
int n, m, c, q, f[N];
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
void _union(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (adj[x].size() > adj[y].size()) std::swap(x, y);
f[x] = y;
for (int p : adj[x]) adj[y].insert(p);
}
void link(int x, int y, int c) {
if (rec[x].count(c))
_union(rec[x][c], y);
else
rec[x][c] = y;
if (rec[y].count(c))
_union(rec[y][c], x);
else
rec[y][c] = x;
adj[find(x)].insert(y);
adj[find(y)].insert(x);
}
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> n >> m >> c >> q;
for (int i = 1; i <= n; ++i) f[i] = i, adj[i].insert(i);
for (int i = 0, x, y, c; i < m; ++i) std::cin >> x >> y >> c, link(x, y, c);
while (q--) {
char opt;
int x, y, c;
std::cin >> opt >> x >> y;
if (opt == '?')
std::cout << (adj[find(x)].count(y) ? "Yes" : "No") << '\n';
else
std::cin >> c, link(x, y, c);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100006;
int lab[MAXN];
map<int, vector<int> > v[MAXN];
set<int> s[MAXN];
vector<int> cc[MAXN], allV[MAXN];
int getRoot(int a) {
while (lab[a] >= 0) a = lab[a];
return a;
}
void dsu(int a, int b) {
int x = lab[a] + lab[b];
if (lab[a] < lab[b]) {
lab[a] = x;
lab[b] = a;
for (auto i : cc[b]) {
for (auto j : allV[i]) {
s[j].erase(b);
s[j].insert(a);
}
}
for (auto i : cc[b]) cc[a].push_back(i);
cc[b].clear();
} else {
lab[b] = x;
lab[a] = b;
for (auto i : cc[a]) {
for (auto j : allV[i]) {
s[j].erase(a);
s[j].insert(b);
}
}
for (auto i : cc[a]) cc[b].push_back(i);
cc[a].clear();
}
}
void addEdge2(int x, int y) {
int m = getRoot(x);
int n = getRoot(y);
if (m == n) {
return;
}
dsu(m, n);
}
void addEdge(int x, int y, int c) {
if (v[y][c].size()) {
addEdge2(x, v[y][c][0]);
}
if (v[x][c].size()) {
addEdge2(y, v[x][c][0]);
}
v[x][c].push_back(y);
v[y][c].push_back(x);
allV[x].push_back(y);
allV[y].push_back(x);
s[x].insert(getRoot(y));
s[y].insert(getRoot(x));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
int n, m, c, q;
cin >> n >> m >> c >> q;
for (int i = 1; i <= n; i++) {
lab[i] = -1;
cc[i].push_back(i);
}
for (int i = 1; i <= m; i++) {
int x, y, c;
cin >> x >> y >> c;
addEdge(x, y, c);
}
for (int i = 1; i <= q; i++) {
char c;
cin >> c;
if (c == '+') {
int x, y, c;
cin >> x >> y >> c;
addEdge(x, y, c);
} else {
int x, y;
cin >> x >> y;
int u = getRoot(x);
if (s[y].find(u) != s[y].end() || u == getRoot(y)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = (int)1e5 + 5;
int n, m, c, q;
map<int, int> mp[M];
set<int> st[M];
int fa[M];
int getfa(int x) {
if (fa[x] == x) return x;
return fa[x] = getfa(fa[x]);
}
void guan(int x, int y) {
for (set<int>::iterator it = st[y].begin(); it != st[y].end(); it++)
st[x].insert(*it);
}
void uni(int x, int y) {
x = getfa(x), y = getfa(y);
if (x == y)
;
else if (st[x].size() > st[y].size()) {
guan(x, y);
fa[y] = x;
} else {
guan(y, x);
fa[x] = y;
}
}
void Add() {
static int x, y, c, fx, fy;
scanf("%d %d %d", &x, &y, &c);
if (mp[x].find(c) == mp[x].end())
mp[x][c] = y;
else
uni(mp[x][c], y);
if (mp[y].find(c) == mp[y].end())
mp[y][c] = x;
else
uni(mp[y][c], x);
fx = getfa(x), fy = getfa(y);
st[fx].insert(y), st[fy].insert(x);
}
void Que() {
static int x, y, fx, fy;
scanf("%d %d", &x, &y);
fx = getfa(x), fy = getfa(y);
if (fx == fy || st[fx].find(y) != st[fx].end())
puts("Yes");
else
puts("No");
}
int main() {
scanf("%d %d %d %d", &n, &m, &c, &q);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) Add();
for (int i = 1; i <= q; i++) {
static char S[5];
scanf("%s", S);
if (S[0] == '+')
Add();
else
Que();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-O2")
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\t";
err(++it, args...);
}
template <typename T1, typename T2>
ostream& operator<<(ostream& c, pair<T1, T2>& v) {
c << "(" << v.first << "," << v.second << ")";
return c;
}
template <template <class...> class TT, class... T>
ostream& operator<<(ostream& out, TT<T...>& c) {
out << "{ ";
for (auto& x : c) out << x << " ";
out << "}";
return out;
}
const int LIM = 1e5 + 5, MOD = 1e9 + 7;
int t, n, m, k, x, y, w, c, q;
map<int, vector<int> > v[LIM];
set<int> e[LIM];
struct dsu {
vector<int> par, rk;
void reset(int n) {
rk.assign(n, 1);
par.resize(n);
iota(par.begin(), par.end(), 0);
for (int i = 0; i < n; ++i) e[i].insert(i);
}
int getpar(int i) { return (par[i] == i) ? i : (par[i] = getpar(par[i])); }
bool con(int i, int j) { return getpar(i) == getpar(j); }
bool join(int i, int j) {
i = getpar(i), j = getpar(j);
if (i == j) return 0;
if (rk[i] > rk[j]) {
par[j] = i;
rk[i] += rk[j];
for (auto& it : e[j]) e[i].insert(it);
} else {
par[i] = j;
if (rk[i] == rk[j]) rk[j] += rk[i];
for (auto& it : e[i]) e[j].insert(it);
}
return 1;
}
} d;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> c >> q;
d.reset(n);
for (int i = 0; i < m; ++i) {
cin >> x >> y >> w;
--x, --y;
v[x][w].push_back(y);
v[y][w].push_back(x);
e[d.getpar(x)].insert(y);
d.join(v[x][w][0], y);
e[d.getpar(y)].insert(x);
d.join(v[y][w][0], x);
}
char ch;
for (int i = 0; i < q; ++i) {
cin >> ch >> x >> y;
--x, --y;
if (ch == '?') {
bool ok = e[d.getpar(x)].find(y) != e[d.getpar(x)].end();
if (ok)
cout << "Yes\n";
else
cout << "No\n";
} else {
cin >> w;
v[x][w].push_back(y);
v[y][w].push_back(x);
e[d.getpar(x)].insert(y);
d.join(v[x][w][0], y);
e[d.getpar(y)].insert(x);
d.join(v[y][w][0], x);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-O2")
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\t";
err(++it, args...);
}
template <typename T1, typename T2>
ostream& operator<<(ostream& c, pair<T1, T2>& v) {
c << "(" << v.first << "," << v.second << ")";
return c;
}
template <template <class...> class TT, class... T>
ostream& operator<<(ostream& out, TT<T...>& c) {
out << "{ ";
for (auto& x : c) out << x << " ";
out << "}";
return out;
}
const int LIM = 1e5 + 5, MOD = 1e9 + 7;
int t, n, m, k, x, y, w, c, q;
map<int, vector<int> > v[LIM];
set<int> e[LIM];
struct dsu {
vector<int> par, rk;
void reset(int n) {
rk.assign(n, 1);
par.resize(n);
iota(par.begin(), par.end(), 0);
for (int i = 0; i < n; ++i) e[i].insert(i);
}
int getpar(int i) { return (par[i] == i) ? i : (par[i] = getpar(par[i])); }
bool con(int i, int j) { return getpar(i) == getpar(j); }
bool join(int i, int j) {
i = getpar(i), j = getpar(j);
if (i == j) return 0;
if (rk[i] > rk[j]) {
par[j] = i;
rk[i] += rk[j];
for (auto& it : e[j]) e[i].insert(it);
} else {
par[i] = j;
rk[j] += rk[i];
for (auto& it : e[i]) e[j].insert(it);
}
return 1;
}
} d;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> c >> q;
d.reset(n);
for (int i = 0; i < m; ++i) {
cin >> x >> y >> w;
--x, --y;
v[x][w].push_back(y);
v[y][w].push_back(x);
e[d.getpar(x)].insert(y);
d.join(v[x][w][0], y);
e[d.getpar(y)].insert(x);
d.join(v[y][w][0], x);
}
char ch;
for (int i = 0; i < q; ++i) {
cin >> ch >> x >> y;
--x, --y;
if (ch == '?') {
bool ok = e[d.getpar(x)].find(y) != e[d.getpar(x)].end();
if (ok)
cout << "Yes\n";
else
cout << "No\n";
} else {
cin >> w;
v[x][w].push_back(y);
v[y][w].push_back(x);
e[d.getpar(x)].insert(y);
d.join(v[x][w][0], y);
e[d.getpar(y)].insert(x);
d.join(v[y][w][0], x);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int l, int r) { return l + rng() % (r - l + 1); }
const int N = 100010;
int n, m, c, q;
int id[N];
map<int, map<int, int>> mp;
set<int> st[N];
int root(int x) { return id[x] < 0 ? x : id[x] = root(id[x]); }
void join(int u, int v) {
if ((u = root(u)) == (v = root(v))) return;
if (st[u].size() < st[v].size()) swap(u, v);
id[u] += id[v];
id[v] = u;
for (auto& i : st[v]) st[u].insert(i);
}
void add(int u, int v, int c) {
if (mp[u][c])
join(mp[u][c], v);
else
mp[u][c] = v;
if (mp[v][c])
join(u, mp[v][c]);
else
mp[v][c] = u;
st[root(u)].insert(v);
st[root(v)].insert(u);
}
int que(int u, int v) { return root(u) == root(v) || st[root(u)].count(v); }
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
;
memset(id, -1, sizeof(id));
cin >> n >> m >> c >> q;
for (int i = 1, _c = m; i <= _c; ++i) {
int u, v, c;
cin >> u >> v >> c;
add(u, v, c);
}
for (int i = 1, _c = q; i <= _c; ++i) {
char t;
int u, v;
cin >> t >> u >> v;
if (t == '+') {
int c;
cin >> c;
add(u, v, c);
} else
cout << (que(u, v) ? "Yes" : "No") << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vint = vector<int>;
using vll = vector<ll>;
struct pseudo_dsu {
int root;
int number;
vector<int> child;
int edges_rank;
set<int> neig_dsus;
void unite(vector<pseudo_dsu> &dsus, vector<map<int, vector<int>>> &neig,
vector<set<int>> &who_contain, pseudo_dsu &other) {
int r = root;
int other_r = other.root;
if (r == other_r) {
return;
}
if (dsus[r].edges_rank < dsus[other_r].edges_rank) {
other.unite(dsus, neig, who_contain, *this);
} else {
for (auto ch : dsus[other_r].child) {
dsus[r].child.push_back(ch);
dsus[ch].root = r;
}
dsus[r].edges_rank += dsus[other_r].edges_rank;
for (auto who : who_contain[other_r]) {
who_contain[r].insert(who);
}
}
}
};
struct solver {
void solve(int n, int m, int c, int q) {
vector<pseudo_dsu> dsus;
for (int i = 0; i < n; i++) {
pseudo_dsu pd;
pd.root = i;
pd.number = i;
pd.child.push_back(i);
pd.edges_rank = 0;
dsus.push_back(pd);
}
vector<map<int, vector<int>>> neig(n);
vector<set<int>> who_contain(n);
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
neig[a][c].push_back(b);
neig[b][c].push_back(a);
dsus[a].edges_rank++;
dsus[b].edges_rank++;
dsus[a].neig_dsus.insert(b);
dsus[b].neig_dsus.insert(a);
who_contain[a].insert(b);
who_contain[b].insert(a);
}
for (int i = 0; i < n; i++) {
for (auto &it : neig[i]) {
vector<int> &vec = it.second;
for (int z = 1; z < vec.size(); z++) {
int one = vec[z - 1];
int two = vec[z];
dsus[one].unite(dsus, neig, who_contain, dsus[two]);
}
}
}
for (int i = 0; i < q; i++) {
string s;
cin >> s;
if (s == "+") {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
vector<int> &neig1 = neig[a][c];
if (!neig1.empty()) {
dsus[neig1.back()].unite(dsus, neig, who_contain, dsus[b]);
}
neig1.push_back(b);
vector<int> &neig2 = neig[b][c];
if (!neig2.empty()) {
dsus[neig2.back()].unite(dsus, neig, who_contain, dsus[a]);
}
neig2.push_back(a);
who_contain[dsus[a].root].insert(b);
who_contain[dsus[b].root].insert(a);
} else {
int a, b;
cin >> a >> b;
a--;
b--;
if (dsus[a].root == dsus[b].root) {
cout << "Yes" << endl;
} else {
bool found = who_contain[dsus[a].root].count(b);
if (found) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
}
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, c, q;
while (cin >> n >> m >> c >> q) {
solver s;
s.solve(n, m, c, q);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int i, n, m, c, Q, f[100005], x, y, col;
map<int, vector<int>> mp[100005];
set<int> d[100005];
int find(int x) { return (f[x] == x) ? x : f[x] = find(f[x]); }
void merge(int x, int y) {
int fx = find(x), fy = find(y);
if (fx != fy) {
if (d[fx].size() < d[fy].size()) swap(x, y), swap(fx, fy);
for (auto i : d[fy]) d[fx].insert(i), f[fy] = fx;
}
}
void add() {
scanf("%d %d %d", &x, &y, &col);
int fx = find(x), fy = find(y);
d[fx].insert(y), d[fy].insert(x);
mp[x][col].push_back(y), merge(y, mp[x][col][0]);
mp[y][col].push_back(x), merge(x, mp[y][col][0]);
}
int main() {
scanf("%d %d %d %d", &n, &m, &c, &Q);
for (i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++) add();
while (Q--) {
char opt;
scanf(" %c", &opt);
if (opt == '?') {
int x, y;
scanf("%d %d", &x, &y);
int fx = find(x), fy = find(y);
printf("%s\n", (fx == fy || d[fx].count(y)) ? "Yes" : "No");
} else
add();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct bian {
int to, nxt, va;
} bi[400040];
int n, m, c, q, head[100010], num, tot, f[100010], siz[100010];
vector<int> E[100010];
unordered_map<int, int> mp[100010], color[100010];
void add(int from, int to, int va) {
bi[++num].nxt = head[from];
head[from] = num;
bi[num].to = to;
bi[num].va = va;
}
int find(int x) {
if (x != f[x]) return f[x] = find(f[x]);
return x;
}
void merge(int x, int y) {
if (siz[x] > siz[y]) swap(x, y);
siz[y] += siz[x], f[x] = y;
for (auto u : E[x]) {
E[y].push_back(u);
for (int i = head[u]; i; i = bi[i].nxt) mp[bi[i].to][y] = 1;
}
E[x].clear();
}
int main() {
scanf("%d %d %d %d", &n, &m, &c, &q);
int x, y, z;
for (int i = 1; i <= n; ++i) siz[i] = 1, f[i] = i, E[i].push_back(i);
for (int i = 1; i <= m; ++i) {
scanf("%d %d %d", &x, &y, &z);
mp[x][find(y)] = 1;
mp[y][find(x)] = 1;
add(x, y, z), add(y, x, z);
if (color[x].count(z)) {
if (find(color[x][z]) != find(y)) merge(find(color[x][z]), find(y));
} else
color[x][z] = y;
swap(x, y);
if (color[x].count(z)) {
if (find(color[x][z]) != find(y)) merge(find(color[x][z]), find(y));
} else
color[x][z] = y;
}
char op;
for (int i = 1; i <= q; ++i) {
scanf(" %c", &op);
if (op == '+') {
scanf("%d %d %d", &x, &y, &z);
mp[x][find(y)] = 1;
mp[y][find(x)] = 1;
add(x, y, z), add(y, x, z);
if (color[x].count(z)) {
if (find(color[x][z]) != find(y)) merge(find(color[x][z]), find(y));
} else
color[x][z] = y;
swap(x, y);
if (color[x].count(z)) {
if (find(color[x][z]) != find(y)) merge(find(color[x][z]), find(y));
} else
color[x][z] = y;
} else {
scanf("%d %d", &x, &y);
if (find(x) == find(y) || mp[y][find(x)])
printf("Yes\n");
else
printf("No\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 1e5 + 5;
set<int> adj[N];
set<pair<int, int>> col[N];
int p[N];
int findPar(int x) {
if (p[x] == x) return x;
return p[x] = findPar(p[x]);
}
void connect(int a, int b) {
int pa = findPar(a);
int pb = findPar(b);
if (pa == pb) return;
if (adj[pa].size() < adj[pb].size()) swap(pa, pb);
for (auto i : adj[pb]) {
adj[pa].insert(i);
}
adj[pb].clear();
p[pb] = pa;
}
void merge(int a, int b, int c) {
adj[findPar(a)].insert(b);
auto it = col[b].lower_bound({c, -1});
if (it == col[b].end() || it->first != c) {
col[b].insert({c, a});
} else {
connect(a, it->second);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, c, q;
cin >> n >> m >> c >> q;
for (int i = 1; i <= n; i++) {
p[i] = i;
}
for (int i = 0; i < m; i++) {
int x, y, c;
cin >> x >> y >> c;
merge(x, y, c);
merge(y, x, c);
}
for (int i = 0; i < q; i++) {
char v;
cin >> v;
if (v == '+') {
int x, y, c;
cin >> x >> y >> c;
merge(x, y, c);
merge(y, x, c);
} else {
int x, y;
cin >> x >> y;
if (findPar(x) == findPar(y) ||
adj[findPar(x)].find(y) != adj[findPar(x)].end()) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
set<int> st[N];
map<int, int> mp[N];
int n, m, q, fa[N];
inline int find(int x) {
while (x != fa[x]) x = fa[x] = fa[fa[x]];
return x;
}
inline void merge(int x, int y) {
int u = find(x), v = find(y);
if (u == v) return;
if (st[u].size() < st[v].size()) u ^= v ^= u ^= v;
fa[v] = u;
for (int i : st[v]) st[u].insert(i);
st[v].clear();
}
inline void addedge(int u, int v, int c) {
st[find(u)].insert(v);
if (mp[u].count(c)) {
int x = mp[u][c];
merge(v, x);
} else
mp[u][c] = v;
}
int main() {
scanf("%d%d%*d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i) fa[i] = i;
while (m--) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
addedge(u, v, c), addedge(v, u, c);
}
while (q--) {
char op[3];
int u, v, c;
scanf("%s%d%d", op, &u, &v);
if (*op == '+') {
scanf("%d", &c);
addedge(u, v, c), addedge(v, u, c);
} else {
int x = find(u), y = find(v);
if (x == y || st[x].count(v))
puts("Yes");
else
puts("No");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
int par[MAXN];
map<int, int> edge[MAXN];
set<int> kel[MAXN];
inline int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
inline void join(int a, int b) {
int x = find(a), y = find(b);
if (x == y) return;
if (kel[x].size() > kel[y].size()) {
kel[x].swap(kel[y]);
swap(x, y);
}
par[x] = y;
for (int isi : kel[x]) {
if (find(isi) == y) continue;
kel[y].insert(isi);
}
kel[x].clear();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, c, q, u, v, w;
char op;
cin >> n >> m >> c >> q;
for (int i = 1; i <= n; i++) {
par[i] = i;
}
for (int i = 1; i <= m; i++) {
cin >> u >> v >> w;
kel[find(u)].insert(v);
kel[find(v)].insert(u);
if (edge[u].count(w)) {
join(v, edge[u][w]);
} else
edge[u][w] = v;
;
if (edge[v].count(w)) {
join(u, edge[v][w]);
} else
edge[v][w] = u;
}
while (q--) {
cin >> op >> u >> v;
if (op == '+') {
cin >> w;
kel[find(u)].insert(v);
kel[find(v)].insert(u);
if (edge[u].count(w)) {
join(v, edge[u][w]);
} else
edge[u][w] = v;
if (edge[v].count(w)) {
join(u, edge[v][w]);
} else
edge[v][w] = u;
} else {
if (find(u) == find(v))
cout << "Yes\n";
else {
if (kel[find(u)].count(v))
cout << "Yes\n";
else
cout << "No\n";
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<pair<int, int> > adj[N];
map<int, int> col[N];
set<int> nodes[N];
int n, m, c, q, par[N];
int Find(int x) { return par[x] == x ? x : par[x] = Find(par[x]); }
void Merge(int u, int v) {
u = Find(u);
v = Find(v);
if (u == v) return;
if (nodes[u].size() > nodes[v].size()) swap(u, v);
for (auto x : nodes[u]) nodes[v].insert(x);
par[u] = v;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> c >> q;
for (int i = 1; i <= n; i++) nodes[i].insert(i), par[i] = i;
for (int i = 0; i < m; i++) {
int u, v, color;
cin >> u >> v >> color;
adj[u].push_back({v, color});
adj[v].push_back({u, color});
nodes[u].insert(v);
nodes[v].insert(u);
}
for (int i = 1; i <= n; i++) {
for (auto x : adj[i])
if (col[i].find(x.second) == col[i].end())
col[i][x.second] = x.first;
else
Merge(col[i][x.second], x.first);
}
while (q--) {
char c;
cin >> c;
if (c == '+') {
int u, v, color;
cin >> u >> v >> color;
nodes[Find(u)].insert(v);
nodes[Find(v)].insert(u);
for (int i = 0; i < 2; i++, swap(u, v))
if (col[u].find(color) == col[u].end())
col[u][color] = v;
else
Merge(col[u][color], v);
} else {
int u, v;
cin >> u >> v;
puts(nodes[Find(u)].count(v) ? "Yes" : "No");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) {
if (a == 0 || b == 0) return a + b;
return a * (b / gcd(a, b));
}
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
int ddx[] = {-1, -2, 1, -2, 2, -1, 2, 1}, ddy[] = {-2, -1, -2, 1, -1, 2, 1, 2};
int f[100001];
map<int, int> col[100001];
set<int> adj[100001];
int n, m, c, q;
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
void merge(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (adj[x].size() > adj[y].size()) swap(x, y);
f[x] = y;
while (!adj[x].empty()) {
adj[y].insert(*adj[x].begin());
adj[x].erase(adj[x].begin());
}
}
void add(int x, int y, int z) {
if (col[x].count(z))
merge(y, col[x][z]);
else
col[x][z] = y;
if (col[y].count(z))
merge(x, col[y][z]);
else
col[y][z] = x;
adj[find(x)].insert(y);
adj[find(y)].insert(x);
}
int main() {
scanf("%d%d%d%d", &n, &m, &c, &q);
for (int(i) = (1); (i) <= (n); (i) += (1)) f[i] = i;
while (m--) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
}
while (q--) {
char c;
int x, y, z;
scanf(" %c%d%d", &c, &x, &y);
if (c == '+') {
scanf("%d", &z);
add(x, y, z);
} else {
if (find(x) == find(y) || adj[find(x)].find(y) != adj[find(x)].end())
puts("Yes");
else
puts("No");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct DSU {
int N;
vector<int> component, weight;
DSU(int n) {
N = n;
component.resize(n + 1);
weight.resize(n + 1);
for (int i = 0; i <= N; i++) {
component[i] = i;
weight[i] = 1;
}
}
int root(int first) {
while (component[first] != first) {
component[first] = component[component[first]];
first = component[first];
}
return first;
}
int merge(int first, int second) {
int val = 0;
if (same(first, second)) return 0;
first = root(first);
second = root(second);
if (weight[first] < weight[second]) {
swap(first, second);
val = 1;
}
weight[first] += weight[second];
component[second] = first;
return val;
}
bool same(int first, int second) { return root(first) == root(second); }
};
const int maxn = 1e5 + 4;
int n, mm, c, q;
set<int> s[maxn];
map<int, int> m[maxn];
DSU d(maxn);
vector<int> adjlist[maxn];
void connect(int first, int second, int color) {
int xpar = d.root(first), ypar = d.root(second);
adjlist[xpar].push_back(second);
adjlist[ypar].push_back(first);
s[second].insert(xpar);
s[first].insert(ypar);
if (m[first][color] != 0) {
int neighbor = m[first][color];
int npar = d.root(neighbor);
if (npar != ypar) {
int op = d.merge(npar, ypar);
if (op) swap(npar, ypar);
for (auto u : adjlist[ypar]) {
adjlist[npar].push_back(u);
s[u].erase(ypar);
s[u].insert(npar);
}
}
}
m[first][color] = second;
xpar = d.root(first);
ypar = d.root(second);
if (m[second][color] != 0) {
int neighbor = m[second][color];
int npar = d.root(neighbor);
if (npar != xpar) {
int op = d.merge(npar, xpar);
if (op) swap(npar, xpar);
for (auto u : adjlist[xpar]) {
adjlist[npar].push_back(u);
s[u].erase(xpar);
s[u].insert(npar);
}
}
}
m[second][color] = first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n >> mm >> c >> q;
for (int i = 1; i <= n; i++) s[i].insert(i);
for (int i = 1; i <= mm; i++) {
int first, second, w;
cin >> first >> second >> w;
connect(first, second, w);
}
while (q--) {
char t;
int first, second;
cin >> t >> first >> second;
if (t == '?') {
if (d.same(first, second) ||
s[second].find(d.root(first)) != s[second].end())
cout << "Yes\n";
else
cout << "No\n";
} else {
int col;
cin >> col;
connect(first, second, col);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100007;
vector<int> grp[MAXN];
int pr[MAXN];
set<int> neighbors[MAXN];
vector<pair<int, int> > edg[MAXN];
void unite(int u, int v) {
u = pr[u];
v = pr[v];
if (u == v) return;
if (grp[u].size() < grp[v].size()) swap(u, v);
for (int x : grp[v]) {
pr[x] = u;
grp[u].push_back(x);
for (pair<int, int> pr : edg[x]) {
neighbors[pr.first].erase(v);
neighbors[pr.first].insert(u);
}
}
grp[v].clear();
}
map<int, int> first[MAXN];
void fixcolor(int u, int v, int c) {
if (first[u].find(c) == first[u].end()) first[u][c] = v;
unite(v, first[u][c]);
}
void addEdge(int u, int v, int c) {
edg[u].emplace_back(v, c);
edg[v].emplace_back(u, c);
neighbors[u].insert(pr[v]);
neighbors[v].insert(pr[u]);
fixcolor(u, v, c);
fixcolor(v, u, c);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, c, q;
cin >> n >> m >> c >> q;
for (int i = 1; i <= n; i++) {
pr[i] = i;
grp[i].push_back(i);
}
while (m--) {
int u, v, c;
cin >> u >> v >> c;
addEdge(u, v, c);
}
while (q--) {
char op;
int u, v;
cin >> op >> u >> v;
if (op == '+') {
int c;
cin >> c;
addEdge(u, v, c);
} else {
bool flag = false;
if (pr[u] == pr[v]) {
flag = true;
} else if (neighbors[v].find(pr[u]) != neighbors[v].end()) {
flag = true;
}
cout << (flag ? "Yes" : "No") << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, c, q, fa[N], siz[N];
set<int> s[N];
map<int, vector<int> > mp[N];
inline int read() {
int f = 1, x = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
inline int findfa(int x) {
if (fa[x] != x) fa[x] = findfa(fa[x]);
return fa[x];
}
inline void unionn(int x, int y) {
x = findfa(x), y = findfa(y);
if (x != y) {
if (siz[x] < siz[y]) swap(x, y);
for (auto i : s[y]) s[x].insert(i);
fa[y] = x, siz[x] += siz[y];
}
}
inline void add() {
int x = read(), y = read(), z = read();
s[findfa(x)].insert(y), s[findfa(y)].insert(x);
if (mp[x][z].size()) unionn(y, mp[x][z][0]);
if (mp[y][z].size()) unionn(x, mp[y][z][0]);
mp[x][z].push_back(y), mp[y][z].push_back(x);
}
inline void query() {
int x = read(), y = read();
if (findfa(x) == findfa(y) || s[findfa(x)].count(y))
printf("Yes\n");
else
printf("No\n");
return;
}
int main() {
n = read(), m = read(), c = read(), q = read();
for (int i = (1), iend = (n); i <= iend; i++) fa[i] = i, siz[i] = 1;
for (int i = (1), iend = (m); i <= iend; i++) add();
for (int i = (1), iend = (q); i <= iend; i++) {
char ch;
scanf("%c", &ch);
if (ch == '+')
add();
else
query();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, C, q, fa[N];
char ch;
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
map<int, int> mp[N], can[N];
map<int, int>::iterator it;
void merge(int x, int y) {
if (x != y) {
if (can[x].size() > can[y].size()) swap(x, y);
fa[x] = y;
for (it = can[x].begin(); it != can[x].end(); it++)
can[y][it->first] = can[y][it->first] | it->second;
}
}
void add(int x, int y, int c) {
if (mp[y][c]) merge(find(x), find(mp[y][c]));
if (mp[x][c]) merge(find(y), find(mp[x][c]));
mp[x][c] = y, mp[y][c] = x;
can[find(x)][y] = can[find(y)][x] = 1;
}
int main() {
cin >> n >> m >> C >> q;
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= n; i++) can[i][i] = 1;
for (int i = 1, x, y, c; i <= m; i++) {
cin >> x >> y >> c;
add(x, y, c);
}
for (int i = 1, x, y, c; i <= q; i++) {
cin >> ch;
if (ch == '?') {
cin >> x >> y;
if (!can[find(x)].count(y))
cout << "No\n";
else
cout << "Yes\n";
} else {
cin >> x >> y >> c;
add(x, y, c);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
size_t n, m, c, q;
cin >> n >> m >> c >> q;
vector<map<size_t, size_t>> adj(++n);
vector<size_t> fa(n);
iota(fa.begin(), fa.end(), 0);
vector<set<size_t>> last(n);
for (size_t i = 0; i != n; ++i) last[i].emplace(i);
auto find = [&](const size_t& x) {
size_t f = -1;
vector<size_t> stack(1, x);
while (!stack.empty()) {
if (fa[stack.back()] == stack.back()) {
f = stack.back();
stack.pop_back();
} else {
if (~f) {
fa[stack.back()] = f;
stack.pop_back();
} else {
stack.emplace_back(fa[stack.back()]);
}
}
}
return f;
};
auto merge = [&](size_t x, size_t y) {
x = find(x);
y = find(y);
if (x != y) {
if (last[x].size() < last[y].size()) swap(x, y);
last[x].insert(last[y].begin(), last[y].end());
for (auto ite1 = last[x].begin(), ite2 = last[y].begin();
ite2 != last[y].end(); ++ite2)
ite1 = last[x].emplace_hint(ite1, *ite2);
last[y].clear();
fa[y] = x;
}
};
auto link = [&]() {
size_t x, y, z;
cin >> x >> y >> z;
auto ite = adj[x].find(z);
if (ite != adj[x].end()) merge(y, ite->second);
ite = adj[y].find(z);
if (ite != adj[y].end()) merge(x, ite->second);
adj[x][z] = y;
adj[y][z] = x;
last[find(x)].emplace(y);
last[find(y)].emplace(x);
};
auto query = [&]() {
size_t x, y;
cin >> x >> y;
x = find(x);
cout << (last[x].find(y) != last[x].end() ? "Yes" : "No") << '\n';
};
while (m--) link();
while (q--) {
char op;
cin >> op;
if (op == '+')
link();
else
query();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, c, q;
vector<int> e[100007];
int F[100007];
int Find(int x) { return F[x] == x ? x : F[x] = Find(F[x]); }
set<int> S[100007], s[100007];
int idx;
map<int, int> id[100007];
int a[100007 * 4], b[100007 * 4], f[100007 * 4], g[100007 * 4];
int find(int x) {
if (f[x] == x) return x;
int fx = find(f[x]);
g[x] ^= g[f[x]];
return f[x] = fx;
}
void join(int x, int y) {
int fx = Find(x), fy = Find(y);
if (fx == fy) return;
if (S[fx].size() > S[fy].size()) swap(fx, fy);
F[fx] = fy;
for (auto u : S[fx]) {
S[fy].insert(u);
for (int v : e[u]) s[v].erase(fx), s[v].insert(fy);
}
}
void add(int x, int y, int z) {
if (id[z].find(x) == id[z].end()) {
id[z][x] = ++idx;
a[idx] = x, b[idx] = 0;
g[f[idx] = idx] = 0;
}
if (id[z].find(y) == id[z].end()) {
id[z][y] = ++idx;
a[idx] = y, b[idx] = 0;
g[f[idx] = idx] = 0;
}
int zx = id[z][x], zy = id[z][y];
int fzx = find(zx), fzy = find(zy);
if (fzx != fzy) {
f[fzx] = fzy, g[fzx] = g[zx] ^ g[zy] ^ 1;
if (!b[fzy]) b[fzy] = a[g[zy] ? zy : zx];
if (!g[fzx]) {
join(a[fzx], a[fzy]);
if (b[fzx]) join(b[fzx], b[fzy]);
} else {
join(a[fzx], b[fzy]);
if (b[fzx]) join(b[fzx], a[fzy]);
}
} else if (g[zx] ^ g[zy] ^ 1)
join(b[fzx], a[fzx]);
e[x].push_back(y), s[x].insert(Find(y));
e[y].push_back(x), s[y].insert(Find(x));
}
int main() {
scanf("%d%d%d%d", &n, &m, &c, &q);
for (int i = 1; i <= n; ++i) F[i] = i, S[i].insert(i);
while (m--) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
}
while (q--) {
char o = getchar();
while (o != '+' && o != '?') o = getchar();
int x, y, z;
if (o == '+') {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
} else {
scanf("%d%d", &x, &y);
if (Find(x) == Find(y) || s[y].find(Find(x)) != s[y].end())
puts("Yes");
else
puts("No");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cc, q, up[100001];
char type, tmp;
set<int> s[100001];
map<int, int> c[100001];
int union_find(int u) {
if (up[u] == u) {
return u;
}
return up[u] = union_find(up[u]);
}
void union_merge(int u, int v) {
int par_u = union_find(u), par_v = union_find(v);
if (par_u == par_v) {
return;
}
if (s[par_u].size() < s[par_v].size()) {
swap(s[par_u], s[par_v]);
}
for (auto x : s[par_v]) {
s[par_u].insert(x);
}
up[par_v] = par_u;
}
signed main() {
scanf("%d %d %d %d", &n, &m, &cc, &q);
for (int i = 1; i <= n; i++) {
up[i] = i;
}
for (int i = 1, x, y, z; i <= m + q; i++) {
if (i > m) {
tmp = getchar();
scanf("%c", &type);
}
if (type == '+' || i <= m) {
scanf("%d %d %d", &x, &y, &z);
if (c[y].count(z)) {
int k = c[y][z];
union_merge(x, k);
}
if (c[x].count(z)) {
int k = c[x][z];
union_merge(y, k);
}
s[union_find(x)].insert(y);
s[union_find(y)].insert(x);
c[x][z] = y;
c[y][z] = x;
} else if (type == '?') {
scanf("%d %d", &x, &y);
if (s[union_find(x)].count(y) || union_find(x) == union_find(y)) {
puts("Yes");
} else {
puts("No");
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > g[100005];
multiset<int> son[100005];
int parent[100005];
vector<int> spis[100005];
int find_parent(int v) {
if (parent[v] == v) return v;
return parent[v] = find_parent(parent[v]);
}
void unions(int a, int b) {
a = find_parent(a), b = find_parent(b);
if (a != b) {
if ((int)spis[a].size() < (int)spis[b].size()) swap(a, b);
parent[b] = a;
for (int i = 0; i < (int)spis[b].size(); i++) {
int v = spis[b][i];
spis[a].push_back(v);
for (auto it = g[v].begin(); it != g[v].end(); it++) {
pair<int, int> A = *it;
son[A.second].erase(son[A.second].find(b));
son[A.second].insert(a);
}
}
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, col, quer;
cin >> n >> m >> col >> quer;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
g[u].insert(make_pair(w, v)), g[v].insert(make_pair(w, u));
}
for (int i = 1; i <= n; i++) parent[i] = i, spis[i].push_back(i);
for (int i = 1; i <= n; i++) {
for (auto it = g[i].begin(); it != g[i].end(); it++) {
pair<int, int> A = *it;
son[A.second].insert(i);
}
}
for (int i = 1; i <= n; i++) {
for (auto it = g[i].begin(); it != g[i].end(); it++) {
auto its = it;
its++;
if (its == g[i].end()) break;
pair<int, int> A = *it, B = *its;
if (A.first == B.first) unions(A.second, B.second);
}
}
for (int rep = 1; rep <= quer; rep++) {
char c;
cin >> c;
if (c == '+') {
int u, v, w;
cin >> u >> v >> w;
g[u].insert(make_pair(w, v)), g[v].insert(make_pair(w, u));
son[u].insert(find_parent(v)), son[v].insert(find_parent(u));
auto it = g[u].find(make_pair(w, v));
it++;
if (it != g[u].end() && w == (*it).first) unions(v, (*it).second);
it--;
if (it != g[u].begin()) {
it--;
if (w == (*it).first) unions(v, (*it).second);
}
it = g[v].find(make_pair(w, u));
it++;
if (it != g[v].end() && w == (*it).first) unions(u, (*it).second);
it--;
if (it != g[v].begin()) {
it--;
if (w == (*it).first) unions(u, (*it).second);
}
} else {
int u, v;
cin >> u >> v;
int a = find_parent(u), b = find_parent(v);
if (a == b || son[v].find(a) != son[v].end())
cout << "Yes\n";
else
cout << "No\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, c, q;
int r[100100];
vector<int> child[100100];
map<int, vector<int>> g[100100];
set<int> s[100100];
void inp() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> c >> q;
}
int get(int u) { return u == r[u] ? u : r[u] = get(r[u]); }
void _union_(int u, int v) {
int ru = get(u), rv = get(v);
if (ru == rv) return;
if (r[ru] > r[rv]) swap(ru, rv);
r[rv] = ru;
for (int x : child[rv]) {
for (auto p : g[x])
for (auto a : p.second) {
s[a].erase(rv);
s[a].insert(ru);
}
child[ru].push_back(x);
}
child[rv].clear();
}
void sub() {
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
g[u][w].push_back(v);
g[v][w].push_back(u);
}
for (int i = 1; i <= n; i++) r[i] = i;
for (int i = 1; i <= n; i++) child[i].push_back(i);
for (int i = 1; i <= n; i++)
for (auto p : g[i])
for (auto a : p.second) s[i].insert(a);
for (int i = 1; i <= n; i++)
for (auto p : g[i])
for (int j = 1; j < p.second.size(); j++)
_union_(p.second[j], p.second[j - 1]);
for (int i = 1; i <= q; i++) {
char tv;
cin >> tv;
if (tv == '+') {
int u, v, w;
cin >> u >> v >> w;
g[u][w].push_back(v);
g[v][w].push_back(u);
s[u].insert(get(v));
s[v].insert(get(u));
if (g[u][w].size() > 1) _union_(g[u][w][g[u][w].size() - 2], v);
if (g[v][w].size() > 1) _union_(g[v][w][g[v][w].size() - 2], u);
} else {
int u, v;
cin >> u >> v;
if (get(u) == get(v))
cout << "Yes\n";
else if (s[v].find(get(u)) != s[v].end())
cout << "Yes\n";
else
cout << "No\n";
}
}
}
int main() {
inp();
sub();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, SQ = 400;
int n, m, c, q;
vector<int> adj[N];
int uni[N];
set<int> cmp[N];
map<int, int> col[N];
vector<int> big;
int uni_find(int x) { return uni[x] = (uni[x] == x ? x : uni_find(uni[x])); }
void unio(int x, int y) {
x = uni_find(x);
y = uni_find(y);
if (x == y) return;
uni[x] = y;
for (int i : big) {
if (cmp[i].find(x) != cmp[i].end()) {
cmp[i].erase(x);
cmp[i].insert(y);
}
}
}
void makebig(int x) {
big.push_back(x);
cmp[x].clear();
for (int i : adj[x]) cmp[x].insert(uni_find(i));
}
void addedge(int x, int y, int c) {
adj[x].push_back(y);
int &r = col[x][c];
if (r)
unio(y, r);
else
r = uni_find(y);
cmp[x].insert(uni_find(r));
if (adj[x].size() == SQ) makebig(x);
}
int okbig(int x, int y) {
x = uni_find(x);
return cmp[y].find(x) != cmp[y].end();
}
int oksmall(int x, int y) {
x = uni_find(x);
for (int i : adj[y]) {
if (uni_find(i) == x) return 1;
}
return 0;
}
int main() {
scanf("%d %d %d %d", &n, &m, &c, &q);
iota(uni + 1, uni + n + 1, 1);
while (m--) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
addedge(a, b, c);
addedge(b, a, c);
}
while (q--) {
char t;
int x, y;
scanf(" %c %d %d", &t, &x, &y);
if (t == '?') {
int ok = uni_find(x) == uni_find(y);
if (adj[y].size() >= SQ)
ok |= okbig(x, y);
else
ok |= oksmall(x, y);
puts(ok ? "Yes" : "No");
} else {
int z;
scanf("%d", &z);
addedge(x, y, z);
addedge(y, x, z);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int c[maxn];
set<int> ver[maxn], adj[maxn];
map<int, int> last[maxn];
void add(int cmp, int v) { adj[cmp].insert(v); }
void merge(int v, int u) {
if (c[v] == c[u]) return;
if (ver[c[v]].size() + adj[c[v]].size() > ver[c[u]].size() + adj[c[u]].size())
swap(v, u);
int tmp = c[v];
for (auto it : ver[c[v]]) {
ver[c[u]].insert(it);
c[it] = c[u];
if (adj[c[u]].find(it) != adj[c[u]].end()) adj[c[u]].erase(it);
}
ver[tmp].clear();
for (auto it : adj[tmp])
if (ver[c[u]].find(it) == ver[c[u]].end()) adj[c[u]].insert(it);
adj[tmp].clear();
}
int main() {
ios_base::sync_with_stdio(false);
int n, m, C, q;
cin >> n >> m >> C >> q;
for (int v = 1; v <= n; v++) {
c[v] = v;
ver[c[v]].insert(v);
}
for (int i = 0; i < m; i++) {
int v, u, x;
cin >> v >> u >> x;
if (last[v].count(x)) merge(u, last[v][x]);
if (last[u].count(x)) merge(v, last[u][x]);
add(c[v], u);
add(c[u], v);
last[v][x] = u;
last[u][x] = v;
}
while (q--) {
char type;
cin >> type;
if (type == '?') {
int x, y;
cin >> x >> y;
if (ver[c[x]].find(y) != ver[c[x]].end() or
adj[c[x]].find(y) != adj[c[x]].end())
cout << "Yes\n";
else
cout << "No\n";
} else {
int v, u, x;
cin >> v >> u >> x;
if (last[v].count(x)) merge(u, last[v][x]);
if (last[u].count(x)) merge(v, last[u][x]);
add(c[v], u);
add(c[u], v);
last[v][x] = u;
last[u][x] = v;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
map<int, int> num[N];
int nm[N];
int n, m, c, q;
struct Quer {
bool add;
int u, v, c;
};
vector<int> a[N];
int par[N];
set<int> ms[N];
int root(int u) {
if (u == par[u])
return u;
else
return par[u] = root(par[u]);
}
void merge(int u, int v) {
u = root(u);
v = root(v);
if (u == v) return;
if (ms[v].size() < ms[u].size()) swap(u, v);
for (int e : ms[u]) ms[v].insert(e);
ms[u].clear();
par[u] = v;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> c >> q;
vector<Quer> d;
for (int i = 0; i < m; ++i) {
int u, v, c;
cin >> u >> v >> c;
a[u].push_back(c);
a[v].push_back(c);
d.push_back({1, u, v, c});
}
for (int i = 0; i < q; ++i) {
char t;
cin >> t;
if (t == '+') {
int u, v, c;
cin >> u >> v >> c;
a[u].push_back(c);
a[v].push_back(c);
d.push_back({1, u, v, c});
} else {
int u, v;
cin >> u >> v;
d.push_back({0, u, v});
}
}
int ptr = 0;
for (int i = 1; i <= n; ++i) {
ms[ptr] = {i};
nm[i] = ptr++;
sort(a[i].begin(), a[i].end());
a[i].resize(unique(a[i].begin(), a[i].end()) - a[i].begin());
for (int e : a[i]) {
ms[ptr] = {i};
num[i][e] = ptr++;
}
}
for (int i = 0; i < ptr; ++i) {
par[i] = i;
}
for (auto e : d) {
if (e.add) {
merge(nm[e.u], num[e.v][e.c]);
merge(num[e.u][e.c], nm[e.v]);
} else {
int r = root(nm[e.u]);
if (ms[r].find(e.v) != ms[r].end())
cout << "Yes\n";
else
cout << "No\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ipair = pair<int, int>;
using int64 = int64_t;
using uint64 = uint64_t;
template <typename T>
void remin(T& a, const T& b) {
if (b < a) {
a = b;
}
}
template <typename T>
void remax(T& a, const T& b) {
if (b > a) {
a = b;
}
}
template <class T1, class T2>
inline istream& operator>>(istream& s, pair<T1, T2>& p) {
return s >> p.first >> p.second;
}
template <class T1, class T2>
inline ostream& operator<<(ostream& s, const pair<T1, T2>& p) {
return s << "(" << p.first << " " << p.second << ")";
}
template <class T1>
inline ostream& operator<<(ostream& s, const set<T1>& container) {
for (const auto& x : container) {
s << x << ' ';
}
return s;
}
template <class T1>
inline ostream& operator<<(ostream& s, const vector<T1>& container) {
for (const auto& x : container) {
s << x << ' ';
}
return s;
}
template <class T1>
inline istream& operator>>(istream& s, vector<T1>& container) {
for (auto& x : container) {
s >> x;
}
return s;
}
template <class T>
inline T euclide(T a, T b, T& x, T& y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline T gcd(T a, T b) {
while (b > 0) {
T tmp = a;
a = a % b;
b = tmp;
}
return a;
}
template <class T>
inline vector<pair<T, int>> factorize(T n) {
vector<pair<T, int>> R;
for (T i = 2; n > 1;) {
if (n % i == 0) {
int C = 0;
for (; n % i == 0; C++, n /= i)
;
R.push_back(make_pair(i, C));
}
i++;
if (i > n / i) i = n;
}
if (n > 1) R.push_back(make_pair(n, 1));
return R;
}
template <class T>
inline bool isPrimeNumber(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
vector<bool> gen_primes(int limit) {
vector<bool> is_prime(limit + 1, true);
is_prime[0] = false;
is_prime[1] = false;
for (int i = 2; i * i <= limit; i += 1) {
if (is_prime[i]) {
for (int j = i + i; j <= limit; j += i) {
is_prime[j] = false;
}
}
}
return is_prime;
}
template <int64_t P>
struct TZp {
static_assert(P > 1, "P should be > 1");
static_assert(numeric_limits<int64_t>::max() / P >= P,
"P * P should be less then 2^63");
int64_t Value = 0;
TZp(int64_t val = 0) : Value(val) {}
TZp& operator+=(const TZp& other) {
Value = (Value + other.Value) % P;
return *this;
}
TZp& operator-=(const TZp& other) {
Value = (Value - other.Value + P) % P;
return *this;
}
TZp& operator*=(const TZp& other) {
Value = (Value * other.Value) % P;
return *this;
}
TZp Inverse() const {
int64_t x, y;
euclide(Value, P, x, y);
return x;
}
TZp& operator/=(const TZp& other) {
Value = (Value * other.Inverse().Value) % P;
return *this;
}
TZp operator-() const { return TZp((P - Value) % P); }
TZp operator+(const TZp& other) const {
TZp result(Value);
result += other;
return result;
}
TZp operator-(const TZp& other) const {
TZp result(Value);
result -= other;
return result;
}
TZp operator*(const TZp& other) const {
TZp result(Value);
result *= other;
return result;
}
TZp operator/(const TZp& other) const {
TZp result(Value);
result /= other;
return result;
}
int64_t ToInt() const { return Value; }
};
template <class T>
struct TPlus {
using Type = T;
const static T Neutral;
T operator()(const T& x, const T& y) const { return x + y; }
T WithAdd(const T& original, const T& add, size_t n) const {
return original + add * n;
}
};
template <class T>
const T TPlus<T>::Neutral = 0;
template <class T>
struct TMax {
using Type = T;
static const T Neutral;
T operator()(const T& x, const T& y) const { return max(x, y); }
T WithAdd(const T& original, const T& add, size_t) const {
return original + add;
}
};
template <class T>
T const TMax<T>::Neutral = numeric_limits<T>::min();
template <class T>
struct TMin {
using Type = T;
static const T Neutral;
T operator()(const T& x, const T& y) const { return min(x, y); }
T WithAdd(const T& original, const T& add, size_t) const {
return original + add;
}
};
template <class T>
T const TMin<T>::Neutral = numeric_limits<T>::max();
template <class TF>
struct TSegmentTree {
using T = typename TF::Type;
size_t N = 0;
TF Func;
vector<T> Data;
TSegmentTree(size_t n, const T& x = T(0), const TF& f = TF())
: N(n), Func(f), Data(N * 2, x) {}
void Set(size_t i, const T& x) {
i += N;
Data[i] = x;
for (i /= 2; i > 0; i /= 2) {
Data[i] = Func(Data[i * 2], Data[i * 2 + 1]);
}
}
T Get(size_t left, size_t right) const {
if (left >= right) {
return TF::Neutral;
}
auto result = TF::Neutral;
for (left += N, right += N; left < right; left /= 2, right /= 2) {
if (left % 2) {
result = Func(result, Data[left]);
++left;
}
if (right % 2) {
--right;
result = Func(result, Data[right]);
}
}
return result;
}
const T& operator[](size_t i) const { return Data[i + N]; }
};
template <class TF>
struct TSegmentTreeIntervalAdd : public TSegmentTree<TF> {
using TParent = TSegmentTree<TF>;
using T = typename TParent::T;
using TParent::Data;
using TParent::Func;
using TParent::N;
vector<T> Add_;
vector<size_t> ChildrenCount;
void PropagateDownOne(size_t n) {
if (n * 2 < Add_.size()) {
Add_[n * 2] += Add_[n];
if (n * 2 + 1 < Add_.size()) {
Add_[n * 2 + 1] += Add_[n];
}
}
Data[n] = Func.WithAdd(Data[n], Add_[n], ChildrenCount[n]);
Add_[n] = 0;
}
void PropagateDown(size_t n) {
if (n == 0) {
return;
}
PropagateDown(n / 2);
PropagateDownOne(n);
}
void PropagateUp(size_t n, const T& x) {
if (n == 0) {
return;
}
auto v = Func.WithAdd(Data[n], x, ChildrenCount[n]);
Data[n / 2] = Func(Data[n ^ 1], v);
for (size_t i = n / 2; i > 1; i /= 2) {
Data[i / 2] = Func(Data[i], Data[i ^ 1]);
}
}
TSegmentTreeIntervalAdd(size_t n, const T& x = T(0), const TF& f = TF())
: TParent(n, x, f), Add_(2 * n, T(0)), ChildrenCount(2 * n, 0) {
std::fill(ChildrenCount.begin() + N, ChildrenCount.end(), 1);
for (size_t i = 2 * N - 1; i > 0; --i) {
ChildrenCount[i / 2] += ChildrenCount[i];
}
}
T Get(size_t left, size_t right) {
if (left >= right) {
return TF::Neutral;
}
PropagateDown((left + N) / 2);
PropagateDown((right + N - 1) / 2);
auto result = TF::Neutral;
for (left += N, right += N; left < right; left /= 2, right /= 2) {
if (left % 2) {
PropagateDownOne(left);
result = Func(result, Data[left]);
++left;
}
if (right % 2) {
--right;
PropagateDownOne(right);
result = Func(result, Data[right]);
}
}
return result;
}
void Add(size_t left, size_t right, const T& x) {
for (left += N, right += N; left < right; left /= 2, right /= 2) {
if (left % 2) {
Add_[left] += x;
PropagateUp(left, x);
++left;
}
if (right % 2) {
--right;
Add_[right] += x;
PropagateUp(right, x);
}
}
}
};
template <class T>
struct TDisjointIntervalSet : public set<pair<T, T>> {
using TParent = set<pair<T, T>>;
void Insert(T left, T right) {
if (right <= left) {
return;
}
auto it = TParent::upper_bound(make_pair(right, numeric_limits<T>::max()));
auto it1 = it;
while (it != TParent::begin()) {
--it;
if (it->second >= left) {
remin(left, it->first);
remax(right, it->second);
} else {
++it;
break;
}
}
TParent::erase(it, it1);
TParent::emplace(left, right);
}
void Remove(T left, T right) {
if (right <= left) {
return;
}
auto it = TParent::upper_bound(make_pair(right, numeric_limits<T>::max()));
auto it1 = it;
T l = left;
T r = right;
while (it != TParent::begin()) {
--it;
if (it->second >= left) {
remin(l, it->first);
remax(r, it->second);
} else {
++it;
break;
}
}
TParent::erase(it, it1);
if (l < left) {
TParent::emplace(l, left);
}
if (r > right) {
TParent::emplace(right, r);
}
}
};
struct TDSU {
vector<size_t> Parents;
vector<unordered_set<int>> SingleHops;
TDSU(size_t n) : Parents(n), SingleHops(n) {
iota(Parents.begin(), Parents.end(), 0);
}
size_t Get(size_t x) {
if (Parents[x] != x) {
Parents[x] = Get(Parents[x]);
}
return Parents[x];
}
void Unite(size_t x, size_t y) {
x = Get(x);
y = Get(y);
if (x == y) {
return;
}
if (SingleHops[x].size() > SingleHops[y].size()) {
std::swap(x, y);
}
Parents[x] = y;
SingleHops[y].insert(SingleHops[x].begin(), SingleHops[x].end());
SingleHops[x].clear();
}
};
int main(void) {
std::ios::sync_with_stdio(false);
int n, m, c, q;
cin >> n >> m >> c >> q;
vector<unordered_map<int, vector<int>>> roads(n);
for (int i = 0; i < m; ++i) {
int x, y, z;
cin >> x >> y >> z;
--x;
--y;
--z;
roads[x][z].push_back(y);
roads[y][z].push_back(x);
}
TDSU dsu(n);
for (int i = 0; i < n; ++i) {
for (auto& rs : roads[i]) {
for (auto x : rs.second) {
dsu.SingleHops[dsu.Get(i)].insert(x);
}
for (size_t j = 1; j < rs.second.size(); ++j) {
dsu.Unite(rs.second[0], rs.second[j]);
}
}
}
for (int i = 0; i < q; ++i) {
char s;
cin >> s;
if (s == '+') {
int x, y, z;
cin >> x >> y >> z;
--x;
--y;
--z;
dsu.SingleHops[dsu.Get(x)].insert(y);
dsu.SingleHops[dsu.Get(y)].insert(x);
{
auto it = roads[x].find(z);
if (it != roads[x].end()) {
dsu.Unite(it->second[0], y);
}
}
{
auto it = roads[y].find(z);
if (it != roads[y].end()) {
dsu.Unite(it->second[0], x);
}
}
roads[x][z].push_back(y);
roads[y][z].push_back(x);
} else {
int x, y;
cin >> x >> y;
--x;
--y;
if (dsu.Get(x) == dsu.Get(y) || dsu.SingleHops[dsu.Get(x)].count(y)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int maxN = (int)1e5 + 100;
set<int> adj[maxN];
int p[maxN];
int n;
set<pair<int, int> > byClr[maxN];
int m;
int c, q;
int get(int a) {
if (a == p[a]) return a;
p[a] = get(p[a]);
return p[a];
}
void unite(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return;
if (adj[a].size() < adj[b].size()) swap(a, b);
for (int v : adj[b]) adj[a].insert(v);
adj[b].clear();
p[b] = a;
}
void add(int a, int b, int clr) {
adj[get(a)].insert(b);
auto it = byClr[b].lower_bound(make_pair(clr, -1));
if (it == byClr[b].end() || (it->first != clr)) {
byClr[b].insert(make_pair(clr, a));
} else {
unite(a, (it->second));
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> c >> q;
for (int i = 1; i <= n; i++) {
p[i] = i;
}
for (int i = 1; i <= m; i++) {
int a, b, cc;
cin >> a >> b >> cc;
add(a, b, cc);
add(b, a, cc);
}
for (int i = 1; i <= q; i++) {
char tp;
cin >> tp;
if (tp == '+') {
int x, y, z;
cin >> x >> y >> z;
add(x, y, z);
add(y, x, z);
} else {
int x, y;
cin >> x >> y;
if (get(x) == get(y)) {
cout << "Yes" << '\n';
} else if (adj[get(x)].find(y) != adj[get(x)].end()) {
cout << "Yes" << '\n';
} else {
cout << "No" << '\n';
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005;
int n, m, c, q, p[MX], x, y, z;
char op;
map<int, int> mp[MX];
set<int> st[MX];
int parent(int a) { return a == p[a] ? a : p[a] = parent(p[a]); }
void join(int a, int b) {
a = parent(a), b = parent(b);
if (a == b) return;
if (st[a].size() < st[b].size()) swap(a, b);
for (int x : st[b]) st[a].insert(x);
st[b].clear();
p[b] = a;
}
bool same(int a, int b) { return parent(a) == parent(b); }
void add() {
if (!mp[x].count(z))
mp[x][z] = y;
else
join(mp[x][z], y);
if (!mp[y].count(z))
mp[y][z] = x;
else
join(mp[y][z], x);
st[parent(x)].insert(y);
st[parent(y)].insert(x);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
iota(p, p + MX, 0);
cin >> n >> m >> c >> q;
while (m--) {
cin >> x >> y >> z;
add();
}
while (q--) {
cin >> op >> x >> y;
if (op == '+') {
cin >> z;
add();
} else {
if (same(x, y))
cout << "Yes" << '\n';
else if (st[parent(x)].count(y))
cout << "Yes" << '\n';
else
cout << "No" << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
const int maxn = 200200;
const int mod = 998244353;
inline long long pow(long long a, int b, int ans = 1) {
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) ans = ans * a % mod;
return ans;
}
inline long long inverse(int x) { return pow(x, mod - 2); }
std::set<int> s0[maxn], s1[maxn];
int fa[maxn];
int n, m, c, q;
inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
std::map<int, std::vector<int>> G[maxn];
inline void merge(int x, int y) {
x = find(x), y = find(y);
if (x != y) {
if (s0[x].size() < s0[y].size()) std::swap(x, y);
s0[x].insert(s0[y].begin(), s0[y].end()), s0[y].clear();
s1[x].insert(s1[y].begin(), s1[y].end()), s1[y].clear();
fa[y] = x;
}
}
inline void add(int x, int y, int z) {
std::map<int, std::vector<int>>& mp = G[z];
if (mp.count(x)) merge(mp[x].back(), y);
if (mp.count(y)) merge(mp[y].back(), x);
mp[x].push_back(y);
mp[y].push_back(x);
s1[find(x)].insert(y);
s1[find(y)].insert(x);
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m >> c >> q;
for (int i = (1), iend = (n); i <= iend; ++i) {
fa[i] = i;
s0[i] = s1[i] = {i};
}
for (int i = (1), iend = (m); i <= iend; ++i) {
int x, y, z;
cin >> x >> y >> z;
add(x, y, z);
}
for (int i = (1), iend = (q); i <= iend; ++i) {
char opt;
int x, y, z;
cin >> opt;
if (opt == '+') {
cin >> x >> y >> z;
add(x, y, z);
} else {
cin >> x >> y;
cout << (s1[find(x)].count(y) ? "Yes" : "No") << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, C, Q, f[100021], size[100021];
set<int> st[100021];
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
void unio(int a, int b) {
a = find(a), b = find(b);
if (a == b) return;
if (size[a] > size[b]) swap(a, b);
f[a] = b;
size[b] += size[a];
st[b].insert(st[a].begin(), st[a].end());
st[a].clear();
}
map<int, int> g[100021];
void make(int a, int b, int c) {
if (g[c][b]) {
unio(a, g[c][b]);
}
g[c][b] = a;
if (g[c][a]) {
unio(b, g[c][a]);
}
g[c][a] = b;
st[find(a)].insert(b);
st[find(b)].insert(a);
}
int main() {
scanf("%d%d%d%d", &n, &m, &C, &Q);
for (int i = 1; i <= n; i++) f[i] = i, size[i] = 1;
for (int a, b, c, i = 1; i <= m; i++) {
scanf("%d%d%d", &a, &b, &c);
make(a, b, c);
}
char s[5];
int a, b, c;
while (Q--) {
scanf("%s", s);
if (s[0] == '?') {
scanf("%d%d", &a, &b);
if (find(a) == find(b) || st[find(a)].count(b))
puts("Yes");
else
puts("No");
} else {
scanf("%d%d%d", &a, &b, &c);
make(a, b, c);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
vector<set<int>> Gpars(MAX);
vector<set<pair<int, int>>> Gcols(MAX);
vector<vector<int>> G(MAX);
vector<vector<int>> classes(MAX);
vector<int> par(MAX);
void merge(int a, int b) {
int x = par[a], y = par[b];
if (x == y) return;
if (classes[x].size() > classes[y].size()) swap(x, y);
while (!classes[x].empty()) {
int cur = classes[x].back();
classes[x].pop_back();
classes[y].push_back(cur);
par[cur] = y;
for (int negh : G[cur]) {
Gpars[negh].insert(y);
}
}
}
void add_edge(int u, int v, int col) {
G[u].push_back(v);
G[v].push_back(u);
Gpars[v].insert(par[u]);
Gpars[u].insert(par[v]);
auto itv = Gcols[v].lower_bound(make_pair(col, 0));
if (itv == Gcols[v].end() || (*itv).first != col) {
Gcols[v].insert({col, u});
} else {
merge(u, (*itv).second);
}
auto itu = Gcols[u].lower_bound(make_pair(col, 0));
if (itu == Gcols[u].end() || (*itu).first != col) {
Gcols[u].insert({col, v});
} else {
merge(v, (*itu).second);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, c, q;
cin >> n >> m >> c >> q;
for (int i = 0; i < n; i++) {
par[i] = i;
classes[i].push_back(i);
}
for (int i = 0; i < m; i++) {
int x, y, z;
cin >> x >> y >> z;
x--, y--;
add_edge(x, y, z);
}
while (q--) {
char cr;
cin >> cr;
if (cr == '+') {
int x, y, z;
cin >> x >> y >> z;
x--, y--;
add_edge(x, y, z);
} else {
int x, y;
cin >> x >> y;
x--, y--;
int a = par[x], b = par[y];
int ok = 0;
if (a == b) ok = 1;
if (Gpars[y].find(a) != Gpars[y].end()) ok = 1;
if (ok)
cout << "Yes\n";
else
cout << "No\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, c, q;
int f[N];
char op[5];
set<int> s[N];
map<int, vector<int> > mp[N];
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x != y) {
int sx = s[x].size(), sy = s[y].size();
if (sx > sy) swap(x, y);
f[x] = y;
set<int>::iterator it;
for (it = s[x].begin(); it != s[x].end(); it++) {
s[y].insert(*it);
}
}
}
void add() {
int x, y, col;
scanf("%d%d%d", &x, &y, &col);
s[find(x)].insert(y);
s[find(y)].insert(x);
mp[x][col].push_back(y);
unite(y, mp[x][col][0]);
mp[y][col].push_back(x);
unite(x, mp[y][col][0]);
}
int main() {
scanf("%d%d%d%d", &n, &m, &c, &q);
for (int i = 1; i <= n; i++) f[i] = i;
while (m--) add();
while (q--) {
scanf("%s", op);
if (op[0] == '+')
add();
else {
int x, y;
scanf("%d%d", &x, &y);
if (find(x) == find(y) || s[find(x)].count(y) > 0)
puts("Yes");
else
puts("No");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
int n, m, c, Q, fa[N], tot;
char ch[5];
set<int> s[N];
map<int, int> mp[N];
int getfa(int x) { return x == fa[x] ? x : fa[x] = getfa(fa[x]); }
int id(int x, int y) {
if (mp[x].count(y)) return mp[x][y];
return mp[x][y] = ++tot;
}
void merge(int x, int y) {
x = getfa(x), y = getfa(y);
if (x == y) return;
if (s[x].size() > s[y].size()) swap(x, y);
fa[x] = y;
for (auto i : s[x]) s[y].insert(i);
s[x].clear();
}
void adde(int x, int y, int z) {
s[getfa(id(x, 0))].insert(id(y, 0));
s[getfa(id(y, 0))].insert(id(x, 0));
merge(id(x, 0), id(y, z)), merge(id(y, 0), id(x, z));
}
int main() {
for (int i = (1); i <= (N - 1); i++) fa[i] = i;
scanf("%d%d%d%d", &n, &m, &c, &Q);
for (int i = (1); i <= (m); i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z), adde(x, y, z);
}
for (int i = (1); i <= (Q); i++) {
int x, y, z;
scanf("%s%d%d", ch, &x, &y);
if (ch[0] == '+')
scanf("%d", &z), adde(x, y, z);
else
puts((getfa(id(x, 0)) == getfa(id(y, 0)) ||
s[getfa(id(x, 0))].count(id(y, 0)))
? "Yes"
: "No");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e5) + 10;
int n, m, c, q;
map<int, int> edge_colored[N];
int root[N];
vector<int> component[N];
vector<int> adj[N];
map<int, int> adj_roots[N];
void merge(int u, int v) {
u = root[u];
v = root[v];
if (u == v) return;
if (component[u].size() > component[v].size()) swap(u, v);
for (int elem : component[u]) {
root[elem] = v;
for (int to : adj[elem]) adj_roots[to][root[elem]] = 1;
}
copy(component[u].begin(), component[u].end(), back_inserter(component[v]));
component[u].clear();
}
void addEdge(int u, int v, int color) {
adj[u].push_back(v);
adj[v].push_back(u);
adj_roots[u][root[v]] = 1;
adj_roots[v][root[u]] = 1;
if (edge_colored[u].find(color) != edge_colored[u].end())
merge(v, edge_colored[u][color]);
else
edge_colored[u][color] = v;
if (edge_colored[v].find(color) != edge_colored[v].end())
merge(u, edge_colored[v][color]);
else
edge_colored[v][color] = u;
}
int main() {
scanf("%d %d %d %d", &n, &m, &c, &q);
for (int i = 1; i <= n; i++) {
root[i] = i;
component[i].push_back(i);
adj[i].push_back(i);
adj_roots[i][i] = 1;
}
for (int i = 1; i <= m; i++) {
int u, v, color;
scanf("%d %d %d", &u, &v, &color);
addEdge(u, v, color);
}
for (int i = 1; i <= q; i++) {
char type;
scanf(" %c", &type);
if (type == '+') {
int u, v, color;
scanf("%d %d %d", &u, &v, &color);
addEdge(u, v, color);
} else {
int u, v;
scanf("%d %d", &u, &v);
if (adj_roots[v].find(root[u]) != adj_roots[v].end())
puts("Yes");
else
puts("No");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
inline int read() {
int sum = 0, fg = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') fg = -1;
for (; isdigit(c); c = getchar()) sum = (sum << 3) + (sum << 1) + (c ^ 0x30);
return fg * sum;
}
const int maxn = 1e5 + 10;
set<int> S[maxn];
map<pair<int, int>, int> M;
namespace DSU {
int fa[maxn];
inline void init(int N) {
for (int i = 1; i <= N; i++) fa[i] = i;
}
inline int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
inline void merge(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (S[x].size() < S[y].size()) swap(x, y);
fa[y] = x;
S[x].insert(S[y].begin(), S[y].end());
}
} // namespace DSU
int n, m, c, q;
inline void Add(int x, int y, int z) {
S[DSU::find(x)].insert(y);
if (M[make_pair(x, z)])
DSU::merge(M[make_pair(x, z)], y);
else
M[make_pair(x, z)] = y;
}
inline bool query(int x, int y) {
x = DSU::find(x);
set<int>::iterator res = S[x].lower_bound(y);
if (res != S[x].end() && *res == y) return 1;
return 0;
}
int main() {
n = read(), m = read(), c = read(), q = read();
DSU::init(n);
for (int i = 1; i <= n; i++) S[i].insert(i);
for (int i = 1; i <= m; i++) {
int x = read(), y = read(), z = read();
Add(x, y, z), Add(y, x, z);
}
for (int i = 1; i <= q; i++) {
char ch = getchar();
if (ch == '+') {
int x = read(), y = read(), z = read();
Add(x, y, z), Add(y, x, z);
} else {
int x = read(), y = read();
printf(query(x, y) ? "Yes\n" : "No\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> col;
set<int> AdjList[100001];
int p[100001];
int anc(int x) {
if (p[x] == x) return x;
return p[x] = anc(p[x]);
}
void join(int x, int y) { p[anc(x)] = anc(y); }
struct Query {
int type, u, v, c;
Query() {}
Query(int _type, int _u, int _v, int _c) {
type = _type;
u = _u;
v = _v;
c = _c;
}
};
vector<Query> Q;
int n;
int m, C, q;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> C >> q;
for (int i = 1; i <= m; i++) {
int u, v, c;
cin >> u >> v >> c;
Q.push_back(Query(0, u, v, c));
}
for (int i = 1; i <= q; i++) {
char z;
cin >> z;
if (z == '+') {
int u, v, c;
cin >> u >> v >> c;
Q.push_back(Query(0, u, v, c));
} else {
int u, v;
cin >> u >> v;
Q.push_back(Query(1, u, v, -1));
}
}
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 0; i < Q.size(); i++) {
if (!Q[i].type) {
int u = Q[i].u;
int v = Q[i].v;
int c = Q[i].c;
int anc_u = anc(u);
int anc_v = anc(v);
AdjList[anc_u].insert(v);
AdjList[anc_v].insert(u);
if (!col[pair<int, int>(u, c)]) col[pair<int, int>(u, c)] = v;
if (!col[pair<int, int>(v, c)]) col[pair<int, int>(v, c)] = u;
int z = col[pair<int, int>(v, c)];
int anc_z = anc(z);
if (anc_u != anc_z) {
if (AdjList[anc_u].size() > AdjList[anc_z].size())
swap(AdjList[anc_u], AdjList[anc_z]);
while (!AdjList[anc_u].empty()) {
AdjList[anc_z].insert(*AdjList[anc_u].begin());
AdjList[anc_u].erase(AdjList[anc_u].begin());
}
p[anc_u] = anc_z;
}
z = col[pair<int, int>(u, c)];
anc_z = anc(z);
if (anc_v != anc_z) {
if (AdjList[anc_v].size() > AdjList[anc_z].size())
swap(AdjList[anc_v], AdjList[anc_z]);
while (!AdjList[anc_v].empty()) {
AdjList[anc_z].insert(*AdjList[anc_v].begin());
AdjList[anc_v].erase(AdjList[anc_v].begin());
}
p[anc_v] = anc_z;
}
} else {
int u = Q[i].u;
int v = Q[i].v;
int anc_u = anc(u);
int anc_v = anc(v);
if (anc_u == anc_v)
cout << "Yes" << '\n';
else if (AdjList[anc_u].find(v) != AdjList[anc_u].end())
cout << "Yes" << '\n';
else
cout << "No" << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, c, x, y, z, q, i, r1;
char tip;
int r[100005];
vector<int> v[100005], w[100005];
set<int> vs[100005];
set<pair<int, int> > s[100005];
set<int>::iterator it;
int rad(int x) {
while (r[x] > 0) {
x = r[x];
}
return x;
}
void adauga(int x, int y, int c) {
pair<int, int> p = make_pair(c, 0);
set<pair<int, int> >::iterator it = s[x].lower_bound(p);
vs[x].insert(rad(y));
if (it == s[x].end() || it->first != c) {
s[x].insert(make_pair(c, y));
} else {
int r1 = rad(y), r2 = rad(it->second);
if (r1 != r2) {
if (r[r1] > r[r2]) {
swap(r1, r2);
}
r[r1] += r[r2];
r[r2] = r1;
for (int i = 0; i < w[r2].size(); i++) {
int nod = w[r2][i];
w[r1].push_back(nod);
for (int j = 0; j < v[nod].size(); j++) {
vs[v[nod][j]].insert(r1);
}
}
}
}
}
int main() {
cin >> n >> m >> c >> q;
for (i = 1; i <= n; i++) {
r[i] = -1;
w[i].push_back(i);
}
for (i = 1; i <= m; i++) {
cin >> x >> y >> z;
v[x].push_back(y);
v[y].push_back(x);
adauga(x, y, z);
adauga(y, x, z);
}
for (i = 1; i <= q; i++) {
cin >> tip;
if (tip == '+') {
cin >> x >> y >> z;
v[x].push_back(y);
v[y].push_back(x);
adauga(x, y, z);
adauga(y, x, z);
continue;
}
cin >> x >> y;
r1 = rad(x);
it = vs[y].lower_bound(r1);
if (r1 == rad(y) || (it != vs[y].end() && *it == r1)) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
}
|
#include <bits/stdc++.h>
const int MAX_CITIES = 1e5;
int n, m, c, q;
int dsu[MAX_CITIES + 1] = {0};
std::set<int> adj[MAX_CITIES + 1];
std::map<int, int>* city_rainbows;
int getDsuRoot(int v) {
int root = v;
while (dsu[root] != 0) {
root = dsu[root];
}
while (v != root) {
int p = dsu[v];
dsu[v] = root;
v = p;
}
return root;
}
int mergeDsu(int x, int y) {
int rootx = getDsuRoot(x);
int rooty = getDsuRoot(y);
if (adj[rootx].size() < adj[rooty].size()) std::swap(rootx, rooty);
if (rootx != rooty) {
dsu[rooty] = rootx;
adj[rootx].insert(adj[rooty].begin(), adj[rooty].end());
adj[rooty].clear();
}
return rootx;
}
bool isReachable(int x, int y) {
bool ans = false;
int rootx = getDsuRoot(x), rooty = getDsuRoot(y);
if (rootx == rooty || adj[rootx].find(y) != adj[rootx].end()) ans = true;
return ans;
}
void addEdge(int x, int y, int z) {
std::map<int, int>&r1 = city_rainbows[x], &r2 = city_rainbows[y];
if (r1.find(z) == r1.end()) {
r1.emplace(std::make_pair(z, y));
} else {
mergeDsu(r1[z], y);
}
if (r2.find(z) == r2.end()) {
r2.emplace(std::make_pair(z, x));
} else {
mergeDsu(r2[z], x);
}
int rootx = getDsuRoot(x);
int rooty = getDsuRoot(y);
if (rootx != rooty) {
adj[rootx].insert(y);
adj[rooty].insert(x);
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &c, &q);
city_rainbows = new std::map<int, int>[n + 1];
for (int i = 0; i < m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
addEdge(x, y, z);
}
for (int i = 0; i < q; i++) {
char type;
int x, y, z;
std::cin >> type;
if (type == '+') {
scanf("%d%d%d", &x, &y, &z);
addEdge(x, y, z);
} else if (type == '?') {
scanf("%d%d", &x, &y);
if (isReachable(x, y)) {
printf("Yes\n");
} else {
printf("No\n");
}
}
}
delete[] city_rainbows;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, c, q, cnt;
int ata[500005];
set<int> s[500005];
map<pair<int, int>, int> mp;
int bul(int node) {
if (ata[node] == node) return node;
return ata[node] = bul(ata[node]);
}
void merge(int a, int b) {
if ((a = bul(a)) != (b = bul(b))) {
if (((int)s[a].size()) < ((int)s[b].size())) swap(a, b);
for (auto x : s[b]) s[a].insert(x);
s[b].clear();
ata[b] = a;
}
}
void nn(int a, int c) {
mp[{a, c}] = ++cnt;
ata[cnt] = cnt;
s[cnt].insert(a);
}
void add(int x, int y, int z) {
if (!mp[{x, z}]) nn(x, z);
if (!mp[{y, z}]) nn(y, z);
merge(x, mp[{y, z}]);
merge(y, mp[{x, z}]);
}
int main() {
scanf("%d %d %d %d", &n, &m, &c, &q);
for (int i = 1; i <= n; i++) ata[i] = ++cnt;
for (int i = 1; i <= m; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
add(x, y, z);
}
while (q--) {
char t;
scanf(" %c", &t);
if (t == '?') {
int x, y;
scanf("%d %d", &x, &y);
if (bul(x) == bul(y) || s[bul(x)].find(y) != s[bul(x)].end())
printf("Yes\n");
else
printf("No\n");
} else {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
add(x, y, z);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int nodes, initialRoads, totalColours, totalQueries;
const int NMAX = 100505;
struct query {
int from, to, colour;
bool addEdge;
};
vector<query> queries;
set<pair<int, int>> edges[NMAX];
set<int> reachable[NMAX];
vector<int> components[NMAX];
int whichComponent[NMAX];
void read() {
cin >> nodes >> initialRoads >> totalColours >> totalQueries;
queries.reserve(initialRoads + totalQueries);
int from, to, colour;
for (int roadIdx = 0; roadIdx < initialRoads; roadIdx++) {
cin >> from >> to >> colour;
queries.push_back({from, to, colour, true});
}
string type;
for (int queryIdx = 0; queryIdx < totalQueries; queryIdx++) {
cin >> type;
if (type == "?") {
cin >> from >> to;
queries.push_back({from, to, -1, false});
} else {
cin >> from >> to >> colour;
queries.push_back({from, to, colour, true});
}
}
}
void prepareStructs() {
for (int node = 1; node <= nodes; node++) {
components[node].push_back(node);
whichComponent[node] = node;
reachable[node].insert(whichComponent[node]);
}
}
void updateReachable(int from, int oldComponent, int newComponent) {
for (auto neighbour : edges[from]) {
reachable[neighbour.second].erase(oldComponent);
reachable[neighbour.second].insert(newComponent);
}
reachable[from].erase(oldComponent);
reachable[from].insert(newComponent);
}
void addEdgeInRainbowGraph(int from, int to) {
if (whichComponent[from] == whichComponent[to]) {
return;
}
int component1 = whichComponent[from], component2 = whichComponent[to];
if (components[component1].size() < components[component2].size()) {
for (auto node : components[component1]) {
updateReachable(node, component1, component2);
whichComponent[node] = component2;
}
components[component2].insert(components[component2].end(),
components[component1].begin(),
components[component1].end());
components[component1].clear();
} else {
for (auto node : components[component2]) {
updateReachable(node, component2, component1);
whichComponent[node] = component1;
}
components[component1].insert(components[component1].end(),
components[component2].begin(),
components[component2].end());
components[component2].clear();
}
}
int extractCandidateEdge(int from, int excludingNode, int colour) {
auto edge = edges[from].lower_bound({colour, -1});
if (edge != edges[from].end() && edge->second == excludingNode) {
edge++;
}
if (edge != edges[from].end() && edge->first != colour) {
return -1;
}
return edge != edges[from].end() ? edge->second : -1;
}
void addEdgesInRainbowGraph(int from, int to, int colour) {
int neighbourIntoFrom = extractCandidateEdge(from, to, colour);
if (neighbourIntoFrom != -1) {
addEdgeInRainbowGraph(neighbourIntoFrom, to);
}
int neighbourIntoTo = extractCandidateEdge(to, from, colour);
if (neighbourIntoTo != -1) {
addEdgeInRainbowGraph(neighbourIntoTo, from);
}
}
void addEdgeAndUpdateReachability(int from, int to, int colour) {
edges[from].insert({colour, to});
reachable[to].insert(whichComponent[from]);
}
void solve() {
for (query &currQuery : queries) {
if (currQuery.addEdge) {
addEdgeAndUpdateReachability(currQuery.from, currQuery.to,
currQuery.colour);
addEdgeAndUpdateReachability(currQuery.to, currQuery.from,
currQuery.colour);
addEdgesInRainbowGraph(currQuery.from, currQuery.to, currQuery.colour);
} else {
if (reachable[currQuery.to].find(whichComponent[currQuery.from]) ==
reachable[currQuery.to].end()) {
cout << "No\n";
} else {
cout << "Yes\n";
}
}
}
}
int main() {
read();
prepareStructs();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 500005, inf = 1000000005, mod = 1000000007;
const long long INF = 1000000000000000005LL;
struct query {
int a, b, c;
};
set<int> S[MN];
vector<int> gdzie[MN];
int rep[MN], ile[MN];
map<pair<int, int>, int> num;
query zap[MN];
int N;
int Find(int x) {
if (x == rep[x]) return x;
return (rep[x] = Find(rep[x]));
}
void Union(int a, int b) {
a = Find(a);
b = Find(b);
if (a == b) return;
if (ile[a] < ile[b]) swap(a, b);
for (auto v : gdzie[b]) {
S[v].erase(b);
S[v].insert(a);
gdzie[a].push_back(v);
}
ile[a] += ile[b];
rep[b] = a;
}
void add(int x, int y, int c) {
int u = num[{x, c}], v = num[{y, c}];
Union(x, v);
Union(u, y);
Union(y, u);
Union(v, x);
u = Find(x), v = Find(y);
S[x].insert(v);
S[y].insert(u);
gdzie[v].push_back(x);
gdzie[u].push_back(y);
}
bool ans(int x, int y) {
x = Find(x);
return (S[y].find(x) != S[y].end());
}
int main() {
int n, m, c, q;
scanf("%d%d%d%d", &n, &m, &c, &q);
N = n;
for (int i = 1; i <= m; ++i) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
num[{x, z}] = ++N;
num[{y, z}] = ++N;
zap[i] = {x, y, z};
}
for (int i = 1; i <= q; ++i) {
char typ[3];
int x, y, z;
scanf("%s", typ);
if (typ[0] == '+') {
scanf("%d%d%d", &x, &y, &z);
num[{x, z}] = ++N;
num[{y, z}] = ++N;
} else {
scanf("%d%d", &x, &y);
z = -1;
}
zap[i + m] = {x, y, z};
}
for (int i = 1; i <= N; ++i) {
ile[i] = 1;
rep[i] = i;
S[i].insert(i);
gdzie[i].push_back(i);
}
q += m;
for (int i = 1; i <= q; ++i)
if (zap[i].c == -1)
printf(ans(zap[i].a, zap[i].b) ? "Yes\n" : "No\n");
else
add(zap[i].a, zap[i].b, zap[i].c);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c, q;
cin >> n >> m >> c >> q;
vector<tuple<char, int, int, int>> query(m + q);
for (int i = 0; i < m; i++) {
int x, y, z;
cin >> x >> y >> z;
x--;
y--;
query[i] = make_tuple('+', x, y, z);
}
for (int i = m; i < m + q; i++) {
char c;
cin >> c;
if (c == '+') {
int x, y, z;
cin >> x >> y >> z;
x--;
y--;
query[i] = make_tuple('+', x, y, z);
}
if (c == '?') {
int x, y;
cin >> x >> y;
x--;
y--;
query[i] = make_tuple('?', x, y, -1);
}
}
vector<set<int>> co(n);
for (int i = 0; i < n; i++) {
co[i].insert(0);
}
for (int i = 0; i < m + q; i++) {
if (get<0>(query[i]) == '+') {
int x = get<1>(query[i]);
int y = get<2>(query[i]);
int z = get<3>(query[i]);
co[x].insert(z);
co[y].insert(z);
}
}
vector<pair<int, int>> t;
for (int i = 0; i < n; i++) {
for (int j : co[i]) {
t.push_back(make_pair(i, j));
}
}
int V = t.size();
vector<map<int, int>> id(n);
for (int i = 0; i < V; i++) {
id[t[i].first][t[i].second] = i;
}
vector<int> p(V);
vector<vector<int>> g(V);
vector<set<int>> st(V);
for (int i = 0; i < V; i++) {
p[i] = i;
g[i].push_back(i);
st[i].insert(t[i].first);
}
for (int i = 0; i < m + q; i++) {
char c = get<0>(query[i]);
if (c == '+') {
int x = get<1>(query[i]);
int y = get<2>(query[i]);
int z = get<3>(query[i]);
vector<int> u = {id[x][0], id[y][0]};
vector<int> v = {id[y][z], id[x][z]};
for (int j = 0; j < 2; j++) {
u[j] = p[u[j]];
v[j] = p[v[j]];
if (u[j] != v[j]) {
if (g[u[j]].size() > g[v[j]].size()) {
swap(u[j], v[j]);
}
for (int k : g[u[j]]) {
g[v[j]].push_back(k);
p[k] = v[j];
}
for (int k : st[u[j]]) {
st[v[j]].insert(k);
}
}
}
}
if (c == '?') {
int x = get<1>(query[i]);
int y = get<2>(query[i]);
int v = id[x][0];
v = p[v];
if (st[v].count(y)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > edges[100005];
set<int> cnt[100005];
map<int, int> color[100005];
vector<int> have[100005];
int pre[100005];
vector<int> chge;
int pset[100005];
int fs(int a) { return (a == pset[a]) ? a : pset[a] = fs(pset[a]); }
void update(int x, int y) {
for (auto p : have[x]) {
if (cnt[p].find(x) == cnt[p].end()) continue;
cnt[p].insert(y);
cnt[p].erase(x);
have[y].push_back(p);
}
}
void addedge(int x, int y, int z) {
if (color[x].find(z) != color[x].end()) {
int u = color[x][z];
if (fs(u) != fs(y)) {
if (have[fs(u)].size() > have[fs(y)].size()) swap(u, y);
update(fs(u), fs(y));
pset[fs(u)] = fs(y);
}
} else {
color[x][z] = y;
cnt[x].insert(fs(y));
have[fs(y)].push_back(x);
}
}
int main() {
int n, m, c, q;
scanf("%d %d %d %d", &n, &m, &c, &q);
for (int i = (1); i <= (n); i++) pset[i] = i;
for (int i = (1); i <= (m); i++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
edges[u].push_back({v, w});
edges[v].push_back({u, w});
addedge(u, v, w);
addedge(v, u, w);
}
for (int u = (1); u <= (n); u++) {
for (auto v : edges[u]) {
if (pre[v.second] && fs(pre[v.second]) != fs(v.first)) {
pset[fs(pre[v.second])] = fs(v.first);
}
pre[v.second] = v.first;
chge.push_back(v.second);
}
for (auto p : chge) pre[p] = 0;
chge.clear();
}
for (int u = (1); u <= (n); u++) {
for (auto v : edges[u]) {
cnt[u].insert(fs(v.first));
have[fs(v.first)].push_back(u);
color[u][v.second] = v.first;
}
}
for (int i = (1); i <= (q); i++) {
char c;
int x, y;
scanf(" %c %d %d", &c, &x, &y);
if (c == '+') {
int z;
scanf("%d", &z);
addedge(x, y, z);
addedge(y, x, z);
} else {
if (fs(x) == fs(y) || cnt[y].find(fs(x)) != cnt[y].end())
printf("Yes\n");
else
printf("No\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
t = 0;
char ch = getchar();
int f = 1;
while ('0' > ch || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
const int maxn = (1e5) + 10;
int n, m, c, q, fa[maxn];
map<int, int> fst[maxn];
set<int> s[maxn];
set<int>::iterator it;
char S[2];
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (s[x].size() > s[y].size()) swap(x, y);
for (it = s[x].begin(); it != s[x].end(); it++) s[y].insert(*it);
s[x].clear();
fa[x] = y;
}
void add(int x, int y, int z) {
if (fst[x][z])
merge(fst[x][z], y);
else
fst[x][z] = y;
if (fst[y][z])
merge(fst[y][z], x);
else
fst[y][z] = x;
s[find(x)].insert(y);
s[find(y)].insert(x);
}
int main() {
read(n);
read(m);
read(c);
read(q);
int x, y;
for (int i = 1; i <= n; i++) fa[i] = i, s[i].insert(i);
for (int i = 1; i <= m + q; i++) {
if (i <= m)
S[1] = '+';
else
scanf("%s", S + 1);
read(x);
read(y);
if (S[1] == '+')
read(c), add(x, y, c);
else {
if (find(x) == find(y) || s[find(x)].count(y))
printf("Yes\n");
else
printf("No\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
inline void readc(char &x) {
char c;
while ((c = getchar()) == ' ' || c == '\n')
;
x = c;
}
inline void writes(string s) { puts(s.c_str()); }
inline void writeln() { writes(""); }
inline void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
int n, m, c, q;
int i, j, blk = 1000;
int fa[100005], typ[100005], deg[100005];
char op[100005];
int px[100005], py[100005], pz[100005], qx[100005], qy[100005], qz[100005];
set<int> s[100005];
map<int, int> lst[100005];
vector<int> e[100005];
int fnd(int x) {
if (fa[x] == x) return x;
return fa[x] = fnd(fa[x]);
}
void mrg(int x, int y) {
x = fnd(x);
y = fnd(y);
if (x == y) return;
if (s[x].size() > s[y].size()) swap(x, y);
fa[x] = y;
for (__typeof((s[x]).begin()) it = (s[x]).begin(); it != (s[x]).end(); it++)
s[y].insert(*it);
s[x].clear();
}
void add(int x, int y, int z) {
if (lst[x].count(z)) mrg(lst[x][z], y);
if (lst[y].count(z)) mrg(lst[y][z], x);
if (typ[y] == 2) s[fnd(x)].insert(y);
if (typ[x] == 2) s[fnd(y)].insert(x);
lst[x][z] = y;
lst[y][z] = x;
e[x].push_back(y);
e[y].push_back(x);
}
int main() {
read(n);
read(m);
read(c);
read(q);
for (((i)) = (1); ((i)) <= ((m)); ((i))++) {
int x, y, z;
read(x);
read(y);
read(z);
qx[i] = x;
qy[i] = y;
qz[i] = z;
deg[x]++;
deg[y]++;
}
for (((i)) = (1); ((i)) <= ((q)); ((i))++) {
readc(op[i]);
if (op[i] == '+') {
read(px[i]);
read(py[i]);
read(pz[i]);
deg[px[i]]++;
deg[py[i]]++;
} else {
read(px[i]);
read(py[i]);
}
}
for (((i)) = (1); ((i)) <= ((n)); ((i))++)
if (deg[i] <= blk)
typ[i] = 1;
else
typ[i] = 2;
for (((i)) = (1); ((i)) <= ((n)); ((i))++)
if (typ[i] == 2) {
s[i].insert(i);
}
for (((i)) = (1); ((i)) <= ((n)); ((i))++) fa[i] = i;
for (((i)) = (1); ((i)) <= ((m)); ((i))++) add(qx[i], qy[i], qz[i]);
for (((i)) = (1); ((i)) <= ((q)); ((i))++) {
if (op[i] == '+')
add(px[i], py[i], pz[i]);
else {
if (typ[py[i]] == 1) {
if (fnd(px[i]) == fnd(py[i])) {
puts("Yes");
continue;
}
bool flg = 0;
for (__typeof((e[py[i]]).begin()) it = (e[py[i]]).begin();
it != (e[py[i]]).end(); it++)
if (fnd(px[i]) == fnd(*it)) {
puts("Yes");
flg = 1;
break;
}
if (!flg) puts("No");
} else {
if (s[fnd(px[i])].count(py[i])) {
puts("Yes");
} else {
puts("No");
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int pre[N], n, m;
int f(int x) { return pre[x] == x ? x : pre[x] = f(pre[x]); }
set<int> s[N];
map<int, vector<int> > v[N];
void join(int x, int y) {
x = f(x);
y = f(y);
if (x == y) return;
if (s[x].size() < s[y].size()) swap(x, y);
set<int>::iterator it = s[y].begin();
for (; it != s[y].end(); ++it) s[x].insert(*it);
pre[y] = x;
}
void add() {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
s[f(x)].insert(y);
s[f(y)].insert(x);
v[x][z].push_back(y);
join(y, v[x][z][0]);
v[y][z].push_back(x);
join(x, v[y][z][0]);
}
void query() {
int x, y;
scanf("%d %d", &x, &y);
if (f(x) == f(y) || s[f(x)].count(y))
printf("Yes\n");
else
printf("No\n");
}
signed main() {
char opt[10];
int c, q;
scanf("%d %d %d %d", &n, &m, &c, &q);
for (register int i = (1); i <= (n); ++i) pre[i] = i;
for (register int i = (1); i <= (m); ++i) add();
for (register int i = (1); i <= (q); ++i) {
scanf("%s", opt);
if (opt[0] == '+')
add();
else
query();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, c, q;
map<int, vector<int> > p[200100];
int per[200200];
set<int> st[200200];
int pr(int x) {
if (x == per[x]) return x;
return per[x] = pr(per[x]);
}
void merg(int x, int y) {
x = pr(x);
y = pr(y);
if (x == y) return;
if (st[x].size() < st[y].size()) swap(x, y);
for (set<int>::iterator it = st[y].begin(); it != st[y].end(); it++) {
st[x].insert(*it);
}
st[y].clear();
per[y] = x;
}
void add(int x, int y, int cl) {
vector<int>& z = p[x][cl];
while (!z.empty()) {
merg(y, z.back());
z.pop_back();
}
st[pr(x)].insert(y);
z.push_back(y);
}
int main() {
cin >> n >> m >> c >> q;
for (int i = 1; i <= n; i++) {
per[i] = i;
}
int x, y;
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &x, &y, &c);
add(x, y, c);
add(y, x, c);
}
char ch;
while (q--) {
scanf("\n%c%d%d", &ch, &x, &y);
if (ch == '+') {
scanf("%d", &c);
add(x, y, c);
add(y, x, c);
continue;
}
x = pr(x);
if (pr(x) == pr(y) || st[x].count(y)) {
printf("Yes\n");
} else {
printf("No\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, i0, n, m, c, q, pre[100005];
map<int, vector<int>> mp[100005];
set<int> dic[100005];
int fin(int x) { return (pre[x] == x) ? x : pre[x] = fin(pre[x]); }
void uni(int x, int y) {
if (fin(x) != fin(y)) {
if (dic[fin(x)].size() < dic[fin(y)].size()) swap(x, y);
for (auto i : dic[fin(y)]) dic[fin(x)].insert(i), pre[fin(y)] = fin(x);
}
}
void add() {
int x, y, col;
scanf("%d %d %d", &x, &y, &col);
dic[fin(x)].insert(y), dic[fin(y)].insert(x);
mp[x][col].push_back(y), uni(y, mp[x][col][0]);
mp[y][col].push_back(x), uni(x, mp[y][col][0]);
}
int main() {
scanf("%d %d %d %d", &n, &m, &c, &q);
for (i = 1; i <= n; i++) pre[i] = i;
while (m--) add();
while (q--) {
char op;
scanf(" %c", &op);
if (op == '?') {
int x, y;
scanf("%d %d", &x, &y);
printf("%s\n", (fin(x) == fin(y) || dic[fin(x)].count(y)) ? "Yes" : "No");
} else
add();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-O2")
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\t";
err(++it, args...);
}
template <typename T1, typename T2>
ostream& operator<<(ostream& c, pair<T1, T2>& v) {
c << "(" << v.first << "," << v.second << ")";
return c;
}
template <template <class...> class TT, class... T>
ostream& operator<<(ostream& out, TT<T...>& c) {
out << "{ ";
for (auto& x : c) out << x << " ";
out << "}";
return out;
}
const int LIM = 1e5 + 5, MOD = 1e9 + 7;
int t, n, m, k, x, y, w, c, q;
map<int, vector<int> > v[LIM];
set<int> e[LIM];
struct dsu {
vector<int> par, rk;
void reset(int n) {
rk.assign(n, 1);
par.resize(n);
iota(par.begin(), par.end(), 0);
for (int i = 0; i < n; ++i) e[i].insert(i);
}
int getpar(int i) { return (par[i] == i) ? i : (par[i] = getpar(par[i])); }
bool con(int i, int j) { return getpar(i) == getpar(j); }
bool join(int i, int j) {
i = getpar(i), j = getpar(j);
if (i == j) return 0;
if (rk[i] > rk[j]) {
par[j] = i;
rk[i] += rk[j];
for (auto& it : e[j]) e[i].insert(it);
e[j].clear();
} else {
par[i] = j;
rk[j] += rk[i];
for (auto& it : e[i]) e[j].insert(it);
e[i].clear();
}
return 1;
}
} d;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> c >> q;
d.reset(n);
for (int i = 0; i < m; ++i) {
cin >> x >> y >> w;
--x, --y;
v[x][w].push_back(y);
v[y][w].push_back(x);
e[d.getpar(x)].insert(y);
d.join(v[x][w][0], y);
e[d.getpar(y)].insert(x);
d.join(v[y][w][0], x);
}
char ch;
for (int i = 0; i < q; ++i) {
cin >> ch >> x >> y;
--x, --y;
if (ch == '?') {
bool ok = e[d.getpar(x)].find(y) != e[d.getpar(x)].end();
if (ok)
cout << "Yes\n";
else
cout << "No\n";
} else {
cin >> w;
v[x][w].push_back(y);
v[y][w].push_back(x);
e[d.getpar(x)].insert(y);
d.join(v[x][w][0], y);
e[d.getpar(y)].insert(x);
d.join(v[y][w][0], x);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
int n, m, c, Q, fa[N], tot;
char ch[5];
set<int> s[N];
map<int, int> mp[N];
int getfa(int x) { return x == fa[x] ? x : fa[x] = getfa(fa[x]); }
int id(int x, int y) {
if (mp[x].count(y)) return mp[x][y];
return mp[x][y] = ++tot;
}
void merge(int x, int y) {
x = getfa(x), y = getfa(y);
if (x == y) return;
if (s[x].size() > s[y].size()) swap(x, y);
fa[x] = y;
for (auto i : s[x]) s[y].insert(i);
s[x].clear();
}
void adde(int x, int y, int z) {
s[getfa(id(x, 0))].insert(id(y, 0));
s[getfa(id(y, 0))].insert(id(x, 0));
merge(id(x, 0), id(y, z)), merge(id(y, 0), id(x, z));
}
int main() {
for (int i = (1); i <= (N - 1); i++) fa[i] = i;
scanf("%d%d%d%d", &n, &m, &c, &Q);
for (int i = (1); i <= (m); i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z), adde(x, y, z);
}
for (int i = (1); i <= (Q); i++) {
int x, y, z;
scanf("%s%d%d", ch, &x, &y);
if (ch[0] == '+')
scanf("%d", &z), adde(x, y, z);
else
puts((getfa(id(x, 0)) == getfa(id(y, 0)) ||
s[getfa(id(x, 0))].count(id(y, 0)))
? "Yes"
: "No");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int w = 1, s = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') w = -1;
ch = getchar();
}
while (isdigit(ch)) {
s = s * 10 + ch - '0';
ch = getchar();
}
return w * s;
}
struct node {
int opt, u, v, c;
} e[1010100];
int n, m, c, q, fa[1010100], tot, du[1010100];
unordered_map<int, int> mp[101010];
inline int find(int x) {
if (x == fa[x])
return x;
else
return fa[x] = find(fa[x]);
}
int cnt;
map<pair<int, int>, int> Idx;
vector<int> vec[101000];
set<int> st[101010];
inline void Ins(int u, int v, int c) {
int x = find(u), y = find(v);
int o = Idx[make_pair(v, c)];
st[u].insert(v);
st[v].insert(u);
du[x]++;
du[y]++;
if (o) {
int nw = find(o);
if (nw == x)
;
else {
if (du[x] < du[nw]) swap(x, nw);
fa[nw] = x;
du[x] += du[nw];
for (register int i = 0; i < (vec[nw]).size(); ++i) {
vec[x].push_back(vec[nw][i]);
for (auto xx : st[vec[nw][i]]) {
mp[xx][x] = 1;
}
}
}
}
Idx[make_pair(v, c)] = x;
x = find(u);
y = find(v);
o = Idx[make_pair(u, c)];
if (o) {
int nw = find(o);
if (nw == y)
;
else {
if (du[y] < du[nw]) swap(y, nw);
fa[nw] = y;
du[y] += du[nw];
for (register int i = 0; i < (vec[nw]).size(); ++i) {
vec[y].push_back(vec[nw][i]);
for (auto xx : st[vec[nw][i]]) {
mp[xx][y] = 1;
}
}
}
}
Idx[make_pair(u, c)] = y;
mp[u][find(v)] = 1;
mp[v][find(u)] = 1;
}
inline void Solve() {
for (register int i = 1; i <= tot; ++i) {
int opt = e[i].opt, u = e[i].u, v = e[i].v, c = e[i].c;
if (opt == 1) {
Ins(u, v, c);
} else {
int x = find(u), y = find(v);
if (x == y) {
cout << "Yes\n";
} else if (mp[v][x])
cout << "Yes\n";
else
cout << "No\n";
}
}
}
int main() {
n = read(), m = read(), c = read(), q = read();
for (register int i = 1; i <= n; ++i) fa[i] = i, vec[i].push_back(i);
for (register int i = 1; i <= m; ++i) {
e[++tot].opt = 1;
e[tot].u = read();
e[tot].v = read();
e[tot].c = read();
}
for (register int i = 1; i <= q; ++i) {
char s[10];
scanf("%s", s + 1);
if (s[1] == '+')
e[++tot].opt = 1, e[tot].u = read(), e[tot].v = read(), e[tot].c = read();
else
e[++tot].opt = 2, e[tot].u = read(), e[tot].v = read();
}
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, c, q;
int fa[N];
set<int> s[N];
map<int, int> G[N];
int fd(int x) { return fa[x] == x ? x : fa[x] = fd(fa[x]); }
void merge(int x, int y) {
x = fd(x);
y = fd(y);
if (x == y) return;
if (s[x].size() < s[y].size()) swap(x, y);
fa[y] = x;
s[x].insert(s[y].begin(), s[y].end());
s[y].clear();
}
void add() {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
if (G[u][w])
merge(G[u][w], v);
else
G[u][w] = v;
if (G[v][w])
merge(G[v][w], u);
else
G[v][w] = u;
s[fd(u)].insert(v);
s[fd(v)].insert(u);
}
void query() {
int x, y;
scanf("%d%d", &x, &y);
puts(((fd(x) == fd(y)) || (s[fd(x)].count(y))) ? "Yes" : "No");
}
int main() {
scanf("%d%d%d%d", &n, &m, &c, &q);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) add();
for (int i = 1; i <= q; i++) {
char ch[10];
scanf("%s", ch);
if (ch[0] == '?')
query();
else
add();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
int n, m, q, totv, fa[maxn];
inline int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
map<int, int> V[maxn];
set<int> S[maxn];
inline void merge(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
if (S[a].size() < S[b].size()) swap(a, b);
for (set<int>::iterator it = S[b].begin(); it != S[b].end(); it++)
S[a].insert(*it);
S[b].clear();
fa[b] = a;
}
inline void Addedge(int a, int b, int c) {
if (V[a].count(c) == 0) V[a][c] = ++totv, fa[totv] = totv;
if (V[b].count(c) == 0) V[b][c] = ++totv, fa[totv] = totv;
S[find(a)].insert(b);
S[find(b)].insert(a);
merge(a, V[b][c]);
merge(b, V[a][c]);
}
inline int query(int a, int b) {
return find(a) == find(b) || S[find(a)].count(b);
}
int main() {
scanf("%d%d%*d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) fa[i] = i;
totv = n;
for (int i = 1, a, b, c; i <= m; i++)
scanf("%d%d%d", &a, &b, &c), Addedge(a, b, c);
char s[10];
int a, b, c;
while (q--) {
scanf("%s%d%d", s, &a, &b);
if (s[0] == '+')
scanf("%d", &c), Addedge(a, b, c);
else
puts(query(a, b) ? "Yes" : "No");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
node *p;
int r;
map<int, node *> adj;
set<node *> setadj;
node *uffind() {
if (!p) return this;
return p = p->uffind();
}
void ufunion(node *o) {
node *a = uffind(), *b = o->uffind();
if (a == b) return;
if (a->r > b->r) {
b->p = a;
a->setadj.insert(b->setadj.begin(), b->setadj.end());
b->setadj.clear();
} else if (b->r > a->r) {
a->p = b;
b->setadj.insert(a->setadj.begin(), a->setadj.end());
a->setadj.clear();
} else {
b->r++;
a->p = b;
b->setadj.insert(a->setadj.begin(), a->setadj.end());
a->setadj.clear();
}
}
};
const int MAXN = 1e5;
node nodes[MAXN];
int N, M, C, Q;
void addedge(int x, int y, int z) {
node *a = &nodes[x], *b = &nodes[y];
if (a->adj[z] != NULL)
b->ufunion(a->adj[z]);
else
a->adj[z] = b;
if (b->adj[z] != NULL)
a->ufunion(b->adj[z]);
else
b->adj[z] = a;
if (a->uffind() != b->uffind()) {
b->uffind()->setadj.insert(a);
a->uffind()->setadj.insert(b);
}
}
int main() {
scanf("%d%d%d%d", &N, &M, &C, &Q);
for (int i = 0; i < M; ++i) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
addedge(x - 1, y - 1, z);
}
char op;
for (int q = 0; q < Q; ++q) {
int x, y;
scanf(" %c%d%d", &op, &x, &y);
x--;
y--;
if (op == '+') {
int z;
scanf("%d", &z);
addedge(x, y, z);
} else if (op == '?') {
node *start = nodes[x].uffind();
bool path = nodes[y].uffind() == start ||
start->setadj.find(&nodes[y]) != start->setadj.end();
printf("%s\n", path ? "Yes" : "No");
} else {
assert(false);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
set<int> s[maxn];
set<int>::iterator it1;
set<pair<int, int> > edge[maxn];
set<pair<int, int> >::iterator it;
int f[maxn];
int get(int x) {
if (x == f[x]) return x;
return f[x] = get(f[x]);
}
void merge(int x, int y) {
int x1 = get(x), y1 = get(y);
if (x1 == y1) return;
if (s[x1].size() < s[y1].size()) swap(x1, y1);
for (it1 = s[y1].begin(); it1 != s[y1].end(); it1++) {
s[x1].insert(*it1);
}
s[y1].clear();
f[y1] = x1;
}
void add(int x, int y, int z) {
s[get(x)].insert(y);
it = edge[x].lower_bound(make_pair(z, -1));
if (it == edge[x].end() || it->first != z) {
edge[x].insert(make_pair(z, y));
} else {
merge(it->second, y);
}
}
int main() {
int x, y, z, n, m, c, T;
char op[5];
scanf("%d%d%d%d", &n, &m, &c, &T);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
add(y, x, z);
}
while (T--) {
scanf("%s", op + 1);
if (op[1] == '+') {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
add(y, x, z);
} else {
scanf("%d%d", &x, &y);
if (get(x) == get(y)) {
printf("Yes\n");
} else if (s[get(x)].find(y) != s[get(x)].end()) {
printf("Yes\n");
} else {
printf("No\n");
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
inline bool read(T &x) {
int second = getchar();
int sgn = 1;
while (~second && second < '0' || second > '9') {
if (second == '-') sgn = -1;
second = getchar();
}
for (x = 0; ~second && '0' <= second && second <= '9'; second = getchar())
x = x * 10 + second - '0';
x *= sgn;
return ~second;
}
const int INF = 2000000009;
const int MX = 100005;
const double EPS = 1e-9;
const int MOD = 1000000007;
vector<pair<int, int> > g[MX];
int par[MX];
set<int> st[MX];
set<pair<int, int> > s[MX];
void init() {
for (int i = 0; i < MX; i++) {
par[i] = i;
}
}
int findParent(int x) { return x == par[x] ? x : par[x] = findParent(par[x]); }
void Union(int u, int v) {
u = findParent(u);
v = findParent(v);
if (u == v) return;
if ((int)st[u].size() < (int)st[v].size()) swap(u, v);
par[v] = u;
for (int p : st[v]) st[u].insert(p);
}
void addEdge(int u, int v, int second) {
st[findParent(u)].insert(v);
st[findParent(v)].insert(u);
set<pair<int, int> >::iterator it;
it = s[v].upper_bound(pair<int, int>(second - 1, INF));
if (it != s[v].end() && it->first == second) {
Union(u, it->second);
} else
s[v].insert(pair<int, int>(second, u));
it = s[u].upper_bound(pair<int, int>(second - 1, INF));
if (it != s[u].end() && it->first == second) {
Union(v, it->second);
} else
s[u].insert(pair<int, int>(second, v));
}
int main() {
init();
int n = ({
int a;
read(a);
a;
}),
m = ({
int a;
read(a);
a;
}),
second = ({
int a;
read(a);
a;
}),
q = ({
int a;
read(a);
a;
});
while (m--) {
int u = ({
int a;
read(a);
a;
}),
v = ({
int a;
read(a);
a;
}),
second = ({
int a;
read(a);
a;
});
addEdge(u, v, second);
}
while (q--) {
char ch;
scanf("%c", &ch);
if (ch == '+') {
int u = ({
int a;
read(a);
a;
}),
v = ({
int a;
read(a);
a;
}),
second = ({
int a;
read(a);
a;
});
addEdge(u, v, second);
} else {
int u = ({
int a;
read(a);
a;
}),
v = ({
int a;
read(a);
a;
});
int pu = findParent(u), pv = findParent(v);
if (pu == pv || st[pu].find(v) != st[pu].end())
printf("Yes\n");
else
printf("No\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int limit = 1000000;
int identifier[limit];
int first[limit];
int last[limit];
int amount[limit];
int nnex;
int nex[limit];
int who[limit];
unordered_set<int> u2setid[limit];
int computeidentifier(int u) {
int &idu = identifier[u];
if (idu == 0) return u;
idu = computeidentifier(idu);
return idu;
}
void addsetid(int u, int v) {
int idv = computeidentifier(v);
amount[idv]++;
int pos = ++nnex;
who[pos] = u;
nex[pos] = first[idv];
first[idv] = pos;
if (!last[idv]) last[idv] = pos;
u2setid[u].insert(idv);
}
void fusion(int u, int v) {
u = computeidentifier(u);
v = computeidentifier(v);
if (u == v) return;
if (amount[u] > amount[v]) swap(u, v);
identifier[u] = v;
amount[v] += amount[u];
for (int ind = first[u]; ind; ind = nex[ind]) {
int w = who[ind];
unordered_set<int> &setid = u2setid[w];
setid.erase(u);
setid.insert(v);
}
if (!first[v]) {
first[v] = first[u];
last[v] = last[u];
return;
}
nex[last[v]] = first[u];
if (last[u]) last[v] = last[u];
}
int n, m, cases;
unordered_map<int, int> u2c2v[limit];
void addarrow(int u, int v, int c) {
unordered_map<int, int> &c2v = u2c2v[u];
if (c2v.count(c)) {
fusion(c2v[c], v);
return;
}
c2v[c] = v;
}
void addedge(int u, int v, int c) {
addarrow(u, v, c);
addarrow(v, u, c);
addsetid(u, v);
addsetid(v, u);
}
bool thereispath(int u, int v) {
int idu = computeidentifier(u);
int idv = computeidentifier(v);
if (idu == idv) return true;
return u2setid[v].count(idu);
}
int maxnumcolors;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> maxnumcolors >> cases;
for (int i = 0; i < m; i++) {
int u, v, c;
cin >> u >> v >> c;
addedge(u, v, c);
}
for (int cas = 0; cas < cases; cas++) {
char car;
cin >> car;
if (car == '+') {
int u, v, c;
cin >> u >> v >> c;
addedge(u, v, c);
} else {
int u, v;
cin >> u >> v;
if (thereispath(u, v))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("-ffloat-store")
using namespace std;
clock_t time_p = clock();
void aryanc403() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
const long long int INF = 0xFFFFFFFFFFFFFFFL;
long long int seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline long long int rnd(long long int l = 0, long long int r = INF) {
return uniform_int_distribution<long long int>(l, r)(rng);
}
class CMP {
public:
bool operator()(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return !(a.first < b.first || a.first == b.first && a.second <= b.second);
}
};
void add(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt == m.end())
m.insert({x, cnt});
else
jt->second += cnt;
}
void del(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt->second <= cnt)
m.erase(jt);
else
jt->second -= cnt;
}
bool cmp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.first < b.first || (a.first == b.first && a.second < b.second);
}
const long long int mod = 1000000007L;
const long long int maxN = 100000L;
long long int T, n, i, j, k, in, cnt, l, r, u, v, x, y;
long long int m;
string s;
vector<long long int> a;
map<long long int, long long int> ec[maxN + 5];
set<long long int> ev[maxN + 5];
long long int id[maxN + 5], z, c, q;
long long int root(long long int n) {
if (id[n] == n) return n;
return id[n] = root(id[n]);
}
void merge(long long int u, long long int v) {
u = root(u);
v = root(v);
if (u == v) return;
if ((long long int)ev[u].size() < (long long int)ev[v].size()) swap(u, v);
id[v] = u;
for (auto x : ev[v]) ev[u].insert(x);
ev[v].clear();
}
void add(long long int u, long long int v, long long int c) {
auto it = ec[u].find(c);
if (it == ec[u].end()) {
ev[root(u)].insert(v);
ec[u][c] = v;
return;
}
merge(root(v), root(it->second));
ev[root(u)].insert(v);
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
cin >> n >> m >> c >> q;
for (i = (1); i <= (n); ++i) id[i] = i;
for (i = 0; i < (m); ++i) {
cin >> u >> v >> z;
add(u, v, z);
add(v, u, z);
}
while (q--) {
char T;
cin >> T;
if (T == '+') {
cin >> u >> v >> z;
add(u, v, z);
add(v, u, z);
} else {
cin >> u >> v;
u = root(u);
if (root(v) == u || ev[u].find(v) != ev[u].end())
cout << "Yes"
<< "\n";
else
cout << "No"
<< "\n";
}
}
}
aryanc403();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, c, p, root[100005];
set<int> Q[100005];
set<pair<int, int> > P[100005];
int getroot(int u) {
if (!root[u]) return u;
return (root[u] = getroot(root[u]));
}
int main() {
cin >> n >> m >> c >> p;
for (int i = 1; i <= m; i++) {
int u, v, c;
cin >> u >> v >> c;
int x = getroot(u);
int y = getroot(v);
Q[x].insert(v);
Q[y].insert(u);
set<pair<int, int> >::iterator k = P[u].lower_bound({c, 0});
if (k != P[u].end() && (*k).first == c) {
int t = getroot((*k).second);
if (t != y) {
if (Q[t].size() <= Q[y].size()) {
root[t] = y;
set<int>::iterator a = Q[t].begin();
while (a != Q[t].end()) {
Q[y].insert(*a);
++a;
}
} else {
root[y] = t;
set<int>::iterator a = Q[y].begin();
while (a != Q[y].end()) {
Q[t].insert(*a);
++a;
}
}
}
} else
P[u].insert({c, v});
k = P[v].lower_bound({c, 0});
if (k != P[v].end() && (*k).first == c) {
int t = getroot((*k).second);
if (t != x) {
int t = getroot((*k).second);
if (t != x) {
if (Q[t].size() <= Q[x].size()) {
root[t] = x;
set<int>::iterator a = Q[t].begin();
while (a != Q[t].end()) {
Q[x].insert(*a);
++a;
}
} else {
root[x] = t;
set<int>::iterator a = Q[x].begin();
while (a != Q[x].end()) {
Q[t].insert(*a);
++a;
}
}
}
}
} else
P[v].insert({c, u});
}
while (p--) {
char k;
cin >> k;
if (k == '+') {
int u, v, c;
cin >> u >> v >> c;
int x = getroot(u);
int y = getroot(v);
Q[x].insert(v);
Q[y].insert(u);
set<pair<int, int> >::iterator k = P[u].lower_bound({c, 0});
if (k != P[u].end() && (*k).first == c) {
int t = getroot((*k).second);
if (t != y) {
if (Q[t].size() <= Q[y].size()) {
root[t] = y;
set<int>::iterator a = Q[t].begin();
while (a != Q[t].end()) {
Q[y].insert(*a);
++a;
}
} else {
root[y] = t;
set<int>::iterator a = Q[y].begin();
while (a != Q[y].end()) {
Q[t].insert(*a);
++a;
}
}
}
} else
P[u].insert({c, v});
k = P[v].lower_bound({c, 0});
if (k != P[v].end() && (*k).first == c) {
int t = getroot((*k).second);
if (t != x) {
if (Q[t].size() <= Q[x].size()) {
root[t] = x;
set<int>::iterator a = Q[t].begin();
while (a != Q[t].end()) {
Q[x].insert(*a);
++a;
}
} else {
root[x] = t;
set<int>::iterator a = Q[x].begin();
while (a != Q[x].end()) {
Q[t].insert(*a);
++a;
}
}
}
} else
P[v].insert({c, u});
} else {
int u, v;
cin >> u >> v;
int x = getroot(u);
int y = getroot(v);
if (x == y)
cout << "Yes" << endl;
else if (Q[x].find(v) != Q[x].end())
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int p[123456];
set<int> has[123456];
vector<pair<int, int> > v[123456];
int getRoot(int a) {
if (a == p[a]) return a;
return p[a] = getRoot(p[a]);
}
void mrge(int a, int b) {
int A = getRoot(a);
int B = getRoot(b);
if (A == B) return;
if ((int)has[A].size() < (int)has[B].size()) {
swap(A, B);
}
for (auto it : has[B]) {
has[A].insert(it);
}
p[B] = A;
}
map<pair<int, int>, set<int> > M;
int main() {
int n, m, c, q;
scanf("%d%d%d%d", &n, &m, &c, &q);
for (auto(i) = (0); (i) < (n + 1); (i)++) {
p[i] = i;
has[i].insert(i);
}
for (auto(i) = (0); (i) < (m); (i)++) {
int x, y, z;
scanf("%d %d %d ", &x, &y, &z);
M[{x, z}].insert(y);
M[{y, z}].insert(x);
has[x].insert(y);
has[y].insert(x);
}
for (auto itt : M) {
auto it = itt.second;
int f = *(it.begin());
for (auto z : it) {
mrge(z, f);
}
}
for (auto(i) = (0); (i) < (q); (i)++) {
char t;
scanf(" %c ", &t);
if (t == '?') {
int a, b;
scanf("%d %d\n", &a, &b);
int A = getRoot(a);
int B = getRoot(b);
if (A == B || has[A].find(b) != has[A].end()) {
printf("Yes\n");
} else {
printf("No\n");
}
} else {
int x, y, z;
scanf("%d %d %d ", &x, &y, &z);
M[{x, z}].insert(y);
M[{y, z}].insert(x);
int X = getRoot(x);
int Y = getRoot(y);
has[X].insert(y);
has[Y].insert(x);
mrge(*(M[{x, z}].begin()), y);
mrge(*(M[{x, z}].rbegin()), y);
mrge(*(M[{y, z}].begin()), x);
mrge(*(M[{y, z}].rbegin()), x);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline int Chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline int Chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline T read() {
T sum = 0, fl = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fl = -1;
for (; isdigit(ch); ch = getchar()) sum = (sum << 3) + (sum << 1) + ch - '0';
return sum * fl;
}
inline void proc_status() {
ifstream t("/proc/self/status");
cerr << string(istreambuf_iterator<char>(t), istreambuf_iterator<char>())
<< endl;
}
const int Maxn = 1e5 + 100;
int N, M, C, Q;
set<int> S[Maxn];
map<pair<int, int>, int> Map;
namespace DSU {
int fa[Maxn];
inline void init(int maxn) {
for (int i = 1; i <= maxn; ++i) fa[i] = i, S[i].insert(i);
}
inline int get_fa(int first) {
return first == fa[first] ? first : fa[first] = get_fa(fa[first]);
}
inline void link(int first, int second) {
first = get_fa(first), second = get_fa(second);
if (first == second) return;
if (S[first].size() > S[second].size()) swap(first, second);
fa[first] = second;
S[second].insert(S[first].begin(), S[first].end());
S[first].clear();
}
inline int query(int first, int second) {
first = get_fa(first);
if (*S[first].lower_bound(second) != second) return 0;
return 1;
}
} // namespace DSU
inline void add_edge(int first, int second, int z) {
if (Map[make_pair(first, z)])
DSU ::link(Map[make_pair(first, z)], second);
else
Map[make_pair(first, z)] = second;
S[DSU ::get_fa(second)].insert(first);
}
inline void Solve() {
DSU ::init(N);
for (int i = 1; i <= M; ++i) {
int first = read<int>(), second = read<int>(), z = read<int>();
add_edge(first, second, z), add_edge(second, first, z);
}
while (Q--) {
char S[10];
scanf("%s", S);
if (S[0] == '?') {
int first = read<int>(), second = read<int>();
printf("%s\n", DSU ::query(first, second) ? "Yes" : "No");
} else {
int first = read<int>(), second = read<int>(), z = read<int>();
add_edge(first, second, z);
add_edge(second, first, z);
}
}
}
inline void Input() {
N = read<int>(), M = read<int>(), C = read<int>(), Q = read<int>();
}
int main() {
Input();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
pair<vector<int>, set<int> > comp[N];
vector<map<int, int> > g;
int at[N];
int compSize(int u) { return comp[u].first.size(); }
void merge(int a, int b) {
a = at[a];
b = at[b];
if (a == b) return;
if (compSize(a) > compSize(b)) swap(a, b);
for (auto &x : comp[a].first) {
at[x] = b;
comp[b].first.push_back(x);
}
comp[b].second.insert(comp[a].second.begin(), comp[a].second.end());
}
void addEdge(int a, int b, int c) {
comp[at[a]].second.insert(b);
comp[at[b]].second.insert(a);
for (int q = 0; q < 2; ++q) {
auto it = g[a].find(c);
if (it != g[a].end())
merge(at[it->second], at[b]);
else
g[a][c] = b;
swap(a, b);
}
}
int main() {
int n;
scanf("%d", &n);
g.resize(n);
for (int i = 0; i < n; ++i) {
at[i] = i;
comp[i].first.push_back(i);
}
int m, c, q;
scanf("%d%d%d", &m, &c, &q);
for (int i = 0; i < m; ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
--a;
--b;
addEdge(a, b, c);
}
char t;
while (q--) {
int u, v, c;
scanf(" %c%d%d", &t, &u, &v);
--u;
--v;
if (t == '+') {
scanf("%d", &c);
addEdge(u, v, c);
} else {
if (at[u] == at[v] || comp[at[u]].second.count(v))
puts("Yes");
else
puts("No");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, c, Q, sl, fh, fa[100010];
set<pair<int, int> > ex[100010];
set<int> edge[100010];
int rd() {
sl = 0;
fh = 1;
char ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') fh = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') sl = sl * 10 + ch - '0', ch = getchar();
return sl * fh;
}
int getfa(int x) {
if (x != fa[x]) fa[x] = getfa(fa[x]);
return fa[x];
}
void conncet(int x, int y) {
static int fx, fy;
fx = getfa(x);
fy = getfa(y);
if (fx == fy) return;
if (edge[fx].size() < edge[fy].size()) swap(edge[fx], edge[fy]);
for (set<int>::iterator i = edge[fy].begin(); i != edge[fy].end(); ++i)
edge[fx].insert(*i);
edge[fy].clear();
fa[fy] = fx;
}
void add(int u, int v, int clr) {
edge[getfa(u)].insert(v);
set<pair<int, int> >::iterator i = ex[v].lower_bound(make_pair(clr, 0));
if (i == ex[v].end() || i->first != clr)
ex[v].insert(make_pair(clr, u));
else
conncet(u, i->second);
}
int main() {
n = rd();
m = rd();
c = rd();
Q = rd();
int x, y, z, fx, fy;
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1; i <= m; ++i)
x = rd(), y = rd(), z = rd(), add(x, y, z), add(y, x, z);
for (char s[2]; Q; --Q) {
scanf("%s", s);
if (s[0] == '+')
x = rd(), y = rd(), z = rd(), add(x, y, z), add(y, x, z);
else {
x = rd();
y = rd();
fx = getfa(x);
fy = getfa(y);
if (fx == fy)
puts("Yes");
else if (*edge[fx].lower_bound(y) == y)
puts("Yes");
else
puts("No");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005;
const int BLOCK = 350;
int n, m, c, q;
int par[MX];
set<int> cc[MX];
unordered_map<int, int> col[MX];
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void merge(int u, int v) {
u = find(u), v = find(v);
if (u != v) {
par[v] = u;
if (cc[u].size() < cc[v].size()) swap(cc[u], cc[v]);
for (int i : cc[v]) cc[u].insert(i);
cc[v].clear();
}
}
void add_edge(int u, int v, int c) {
if (col[u].count(c))
merge(v, col[u][c]);
else
col[u][c] = v;
if (col[v].count(c))
merge(u, col[v][c]);
else
col[v][c] = u;
cc[find(u)].insert(v);
cc[find(v)].insert(u);
}
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> m >> c >> q;
for (int i = 1; i <= n; i++) {
cc[i].insert(i);
par[i] = i;
}
int u, v, c;
for (int i = 0; i < m; i++) {
cin >> u >> v >> c;
add_edge(u, v, c);
}
for (char tp; q--;) {
cin >> tp >> u >> v;
if (tp == '+') {
cin >> c;
add_edge(u, v, c);
} else {
if (cc[find(u)].count(v))
cout << "Yes\n";
else
cout << "No\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long n, a[500005], b[500005], k, m, res = 0, sm = 0, edge = -1, nb = 1,
ans = 0;
multiset<long long> mst;
set<long long> st[500005], st2;
string s1, s2, t1, t2;
vector<long long> vp, vans, v3;
vector<pair<long long, long long> > vv, vv1, adj, v1, v2;
vector<pair<pair<long long, long long>, long long> > vvv;
priority_queue<pair<pair<long long, long long>, long long> > pq;
set<pair<long long, long long> >::iterator it;
set<pair<pair<long long, long long>, long long> >::iterator it1, it2, it3;
map<long long, long long> red, mplose;
long long dx[] = {0, 0, -1, 1};
long long dy[] = {1, -1, 0, 0};
int voyel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y')
return 1;
return 0;
}
long long parent[500005], sizec[500005];
void make_set(int v) {
parent[v] = v;
sizec[v] = 0;
}
long long find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
string solve(long long x, long long y) {
x = find_set(x);
if (x == find_set(y) || st[x].find(y) != st[x].end()) return "Yes\n";
return "No\n";
}
map<long long, vector<long long> > v[500005];
void merge(long long x, long long y) {
x = find_set(x);
y = find_set(y);
if (x == y) return;
if (st[x].size() > st[y].size()) swap(x, y);
set<long long>::iterator it;
for (it = st[x].begin(); it != st[x].end(); it++) {
st[y].insert(*it);
}
st[x].clear();
parent[x] = y;
}
void add(long long x, long long y, long long c) {
vector<long long>& z = v[x][c];
while (z.size()) {
merge(y, z.back());
z.pop_back();
}
x = find_set(x);
st[x].insert(y);
z.push_back(y);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long i = 0, j = 0, x, y, z = 0, mx = 0, nb2 = 0, nb1 = 0, nbmax = 0,
nbinf = 0, mm = 5e9, idx = 0, ok = 0, l, r, negatif = 0,
positif = 0, q, d, res1 = 0, flag, color;
char c;
cin >> n >> m >> color >> q;
for (i = 1; i <= n; i++) make_set(i);
for (i = 1; i <= m; i++) {
cin >> x >> y >> z;
add(x, y, z);
add(y, x, z);
}
while (q--) {
cin >> c >> x >> y;
if (c == '?') {
cout << solve(x, y);
} else {
cin >> z;
add(x, y, z);
add(y, x, z);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxm = 5e6 + 10;
const long long mod = 1e9 + 7;
map<int, int> ma[maxn];
set<int> se[maxn];
int n, m, c, q, boss[maxn];
void inti() {
for (int i = 1; i <= n; i++) boss[i] = i;
}
int fin(int x) {
if (boss[x] == x) return x;
return boss[x] = fin(boss[x]);
}
void uni(int a, int b) {
int v1 = fin(a), v2 = fin(b);
if (v1 == v2) return;
if (se[v1].size() > se[v2].size()) swap(v1, v2);
boss[v1] = v2;
for (auto i : se[v1]) se[v2].insert(i);
se[v1].clear();
}
void add_edge() {
int a, b, v;
scanf("%d %d %d", &a, &b, &v);
if (ma[a].count(v))
uni(ma[a][v], b);
else
ma[a][v] = b;
if (ma[b].count(v))
uni(ma[b][v], a);
else
ma[b][v] = a;
se[fin(a)].insert(b);
se[fin(b)].insert(a);
}
int main() {
scanf("%d %d %d %d", &n, &m, &c, &q);
inti();
for (int i = 1; i <= m; i++) add_edge();
while (q--) {
getchar();
if (getchar() == '?') {
int fla = 0, a, b;
scanf("%d %d", &a, &b);
int v = fin(a);
if (v == fin(b) || se[v].find(b) != se[v].end())
printf("Yes\n");
else
printf("No\n");
} else {
add_edge();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> col;
set<int> AdjList[100001];
int p[100001];
int anc(int x) {
if (p[x] == x) return x;
return p[x] = anc(p[x]);
}
void join(int x, int y) { p[anc(x)] = anc(y); }
struct Query {
int type, u, v, c;
Query() {}
Query(int _type, int _u, int _v, int _c) {
type = _type;
u = _u;
v = _v;
c = _c;
}
};
vector<Query> Q;
int n;
int m, C, q;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> C >> q;
for (int i = 1; i <= m; i++) {
int u, v, c;
cin >> u >> v >> c;
Q.push_back(Query(0, u, v, c));
}
for (int i = 1; i <= q; i++) {
char z;
cin >> z;
if (z == '+') {
int u, v, c;
cin >> u >> v >> c;
Q.push_back(Query(0, u, v, c));
} else {
int u, v;
cin >> u >> v;
Q.push_back(Query(1, u, v, -1));
}
}
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 0; i < Q.size(); i++) {
if (!Q[i].type) {
int u = Q[i].u;
int v = Q[i].v;
int c = Q[i].c;
int anc_u = anc(u);
int anc_v = anc(v);
AdjList[anc_u].insert(v);
AdjList[anc_v].insert(u);
if (col[pair<int, int>(v, c)]) {
int z = col[pair<int, int>(v, c)];
int anc_z = anc(z);
if (anc_u != anc_z) {
if (AdjList[anc_u].size() > AdjList[anc_z].size())
swap(AdjList[anc_u], AdjList[anc_z]);
while (!AdjList[anc_u].empty()) {
AdjList[anc_z].insert(*AdjList[anc_u].begin());
AdjList[anc_u].erase(AdjList[anc_u].begin());
}
p[anc_u] = anc_z;
}
}
if (col[pair<int, int>(u, c)]) {
int z = col[pair<int, int>(u, c)];
int anc_z = anc(z);
if (anc_v != anc_z) {
if (AdjList[anc_v].size() > AdjList[anc_z].size())
swap(AdjList[anc_v], AdjList[anc_z]);
while (!AdjList[anc_v].empty()) {
AdjList[anc_z].insert(*AdjList[anc_v].begin());
AdjList[anc_v].erase(AdjList[anc_v].begin());
}
p[anc_v] = anc_z;
}
}
col[pair<int, int>(u, c)] = v;
col[pair<int, int>(v, c)] = u;
} else {
int u = Q[i].u;
int v = Q[i].v;
int anc_u = anc(u);
int anc_v = anc(v);
if (anc_u == anc_v)
cout << "Yes" << '\n';
else if (AdjList[anc_u].find(v) != AdjList[anc_u].end())
cout << "Yes" << '\n';
else
cout << "No" << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -f;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
x *= f;
}
void print(int x) {
if (x < 0) putchar('-'), x = -x;
if (!x) return;
print(x / 10), putchar(x % 10 + 48);
}
void write(int x) {
if (!x)
putchar('0');
else
print(x);
putchar('\n');
}
const int maxn = 1e6 + 10;
const int inf = 1e9;
const double eps = 1e-8;
const int mod = 1e9 + 7;
map<int, vector<int> > e[maxn];
set<int> r[maxn];
int n, m, c, q, fa[maxn];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (r[x].size() > r[y].size()) swap(x, y);
fa[x] = y;
for (auto v : r[x]) r[y].insert(v);
}
void add() {
int x, y, z;
read(x), read(y), read(z);
r[find(x)].insert(y), r[find(y)].insert(x);
e[x][z].push_back(y), unite(e[x][z][0], y);
e[y][z].push_back(x), unite(e[y][z][0], x);
}
int main() {
read(n), read(m), read(c), read(q);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) add();
for (int i = 1; i <= q; i++) {
char s[5];
scanf("%s", s + 1);
if (s[1] == '+')
add();
else {
int x, y;
read(x), read(y);
x = find(x);
puts((x == find(y) || r[x].count(y)) ? "Yes" : "No");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nax = 1e5 + 5;
int n, m, k, q;
set<int> zbior[nax];
int wjakiejskladowejjestem[nax];
vector<int> skladowe[nax];
map<int, int> krawedzie[nax];
int rozmiar[nax];
void pre() {
cin >> n >> m >> k >> q;
for (int i = 1; i <= n; i++) {
zbior[i].insert(i);
skladowe[i].push_back(i);
wjakiejskladowejjestem[i] = i;
rozmiar[i] = 1;
}
}
void dodaj(int v, int u) {
int V = wjakiejskladowejjestem[v];
int U = wjakiejskladowejjestem[u];
if (zbior[v].count(U)) {
return;
}
skladowe[U].push_back(v);
rozmiar[U]++;
zbior[v].insert(U);
}
void debug(int kt) {
set<int>::iterator it;
it = zbior[kt].begin();
while (it != zbior[kt].end()) {
cout << *it << endl;
it++;
}
cout << "*********************" << endl;
for (int i = 1; i <= n; i++) cout << rozmiar[i] << " ";
cout << "*********************" << endl;
}
void query(int v, int u) {
v = wjakiejskladowejjestem[v];
if (zbior[u].count(v))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void zrob(int v, int u, int kolor) {
if (krawedzie[v][kolor] == 0) {
krawedzie[v][kolor] = u;
return;
}
int A = wjakiejskladowejjestem[u];
int B = krawedzie[v][kolor];
B = wjakiejskladowejjestem[B];
if (A == B) return;
if (rozmiar[A] < rozmiar[B]) swap(A, B);
for (int i = 0; i < skladowe[B].size(); i++) {
int akt = skladowe[B][i];
zbior[akt].erase(B);
zbior[akt].insert(A);
if (wjakiejskladowejjestem[akt] == B) wjakiejskladowejjestem[akt] = A;
skladowe[A].push_back(akt);
}
skladowe[B].clear();
rozmiar[A] += rozmiar[B];
rozmiar[B] = 0;
}
void add_edge(int u, int v, int kolor) {
dodaj(u, v);
dodaj(v, u);
zrob(u, v, kolor);
zrob(v, u, kolor);
}
int main() {
pre();
while (m--) {
int x, y, z;
cin >> x >> y >> z;
add_edge(x, y, z);
}
while (q--) {
char zz;
cin >> zz;
if (zz == '?') {
int x, y;
cin >> x >> y;
query(x, y);
} else {
int x, y, z;
cin >> x >> y >> z;
add_edge(x, y, z);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = INT_MAX, df = 1e5 + 7;
set<long long> st[df];
map<long long, vector<long long> > e[df];
long long i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, fa[df];
long long chk(long long x) { return (x == fa[x]) ? x : fa[x] = chk(fa[x]); }
void merge(long long u, long long v) {
u = chk(u), v = chk(v);
if (u != v) {
if (st[u].size() < st[v].size()) swap(u, v);
while (!st[v].empty())
st[u].insert(*st[v].begin()), st[v].erase(st[v].begin());
fa[v] = u;
}
}
void add(long long u, long long v, long long w) {
st[chk(u)].insert(v), st[chk(v)].insert(u);
e[u][w].push_back(v), merge(v, e[u][w][0]);
e[v][w].push_back(u), merge(u, e[v][w][0]);
return;
}
void qry(long long u, long long v) {
if (chk(u) == chk(v) || st[chk(u)].count(v))
puts("Yes");
else
puts("No");
return;
}
int main() {
scanf("%lld%lld%lld%lld", &n, &m, &p, &q);
for (long long i = (1); i <= (n); ++i) fa[i] = i;
while (m--) {
scanf("%lld%lld%lld", &u, &v, &w);
add(u, v, w);
}
while (q--) {
char ch[12];
scanf("%s", ch);
if (ch[0] == '+') {
scanf("%lld%lld%lld", &u, &v, &w);
add(u, v, w);
}
if (ch[0] == '?') {
scanf("%lld%lld", &u, &v);
qry(u, v);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int MAXBIG = 6e3;
const int DEG = 35;
struct edge {
int u, v, clr;
};
int N, M, C, Q;
char cmd[MAXN];
int deg[MAXN], idx[MAXN];
vector<edge> roads;
vector<pair<int, int> > queries;
int dad[MAXN], rnk[MAXN];
bitset<MAXBIG> has[MAXN];
unordered_map<int, int> who[MAXN];
vector<int> adj[MAXN];
void add_road(int x, int y, int z) {
roads.push_back({x, y, z});
deg[x]++;
deg[y]++;
}
void load() {
scanf("%d%d%d%d", &N, &M, &C, &Q);
for (int i = 0; i < M; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
add_road(x, y, z);
}
for (int i = 0; i < Q; i++) {
int x, y, z;
scanf(" %c%d%d", cmd + i, &x, &y);
if (cmd[i] == '+') {
scanf("%d", &z);
add_road(x, y, z);
} else
queries.push_back({x, y});
}
}
int find(int x) { return dad[x] == x ? x : dad[x] = find(dad[x]); }
void join(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (rnk[x] > rnk[y]) swap(x, y);
dad[x] = y;
rnk[y] += rnk[x] == rnk[y];
has[y] |= has[x];
}
void merge(int x, int y, int c) {
for (int i = 0; i < 2; i++) {
adj[x].push_back(y);
if (deg[y] > DEG) has[find(x)].set(idx[y]);
int &ref = who[x][c];
if (ref)
join(ref, y);
else
ref = y;
swap(x, y);
}
}
void advance() {
merge(roads.back().u, roads.back().v, roads.back().clr);
roads.pop_back();
}
bool query(int x, int y) {
int comp = find(x);
if (find(y) == comp) return true;
if (deg[y] > DEG) return has[comp].test(idx[y]);
for (auto it : adj[y])
if (find(it) == comp) return true;
return false;
}
void solve() {
reverse(roads.begin(), roads.end());
reverse(queries.begin(), queries.end());
int ptr = 0;
for (int i = 1; i <= N; i++) {
dad[i] = i;
if (deg[i] > DEG) {
idx[i] = ptr++;
has[i].set(idx[i]);
}
}
while (M--) advance();
for (int i = 0; i < Q; i++)
if (cmd[i] == '?') {
puts(query(queries.back().first, queries.back().second) ? "Yes" : "No");
queries.pop_back();
} else
advance();
}
int main() {
load();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using i64 = long long;
int main() {
int n, m, c, q;
scanf("%d%d%d%d", &n, &m, &c, &q);
std::vector<std::set<int>> reachable(n + 1);
std::vector<int> par(n + 1);
std::vector<std::deque<int>> ss(n + 1);
for (int i = 0; i <= n; i++) {
par[i] = i;
reachable[i].insert(i);
ss[i].push_back(i);
}
auto unite = [&](int i, int j) {
int pi = par[i], pj = par[j];
if (pi == pj) return;
if (reachable[pi].size() > reachable[pj].size()) {
std::swap(reachable[pi], reachable[pj]);
}
reachable[pj].insert(reachable[pi].begin(), reachable[pi].end());
reachable[pi].clear();
if (ss[pi].size() > ss[pj].size()) {
std::swap(pi, pj);
std::swap(reachable[pi], reachable[pj]);
}
for (auto e : ss[pi]) par[e] = pj;
ss[pj].insert(ss[pj].end(), ss[pi].begin(), ss[pi].end());
ss[pi].clear();
};
std::vector<std::map<int, int>> g(n + 1);
for (int i = 0; i < m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
reachable[par[x]].insert(y);
reachable[par[y]].insert(x);
if (g[y][z] == 0)
g[y][z] = x;
else
unite(x, g[y][z]);
if (g[x][z] == 0)
g[x][z] = y;
else
unite(y, g[x][z]);
}
for (int i = 0; i < q; i++) {
char t[3];
scanf("%s", t);
if (t[0] == '+') {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
reachable[par[x]].insert(y);
reachable[par[y]].insert(x);
if (g[y][z] == 0)
g[y][z] = x;
else
unite(x, g[y][z]);
if (g[x][z] == 0)
g[x][z] = y;
else
unite(y, g[x][z]);
} else {
int x, y;
scanf("%d%d", &x, &y);
printf(reachable[par[x]].count(y) ? "Yes\n" : "No\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, c, q;
int fa[N];
vector<int> G[N], col[N];
set<int> s[N];
map<int, int> mp[N];
char op[4];
bool vis[N];
void addedge(int u, int v, int w) {
G[u].push_back(v);
col[u].push_back(w);
}
int find(int u) {
if (u == fa[u]) {
return fa[u];
}
return fa[u] = find(fa[u]);
}
void uniset(int u, int v) {
if (find(u) == find(v)) {
return;
}
if (s[find(u)].size() < s[find(v)].size()) {
swap(u, v);
}
while (!s[find(v)].empty()) {
s[find(u)].insert(*s[find(v)].begin());
s[find(v)].erase(s[find(v)].begin());
}
fa[find(v)] = find(u);
}
void dfs(int u) {
if (vis[u]) {
return;
}
vis[u] = 1;
for (int i = 0, v, w; i < (int)G[u].size(); i++) {
v = G[u][i];
w = col[u][i];
if (!mp[u][w]) {
mp[u][w] = v;
} else {
uniset(find(mp[u][w]), find(v));
}
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &c, &q);
for (int i = 1; i <= n; i++) {
s[i].insert(i);
fa[i] = i;
}
for (int i = 1, u, v, w; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
addedge(u, v, w);
addedge(v, u, w);
s[u].insert(v);
s[v].insert(u);
}
for (int i = 1; i <= n; i++) {
dfs(i);
}
int u, v, w;
while (q--) {
scanf("%s", op);
if (op[0] == '+') {
scanf("%d%d%d", &u, &v, &w);
s[find(u)].insert(v);
s[find(v)].insert(u);
if (mp[u][w]) {
uniset(find(mp[u][w]), find(v));
} else {
mp[u][w] = v;
}
if (mp[v][w]) {
uniset(find(mp[v][w]), find(u));
} else {
mp[v][w] = u;
}
} else {
scanf("%d%d", &u, &v);
if (s[find(u)].count(v)) {
printf("Yes\n");
} else {
printf("No\n");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int n, m, c, q;
map<int, int> adj[MAX];
set<int> adj2[MAX];
int ds[MAX], h[MAX];
void init() {
for (int i = 1; i <= n; ++i) {
ds[i] = i;
}
}
int find(int x) { return ds[x] == x ? x : ds[x] = find(ds[x]); }
bool merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return false;
}
if (h[x] < h[y]) swap(x, y);
ds[y] = x;
if (h[x] == h[y]) ++h[x];
for (auto u : adj2[y]) {
adj2[x].insert(u);
}
return true;
}
void add_edge(int x, int y, int z) {
if (adj[x].count(z) == 0) {
adj[x][z] = y;
}
merge(adj[x][z], y);
if (adj[y].count(z) == 0) {
adj[y][z] = x;
}
merge(adj[y][z], x);
int oldx = x, oldy = y;
x = find(x), y = find(y);
adj2[x].insert(oldy);
adj2[y].insert(oldx);
}
bool query(int x, int y) {
int oldy = y;
x = find(x);
y = find(y);
if (x == y) {
return true;
}
if (adj2[x].count(oldy)) {
return true;
}
return false;
}
int main() {
scanf("%d%d%d%d", &n, &m, &c, &q);
init();
for (int i = 0; i < m; ++i) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
add_edge(x, y, z);
}
while (q--) {
char op;
int x, y;
scanf(" %c %d %d", &op, &x, &y);
if (op == '?') {
if (query(x, y)) {
printf("Yes\n");
} else {
printf("No\n");
}
} else {
int z;
scanf("%d", &z);
add_edge(x, y, z);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 222;
map<int, int> ma[maxn];
int fa[maxn];
set<int> se[maxn];
inline int FA(int x) {
if (fa[x] == x) return x;
fa[x] = FA(fa[x]);
return fa[x];
}
void merge1(int a, int b) {
int A = FA(a);
int B = FA(b);
if (A == B) return;
if (se[A].size() > se[B].size()) {
swap(A, B);
}
for (int aa : se[A]) {
se[B].insert(aa);
}
se[A].clear();
fa[A] = B;
}
inline void add(int a, int b, int c) {
se[FA(a)].insert(b);
se[FA(b)].insert(a);
if (ma[a].count(c)) {
merge1(b, ma[a][c]);
}
if (ma[b][c]) {
merge1(a, ma[b][c]);
}
ma[a][c] = b;
ma[b][c] = a;
}
char str[maxn];
int n, m, cc, q;
void solve() {
scanf("%d %d %d %d", &n, &m, &cc, &q);
for (int i = 1; i <= n; i++) {
fa[i] = i;
}
for (int i = 1; i <= m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
add(a, b, c);
}
while (q--) {
scanf("%s", str);
if (str[0] == '+') {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
add(a, b, c);
} else if (str[0] == '?') {
int a, b;
scanf("%d %d", &a, &b);
int A = FA(a);
int B = FA(b);
if (A == B)
puts("Yes");
else if (se[A].find(b) != se[A].end()) {
puts("Yes");
} else
puts("No");
}
}
}
signed main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
const int maxm = 2e1 + 7;
const int mod = 1e9 + 7;
int n, m, k;
int ar[maxn];
vector<pair<int, int>> g[maxn];
set<int> se[maxn];
map<int, int> ma[maxn];
int c, p;
int f[maxn];
int findx(int u) { return f[u] == u ? u : f[u] = findx(f[u]); }
void un(int x, int y) {
x = findx(x);
y = findx(y);
if (x == y) return;
if (se[x].size() > se[y].size()) swap(x, y);
for (auto it : se[x]) se[y].insert(it);
se[x].clear();
f[x] = y;
}
void dfs(int u, int py, int pz) {
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, c = g[u][i].second;
if (pz == c) {
un(py, v);
}
}
}
void add(int a, int b, int c) {
dfs(a, b, c);
dfs(b, a, c);
if (ma[a].count(c))
un(ma[a][c], b);
else
ma[a][c] = b;
if (ma[b].count(c))
un(ma[b][c], a);
else
ma[b][c] = a;
se[findx(a)].insert(b);
se[findx(b)].insert(a);
}
int main() {
scanf("%d%d%d%d", &n, &m, &c, &p);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
while (p--) {
char ch[2];
scanf("%s", ch);
int x, y, z;
if (ch[0] == '+') {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
} else {
scanf("%d%d", &x, &y);
x = findx(x);
if (x == findx(y) || se[x].count(y))
printf("Yes\n");
else
printf("No\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct DSU {
vector<int> rank;
vector<int> parent;
DSU() {}
DSU(int n) {
rank.resize(n, 1);
parent.resize(n);
iota(parent.begin(), parent.end(), 0);
}
int find(const int u) {
if (parent[u] == u) {
return u;
}
parent[u] = find(parent[u]);
return parent[u];
}
bool merge(int u, int v) {
u = find(u);
v = find(v);
if (u == v) {
return false;
}
if (rank[u] < rank[v]) {
swap(u, v);
}
rank[u] += rank[v];
parent[v] = u;
return true;
}
int size(int u) { return rank[find(u)]; }
};
vector<map<int, int>> adj;
vector<set<int>> dadj;
DSU dsu;
set<int> merge(set<int> &s1, set<int> &s2) {
if (s1.size() > s2.size()) {
swap(s1, s2);
}
s2.insert(s1.begin(), s1.end());
s1.clear();
return move(s2);
}
void merge(int u, int v) {
u = dsu.find(u);
v = dsu.find(v);
if (u == v) {
return;
}
set<int> s = merge(dadj[u], dadj[v]);
dsu.merge(u, v);
dadj[dsu.find(u)] = move(s);
}
void addEdge(const int x, const int y, const int z) {
if (dsu.find(x) != dsu.find(y)) dadj[dsu.find(x)].insert(y);
if (!adj[x].count(z)) {
adj[x][z] = y;
} else {
merge(adj[x][z], y);
}
}
void addEdges() {
int x, y, z;
cin >> x >> y >> z;
addEdge(x, y, z);
addEdge(y, x, z);
}
int main() {
int n, m, c, q;
cin >> n >> m >> c >> q;
adj.resize(n + 1);
dadj.resize(n + 1);
dsu = DSU(n + 1);
for (int i = 0; i < m; ++i) {
addEdges();
}
for (int i = 0; i < q; i++) {
char t;
cin >> t;
if (t == '+') {
addEdges();
} else {
int x, y;
cin >> x >> y;
x = dsu.find(x);
bool b = (x == dsu.find(y)) || (dadj[x].count(y));
string res = (b) ? "Yes" : "No";
cout << res << endl;
}
}
cin.ignore(2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e5 + 20;
vector<long long> adj[MAX];
struct DisjointSetUnion {
long long parent[MAX];
long long size[MAX];
void make_set(long long v) {
parent[v] = v;
size[v] = 1;
}
long long find(long long v) {
if (v == parent[v]) {
return v;
}
return parent[v] = find(parent[v]);
}
void join(long long a, long long b) {
a = find(a);
b = find(b);
if (a != b) {
if (size[a] < size[b]) {
swap(a, b);
}
parent[b] = a;
size[a] += size[b];
}
}
} dsu;
map<pair<long long, long long>, vector<long long> > adj2;
void addEdge(long long u, long long v, long long c) {
u--;
v--;
c--;
adj[u].push_back(v);
adj[v].push_back(u);
adj2[{c, u}].push_back(v);
adj2[{c, v}].push_back(u);
}
set<long long> neigh[MAX];
bool query(long long u, long long v) {
u--;
v--;
if (dsu.find(u) == dsu.find(v)) {
return true;
}
if (neigh[dsu.find(u)].find(v) != neigh[dsu.find(u)].end()) {
return true;
}
return false;
}
void add(long long u, long long v, long long c) {
u--;
v--;
c--;
if ((long long)adj2[{c, u}].size() > 0) {
long long a = dsu.find(adj2[{c, u}][0]);
long long b = dsu.find(v);
if (a != b) {
dsu.join(adj2[{c, u}][0], v);
long long c = dsu.find(v);
if (c == a) {
neigh[a].insert(neigh[b].begin(), neigh[b].end());
} else {
neigh[b].insert(neigh[a].begin(), neigh[a].end());
}
}
}
if ((long long)adj2[{c, v}].size() > 0) {
long long a = dsu.find(adj2[{c, v}][0]);
long long b = dsu.find(u);
if (a != b) {
dsu.join(adj2[{c, v}][0], u);
long long c = dsu.find(u);
if (c == a) {
neigh[a].insert(neigh[b].begin(), neigh[b].end());
} else {
neigh[b].insert(neigh[a].begin(), neigh[a].end());
}
}
}
adj2[{c, u}].push_back(v);
adj2[{c, v}].push_back(u);
if (dsu.find(u) != dsu.find(v)) {
neigh[dsu.find(u)].insert(v);
neigh[dsu.find(v)].insert(u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, c, q;
cin >> n >> m >> c >> q;
for (long long i = 0; i < (long long)n; i++) {
dsu.make_set(i);
}
for (long long i = 0; i < (long long)m; i++) {
long long u, v, c;
cin >> u >> v >> c;
addEdge(u, v, c);
}
for (pair<pair<long long, long long>, vector<long long> > p : adj2) {
for (long long x : p.second) {
if (x == p.second[0]) {
continue;
}
dsu.join(p.second[0], x);
}
}
for (long long i = 0; i < (long long)n; i++) {
for (long long v : adj[i]) {
neigh[dsu.find(i)].insert(v);
}
}
for (long long i = 0; i < (long long)q; i++) {
char x;
cin >> x;
long long u, v;
cin >> u >> v;
if (x == '?') {
if (query(u, v)) {
cout << "Yes" << '\n';
} else {
cout << "No" << '\n';
}
} else {
long long c;
cin >> c;
add(u, v, c);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int n, m, c, q;
set<int> st[MAXN];
int par[MAXN];
map<int, int> mp[MAXN];
vector<int> vec[MAXN];
vector<int> adj[MAXN];
int root(int v) {
if (par[v] == -1) {
return v;
}
return par[v] = root(par[v]);
}
void merg(int v, int u) {
v = root(v);
u = root(u);
if (v == u) {
return;
}
if (vec[v].size() < vec[u].size()) {
swap(v, u);
}
par[u] = v;
for (int i = 0; i < vec[u].size(); i++) {
vec[v].push_back(vec[u][i]);
for (int j = 0; j < adj[vec[u][i]].size(); j++) {
st[adj[vec[u][i]][j]].erase(u);
st[adj[vec[u][i]][j]].insert(v);
}
st[vec[u][i]].erase(u);
st[vec[u][i]].insert(v);
}
}
void add_edge(int v, int u, int z) {
if (root(v) != root(u)) {
st[v].insert(root(u));
st[u].insert(root(v));
}
adj[v].push_back(u);
adj[u].push_back(v);
if (mp[v].count(z)) {
merg(u, mp[v][z]);
}
if (mp[u].count(z)) {
merg(v, mp[u][z]);
}
mp[v][z] = u;
mp[u][z] = v;
}
void print_ans(int v, int u) {
int k = root(v);
if (st[u].count(k)) {
cout << "Yes" << '\n';
return;
}
cout << "No" << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> c >> q;
for (int i = 1; i <= n; i++) {
par[i] = -1;
st[i].insert(i);
vec[i].push_back(i);
}
int u, v, z;
for (int i = 0; i < m; i++) {
cin >> u >> v >> z;
add_edge(u, v, z);
}
char command;
while (q--) {
cin >> command;
cin >> u >> v;
if (command == '?') {
print_ans(u, v);
} else {
cin >> z;
add_edge(u, v, z);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch ^ 48);
return x;
}
int n, m, ctot, q;
int fat[100010];
int find(int x) { return fat[x] ? fat[x] = find(fat[x]) : x; }
set<int> st[100010];
map<pair<int, int>, int> mp;
void mrg(int x, int y) {
if (x == y) return;
if (st[x].size() > st[y].size()) swap(x, y);
for (set<int>::iterator i = st[x].begin(); i != st[x].end(); ++i)
st[y].insert(*i);
st[x].clear();
fat[x] = y;
}
void addedge(int x, int y, int w) {
st[find(x)].insert(y);
if (!mp.count((pair<int, int>){x, w}))
mp[(pair<int, int>){x, w}] = y;
else
mrg(find(y), find(mp[(pair<int, int>){x, w}]));
}
int main() {
int x, y, z, fx, fy;
char opt[3];
n = read(), m = read(), ctot = read(), q = read();
while (m--) {
x = read(), y = read(), z = read();
addedge(x, y, z);
addedge(y, x, z);
}
while (q--) {
scanf("%s", opt);
x = read(), y = read();
if (opt[0] == '+')
z = read(), addedge(x, y, z), addedge(y, x, z);
else {
fx = find(x), fy = find(y);
if (fx == fy || st[fx].count(y))
puts("Yes");
else
puts("No");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 100 + 10;
int par[N], n, m, c;
unordered_map<int, int> adj[N];
unordered_set<int> adj1[N];
int getPar(int root) {
return par[root] == par[par[root]] ? par[root]
: par[root] = getPar(par[root]);
}
void Union(int v, int u) {
v = getPar(v), u = getPar(u);
if (v == u) return;
if (adj1[v].size() < adj1[u].size()) swap(v, u);
par[u] = par[v];
for (auto it : adj1[u]) adj1[v].insert(it);
}
void add(int v, int u, int c) {
if (adj[u][c]) Union(v, adj[u][c]);
if (adj[v][c]) Union(u, adj[v][c]);
int pv = getPar(v), pu = getPar(u);
adj[v][c] = pu, adj[u][c] = pv;
adj1[pv].insert(u), adj1[pu].insert(v);
}
bool check(int v, int u) {
int pv = getPar(v), pu = getPar(u);
return pv == pu || adj1[pv].count(u);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int Q;
cin >> n >> m >> c >> Q;
for (int i = 1; i <= n; i++) par[i] = i;
for (int i = 1, v, u, z; i <= m; i++) {
cin >> v >> u >> z;
add(v, u, z);
}
while (Q--) {
char c;
int x, y, z;
cin >> c >> x >> y;
if (c == '?')
cout << (check(x, y) ? "Yes" : "No") << '\n';
else {
cin >> z;
add(x, y, z);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e5 + 20;
vector<long long> adj[MAX];
struct Edge {
long long u, v, c;
Edge() {}
Edge(long long u, long long v, long long c) : u(u), v(v), c(c) {}
};
vector<Edge> E;
struct DisjointSetUnion {
long long parent[MAX];
long long size[MAX];
void make_set(long long v) {
parent[v] = v;
size[v] = 1;
}
long long find(long long v) {
if (v == parent[v]) {
return v;
}
return parent[v] = find(parent[v]);
}
void join(long long a, long long b) {
a = find(a);
b = find(b);
if (a != b) {
if (size[a] < size[b]) {
swap(a, b);
}
parent[b] = a;
size[a] += size[b];
}
}
} dsu;
map<pair<long long, long long>, vector<long long> > adj2;
void addEdge(long long u, long long v, long long c) {
u--;
v--;
c--;
adj[u].push_back(v);
adj[v].push_back(u);
adj2[{c, u}].push_back(v);
adj2[{c, v}].push_back(u);
}
set<long long> neigh[MAX];
bool query(long long u, long long v) {
u--;
v--;
if (dsu.find(u) == dsu.find(v)) {
return true;
}
if (neigh[dsu.find(u)].find(v) != neigh[dsu.find(u)].end()) {
return true;
}
return false;
}
void add(long long u, long long v, long long c) {
u--;
v--;
c--;
if ((long long)adj2[{c, u}].size() > 0) {
long long a = dsu.find(adj2[{c, u}][0]);
long long b = dsu.find(v);
if (a != b) {
dsu.join(adj2[{c, u}][0], v);
long long c = dsu.find(v);
if (c == a) {
neigh[a].insert(neigh[b].begin(), neigh[b].end());
} else {
neigh[b].insert(neigh[a].begin(), neigh[a].end());
}
}
}
if ((long long)adj2[{c, v}].size() > 0) {
long long a = dsu.find(adj2[{c, v}][0]);
long long b = dsu.find(u);
if (a != b) {
dsu.join(adj2[{c, v}][0], u);
long long c = dsu.find(u);
if (c == a) {
neigh[a].insert(neigh[b].begin(), neigh[b].end());
} else {
neigh[b].insert(neigh[a].begin(), neigh[a].end());
}
}
}
adj2[{c, u}].push_back(v);
adj2[{c, v}].push_back(u);
if (dsu.find(u) != dsu.find(v)) {
neigh[dsu.find(u)].insert(v);
neigh[dsu.find(v)].insert(u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, c, q;
cin >> n >> m >> c >> q;
for (long long i = 0; i < (long long)n; i++) {
dsu.make_set(i);
}
for (long long i = 0; i < (long long)m; i++) {
long long u, v, c;
cin >> u >> v >> c;
addEdge(u, v, c);
}
for (pair<pair<long long, long long>, vector<long long> > p : adj2) {
for (long long x : p.second) {
if (x == p.second[0]) {
continue;
}
dsu.join(p.second[0], x);
}
}
for (long long i = 0; i < (long long)n; i++) {
for (long long v : adj[i]) {
neigh[dsu.find(i)].insert(v);
}
}
for (long long i = 0; i < (long long)q; i++) {
char x;
cin >> x;
long long u, v;
cin >> u >> v;
if (x == '?') {
if (query(u, v)) {
cout << "Yes" << '\n';
} else {
cout << "No" << '\n';
}
} else {
long long c;
cin >> c;
add(u, v, c);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using si = set<int>;
using sii = set<pii>;
sii G[100005];
si g[100005];
int p[100005];
int f(int x) { return (x == p[x]) ? x : p[x] = f(p[x]); }
void un(int x, int y) {
x = f(x), y = f(y);
if (x == y) return;
if (g[y].size() < g[x].size()) swap(x, y);
p[x] = y;
for (auto u : g[x]) g[y].insert(u);
g[x].clear();
}
int n;
int main() {
int m, c, q;
scanf("%d%d%d%d", &n, &m, &c, &q);
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
auto l1 = G[x].lower_bound({z, 0});
auto l2 = G[y].lower_bound({z, 0});
G[x].emplace(z, y);
G[y].emplace(z, x);
int px = f(x), py = f(y);
if (px != py) {
g[px].insert(y);
g[py].insert(x);
}
if (l1 != G[x].end() and l1->first == z) un(l1->second, y);
if (l2 != G[y].end() and l2->first == z) un(l2->second, x);
}
for (int i = 1; i <= q; i++) {
char c;
scanf(" %c", &c);
if (c == '+') {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
auto l1 = G[x].lower_bound({z, 0});
auto l2 = G[y].lower_bound({z, 0});
G[x].emplace(z, y);
G[y].emplace(z, x);
int px = f(x), py = f(y);
if (px != py) {
g[px].insert(y);
g[py].insert(x);
}
if (l1 != G[x].end() and l1->first == z) un(l1->second, y);
if (l2 != G[y].end() and l2->first == z) un(l2->second, x);
} else if (c == '?') {
int x, y;
scanf("%d%d", &x, &y);
int px = f(x), py = f(y);
if (px == py)
printf("Yes\n");
else if (g[px].find(y) != g[px].end())
printf("Yes\n");
else
printf("No\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <int MS>
struct DSU {
public:
int p[MS], r[MS], m[MS];
set<int> v[MS];
int f(int n) { return p[n] ? p[n] = f(p[n]) : n; }
void init(void) {
for (int i = 0; i < MS; i++) m[i] = i;
}
bool mm(int a, int b) {
a = f(a), b = f(b);
if (a == b) return 0;
if (r[a] < r[b]) swap(a, b);
r[a] += r[a] == r[b], r[b] = -1, p[b] = a;
if (v[m[a]].size() < v[m[b]].size()) swap(m[a], m[b]);
v[m[a]].insert(v[m[b]].begin(), v[m[b]].end()), v[m[b]].clear();
return 1;
}
void add(int a, int b) {
a = f(a);
v[m[a]].insert(b);
}
bool test(int a, int b) {
a = f(a);
if (a == f(b)) return 1;
if (v[m[a]].find(b) != v[m[a]].end()) return 1;
return 0;
}
};
const int MN = 1e5 + 100;
const int MM = 1e5 + 100;
int N, M, C, Q;
map<int, int> c[MN];
using mapit = map<int, int>::iterator;
DSU<MN> dsu;
void add_edge(void) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
mapit it;
it = c[x].find(z);
if (it != c[x].end())
dsu.mm(it->second, y);
else
c[x].insert({z, y});
it = c[y].find(z);
if (it != c[y].end())
dsu.mm(it->second, x);
else
c[y].insert({z, x});
dsu.add(x, y);
dsu.add(y, x);
}
int main(void) {
dsu.init();
scanf("%d%d%d%d", &N, &M, &C, &Q);
for (int i = 0; i < M; i++) add_edge();
for (int i = 0; i < Q; i++) {
char t;
scanf(" %c", &t);
if (t == '+')
add_edge();
else {
int x, y;
scanf("%d%d", &x, &y);
if (dsu.test(x, y))
printf("Yes\n");
else
printf("No\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int par[N];
set<int> verts[N];
set<pair<int, int> > cols[N];
int Find(int a) {
if (a == par[a])
return a;
else
return par[a] = Find(par[a]);
}
void Union(int a, int b) {
a = Find(a);
b = Find(b);
if (a == b) return;
if (verts[a].size() > verts[b].size()) swap(a, b);
for (int vert : verts[a]) verts[b].insert(vert);
par[a] = b;
}
void add(int u, int v, int col) {
verts[Find(u)].insert(v);
auto it = cols[v].upper_bound({col, -1});
if (it == cols[v].end() || it->first != col)
cols[v].insert({col, u});
else
Union(u, it->second);
}
int main() {
int n, m, c, q;
cin >> n >> m >> c >> q;
for (int i = 1; i <= n; ++i) par[i] = i;
while (m--) {
int u, v, col;
cin >> u >> v >> col;
add(u, v, col);
add(v, u, col);
}
while (q--) {
char c;
cin >> c;
if (c == '?') {
int u, v;
cin >> u >> v;
int fu = Find(u);
if (fu == Find(v) || verts[fu].count(v))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
int u, v, col;
cin >> u >> v >> col;
add(u, v, col);
add(v, u, col);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using v = vector<T>;
const long long inf = 4611686018427387903;
const long double EPS = 1e-10;
void read() {}
template <typename Arg, typename... Args>
void read(Arg& arg, Args&... args) {
cin >> (arg);
read(args...);
}
void print() {}
template <typename Arg, typename... Args>
void print(Arg arg, Args... args) {
cout << (arg) << " ";
print(args...);
}
long long getInt() {
long long a;
cin >> a;
return a;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long N = 1e5 + 1;
map<long long, long long> col[N];
set<long long> pos[N];
long long repr[N];
long long ffind(long long a) {
return (a == repr[a]) ? a : repr[a] = ffind(repr[a]);
}
void unite(long long a, long long b) {
a = ffind(a);
b = ffind(b);
if (a == b) return;
if (pos[a].size() > pos[b].size()) swap(a, b);
repr[a] = b;
for (long long i : pos[a]) pos[b].insert(i);
}
void add(long long x, long long y, long long z) {
if (col[x].count(z)) unite(col[x][z], y);
if (col[y].count(z)) unite(col[y][z], x);
pos[ffind(x)].insert(y);
pos[ffind(y)].insert(x);
col[x][z] = y;
col[y][z] = x;
}
void run() {
long long n, m, c, q;
read(n, m, c, q);
for (long long i = (0); i < (n + 1); i++) {
repr[i] = i;
pos[i].insert(i);
}
for (; m; m--) {
long long x, y, z;
read(x, y, z);
add(x, y, z);
}
for (; q; q--) {
string t;
cin >> t;
if (t == "+") {
long long x, y, z;
read(x, y, z);
add(x, y, z);
} else {
long long x, y;
read(x, y);
x = ffind(x);
if (pos[x].count(y)) {
cout << "Yes";
} else
cout << "No";
cout << endl;
}
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(12);
run();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
pair<vector<int>, set<int> > comp[N];
vector<map<int, int> > g;
int at[N];
int compSize(int u) { return comp[u].first.size() + comp[u].second.size(); }
void merge(int a, int b) {
a = at[a];
b = at[b];
if (a == b) return;
if (compSize(a) > compSize(b)) swap(a, b);
for (auto &x : comp[a].first) {
at[x] = b;
comp[b].first.push_back(x);
}
comp[b].second.insert(comp[a].second.begin(), comp[a].second.end());
}
void addEdge(int a, int b, int c) {
comp[at[a]].second.insert(b);
comp[at[b]].second.insert(a);
for (int q = 0; q < 2; ++q) {
auto it = g[a].find(c);
if (it != g[a].end())
merge(at[it->second], at[b]);
else
g[a][c] = b;
swap(a, b);
}
}
int main() {
int n;
scanf("%d", &n);
g.resize(n);
for (int i = 0; i < n; ++i) {
at[i] = i;
comp[i].first.push_back(i);
}
int m, c, q;
scanf("%d%d%d", &m, &c, &q);
for (int i = 0; i < m; ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
--a;
--b;
addEdge(a, b, c);
}
char t;
while (q--) {
int u, v, c;
scanf(" %c%d%d", &t, &u, &v);
--u;
--v;
if (t == '+') {
scanf("%d", &c);
addEdge(u, v, c);
} else {
if (at[u] == at[v] || comp[at[u]].second.count(v))
puts("Yes");
else
puts("No");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
const ld pi = acos(0) * 2;
template <typename T>
inline void read(T &x) {
char c;
bool nega = 0;
while ((!isdigit(c = getchar())) && (c != '-'))
;
if (c == '-') {
nega = 1;
c = getchar();
}
x = c - 48;
while (isdigit(c = getchar())) x = x * 10 + c - 48;
if (nega) x = -x;
}
template <typename T>
inline void writep(T x) {
if (x > 9) writep(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
writep(x);
}
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
map<int, vector<int> > g[100001];
vector<int> child[100001];
set<int> s[100001];
int r[100001];
int n, m, c, q;
int root(int u) {
if (r[u] < 0) return u;
return r[u] = root(r[u]);
}
bool unite(int u, int v) {
u = root(u);
v = root(v);
if (u == v) return 0;
if (r[u] > r[v]) swap(u, v);
r[u] += r[v];
r[v] = u;
for (int x : child[v]) {
for (auto p : g[x])
for (auto a : p.second) {
s[a].erase(v);
s[a].insert(u);
}
child[u].push_back(x);
}
child[v].clear();
return 1;
}
int main() {
read(n);
read(m);
read(c);
read(q);
{
int x, y, z;
for (int i = (1); i <= (m); i++) {
read(x);
read(y);
read(z);
g[x][z].push_back(y);
g[y][z].push_back(x);
}
}
for (int i = (1); i <= (n); i++) r[i] = -1;
for (int i = (1); i <= (n); i++) child[i].push_back(i);
for (int i = (1); i <= (n); i++)
for (auto p : g[i])
for (auto a : p.second) s[i].insert(a);
for (int i = (1); i <= (n); i++)
for (auto p : g[i])
for (int j = (1); j < (p.second.size()); j++)
unite(p.second[j], p.second[j - 1]);
{
char c;
int x, y, z;
for (int i = (1); i <= (q); i++) {
while (c = getchar())
if (c == '+' || c == '?') break;
read(x);
read(y);
if (c == '+') {
read(z);
g[x][z].push_back(y);
g[y][z].push_back(x);
s[x].insert(root(y));
s[y].insert(root(x));
if (g[x][z].size() > 1) unite(g[x][z][g[x][z].size() - 2], y);
if (g[y][z].size() > 1) unite(g[y][z][g[y][z].size() - 2], x);
} else {
if (root(x) == root(y))
puts("Yes");
else if (s[y].find(root(x)) != s[y].end())
puts("Yes");
else
puts("No");
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream in;
ofstream out;
const long long kk = 1000;
const long long ml = kk * kk;
const long long mod = ml * kk + 7;
const long long inf = ml * ml * ml + 7;
const long long gs = 500 * kk;
long n, m, i, j, c, q;
vector<long> reb[gs + 10];
vector<unordered_map<long long, long long>> have;
vector<set<long long>> nb;
vector<long long> col, tc, par, sz;
bool viv = false;
void prepare() {
for (long long i = 0; i < n; i++) par.push_back(i);
sz.resize(n, 1);
nb.resize(n);
have.resize(n);
}
long long lead(long long v) {
if (par[v] == v) return v;
par[v] = lead(par[v]);
return par[v];
}
void merge(long long v1, long long v2) {
if (v1 == v2) return;
if (nb[v1].size() < nb[v2].size()) swap(v1, v2);
sz[v1] += sz[v2];
sz[v2] = 0;
par[v2] = v1;
for (auto v : nb[v2]) nb[v1].insert(v);
}
void add(long long v1, long long v2, long long cr) {
if (have[v1].find(cr) != have[v1].end()) merge(lead(v2), lead(have[v1][cr]));
if (have[v2].find(cr) != have[v2].end()) merge(lead(v1), lead(have[v2][cr]));
nb[lead(v1)].insert(v2);
nb[lead(v2)].insert(v1);
have[v1][cr] = v2;
have[v2][cr] = v1;
}
bool exist(long long st, long long fin) {
if (lead(st) == lead(fin)) return true;
long long v = lead(st);
if (nb[v].find(fin) != nb[v].end()) return true;
return false;
}
void qrs() {
for (long long i = 0; i < q; i++) {
string str;
cin >> str;
if (str == "+") {
long long a, b, c;
cin >> a >> b >> c;
a--, b--, c--;
add(a, b, c);
} else {
long long a, b;
cin >> a >> b;
a--, b--;
if (exist(a, b))
cout << "Yes\n";
else
cout << "No\n";
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> c >> q;
prepare();
for (i = 0; i < m; i++) {
long a, b, c;
cin >> a >> b >> c;
a--;
b--;
c--;
add(a, b, c);
}
qrs();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int nodes, initialRoads, totalColours, totalQueries;
const int NMAX = 100505;
struct query {
int from, to, colour;
bool addEdge;
};
vector<query> queries;
set<pair<int, int>> edges[NMAX];
set<int> reachable[NMAX];
vector<int> components[NMAX];
int whichComponent[NMAX];
void read() {
cin >> nodes >> initialRoads >> totalColours >> totalQueries;
queries.reserve(initialRoads + totalQueries);
int from, to, colour;
for (int roadIdx = 0; roadIdx < initialRoads; roadIdx++) {
cin >> from >> to >> colour;
queries.push_back({from, to, colour, true});
}
string type;
for (int queryIdx = 0; queryIdx < totalQueries; queryIdx++) {
cin >> type;
if (type == "?") {
cin >> from >> to;
queries.push_back({from, to, -1, false});
} else {
cin >> from >> to >> colour;
queries.push_back({from, to, colour, true});
}
}
}
void prepareStructs() {
for (int node = 1; node <= nodes; node++) {
components[node].push_back(node);
whichComponent[node] = node;
reachable[node].insert(whichComponent[node]);
}
}
void updateReachable(int from, int oldComponent, int newComponent) {
for (auto neighbour : edges[from]) {
reachable[neighbour.second].erase(oldComponent);
reachable[neighbour.second].insert(newComponent);
}
reachable[from].erase(oldComponent);
reachable[from].insert(newComponent);
}
void addEdgeInRainbowGraph(int from, int to) {
if (whichComponent[from] == whichComponent[to]) {
return;
}
int component1 = whichComponent[from], component2 = whichComponent[to];
if (components[component1].size() < components[component2].size()) {
for (auto node : components[component1]) {
updateReachable(node, component1, component2);
whichComponent[node] = component2;
}
components[component2].insert(components[component2].end(),
components[component1].begin(),
components[component1].end());
components[component1].clear();
} else {
for (auto node : components[component2]) {
updateReachable(node, component2, component1);
whichComponent[node] = component1;
}
components[component1].insert(components[component1].end(),
components[component2].begin(),
components[component2].end());
components[component2].clear();
}
}
int extractCandidateEdge(int from, int excludingNode, int colour) {
auto edge = edges[from].lower_bound({colour, -1});
if (edge != edges[from].end() && edge->second == excludingNode) {
edge++;
}
if (edge != edges[from].end() && edge->first != colour) {
return -1;
}
return edge != edges[from].end() ? edge->second : -1;
}
void addEdgesInRainbowGraph(int from, int to, int colour) {
int neighbourIntoFrom = extractCandidateEdge(from, to, colour);
if (neighbourIntoFrom != -1) {
addEdgeInRainbowGraph(neighbourIntoFrom, to);
}
int neighbourIntoTo = extractCandidateEdge(to, from, colour);
if (neighbourIntoTo != -1) {
addEdgeInRainbowGraph(neighbourIntoTo, from);
}
}
void addEdgeAndUpdateReachability(int from, int to, int colour) {
edges[from].insert({colour, to});
reachable[to].insert(whichComponent[from]);
}
void solve() {
for (query &currQuery : queries) {
if (currQuery.addEdge) {
addEdgeAndUpdateReachability(currQuery.from, currQuery.to,
currQuery.colour);
addEdgeAndUpdateReachability(currQuery.to, currQuery.from,
currQuery.colour);
addEdgesInRainbowGraph(currQuery.from, currQuery.to, currQuery.colour);
} else {
if (reachable[currQuery.to].find(whichComponent[currQuery.from]) ==
reachable[currQuery.to].end()) {
cout << "No\n";
} else {
cout << "Yes\n";
}
}
}
}
int main() {
read();
prepareStructs();
solve();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.