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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.