solution
stringlengths
11
983k
difficulty
int64
0
21
language
stringclasses
2 values
#include <bits/stdc++.h> using namespace std; int n; vector<vector<int>> friends; vector<vector<int>> enemies; vector<int> parent; int cnt; bool dfs(int node, int color) { parent[node] = color; cnt++; bool result = true; for (int next : friends[node]) if (parent[next] == 0) result = dfs(next, color) && result; for (int next : enemies[node]) if (parent[next] == color) result = false; return result; } int main() { std::ios::sync_with_stdio(false); cin >> n; friends.resize(n); enemies.resize(n); parent.resize(n, 0); int m, a, b; cin >> m; for (int i = 0; i < m; ++i) { cin >> a >> b; a--; b--; friends[a].push_back(b); friends[b].push_back(a); } cin >> m; for (int i = 0; i < m; ++i) { cin >> a >> b; a--; b--; enemies[a].push_back(b); enemies[b].push_back(a); } int result = 0, color = 0; for (int i = 0; i < n; ++i) if (parent[i] == 0) { cnt = 0; if (dfs(i, ++color)) { result = max(result, cnt); } } cout << result << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int N = 2000; bool fr[N][N], en[N][N]; bool u[N]; int comp[N]; void dfs(int v, int k, int n) { u[v] = true; comp[v] = k; for (int i = 0; i < n; ++i) if (fr[v][i] && !u[i]) dfs(i, k, n); } int main() { ios_base::sync_with_stdio(0); int n, k, m; cin >> n >> k; for (int i = 0; i < n; ++i) u[i] = false; for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) fr[i][j] = en[i][j] = false; for (int i = 0; i < k; ++i) { int a, b; cin >> a >> b; --a; --b; fr[a][b] = fr[b][a] = true; } cin >> m; for (int i = 0; i < m; ++i) { int a, b; cin >> a >> b; --a; --b; en[a][b] = en[b][a] = true; } int kf = 0; for (int i = 0; i < n; ++i) if (!u[i]) dfs(i, kf++, n); int ans = 0; for (int i = 0; i < kf; ++i) { int s = 0; for (int j = 0; j < n; ++j) if (comp[j] == i) ++s; vector<int> v; for (int j = 0; j < n; ++j) if (comp[j] == i) v.push_back(j); bool ok = true; for (int ii = 0; ii < v.size() && ok; ++ii) for (int j = ii + 1; j < v.size() && ok; ++j) if (en[v[ii]][v[j]]) ok = false; if (ok) ans = max(ans, s); } cout << ans; cin >> n; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; long long N, M, K; vector<pair<long long, long long>> enemies; vector<long long> adj[2001]; bool visited[2001]; long long comp_count = 0; long long component[2001]; long long numNodes[2001]; long long currNode = 0; unordered_set<long long> hateComps[2001]; long long maxInvite = INT_MIN; void dfs(long long s) { if (visited[s]) return; visited[s] = true; component[s] = comp_count; currNode++; for (auto u : adj[s]) dfs(u); } void findComponents() { for (auto(i) = 0; i < N; i++) { if (!visited[i]) { comp_count++; currNode = 0; dfs(i); numNodes[comp_count - 1] = currNode; } } } void findHated() { for (auto(i) = 0; i < M; i++) { pair<long long, long long> curr = enemies[i]; long long comp1 = component[curr.first] - 1; long long comp2 = component[curr.second] - 1; hateComps[comp1].insert(comp2); hateComps[comp2].insert(comp1); } } void findMaxInvite() { for (auto(i) = 0; i < comp_count; i++) { long long curr = numNodes[i]; for (auto u : hateComps[i]) { if (u == i) { curr = 0; break; } } maxInvite = max(maxInvite, curr); } } void debugPrint() { cout << "The number of connected components : " << comp_count << "\n"; cout << "The number of nodes in each connected component : "; for (auto(i) = 0; i < comp_count; i++) cout << numNodes[i] << " "; cout << "\nHated Components : "; for (auto(i) = 0; i < comp_count; i++) { cout << i << " : "; for (auto u : hateComps[i]) cout << u << " "; cout << "--> "; } cout << "\nFINAL ANSWER : " << maxInvite; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> N; cin >> K; for (auto(i) = 0; i < K; i++) { long long a, b; cin >> a >> b; --a; --b; adj[a].push_back(b); adj[b].push_back(a); } cin >> M; for (auto(i) = 0; i < M; i++) { long long a, b; cin >> a >> b; --a; --b; enemies.push_back(make_pair(a, b)); } for (auto(i) = 0; i < N; i++) visited[i] = false; findComponents(); findHated(); findMaxInvite(); cout << maxInvite; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; vector<int> *friends = new vector<int>[n + 1]; int k; cin >> k; int u, v; for (int t = 0; t < k; t++) { cin >> u >> v; friends[u].push_back(v); friends[v].push_back(u); } vector<int> component_sizes; int *in_which = new int[n + 1]; for (int i = 1; i <= n; i++) in_which[i] = -1; int component = 0; for (int i = 1; i <= n; i++) { if (in_which[i] == -1) { int compSize = 1; int seed = i; stack<int> all_vert; all_vert.push(seed); in_which[seed] = component; while (!all_vert.empty()) { seed = all_vert.top(); all_vert.pop(); for (int j = 0; j < friends[seed].size(); j++) { int nova = friends[seed][j]; if (in_which[nova] == -1) { all_vert.push(nova); in_which[nova] = component; compSize++; } } } component++; component_sizes.push_back(compSize); } } bool *can_take = new bool[component]; memset(can_take, true, component); int m; cin >> m; for (int t = 0; t < m; t++) { cin >> u >> v; if (in_which[u] == in_which[v]) { can_take[in_which[u]] = false; } } int result = 0; for (int i = 0; i < component; i++) { if (can_take[i]) result = max(result, component_sizes[i]); } cout << result; delete[] friends, in_which, can_take; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; inline int qpow(int b, int e, int m = 998244353) { int a = 1; for (; e; e >>= 1, b = (long long)b * b % m) if (e & 1) a = (long long)a * b % m; return a; } int vis[2001]; int cc[2001]; void dfs(int u, vector<vector<int>> &adj) { vis[u] = 1; cc[u] = 1; for (int j = 0; j < adj[u].size(); j++) { int v = adj[u][j]; if (vis[v] == 0) { dfs(v, adj); } } } void solve() { int n; cin >> n; vector<vector<int>> adj(n + 1); int t; cin >> t; for (int i = 0; i < t; i++) { int u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } memset(vis, 0, sizeof vis); int ans = 0; int m; cin >> m; vector<vector<bool>> dislike(n + 1, vector<bool>(n + 1)); for (int i = 0; i < m; i++) { int u, v; cin >> u >> v; dislike[u][v] = 1; dislike[v][u] = 1; } for (int i = 1; i <= n; i++) { if (vis[i] == 0) { memset(cc, 0, sizeof cc); dfs(i, adj); int cnt = 0; int test = 0; for (int j = 1; j <= n; j++) { if (cc[j] == 1) { for (int k = 1; k <= n; k++) { if (dislike[j][k] && cc[k]) { test = 1; goto out; } } cnt++; } } int c; out: if (test == 0) { ans = max(cnt, ans); } } } cout << ans << endl; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long t; t = 1; while (t--) solve(); return 0; }
9
CPP
#include <bits/stdc++.h> const int MOD = 1e9 + 7; using namespace std; const int N = 299; vector<int> adj[N], dislike[N]; bool vis[N]; vector<int> V; int ans = 0, group = 0; void dfs(int u) { vis[u] = 1; ++group; for (int v : adj[u]) { if (!vis[v]) { dfs(v); } } for (int v : dislike[u]) { if (vis[v]) group = -1e9; } } void solve() { int n, m; cin >> n >> m; for (int i = 0; i < m; ++i) { int u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } int k; cin >> k; for (int i = 0; i < k; ++i) { int u, v; cin >> u >> v; dislike[u].push_back(v); dislike[v].push_back(u); } for (int i = 1; i <= n; ++i) { dfs(i); ans = max(ans, group); group = 0; memset(vis, 0, sizeof(vis)); } cout << ans; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); solve(); }
9
CPP
#include <bits/stdc++.h> using namespace std; const int nMax = 2e3 + 2; vector<int> good[nMax]; bool bad[nMax][nMax] = {false}, used[nMax] = {false}; vector<int> comp; inline void dfs(int v) { used[v] = true; comp.push_back(v); for (int i = 0; i < (int)good[v].size(); ++i) { int to = good[v][i]; if (!used[to]) dfs(to); } } signed main() { int n, m; scanf("%d", &n); scanf("%d", &m); for (int i = 0; i < m; i++) { int u, v; scanf("%d %d", &u, &v); good[u - 1].push_back(v - 1); good[v - 1].push_back(u - 1); } int k; scanf("%d", &k); while (k-- > 0) { int u, v; scanf("%d %d", &u, &v); u--; v--; bad[u][v] = bad[v][u] = true; } int ans = 0; for (int i = 0; i < n; i++) { if (!used[i]) { comp.clear(); dfs(i); int curAns = (int)comp.size(); for (int i = 0; i < (int)comp.size() && curAns; i++) { for (int j = 0; j < (int)comp.size() && curAns; ++j) { int v = comp[i], to = comp[j]; if (i == j) continue; if (bad[v][to]) { curAns = -1; break; } } } ans = max(ans, curAns); } } printf("%d\n", ans); return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; vector<long long int> parent, s; vector<vector<long long int> > adj; void make_set(long long int v) { parent[v] = v; s[v] = 1; } long long int find_set(long long int v) { if (parent[v] == v) return v; else return parent[v] = find_set(parent[v]); } void union_sets(long long int a, long long int b) { a = find_set(a); b = find_set(b); if (a != b) { parent[b] = a; s[a] += s[b]; } } int main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); long long int n, k; cin >> n >> k; adj.resize(n + 1); s.resize(n + 1, 0); parent.resize(n + 1); for (long long int i = 1; i <= n; i++) make_set(i); for (long long int i = 1; i <= k; i++) { long long int u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); union_sets(u, v); } long long int m; cin >> m; for (long long int i = 1; i <= m; i++) { long long int u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); if (find_set(u) == find_set(v)) { parent[find_set(u)] = 0; } } long long int ans = 0; for (long long int i = 1; i <= n; i++) if (parent[i] == i) { ans = max(ans, s[i]); } cout << ans; return 0; }
9
CPP
#include <bits/stdc++.h> int link[300000], next[300000], e[300000], top, f[10000]; void connect(int t, int w) { top++; e[top] = w; next[top] = link[t]; link[t] = top; } int main() { int n, m1, m2, num[10000], b[10000], i, t, w, t2, p; scanf("%d", &n); scanf("%d", &m1); for (i = 0; i < m1; i++) { scanf("%d%d", &t, &w); connect(t, w); connect(w, t); } t2 = 0; for (i = 1; i <= n; i++) if (!f[i]) { t = 0; w = 1; b[1] = i; t2++; f[i] = t2; while (w > t) { t++; p = link[b[t]]; while (p) { if (!f[e[p]]) { f[e[p]] = t2; w++; b[w] = e[p]; } p = next[p]; } } num[t2] = w; } scanf("%d", &m2); for (i = 0; i < m2; i++) { scanf("%d%d", &t, &w); if (f[t] == f[w]) num[f[t]] = 0; } for (i = 2; i <= t2; i++) if (num[i] > num[1]) num[1] = num[i]; printf("%d", num[1]); return 0; }
9
CPP
#include <bits/stdc++.h> const int MAXN = 2010; int N; int ar[MAXN][MAXN]; int used[MAXN]; int vis[MAXN]; int par; int enemy[MAXN][MAXN]; void read() { int i, M, a, b; scanf(" %d %d", &N, &M); for (i = 1; i <= M; i++) { scanf(" %d %d", &a, &b); ar[a][b] = ar[b][a] = 1; } scanf(" %d", &M); for (i = 1; i <= M; i++) { scanf(" %d %d", &a, &b); enemy[a][b] = enemy[b][a] = 1; } } void dfs(int a) { vis[++par] = a; used[a] = 1; int i; for (i = 1; i <= N; i++) if (ar[a][i] && !used[i]) dfs(i); } bool control() { int i, j; for (i = 1; i <= par; i++) for (j = 1; j <= par; j++) if (enemy[vis[i]][vis[j]]) return false; return true; } int main() { read(); int i, max = 0; for (i = 1; i <= N; i++) if (!used[i]) { par = 0; dfs(i); if (par > max && control()) max = par; } printf("%d\n", max); return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; int friends[2001][2001]; int enemies[2001][2001]; int vis[2001]; void dfs(int v, vector<int> &gr, int &n) { vis[v] = 1; gr.push_back(v); for (int i = 1; i <= n; i++) { if (friends[v][i] && vis[i] == 0) { dfs(i, gr, n); } } return; } bool noenemy(vector<int> &gr) { for (int i = 0; i < gr.size() - 1; i++) { for (int j = i + 1; j < gr.size(); j++) { if (enemies[gr[i]][gr[j]]) { return 0; } } } return 1; } int main() { int n; cin >> n; for (int i = 0; i <= 2000; i++) { for (int j = 0; j <= 2000; j++) { friends[i][j] = 0; enemies[2001][2001] = 0; vis[i] = 0; } } int k; cin >> k; while (k) { int u, v; cin >> u >> v; friends[u][v] = 1; friends[v][u] = 1; k--; } int m; cin >> m; while (m) { int u, v; cin >> u >> v; enemies[u][v] = 1; enemies[v][u] = 1; m--; } int ans = 0; for (int i = 1; i <= n; i++) { if (vis[i] == 0) { vector<int> gr; dfs(i, gr, n); if (noenemy(gr)) { ans = max(ans, (int)gr.size()); } } } cout << ans; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int mod = 1000000007; int arr[1000000]; int Size[1000000]; void makeSet(int v) { for (int i = 0; i < v; i++) { arr[i] = i; Size[i] = 1; } } int find(int u) { if (arr[u] == u) return u; arr[u] = find(arr[u]); return arr[u]; } void munion(int u, int v) { int rootu = find(u); int rootv = find(v); if (rootu == rootv) return; if (Size[rootu] < Size[rootv]) { arr[rootu] = arr[rootv]; Size[rootv] += Size[rootu]; } else { arr[rootv] = arr[rootu]; Size[rootu] += Size[rootv]; } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); ; int n, k, m; cin >> n >> k; makeSet(n); for (int i = 0; i < k; i++) { int u, v; cin >> u >> v; u--; v--; munion(u, v); } cin >> m; bool stat[n]; for (int i = 0; i < n; i++) stat[i] = true; ; for (int i = 0; i < m; i++) { int u, v; cin >> u >> v; u--, v--; if (find(u) == find(v)) stat[find(u)] = false; } int ans = 0; for (int i = 0; i < n; i++) { if (stat[find(i)] == true) ans = max(ans, Size[find(i)]); } cout << ans << endl; }
9
CPP
#include <bits/stdc++.h> using namespace std; const long double pi = 3.141593; const long long mod = 1000000007; const long long INF = 1e15; const long long nax = 1e5 + 5; long long dx[] = {0, 0, 1, -1}; long long dy[] = {1, -1, 0, 0}; string ds = "RLDU"; long long parent[200001] = {0}; long long size[200001] = {0}; long long vi[200001] = {0}; long long find_set(long long v) { while (parent[v] != v) v = parent[v]; return v; } void unite(long long a, long long b) { a = find_set(a); b = find_set(b); if (a != b) { parent[b] = a; size[a] += size[b]; } } int32_t main() { long long n, k; cin >> n >> k; for (long long i = 1; i <= n; i++) { parent[i] = i; size[i] = 1; } for (long long i = 0; i < k; i++) { long long u, v; cin >> u >> v; unite(u, v); } long long m; cin >> m; map<long long, long long> M; for (long long i = 0; i < m; i++) { long long u, v; cin >> u >> v; long long a = find_set(u); long long b = find_set(v); if (a == b) M[a] = 1; } long long mx = 0; for (long long i = 1; i <= n; i++) { if (M[find_set(i)] == 0) { mx = max(mx, size[find_set(i)]); } } cout << mx << "\n"; }
9
CPP
#include <bits/stdc++.h> using namespace std; const double eps = 1.0e-11; const double pi = acos(-1.0); const int N = 2009; vector<vector<int> > g; vector<vector<int> > components; bool adj[N][N]; int used[N]; void dfs(int v) { used[v] = true; components[components.size() - 1].push_back(v); for (long long i = 0; i < (int)(g[v]).size(); i++) { int to = g[v][i]; if (!used[to]) { dfs(to); } } } int main() { int n; cin >> n; g.resize(n); int k, m; cin >> k; for (long long i = 0; i < k; i++) { int a, b; cin >> a >> b; --a, --b; g[a].push_back(b); g[b].push_back(a); } cin >> m; for (long long i = 0; i < m; i++) { int a, b; cin >> a >> b; --a, --b; adj[a][b] = adj[b][a] = 1; } for (long long i = 0; i < n; i++) { if (!used[i]) { components.push_back(vector<int>()); dfs(i); } } long long res = 0; for (long long i = 0; i < (int)(components).size(); i++) { bool ok = true; for (long long j = 0; j < (int)(components[i]).size(); j++) { for (long long t = 0; t < (int)(components[i]).size(); t++) { if (j == t) { continue; } if (adj[components[i][j]][components[i][t]]) { ok = false; } } } if (ok) { res = max(res, (long long)components[i].size()); } } cout << res << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const long long MAXN = 2e3 + 100; long long n, m, k; vector<long long> adj[MAXN], path; bool vis[MAXN], Bad[MAXN][MAXN]; void dfs(long long x) { vis[x] = true; path.push_back(x); for (long long i = 0; i < adj[x].size(); i++) { if (!vis[adj[x][i]]) { dfs(adj[x][i]); } } return; } int check(long long x) { path.clear(); dfs(x); for (long long i = 0; i < path.size(); i++) for (long long j = i + 1; j < path.size(); j++) if (Bad[path[i]][path[j]]) return 0; return path.size(); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> m; for (long long i = 0; i < m; i++) { long long u, v; cin >> u >> v; adj[u].push_back(v), adj[v].push_back(u); } cin >> k; for (long long i = 0; i < k; i++) { long long u, v; cin >> u >> v; Bad[u][v] = true, Bad[v][u] = true; } int ans = -1; for (long long i = 1; i <= n; i++) { ans = max(ans, check(i)); for (long long i = 1; i <= n; i++) vis[i] = false; } cout << ans; }
9
CPP
#include <bits/stdc++.h> long long const MAX = 1e5 + 5; using namespace std; set<pair<long long, long long> > st; vector<long long> adj[2001]; long long vis[2001]; vector<long long> visit; void dfs(long long v) { vis[v] = 1; visit.push_back(v); for (auto i : adj[v]) { if (!vis[i]) dfs(i); } } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long n, k; cin >> n >> k; for (long long i = 0; i < k; i++) { long long x, y; cin >> x >> y; adj[x].push_back(y); adj[y].push_back(x); } long long m; cin >> m; for (long long i = 0; i < m; i++) { long long x, y; cin >> x >> y; if (x > y) swap(x, y); st.insert({x, y}); } long long ans = 0; for (long long i = 1; i < n + 1; i++) { if (!vis[i]) { visit.clear(); dfs(i); long long cnt = visit.size(); int f = 0; for (long long j = 0; j < cnt; j++) { for (long long k = 0; k < cnt; k++) { if (st.find({min(visit[j], visit[k]), max(visit[j], visit[k])}) != st.end()) f = 1; } } if (f == 0) ans = max(ans, cnt); } } return cout << ans, 0; ; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int N = 203600; int p[N], sz[N]; int n, m; void init() { for (int i = (0); i < (int)(n); i++) p[i] = i, sz[i] = 1; } int f(int first) { if (first == p[first]) return first; return p[first] = f(p[first]); } bool gao[N]; int main() { while (cin >> n) { int m; cin >> m; init(); for (int i = (0); i < (int)(m); i++) { int first, second; cin >> first >> second; --first; --second; int px = f(first), py = f(second); if (px ^ py) { sz[py] += sz[px]; sz[px] = 0; p[px] = py; } } memset(gao, 0, sizeof(gao)); cin >> m; for (int i = (0); i < (int)(m); i++) { int first, second; cin >> first >> second; --first; --second; if (f(first) == f(second)) { gao[f(first)] = true; } } int ans = 0; for (int i = (0); i < (int)(n); i++) if (f(i) == i && !gao[i]) { ans = max(ans, sz[i]); } cout << ans << endl; } return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; vector<vector<int> > f; vector<vector<int> > d; vector<int> ch; inline int dfs(int v) { ch[v] = 1; for (int i = 0; i < (int)d[v].size(); i++) if (ch[d[v][i]] == 1) return 0; int ret = 1; for (int i = 0; i < (int)f[v].size(); i++) { if (ch[f[v][i]] == -1) return -1; if (ch[f[v][i]] == 0) { int newr = dfs(f[v][i]); if (newr == 0) return 0; if (newr == -1) return -1; ret += newr; } } return ret; } int main() { ch.clear(); f.clear(); d.clear(); int n, k, m; cin >> n; cin >> k; ch.resize(n, 0); f.resize(n); d.resize(n); for (int i = 0; i < k; i++) { int a, b; cin >> a >> b; f[a - 1].push_back(b - 1); f[b - 1].push_back(a - 1); } cin >> m; for (int i = 0; i < m; i++) { int a, b; cin >> a >> b; d[a - 1].push_back(b - 1); d[b - 1].push_back(a - 1); } int ans = 0; for (int i = 0; i < n; i++) { int ne = dfs(i); ans = max(ans, ne); ch[i] = -1; } cout << ans << endl; return 0; }
9
CPP
n = int(input()) l = int(input()) likes_list = [[] for i in range(n + 1)] for i in range(l): a, b = map(int, input().split()) likes_list[a].append(b) likes_list[b].append(a) d = int(input()) dislikes_list = [[] for i in range(n + 1)] for i in range(d): a, b = map(int, input().split()) dislikes_list[a].append(b) dislikes_list[b].append(a) v = [False] * (n + 1) groups = {} f_id = [i for i in range(n + 1)] for i in range(1, n + 1): if not v[i]: f = set() s = [i] while len(s) > 0: x = s.pop() f_id[x] = i f.add(x) if v[x]: continue v[x] = True for y in likes_list[x]: s.append(y) groups[i] = f for i in range(1, n + 1): for ds in dislikes_list[i]: groups[f_id[i]].difference_update({ds}.union(groups[f_id[ds]])) ans = 0 for v in groups.values(): ans = max(ans, len(v)) print(ans)
9
PYTHON3
#include <bits/stdc++.h> using namespace std; int f[2048], z[2048]; int rt(int x) { return (x == f[x] ? x : (f[x] = rt(f[x]))); } int main(void) { int n, m, v = 0; cin >> n >> m; for (int i = 1; i <= n; ++i) f[i] = i, z[i] = 1; for (int i = 0, a, b; i < m && cin >> a >> b; ++i) { a = rt(a), b = rt(b); if (a != b) f[b] = a, z[a] += z[b]; } cin >> m; for (int i = 0, a, b; i < m && cin >> a >> b; ++i) { a = rt(a), b = rt(b); if (a == b) z[a] = 0; } for (int i = 1; i <= n; ++i) if (i == rt(i) && z[i] > v) v = z[i]; cout << v << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; inline int max(int a, int b) { return a > b ? a : b; } inline int min(int a, int b) { return a < b ? a : b; } inline int gcd(int a, int b) { if (a % b) return gcd(b, a % b); else return b; } inline int lcm(int a, int b) { return (a * (b / gcd(a, b))); } inline int And(int mask, int bit) { return mask & (1 << bit); } inline int Or(int mask, int bit) { return mask | (1 << bit); } inline int Xor(int mask, int bit) { return mask & (~(1 << bit)); } vector<int> adj[2010]; vector<int> str; stack<int> S; int low[2010], num[2010], scc, color[2010]; int a[2010][2010], cnt; bool check() { int sz = str.size(); for (int i = 0; i < sz - 1; i++) for (int j = i + 1; j < sz; j++) { int x = str[i]; int y = str[j]; if (a[x][y] || a[y][x]) return false; } return true; } void tajan(int u) { num[u] = low[u] = ++cnt; S.push(u); for (int i = 0; i < adj[u].size(); i++) { int v = adj[u][i]; if (!color[v]) if (num[v]) low[u] = min(low[u], num[v]); else { tajan(v); low[u] = min(low[u], low[v]); } } if (low[u] == num[u]) { ++scc; int x; do { x = S.top(); S.pop(); color[x] = 1; str.push_back(x); } while (x != u); } } int main() { int n, m, x, y, sz, Ans; scanf("%d", &n); for (int i = 1; i <= n; i++) { color[i] = 0; low[i] = num[i] = 0; for (int j = 1; j <= n; j++) a[i][j] = 0; } scanf("%d", &m); for (int i = 0; i < m; i++) { scanf("%d %d", &x, &y); adj[x].push_back(y); adj[y].push_back(x); } scanf("%d", &sz); for (int i = 0; i < sz; i++) { scanf("%d %d", &x, &y); a[x][y] = 1; a[y][x] = 1; } Ans = 0; for (int i = 1; i <= n; i++) { if (!color[i]) { tajan(i); if (check()) Ans = max(Ans, str.size()); str.clear(); } } printf("%d\n", Ans); }
9
CPP
#include <bits/stdc++.h> using namespace std; const long long INF = 1e9, MOD = 998244353; long long gcd(long long a, long long b) { return (b ? gcd(b, a % b) : a); } long long power(long long a, long long b) { return (!b ? 1 : power(a, b / 2) * power(a, b / 2) * (b % 2 ? a : 1)); } long long mod(long long a) { return (a % MOD + MOD) % MOD; } const long long N = 2e3 + 20; long long par[N]; long long sz[N]; long long getPar(long long v) { return (par[v] == v ? v : par[v] = getPar(par[v])); } void merge(long long v, long long u) { v = getPar(v); u = getPar(u); if (v == u) return; if (sz[v] > sz[u]) swap(v, u); par[v] = u; sz[u] += sz[v]; sz[v] = 0; } void unmerge(long long v, long long u) { v = getPar(v); u = getPar(u); if (v != u) return; sz[v] = sz[u] = 0; } int32_t main() { ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); long long n; cin >> n; for (long long i = 1; i <= n; i++) par[i] = i, sz[i] = 1; long long k; cin >> k; for (long long i = 0; i < k; i++) { long long x, y; cin >> x >> y; merge(x, y); } long long m; cin >> m; for (long long i = 0; i < m; i++) { long long x, y; cin >> x >> y; unmerge(x, y); } long long mx = 0; for (long long i = 1; i <= n; i++) mx = max(mx, sz[getPar(i)]); cout << mx << "\n"; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; int par[100005]; int cnt[100005]; int find(int x) { while (x != par[x]) { par[x] = par[par[x]]; x = par[x]; } return x; } void uni(int a, int b) { int px = find(a); int py = find(b); if (px == py) return; if (cnt[py] > cnt[px]) { par[px] = py; cnt[py] += cnt[px]; } else { par[py] = px; cnt[px] += cnt[py]; } } int main() { int n; cin >> n; for (int i = 1; i <= n; i++) { par[i] = i; cnt[i] = 1; } int k; cin >> k; int a, b; for (int i = 0; i < k; i++) { cin >> a >> b; uni(a, b); } int l; cin >> l; for (int i = 0; i < l; i++) { cin >> a >> b; int pa = find(a); int push_back = find(b); if (pa == push_back) { cnt[pa] = 0; } } int ans = 0; for (int i = 1; i <= n; i++) { if (par[i] == i) ans = max(ans, cnt[i]); } cout << ans; }
9
CPP
#include <bits/stdc++.h> using namespace std; int par[2004], siz[2004]; int find_set(int a) { if (par[a] == a) return a; return par[a] = find_set(par[a]); } void union_set(int a, int b) { a = find_set(a); b = find_set(b); if (a != b) { if (siz[a] < siz[b]) swap(a, b); par[b] = a; siz[a] += siz[b]; } } int main() { int n; cin >> n; int k; cin >> k; for (int i = 0; i <= 2003; i++) par[i] = i, siz[i] = 1; int u, v; for (int i = 0; i < k; i++) { cin >> u >> v; union_set(u, v); } int m; cin >> m; for (int i = 0; i < m; i++) { cin >> u >> v; u = find_set(u); v = find_set(v); if (u == v) { siz[u] = -1; } } int ans = 0; for (int i = 1; i <= n; i++) { int z = find_set(i); ans = max(ans, siz[z]); } cout << ans << "\n"; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int inf = 1e9; const int mod = 1000000007; int N, M; vector<int> g[2001]; vector<int> cur; vector<bool> vis(2001); int Gbad[2001][2001]; int ans; void dfs(int v) { cur.push_back(v); vis[v] = true; for (int x : g[v]) if (!vis[x]) dfs(x); } void check(vector<int> &v) { bool good = true; int N = v.size(); for (int i = 0; i < N; i++) { for (int j = i + 1; j < N; j++) if (Gbad[cur[j]][cur[i]] == 1) { good = false; break; } } int cur = v.size(); if (good) ans = max(ans, cur); } void slv() { cin >> N >> M; int x, y; for (int i = 1; i <= M; i++) { cin >> x >> y; g[x].push_back(y); g[y].push_back(x); } int K; cin >> K; for (int i = 1; i <= K; i++) { cin >> x >> y; Gbad[x][y] = Gbad[y][x] = 1; } for (int i = 1; i <= N; i++) { if (vis[i] == 0) { dfs(i); check(cur); cur.clear(); } } cout << ans; } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int T = 1; while (T--) slv(); return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; vector<vector<int> > v, q; int vis1[2001] = {0}; int f(int k) { queue<int> z; int vis[2001] = {0}; int c = 1, i; z.push(k); vis[k] = 1; while (!z.empty()) { k = z.front(); z.pop(); for (i = 0; i < v[k].size(); i++) { if (vis[v[k][i]] == 2) return 0; if (vis[v[k][i]] == 0) { vis[v[k][i]] = 1; vis1[v[k][i]] = 1; c++; z.push(v[k][i]); } } for (i = 0; i < q[k].size(); i++) { if (vis[q[k][i]] == 1) return 0; if (vis[q[k][i]] == 0) vis[q[k][i]] = 2; } } return c; } int main() { int n, m, k, x, y, i; cin >> n; cin >> k; v.resize(n + 1); q.resize(n + 1); for (i = 0; i < k; i++) { cin >> x >> y; v[x].push_back(y); v[y].push_back(x); } cin >> m; for (i = 0; i < m; i++) { cin >> x >> y; q[x].push_back(y); q[y].push_back(x); } int p, m1 = 0; for (i = 1; i <= n; i++) if (!vis1[i]) { p = f(i); if (m1 < p) m1 = p; } cout << m1 << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int MAXN = 2010; const int FRIEND = 1; const int ENEMY = -1; int n, k, m, num_colors; int a[MAXN][MAXN]; int colors[MAXN]; int good_color[MAXN]; void dfs(int vertex, int color) { colors[vertex] = color; for (int j = 0; j < n; ++j) { if (a[vertex][j] == ENEMY) { if (colors[j] == colors[vertex]) { good_color[colors[vertex]] = false; } } if (a[vertex][j] == FRIEND && colors[j] == 0) { dfs(j, color); } } } int main() { scanf("%d%d", &n, &k); for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { a[i][j] = 0; } } for (int i = 0; i < k; ++i) { int u, v; scanf("%d%d", &u, &v); u--; v--; a[u][v] = FRIEND; a[v][u] = FRIEND; } scanf("%d", &m); for (int i = 0; i < m; ++i) { int u, v; scanf("%d%d", &u, &v); u--; v--; a[u][v] = ENEMY; a[v][u] = ENEMY; } num_colors = 0; for (int i = 0; i < n; ++i) { colors[i] = 0; } for (int i = 0; i < n; ++i) { if (colors[i] == 0) { good_color[++num_colors] = true; dfs(i, num_colors); } } for (int i = 0; i < n; ++i) { } int res = 0; for (int i = 1; i <= num_colors; ++i) { if (good_color[i]) { int num_so_colored = 0; for (int j = 0; j < n; ++j) { if (colors[j] == i) { num_so_colored++; } } if (num_so_colored > res) { res = num_so_colored; } } } cout << res << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; int n, l, d, maxi = 0; int adj[2010][2010] = {{0}}; int vis[2010] = {0}; void bfs(int x) { set<int> res; set<int> hate; queue<int> q; q.push(x); res.insert(x); vis[x] = 1; while (!q.empty()) { int t = q.front(); q.pop(); for (int k = 1; k <= n; k++) { if (adj[t][k] == -1) { if (res.count(k) > 0) return; hate.insert(k); } if (adj[t][k] == 1) { if (hate.count(k) > 0) { vis[k] = 1; return; } else if (!vis[k]) { q.push(k); res.insert(k); vis[k] = 1; } } } } if (res.size() > maxi) maxi = res.size(); int k; } int main() { cin >> n >> l; int j, k, a, b; for (j = 0; j < l; j++) { cin >> a >> b; adj[a][b] = adj[b][a] = 1; } cin >> d; for (j = 0; j < d; j++) { cin >> a >> b; adj[a][b] = adj[b][a] = -1; } for (k = 1; k <= n; k++) if (vis[k] == 0) bfs(k); cout << maxi << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; using ll = long long; const int N = 2e3 + 4; vector<int> circle; bool vis[N]; bool bad_Relation[N][N]; int parent[N]; ll chk[N]; int color[N]; int tim[N]; int dis[N]; int position[N]; vector<int> adj[N]; vector<int> adj1[N]; vector<int> graph[N]; bool has_cycle; int maxdis, maxnode, Totnode, depth = 1; bool ok; queue<int> q; stack<int> stk; vector<int> solution; int indegree[N]; int go[N]; int to[N]; ll x1, x2, x3, x4, x5, x6; string ss; int gn, gk; vector<int> vec; void dfs(int node) { vis[node] = true; vec.push_back(node); for (int i = 0; i < adj[node].size(); i++) { int u = adj[node][i]; if (!vis[u]) { dfs(u); } } } bool check() { for (int i = 0; i < vec.size(); i++) { for (int j = 0; j < vec.size(); j++) { if (bad_Relation[vec[i]][vec[j]]) { return false; } } } return true; } int main() { int t = 1; int cas = 0; while (t--) { int n, m, i, j, cnt = 0, cnt1 = 0, cnt2 = 0, even = 0, odd = 0, len, k, r, l, z = 0, x = 0, y = 0, flag = 0, sum = 0, tottal = 0; int a = 0, b = 0, c = 0, d = 0, ans = 0, rem, quot, zero = 0, fst = 0, null = 0, snd = 0, lst = 0, rone = 0, one = 0, pos = 0, neg = 0, mn = INT_MAX, mx = INT_MIN; char ch; int h1, h2, m1, m2, h; int velo1, velo2, ac1, ac2, tim, hour, mint, sec; int node, edge, u, v, cost; int bst, wrst; double nd, ad, bd, cd, dd, xd, sumd = 0.00; string str, str1 = "", str2 = "", str3 = "", strstore1 = "", strstore2 = ""; cin >> node >> edge; for (i = 0; i < edge; i++) { cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } cin >> m; for (i = 0; i < m; i++) { cin >> u >> v; bad_Relation[u][v] = true; } ans = 0; for (i = 1; i <= node; i++) { if (!vis[i]) { vec.clear(); dfs(i); if (check()) { x = vec.size(); ans = max(ans, x); } } } cout << ans << endl; } return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; int rela[2000][2000]; int par[2000]; bool dislike[2000][2000]; void init_par(int n) { for (int i = 0; i < (n); i++) par[i] = i; } int root(int x) { return (par[x] == x ? x : par[x] = root(par[x])); } void unite(int x, int y) { x = root(x); y = root(y); if (x != y) { (y < x ? par[x] = y : par[y] = x); } } bool same(int x, int y) { return (root(x) == root(y)); } int main() { memset(rela, 0, sizeof(rela)); memset(dislike, false, sizeof(dislike)); int n; scanf("%d", &n); init_par(n); int k; scanf("%d", &k); for (int i = 0; i < (k); i++) { int a, b; scanf("%d %d", &a, &b); a--; b--; unite(a, b); } int m; scanf("%d", &m); for (int i = 0; i < (m); i++) { int c, d; scanf("%d %d", &c, &d); c--; d--; dislike[c][d] = true; dislike[d][c] = true; } map<int, int> group; vector<int> acqu(n); for (int i = 0; i < (n); i++) { group[root(i)]++; acqu[i] = root(i); } int res = 0; map<int, int>::iterator it = group.begin(); for (; it != group.end(); it++) { int g = (*it).first; bool found = false; if ((*it).second > res) { for (int i = 0; i < (n); i++) for (int j = 0; j < (n); j++) if (i != j && g == acqu[i] && g == acqu[j]) { if (dislike[i][j]) { found = true; break; } } if (!found) { res = (*it).second; } } } printf("%d\n", res); return 0; }
9
CPP
# Problem: C1. Party # Contest: Codeforces - ABBYY Cup 2.0 - Easy # URL: https://codeforces.com/contest/177/problem/C1 # Memory Limit: 256 MB # Time Limit: 2000 ms # # KAPOOR'S from sys import stdin, stdout def INI(): return int(stdin.readline()) def INL(): return [int(_) for _ in stdin.readline().split()] def INS(): return stdin.readline() def MOD(): return pow(10,9)+7 def OPS(ans): stdout.write(str(ans)+"\n") def OPL(ans): [stdout.write(str(_)+" ") for _ in ans] stdout.write("\n") rank=[0 for _ in range(2000+1)] par=[_ for _ in range(2000+1)] Size=[1 for _ in range(2000+1)] def findpar(x): if x==par[x]: return x return findpar(par[x]) def union(pu,pv): if rank[pu]<rank[pv]: par[pu]=pv Size[pv]+=Size[pu] elif rank[pv]<rank[pu]: par[pv]=pu Size[pu]+=Size[pv] else: par[pv]=pu rank[pu]+=1 Size[pu]+=Size[pv] if __name__=="__main__": # for _ in range(INI()): t=INI() n=INI() for _ in range(n): u,v=INL() pu=findpar(u) pv=findpar(v) if pu!=pv: union(pu,pv) q=int(input()) for _ in range(q): u,v=INL() pu=findpar(u) pv=findpar(v) if pu==pv: Size[pu]=0 ans=0 for _ in range(1,t+1): ans=max(ans,Size[findpar(_)]) print(ans)
9
PYTHON3
#include <bits/stdc++.h> using namespace std; long long n, k, m; vector<vector<long long> > friends, enemies; vector<long long> group_nums; vector<bool> visited; long long dfs(long long node, bool &ok, long long num) { long long cnt = 1; visited[node] = true; group_nums[node] = num; for (auto neigh : friends[node]) { if (!visited[neigh]) { cnt += dfs(neigh, ok, num); } } for (auto e : enemies[node]) { if (group_nums[e] == group_nums[node]) { ok = false; } } return cnt; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); ; cin >> n; friends.resize(n + 1); enemies.resize(n + 1); cin >> k; for (long long i = 0; i < k; ++i) { long long a, b; cin >> a >> b; friends[a].push_back(b); friends[b].push_back(a); } cin >> m; for (long long i = 0; i < m; ++i) { long long a, b; cin >> a >> b; enemies[a].push_back(b); enemies[b].push_back(a); } group_nums.resize(n + 1, -1); visited.resize(n + 1, false); long long ans = 0, num = 1; for (long long i = 1; i <= n; ++i) { if (!visited[i]) { bool ok = true; long long val = dfs(i, ok, num++); if (ok) { ans = max(ans, val); } } } cout << ans; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; static const double EPS = 1e-5; const int MODULO = 1000000007; template <int size> class UnionFind { int par[size]; int rank[size]; public: UnionFind() { reset(); } void reset() { for (int i = 0; i < (size); i++) par[i] = i, rank[i] = 0; } int find(int x) { if (par[x] == x) return x; return par[x] = find(par[x]); } void unite(int x, int y) { x = find(x), y = find(y); if (x == y) return; if (rank[x] < rank[y]) { par[x] = y; } else { par[y] = x; if (rank[x] == rank[y]) rank[x]++; } } bool same(int x, int y) { return find(x) == find(y); } }; int n, l, d; bool dis[2000][2000]; bool b[2000]; bool check(vector<int> &v) { for (int i = 0; i < int((v).size()); i++) { for (int j = i + 1; j < int((v).size()); j++) { if (dis[v[i]][v[j]]) return false; } } return true; } int main() { UnionFind<2000> u; cin >> n; cin >> l; for (int i = 0; i < (l); i++) { int a, b; cin >> a >> b; u.unite(a - 1, b - 1); } cin >> d; for (int i = 0; i < (d); i++) { int a, b; cin >> a >> b; dis[a - 1][b - 1] = 1; dis[b - 1][a - 1] = 1; } int ans = 0; vector<int> v; for (int i = 0; i < (n); i++) { if (b[i]) continue; v.clear(); for (int j = 0; j < (n); j++) if (u.same(i, j)) v.push_back(j); for (__typeof__((v).begin()) it = (v).begin(); it != (v).end(); ++it) b[*it] = true; if (check(v)) ans = max(ans, int((v).size())); } cout << ans << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int N = 123456; int Father[N + 1], s[N + 1]; void init() { for (int i = 1; i <= N; i++) Father[i] = i, s[i] = 1; } int find(int x) { return x == Father[x] ? x : Father[x] = find(Father[x]); } int main() { ios::sync_with_stdio(false); init(); int x, y, ans = 0; int n, k, m; cin >> n >> k; for (int i = 1; i <= k; i++) { cin >> x >> y; int fx = find(x), fy = find(y); if (fx != fy) { Father[fx] = fy; s[fy] += s[fx]; } } cin >> m; for (int i = 1; i <= m; i++) { cin >> x >> y; int fx = find(x), fy = find(y); if (fx == fy) s[fy] = 0; } for (int i = 1; i <= n; i++) { if (ans < s[i] && s[find(i)] != 0) ans = s[i]; } cout << ans << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; vector<long long int> adj[2005]; vector<long long int> lan[2005]; long long int parent[2005]; long long int cnt[2005]; long long int find_parent(long long int x) { if (x == parent[x]) return x; return parent[x] = find_parent(parent[x]); } int main() { long long int n; cin >> n; for (long long int i = 1; i < n + 1; i++) { parent[i] = i; cnt[i] = 1; } long long int m; cin >> m; while (m--) { long long int u, v; cin >> u >> v; long long int pu = find_parent(u); long long int pv = find_parent(v); if (pu != pv) { cnt[pu] += cnt[pv]; cnt[pv] = 0; parent[pv] = pu; } } long long int k; cin >> k; while (k--) { long long int u, v; cin >> u >> v; long long int pu = find_parent(u); long long int pv = find_parent(v); if (pu == pv) { cnt[pu] = 0; } } long long int ans = LONG_LONG_MIN; for (long long int i = 1; i < n + 1; i++) { if (parent[i] == i) ans = max(cnt[i], ans); } cout << ans; }
9
CPP
#include <bits/stdc++.h> using namespace std; bool link[2001][2001], ulink[2001][2001]; bool visited[2001]; int n, k, m; vector<int> data; void dfs(int st) { for (int i = 1; i <= n; i++) { if (!visited[i] && link[st][i]) { visited[i] = 1; data.push_back(i); dfs(i); } } } int stop; int main() { while (scanf(" %d", &n) == 1) { memset(link, 0, sizeof(link)); memset(ulink, 0, sizeof(ulink)); scanf(" %d", &m); for (int i = 0; i < m; i++) { int a, b; scanf(" %d %d", &a, &b); link[a][b] = link[b][a] = 1; } scanf(" %d", &k); for (int i = 0; i < k; i++) { int a, b; scanf(" %d %d", &a, &b); ulink[a][b] = ulink[b][a] = 1; } int ans = 0; memset(visited, 0, sizeof(visited)); for (int i = 1; i <= n; i++) { if (!visited[i]) { data.clear(); visited[i] = 1; data.push_back(i); dfs(i); bool flag = true; for (int j = 0; j < data.size(); j++) { for (int k = j + 1; k < data.size(); k++) { if (ulink[data[j]][data[k]]) { flag = false; j = data.size(); break; } } } if (flag && data.size() > ans) ans = data.size(); } } printf("%d\n", ans); } return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const long long N = 1e6 + 5, inf = 1e18, mod = 1e9 + 7; const long double pi = 3.141592653589793238; bool check_prime(long long n) { long long flag = 0, i; for (i = 2; i * i <= n; i++) { if (n % i == 0) { flag = 1; break; } } if (n == 1) { return false; } else if (flag == 0 || n == 2 || n == 3) { return true; } else { return false; } } long long fastexpo(long long a, long long b, long long MOD) { long long result = 1; while (b > 0) { if (b % 2 == 1) { result = (result * a) % MOD; } a = (a * a) % MOD; b = b / 2; } return result; } vector<long long> G[N]; long long vis[N]; vector<long long> vec[2005]; void dfs(long long node, long long count) { long long i; vis[node] = 1; vec[count].push_back(node); for (i = 0; i < G[node].size(); i++) { if (vis[G[node][i]] == 0) { dfs(G[node][i], count); } } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long n, u, v, i, k, m, ma, c, j, count; cin >> n; cin >> m; for (i = 1; i <= m; i++) { cin >> u >> v; G[u].push_back(v); if (u != v) { G[v].push_back(u); } } vector<pair<long long, long long> > vi; cin >> k; for (i = 1; i <= k; i++) { cin >> u >> v; vi.push_back({u, v}); } count = 0; for (i = 1; i <= n; i++) { if (vis[i] == 0) { dfs(i, count); count++; } } ma = 0; for (i = 0; i < count; i++) { sort(vec[i].begin(), vec[i].end()); c = 1; for (j = 0; j < k; j++) { if (binary_search(vec[i].begin(), vec[i].end(), vi[j].first) && binary_search(vec[i].begin(), vec[i].end(), vi[j].second)) { c = 0; break; } } if (c == 1) { c = vec[i].size(); ma = max(ma, c); } } cout << ma << "\n"; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; struct DS { vector<int> p, s; void reset(int n) { p.resize(n); s.resize(n); for (int i = 0; i < n; ++i) { p[i] = i; s[i] = 1; } } int getParent(int v) { if (v != p[v]) p[v] = getParent(p[v]); return p[v]; } void link(int u, int v) { u = getParent(u); v = getParent(v); if (u == v) return; if (s[u] > s[v]) swap(u, v); p[u] = v; s[v] += s[u]; } }; int main() { int n; cin >> n; DS friends; friends.reset(n); int k; cin >> k; while (k--) { int u, v; cin >> u >> v; friends.link(u - 1, v - 1); } vector<bool> ok(n, true); cin >> k; while (k--) { int u, v; cin >> u >> v; --u; --v; if (friends.getParent(u) == friends.getParent(v)) ok[friends.getParent(u)] = false; } int res = 0; for (int i = 0; i < n; ++i) { int p = friends.getParent(i); if (ok[p]) res = max(res, friends.s[p]); } cout << res << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int maxn = 5000; vector<int> good[maxn]; vector<int> bad[maxn]; int colorg[maxn], colorb[maxn]; int n, k, m; int mg = 1, mb = 1; void dfsg(int v, int c) { colorg[v] = c; for (int i = 0; i < (int)(good[v].size()); i++) if (!colorg[good[v][i]]) dfsg(good[v][i], c); } set<int> bbad[maxn]; void dfsb(int v, int c) { colorb[v] = c; for (int i = 0; i < (int)(bad[v].size()); i++) if (!colorb[bad[v][i]]) dfsb(bad[v][i], c); } vector<int> colors[maxn]; int main(void) { scanf("%d", &n); scanf("%d", &k); for (int i = 0; i < k; i++) { int u, v; scanf("%d %d", &u, &v), --u, --v; good[u].push_back(v), good[v].push_back(u); } scanf("%d", &m); for (int i = 0; i < m; i++) { int u, v; scanf("%d %d", &u, &v), --u, --v; bad[u].push_back(v), bad[v].push_back(u); bbad[u].insert(v), bbad[v].insert(u); } for (int i = 0; i < n; i++) { if (!colorg[i]) dfsg(i, mg), mg++; if (!colorb[i]) dfsb(i, mb), mb++; } int ans = 0; for (int i = 0; i < n; i++) colors[colorg[i]].push_back(i); for (int i = 1; i < n; i++) { bool flag = true; for (int j = 0; j < (int)(colors[i].size()); j++) for (int k = j + 1; k < (int)(colors[i].size()); k++) { int u = colors[i][j], v = colors[i][k]; if (bbad[u].find(v) != bbad[u].end()) flag = false; } if (flag) ans = max(ans, (int)colors[i].size()); } cout << ans << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; long long dfs(long long i, vector<vector<long long>> &v, vector<vector<long long>> &v1, vector<long long> &isit, vector<long long> &temp) { if (isit[i] != 0) { return 0; } isit[i]++; temp[i]++; bool flag = 0; long long t = 1; for (long long j = 0; j < v[i].size(); j++) { if (isit[v[i][j]] == 0) { long long k = dfs(v[i][j], v, v1, isit, temp); if (k == -1) { flag = 1; } t += k; } } for (long long j = 0; j < v1[i].size(); j++) { if (temp[v1[i][j]] == 1) { return -1; } } if (flag == 1) { return -1; } else { return t; } } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long n; cin >> n; long long l; long long dl; cin >> l; vector<vector<long long>> like(n + 1); for (long long i = 0; i < l; i++) { long long a, b; cin >> a >> b; like[a].push_back(b); like[b].push_back(a); } cin >> dl; vector<vector<long long>> dlike(n + 1); for (long long i = 0; i < dl; i++) { long long a, b; cin >> a >> b; dlike[a].push_back(b); dlike[b].push_back(a); } vector<long long> ans; long long ians = 0; vector<long long> isit(n + 1); for (long long i = 1; i <= n; i++) { if (isit[i] == 0) { vector<long long> temp(n + 1); long long t = dfs(i, like, dlike, isit, temp); ans.push_back(t); } } for (long long i : ans) { ians = max(ians, i); } cout << ians; }
9
CPP
#include <bits/stdc++.h> using namespace std; int p[10000]; int parent(int x) { return p[x] == x ? x : parent(p[x]); } void join(int x, int y) { p[parent(y)] = parent(x); } vector<int> graph[10000]; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int u, v, n, k, m; cin >> n >> k; for (int i = 0; i < n; i++) p[i] = i; for (int i = 0; i < k; i++) { cin >> u >> v; graph[u - 1].push_back(v - 1); graph[v - 1].push_back(u - 1); join(u - 1, v - 1); } set<int> s; cin >> m; for (int i = 0; i < m; i++) { cin >> u >> v; if (parent(u - 1) == parent(v - 1)) s.insert(parent(v - 1)); } int h, ans = INT_MIN, count[10000] = {0}; for (int i = 0; i < n; i++) { h = parent(i); if (s.count(h) == 0) { count[h]++; } ans = max(ans, count[h]); } cout << ans; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; vector<int> color; vector<vector<int> > fr, enemies, heap(2001, vector<int>(0)); bool cmp(vector<int> a, vector<int> b) { return (int)a.size() < (int)b.size(); } void DFS(int v, int val) { color[v] = val; heap[val].push_back(v); int sz = (int)fr[v].size(); for (int i = 0; i < sz; i++) if (!color[fr[v][i]]) DFS(fr[v][i], val); } bool can(vector<int> a) { int sz = (int)a.size(), i, j; for (i = 0; i < sz; i++) for (j = 0; j < sz; j++) if (enemies[a[i]][a[j]]) return false; return true; } int main() { long long n, x, a, b, i, j; long long col = 1; cin >> n >> x; enemies.resize(n, vector<int>(n)); fr.resize(n, vector<int>(0)); color.resize(n); for (i = 0; i < x; i++) { cin >> a >> b; a--, b--; fr[a].push_back(b); fr[b].push_back(a); } cin >> x; for (i = 0; i < x; i++) { cin >> a >> b; a--, b--; enemies[a][b] = enemies[b][a] = 1; } col = 1; for (i = 0; i < n; i++) { if (!color[i]) { DFS(i, col); col++; } } sort(heap.rbegin(), heap.rend(), &cmp); for (i = 0; i < 2001; i++) if (can(heap[i])) { cout << (int)heap[i].size(); return 0; } }
9
CPP
#include <bits/stdc++.h> using namespace std; vector<vector<int> > f; vector<vector<int> > d; int ch[2000 + 100]; inline int dfs(int v) { for (int i = 0; i < (int)d[v].size(); i++) if (ch[d[v][i]] == 1) return 0; ch[v] = 1; int ret = 1; for (int i = 0; i < (int)f[v].size(); i++) { if (ch[f[v][i]] == 0) { int newr = dfs(f[v][i]); if (newr == 0) return 0; ret += newr; } } return ret; } int main() { f.clear(); d.clear(); int n, k, m; cin >> n; cin >> k; f.resize(n); d.resize(n); for (int i = 0; i < k; i++) { int a, b; cin >> a >> b; f[a - 1].push_back(b - 1); f[b - 1].push_back(a - 1); } cin >> m; for (int i = 0; i < m; i++) { int a, b; cin >> a >> b; d[a - 1].push_back(b - 1); d[b - 1].push_back(a - 1); } int ans = 0; for (int i = 0; i < n; i++) { memset(ch, 0, sizeof ch); int ne = dfs(i); ans = max(ans, ne); } cout << ans << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; long long ran[200009]; long long parent[200009]; long long find(long long i) { if (parent[i] == i) { return i; } return parent[i] = find(parent[i]); } void merge(long long i, long long j) { long long pi = find(i); long long pj = find(j); long long r1 = ran[pi]; long long r2 = ran[pj]; if (pi == pj) return; if (r1 < r2) { parent[pi] = pj; } else if (r1 == r2) { parent[pj] = pi; ran[pi]++; } else { parent[pj] = pi; } } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long n; cin >> n; long long z[n + 1]; for (long long i = 0; i < n + 1; i++) { ran[i] = 0; z[i] = 0; parent[i] = i; } long long m; cin >> m; for (long long i = 0; i < m; i++) { long long x, y; cin >> x >> y; merge(x, y); } long long p; cin >> p; for (long long i = 0; i < p; i++) { long long x, y; cin >> x >> y; x = find(x); y = find(y); if (x == y) { z[x] = -1; } } for (long long i = 1; i < n + 1; i++) { long long x = find(i); if (z[x] != -1) z[x]++; } long long c = 0; for (long long i = 1; i < n + 1; i++) c = max(c, z[i]); cout << c << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; struct Node { int groupId; vector<int> friends; Node() { groupId = -1; } } G[2000]; int groupCount = 0, groupSize[2000], n; int enemyX[100000], enemyY[10000], enemyCnt; void dfs(int u); int getMax(); int main() { int k, u, v; scanf("%d%d", &n, &k); for (int i = 0; i < k; ++i) { scanf("%d%d", &u, &v); G[u - 1].friends.push_back(v - 1); G[v - 1].friends.push_back(u - 1); } scanf("%d", &enemyCnt); for (int i = 0; i < enemyCnt; ++i) { scanf("%d%d", enemyX + i, enemyY + i); --enemyX[i]; --enemyY[i]; } int ans = getMax(); printf("%d\n", ans); } int getMax() { for (int i = 0; i < n; ++i) { if (G[i].groupId == -1) { dfs(i); ++groupCount; } } int g; for (int i = 0; i < n; ++i) { g = G[i].groupId; ++groupSize[g]; } int x, y, gx, gy; for (int i = 0; i < enemyCnt; ++i) { x = enemyX[i]; y = enemyY[i]; gx = G[x].groupId; gy = G[y].groupId; if (gx == gy) groupSize[gx] = 0; } return *max_element(groupSize, groupSize + groupCount); } void dfs(int u) { G[u].groupId = groupCount; const int f = G[u].friends.size(); for (int i = 0; i < f; ++i) { int v = G[u].friends[i]; if (G[v].groupId == -1) dfs(v); } }
9
CPP
#include <bits/stdc++.h> using namespace std; int fa[10000]; int num[10000]; int i, j, n, k; int find(int u) { return (u == fa[u]) ? u : fa[u] = find(fa[u]); } int main() { scanf("%d", &n); for (i = 1; i <= n; i++) fa[i] = i; scanf("%d", &k); for (i = 1; i <= k; i++) { int u, v; scanf("%d%d", &u, &v); fa[find(u)] = find(v); } scanf("%d", &k); for (i = 1; i <= k; i++) { int u, v; scanf("%d%d", &u, &v); int f1 = find(u), f2 = find(v); if (f1 == f2) num[f1] = -1; } for (i = 1; i <= n; i++) { int f = find(i); if (num[f] != -1) num[f]++; } int maxx = 0; for (i = 1; i <= n; i++) { int f = find(i); if (num[f] > maxx) maxx = num[f]; } printf("%d\n", maxx); return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int maxn = 3005; vector<int> edge[maxn]; int st[maxn], dfn[maxn], low[maxn]; int Top, Btype, Time; int Belong[maxn], n, m; bool ins[maxn]; void tarjan(int s) { int i, t; dfn[s] = low[s] = ++Time; ins[s] = true; st[++Top] = s; for (i = 0; i < edge[s].size(); i++) { t = edge[s][i]; if (!dfn[t]) { tarjan(t); if (low[t] < low[s]) low[s] = low[t]; } else if (ins[t] && dfn[t] < low[s]) low[s] = dfn[t]; } if (dfn[s] == low[s]) { Btype++; do { t = st[Top--]; ins[t] = false; Belong[t] = Btype; } while (t != s); } } void SCC(int n) { int i; Top = Btype = Time = 0; memset(ins, 0, sizeof(ins)); memset(dfn, 0, sizeof(dfn)); for (i = 1; i <= n; i++) if (!dfn[i]) tarjan(i); return; } int chu[maxn], cnt[maxn]; bool mark[maxn]; int main() { int i, a, b; while (scanf("%d", &n) != -1) { scanf("%d", &m); for (i = 1; i <= n; i++) edge[i].clear(); for (i = 0; i < m; i++) { scanf("%d%d", &a, &b); edge[a].push_back(b); edge[b].push_back(a); } SCC(n); memset(mark, false, sizeof(mark)); scanf("%d", &m); for (i = 0; i < m; i++) { scanf("%d%d", &a, &b); if (Belong[a] == Belong[b]) mark[Belong[a]] = 1; } int ans[maxn], Max = 0; memset(ans, 0, sizeof(ans)); for (i = 1; i <= n; i++) { if (!mark[Belong[i]]) ans[Belong[i]]++; Max = Max < ans[Belong[i]] ? ans[Belong[i]] : Max; } printf("%d\n", Max); } return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; void qmax(int &x, int y) { if (x < y) x = y; } void qmin(int &x, int y) { if (x > y) x = y; } inline int read() { char s; int k = 0, base = 1; while ((s = getchar()) != '-' && s != EOF && !(isdigit(s))) ; if (s == EOF) exit(0); if (s == '-') base = -1, s = getchar(); while (isdigit(s)) k = k * 10 + (s ^ '0'), s = getchar(); return k * base; } inline void write(int x) { static char cnt, num[15]; cnt = 0; if (!x) { putchar('0'); return; } for (; x; x /= 10) num[++cnt] = x % 10; for (; cnt; putchar(num[cnt--] + 48)) ; } const int maxn = 2e3 + 100; int n, m; int u, v; int fa[maxn], sz[maxn]; int gf(int x) { if (fa[x] == x) return x; return fa[x] = gf(fa[x]); } int main() { n = read(); for (int i = 1; i <= n; i++) sz[i] = 1, fa[i] = i; m = read(); while (m--) { u = read(); v = read(); u = gf(u); v = gf(v); if (u != v) { fa[u] = v; sz[v] += sz[u]; sz[u] = 0; } } m = read(); while (m--) { u = read(); v = read(); u = gf(u); v = gf(v); if (u == v) { sz[u] = 0; } } int ans = 0; for (int i = 1; i <= n; i++) { if (fa[i] == i) { ans = max(ans, sz[i]); } } printf("%d\n", ans); return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; int n, m, x, y, a[100001], b[100001], visit[2001], t; set<int> gr, fin; vector<long long> v[2001]; void dfs(int x) { visit[x] = 1; gr.insert(x); for (int i = 0; i < v[x].size(); i++) if (!visit[v[x][i]]) dfs(v[x][i]); } int main() { scanf("%d", &n); scanf("%d", &t); for (int i = 0; i < t; i++) { scanf("%d%d", &x, &y); v[x].push_back(y); v[y].push_back(x); } scanf("%d", &m); for (int i = 0; i < m; i++) scanf("%d%d", &a[i], &b[i]); for (int i = 1; i <= n; i++) { gr.clear(); if (!visit[i]) { dfs(i); for (int i = 0; i < m; i++) { if (gr.find(a[i]) != gr.end() && gr.find(b[i]) != gr.end()) { gr.clear(); break; } } for (auto i = gr.begin(); i != gr.end(); i++) { if (i == prev(gr.end())) continue; set<int>::iterator p = i; p++; if ((*i) + 1 != *p) { gr.clear(); break; } } fin.insert(gr.size()); } } if (fin.empty()) printf("0"); else { set<int>::iterator i = prev(fin.end()); printf("%d", *i); } }
9
CPP
#include <bits/stdc++.h> using namespace std; int n, m, res; int w[2002]; bool a[2002][2002]; vector<int> ed[2002]; vector<int> q; void dfs(int u) { w[u] = 1; q.push_back(u); for (int i = 0; i < ((int)ed[u].size()); i++) if (!w[ed[u][i]]) dfs(ed[u][i]); } int main() { scanf("%d%d", &n, &m); for (int i = 0; i < m; i++) { int u, v; scanf("%d%d", &u, &v); ed[u].push_back(v); ed[v].push_back(u); } scanf("%d", &m); for (int i = 0; i < m; i++) { int u, v; scanf("%d%d", &u, &v); a[u][v] = a[v][u] = 1; } for (int i = 1; i <= n; i++) if (!w[i]) { q.clear(); dfs(i); bool ok = 1; for (int j = 0; j < ((int)q.size()) && ok; j++) for (int k = j + 1; k < ((int)q.size()) && ok; k++) if (a[q[j]][q[k]]) ok = 0; if (ok) res = max(res, ((int)q.size())); } cout << res << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; int visit[2008]; vector<int> v[2008]; vector<int> conn(2008); vector<int> parent(2008); map<int, int> m; int kk; void dfs(int node) { kk++; int com = 0; stack<int> st; st.push(node); while (st.size()) { int ff = st.top(); st.pop(); if (visit[ff]) { continue; } visit[ff] = 1; com++; conn[ff] = kk; parent[ff] = node; for (int child : v[ff]) { if (!visit[child]) st.push(child); } } m[com]++; parent[node] = -com; } int main() { int n, e; cin >> n >> e; int a, b; while (e--) { cin >> a >> b; if (a == b) continue; v[a].push_back(b); v[b].push_back(a); } for (int i = 1; i <= n; i++) { if (visit[i]) continue; dfs(i); } int dis; cin >> dis; while (dis--) { cin >> a >> b; if (conn[a] != conn[b]) continue; if (parent[a] < 0) m[-parent[a]]--; else { m[-parent[parent[a]]]--; } } bool flag = true; for (auto it = m.rbegin(); it != m.rend(); it++) { if (it->second > 0) { cout << it->first << endl; flag = false; break; } } if (flag) cout << 0 << endl; }
9
CPP
#include <bits/stdc++.h> using namespace std; const long long M = 1e18; map<int, int> q; vector<int> a[2005]; int vis[2005], s; void dfs(int i) { q[i] = 1; vis[i] = 1; s++; for (auto j : a[i]) { if (!vis[j]) { dfs(j); } } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int n, k, m, x, y; cin >> n >> k; vector<pair<int, int> > b; for (int i = 0; i < k; i++) { cin >> x >> y; a[x].push_back(y); a[y].push_back(x); } cin >> m; for (int i = 0; i < m; i++) { cin >> x >> y; b.push_back({x, y}); } if (k == 0 && m == 0) { cout << 1; return 0; } int z = 0, ans = 0; for (int i = 1; i <= n; i++) { if (!vis[i]) { dfs(i); if (s == 1) { ans = max(ans, s); continue; } for (int j = 0; j < m; j++) { if (q[b[j].first] == 1 && q[b[j].second] == 1) { z = 1; break; } } if (z == 0) ans = max(ans, s); s = 0; q.clear(); } } cout << ans; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; void dfs(const vector<vector<int> > &g, int v, vector<int> &components, vector<int> &comp_length, int comp_n) { components[v] = comp_n; ++comp_length[comp_n]; for (int i = 0; i < (int)g[v].size(); ++i) { if (components[g[v][i]] == -1) { dfs(g, g[v][i], components, comp_length, comp_n); } } } int main() { int n, k, m, a, b; cin >> n >> k; vector<vector<int> > graph(n); for (int i = 0; i < k; ++i) { cin >> a >> b; --a; --b; graph[a].push_back(b); graph[b].push_back(a); } vector<pair<int, int> > enemies; cin >> m; for (int i = 0; i < m; ++i) { cin >> a >> b; --a; --b; enemies.push_back(make_pair(a, b)); } vector<int> components(n, -1); vector<int> comp_length; for (int i = 0; i < n; ++i) { if (components[i] == -1) { comp_length.push_back(0); dfs(graph, i, components, comp_length, comp_length.size() - 1); } } vector<bool> is_acceptable(comp_length.size(), true); for (int i = 0; i < (int)enemies.size(); ++i) { if (components[enemies[i].first] == components[enemies[i].second]) { is_acceptable[components[enemies[i].first]] = false; } } int max = 0; for (int i = 0; i < (int)comp_length.size(); ++i) { if (is_acceptable[i] && comp_length[i] > max) { max = comp_length[i]; } } cout << max << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int sz = 1e5 + 5; vector<int> a[sz]; bool mark[sz]; int items[sz]; int com[sz]; int cc; int n; int k; void dfs(int u) { com[u] = cc; items[cc]++; for (int i = 0; i < (int)a[u].size(); i++) { int v = a[u][i]; if (!com[v]) dfs(v); } } int main() { scanf("%d", &n); ; scanf("%d", &k); ; for (int i = 0; i < k; i++) { int u; int v; scanf("%d", &u); ; scanf("%d", &v); ; a[u].push_back(v); a[v].push_back(u); } for (int i = 1; i <= n; i++) { if (com[i] == 0) { cc++; dfs(i); } } int m; scanf("%d", &m); ; for (int i = 0; i < m; i++) { int u; int v; scanf("%d", &u); ; scanf("%d", &v); ; if (com[u] == com[v]) mark[com[u]] = true; } int ans = 0; for (int i = 1; i <= cc; i++) { if (mark[i] == false) ans = max(ans, items[i]); } printf("%d", ans); ; puts(""); ; }
9
CPP
#include <bits/stdc++.h> using namespace std; vector<long long int> p; vector<long long int> sz; vector<vector<long long int>> g; long long int find_set(long long int x) { if (x == p[x]) return x; return p[x] = find_set(p[x]); } void union_set(long long int x, long long int y) { x = find_set(x); y = find_set(y); if (x != y) { p[y] = x; sz[x] += sz[y]; sz[y] = 0; } } int32_t main() { ios::sync_with_stdio(false); cin.tie(0); long long int n, k; cin >> n >> k; p = vector<long long int>(n + 1); sz = vector<long long int>(n + 1, 1); g = vector<vector<long long int>>(n + 1); for (long long int i = 1; i <= n; ++i) p[i] = i; for (long long int i = 0; i < k; ++i) { long long int u, v; cin >> u >> v; union_set(u, v); } long long int m; cin >> m; long long int ans = 0; vector<long long int> w(n + 1, 0); for (long long int i = 0; i < m; ++i) { long long int u, v; cin >> u >> v; long long int x = find_set(u); long long int y = find_set(v); if (x == y) w[x] = 1; } for (long long int i = 1; i <= n; ++i) { if (!w[i]) { ans = max(ans, sz[i]); } } cout << ans; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int MAXN = 1000 * 3 + 10, INF = 1e9 + 10; struct UnionFind { int parent[MAXN], sz[MAXN]; UnionFind(int n) { for (int i = 0; i < n; i++) { parent[i] = i; sz[i] = 1; } } int find(int v) { int root = v; while (parent[root] != root) root = parent[root]; while (v != root) { int old = v; v = parent[v]; parent[old] = root; } return root; } void merge(int u, int v) { u = find(u); v = find(v); if (u == v) return; if (sz[u] < sz[v]) swap(u, v); sz[u] += sz[v]; parent[v] = u; } }; int mark[MAXN]; vector<int> dis[MAXN]; int main() { ios::sync_with_stdio(false); int n, k, m; cin >> n >> k; UnionFind a(n); for (int i = 0; i < k; i++) { int x, y; cin >> x >> y; x--, y--; a.merge(x, y); } cin >> m; for (int i = 0; i < m; i++) { int x, y; cin >> x >> y; x--, y--; dis[x].push_back(y); dis[y].push_back(x); } int ans = 0; for (int i = 0; i < n; i++) if (!mark[i]) { vector<int> cur; int root = a.find(i); for (int j = 0; j < n; j++) if (a.find(j) == root) { cur.push_back(j); mark[j] = i + 1; } bool check = true; for (int j = 0; j < ((int)cur.size()); j++) { int v = cur[j]; for (int k = 0; k < ((int)dis[v].size()); k++) { if (mark[dis[v][k]] == i + 1) check = false; } } if (!check) continue; ans = max(ans, ((int)cur.size())); } cout << ans << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const long long LLINF = 1e17 + 7; const int INF = 1e9 + 7; const int MAX = 2000 + 7; const int MOD = 1e9 + 7; struct Node { vector<int> adj; bool vis = false; }; Node node[MAX]; bool enemy[MAX][MAX]; vector<int> path; int mx = 0; void clean() { for (int i = 0; i < MAX; i++) { node[i].vis = false; } } void addFriend(int v, int u) { node[v].adj.push_back(u); node[u].adj.push_back(v); } void addEnemy(int v, int u) { enemy[v][u] = true; enemy[u][v] = true; } void DFS(int v) { node[v].vis = true; path.push_back(v); for (auto i : node[v].adj) { if (!node[i].vis) DFS(i); } } bool hasEnemy() { for (auto i : path) { for (auto j : path) { if (enemy[i][j]) return true; } } return false; } int main() { int n; cin >> n; int f; cin >> f; while (f--) { int v, u; cin >> v >> u; v--, u--; addFriend(u, v); } int e; cin >> e; while (e--) { int v, u; cin >> v >> u; v--, u--; addEnemy(v, u); } for (int i = 0; i < n; i++) { if (node[i].vis) continue; path.clear(); DFS(i); if (hasEnemy()) continue; int sz = path.size(); mx = max(mx, sz); } cout << mx; return EXIT_SUCCESS; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int maxn = 2000; int head[maxn], tol, vis[maxn], ans, flag[maxn][maxn], que[maxn * maxn], st; struct node { int next, to, val; } edge[maxn * maxn]; void add(int u, int v, int w) { edge[tol].to = v; edge[tol].next = head[u]; edge[tol].val = w; head[u] = tol++; } void dfs(int u) { vis[u] = 1; que[++st] = u; for (int i = head[u]; i != -1; i = edge[i].next) { int v = edge[i].to; if (!vis[v] && edge[i].val) dfs(v); } } int fun(int u) { st = 0; dfs(u); for (int i = 1; i <= st; i++) for (int j = i + 1; j <= st; j++) if (flag[que[i]][que[j]] == -1) return 0; return st; } int main() { int i, j, k, m, n; while (~scanf("%d", &n)) { memset(head, -1, sizeof(head)); tol = 0; memset(vis, 0, sizeof(vis)); memset(flag, 0, sizeof(flag)); cin >> m; while (m--) { cin >> i >> j; add(i, j, 1); add(j, i, 1); flag[i][j] = 1; flag[j][i] = 1; } cin >> m; while (m--) { cin >> i >> j; add(i, j, 0); add(j, i, 0); flag[i][j] = flag[j][i] = -1; } int cnt = 0; for (i = 1; i <= n; i++) if (vis[i] == 0) { j = fun(i); cnt = max(cnt, j); } cout << cnt << endl; } return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const char IN[] = "_.in"; const char OUT[] = "_.out"; const int maxn = 2100; int ntest = 0, test; int n, k, m, u, v, res, dem; vector<int> a[maxn]; bool dis[maxn][maxn]; bool tham[maxn]; int b[maxn]; void nhap() { cin >> n; cin >> k; for (int i = (1); i <= (k); i++) { cin >> u >> v; a[u].push_back(v); a[v].push_back(u); } cin >> m; for (int i = (1); i <= (m); i++) { cin >> u >> v; dis[u][v] = true; } } void dfs(int u) { tham[u] = true; dem++; b[dem] = u; for (__typeof(a[u].begin()) i = a[u].begin(); i != a[u].end(); i++) { int v = *i; if (!tham[v]) dfs(v); } } void solve() { res = 0; memset((tham), (false), sizeof(tham)); for (int i = (1); i <= (n); i++) if (!tham[i]) { dem = 0; dfs(i); bool ok = true; for (int j = (1); j <= (dem); j++) for (int o = (1); o <= (dem); o++) if (dis[b[j]][b[o]]) { ok = false; break; } if (ok) res = max(res, dem); } cout << res; } int main() { nhap(); solve(); return 0; }
9
CPP
class DisjointSetStructure(): def __init__(self, n): self.A = [[i,0,1] for i in range(n)] self.size = n def getpair(self, i): p = i while self.A[p][0] != p: p = self.A[p][0] j = self.A[i][0] while j != p: self.A[i][0] = p i, j = j, self.A[j][0] return (p, self.A[p][2]) def __getitem__(self, i): return self.getpair(i)[0] def union(self, i, j): u, v = self[i], self[j] if u == v: return self.size -= 1 if self.A[u][1] > self.A[v][1]: self.A[v][0] = u self.A[u][2] += self.A[v][2] else: self.A[u][0] = v self.A[v][2] += self.A[u][2] if self.A[u][1] == self.A[v][1]: self.A[v][1] += 1 def __len__(self): return self.size n = int(input()) k = int(input()) D = DisjointSetStructure(n) for i in range(k): u, v = [int(x) - 1 for x in input().split()] D.union(u, v) l = int(input()) friendly = [True for i in range(n)] for i in range(l): u, v = [int(x) - 1 for x in input().split()] if D[u] == D[v]: friendly[D[u]] = False print(max(D.getpair(i)[1] if friendly[D[i]] else 0 for i in range(n)))
9
PYTHON3
#include <bits/stdc++.h> using namespace std; vector<pair<int, bool>> g[2005]; int a = 0, cnt = 0; bool vs[2004]; vector<set<int>> h; void dfs(int u, set<int> &s) { vs[u] = 1; s.insert(u); for (pair<int, bool> v : g[u]) { if (v.second == 1) { if (!vs[v.first]) { dfs(v.first, s); } } } } int main() { int n; cin >> n; int m; cin >> m; int u, v; for (int i = 0; i < m; i++) { cin >> u >> v; g[u].push_back({v, 1}); g[v].push_back({u, 1}); } cin >> m; for (int i = 0; i < m; i++) { cin >> u >> v; g[u].push_back({v, 0}); g[v].push_back({u, 0}); } for (int i = 1; i <= n; i++) { if (!vs[i]) { set<int> s; dfs(i, s); h.push_back(s); } } for (int i = 0; i < h.size(); i++) { set<int> r = h[i]; bool f = 1; for (int el : r) { for (pair<int, bool> u : g[el]) { if (u.second == 0) { if (r.find(u.first) != r.end()) f = 0; } } } int l = r.size(); if (f) a = max(a, l); } cout << a << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; vector<int> parent; int find(int u) { while (parent[u] != -1) u = parent[u]; return u; } void unionop(int u, int v) { int xp = find(u); int yp = find(v); if (xp != yp) parent[xp] = yp; } void solve() { int n, k, m, x, y; cin >> n; parent.resize(n + 1, -1); vector<pair<int, int> > p, d; cin >> k; for (int i = 0; i < k; i++) { cin >> x >> y; p.push_back({x, y}); } for (auto &it : p) { unionop(it.first, it.second); } cin >> m; vector<int> count(n + 1, 0); for (int i = 0; i < m; i++) { cin >> x >> y; int xp = find(x); int yp = find(y); if (xp == yp) { count[xp] = -1; } } for (int i = 1; i <= n; i++) { int par = find(i); if (count[par] != -1) { count[par]++; } } int mx = 0; for (int i = 1; i <= n; i++) mx = max(mx, count[i]); cout << mx; } int main(void) { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); int t = 1; while (t--) { solve(); } return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int Max = 2e3 + 9; vector<int> G[Max], V; bool B[Max][Max], mark[Max]; void dfs(int sv) { mark[sv] = 1; V.push_back(sv); for (int i = 0; i < G[sv].size(); i++) if (!mark[G[sv][i]]) dfs(G[sv][i]); } int main() { int n, m, mx = 0, u, v; scanf("%d%d", &n, &m); while (m--) scanf("%d%d", &u, &v), G[u].push_back(v), G[v].push_back(u); scanf("%d", &m); while (m--) scanf("%d%d", &u, &v), B[u][v] = 1, B[v][u] = 1; for (int i = 1; i <= n; i++) if (!mark[i]) { dfs(i); for (int i = 0; i < V.size(); i++) for (int j = i + 1; j < V.size(); j++) if (B[V[i]][V[j]]) V.clear(); int sz = V.size(); mx = max(mx, sz); V.clear(); } printf("%d", mx); }
9
CPP
#include <bits/stdc++.h> using namespace std; long long BigMod(long long B, long long P, long long M) { long long R = 1; while (P > 0) { if (P % 2 == 1) { R = (R * B) % M; } P /= 2; B = (B * B) % M; } return R; } int pr[2001]; int find(int r) { if (pr[r] == r) return r; else return pr[r] = find(pr[r]); } int n, k, m; int seg[2001]; int main() { ios_base::sync_with_stdio(0); cin.tie(nullptr); cin >> n; for (int i = 1; i <= n; i++) pr[i] = i, seg[i] = 1; cin >> k; for (int i = 1; i <= k; i++) { int a, b; cin >> a >> b; int u = find(a); int v = find(b); if (u != v) { pr[v] = u; seg[u] += seg[v]; } } int mx = 0; cin >> m; for (int i = 1; i <= m; i++) { int a, b; cin >> a >> b; int u = find(a); int v = find(b); if (u == v) { seg[u] = 0; } } for (int i = 1; i <= n; i++) { if (find(i) == i) mx = max(mx, seg[i]); } cout << mx; }
9
CPP
#include <bits/stdc++.h> using namespace std; vector<int> grav[2050]; int n; int m, k; int mark[2050]; bool bad[2050]; int sz[2050]; void dfs(int v, int color) { mark[v] = color; for (int i = 0; i < (int)grav[v].size(); i++) { int u = grav[v][i]; if (mark[u] == 0) dfs(u, color); } } int main() { int u, v; cin >> n; cin >> m; for (int i = 0; i < (int)(m); i++) { cin >> u >> v; --u; --v; grav[u].push_back(v); grav[v].push_back(u); } int color = 1; for (int i = 0; i < (int)(n); i++) { if (mark[i] == 0) dfs(i, color++); sz[mark[i]]++; } cin >> k; for (int i = 0; i < (int)(k); i++) { cin >> u >> v; --u; --v; if (mark[u] == mark[v]) bad[mark[u]] = true; } int mx = 0; for (int c = 1; c < color; ++c) { if (!bad[c] && (mx == 0 || sz[c] > sz[mx])) mx = c; } cout << sz[mx] << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; class Set { public: long long rank; long long parent; }; long long find(Set *set, long long i) { if (set[i].parent != i) set[i].parent = find(set, set[i].parent); return set[i].parent; } void Union(Set *set, long long v1, long long v2) { long long v1_root = find(set, v1); long long v2_root = find(set, v2); if (set[v1_root].rank < set[v2_root].rank) { set[v1_root].parent = v2_root; } else if (set[v2_root].rank > set[v2_root].rank) { set[v2_root].parent = v1_root; } else { set[v2_root].parent = v1_root; set[v1_root].rank++; } } int main() { long long n, k; cin >> n >> k; Set *set = new Set[n + 1]; for (long long i = 1; i < n + 1; i++) { set[i].parent = i; set[i].rank = 0; } while (k--) { long long a, b; cin >> a >> b; Union(set, a, b); } long long m; cin >> m; long long mark[2001] = {0}; while (m--) { long long a, b; cin >> a >> b; long long p = find(set, a), q = find(set, b); if (p == q) mark[p] = 1; } map<long long, long long> mp; for (long long i = 1; i < n + 1; i++) { long long q = find(set, i); if (mark[q] != 1) mp[q]++; } long long ans = 0; for (auto i : mp) { ans = max(ans, i.second); } cout << ans << "\n"; }
9
CPP
t, p, k = [0] * (int(input()) + 1), {0: []}, 1 for i in range(int(input())): a, b = map(int, input().split()) if t[a] == t[b]: if t[a] == 0: t[a] = t[b] = k p[k] = [a, b] k += 1 else: if t[a] == 0: t[a] = t[b] p[t[b]].append(a) elif t[b] == 0: t[b] = t[a] p[t[a]].append(b) else: x, y = t[b], t[a] for c in p[x]: t[c] = y p[y] += p[x] p[x] = [] for i in range(int(input())): a, b = map(int, input().split()) if t[a] == t[b]: p[t[a]] = [] ans = max(len(p[i]) for i in p) print(ans if ans > 0 else int(0 in t[1:]))
9
PYTHON3
#include <bits/stdc++.h> using namespace std; vector<long long> adj[1000005]; vector<long long> grp; vector<vector<long long> > cycle; long long visited[1000005]; void dfs(long long x) { visited[x] = 1; grp.push_back(x); for (int i = 0; i < adj[x].size(); i++) { int u = adj[x][i]; if (visited[u] == 0) { dfs(u); } } } int main() { int n, k, m; cin >> n >> k; int p, q, r = 0; for (int i = 0; i < k; i++) { cin >> p >> q; adj[p].push_back(q); adj[q].push_back(p); } for (int i = 1; i <= n; i++) { if (visited[i] == 0) { grp.clear(); dfs(i); cycle.push_back(grp); } } cin >> m; for (int i = 0; i < m; i++) { cin >> p >> q; for (int j = 0; j < cycle.size(); j++) { int a = 0, b = 0; for (int k = 0; k < cycle[j].size(); k++) { if (cycle[j][k] == p) a = 1; if (cycle[j][k] == q) b = 1; } if (a == 1 && b == 1) cycle[j][0] = n + 10; } } int max = 0; for (int i = 0; i < cycle.size(); i++) { if (cycle[i].size() > max && cycle[i][0] != n + 10) max = cycle[i].size(); } cout << max << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int N = (int)1e5 + 10; vector<int> P(N), R(N), S(N); int find(int x) { if (x == P[x]) return x; return P[x] = find(P[x]); } void join(int a, int b) { a = find(a); b = find(b); if (a != b) { if (R[a] > R[b]) { P[b] = a; S[a] += S[b]; } else if (R[a] < R[b]) { P[a] = b; S[b] += S[a]; } else { R[a]++; P[b] = a; S[a] += S[b]; } } } void solve() { int n, k, m; scanf("%d", &n), scanf("%d", &k); for (int i = 1; i <= n; i++) { P[i] = i; R[i] = 1; S[i] = 1; } for (int i = 0; i < k; i++) { int u, v; scanf("%d", &u), scanf("%d", &v); join(u, v); } scanf("%d", &m); unordered_set<int> bad; int mx = 0; for (int i = 0; i < m; i++) { int x, y; scanf("%d", &x), scanf("%d", &y); x = find(x), y = find(y); if (x == y) { bad.insert(x); } } for (int i = 1; i <= n; i++) { int x = find(i); if (bad.count(x)) continue; mx = max(mx, S[find(x)]); } printf("%d\n", mx); } int main() { int t = 1; while (t--) { solve(); } }
9
CPP
#include <bits/stdc++.h> int n, k, m, a, b, sol; int p[2001]; int depth[2001]; int del[2001]; int done[2001]; int size[2001]; int max(int i, int j) { return (i > j) ? i : j; } int dsu_find(int i) { while (i != p[i]) { p[i] = p[p[i]]; i = p[i]; } return i; } void dsu_union(int i, int j) { i = dsu_find(i); j = dsu_find(j); if (depth[i] > depth[j]) p[j] = i; else { p[i] = j; if (depth[i] == depth[j]) depth[j]++; } } int main(void) { scanf("%d", &n); for (int i = 1; i <= n; ++i) { p[i] = i; depth[i] = 1; } scanf("%d", &k); for (int i = 0; i < k; ++i) { scanf("%d %d", &a, &b); dsu_union(a, b); } scanf("%d", &m); for (int i = 0; i < m; ++i) { scanf("%d %d", &a, &b); a = dsu_find(a); b = dsu_find(b); if (a == b) del[a]++; } for (int i = 1; i <= n; ++i) { a = dsu_find(i); if (!del[a]) size[a]++; } for (int i = 1; i <= n; ++i) sol = max(sol, size[i]); printf("%d", sol); return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; unordered_map<long long, set<long long> > friends, hate; vector<bool> visited; long long n, m; set<long long> addedInThisSet; bool possible; long long length; void dfs(int i) { if (visited[i]) return; visited[i] = true; length++; for (auto j : addedInThisSet) { if (hate[i].count(j)) possible = false; } addedInThisSet.insert(i); for (auto j : friends[i]) { dfs(j); } } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n >> m; for (int i = 0; i < m; i++) { int a, b; cin >> a >> b; friends[a].insert(b); friends[b].insert(a); } long long k; cin >> k; for (int i = 0; i < k; i++) { int a, b; cin >> a >> b; hate[a].insert(b); hate[b].insert(a); } visited.resize(n + 1); long long ans = 0; for (int i = 1; i <= n; i++) { if (visited[i]) continue; possible = true; length = 0; dfs(i); if (possible) { ans = max(ans, length); } addedInThisSet.clear(); } cout << ans; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; void addedge(vector<long long int> adj[], int u, int v) { adj[u].push_back(v); adj[v].push_back(u); } vector<long long int> v; void dfs(vector<long long int> adj[], long long int u, vector<long long int> &vis) { vis[u] = true; v.push_back(u); for (long long int i = 0; i < adj[u].size(); i++) { if (!vis[adj[u][i]]) dfs(adj, adj[u][i], vis); } } void solve() { long long int i, j, k, n, m, m2; cin >> n >> m; vector<long long int> adj[n]; for (i = 0; i < m; i++) { cin >> j >> k; addedge(adj, j - 1, k - 1); } cin >> m2; vector<vector<long long int> > mp(2001, vector<long long int>(2001, 0)); for (i = 0; i < m2; i++) { cin >> j >> k; mp[j - 1][k - 1] = 1; } vector<long long int> vis(n, 0); long long int ans = 0; for (i = 0; i < n; i++) { if (!vis[i]) { v.clear(); dfs(adj, i, vis); long long int u = 1; for (j = 0; j < v.size(); j++) { for (k = j + 1; k < v.size(); k++) { if (mp[v[j]][v[k]]) u = 0; } } if (u) ans = max(ans, (long long int)v.size()); } } cout << ans << '\n'; } int main() { ios::sync_with_stdio(0); cin.tie(0); long long int t = 1; while (t--) { solve(); } return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int maxn = 5e5 + 5; const int inf = 0x3f3f3f3f; int n, m; vector<int> G[maxn]; int color[maxn]; int sz[maxn]; int vis[maxn]; void dfs(int u, int col) { color[u] = col; for (auto it : G[u]) { if (!color[it]) { color[it] = col; dfs(it, col); } } } int main() { cin >> n; int x; cin >> x; for (int i = 1; i <= x; i++) { int u, v; cin >> u >> v; G[u].push_back(v); G[v].push_back(u); } int tmp = 0; for (int i = 1; i <= n; i++) { if (!color[i]) { dfs(i, ++tmp); } } for (int i = 1; i <= n; i++) sz[color[i]]++; int y; cin >> y; for (int i = 1; i <= y; i++) { int u, v; cin >> u >> v; if (color[u] == color[v]) { vis[color[u]] = 1; } } int ans = 0; for (int i = 1; i <= n; i++) { if (!vis[i]) { ans = max(ans, sz[i]); } } cout << ans; return 0; }
9
CPP
from collections import defaultdict def Root(child): while(Parent[child]!=child): child = Parent[child] return child def Union(a,b): root_a = Root(a) root_b = Root(b) if(root_a!=root_b): if(Size[root_a]<Size[root_b]): Parent[root_a] = root_b Size[root_b]+=Size[root_a] else: Parent[root_b] = root_a Size[root_a]+=Size[root_b] return 1 return 0 n = int(input()) Parent = [i for i in range(n)] Size = [1 for i in range(n)] k = int(input()) for i in range(k): u,v = map(int,input().split()) u-=1;v-=1 Union(u,v) m = int(input()) for i in range(m): u,v = map(int,input().split()) root_u = Root(u-1) root_v = Root(v-1) if(root_u==root_v): Size[root_u] = 0 Max = -float('inf') for i in range(n): Max = max(Max,Size[Root(i)]) print(Max)
9
PYTHON3
#include <bits/stdc++.h> using namespace std; struct dsu { vector<int> p, siz; int get(int x) { if (p[x] == x) return x; return p[x] = get(p[x]); } bool same(int x, int y) { x = get(x), y = get(y); return x == y; } void unite(int x, int y) { x = get(x), y = get(y); if (x == y) return; if (siz[x] < siz[y]) swap(x, y); p[y] = x; siz[x] += siz[y]; } dsu(int n) { siz.resize(n, 1); p.resize(n); for (int i = 0; i < n; i++) p[i] = i; } }; int main() { ios::sync_with_stdio(0); cin.tie(0); int n, k; cin >> n >> k; dsu d(n); for (int i = 0; i < k; i++) { int x, y; cin >> x >> y; --x; --y; d.unite(x, y); } int m; cin >> m; vector<bool> bad(n); for (int i = 0; i < m; i++) { int x, y; cin >> x >> y; --x; --y; if (d.same(x, y)) { bad[d.get(x)] = true; } } int ans = 0; for (int i = 0; i < n; i++) { if (!bad[d.get(i)]) { ans = max(ans, d.siz[d.get(i)]); } } cout << ans; }
9
CPP
#include <bits/stdc++.h> using namespace std; int dfs(vector<vector<pair<int, bool> > >& Graph, vector<int>& visited, vector<bool>& is_enemy, int root, int idx, bool& is_valid) { if (is_enemy[root]) is_valid = false; visited[root] = idx; int count = 1; for (auto a : Graph[root]) if (!a.second && visited[a.first] != idx) is_enemy[a.first] = true; else if (!a.second && visited[a.first] == idx) is_valid = false; else if (a.second && visited[a.first] == -1) { count += dfs(Graph, visited, is_enemy, a.first, idx, is_valid); } return count; } int main(void) { int n, m, k; cin >> n >> k; vector<vector<pair<int, bool> > > Graph(n); for (int i = 0; i < k; ++i) { int u, v; cin >> u >> v; --u, --v; Graph[u].push_back(make_pair(v, 1)); Graph[v].push_back(make_pair(u, 1)); } cin >> m; for (int i = 0; i < m; ++i) { int u, v; cin >> u >> v; --u, --v; Graph[u].push_back(make_pair(v, 0)); Graph[v].push_back(make_pair(u, 0)); } int result = 0; vector<int> visited(n, -1); for (int i = 0; i < n; ++i) if (visited[i] == -1) { vector<bool> is_enemy(n, false); bool is_valid = true; int tmp = dfs(Graph, visited, is_enemy, i, i, is_valid); if (is_valid) result = max(result, tmp); } cout << result << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; vector<long long> g[2002]; vector<bool> fr(2002); long long dis = 0; void dfs(long long x) { fr[x] = true; for (auto i : g[x]) { if (!fr[i]) ++dis, dfs(i); } } int32_t main() { long long n, k, m; cin >> n >> k; unordered_map<long long, long long> mp; for (long long i = 1; i <= n; ++i) fr[i] = false; while (k--) { long long a, b; cin >> a >> b; g[a].push_back(b), g[b].push_back(a); } cin >> m; while (m--) { long long a, b; cin >> a >> b; mp[a] = b, mp[b] = a; } bool flag = false, check = false; long long c = 0, ans = 0; for (long long i = 1; i <= n; ++i) { dis = 0, c = 0; if (!fr[i]) { dfs(i); if (dis == 0) ans = max(ans, dis), check = true; if (ans < dis) { for (long long i = 1; i <= n; ++i) { if (fr[i] && mp[i] > 0 && fr[mp[i]]) { flag = true; break; } } if (!flag) ans = max(ans, dis), check = true; } } for (long long i = 1; i <= n; ++i) fr[i] = false; } if (check) ++ans; cout << ans << endl; }
9
CPP
from sys import setrecursionlimit setrecursionlimit(10 ** 9) def dfs(g, col, st): global used used[st] = col for w in g[st]: if used[w] is False: dfs(g, col, w) n = int(input()) k = int(input()) g = [] used = [False] * n for i in range(n): g.append([]) for i in range(k): x, y = map(int, input().split()) g[x - 1].append(y - 1) g[y - 1].append(x - 1) cur = 0 for i in range(n): if used[i] is False: dfs(g, cur, i) cur += 1 k = int(input()) lst = [0] * n for i in range(k): x, y = map(int, input().split()) x -= 1 y -= 1 if used[x] == used[y]: lst[used[x]] = -1 for i in range(n): if lst[used[i]] != -1: lst[used[i]] += 1 print(max(0, max(lst)))
9
PYTHON3
#include <bits/stdc++.h> using namespace std; int main() { int n, k; cin >> n >> k; list<int> friends[n + 1]; int temp1, temp2; for (int i = 0; i < k; i++) { cin >> temp1 >> temp2; friends[temp1].push_back(temp2); friends[temp2].push_back(temp1); } int m; cin >> m; vector<pair<int, int>> dislikes; for (int i = 0; i < m; i++) { cin >> temp1 >> temp2; dislikes.push_back(pair<int, int>(temp1, temp2)); } vector<int> seg_vect(n + 1, 0); vector<bool> visited(n + 1, false); vector<unordered_set<int>> segment_list; unordered_set<int> segment; stack<int> pending; int work, count; count = 0; for (int i = 1; i <= n; i++) { if (visited[i]) continue; visited[i] = true; pending.push(i); while (!pending.empty()) { work = pending.top(); pending.pop(); seg_vect[work] = count; segment.insert(work); for (auto neighbour : friends[work]) { if (visited[neighbour]) continue; visited[neighbour] = true; pending.push(neighbour); } } segment_list.push_back(segment); segment = {}; count++; } unordered_set<int> not_allowed; for (auto val : dislikes) { if (seg_vect[val.first] == seg_vect[val.second]) { not_allowed.insert(seg_vect[val.first]); } } int greatest = 0; for (int i = 0; i < (int)segment_list.size(); i++) { if (not_allowed.count(i)) continue; greatest = max(greatest, (int)segment_list[i].size()); } cout << greatest; }
9
CPP
#include <bits/stdc++.h> using namespace std; vector<int> adj[1000], Color(1000); int mp[50][50]; int grid[1000][1000]; void BFS(int source); int mx; int main() { int i, u, v, nodes, edges, source, j; scanf("%d %d", &nodes, &edges); for (i = 0; i < nodes; i++) { adj[i].clear(); } for (i = 0; i < nodes; i++) for (j = 0; j < nodes; j++) grid[i][j] = 0; for (i = 0; i < edges; i++) { scanf("%d %d", &u, &v); adj[u].push_back(v); adj[v].push_back(u); } int dis; scanf("%d", &dis); for (i = 1; i <= dis; i++) { scanf("%d %d", &u, &v); grid[u][v] = 1; grid[v][u] = 1; } for (i = 0; i <= nodes; i++) { Color[i] = 0; } mx = 0; for (i = 1; i <= nodes; i++) if (Color[i] == 0) BFS(i); cout << mx << endl; return 0; } void BFS(int source) { queue<int> Q; int i, u, v, cnt = 0, trk = 0, k = 0; Color[source] = 1; Q.push(source); cnt++; int V[105]; V[0] = source; k = 1; while (!Q.empty()) { u = Q.front(); Q.pop(); for (i = 0; i < adj[u].size(); i++) { v = adj[u][i]; if (Color[v] == 0) { V[k++] = v; cnt++; Color[v] = 1; Q.push(v); } } } for (i = 0; i < k; i++) for (int j = i + 1; j < k; j++) if (grid[V[i]][V[j]] == 1 && grid[V[j]][V[i]] == 1) { trk = 1; goto ab; } ab:; if (trk == 0) mx = max(mx, cnt); while (!Q.empty()) Q.pop(); }
9
CPP
#include <bits/stdc++.h> using namespace std; template <typename Head> void print(Head&& head) { cout << head << '\n'; } template <typename Head, typename... Tail> void print(Head&& head, Tail... tail) { cout << head << " "; print(tail...); } void chandan1() { int y = 1; return; } void chandan2() { for (int i = 0; i < 10; i++) { int x = 1; } return (chandan1()); } struct DSU { static const int MAXN = 100005; int parent[MAXN]; int size[MAXN]; bool enemie[200005]; void init() { for (int i = 0; i < MAXN; i++) { parent[i] = i; size[i] = 1; enemie[i] = 0; } } int root(int i) { while (parent[i] != i) { parent[i] = parent[parent[i]]; i = parent[i]; } return i; } void Union(int a, int b) { int root_a = root(a); int root_b = root(b); if (root_a == root_b) return; if (size[root_a] < size[root_b]) { parent[root_a] = parent[root_b]; size[root_b] += size[root_a]; } else { parent[root_b] = parent[root_a]; size[root_a] += size[root_b]; } } bool find(int a, int b) { return (a == b or root(a) == root(b)); } }; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int t = 1; chandan2(); while (t--) { int n, m, q, k; cin >> n >> k; DSU uf; uf.init(); for (int i = 0; i < k; i++) { int x, y; cin >> x >> y; uf.Union(x, y); } cin >> m; for (int i = 0; i < m; i++) { int x, y; cin >> x >> y; if (uf.find(x, y)) uf.enemie[uf.root(x)] = 1; } int maxi = -1; for (int i = 1; i <= n; i++) if (uf.enemie[uf.root(i)] == 0) maxi = max(maxi, uf.size[uf.root(i)]); if (maxi == -1) print(0); else print(maxi); } return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; int a, b, c, d, e, f, m, x, y; vector<int> v[2100], v2[2100]; int tanda[2100]; bool bole; void cari(int x) { int i; if (tanda[x] == 3) bole = 1; tanda[x] = 2; for (i = 0; i < v2[x].size(); i++) if (tanda[v2[x][i]] == 2) bole = 1; else tanda[v2[x][i]] = 3; for (i = 0; i < v[x].size(); i++) if (tanda[v[x][i]] != 2) cari(v[x][i]); } int main() { scanf("%d", &a); scanf("%d", &b); m = 0; memset(tanda, 0, sizeof(tanda)); for (c = 1; c <= b; c++) { scanf("%d %d", &x, &y); v[x].push_back(y); v[y].push_back(x); } scanf("%d", &d); for (c = 1; c <= d; c++) { scanf("%d %d", &x, &y); v2[x].push_back(y); v2[y].push_back(x); } for (c = 1; c <= a; c++) { bole = 0; if (tanda[c] == 0) cari(c); if (bole == 0) { f = 0; for (e = 1; e <= a; e++) if (tanda[e] == 2) { f++; tanda[e] = 1; } else if (tanda[e] == 3) tanda[e] = 0; m = max(m, f); } else { for (e = 1; e <= a; e++) if (tanda[e] == 2) { tanda[e] = 1; } else if (tanda[e] == 3) tanda[e] = 0; } } printf("%d\n", m); }
9
CPP
#include <bits/stdc++.h> using namespace std; const int N = 2e3 + 4; vector<vector<int> > G(N); vector<int> par(N); vector<bool> vis(N); map<int, int> MP; int cnt; void dfs(int root, int u) { vis[root] = true; cnt++; par[root] = u; for (int i = 0; i < G[root].size(); i++) { int v = G[root][i]; if (!vis[v]) dfs(v, u); } } int main() { int n, k; cin >> n >> k; for (int i = 1; i <= n; i++) par[i] = i; for (int i = 1; i <= k; i++) { int a, b; cin >> a >> b; G[a].push_back(b), G[b].push_back(a); } for (int i = 1; i <= n; i++) { if (!vis[i]) { cnt = 0; dfs(i, i); MP[i] = cnt; } } int m; cin >> m; for (int i = 1; i <= m; i++) { int u, v; cin >> u >> v; if (par[u] == par[v]) MP[par[u]] = 0; } int mx = 0; map<int, int>::iterator it; for (it = MP.begin(); it != MP.end(); it++) mx = max(mx, it->second); cout << mx << '\n'; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; long long ans, b[2001], s; vector<int> f[2001], e[2001]; void dfs(int x) { b[x] = 1; s++; for (long long i = 0; i < f[x].size(); i++) if (!b[f[x][i]]) dfs(f[x][i]); for (int j = 0; j < e[x].size() && s >= 0; j++) if (b[e[x][j]]) s = -1e9; } int main() { long long n, m, x, y, k; cin >> n >> k; for (long long i = 0; i < k; i++) { cin >> x >> y; f[x].push_back(y); f[y].push_back(x); } cin >> m; for (long long i = 0; i < m; i++) { cin >> x >> y; e[x].push_back(y); e[y].push_back(x); } for (long long i = 1; i <= n; i++) { s = 0; dfs(i); ans = max(s, ans); memset(b, 0, sizeof(b)); } cout << ans; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; void dfs(int x, vector<vector<int> > adj, vector<vector<int> >& group, int c, vector<int>& id, vector<bool>& vis) { vis[x] = 1; group[c].push_back(x); id[x] = c; for (int i = 0; i < adj[x].size(); i++) { if (vis[adj[x][i]] == 0) { dfs(adj[x][i], adj, group, c, id, vis); } } } int main() { int n; cin >> n; int k; cin >> k; int i, j; vector<vector<int> > adj(n + 1); vector<bool> vis(n + 1, 0); while (k--) { int u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } vector<vector<int> > group(n + 1); vector<int> id(n + 1); int c = 0; for (i = 1; i <= n; i = i + 1) { if (vis[i] == 0) { dfs(i, adj, group, c, id, vis); c++; } } int m; cin >> m; vector<bool> black(n, 0); while (m--) { int u, v; cin >> u >> v; if (id[u] == id[v]) { black[id[u]] = 1; } } int res = 0; for (i = 0; i < c; i++) { if (black[i] == 0) { int x = group[i].size(); res = max(res, x); } } cout << res << endl; }
9
CPP
#include <bits/stdc++.h> using namespace std; using namespace std::chrono; long long mod = 1000000007; struct modified_hash { static uint64_t splitmix64(uint64_t x) { x += 0x9e3779b97f4a7c15; x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; x = (x ^ (x >> 27)) * 0x94d049bb133111eb; return x ^ (x >> 31); } long long operator()(uint64_t x) const { static const uint64_t random = steady_clock::now().time_since_epoch().count(); return splitmix64(x + random); } }; long long N; vector<long long> grph[2001]; vector<long long> dis[2001]; set<long long> st; bool vis[2001]; long long ans = 0; bool flag = true; vector<long long> vp; void dfs(long long i, long long p1) { vis[i] = true; st.insert(i); for (auto x : grph[i]) { if (!vis[x]) { dfs(x, i); } } } void solve() { long long a, b, k, c, n, d, m, x, y, l, r; cin >> n >> m; memset(vis, false, sizeof(vis)); for (long long i = 0; i < m; i++) { cin >> a >> b; grph[a].push_back(b); grph[b].push_back(a); } cin >> k; for (long long i = 0; i < k; i++) { cin >> a >> b; dis[a].push_back(b); dis[b].push_back(a); } long long ans1 = 0; for (long long i = 1; i <= n; i++) { if (!vis[i]) { flag = true; ans = 0; st.clear(); dfs(i, -1LL); for (auto p : st) { for (auto p1 : dis[p]) { if (st.find(p1) != st.end()) { flag = false; } } } if (flag) { long long fm = st.size(); ans1 = max(ans1, fm); } } } cout << ans1 << "\n"; return; } int main() { ios::sync_with_stdio(false); cin.tie(0); long long a, b, c, n, tt, d, m, k, x, y; tt = 1; while (tt--) { solve(); } }
9
CPP
#include <bits/stdc++.h> using namespace std; struct djset { int set_size; djset *rep; }; inline djset *create_set(int n) { djset *node = (djset *)malloc(sizeof(djset)); node->set_size = 1; node->rep = node; return node; } djset *find_set(djset *a) { if (a->rep != a) { a->rep = find_set(a->rep); } return a->rep; } inline void merge_sets(djset *a, djset *b) { a = find_set(a); b = find_set(b); if (a == b) { return; } if (a->set_size > b->set_size) { b->rep = a; a->set_size += b->set_size; b->set_size = 0; } else if (a->set_size < b->set_size) { a->rep = b; b->set_size += a->set_size; a->set_size = 0; } else { b->rep = a; a->set_size += b->set_size; b->set_size = 0; } } int main() { int n, k, m, a, b; int i, j; scanf("%d", &n); djset **dja = (djset **)malloc((n + 1) * sizeof(djset *)); for (i = 1; i <= n; i++) { dja[i] = create_set(i); } scanf("%d", &k); for (i = 1; i <= k; i++) { scanf("%d%d", &a, &b); if (find_set(dja[a]) != find_set(dja[b])) { merge_sets(dja[a], dja[b]); } } scanf("%d", &m); for (i = 1; i <= m; i++) { scanf("%d%d", &a, &b); if (find_set(dja[a]) == find_set(dja[b])) { find_set(dja[a])->set_size = 0; find_set(dja[b])->set_size = 0; } } int max = 0; for (i = 1; i <= n; i++) { max = ((max) >= (dja[i]->set_size) ? (max) : (dja[i]->set_size)); } printf("%d\n", max); return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const double eps = 1E-9; vector<int> used; int ccolor = 1; long long dfs(int u, vector<vector<int>>& g) { long long ans = 0; used[u] = ccolor; for (int i = 1; i < g[u].size(); ++i) { if (g[u][i] == -1 && used[i] == ccolor) return 0; else if (used[i] != ccolor && g[u][i] == 1) { long long k = dfs(i, g); if (k == 0) return 0; ans += k; } } return ans + 1; } int main(int argc, char** argv) { ios::sync_with_stdio(false); int n, k; cin >> n >> k; used.resize(n + 1); vector<vector<int>> v(n + 1, vector<int>(n + 1)); for (int i = 0; i < k; ++i) { int u, w; cin >> u >> w; v[u][w] = 1; v[w][u] = 1; } cin >> k; for (int i = 0; i < k; ++i) { int u, w; cin >> u >> w; v[u][w] = -1; v[w][u] = -1; } long long ans = 0; for (int i = 1; i <= n; ++i) { ans = std::max(ans, dfs(i, v)); ++ccolor; } cout << ans << endl; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; int p[1000], sum[1000], good[1000], n, k, m, x, y; int find(int x) { if (p[x] == x) return x; else return p[x] = find(p[x]); } int main() { cin >> n >> k; for (int i = 1; i <= n; i++) p[i] = i; for (int i = 1; i <= k; i++) { cin >> x >> y; p[find(y)] = find(x); } cin >> m; for (int i = 1; i <= m; i++) { cin >> x >> y; if (find(x) == find(y)) good[find(x)] = -1; } m = 0; for (int i = 1; i <= n; i++) sum[find(i)]++; for (int i = 1; i <= n; i++) { x = find(i); if (good[find(i)] == 0) m = max(m, sum[x]); } cout << m; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int maxN = 1e3 + 10; int par[maxN]; int h[maxN]; int find_root(int x) { if (x == par[x]) return x; else par[x] = find_root(par[x]); return par[x]; } void merge(int x, int y) { x = find_root(x); y = find_root(y); if (h[x] == h[y]) { par[y] = x; h[x]++; } if (h[x] > h[y]) par[y] = x; if (h[x] < h[y]) par[x] = y; } bool hate[maxN][maxN]; vector<int> g[maxN]; int main() { ios_base::sync_with_stdio(false); for (int i = 0; i < maxN; i++) par[i] = i; int n, k, m; cin >> n >> k; for (int i = 0; i < k; i++) { int v, u; cin >> v >> u; v--, u--; if (find_root(v) != find_root(u)) merge(v, u); } cin >> m; for (int i = 0; i < m; i++) { int v, u; cin >> v >> u; v--, u--; hate[v][u] = hate[u][v] = true; } for (int i = 0; i < n; i++) g[find_root(i)].push_back(i); int mx = 0; for (int i = 0; i < n; i++) { vector<int> cur = g[i]; bool ok = 1; for (int x = 0; x < cur.size(); x++) { for (int y = 0; y < cur.size(); y++) ok &= !(hate[cur[x]][cur[y]]); } if (ok) mx = max(mx, (int)cur.size()); } cout << mx << '\n'; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; int n, m; bool debug = false; int k; int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0}; vector<int> mp[2005]; int c[2005], col, cnt, cc[2005]; vector<pair<int, int>> v; void dfs(int x) { c[x] = col; cnt++; for (int child : mp[x]) if (!c[child]) dfs(child); } int main() { scanf("%d%d", &n, &k); for (int i = 0, u, v; i < k; i++) { scanf("%d%d", &u, &v); mp[u].push_back(v); mp[v].push_back(u); } for (int i = 1; i <= n; i++) if (!c[i]) { col++; cnt = 0; dfs(i); v.push_back({-cnt, col}); } scanf("%d", &m); for (int i = 0, u, v; i < m; i++) { scanf("%d%d", &u, &v); if (c[u] == c[v]) cc[c[u]] = 1; } sort(v.begin(), v.end()); for (auto p : v) if (!cc[p.second]) { printf("%d\n", -p.first); return 0; } puts("0"); return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; int parent[2000]; int Find(int x) { if (parent[x] != x) parent[x] = Find(parent[x]); return parent[x]; } void Union(int x, int y) { x = Find(x); y = Find(y); parent[x] = y; } int main() { int n, m; scanf("%d %d", &n, &m); for (int i = 0; i < n; ++i) parent[i] = i; for (int i = 0, u, v; i < m; ++i) { scanf("%d %d", &u, &v); Union(u - 1, v - 1); } int sz[n]; memset(sz, 0, sizeof sz); for (int i = 0; i < n; ++i) ++sz[Find(i)]; scanf("%d", &m); bool valid[n]; memset(valid, true, sizeof valid); for (int i = 0, u, v; i < m; ++i) { scanf("%d %d", &u, &v); --u; --v; u = Find(u); v = Find(v); if (u == v) valid[u] = false; } int ans = 0; for (int i = 0; i < n; ++i) if (valid[i]) ans = max(ans, sz[i]); printf("%d\n", ans); return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int maxn = 2002; int n, m, fa[maxn], num[maxn]; bool ok[maxn]; void make_set() { for (int i = 1; i <= n; ++i) fa[i] = i, num[i] = 1, ok[i] = true; } int find(int x) { if (fa[x] == x) return x; fa[x] = find(fa[x]); return fa[x]; } void Union(int x, int y) { int xx = find(x), yy = find(y); if (xx == yy) return; if (num[xx] > num[yy]) { fa[yy] = xx; num[xx] += num[yy]; } else { fa[xx] = yy; num[yy] += num[xx]; } } int main(void) { while (~scanf("%d", &n)) { make_set(); scanf("%d", &m); int a, b; for (int i = 0; i < m; ++i) { scanf("%d%d", &a, &b); Union(a, b); } scanf("%d", &m); for (int i = 0; i < m; ++i) { scanf("%d%d", &a, &b); int xx = find(a), yy = find(b); if (xx == yy) ok[xx] = 0; } int maxx = 0; for (int i = 1; i <= n; ++i) { int tmp = find(i); if (ok[tmp]) maxx = max(maxx, num[tmp]); } cout << maxx << endl; } }
9
CPP
#include <bits/stdc++.h> using namespace std; const int N = 2010; const int M = 100010; bool f[N][N], z[N][N], used[N], can[N]; int cnt, n; bool good = true; void dfs(int v) { used[v] = true; cnt++; for (int i = 0; i < n; i++) if (z[v][i]) can[i] = true; bool all = true; for (int j = 0; j < n; j++) if (f[v][j]) { if (used[j]) continue; if (can[j]) all = false; else dfs(j); } if (!all) good = false; } int main() { int m, k; cin >> n >> k; int a, b; for (int i = 0; i < k; i++) { cin >> a >> b; a--, b--; f[a][b] = f[b][a] = true; } cin >> m; for (int i = 0; i < m; i++) { cin >> a >> b; a--, b--; z[a][b] = z[b][a] = true; } int ans = 0; for (int i = 0; i < n; i++) { memset(used, false, n); memset(can, false, n); cnt = 0; good = true; dfs(i); if (!good) cnt = 0; ans = max(ans, cnt); } cout << ans; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; vector<int> likes[2001]; vector<int> dislikes[2001]; int visited[2001] = {0}; vector<int> temp; void DFS(int s) { int i; visited[s] = 1; temp.push_back(s); for (i = 0; i < likes[s].size(); i++) { if (visited[likes[s][i]] == 0) DFS(likes[s][i]); } } int check() { int i, j, flag = 0; vector<int> c; for (i = 0; i < temp.size(); i++) { c = dislikes[temp[i]]; for (j = 0; j < c.size(); j++) { if (find(temp.begin(), temp.end(), c[j]) != temp.end()) { flag = 1; break; } } if (flag) break; } if (flag) return 0; else return 1; } int main() { ios::sync_with_stdio(false), cin.tie(0); ; int n, k, m, i, u, v, ans = 0; cin >> n; cin >> k; for (i = 0; i < k; i++) { cin >> u >> v; likes[u].push_back(v); likes[v].push_back(u); } cin >> m; for (i = 0; i < m; i++) { cin >> u >> v; dislikes[u].push_back(v); dislikes[v].push_back(u); } for (i = 1; i <= n; i++) { if (visited[i] == 0) { DFS(i); if (check()) { k = temp.size(); ans = max(ans, k); } temp.clear(); } } cout << ans; }
9
CPP
#include <bits/stdc++.h> using namespace std; const long long int maxn = 2e3 + 5; vector<long long int> parent(maxn), sz(maxn); void make_set(long long int v) { parent[v] = v; sz[v] = 1; } long long int find_set(long long int v) { if (v == parent[v]) return v; return parent[v] = find_set(parent[v]); } void union_set(long long int u, long long int v) { u = find_set(u); v = find_set(v); if (u != v) { if (sz[u] < sz[v]) swap(u, v); parent[v] = u; sz[u] += sz[v]; } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long int n, k, m, i; cin >> n; for (i = 0; i < n; i++) make_set(i + 1); cin >> k; for (i = 0; i < k; i++) { long long int u, v; cin >> u >> v; union_set(u, v); } cin >> m; vector<bool> vis(n + 1, true); for (i = 0; i < m; i++) { long long int u, v; cin >> u >> v; u = find_set(u); v = find_set(v); if (u == v) vis[u] = false; } long long int mx = 0; for (i = 1; i <= n; i++) { if (i == parent[i] && vis[i] == true) mx = max(mx, sz[i]); } cout << mx << "\n"; }
9
CPP
#include <bits/stdc++.h> using namespace std; void DFS(int i, vector<bool> &visited, set<int> &group, vector<vector<int> > &L) { group.insert(i); visited[i] = true; for (vector<int>::iterator it = L[i].begin(); it != L[i].end(); ++it) { if (!visited[*it]) { DFS(*it, visited, group, L); } } } bool anyDislikes(set<int> &group, vector<vector<int> > &F) { vector<int> G(group.begin(), group.end()); int size = G.size(); if (size == 0) return true; for (int i = 0; i < size - 1; ++i) for (int j = i + 1; j < size; ++j) if (F[G[i]][G[j]] == 2) return true; return false; } int main() { int n; cin >> n; vector<vector<int> > F(n + 1, vector<int>(n + 1, 0)); vector<vector<int> > L(n + 1, vector<int>()); vector<vector<int> > D(n + 1, vector<int>()); int l; cin >> l; for (int i = (0); i < (l); ++i) { int a, b; cin >> a >> b; F[a][b] = 1; F[b][a] = 1; L[a].push_back(b); L[b].push_back(a); } int d; cin >> d; for (int i = (0); i < (d); ++i) { int a, b; cin >> a >> b; F[a][b] = 2; F[b][a] = 2; D[a].push_back(b); D[b].push_back(a); } vector<bool> visited(n + 1, false); int maxx = 0; for (int i = 1; i <= n; ++i) { if (!visited[i]) { set<int> group; DFS(i, visited, group, L); int size = group.size(); if (!anyDislikes(group, F)) { maxx = max(maxx, size); } } } cout << maxx << endl; }
9
CPP
#include <bits/stdc++.h> using namespace std; int n, k, m, u, v; int p[2048]; void init() { for (int i = 0; i < 2048; i++) { p[i] = i; } } int find(int x) { return p[x] == x ? x : find(p[x]); } void merge(int u, int v) { if (find(u) == find(v)) { return; } p[find(u)] = find(v); } int main() { cin >> n; cin >> k; init(); for (int i = 0; i < k; i++) { cin >> u >> v; u--; v--; merge(u, v); } cin >> m; unordered_set<int> blacklist; unordered_map<long long, long long> ct; for (int i = 0; i < m; i++) { cin >> u >> v; u--; v--; if (find(u) == find(v)) { blacklist.insert(find(u)); } } for (int i = 0; i < n; i++) { ct[find(i)]++; } long long ans = 0; for (auto p : ct) { if (blacklist.find(p.first) == blacklist.end()) { ans = max(ans, p.second); } } cout << ans; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; const int mod = 1000000007; const int N = 2003; vector<int> g[N]; bool vis[N]; vector<int> q; void dfs(int u) { vis[u] = true; q.push_back(u); for (auto i : g[u]) { if (!vis[i]) dfs(i); } } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n, m, a, b; cin >> n; cin >> m; bool arr[n + 1][n + 1]; memset(arr, false, sizeof(arr)); for (int j = 0; j < m; ++j) { cin >> a >> b; g[a].push_back(b); g[b].push_back(a); } cin >> m; for (int j = 0; j < m; ++j) { cin >> a >> b; arr[a][b] = arr[b][a] = true; } int ans = 0; int flag; for (int i = 1; i <= n; ++i) { if (!vis[i]) { q.clear(); flag = 1; dfs(i); for (int j = 0; j < q.size() && flag; ++j) { for (int k = j + 1; k < q.size() && flag; ++k) { if (arr[q[j]][q[k]]) flag = 0; } } int ss = q.size(); if (flag) ans = max(ans, ss); } } cout << ans; return 0; }
9
CPP
#include <bits/stdc++.h> using namespace std; int f[2020]; int c[2020]; int v[2020]; int n, m, x, y; int F(int x) { return f[x] != x ? f[x] = F(f[x]) : x; } int main() { scanf("%d", &n); for (int i = 1; i <= n; i++) f[i] = i; scanf("%d", &m); for (int i = 1; i <= m; i++) scanf("%d %d", &x, &y), f[F(x)] = F(y); scanf("%d", &m); for (int i = 1; i <= m; i++) scanf("%d %d", &x, &y), v[F(x)] |= F(x) == F(y); for (int i = 1; i <= n; i++) if (!v[F(i)]) c[f[i]]++; printf("%d\n", *max_element(c, c + n + 1)); return 0; }
9
CPP