text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int const MAX = 2e5 + 41;
int n, m, q;
vector<int> e[MAX][2];
int ans;
int u[MAX][2];
int x[MAX];
int y[MAX];
void dfs(int x, int p) {
u[x][p] = 1;
for (int y : e[x][p]) {
if (!u[y][1 - p]) {
dfs(y, 1 - p);
}
}
}
void solve() {
if (n == 1) {
set<int> t;
for (int i = 1; i <= q; i++) {
t.insert(y[i]);
}
printf("%d\n", m - (int)t.size());
return;
}
if (m == 1) {
set<int> t;
for (int i = 1; i <= q; i++) {
t.insert(x[i]);
}
printf("%d\n", n - (int)t.size());
return;
}
ans = -1;
for (int i = 1; i <= n; i++) {
if (!u[i][0]) {
ans++;
dfs(i, 0);
}
}
for (int i = 1; i <= m; i++) {
if (!u[i][1]) {
ans++;
dfs(i, 1);
}
}
printf("%d\n", ans);
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= q; i++) {
scanf("%d %d", &x[i], &y[i]);
e[x[i]][0].push_back(y[i]);
e[y[i]][1].push_back(x[i]);
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fa[200005 << 1], mark[200005 << 1];
int Find(int x) { return fa[x] == x ? x : fa[x] = Find(fa[x]); }
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n + m; i++) fa[i] = i;
for (int i = 1, x, y; i <= q; i++) {
scanf("%d%d", &x, &y), y += n;
int k1 = Find(x), k2 = Find(y);
fa[k2] = k1;
}
int ans = -1;
for (int i = 1; i <= n + m; i++) {
int k1 = Find(i);
if (!mark[k1]) mark[k1] = 1, ans++;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10000100;
int n, m, k;
int h[N], e[N], ne[N], idx;
bool st[N];
void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
void dfs(int u) {
st[u] = true;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (st[j]) {
continue;
}
dfs(j);
}
}
int main() {
int cnt = 0;
cin >> n >> m >> k;
memset(h, -1, sizeof h);
while (k--) {
int a, b;
cin >> a >> b;
add(a, b + n), add(b + n, a);
}
for (int i = 1; i <= n + m; i++) {
if (!st[i]) {
dfs(i);
cnt++;
}
}
cout << cnt - 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long maxn = 4e5 + 5;
vector<int> e[maxn];
bool vis[maxn], in[maxn];
int sum = 0, num = 0, dfn[maxn], low[maxn];
stack<int> st;
void tarjan(int d) {
vector<int>::iterator i;
int dd;
st.push(d);
in[d] = vis[d] = 1;
num++;
low[d] = dfn[d] = num;
for (i = e[d].begin(); i != e[d].end(); i++) {
dd = *i;
if (!vis[dd]) {
tarjan(dd);
low[d] = min(low[d], low[dd]);
} else if (in[dd])
low[d] = min(low[d], dfn[dd]);
}
if (dfn[d] == low[d]) {
sum++;
while (st.top() != d) {
in[st.top()] = 0;
st.pop();
}
in[d] = 0;
st.pop();
}
}
int main() {
int n, m, q, i, r, c;
scanf("%d%d%d", &n, &m, &q);
while (q--) {
scanf("%d%d", &r, &c);
c += n;
e[r].push_back(c);
e[c].push_back(r);
}
for (i = 1; i <= n + m; i++) {
vis[i] = false;
in[i] = 0;
}
for (i = 1; i <= n + m; i++)
if (!vis[i]) tarjan(i);
printf("%d", sum - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mxsz = 2e5 + 5;
vector<long long> X[mxsz], Y[mxsz];
struct DSU {
vector<long long> p;
inline long long find(long long n) {
return p[n] == n ? n : p[n] = find(p[n]);
}
inline void join(long long a, long long b) { p[find(a)] = find(b); }
DSU(long long n) : p(n) {
for (long long i = 0; i < n; i++) p[i] = i;
}
};
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
long long n, m, k;
cin >> n >> m >> k;
if (!k) return cout << n + m - 1 << '\n', 0;
vector<tuple<long long, long long> > v(k);
for (long long i = 0, x, y; i < k; i++)
cin >> x >> y, --x, --y, v[i] = tie(x, y), X[x].push_back(y),
Y[y].push_back(x);
long long sum = 0;
for (long long i = 0; i < n; i++) sum += X[i].size() == 0;
for (long long i = 0; i < m; i++) sum += Y[i].size() == 0;
DSU dsu(n + m);
for (long long x = 0; x < n; x++)
for (long long y : X[x]) dsu.join(x, n + y);
for (long long y = 0; y < m; y++)
for (long long x : Y[y]) dsu.join(x, n + y);
set<long long> st;
for (auto it : v) {
long long x, y;
tie(x, y) = it;
st.insert(dsu.find(x));
}
sum += st.size() - 1;
cout << sum << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (!((ch = getchar() - 48) >= 0))
;
int v = ch;
while (((ch = getchar() - 48) >= 0)) v = (v << 1) + (v << 3) + ch;
return v;
}
int n, m, q, x, y, cnt, head[200005 << 1];
bool f[200005 << 1];
struct node {
int to, next;
} e[200005 << 1];
void insert(int u, int v) {
e[++cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
e[++cnt].to = u;
e[cnt].next = head[v];
head[v] = cnt;
}
void dfs(int x) {
f[x] = 1;
for (int i = head[x]; i; i = e[i].next)
if (!f[e[i].to]) dfs(e[i].to);
}
int main() {
n = get();
m = get();
q = get();
for (int i = 1; i <= q; i++) x = get(), y = get(), insert(x, y + n);
int ans = 0;
for (int i = 1; i <= n + m; i++)
if (!f[i]) ans++, dfs(i);
printf("%d\n", ans - 1);
return 0;
}
|
#include <bits/stdc++.h>
int r, c, q, E;
int to[200005 * 4], first[200005 * 2], next[200005 * 4];
int scx[200005 * 2];
inline void addedge(int u, int v) {
to[++E] = v;
next[E] = first[u];
first[u] = E;
to[++E] = u;
next[E] = first[v];
first[v] = E;
}
void dfs(int x) {
int i, y;
scx[x] = 1;
for (i = first[x]; i; i = next[i])
if (!scx[y = to[i]]) dfs(y);
}
int main() {
int i, u, v, ans = 0;
scanf("%d%d%d", &r, &c, &q);
for (i = 1; i <= q; ++i) {
scanf("%d%d", &u, &v);
addedge(u, v + r);
}
for (i = 1; i <= r + c; ++i)
if (!scx[i]) dfs(i), ++ans;
printf("%d\n", --ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const long double PI = 3.14159265358979323846;
const long double eps = 1e-5;
const int INF = numeric_limits<int>::max();
const long long LINF = numeric_limits<long long>::max();
const long long mod = 1000 * 1000 * 1000 + 7;
vector<vector<int> > g;
vector<int> used;
void dfs(int pos) {
used[pos] = 1;
for (int i = 0; i < g[pos].size(); ++i) {
int to = g[pos][i];
if (used[to]) continue;
dfs(to);
}
}
void solve() {
int n, m, q;
cin >> n >> m >> q;
g.resize(m + n);
for (int i = 0; i < q; ++i) {
int x, y;
cin >> x >> y;
--x, --y;
y += n;
g[x].push_back(y);
g[y].push_back(x);
}
int res = 0;
used.assign(m + n, 0);
for (int i = 0; i < m + n; ++i) {
if (used[i]) continue;
dfs(i);
++res;
}
cout << res - 1 << endl;
}
int main() {
ios_base::sync_with_stdio(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[400000];
int N, M, Q, a, b, comp;
bool volt[400000];
void DFS(int p) {
volt[p] = 1;
for (int q : G[p])
if (!volt[q]) DFS(q);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> N >> M >> Q;
for (int i = 0; i < Q; i++) {
cin >> a >> b;
a--;
b = b + N - 1;
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 0; i < N + M; i++) {
if (!volt[i]) {
comp++;
DFS(i);
}
}
cout << comp - 1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353ll;
const long long int P = 1000000007ll;
const long long int N = 400005ll;
long long int a[N];
long long int p[N];
long long int dsu(long long int x) {
if (p[x] == x) return x;
p[x] = dsu(p[x]);
return p[x];
}
void solve() {
long long int n, m;
cin >> n >> m;
for (long long int i = (1); i <= (n + m); ++i) p[i] = i;
long long int q;
cin >> q;
while (q--) {
long long int x, y;
cin >> x >> y;
y += n;
long long int x1 = dsu(x);
long long int y1 = dsu(y);
p[y1] = x1;
}
long long int ans = 0;
for (long long int i = (1); i <= (n + m); ++i)
if (p[i] == i) ++ans;
cout << ans - 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int f[N * 2 + 10];
void init(int n) {
for (int i = 1; i <= n; i++) f[i] = i;
}
int getf(int x) { return f[x] == x ? x : f[x] = getf(f[x]); }
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
init(n + m);
for (int i = 1; i <= q; i++) {
int x, y;
scanf("%d%d", &x, &y);
f[getf(y + n)] = getf(x);
}
int ans = -1;
for (int i = 1; i <= n + m; i++) ans += f[i] == i;
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
vector<int> a[400002];
bool vis[400002];
void dfs(int u) {
vis[u] = 1;
for (int v : a[u]) {
if (!vis[v]) {
dfs(v);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
fill(vis + 1, vis + 1 + n + m, 0);
for (int i = 1; i <= q; i++) {
int x, y;
scanf("%d%d", &x, &y);
y += n;
a[x].push_back(y);
a[y].push_back(x);
}
int cnt = 0;
for (int i = 1; i <= n + m; i++)
if (!vis[i]) {
dfs(i);
cnt++;
}
printf("%d", cnt - 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 10;
int n, m, q;
vector<int> G[N * 2];
bool vis[N * 2];
void dfs(int u) {
vis[u] = true;
for (auto v : G[u]) {
if (!vis[v]) {
dfs(v);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
int x, y;
while (q--) {
cin >> x >> y;
G[x].push_back(y + n);
G[y + n].push_back(x);
}
int ans = 0;
for (int i = 1; i <= n + m; i++) {
if (!vis[i]) {
dfs(i);
ans++;
}
}
cout << ans - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void dfs(int u, const vector<vector<int> > &adj,
const vector<vector<int> > &col, vector<bool> &vis, set<int> &ms) {
vis[u] = true;
for (int v : col[u]) ms.insert(v);
for (int v : adj[u]) {
if (!vis[v]) dfs(v, adj, col, vis, ms);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
vector<vector<int> > adj, col, row;
adj.resize(m);
col.resize(m);
row.resize(n);
for (int i = 0; i < q; ++i) {
int a, b;
cin >> a >> b;
row[a - 1].push_back(b - 1);
col[b - 1].push_back(a - 1);
}
int state = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j + 1 < row[i].size(); ++j) {
adj[row[i][j + 1]].push_back(row[i][j]);
adj[row[i][j]].push_back(row[i][j + 1]);
}
}
set<int> ms;
vector<bool> vis(m, false);
for (int i = 0; i < m; ++i) {
if (!vis[i]) {
dfs(i, adj, col, vis, ms);
state++;
}
}
cout << state - 1 + n - ms.size() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char ch = getchar();
int fh = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') fh = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= fh;
}
template <typename T>
void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void writeln(T x) {
write(x);
puts("");
}
int n, m, q;
int fa[400005];
int fnd(int x) {
if (fa[x] != x) fa[x] = fnd(fa[x]);
return fa[x];
}
signed main() {
cin >> n >> m >> q;
for (int i = 1; i <= n + m; ++i) fa[i] = i;
while (q--) {
int r, c;
cin >> r >> c;
fa[fnd(r)] = fnd(n + c);
}
int ans = -1;
for (int i = 1; i <= n + m; ++i)
if (fnd(i) == i) ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, q, to;
vector<vector<long long> > v(400400);
vector<long long> used(400400, 0);
void dfs(long long ver) {
used[ver] = 1;
for (long long j = 0; j < (long long)v[ver].size(); j++) {
if (used[v[ver][j]] == 0) {
dfs(v[ver][j]);
}
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> q;
if (n == 1 || m == 1) {
cout << n * m - q;
return 0;
}
long long a, b;
for (long long i = 1; i <= q; i++) {
cin >> a >> b;
v[a].push_back(n + b);
v[n + b].push_back(a);
}
long long ans = 0, tec = n + m;
for (long long i = 1; i <= n + m; i++) {
if (used[i] == 0) {
dfs(i);
ans++;
}
}
cout << ans - 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, ans;
int num;
int fa[400005];
void init(int t) {
num = t;
for (int i = 1; i <= num; i++) {
fa[i] = i;
}
}
int find(int x) {
if (fa[x] == x) {
return x;
}
return fa[x] = find(fa[x]);
}
void merge(int x, int y) { fa[find(y)] = fa[find(x)]; }
int main() {
cin >> n >> m >> q;
init(n + m);
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
b += n;
merge(a, b);
}
for (int i = 1; i <= n + m; i++) {
if (fa[i] == i) {
ans++;
}
}
cout << ans - 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 600010;
const int INF = 2147483600;
int fa[MAXN + 1];
int N, M, Q;
inline int find(int x) { return x == fa[x] ? x : (fa[x] = find(fa[x])); }
inline void merge(int u, int v) {
int x = find(u), y = find(v);
if (x == y) return;
fa[y] = x;
}
int main() {
N = read(), M = read(), Q = read();
int cnt = 0;
for (int i = 1; i <= N + M; i++) fa[i] = i;
for (int i = 1; i <= Q; i++) {
int u = read(), v = read();
merge(u, v + N);
}
for (int i = 1; i <= N + M; i++)
if (fa[i] == i) ++cnt;
printf("%d\n", cnt - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename num_t>
inline void addmod(num_t& a, const long long& b, const int& m) {
a = (a + b) % m;
if (a < 0) a += m;
}
template <typename num_t>
inline void update_max(num_t& a, const num_t& b) {
a = max(a, b);
}
template <typename num_t>
inline void update_min(num_t& a, const num_t& b) {
a = min(a, b);
}
template <typename num_t>
num_t gcd(num_t lhs, num_t rhs) {
return !lhs ? rhs : gcd(rhs % lhs, lhs);
}
template <typename num_t>
num_t pw(num_t n, num_t k, num_t mod) {
num_t res = 1;
for (; k; k >>= 1) {
if (k & 1) res = 1ll * res * n % mod;
n = 1ll * n * n % mod;
}
return res;
}
const int inf = 1e9 + 7;
const long long ll_inf = 1ll * inf * inf;
const int max_n = 200000 + 7;
const int mod = inf;
struct DisjoinSet {
vector<int> r;
int n, group_count;
void init(int n_) {
n = n_;
r.resize(n + 1);
fill(r.begin(), r.end(), -1);
group_count = n;
}
int get_root(int u) { return r[u] < 0 ? u : r[u] = get_root(r[u]); }
bool is_root(int u) { return u == get_root(u); }
bool join(int u, int v) {
u = get_root(u);
v = get_root(v);
if (u == v) return false;
if (r[u] > r[v]) swap(u, v);
r[u] += r[v];
r[v] = u;
--group_count;
return true;
}
int size(int u) { return -r[get_root(u)]; }
bool connected(int u, int v) { return get_root(u) == get_root(v); }
} dsu;
bitset<max_n> row_mask, col_mask;
int n, m, q;
vector<pair<int, int>> row[max_n], col[max_n];
void solve() {
cin >> n >> m >> q;
for (int i = 0; i < n; ++i) row_mask[i] = true;
for (int j = 0; j < m; ++j) col_mask[j] = true;
dsu.init(q);
for (int i = (0), _b = (q); i < _b; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
col_mask.reset(v);
row_mask.reset(u);
row[u].push_back({v, i});
col[v].push_back({u, i});
}
if (n == 1 || m == 1) {
cout << n * m - q << '\n';
return;
}
for (int i = 0; i < n; ++i) {
for (int j = 1; j < row[i].size(); ++j) {
dsu.join(row[i][j].second, row[i][j - 1].second);
}
}
for (int i = 0; i < m; ++i) {
for (int j = 1; j < col[i].size(); ++j) {
dsu.join(col[i][j].second, col[i][j - 1].second);
}
}
cout << dsu.group_count + row_mask.count() + col_mask.count() - 1 << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 5;
int n, m, q, ans;
bool v[maxn];
vector<int> g[maxn];
void dfs(int x) {
if (v[x]) return;
v[x] = true;
for (int y : g[x]) dfs(y);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> q;
int x, y;
while (q--) {
cin >> x >> y;
y += n;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n + m; i++)
if (!v[i]) {
dfs(i);
ans++;
}
cout << ans - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m, el_nr;
cin >> n >> m >> el_nr;
vector<vector<int> > vertex___neigh_v(n + m);
for (int i = 0; i < el_nr; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
vertex___neigh_v[x].push_back(y + n);
vertex___neigh_v[y + n].push_back(x);
}
vector<int> vertex___is_visited(n + m, 0);
int components_nr = 0;
for (int vertex = 0; vertex < n + m; vertex++) {
if (vertex___is_visited[vertex]) {
continue;
}
stack<int> dfsstack;
dfsstack.push(vertex);
vertex___is_visited[vertex] = 1;
while (!dfsstack.empty()) {
int curr_v = dfsstack.top();
dfsstack.pop();
for (int neigh_v : vertex___neigh_v[curr_v]) {
if (!vertex___is_visited[neigh_v]) {
vertex___is_visited[neigh_v] = 1;
dfsstack.push(neigh_v);
}
}
}
components_nr++;
}
cout << components_nr - 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + (ch ^ 48), ch = getchar();
return x * f;
}
void Write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) Write(x / 10);
putchar(x % 10 + 48);
}
inline void writes(long long x) { Write(x), putchar(' '); }
inline void Writes(long long x) { Write(x), putchar('\n'); }
int n, m, q;
vector<int> dx[201010], dy[201010];
int fa[201010], from[201010];
bool vis[201010];
int Get(int x) { return x == fa[x] ? x : fa[x] = Get(fa[x]); }
void Merge(int x, int y) {
x = Get(x), y = Get(y);
if (x != y) fa[x] = y;
}
int main() {
n = read(), m = read(), q = read();
for (int i = 1; i <= m; ++i) fa[i] = i;
for (int i = 1; i <= q; ++i) {
int x = read(), y = read();
dx[x].push_back(y), dy[y].push_back(x);
}
for (int i = 1; i <= m; ++i) {
for (int j = 0; j < dy[i].size(); ++j) {
int x = dy[i][j], y = i;
if (!from[x])
from[x] = y;
else
Merge(from[x], y), from[x] = Get(from[x]);
}
}
int ans = n;
for (int i = 1; i <= n; ++i)
if (from[i]) ans--;
for (int i = 1; i <= m; ++i) {
int root = Get(i);
if (!vis[root]) ans++;
vis[root] = 1;
}
Writes(ans - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI =
3.141592653589793238462643383279502884197169399375105820974944;
int ans = -1;
vector<vector<int> > adj[2];
vector<int> visited[2];
void dfs(int node, int type) {
visited[type][node] = 1;
for (int x : adj[type][node]) {
if (!visited[1 - type][x]) dfs(x, 1 - type);
}
}
int main() {
int n, m, q;
cin >> n >> m >> q;
adj[0].resize(n + 1);
adj[1].resize(m + 1);
visited[1].assign(m + 1, 0);
visited[0].assign(n + 1, 0);
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
adj[0][x].push_back(y);
adj[1][y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (!visited[0][i]) {
ans++;
dfs(i, 0);
}
for (int i = 1; i <= m; i++)
if (!visited[1][i]) {
ans++;
dfs(i, 1);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
bool Debug;
const int mod = 1e9 + 7;
const int MAXN = 1e5 + 7;
template <typename T>
T gcd(T a, T b) {
T t;
while (t = a % b) a = b, b = t;
return b;
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T>
T Pow(T a, T b) {
T ret = 1;
for (; b; b >>= 1) {
if (b & 1) ret = ret * 1ull * a % mod;
a = a * 1ull * a % mod;
}
return ret % mod;
}
template <typename T>
void chmax(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
void chmin(T &x, T y) {
if (x > y) x = y;
}
template <typename T>
void amod(T &x, T y) {
x += y;
if (x >= mod) x -= mod;
}
template <typename T>
void smod(T &x, T y) {
x -= y;
if (x < 0) x += mod;
}
struct IO {
static const int S = 5 << 20;
int c, f, sta[24], n;
char wbuf[S], *p2, buf[S], *p1, *end, *wend;
IO() { p1 = end = buf, p2 = wbuf, wend = p2 + S; }
int getc() {
return p1 == end && (end = (p1 = buf) + fread(buf, 1, S, stdin), p1 == end)
? EOF
: *p1++;
}
template <typename T>
void read(T &x) {
x = 0;
for (c = getc(), f = 1; !isdigit(c); c = getc()) (c == '-') && (f = -1);
while (isdigit(c)) x = x * 10 + c - '0', c = getc();
x *= f;
}
void get(char *s) {
for (c = getc(); c <= 32; c = getc())
;
for (c = getc(); c > 32; *s++ = c, c = getc())
;
*s = 0;
}
void put(int x) {
if (p2 == wend) fwrite(wbuf, 1, S, stdout), p2 = wbuf;
*p2++ = x;
}
template <typename T>
void out(T x, int y) {
if (x < 0) put('-'), x = -x;
for (n = 0; x || !n; sta[++n] = x % 10 + '0', x /= 10)
;
while (n) put(sta[n--]);
put(y);
}
void print(const char *s, int y) {
while (*s) put(*s++);
put(y);
}
~IO() { fwrite(wbuf, 1, p2 - wbuf, stdout), p2 = wbuf; }
} io;
int n, m, q;
struct Node {
int x, y;
} a[200005];
int fa[400005], ans, is[400005];
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);
fa[x] = y;
}
int main() {
((io.read(n)), (io.read(m)), (io.read(q)));
for (int i = 1; i <= n + m; ++i) fa[i] = i;
for (int i = (1); i <= (q); ++i)
((io.read(a[i].x)), (io.read(a[i].y))), merge(a[i].x, a[i].y + n);
for (int i = 1; i <= n + m; ++i) {
is[Find(i)] = 1;
}
for (int i = 1; i <= n + m; ++i) ans += is[i];
cout << ans - 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
vector<vector<int>> r(n), c(m);
for (int i = 0; i < q; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
r[x].push_back(y);
c[y].push_back(x);
}
if (n == 1) {
cout << m - q;
return 0;
}
if (m == 1) {
cout << n - q;
return 0;
}
vector<char> used_row(n, false);
vector<char> used_col(m, false);
int ans = 0;
vector<int> cols_to_add(r[0]), next_cols_to_add;
used_row[0] = true;
for (int i = 0; i < m; ++i) {
if (used_col[i]) continue;
while (!cols_to_add.empty()) {
next_cols_to_add.clear();
for (int col : cols_to_add) {
if (used_col[col]) continue;
used_col[col] = true;
for (int row : c[col]) {
if (used_row[row]) continue;
used_row[row] = true;
for (int new_col : r[row]) {
next_cols_to_add.push_back(new_col);
}
}
}
cols_to_add = next_cols_to_add;
}
if (!used_col[i]) {
++ans;
cols_to_add.push_back(i);
}
}
while (!cols_to_add.empty()) {
next_cols_to_add.clear();
for (int col : cols_to_add) {
if (used_col[col]) continue;
used_col[col] = true;
for (int row : c[col]) {
if (used_row[row]) continue;
used_row[row] = true;
for (int new_col : r[row]) {
next_cols_to_add.push_back(new_col);
}
}
}
cols_to_add = next_cols_to_add;
}
for (int i = 1; i < n; ++i) {
if (!used_row[i]) {
++ans;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400002;
int n, m, z, pre[maxn], num, x2, y2;
int finds(int x) { return x == pre[x] ? x : pre[x] = finds(pre[x]); }
int unions(int x, int y) {
int x1 = finds(x);
int y1 = finds(y);
if (x1 != y1) {
pre[y1] = x1;
return 1;
}
return 0;
}
int main() {
scanf("%d%d%d", &n, &m, &z);
num = n + m - 1;
for (int i = 1; i <= n + m; i++) pre[i] = i;
for (int i = 1; i <= z; i++) {
scanf("%d%d", &x2, &y2);
if (unions(x2, y2 + n) == 1) num--;
}
printf("%d\n", num);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 400004;
vector<int> e[mx];
bool mark[mx];
void dfs(int x) {
mark[x] = true;
for (auto it : e[x]) {
if (!mark[it]) dfs(it);
}
}
int main() {
int n, m, q;
cin >> n >> m >> q;
while (q--) {
int x, y;
cin >> x >> y;
y += n;
e[x].push_back(y);
e[y].push_back(x);
}
int sol = 0;
for (int i = 1; i <= n + m; i++) {
if (!mark[i]) sol++, dfs(i);
}
cout << sol - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 4e5 + 10;
int f[maxn];
bool g[maxn] = {0};
int fa(int x) {
if (f[x] == x) return x;
f[x] = fa(f[x]);
return f[x];
}
int main() {
int n, m, q, x, y;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = n + 1; i <= n + m; i++) f[i] = i;
while (q--) {
scanf("%d%d", &x, &y);
y += n;
int r1 = fa(x), r2 = fa(y);
if (r1 != r2) f[r1] = r2;
}
int l = 0;
for (int i = 1; i <= n + m; i++) {
y = fa(i);
if (!g[y]) {
l++;
g[y] = 1;
}
}
printf("%d\n", l - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int N = 400000 + 5;
int n, m, q;
int par[N], sizes[N];
int get(int x) { return par[x] == x ? x : par[x] = get(par[x]); }
void join(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return;
if (sizes[a] > sizes[b]) swap(a, b);
par[a] = b;
sizes[b] += sizes[a];
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n + m; i++) {
par[i] = i;
sizes[i] = 1;
}
int a, b;
while (q--) {
scanf("%d %d", &a, &b);
b += n;
join(a, b);
}
int ans = -1;
for (int i = 1; i <= n + m; i++) {
if (par[i] == i) ans += 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000, MAXM = 200000, MAXQ = 200000;
int N, M, Q;
int X[MAXQ + 1], Y[MAXQ + 1];
int par[MAXN + MAXM + 1];
int ans;
void init() {
scanf("%d %d %d", &N, &M, &Q);
for (int i = 1; i <= Q; ++i) scanf("%d %d", &X[i], &Y[i]);
for (int i = 1; i <= N + M; ++i) par[i] = i;
}
int Find(int x) { return x == par[x] ? x : par[x] = Find(par[x]); }
void solve() {
ans = N + M - 1;
for (int i = 1; i <= Q; ++i) {
int u = X[i], v = Y[i] + N;
int p = Find(u), q = Find(v);
if (p != q) {
ans--;
par[p] = q;
}
}
cout << ans << endl;
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > FR, FC;
vector<bool> VR, VC;
vector<int> QR, QC;
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
FR.resize(n);
FC.resize(m);
for (int i = 0; i < q; i++) {
int j, k;
scanf("%d%d", &j, &k);
FR[j - 1].push_back(k - 1);
FC[k - 1].push_back(j - 1);
}
if (n == 1) {
printf("%d\n", m - FR[0].size());
return 0;
}
if (m == 1) {
printf("%d\n", n - FC[0].size());
return 0;
}
int ans = -1;
VR.assign(FR.size(), false);
VC.assign(FC.size(), false);
for (int r0 = 0; r0 < FR.size(); r0++)
if (!VR[r0]) {
ans++;
VR[r0] = true;
QR.clear();
QR.push_back(r0);
while (!QR.empty()) {
QC.clear();
for (auto r : QR) {
for (auto c : FR[r])
if (!VC[c]) {
VC[c] = true;
QC.push_back(c);
}
}
QR.clear();
for (auto c : QC) {
for (auto r : FC[c])
if (!VR[r]) {
VR[r] = true;
QR.push_back(r);
}
}
}
}
for (int c0 = 0; c0 < FC.size(); c0++)
if (!VC[c0]) ans++;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fa[500000];
int ffa(int x) {
if (fa[x] != x) fa[x] = ffa(fa[x]);
return fa[x];
}
void unite(int x, int y) {
x = ffa(x), y = ffa(y);
fa[y] = x;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 200001; i <= m + 200000; i++) fa[i] = i;
for (int i = 1; i <= q; i++) {
int r, c;
scanf("%d%d", &r, &c);
unite(r, c + 200000);
}
int now = 0;
for (int i = 1; i <= n; i++)
if (fa[i] != i) now++;
for (int i = 200001; i <= m + 200000; i++)
if (fa[i] != i) now++;
int ans = n + m - now - 1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, m, q, fa[maxn << 1], vis[maxn << 1];
int fd(int x) { return fa[x] == x ? x : fa[x] = fd(fa[x]); }
int main() {
scanf("%d%d%d", &n, &m, &q);
for (register int i = 1; i <= n + m; ++i) fa[i] = i;
for (register int i = 1, x, y; i <= q; ++i) {
scanf("%d%d", &x, &y);
fa[fd(x)] = fd(y + n);
}
int ans = 0;
for (register int i = 1; i <= n + m; ++i)
if (!vis[fd(i)]) ans++, vis[fd(i)] = 1;
printf("%d\n", ans - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int R[maxn], C[maxn], pa[maxn], x[maxn], y[maxn];
int n, m, Q, last, reX, reY, ans;
vector<int> X[maxn], Y[maxn], q[maxn];
inline int getpa(int x) { return pa[x] == x ? x : pa[x] = getpa(pa[x]); }
int main() {
scanf("%d%d%d", &n, &m, &Q);
if (!Q) return printf("%d\n", n + m - 1), 0;
reX = n;
reY = m;
for (int i = (1); i <= (Q); i++) {
scanf("%d%d", &x[i], &y[i]);
if (!R[x[i]]) reX--;
if (!C[y[i]]) reY--;
R[x[i]] = C[y[i]] = 1;
X[x[i]].push_back(i);
Y[y[i]].push_back(i);
pa[i] = i;
}
ans = reX + reY;
for (int i = (1); i <= (n); i++) {
last = 0;
while (!X[i].empty()) {
if (last) pa[getpa(last)] = getpa(X[i].back());
last = X[i].back();
X[i].pop_back();
}
}
for (int i = (1); i <= (m); i++) {
last = 0;
while (!Y[i].empty()) {
if (last) pa[getpa(last)] = getpa(Y[i].back());
last = Y[i].back();
Y[i].pop_back();
}
}
ans--;
for (int i = (1); i <= (Q); i++)
if (pa[i] == i) ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int n = 0, f = 1, ch = getchar();
while (ch == ' ' || ch == '\n') ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
n = n * 10 + ch - '0';
ch = getchar();
}
return n * f;
}
int fa[500000];
int findf(int n) {
if (fa[n] == n) return n;
return fa[n] = findf(fa[n]);
}
int main() {
int n, m, q, ans, x, y;
n = read();
m = read();
q = read();
for (int i = 1; i <= n + m; i++) fa[i] = i;
ans = n + m;
for (int i = 1; i <= q; i++) {
x = read();
y = read();
y += n;
x = findf(x);
y = findf(y);
if (x != y) {
fa[x] = y;
ans--;
}
}
cout << ans - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > Adj;
vector<int> Component;
void BFS(int start, int c) {
queue<int> Q;
Q.push(start);
Component[start] = c;
while (!Q.empty()) {
int v = Q.front();
Q.pop();
for (int x : Adj[v]) {
if (Component[x] == -1) {
Component[x] = c;
Q.push(x);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
Adj.resize(n + m + 3);
Component.resize(n + m + 1, -1);
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
Adj[a].push_back(n + b);
Adj[n + b].push_back(a);
}
int c = 0;
for (int i = 1; i <= n + m; i++) {
if (Component[i] == -1) {
BFS(i, c);
c++;
}
}
cout << c - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int mxN = 200010;
struct DSU {
vector<int> p, sz;
DSU(int N) {
p.resize(N);
sz.resize(N, 1);
for (int i = 0; i < N; i++) p[i] = i;
}
int par(int x) {
if (x == p[x]) return x;
return p[x] = par(p[x]);
}
bool mrg(int x, int y) {
x = par(x), y = par(y);
if (x == y) return false;
if (sz[x] < sz[y]) {
swap(x, y);
}
p[y] = p[x];
sz[x] += sz[y];
return true;
}
};
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N, M, q, x, y;
cin >> N >> M >> q;
DSU dsu(N + M);
for (int i = 0; i < q; i++) {
cin >> x >> y;
x--, y--;
dsu.mrg(x, y + N);
}
int res = -1;
for (int i = 0; i < N; i++) res += dsu.par(i) == i;
for (int i = 0; i < M; i++) res += dsu.par(i + N) == i + N;
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
vector<int> v[2 * 200007];
bool used[2 * 200007];
void dfs(int vertex) {
used[vertex] = true;
int i;
int sz = v[vertex].size();
for (i = 0; i < sz; i++) {
if (used[v[vertex][i]] == true) {
continue;
}
dfs(v[vertex][i]);
}
}
void input() {
scanf("%d%d%d", &n, &m, &q);
int i;
for (i = 1; i <= q; i++) {
int x, y;
scanf("%d%d", &x, &y);
y += n;
v[x].push_back(y);
v[y].push_back(x);
}
}
void solve() {
int i;
int ans = 0;
for (i = 1; i <= n + m; i++) {
if (used[i] == false) {
dfs(i);
ans++;
}
}
ans--;
printf("%d\n", ans);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[200005 << 1];
int n, m, q, tot, Ans;
int head[200005 << 1], nex[200005 << 1], ver[200005 << 1];
void Add(int x, int y) {
ver[++tot] = y;
nex[tot] = head[x];
head[x] = tot;
}
void DFS(int x) {
vis[x] = true;
for (int i = head[x], y; i; i = nex[i]) {
if (!vis[y = ver[i]]) {
vis[y] = true;
DFS(y);
}
}
}
int main() {
ios ::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n >> m >> q;
for (int i = 1, x, y; i <= q; ++i) {
cin >> x >> y;
Add(x, y + n), Add(y + n, x);
}
for (int i = 1; i <= n + m; ++i)
if (!vis[i]) ++Ans, DFS(i);
cout << Ans - 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vb = vector<bool>;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vi>;
using vvll = vector<vll>;
using vii = vector<ii>;
const ll MOD = 1000000007;
const int INF = 1000000000;
const double PI = 3.14159265358979323846;
class Union_Find {
public:
Union_Find(int n) : set_cnt(n), parent(n), rank(n, 0), set_size(n, 1) {
iota(parent.begin(), parent.end(), 0);
}
void merge(int x, int y) {
int x_root = find(x), y_root = find(y);
if (x_root == y_root) {
return;
}
--set_cnt;
if (rank[x_root] < rank[y_root]) {
parent[x_root] = y_root;
set_size[y_root] += set_size[x_root];
} else {
parent[y_root] = x_root;
set_size[x_root] += set_size[y_root];
if (rank[x_root] == rank[y_root]) {
++rank[x_root];
}
}
}
int find(int x) {
if (parent[x] != x) {
parent[x] = find(parent[x]);
}
return parent[x];
}
int set_cnt;
vector<int> set_size;
private:
vector<int> parent, rank;
};
int main() {
ios::sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
if (q == 0) {
cout << n + m - 1 << endl;
return 0;
}
vi r_id(n, -1), c_id(m, -1);
int emp_row = n, emp_col = m;
Union_Find rows(n), cols(m);
for (int i = 0, _i = (q); i < _i; ++i) {
int r, c;
cin >> r >> c;
--r;
--c;
if (r_id[r] != -1) {
cols.merge(r_id[r], c);
r_id[r] = cols.find(c);
} else {
r_id[r] = c;
--emp_row;
}
if (c_id[c] != -1) {
rows.merge(c_id[c], r);
c_id[c] = rows.find(r);
} else {
c_id[c] = r;
--emp_col;
}
}
cout << rows.set_cnt - 1 + emp_col << endl;
}
|
#include <bits/stdc++.h>
struct DSU {
long long M[400005];
DSU(long long n) {
for (long long i = 0; i < n; i++) {
M[i] = i;
}
}
long long find(long long x) {
while (M[x] != x) {
long long p = M[x];
M[x] = M[p];
x = p;
}
return x;
}
bool join(long long x, long long y) {
long long xr = find(x);
long long yr = find(y);
if (xr == yr) {
return false;
} else {
M[xr] = yr;
return true;
}
}
};
using namespace std;
int main() {
long long n, m, q;
cin >> n >> m >> q;
DSU dsu(n + m);
long long z = n + m - 1;
for (long long i = 0; i < q; i++) {
long long r, c;
cin >> r >> c;
r--;
c--;
if (dsu.join(r, c + n)) z--;
}
cout << z;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[400005];
int vis[400005];
void dfs(int u) {
vis[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!vis[v]) dfs(v);
}
}
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
};
int n, m, q, x, y;
cin >> n >> m >> q;
for (int i = 0; i < q; i++) {
cin >> x >> y;
g[x].push_back(y + n);
g[y + n].push_back(x);
}
int ans = 0;
for (int i = 1; i <= n + m; i++) {
if (!vis[i]) {
dfs(i);
ans++;
}
}
cout << ans - 1;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 10;
int f[maxn];
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
void unite(int x, int y) {
int xx = find(x);
int yy = find(y);
if (xx != yy) f[xx] = yy;
}
void init(int n) {
for (int i = 1; i <= n; i++) f[i] = i;
}
int main() {
int n, m, q, x, y;
cin >> n >> m >> q;
init(n + m);
for (int i = 0; i < q; i++) {
cin >> x >> y;
unite(x, y + n);
}
int ans = 0;
int root = find(1);
for (int i = 2; i <= n + m; i++) {
if (find(i) != root) {
ans++;
f[find(i)] = root;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 201010;
const int MAXM = 201010;
int n, m;
int cnt;
int id[MAXN + MAXM];
int sz[MAXN + MAXM];
inline int getRow(int r) { return r; }
inline int getCol(int c) { return n + c; }
void setup(int total) {
cnt = total;
for (int i = 0; i < total; ++i) {
id[i] = i;
sz[i] = 1;
}
}
int find(int x) {
if (id[x] == x) return x;
return id[x] = find(id[x]);
}
void merge(int x, int y) {
int i = find(x);
int j = find(y);
if (i == j) return;
if (sz[i] > sz[j]) swap(i, j);
id[i] = j;
sz[j] += sz[i];
--cnt;
}
int main() {
ios_base ::sync_with_stdio(false);
int q;
cin >> n >> m >> q;
setup(n + m);
for (int r, c, i = 0; i < q; i++) {
cin >> r >> c;
merge(getRow(r), getCol(c));
}
cout << cnt - 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> parent;
vector<int> Rank;
int root(int v) {
if (parent[v] == v) return v;
return parent[v] = root(parent[v]);
}
void DSU(int a, int b) {
a = root(a);
b = root(b);
if (a != b) {
if (Rank[b] > Rank[a]) swap(a, b);
Rank[a] += Rank[b];
parent[b] = a;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
parent.resize(n + m + 3);
for (int i = 0; i < parent.size(); i++) {
parent[i] = i;
}
Rank.resize(n + m + 3, 1);
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
b += n;
DSU(a, b);
}
set<int> roots;
for (int i = 1; i <= n + m; i++) {
roots.insert(root(i));
}
cout << roots.size() - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 100;
int n, m, p;
int f[MAX * 2];
bool use[MAX * 2];
int find(int x) {
if (f[x] != x) f[x] = find(f[x]);
return f[x];
}
int main() {
cin >> n >> m >> p;
for (int i = 1; i <= n + m; ++i) f[i] = i;
for (int i = 1; i <= p; ++i) {
int x, y;
cin >> x >> y;
f[find(x)] = find(y + n);
}
int ans = 0;
for (int i = 1; i <= n + m; ++i) {
int ff = find(i);
if (!use[ff]) use[ff] = 1, ++ans;
}
printf("%d", ans - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, i, j, k, l, r, c, rn, cn, p;
vector<int> ri, ci;
vector<vector<int> > rx, cx;
int main() {
scanf("%d%d%d", &n, &m, &q);
for (r = 0; r < n; r++) ri.push_back(-1);
for (c = 0; c < m; c++) ci.push_back(-1);
for (i = 0; i < q; i++) {
scanf("%d%d", &r, &c);
r--;
c--;
if (ri[r] == -1 && ci[c] == -1) {
j = rx.size();
ri[r] = j;
ci[c] = j;
rx.push_back(vector<int>());
rx[j].push_back(r);
cx.push_back(vector<int>());
cx[j].push_back(c);
} else if (ri[r] == -1) {
j = ci[c];
ri[r] = j;
rx[j].push_back(r);
} else if (ci[c] == -1) {
j = ri[r];
ci[c] = j;
cx[j].push_back(c);
} else {
j = ri[r];
k = ci[c];
if (k == j) continue;
rn = rx[j].size() + cx[j].size();
cn = rx[k].size() + cx[k].size();
if (rn > cn) {
l = k;
k = j;
j = l;
}
rx[k].insert(rx[k].end(), rx[j].begin(), rx[j].end());
cx[k].insert(cx[k].end(), cx[j].begin(), cx[j].end());
for (r = 0; r < rx[j].size(); r++) ri[rx[j][r]] = k;
for (c = 0; c < cx[j].size(); c++) ci[cx[j][c]] = k;
rx[j].clear();
cx[j].clear();
}
}
p = -1;
for (i = 0; i < rx.size(); i++) p += rx[i].size() > 0;
for (r = 0; r < n; r++) p += ri[r] == -1;
for (c = 0; c < m; c++) p += ci[c] == -1;
printf("%d\n", p);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, fa[400005], ans;
int get(int x) { return fa[x] == x ? x : fa[x] = get(fa[x]); }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = (int)(1); i <= (int)(n + m); i++) fa[i] = i;
int ans = n + m - 1;
for (int i = (int)(1); i <= (int)(k); i++) {
int x, y;
scanf("%d%d", &x, &y);
x = get(x);
y = get(y + n);
if (x != y) fa[x] = y, ans--;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400400;
int n, m, k;
vector<int> g[N];
bool used[N];
void dfs(int v) {
used[v] = 1;
for (int u : g[v]) {
if (used[u]) continue;
dfs(u);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
while (k--) {
int v, u;
scanf("%d%d", &v, &u);
v--;
u += n - 1;
g[v].push_back(u);
g[u].push_back(v);
}
int ans = -1;
for (int v = 0; v < n + m; v++) {
if (used[v]) continue;
dfs(v);
ans++;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400000;
int cntR[MAXN];
int cntC[MAXN];
vector<int> xs[MAXN];
int p[MAXN];
int cntComp = 0;
int getRoot(int x) {
if (p[x] == x) {
return x;
}
int res = getRoot(p[x]);
p[x] = res;
return res;
}
void join(int x, int y) {
int r1 = getRoot(x);
int r2 = getRoot(y);
if (r1 != r2) {
cntComp--;
p[r1] = r2;
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
cntComp = n;
for (int i = 0; i < (int)(n); i++) {
p[i] = i;
}
int freeCols = m;
for (int i = 0; i < (int)(q); i++) {
int x, y;
cin >> x >> y;
xs[--y].push_back(--x);
cntR[x]++;
cntC[y]++;
if (cntC[y] == 1) {
freeCols--;
}
}
for (int i = 0; i < (int)(m); i++) {
for (int j = (int)1; j <= (int)(xs[i].size() - 1); j++) {
join(xs[i][0], xs[i][j]);
}
}
cout << cntComp - 1 + freeCols;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sz[1000005], par[1000005];
int N, M, Q;
void init(int size) {
for (int i = 0; i < size; i++) {
par[i] = i;
sz[i] = 1;
}
}
int find(int x) {
while (x != par[x]) {
par[x] = par[par[x]];
x = par[x];
}
return (x);
}
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (sz[x] > sz[y]) {
par[y] = x;
sz[x] += sz[y];
} else {
par[x] = y;
sz[y] += sz[x];
}
}
int main() {
cin >> N >> M >> Q;
init(N + M + 1);
for (int i = 0; i < Q; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
merge(a, b + N);
}
int ans = 0;
for (int i = 0; i < (N + M); i++)
if (find(i) == i) ans++;
cout << ans - 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
vector<int> G[MAXN * 2];
bool vis[MAXN * 2];
void bfs(int st) {
vis[st] = true;
queue<int> q;
q.push(st);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : G[u])
if (!vis[v]) {
vis[v] = true;
q.push(v);
}
}
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < q; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(n + v);
G[n + v].push_back(u);
}
int ans = 0;
for (int i = 1; i <= n + m; i++)
if (!vis[i]) {
ans++;
bfs(i);
}
printf("%d", ans - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fa[400005], n, cnt;
int find(int x) {
if (fa[x] == x) return x;
fa[x] = find(fa[x]);
return fa[x];
}
void un(int x, int y) {
int a = find(x), b = find(y);
if (a != b) {
cnt--;
fa[a] = b;
}
}
int main() {
int m, q;
cin >> n >> m >> q;
cnt = n + m;
for (int i = 1; i <= n + m; i++) fa[i] = i;
for (int i = 1; i <= q; i++) {
int x, y;
cin >> x >> y;
un(x, y + n);
}
cout << cnt - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct DSU {
vector<int> par, sz;
DSU(int n) : par(n), sz(n, 1) { iota(par.begin(), par.end(), 0); }
inline int get_par(int v) {
return par[v] == v ? v : par[v] = get_par(par[v]);
}
inline bool uni(int v, int u) {
v = get_par(v);
u = get_par(u);
if (v == u) return false;
if (sz[v] < sz[u]) swap(v, u);
par[u] = v;
sz[v] += sz[u];
return true;
}
};
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int n, m, q;
cin >> n >> m >> q;
DSU dsu(n + m);
int ans = n + m - 1;
while (q--) {
int i, j;
cin >> i >> j;
i--, j--;
ans -= dsu.uni(i, n + j);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> col[200005];
int row[200005];
int pre[200005];
int pset[200005];
int findSet(int a) { return (a == pset[a]) ? a : pset[a] = findSet(pset[a]); }
bool used[200005];
int main() {
int n, m, q;
scanf("%d %d %d", &n, &m, &q);
memset(row, 0, sizeof(row));
for (int i = (1); i <= (q); i += (1)) {
int x, y;
scanf("%d %d", &x, &y);
col[y].insert(x);
row[x]++;
}
memset(pre, -1, sizeof(pre));
for (int i = (1); i <= (m); i += (1)) pset[i] = i;
for (int i = (1); i <= (m); i += (1)) {
for (auto u : col[i]) {
if (pre[u] != -1) {
pset[findSet(i)] = findSet(pre[u]);
}
pre[u] = i;
}
}
memset(used, 0, sizeof(used));
int cnt = 0;
for (int i = (1); i <= (m); i += (1)) {
if (!used[findSet(i)]) {
used[findSet(i)] = 1;
cnt++;
}
}
cnt--;
for (int i = (1); i <= (n); i += (1)) {
if (!row[i]) cnt++;
}
printf("%d\n", cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, father[1000001], ans;
bool vis[1000001];
inline int getfather(int x) {
if (father[x] == x) return x;
return father[x] = getfather(father[x]);
}
inline void merge(int x, int y) {
int f1 = getfather(x), f2 = getfather(y);
if (father[f1] != f2) {
father[f1] = f2;
}
}
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= n + m; i++) {
father[i] = i;
}
for (int i = 0; i < q; i++) {
int a, b;
scanf("%d%d", &a, &b);
merge(a, b + n);
}
for (int i = 1; i <= n + m; i++) {
if (!vis[getfather(i)]) {
vis[getfather(i)] = 1;
ans++;
}
}
cout << ans - 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans = 0, n, m, q;
int f[500005];
int getfather(int v) {
if (f[v] == v) return v;
return f[v] = getfather(f[v]);
}
int main() {
cin >> n >> m >> q;
int r, c;
int cnt = n + m;
for (int i = 1; i <= n + m; i++) f[i] = i;
for (int i = 1; i <= q; i++) {
cin >> r >> c;
c += n;
int fx = getfather(r), fy = getfather(c);
if (fx != fy) {
f[fx] = fy;
cnt--;
}
}
cout << cnt - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 9;
const long long int MOD = 1e9 + 696969;
const long long INF = 1e18 + 3;
const int maxn = 500100;
vector<int> v[maxn];
vector<int> x[maxn], y[maxn];
int n, m, k;
int f[maxn];
int find(int a) {
if (f[a] == a) return a;
f[a] = find(f[a]);
return f[a];
}
int skl;
void lacz(int a, int b) {
if (find(a) != find(b)) --skl;
f[find(a)] = find(b);
}
int A[maxn], B[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
if (n == 1) {
cout << m - k;
exit(0);
};
if (m == 1) {
cout << n - k;
exit(0);
};
if (k == 0) {
cout << n + m - 1;
exit(0);
};
for (int i = (1); i <= (n + m); ++i) f[i] = i;
skl = n + m;
for (int i = (1); i <= (k); ++i) {
int a, b;
cin >> a >> b;
lacz(a, b + n);
}
cout << skl - 1;
}
|
#include <bits/stdc++.h>
using namespace std;
template <int um>
class UF {
public:
vector<int> par, rank;
UF() {
rank = vector<int>(um, 0);
for (int i = 0; i < um; i++) par.push_back(i);
}
int operator[](int x) {
return (par[x] == x) ? (x) : (par[x] = operator[](par[x]));
}
int operator()(int x, int y) {
if ((x = operator[](x)) == (y = operator[](y))) return x;
if (rank[x] > rank[y]) return par[x] = y;
rank[x] += rank[x] == rank[y];
return par[y] = x;
}
};
UF<500000> uf;
int H, W, Q;
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> H >> W >> Q;
int ret = H + W - 1;
while (Q--) {
cin >> x >> y;
y += H + 1;
if (uf[x] != uf[y]) uf(x, y), ret--;
}
cout << ret << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 400005;
int ans = 0, n, m, q;
int fa[MAX];
int get(int x) {
if (fa[x] == x) return x;
return fa[x] = get(fa[x]);
}
void merge(int x, int y) { fa[get(x)] = get(y); }
bool query(int x, int y) { return get(x) == get(y); }
void Search() {
for (int i = 1; i <= n + m; i++) {
if (fa[i] == i) {
ans++;
}
}
}
int main() {
int x, y;
cin >> n >> m >> q;
for (int i = 1; i <= n + m; i++) {
fa[i] = i;
}
for (int i = 1; i <= q; i++) {
cin >> x >> y;
merge(x, y + n);
}
Search();
cout << ans - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int Maxn = 202020;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
struct pos {
int first, second, third;
};
int N, M, Q;
bool vis[2 * Maxn];
vector<int> conn[2 * Maxn];
bool dfs(int a) {
if (vis[a]) return false;
vis[a] = true;
for (int(i) = 0; (i) < (int)(conn[a].size()); i++) dfs(conn[a][i]);
return true;
}
int main() {
scanf("%d%d%d", &N, &M, &Q);
for (int(i) = 0; (i) < (int)(Q); i++) {
int u, v;
scanf("%d%d", &u, &v);
u += Maxn;
conn[u].push_back(v);
conn[v].push_back(u);
}
int cnt = -1;
for (int(i) = 1; (i) <= (int)(N); i++)
if (dfs(Maxn + i)) cnt++;
for (int(i) = 1; (i) <= (int)(M); i++)
if (dfs(i)) cnt++;
printf("%d\n", cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 10;
int N, M, Q;
int P[MAXN];
int find(int here) {
if (here == P[here]) return here;
return P[here] = find(P[here]);
}
void merge(int node1, int node2) {
node1 = find(node1);
node2 = find(node2);
if (node1 != node2) P[node1] = node2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> M >> Q;
for (int i = 1; i <= N + M; i++) P[i] = i;
for (int i = 0; i < Q; i++) {
int x, y;
cin >> x >> y;
merge(x, N + y);
}
int ans = 0;
for (int i = 1; i <= N + M; i++)
if (P[i] == i) ans++;
cout << ans - 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ostream cnull(NULL);
template <class TH>
void _dbg(const char *sdbg, TH h) {
cnull << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cnull << *sdbg++;
cnull << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
const int MX = 200007;
vector<int> col[MX];
int row[MX];
int rep[MX], rnk[MX];
void init() {
for (int i = 0; i < MX; ++i) rep[i] = i, rnk[i] = 0;
}
int Find(int x) { return rep[x] = (rep[x] == x ? x : Find(rep[x])); }
void Union(int a, int b) {
if ((a = Find(a)) == (b = Find(b))) return;
if (rnk[a] < rnk[b]) swap(a, b);
rep[b] = a;
rnk[a] = max(rnk[a], rnk[b] + 1);
}
int32_t main() {
init();
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= q; ++i) {
int x, y;
scanf("%d%d", &x, &y);
col[y].push_back(x);
row[x] = 1;
}
for (int i = 1; i <= m; ++i) {
for (int j = 0; j < ((int)(col[i]).size()) - 1; ++j) {
Union(col[i][j], col[i][j + 1]);
}
}
int cnt = 0;
for (int i = 1; i <= n; ++i) cnt += (row[i] == 1 && rep[i] == i);
int odp = cnt - 1;
for (int i = 1; i <= n; ++i) odp += (row[i] == 0);
for (int i = 1; i <= m; ++i) odp += (col[i].empty());
printf("%d", odp);
}
|
#include <bits/stdc++.h>
using namespace std;
int vis[400009];
vector<vector<int>> graph;
void dfs(int node) {
vis[node] = 1;
for (int i = 0; i < graph[node].size(); i++) {
if (!vis[graph[node][i]]) {
dfs(graph[node][i]);
}
}
}
int main() {
int n, m, q;
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &q);
graph.resize(n + m + 3);
for (int i = 0; i < q; i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
graph[u].push_back(n + v);
graph[n + v].push_back(u);
}
if (n == 1)
cout << m - q << '\n';
else if (m == 1)
cout << n - q << '\n';
else {
int ans = 0;
for (int i = 1; i <= n + m; i++) {
if (!vis[i]) {
ans++;
dfs(i);
}
}
ans--;
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int i;
int a[200001] = {0};
int d[200001] = {0};
for (i = 1; i <= 200000; i++) {
a[i] = i;
}
int n, m, q;
while (scanf("%d%d%d", &n, &m, &q) > 0) {
int line = n;
int head;
int x, y;
for (i = q; i > 0; i--) {
scanf("%d%d", &x, &y);
if (d[x] != y) {
if (d[x] == 0) {
d[x] = y;
head = d[x];
while (a[head] != head) {
head = a[head];
}
while (a[d[x]] != d[x]) {
a[d[x]] = head;
d[x] = a[d[x]];
}
} else {
head = y;
while (a[head] != head) {
head = a[head];
}
while (a[y] != y) {
a[y] = head;
y = a[y];
}
while (a[d[x]] != d[x]) {
d[x] = a[d[x]];
}
while (a[d[x]] != d[x]) {
a[d[x]] = head;
d[x] = a[d[x]];
}
a[y] = d[x];
}
}
}
int same = 0;
for (i = 1; i <= m; i++) {
if (a[i] == i) {
same++;
}
}
for (i = 1; i <= n; i++) {
if (d[i] != 0) {
line--;
}
}
printf("%d\n", same + line - 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<vector<int_fast64_t> > const& g, vector<bool>& vis,
int_fast64_t v) {
if (vis[v]) return;
vis[v] = true;
for (auto w : g[v]) dfs(g, vis, w);
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int_fast64_t n, m, q;
cin >> n >> m >> q;
vector<vector<int_fast64_t> > xs(n), ys(m);
for (int_fast64_t i = 0; i < q; ++i) {
int_fast64_t x, y;
cin >> x >> y;
--x;
--y;
xs[x].push_back(i);
ys[y].push_back(i);
}
int_fast64_t empty = 0;
vector<vector<int_fast64_t> > g(q);
for (auto& row : xs) {
int_fast64_t prev = -1;
for (int_fast64_t x : row) {
if (prev != -1) {
g[prev].push_back(x);
g[x].push_back(prev);
}
prev = x;
}
if (prev == -1) ++empty;
}
for (auto& row : ys) {
int_fast64_t prev = -1;
for (int_fast64_t x : row) {
if (prev != -1) {
g[prev].push_back(x);
g[x].push_back(prev);
}
prev = x;
}
if (prev == -1) ++empty;
}
vector<bool> vis(q);
int_fast64_t comps = 0;
for (int_fast64_t i = 0; i < q; ++i) {
if (!vis[i]) {
dfs(g, vis, i);
++comps;
}
}
cout << empty + comps - 1 << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int ff[512345];
int rr[212345];
int cc[212345];
int findf(int u) {
int t = u;
while (ff[u] != u) {
u = ff[u];
}
while (t != u) {
int k = t;
t = ff[k];
ff[k] = u;
}
return u;
}
void uu(int x, int y) {
int fx = findf(x);
ff[fx] = findf(y);
}
int main() {
int m, n;
cin >> n >> m;
int q;
cin >> q;
for (int i = 1; i <= n + m; i++) {
ff[i] = i;
}
for (int i = 1; i <= q; i++) {
int a, b;
cin >> a >> b;
rr[a]++;
cc[b]++;
uu(a, b + n);
}
int lr = 0;
for (int i = 1; i <= n; i++) {
if (rr[i] == 0) lr++;
}
int lc = 0;
for (int i = 1; i <= m; i++) {
if (cc[i] == 0) lc++;
}
int tmp = max(lr, lc);
int ans = 0;
for (int i = 1; i <= n + m; i++) {
if (ff[i] == i) ans++;
}
cout << ans - 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 5;
int n, m, q, ap[N];
vector<int> vr[N];
vector<int> vc[N];
int comp[N], tbag[N];
set<int> s[N];
int t[N], h[N];
inline int FindSet(int nod) {
while (nod != t[nod]) nod = t[nod];
return nod;
}
inline void UnionSet(int x, int y) {
x = FindSet(x);
y = FindSet(y);
if (x == y) return;
if (h[x] == h[y]) {
h[x]++;
t[y] = x;
return;
}
if (h[x] > h[y]) t[y] = x;
if (h[x] < h[y]) t[x] = y;
}
bool iscomp[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> q;
if (q == 0) {
cout << n + m - 1 << "\n";
return 0;
}
for (int i = 1; i <= q; i++) {
int r, c;
cin >> r >> c;
ap[c]++;
vr[r].push_back(c);
vc[c].push_back(r);
}
for (int i = 1; i <= n; i++) {
t[i] = i;
h[i] = 1;
}
for (int col = 1; col <= m; col++) {
int sz = vc[col].size();
for (int j = 1; j < sz; j++) {
UnionSet(vc[col][0], vc[col][j]);
}
}
for (int i = 1; i <= n; i++) {
comp[i] = FindSet(i);
iscomp[comp[i]] = 1;
}
int cnt_comp = 0;
int rgol = 0, cgol = 0;
for (int i = 1; i <= n; i++) {
if (vr[i].size() && iscomp[i] == 1) {
cnt_comp++;
}
if (vr[i].size() == 0) rgol++;
}
for (int i = 1; i <= m; i++) {
if (vc[i].size() == 0) cgol++;
}
cout << cgol + rgol + cnt_comp - 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, l, ans, x, y;
int head[400010];
bool vis[400010];
struct node {
int y, next;
} edge[400010];
void add(int x, int y) {
l++;
edge[l].y = y;
edge[l].next = head[x];
head[x] = l;
}
void dfs(int x) {
vis[x] = 1;
for (int p = head[x]; p; p = edge[p].next)
if (!vis[edge[p].y]) dfs(edge[p].y);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
memset(head, 0, sizeof(head));
l = 0;
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x, &y);
add(x, y + n);
add(y + n, x);
}
ans = 0;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n + m; i++)
if (!vis[i]) {
ans++;
dfs(i);
}
printf("%d\n", ans - 1);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a[200005], b[200005];
int f[200005];
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
void uni(int x, int y) {
int fx = find(x), fy = find(y);
if (fx == fy) return;
f[fx] = fy;
}
int main() {
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < q; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x].push_back(y);
b[y].push_back(x);
}
if (n == 1 || m == 1) {
long long ans = n;
ans *= m;
ans -= q;
cout << ans << endl;
return 0;
}
for (int i = 1; i <= n; i++) f[i] = i;
long long ans = 0;
for (int i = 1; i <= m; i++) {
if (b[i].size() == 0) {
ans++;
} else {
int x = b[i][0];
for (int j = 1; j < b[i].size(); j++) {
uni(b[i][j], x);
}
}
}
set<int> s;
for (int i = 1; i <= n; i++) s.insert(find(i));
ans += (int)s.size() - 1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
vector<int> graph[200001 * 2];
set<int> node;
bool visited[200001 * 2];
void dfs(int node) {
visited[node] = true;
for (int i = 0; i < graph[node].size(); i++) {
if (!visited[graph[node][i]]) dfs(graph[node][i]);
}
}
int main(void) {
cin >> n >> m >> q;
int r, c;
for (int i = 0; i < q; i++) {
cin >> r >> c;
graph[r].push_back(n + c);
graph[n + c].push_back(r);
node.insert(r);
node.insert(n + c);
}
memset(visited, false, sizeof(visited));
int num = 0;
int num_node = 0;
for (set<int>::iterator it = node.begin(); it != node.end(); it++) {
num_node++;
int temp = *it;
if (!visited[temp]) {
num++;
dfs(temp);
}
}
cout << num - 1 + n + m - num_node << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[400010];
int get(int x) {
if (f[x] == x) return x;
return f[x] = get(f[x]);
}
int main() {
int n, m, q, i, x, y;
scanf("%d%d%d", &n, &m, &q);
for (i = 1; i <= n + m; i++) f[i] = i;
for (i = 1; i <= q; i++) {
scanf("%d%d", &x, &y);
x = get(x), y = get(y + n);
f[x] = y;
}
int s = 0;
for (i = 1; i <= n + m; i++)
if (get(i) == i) s++;
printf("%d", s - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
vector<int> g[400005];
bool vis[400005];
void dfs(int x) {
for (int i = 0; i < g[x].size(); i++) {
if (!vis[g[x][i]]) {
vis[g[x][i]] = true;
dfs(g[x][i]);
}
}
}
int main() {
cin >> n >> m >> q;
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b + 200000);
g[b + 200000].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
ans++;
dfs(i);
}
}
for (int i = 1; i <= m; i++) {
if (!vis[i + 200000]) {
ans++;
dfs(i + 200000);
}
}
cout << ans - 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 2e5 + 20;
long long inf = (long long)1e14;
long long mod1 = (long long)1e9 + 9, p = 151, mod2 = (long long)1e9 + 7;
long long n, m, q, par[MAX], sz[MAX];
vector<long long> nums[MAX];
set<long long> un;
long long get(long long u) {
if (par[u] == u)
return u;
else {
long long v = get(par[u]);
par[u] = v;
return v;
}
}
void unite(long long a, long long b) {
a = get(a);
b = get(b);
if (sz[a] < sz[b]) swap(a, b);
par[b] = a;
sz[a] += sz[b];
}
void solve() {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
par[i] = i;
sz[i] = 1;
}
if (q == 0) {
cout << n + m - 1;
return;
}
for (int i = 0; i < q; i++) {
long long a, b;
cin >> a >> b;
nums[b].push_back(a);
un.insert(b);
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j < nums[i].size(); j++) {
unite(nums[i][j], nums[i][j - 1]);
}
}
long long ans = 0;
set<long long> nums;
for (int i = 1; i <= n; i++) {
nums.insert(get(i));
}
ans += nums.size() - 1;
nums.clear();
for (int i = 1; i <= m; i++) {
if (un.count(i) == 0) ans++;
}
cout << ans;
}
int main() {
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ios::sync_with_stdio(0);
long long q;
q = 1;
while (q--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\t';
err(++it, args...);
}
const int NN = 2e5 + 2, mod = 1e9 + 7;
pair<int, int> ar[NN];
int Arr[NN], sz[NN];
int count_of_x_[NN];
int get_root(int i) {
while (Arr[i] != i) {
Arr[i] = Arr[Arr[i]];
i = Arr[i];
}
return i;
}
void _union(int A, int B) {
int root_A = get_root(A);
int root_B = get_root(B);
if (root_B == root_A) return;
if (sz[root_A] < sz[root_B]) {
Arr[root_A] = Arr[root_B];
sz[root_B] += sz[root_A];
count_of_x_[root_B] += count_of_x_[root_A];
} else {
Arr[root_B] = Arr[root_A];
sz[root_A] += sz[root_B];
count_of_x_[root_A] += count_of_x_[root_B];
}
}
vector<int> set_of_y[NN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, i, j, k, m, q;
cin >> n >> m >> q;
for (i = 0; i < q; i++) {
cin >> ar[i].first >> ar[i].second;
set_of_y[ar[i].first].push_back(ar[i].second);
}
for (i = 1; i <= 2e5; i++) {
if (!set_of_y[i].size()) continue;
for (auto y : set_of_y[i]) {
if (!Arr[y]) {
Arr[y] = y;
sz[y] = 1;
}
}
for (j = 0; j < set_of_y[i].size() - 1; j++) {
_union(set_of_y[i][j], set_of_y[i][j + 1]);
}
k = get_root(set_of_y[i][0]);
count_of_x_[k]++;
}
map<int, int> yx;
for (i = 1; i <= 2e5; i++) {
if (Arr[i]) {
k = get_root(i);
yx[k]++;
}
}
int ans = yx.size() - 1;
long long int tot_y = 0, tot_x = 0;
for (auto it : yx) {
tot_y += it.second;
tot_x += count_of_x_[it.first];
}
ans += (m - tot_y) + (n - tot_x);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 222222;
long long r[N], c[N];
vector<long long> graph[N << 1];
bool vis[N << 1];
long long n, m, q;
void dfs(long long u) {
vis[u] = true;
for (auto v : graph[u]) {
if (vis[v]) continue;
dfs(v);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> q;
for (long long i = (1); i <= (q); i++) {
cin >> r[i] >> c[i];
long long u = r[i], v = c[i] + n;
graph[u].push_back(v);
graph[v].push_back(u);
}
long long ans = 0;
for (long long i = (1); i <= (n + m); i++) {
if (vis[i]) continue;
dfs(i);
ans++;
}
ans--;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
int n, m, q, ans, rt[N];
int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x;
}
int root(int u) { return rt[u] == u ? u : rt[u] = root(rt[u]); }
void add(int u, int v) {
if (root(u) != root(v)) rt[rt[u]] = rt[v];
}
int main() {
n = read(), m = read(), q = read();
for (int i = 1; i <= n + m; i++) rt[i] = i;
for (int u, v; q; q--) u = read(), v = read(), add(u, v + n);
for (int i = 1; i <= n + m; i++) ans += root(i) == i;
printf("%d", ans - 1);
}
|
#include <bits/stdc++.h>
using namespace std;
class UnionFind {
private:
int siz;
vector<int> a;
public:
UnionFind(int x) : siz(x), a(x, -1) {}
int root(int x) { return a[x] < 0 ? x : a[x] = root(a[x]); }
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return false;
siz--;
if (a[x] > a[y]) swap(x, y);
a[x] += a[y];
a[y] = x;
return true;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return -a[root(x)]; }
int connected_component() { return siz; }
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
UnionFind uf(n + m);
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
uf.unite(a, n + b);
}
cout << uf.connected_component() - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
vector<int> vec[N];
bool visited[N];
void dfs(int node) {
if (visited[node]) return;
visited[node] = true;
for (auto to : vec[node]) {
if (!visited[to]) dfs(to);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
x--, y--;
y += n;
vec[x].push_back(y);
vec[y].push_back(x);
}
int cevap = 0;
for (int i = 0; i < n + m; i++) {
if (!visited[i]) {
dfs(i);
cevap++;
}
}
cout << cevap - 1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 10;
int f[MAXN];
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
void unionn(int u, int v) { f[find(u)] = find(v); }
int main() {
std::ios::sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n + m; i++) f[i] = i;
int cnt = 0;
while (q--) {
int u, v;
cin >> u >> v;
if (find(u) == find(n + v)) {
continue;
} else {
cnt++;
unionn(u, n + v);
}
}
cout << n + m - 1 - cnt << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 200005;
const int MOD = 1e9 + 9;
vector<int> g[MAXN];
int n, m, q, ans;
int rows[MAXN];
bool vist[MAXN];
pair<int, int> samp[MAXN];
void dfs(int st) {
if (vist[st]) return;
vist[st] = 1;
for (int i = 0; i < g[st].size(); i++) {
dfs(g[st][i]);
}
}
void buildG() {
sort(samp, samp + q);
for (int i = 1; i < q; ++i) {
int r = samp[i].first, c = samp[i].second;
int rl = samp[i - 1].first, cl = samp[i - 1].second;
if (r == rl) {
g[c].push_back(cl);
g[cl].push_back(c);
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < q; ++i) {
int r, c;
scanf("%d %d", &r, &c);
r--;
c--;
rows[r] = 1;
samp[i] = {r, c};
}
buildG();
for (int i = 0; i < m; ++i) {
if (!vist[i]) {
ans++;
dfs(i);
}
}
ans--;
for (int i = 1; i < n; ++i) rows[i] += rows[i - 1];
ans += n - rows[n - 1];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, K;
int fa[200005 * 2];
int getfa(int x) { return x == fa[x] ? x : fa[x] = getfa(fa[x]); }
void solve() {
scanf("%d %d %d", &n, &m, &K);
for (int i = 1; i <= n + m; i++) fa[i] = i;
for (int a, b, i = 1; i <= K; i++) {
scanf("%d %d", &a, &b);
int x = getfa(a), y = getfa(b + n);
if (x == y) continue;
fa[x] = y;
}
int ans = 0;
for (int i = 1; i <= n + m; i++)
if (fa[i] == i) ans++;
printf("%d\n", ans - 1);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 100;
vector<int> adj[N];
int n, m, q;
int vis[N];
void dfs(int cur) {
if (vis[cur]++) return;
for (int i = 0; i < adj[cur].size(); ++i) dfs(adj[cur][i]);
}
int main() {
scanf("%d", &n), scanf("%d", &m), scanf("%d", &q);
for (int i = 0; i < q; ++i) {
int x, y;
scanf("%d", &x), scanf("%d", &y);
x--, y--;
adj[x].push_back(n + y);
adj[n + y].push_back(x);
}
int out = 0;
for (int i = 0; i < n; ++i)
if (!vis[i]) out++, dfs(i);
for (int i = 0; i < m; ++i)
if (!vis[n + i]) out++, dfs(n + i);
cout << out - 1;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 200005;
inline void read(int &x) {
int f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
inline void print(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
inline void caltime(int tt) {
tt = clock() - tt;
cerr << (double)tt / CLOCKS_PER_SEC << " seconds!" << endl;
}
int n, m, q;
vector<int> e[maxn * 10];
bool vis[maxn * 10];
void dfs(int x) {
vis[x] = 1;
for (int i = 0; i < e[x].size(); i++) {
if (!vis[e[x][i]]) dfs(e[x][i]);
}
}
int main() {
cin >> n >> m >> q;
for (int i = 0; i < q; i++) {
int x, y;
read(x), read(y);
e[x].push_back(y + n);
e[y + n].push_back(x);
}
int ans = 0;
for (int i = 1; i <= m + n; i++) {
if (!vis[i]) {
dfs(i);
ans++;
}
}
cout << ans - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int last[200200];
int p[200200], h[200200];
int find_set(int v) { return p[v] == v ? v : p[v] = find_set(p[v]); }
int union_set(int u, int v) {
u = find_set(u);
v = find_set(v);
if (u == v) return 0;
if (h[u] < h[v]) swap(u, v);
h[u] += h[u] == h[v];
p[v] = u;
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, q;
cin >> n >> m >> q;
for (int i(1); i <= n; ++i) p[i] = i;
int empt(0);
map<int, set<int>> table;
map<int, int> last;
for (int i(1); i <= q; ++i) {
int x, y;
cin >> x >> y;
table[x].insert(y);
}
empt = n - table.size();
for (auto it = table.begin(); it != table.end(); ++it)
for (int y : it->second)
if (last.count(y))
union_set(last[y], it->first);
else
last[y] = it->first;
set<int> ys;
for (auto it = table.begin(); it != table.end(); ++it)
for (int y : it->second) ys.insert(y);
if (empt == n) {
cout << n + m - 1;
return 0;
}
int str(m - ys.size());
int comp(0);
for (auto it = table.begin(); it != table.end(); ++it)
comp += find_set(it->first) == it->first;
cout << comp - 1 + empt + str;
}
|
#include <bits/stdc++.h>
using namespace std;
class Solution {
struct UFNode {
int val;
int root;
UFNode(int v, int r) : val(v), root(-1) {}
UFNode() : val(0), root(-1) {}
};
vector<UFNode> nodes;
unordered_map<int, int> map;
int rows;
public:
Solution(int m) : nodes(m + 1), rows(m - 1) {}
int find(int val) {
UFNode& node = nodes[val];
if (node.root < 0) {
return val;
}
return nodes[val].root = find(node.root);
}
void unionTwo(int val1, int val2) {
int root1 = find(val1);
int root2 = find(val2);
if (root1 == root2) {
return;
}
UFNode& node1 = nodes[root1];
UFNode& node2 = nodes[root2];
if (node1.root < node2.root) {
node1.root += node2.root;
node2.root = root1;
} else {
node2.root += node1.root;
node1.root = root2;
}
rows--;
}
int findMinimalPurchases(int n, int q) {
int count = n;
int x, y;
for (int i = 0; i < q; i++) {
cin >> x >> y;
if (map.find(x) != map.end()) {
unionTwo(map[x], y);
} else {
count--;
}
map[x] = y;
}
return count + rows;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
cout << Solution(m).findMinimalPurchases(n, q);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 69, base = 1024 * 1024, mod = 1e9 + 7;
int rep[N], n, m, q;
vector<int> vek;
int re(int v) {
if (v != rep[v]) rep[v] = re(rep[v]);
return rep[v];
}
void uni(int a, int b) {
a = re(a);
b = re(b);
rep[a] = b;
}
int32_t main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= n + m + 3; i++) rep[i] = i;
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
uni(a, b + n);
}
for (int i = 1; i <= n + m; i++) vek.push_back(re(i));
sort(vek.begin(), vek.end());
vek.resize(distance(vek.begin(), unique(vek.begin(), vek.end())));
cout << vek.size() - 1 << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int par[200005], lev[200005], tot[200005];
void makeset(int n) {
fill(par, par + n, -1);
fill(tot, tot + n, 1);
return;
}
int findset(int x) {
int y = x;
while (par[y] >= 0) y = par[y];
if (x != y) par[x] = y;
return y;
}
void combine(int a, int b) {
a = findset(a);
b = findset(b);
if (a != b) {
if (lev[a] < lev[b])
par[a] = b, tot[b] += tot[a];
else if (lev[a] > lev[b])
par[b] = a, tot[a] += tot[b];
else
lev[b]++, par[a] = b, tot[b] += tot[a];
}
return;
}
int ad[200005];
int main() {
int n, m, q, a, b, i, k;
scanf("%d%d%d", &n, &m, &q);
makeset(m + 1);
while (q--) {
scanf("%d%d", &a, &b);
if (ad[a] == 0)
ad[a] = b;
else
combine(ad[a], b);
}
k = -1;
for (i = 1; i < m + 1; i++)
if (par[i] < 0) k++;
for (i = 1; i < n + 1; i++)
if (ad[i] == 0) k++;
printf("%d\n", k);
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
register long long x = 0, o = 1;
register char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9')
x = ((x << 3) + (x << 1)) + ch - '0', ch = getchar();
return x * o;
}
int n, m, fa[201000 << 1], k, vis[201000 << 1];
inline int Find(int x) {
if (fa[x] != x) fa[x] = Find(fa[x]);
return fa[x];
}
int main() {
n = read(), m = read(), k = read();
for (register int i = 1; i <= n + m; ++i) fa[i] = i;
for (register int i = 1; i <= k; ++i) {
int x = read(), y = read() + n;
int fx = Find(x), fy = Find(y);
if (fx != fy) fa[fx] = fy;
}
int ans = 0;
for (register int i = 1; i <= n + m; ++i) {
int now = Find(i);
if (!vis[now]) vis[now] = 1, ++ans;
}
printf("%d\n", ans - 1);
}
|
#include <bits/stdc++.h>
using namespace std;
int parent[200005 * 2];
inline int Find(int a) {
if (parent[a] == a) return a;
parent[a] = Find(parent[a]);
return parent[a];
}
inline void Union(int a, int b) { parent[Find(b)] = parent[Find(a)]; }
int main() {
ios_base::sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i <= n + m; i++) parent[i] = i;
while (q--) {
int a, b;
cin >> a >> b;
Union(a, n + b);
}
int ans = 0;
for (int i = 1; i <= n + m; i++) {
if (parent[i] == i) ans++;
}
cout << ans - 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 400000 + 5;
int f[maxn];
int n, m, q;
int ans;
inline int Read() {
register int ret;
register char r;
register bool f = false;
while (r = getchar(), r < '0' || r > '9')
if (r == '-') f = true;
ret = r - 48;
while (r = getchar(), r >= '0' && r <= '9')
ret = (ret << 3) + (ret << 1) + r - 48;
return f ? ~ret + 1 : ret;
}
inline int Find(int x) { return x == f[x] ? x : f[x] = Find(f[x]); }
int main() {
n = Read();
m = Read();
q = Read();
for (register int i = n + m; i; i--) f[i] = i;
for (register int i = 1; i <= q; i++) {
int x = Find(Read()), y = Find(Read() + n);
if (x != y) f[x] = y;
}
for (register int i = n + m; i; i--) ans += (Find(i) == i);
printf("%d\n", ans - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[400005], n, m, q, a[400005], b[400005];
int Find(int x) { return x == p[x] ? x : p[x] = Find(p[x]); }
int join(int x, int y) {
int fx = Find(x);
int fy = Find(y);
if (fx != fy) p[fx] = fy;
}
int main() {
int ans = 0;
cin >> n >> m >> q;
for (int i = 1; i <= n + m; i++) {
p[i] = i;
}
for (int i = 0; i < q; i++) {
cin >> a[i] >> b[i];
join(a[i], b[i] + n);
}
for (int i = 1; i <= n + m; i++) {
if (p[i] == i) ans++;
}
cout << ans - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 5;
int n, m, q, par[MAXN];
void input();
int get_par(int);
void merge(int, int);
void solve();
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
input(), solve();
return 0;
}
void input() {
cin >> n >> m >> q;
memset(par, -1, sizeof par);
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
merge(--a, n + --b);
}
}
int get_par(int u) { return par[u] < 0 ? u : par[u] = get_par(par[u]); }
void merge(int u, int v) {
u = get_par(u), v = get_par(v);
if (u == v) return;
if (par[u] > par[v]) swap(u, v);
par[u] += par[v];
par[v] = u;
}
void solve() {
int a = -1;
for (int i = 0; i < n + m; i++) a += par[i] < 0;
cout << a;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 5;
int par[maxn];
int getP(int p) { return par[p] == p ? p : par[p] = getP(par[p]); }
void Union(int u, int v) {
u = getP(u);
v = getP(v);
if (u == v) return;
par[v] = u;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(15);
cout << fixed;
int n, m, q;
cin >> n >> m >> q;
iota(par, par + n + m + 1, 0);
while (q--) {
int a, b;
cin >> a >> b;
Union(a, b + n);
}
int cnt = 0;
for (int i = 1; i <= n + m; i++) {
if (getP(i) == i) cnt++;
}
cout << cnt - 1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
long long qpow(long long x, long long k) {
return k == 0 ? 1
: 1ll * qpow(1ll * x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod;
}
const int maxn = 400111;
int n, m, q;
int f[maxn];
int gf(int x) { return f[x] == x ? x : f[x] = gf(f[x]); }
int main() {
n = getnum(), m = getnum(), q = getnum();
for (int i = 1; i <= n + m; i++) f[i] = i;
for (int i = 1; i <= q; i++) {
int x, y;
x = getnum(), y = getnum();
f[gf(x)] = gf(y + n);
}
int ans = 0;
for (int i = 1; i <= n + m; i++) ans += gf(i) == i;
cout << ans - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
inline void read(int& x) {
char c;
while ((c = getchar()) < '0' || c > '9')
;
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
}
using namespace std;
const int maxn = 4e5 + 10;
const int M = 128;
const int inf = 0x7fffffff;
const long long INF = 9E18;
const int mod = 1e9 + 7;
const int eps = 1e-7;
const double pi = 3.1415926535898;
int fa[maxn];
int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n + m; i++) fa[i] = i;
int ans = m + n - 1;
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
y += n;
int xx = getfa(x);
int yy = getfa(y);
if (xx != yy) {
fa[xx] = yy;
ans--;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400100;
int fat[N];
int rnk[N];
int find(int x) {
if (fat[x] == x)
return x;
else
return fat[x] = find(fat[x]);
}
bool unit(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return false;
if (rnk[x] > rnk[y]) swap(rnk[x], rnk[y]);
if (rnk[x] == rnk[y]) rnk[y]++;
fat[x] = y;
return true;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n + m; ++i) {
fat[i] = i;
rnk[i] = 0;
}
int ans = n + m;
for (int i = 0; i < q; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (unit(x, n + y)) {
ans--;
}
}
printf("%d\n", ans - 1);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int Gcd(int X, int Y) { return Y ? Gcd(Y, X % Y) : X; }
inline long long Gcd(long long X, long long Y) { return Y ? Gcd(Y, X % Y) : X; }
inline int Pow(int base, long long exp, int _mod) {
if (!(base %= _mod)) return 0;
int _ans = 1;
for (; exp; exp >>= 1, base = (long long)base * base % _mod)
exp & 1 ? _ans = (long long)_ans * base % _mod : 0;
return _ans;
}
inline long long Pow(long long base, long long exp, long long _mod) {
if (!(base %= _mod)) return 0;
long long _ans = 1;
for (; exp; exp >>= 1, base = base * base % _mod)
exp & 1 ? _ans = _ans * base % _mod : 0;
return _ans;
}
const int INF = 0x3f3f3f3f;
int n, m, q, X, Y, S;
int a[200001], b[200001];
int v[200001], u[200001];
int c[200001], d[200001];
int h[200001], H[200001], nxt[400001], to[400001], tot;
inline void ins(int *h, int x, int y) {
nxt[++tot] = h[x];
to[tot] = y;
h[x] = tot;
}
void FF(int x);
void D(int x) {
v[x] = 1;
++X;
for (int i = h[x]; i; i = nxt[i])
if (!u[to[i]]) FF(to[i]);
}
void FF(int x) {
u[x] = 1;
++Y;
for (int i = H[x]; i; i = nxt[i])
if (!v[to[i]]) D(to[i]);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= (q); ++i)
scanf("%d%d", a + i, b + i), ins(h, a[i], b[i]), ins(H, b[i], a[i]);
for (int i = 1; i <= (n); ++i) {
if (!v[i]) {
X = 0, Y = 0;
D(i);
S += X + Y - 1;
}
}
printf("%d", n + m - 1 - S);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 400000 + 200;
vector<long long> adj[maxn];
bool seen[maxn];
long long cnt;
void dfs(long long root) {
seen[root] = 1;
for (auto x : adj[root])
if (!seen[x]) dfs(x);
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m, q;
cin >> n >> m >> q;
for (long long(i) = (0); (i) < (q); (i)++) {
long long x, y;
cin >> x >> y;
x--, y--;
y += 200000;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (long long(i) = (0); (i) < (n); (i)++)
if (!seen[i]) dfs(i), cnt++;
for (long long(i) = (0); (i) < (m); (i)++)
if (!seen[i + 200000]) dfs(i + 200000), cnt++;
cout << cnt - 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
inline int read() {
char c = getchar();
int x = 0;
while (c < '0' || c > '9') {
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c & 15);
c = getchar();
}
return x;
}
const int N = 800005;
int n, m, q, ans = -1;
bool vis[N];
struct List {
int tot, fst[N], nxt[N], to[N];
List() { memset(fst, -1, sizeof(fst)); }
inline void insert(int u, int v) {
nxt[tot] = fst[u];
to[tot] = v;
fst[u] = tot++;
}
inline void link(int u, int v) {
insert(u, v);
insert(v, u);
}
} e;
void dfs(int u) {
if (vis[u]) {
return;
}
vis[u] = true;
for (int i = e.fst[u]; ~i; i = e.nxt[i]) {
dfs(e.to[i]);
}
}
int main() {
m = read();
n = m + read();
q = read();
for (int u, v; q; q--) {
u = read();
v = read();
e.link(u, m + v);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
ans++;
dfs(i);
}
}
printf("%d\n", ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.