solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int pow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) {
ans = (ans * a) % MOD;
}
b /= 2;
a = (a * a) % MOD;
}
return ans;
}
bool visited[100005];
int id;
int group[100005];
int cnt[100005];
void dfs(int s, vector<int> graph[]) {
visited[s] = true;
group[s] = id;
cnt[id]++;
for (int i : graph[s]) {
if (!visited[i]) {
dfs(i, graph);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k, m;
cin >> n;
vector<int> graph[n + 1];
bool relation[n + 1][n + 1];
cin >> k;
for (int i = 0; i < k; i++) {
int u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
cin >> m;
memset(relation, false, sizeof(relation));
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
relation[u][v] = true;
relation[v][u] = true;
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
id++;
dfs(i, graph);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) {
continue;
}
if ((group[i] == group[j]) && (relation[i][j])) {
cnt[group[i]] = 0;
}
}
}
int mm = INT_MIN;
for (int i = 1; i <= n; i++) {
if (cnt[i] > mm) {
mm = cnt[i];
}
}
cout << mm << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
void fun() {}
const long long int N = 2007;
std::vector<long long int> v[N];
bool visited[N];
std::vector<long long int> friends;
long long int enemy[N][N];
void dfs(long long int node) {
visited[node] = true;
for (auto to : v[node]) {
if (!visited[to]) {
dfs(to);
}
}
friends.push_back(node);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
fun();
long long int tests = 1;
while (tests--) {
long long int n;
cin >> n;
long long int m;
cin >> m;
for (long long int i = 1; i <= m; i++) {
long long int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
cin >> m;
for (long long int i = 1; i <= m; i++) {
long long int x, y;
cin >> x >> y;
enemy[x][y] = 1;
enemy[y][x] = 1;
}
long long int maxInvitations = 0;
for (long long int i = 1; i <= n; i++) {
if (!visited[i]) {
friends.clear();
dfs(i);
bool stillFriends = true;
for (long long int j = 0; j < friends.size(); j++) {
for (long long int k = 0; k < friends.size(); k++) {
if (enemy[friends[j]][friends[k]]) {
stillFriends &= false;
}
}
}
if (stillFriends) {
maxInvitations = max(maxInvitations, (long long int)friends.size());
}
}
}
cout << maxInvitations;
}
cerr << "time elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
class vertex {
public:
bool mark;
int comp;
vector<pair<int, bool>> to;
};
int n, k, m;
vertex f[2000];
int sz[2000];
int counter = 1;
int maxInv = 0;
bool checkComponent(int c) {
for (int i = 1; i <= n; i++) {
if (f[i].comp == c) {
for (int j = 0; j < f[i].to.size(); j++) {
if (f[f[i].to[j].first].comp == c && f[i].to[j].second == false)
return false;
}
}
}
return true;
}
void dfs(int v) {
f[v].mark = true;
f[v].comp = counter;
sz[counter]++;
for (auto w : f[v].to) {
if (w.second == 1 && f[w.first].mark == false) {
dfs(w.first);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
int a, b;
for (int i = 0; i <= k - 1; i++) {
cin >> a >> b;
f[a].to.push_back({b, 1});
f[b].to.push_back({a, 1});
}
cin >> m;
for (int i = 0; i <= m - 1; i++) {
cin >> a >> b;
f[a].to.push_back({b, 0});
f[b].to.push_back({a, 0});
}
for (int i = 1; i <= n; i++) {
if (f[i].mark == false) {
dfs(i);
counter++;
}
}
int compN = counter - 1;
for (int i = 1; i <= compN; i++) {
if (checkComponent(i)) {
if (sz[i] > maxInv) maxInv = sz[i];
}
}
cout << maxInv;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > fri, dis;
int n, k;
vector<int> vis;
void purge(int x) {
vis[x] = 3;
for (int i = 0; i < fri[x].size(); i++) {
int s = fri[x][i];
if (vis[s] != 3) purge(s);
}
}
int dfs(int x, int p) {
vis[x] = 1;
int res = 1;
for (int i = 0; i < dis[x].size(); i++) {
int s = dis[x][i];
if (vis[s] == 1) {
purge(x);
return -1;
}
vis[s] = 2;
}
for (int i = 0; i < fri[x].size(); i++) {
int s = fri[x][i];
if (vis[s] == 2) {
purge(x);
return -1;
}
if (vis[s] == 1) continue;
if (vis[s] == 0) {
int lol = dfs(s, x);
if (lol == -1) {
return -1;
}
res += lol;
}
}
return res;
}
void clean() {
for (int i = 0; i < n; i++) {
if (vis[i] == 2)
vis[i] = 0;
else if (vis[i] == 1)
vis[i] = 3;
}
}
int main() {
cin >> n;
fri = vector<vector<int> >(n);
dis = vector<vector<int> >(n);
cin >> k;
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
fri[a].push_back(b);
fri[b].push_back(a);
}
cin >> k;
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
dis[a].push_back(b);
dis[b].push_back(a);
}
vis = vector<int>(n, 0);
int res = 0;
for (int i = 0; i < n; i++) {
if (vis[i] == 0) {
int r = dfs(i, -1);
if (r != -1) res = max(res, r);
clean();
}
}
cout << res << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int k = 2001;
vector<long long int> parent(k);
vector<long long int> size(k);
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 a, long long int b) {
a = find_set(a);
b = find_set(b);
if (a == b) return;
if (size[b] > size[a]) swap(a, b);
parent[b] = a;
size[a] += size[b];
}
signed main() {
long long int n, m;
cin >> n >> m;
long long int k1, k2;
for (long long int i = 1; i <= n; i++) {
parent[i] = i;
size[i] = 1;
}
while (m--) {
cin >> k1 >> k2;
union_set(k1, k2);
}
set<long long int> s;
for (long long int i = 1; i <= n; i++) {
parent[i] = find_set(i);
s.insert(parent[i]);
}
cin >> m;
while (m--) {
cin >> k1 >> k2;
k1 = find_set(k1);
k2 = find_set(k2);
if (k1 == k2) {
if (s.find(k1) != s.end()) s.erase(k1);
}
}
long long int max1 = 0;
for (auto i = s.begin(); i != s.end(); i++) {
max1 = max(max1, size[*i]);
}
cout << max1;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e18;
int n, m, k, c, a, b, sum[2020], chk[2020], bo[2020], ans;
vector<int> v[2020];
void dfs(int pos) {
if (chk[pos]) return;
chk[pos] = c;
sum[c]++;
for (auto p : v[pos]) {
dfs(p);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (chk[i] != 0) continue;
c++;
dfs(i);
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a >> b;
if (chk[a] == chk[b]) {
bo[chk[a]] = 1;
}
}
for (int i = 1; i <= c; i++) {
if (bo[i] == 1) continue;
ans = max(ans, sum[i]);
}
cout << ans << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, m, a[2000 + 1][2000 + 1], t1, t2, ans = 0, hold[2000 + 1];
bool holded[2000 + 1], checked[2000 + 1];
void DFS(int neo, int d);
void DFS(int neo, int d) {
hold[d] = neo;
holded[neo] = true;
checked[neo] = true;
bool all = true;
for (int i = 1; i <= d; i++) {
for (int j = 1; j <= n; j++) {
if (a[hold[i]][j] == 1 && !holded[j]) {
all = false;
break;
}
}
if (!all) break;
}
if (all) ans = (d > ans) ? d : ans;
for (int i = 1; i <= n; i++) {
if (!checked[i] && !holded[i]) {
bool flag = false;
for (int j = 1; j <= d; j++) {
if (a[hold[j]][i] == 1) {
flag = true;
break;
}
}
for (int j = 1; j <= d; j++) {
if (a[hold[j]][i] == 2) {
flag = false;
break;
}
}
if (flag) {
DFS(i, d + 1);
}
}
}
holded[neo] = false;
}
int main(int argc, const char* argv[]) {
cin >> n;
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> t1 >> t2;
a[t1][t2] = a[t2][t1] = 1;
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> t1 >> t2;
a[t1][t2] = a[t2][t1] = 2;
}
for (int i = 1; i <= n; i++) {
holded[i] = false;
checked[i] = false;
}
for (int i = 1; i <= n; i++) {
if (!checked[i]) DFS(i, 1);
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
def root(Arr,i):
while(Arr[i]!=i):
Arr[i]=Arr[Arr[i]]
i=Arr[i]
return i
def Union(Arr,A,B):
root_A= root(Arr,A)
root_B=root(Arr,B)
if size[root_B]<size[root_A]:
Arr[root_B]=Arr[root_A]
size[root_A]+=size[root_B]
else:
Arr[root_A]=Arr[root_B]
size[root_B]+=size[root_A]
def Find(A,B):
if root(Arr,A)==root(Arr,B):
return True
return False
n=int(input())
Arr=list(range(n))
size=[1]*(n)
lst=[]
f=int(input())
for i in range(f):
A,B=map(int,input().split())
if not Find(A-1,B-1):
Union(Arr,A-1,B-1)
e=int(input())
enemy=[]
#print(enemy)
for x in range(e):
a,b=map(int,input().split())
enemy.append([a-1,b-1])
#print(enemy)
for i in range(n):
if Arr[i]==i:
lst.append([size[i],i])
lst=sorted(lst)[::-1]
ans=0
test=0
if e==0:
print(lst[0][0])
else:
for i in range(len(lst)):
Root=lst[i][1]
test=0
for k in range(e):
if root(Arr,enemy[k][0])==Root and root(Arr,enemy[k][1])==Root:
test=1
break
if test==0:
ans=lst[i][0]
break
#print(enemy)
#print(lst)
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m, a, b, vis[2010];
vector<int> like[2010];
vector<int> dislike[2010];
vector<int> ac;
int is;
void dfs(int x) {
vis[x] = 1;
ac.push_back(x);
for (int i = 0; i < dislike[x].size(); i++) {
if (count(ac.begin(), ac.end(), dislike[x][i])) {
is = 0;
return;
}
}
for (int i = 0; i < like[x].size(); i++) {
if (!vis[like[x][i]]) {
dfs(like[x][i]);
}
}
}
int main(void) {
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> a >> b;
like[a].push_back(b);
like[b].push_back(a);
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
dislike[a].push_back(b);
dislike[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
is = 1;
memset(vis, 0, sizeof(vis));
ac.clear();
dfs(i);
if (is && ac.size() > ans) {
ans = (int)ac.size();
}
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
const int N = 2010;
struct node {
int p;
node *next;
} h[N];
void add(int x, int y) {
node *tmp = new node;
tmp->p = y;
tmp->next = h[x].next;
h[x].next = tmp;
}
int p[N], d = 0, cnt[N];
bool flag[N];
void DFS(int x) {
flag[x] = true;
p[x] = d;
cnt[d]++;
for (node *tmp = h[x].next; tmp != NULL; tmp = tmp->next)
if (!flag[tmp->p]) DFS(tmp->p);
}
int main() {
int n, m1, m2, x, y;
scanf("%d%d", &n, &m1);
for (int i = 1; i <= n; i++) h[i].next = NULL;
while (m1--) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; i++)
if (!flag[i]) {
++d;
DFS(i);
}
scanf("%d", &m2);
while (m2--) {
scanf("%d%d", &x, &y);
if (p[x] == p[y]) cnt[p[x]] = 0;
}
int ans = 0;
for (int i = 1; i <= d; i++)
if (ans < cnt[i]) ans = cnt[i];
printf("%d\n", ans);
scanf(" ");
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, vis[2005], sz[2005];
vector<int> e[2005];
pair<int, int> f[2005];
void dfs(int u, int c) {
if (vis[u] != -1) return;
vis[u] = c;
sz[c]++;
for (int i = 0; i < e[u].size(); i++) dfs(e[u][i], c);
}
int main() {
ios_base::sync_with_stdio(0);
cin.clear();
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
u--;
v--;
e[u].push_back(v);
e[v].push_back(u);
}
cin >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
f[i] = make_pair(u, v);
}
memset(vis, -1, sizeof vis);
for (int i = 0; i < n; i++) {
dfs(i, i);
}
int mx = 0;
for (int i = 0; i < m; i++) {
int u = f[i].first, v = f[i].second;
if (vis[u] == vis[v]) {
sz[vis[u]] = 0;
}
}
for (int i = 0; i < n; i++) {
mx = max(mx, sz[i]);
}
cout << mx;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 1e5 + 12;
const long long INF = 1e18 + 12;
const long long Inf = 1e9 + 12;
long long n, k, m, mx, par[maxN], sz[maxN];
long long find(long long x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = 0; i <= n; i++) par[i] = i, sz[i] = 1;
while (k--) {
long long x, y;
cin >> x >> y;
x = find(x);
y = find(y);
if (y - x) {
par[y] = x;
sz[x] += sz[y];
}
}
cin >> m;
while (m--) {
long long x, y;
cin >> x >> y;
x = find(x);
y = find(y);
if (x == y) sz[y] = 0;
}
for (long long i = 1; i <= n; i++) {
mx = max(mx, sz[find(i)]);
}
cout << mx << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, k, m, ans;
vector<long long> e[1000005], v;
set<long long> hate[1000005];
bool mark[1000005];
void dfs(int u) {
mark[u] = 1;
v.push_back(u);
for (int x : e[u]) {
if (mark[x]) continue;
dfs(x);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> k;
for (int i = 1; i <= k; i++) {
long long x, y;
cin >> x >> y;
e[x].push_back(y);
e[y].push_back(x);
}
cin >> m;
for (int i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
hate[x].insert(y);
hate[y].insert(x);
}
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
v.clear();
dfs(i);
set<long long> s(v.begin(), v.end());
bool check = true;
for (int x : s) {
for (int y : hate[x]) {
if (s.count(y)) {
check = false;
break;
}
if (!check) break;
}
if (!check) break;
}
if (check) ans = max(ans, (long long)v.size());
}
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
std::vector<std::vector<unsigned>*> parties;
std::list<std::vector<unsigned>> groups;
class Pair {
public:
unsigned m_first;
unsigned m_second;
Pair() : m_first(0), m_second(0) {}
void read(bool is_a_friends) {
std::cin >> m_first >> m_second;
m_first--;
m_second--;
if (is_a_friends && parties[m_first] != parties[m_second]) {
parties[m_first]->insert(parties[m_first]->end(),
parties[m_second]->begin(),
parties[m_second]->end());
std::vector<unsigned>* ptr = parties[m_second];
for (auto i = ptr->begin(), end = ptr->end(); i != end; ++i)
parties[*i] = parties[m_first];
ptr->clear();
} else if (!is_a_friends && parties[m_first] == parties[m_second])
parties[m_first]->clear();
}
};
void read(bool is_a_friends) {
unsigned k(0);
Pair pair;
std::cin >> k;
for (unsigned i = 0; i < k; i++) pair.read(is_a_friends);
}
int main() {
unsigned size(0);
std::cin >> size;
parties.assign(size, nullptr);
for (unsigned i = 0; i < size; i++) {
groups.push_front(std::vector<unsigned>(1, i));
parties[i] = &groups.front();
parties[i]->reserve(size);
}
read(true);
read(false);
unsigned max(0);
for (auto i = groups.begin(); i != groups.end(); ++i)
if (max < i->size()) max = i->size();
std::cout << max;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[2001], v;
bool dis[2001][2001], vit[2001];
void dfs(int u) {
vit[u] = true;
v.push_back(u);
for (int i = 0; i < g[u].size(); i++) {
int t = g[u][i];
if (!vit[t]) dfs(t);
}
}
bool ok() {
for (int i = 0; i < v.size(); i++)
for (int k = i + 1; k < v.size(); k++)
if (dis[v[i]][v[k]]) return false;
return true;
}
int main() {
int n, i, a, b, ret = 0;
scanf("%d %d", &n, &i);
while (i--) {
scanf("%d %d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
scanf("%d", &i);
while (i--) {
scanf("%d %d", &a, &b);
dis[a][b] = dis[b][a] = true;
}
for (i = 1; i <= n; i++)
if (!vit[i]) {
v.clear();
dfs(i);
if (ok()) {
ret = max(ret, (int)v.size());
}
}
printf("%d", ret);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
void sIO();
int n, m, k, x, y, p[2222], ans, kk, tt;
bool f[2222][2222], w[2222], ok;
vector<int> cur;
int findSet(int v) {
if (p[v] != v) p[v] = findSet(p[v]);
return p[v];
}
void unite(int a, int b) {
a = findSet(a);
b = findSet(b);
if (a != b) {
if (rand() & 1) swap(a, b);
p[a] = b;
}
}
int main() {
sIO();
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) p[i] = i;
for (int i = 0; i < m; ++i) {
scanf("%d %d", &x, &y);
unite(x, y);
}
memset(f, 0, sizeof(f));
scanf("%d", &k);
for (int i = 0; i < k; ++i) {
scanf("%d %d", &x, &y);
f[x][y] = f[y][x] = true;
}
for (int i = 1; i <= n; ++i) p[i] = findSet(i);
memset(w, 0, sizeof(w));
ans = 0;
for (int i = 1; i <= n; ++i)
if (!w[i]) {
tt = p[i];
cur.clear();
ok = true;
for (int j = i; j <= n; ++j)
if (p[j] == tt) {
kk = (int)cur.size();
for (k = 0; k < kk; ++k)
if (f[cur[k]][j]) {
ok = false;
break;
}
if (!ok) break;
cur.push_back(j);
}
for (int j = i; j <= n; ++j) w[j] |= p[j] == tt;
ans = max(ans, (int)cur.size() * ok);
}
printf("%d", ans);
return 0;
}
void sIO() {}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int ans, n, m;
int f[maxn], size[maxn], use[maxn];
int findset(int x) {
if (f[x] == x) return x;
int fx = findset(f[x]);
f[x] = fx;
return fx;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) f[i] = i, size[i] = 1, use[i] = 1;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x, y, f1, f2;
scanf("%d%d", &x, &y);
f1 = findset(x);
f2 = findset(y);
if (f1 == f2) continue;
f[f1] = f2;
size[f2] += size[f1];
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x, y, f1, f2;
scanf("%d%d", &x, &y);
f1 = findset(x);
f2 = findset(y);
if (f1 == f2) use[f1] = 0;
}
for (int i = 1; i <= n; i++)
if (f[i] == i && use[i])
if (size[i] > ans) ans = size[i];
printf("%d\n", ans);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2000;
struct UFT {
int links[MAX_N], ranks[MAX_N], sizes[MAX_N];
UFT() {}
void init(int n) {
for (int i = 0; i < n; i++) links[i] = i, ranks[i] = sizes[i] = 1;
}
int root(int i) {
int i0 = i;
while (links[i0] != i0) i0 = links[i0];
return (links[i] = i0);
}
int rank(int i) { return ranks[root(i)]; }
int size(int i) { return sizes[root(i)]; }
bool same(int i, int j) { return root(i) == root(j); }
int merge(int i0, int i1) {
int r0 = root(i0), r1 = root(i1), mr;
if (r0 == r1) return r0;
if (ranks[r0] == ranks[r1]) {
links[r1] = r0;
sizes[r0] += sizes[r1];
ranks[r0]++;
mr = r0;
} else if (ranks[r0] > ranks[r1]) {
links[r1] = r0;
sizes[r0] += sizes[r1];
mr = r0;
} else {
links[r0] = r1;
sizes[r1] += sizes[r0];
mr = r1;
}
return mr;
}
};
UFT uft;
bool ngs[MAX_N];
int main() {
int n;
scanf("%d", &n);
uft.init(n);
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
uft.merge(u, v);
}
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
if (uft.same(u, v)) ngs[uft.root(u)] = true;
}
int maxg = 0;
for (int i = 0; i < n; i++)
if (!ngs[i] && i == uft.root(i) && maxg < uft.size(i)) maxg = uft.size(i);
printf("%d\n", maxg);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1;
const long double eps = 1e-9;
const long double pi = fabs(atan2(0.0, -1.0));
int *ass;
void ML() {
for (;;) {
ass = new int[2500000];
for (int i = 0; i < 2500000; i++) ass[i] = rand();
}
}
int n, k, m;
vector<list<int> > fr;
vector<list<int> > en;
void LoAd() {
cin >> n >> k;
fr.resize(n + 1);
en.resize(n + 1);
for (int x, y, i = 0; i < k; i++) {
scanf("%d %d", &x, &y);
fr[x].push_back(y);
fr[y].push_back(x);
}
cin >> m;
for (int x, y, i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
en[x].push_back(y);
en[y].push_back(x);
}
}
vector<list<int> > co;
vector<bool> was;
vector<bool> goodCompany;
vector<int> company;
void dfs(const int v, const int cnt) {
was[v] = true;
company[v] = cnt;
co[cnt].push_back(v);
for (list<int>::iterator it = fr[v].begin(); it != fr[v].end(); it++) {
if (!was[*it]) dfs(*it, cnt);
}
}
void SoLvE() {
co.reserve(n + 1);
was.resize(n + 1, false);
company.resize(n + 1);
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (!was[i]) {
co.push_back(list<int>());
dfs(i, cnt);
cnt++;
}
}
goodCompany.resize(co.size(), true);
for (int i = 1; i < (int)en.size(); i++) {
for (list<int>::iterator it = en[i].begin(); it != en[i].end(); it++) {
if (company[i] == company[*it]) goodCompany[company[i]] = false;
}
}
int ind = -1;
for (int i = 0; i < (int)co.size(); i++) {
if (!goodCompany[i]) continue;
if (-1 == ind) {
ind = i;
continue;
}
if (co[i].size() > co[ind].size()) ind = i;
}
if (-1 == ind) {
cout << "0";
return;
}
cout << co[ind].size();
}
int main() {
srand((int)time(NULL));
LoAd();
SoLvE();
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int parent[2002];
int comp[2002];
int ans[2002];
int fp(int x) {
if (x == parent[x])
return x;
else
return parent[x] = fp(parent[x]);
}
int main() {
int n, good, bad;
cin >> n;
for (int i = 1; i < n + 1; i++) parent[i] = i;
cin >> good;
while (good--) {
int a, b;
cin >> a >> b;
int pa = fp(a), pb = fp(b);
parent[pa] = parent[pb];
}
cin >> bad;
while (bad--) {
int a, b;
cin >> a >> b;
int pa = fp(a), pb = fp(b);
if (pa != pb) continue;
parent[pa] = parent[pb];
comp[pa] = comp[pb] = 1;
}
int maxi = 0;
for (int i = 1; i < n + 1; i++) {
int pa = fp(i);
if (not comp[pa]) ans[pa]++;
maxi = max(maxi, ans[pa]);
}
cout << maxi << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
class dsu {
public:
int *id;
int *compSize;
int compCount;
dsu(int N) {
compCount = N + 1;
compSize = new int[compCount];
id = new int[compCount];
for (int i = 0; i <= compCount; i++) {
id[i] = i;
compSize[i] = 1;
}
}
int Find(int p) {
int root = p;
while (root != id[root]) root = id[root];
while (p != root) {
int newp = id[p];
id[p] = root;
p = newp;
}
return root;
}
bool Connected(int p, int q) { return Find(p) == Find(q); }
void Union(int p, int q) {
int i = Find(p);
int j = Find(q);
if (i == j) return;
id[i] = j;
compSize[j] += compSize[i];
compCount--;
}
};
int n, m, p, q, i, sol, rp, rq;
int main() {
scanf("%d", &n);
dsu uf(n);
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d %d", &p, &q);
uf.Union(p, q);
}
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d %d", &p, &q);
rp = uf.Find(p);
rq = uf.Find(q);
if (rp == rq) {
uf.compSize[rp] = 0;
}
}
sol = 0;
for (i = 1; i <= n; i++) {
if (i == uf.id[i]) sol = max(sol, uf.compSize[i]);
}
printf("%d\n", sol);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 2020;
int n, m, k;
bool used[N_MAX], nenr[N_MAX][N_MAX];
vector<int> druz[N_MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
while (m--) {
int a, b;
cin >> a >> b;
a--;
b--;
druz[a].push_back(b);
druz[b].push_back(a);
}
cin >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
nenr[i][j] = false;
}
}
while (k--) {
int a, b;
cin >> a >> b;
a--;
b--;
nenr[a][b] = true;
nenr[b][a] = true;
}
for (int i = 0; i < n; i++) {
used[i] = false;
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) {
vector<int> grp;
queue<int> q;
used[i] = true;
q.push(i);
while (!q.empty()) {
int v = q.front();
q.pop();
grp.push_back(v);
for (auto u : druz[v]) {
if (!used[u]) {
q.push(u);
used[u] = true;
}
}
}
bool jojo = true;
for (auto v : grp) {
for (auto u : grp) {
jojo &= !nenr[v][u];
}
}
if (jojo) {
ans = max(ans, (int)grp.size());
}
}
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<int, vector<int> > like;
map<int, vector<int> > dislike;
vector<int> memo_all;
vector<int> memo;
int dfs(int &n) {
int r = 1, s;
vector<int> v = like[n];
for (int i = 0; i < v.size(); i++) {
if (find(memo_all.begin(), memo_all.end(), v[i]) == memo_all.end()) {
memo.push_back(v[i]);
memo_all.push_back(v[i]);
s = dfs(v[i]);
if (!s) return 0;
r += s;
}
}
return r;
}
int main() {
int n, k, x, y;
for (scanf("%d%d", &n, &k); k; k--) {
scanf("%d%d", &x, &y);
like[x].push_back(y);
like[y].push_back(x);
}
for (scanf("%d", &k); k; k--) {
scanf("%d%d", &x, &y);
dislike[x].push_back(y);
dislike[y].push_back(x);
}
for (x = 0, y = 1; y <= n; y++) {
if (find(memo_all.begin(), memo_all.end(), y) == memo_all.end()) {
memo.clear();
memo.push_back(y);
memo_all.push_back(y);
k = dfs(y);
for (int i = 0; i < memo.size() - 1; i++)
for (int j = i + 1; j < memo.size(); j++) {
if (find(dislike[memo[i]].begin(), dislike[memo[i]].end(), memo[j]) !=
dislike[memo[i]].end())
goto next;
}
if (x < k) x = k;
}
next:;
}
printf("%d\n", x);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int f[100100], kl[100100], used[100100], K;
vector<int> g[100100];
void dfs(int v) {
used[v] = K;
kl[K]++;
for (int i = 0; i < g[v].size(); i++)
if (!used[g[v][i]]) dfs(g[v][i]);
}
int main() {
ios_base::sync_with_stdio(0);
int n, k, m;
cin >> n >> k;
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
K++;
dfs(i);
}
}
cin >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if (used[x] == used[y]) f[used[x]] = 1;
}
int ans = 0;
for (int i = 1; i <= K; i++) {
if (!f[i]) ans = max(ans, kl[i]);
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> groups;
bool visited[2001];
int group_num[2001];
vector<int> graph[2001];
void dfs(vector<int> &group, int i) {
visited[i] = 1;
group.push_back(i);
for (int v : graph[i]) {
if (!visited[v]) dfs(group, v);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, k, u, v, i = 1, m;
vector<int> group_len;
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 0; i < n + 1; i++) visited[i] = 0;
for (int i = 1; i < n + 1; i++) {
if (!visited[i]) {
vector<int> group;
dfs(group, i);
groups.push_back(group);
}
}
for (vector<int> temp : groups) {
for (int v : temp) group_num[v] = i;
group_len.push_back(temp.size());
i++;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
if (group_num[u] == group_num[v]) group_len[group_num[u] - 1] = 0;
}
cout << *max_element(group_len.begin(), group_len.end());
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, like, dislike, a, b, flag[2005], jum[2005];
int main() {
while (scanf("%d", &n) != EOF) {
vector<int> vec1[2005];
vector<pair<int, int> > vec2;
scanf("%d", &like);
for (int i = 0; i < like; i++) {
scanf("%d %d", &a, &b);
vec1[a].push_back(b);
vec1[b].push_back(a);
}
scanf("%d", &dislike);
for (int i = 0; i < dislike; i++) {
scanf("%d %d", &a, &b);
vec2.push_back(make_pair(a, b));
}
memset(flag, -1, sizeof(flag));
memset(jum, 0, sizeof(jum));
int pos = 0;
for (int i = 1; i <= n; i++) {
if (flag[i] == -1) {
pos++;
queue<pair<int, int> > q;
q.push(make_pair(i, pos));
flag[i] = pos;
while (!q.empty()) {
pair<int, int> tmp;
tmp = q.front();
q.pop();
int v = tmp.first, curr = tmp.second;
for (int j = 0; j < vec1[v].size(); j++) {
if (flag[vec1[v][j]] == -1) {
flag[vec1[v][j]] = curr;
q.push(make_pair(vec1[v][j], curr));
}
}
}
}
}
for (int i = 1; i <= 2000; i++) jum[flag[i]]++;
for (int i = 0; i < vec2.size(); i++) {
if (flag[vec2[i].first] == flag[vec2[i].second]) {
jum[flag[vec2[i].first]] = 0;
}
}
int res = 0;
for (int i = 1; i <= 2000; i++) {
res = max(res, jum[i]);
}
printf("%d\n", res);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
const int inf = 1 << 29;
const double eps = 1e-8;
int par[maxn], siz[maxn];
bool vis[maxn];
int findset(int x) {
if (par[x] != x) par[x] = findset(par[x]);
return par[x];
}
void unionset(int x, int y) {
int fx = findset(x);
int fy = findset(y);
if (fx == fy)
return;
else {
par[fx] = fy;
siz[fy] += siz[fx];
}
}
int main() {
int n, k, m, a, b;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
par[i] = i;
siz[i] = 1;
}
scanf("%d", &k);
while (k--) {
int a, b;
scanf("%d%d", &a, &b);
unionset(a, b);
}
scanf("%d", &m);
while (m--) {
scanf("%d%d", &a, &b);
if (findset(a) == findset(b)) {
vis[findset(a)] = 1;
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (par[i] == i && !vis[i]) {
res = max(res, siz[i]);
}
}
printf("%d\n", res);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, K;
int A, B;
struct UnionFind {
int par[2000], ra[2000];
UnionFind() {
for (int(i) = 0; (i) < (2000); (i)++) par[i] = i, ra[i] = 1;
}
int find(int x) { return par[x] == x ? x : par[x] = find(par[x]); }
bool same(int a, int b) { return find(a) == find(b); }
void unite(int a, int b) {
if ((a = find(a)) != (b = find(b))) {
if (ra[a] < ra[b]) swap(a, b);
par[b] = a;
ra[a] += ra[b];
}
}
} uf;
bool cant[2000];
int main() {
scanf("%d", &N);
scanf("%d", &K);
while (K--) scanf("%d%d", &A, &B), uf.unite(A - 1, B - 1);
scanf("%d", &K);
while (K--) {
scanf("%d%d", &A, &B);
A = uf.find(A - 1), B = uf.find(B - 1);
if (A == B) uf.ra[A] = 0;
}
int res = 0;
for (int(i) = 0; (i) < (N); (i)++)
if (uf.find(i) == i) res = max(res, uf.ra[i]);
printf("%d\n", res);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int p[111111];
int s[111111];
int P(int first) {
return ((p[first] == first) ? (first) : (p[first] = P(p[first])));
}
inline void U(int first, int second) {
first = P(first);
second = P(second);
if (rand() % 2) {
p[first] = second;
s[second] += s[first];
} else {
p[second] = first;
s[first] += s[second];
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) p[i] = i, s[i] = 1;
scanf("%d", &k);
for (int i = 0; i < k; ++i) {
int first, second;
scanf("%d%d", &first, &second);
--first;
--second;
if (P(first) != P(second)) U(first, second);
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
int first, second;
scanf("%d%d", &first, &second);
--first;
--second;
if (P(first) == P(second)) s[P(first)] = 0;
}
int ans = 0;
for (int i = 0; i < n; ++i)
if (P(i) == i) ans = max(ans, s[i]);
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> like[2000 + 1];
vector<int> dislike[2000 + 1];
int main() {
int n, m1, m2;
cin >> n >> m1;
for (int i = 0; i < m1; i++) {
int a, b;
cin >> a >> b;
like[a].push_back(b);
like[b].push_back(a);
}
cin >> m2;
for (int i = 0; i < m2; i++) {
int a, b;
cin >> a >> b;
dislike[a].push_back(b);
dislike[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int ans1 = 0;
bool vis[2000 + 1];
memset(vis, false, sizeof vis);
vis[i] = true;
queue<int> q;
queue<int> q1;
q.push(i);
q1.push(i);
while (!q.empty()) {
int cur = q.front();
ans1++;
q1.push(cur);
q.pop();
for (int j = 0; j < int(like[cur].size()); j++) {
if (!vis[like[cur][j]]) {
vis[like[cur][j]] = true;
q.push(like[cur][j]);
}
}
}
bool sw1 = true;
while (!q1.empty()) {
bool sw = true;
int cur = q1.front();
q1.pop();
for (int j = 0; j < int(dislike[cur].size()); j++)
if (vis[dislike[cur][j]]) {
sw = false;
break;
}
if (!sw) {
sw1 = false;
break;
}
}
if (!sw1) continue;
ans = max(ans, ans1);
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> v(100002);
vector<int> vis(100002);
vector<int> dfs(int src) {
stack<int> st;
st.push(src);
vector<int> sts;
vis[src] = 1;
sts.push_back(src);
while (!st.empty()) {
int x = st.top();
st.pop();
if (!vis[x]) {
sts.push_back(x);
vis[x] = 1;
}
for (int i = 0; i < v[x].size(); i++) {
if (vis[v[x][i]] == 0) st.push(v[x][i]);
}
}
return sts;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
fill(vis.begin(), vis.end(), 0);
for (int i = 0; i < v.size(); i++) v[i].clear();
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
vector<vector<int>> dis(1000005);
int k;
cin >> k;
while (k--) {
int a, b;
cin >> a >> b;
dis[a].push_back(b);
dis[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
vector<int> tr = dfs(i);
sort(tr.begin(), tr.end());
int f = 0;
for (int i = 0; i < tr.size(); i++) {
for (int j = 0; j < dis[tr[i]].size(); j++) {
if (dis[tr[i]][j] != 0) {
int disx = dis[tr[i]][j];
if (binary_search(tr.begin(), tr.end(), disx)) {
f = 1;
break;
}
}
}
}
if (f == 0) {
int xx = tr.size();
ans = max(ans, xx);
}
}
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1 << 20;
const double PI = M_PI;
const double EPS = 1e-15;
const int MaxN = 3001;
int N, A, B;
vector<int> G[MaxN];
bool M[MaxN][MaxN];
bool visited[MaxN];
int comp[MaxN], size;
void dfs(int u) {
comp[size++] = u;
visited[u] = true;
for (int i = (int)G[u].size() - 1; i >= 0; i--) {
int w = G[u][i];
if (!visited[w]) dfs(w);
}
}
int main() {
cin.sync_with_stdio(false);
cin >> N;
cin >> A;
for (int i = 0; i < (A); i++) {
int u, v;
cin >> u >> v;
G[u - 1].push_back(v - 1);
G[v - 1].push_back(u - 1);
}
cin >> B;
for (int i = 0; i < (B); i++) {
int u, v;
cin >> u >> v;
M[u - 1][v - 1] = true;
M[v - 1][u - 1] = true;
}
int answer = 0;
for (int i = 0; i < (N); i++)
if (!visited[i]) {
size = 0;
dfs(i);
bool valid = true;
for (int j = 0; j < (size); j++) {
for (int k = 0; k < (j); k++)
if (M[comp[j]][comp[k]]) {
valid = false;
break;
}
if (!valid) break;
}
if (valid) answer = max(answer, size);
}
cout << answer << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long amount, k, m, x, y, *block_in_stack, res, max;
char *object;
bool *obj;
cin >> amount >> k;
object = new char[amount * amount];
obj = new bool[amount];
block_in_stack = new long[amount];
for (long i = 0; i < amount; i++) obj[i] = 0;
for (long i = 0; i < amount * amount; i++) {
object[i] = 0;
}
for (long i = 0; i < k; i++) {
cin >> x >> y;
object[amount * (x - 1) + y - 1] = object[amount * (y - 1) + x - 1] = 1;
}
cin >> m;
for (long i = 0; i < m; i++) {
cin >> x >> y;
object[amount * (x - 1) + y - 1] = object[amount * (y - 1) + x - 1] = 2;
}
max = 0;
bool flag;
for (long i = 0; i < amount; i++) {
res = 0;
flag = 1;
if (!obj[i]) {
obj[i] = 1;
block_in_stack[res] = i;
res++;
for (long place = 0; place < res; place++) {
for (long j = 0; j < amount; j++) {
if (object[j * amount + block_in_stack[place]] == 1 && !obj[j]) {
obj[j] = 1;
block_in_stack[res] = j;
res++;
}
}
}
}
for (long place = 0; place < res; place++) {
for (long j = 0; j < res; j++) {
if (object[block_in_stack[j] * amount + block_in_stack[place]] == 2)
flag = 0;
}
}
if (res > max && flag) max = res;
}
cout << max << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> E[2005];
int belong[2000 + 5], used[2000 + 5];
int group[2000 + 5], cnt[2000 + 4];
void dfs(int p, int d) {
int i;
if (used[p] == 1) return;
used[p] = 1;
belong[p] = d;
for (i = 0; i < E[p].size(); i++) dfs(E[p][i], d);
}
int main() {
int i, j, k;
int n, m;
scanf("%d %d", &n, &m);
for (i = 1; i <= m; i++) {
int a, b;
scanf("%d %d", &a, &b);
E[a].push_back(b);
E[b].push_back(a);
}
int idx = 0;
for (i = 1; i <= n; i++) {
if (used[i] == 0) {
idx++;
dfs(i, idx);
}
}
int mm = 0;
scanf("%d", &mm);
for (i = 1; i <= n; i++) {
cnt[belong[i]]++;
}
for (i = 1; i <= mm; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (belong[a] == belong[b]) group[belong[a]] = 1;
}
int Max = 0;
for (i = 1; i <= idx; i++) {
if (group[i] == 0) {
if (cnt[i] > Max) Max = cnt[i];
}
}
printf("%d\n", Max);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 + 100;
int fa[N];
int Find(int x) { return fa[x] < 0 ? x : fa[x] = Find(fa[x]); }
void Union(int x, int y) {
int rx = Find(x);
int ry = Find(y);
if (rx != ry) {
fa[rx] += fa[ry];
fa[ry] = rx;
}
}
int main() {
int n;
scanf("%d", &(n));
memset((fa), -1, sizeof(fa));
int m;
scanf("%d", &(m));
while (m--) {
int x, y;
scanf("%d", &(x)), scanf("%d", &(y));
Union(x, y);
}
int k;
scanf("%d", &(k));
int cant[N];
memset((cant), 0, sizeof(cant));
while (k--) {
int x, y;
scanf("%d", &(x)), scanf("%d", &(y));
if (Find(x) == Find(y)) cant[Find(x)] = 1;
}
int ans = 0;
for (int i(1), _h(n); i <= _h; ++i)
if (Find(i) == i) {
if (!cant[i] && -fa[i] > ans) ans = -fa[i];
}
printf("%d\n", (ans));
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, k, m, used[2020][2020];
vector<int> g[2020];
bool c[2020];
vector<int> cur;
void dfs(int v) {
c[v] = 1;
cur.push_back(v);
for (__typeof(g[v].begin()) it = g[v].begin(); it != g[v].end(); it++) {
int to = *it;
if (!c[to]) dfs(to);
}
}
int main() {
scanf("%d\n", &n);
scanf("%d\n", &k);
for (int i = 0, x, y; i < k; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
scanf("%d\n", &m);
for (int i = 0, x, y; i < m; i++) {
scanf("%d%d\n", &x, &y);
x--;
y--;
used[x][y] = used[y][x] = 1;
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!c[i]) {
cur.clear();
dfs(i);
bool ok = 1;
for (int i = 0; i < cur.size(); i++) {
for (int j = 0; j < cur.size(); j++) {
if (used[cur[i]][cur[j]]) ok = 0;
}
}
if (ok) ans = max(ans, (int)cur.size());
}
}
printf("%d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string get() {
char ch[1000010];
scanf("%s", ch);
return ch;
}
const int MAX_LG = 21;
const long long maxn = 2e3 + 10;
const long long base = 29;
const long long mod = 1e9 + 7;
const long long INF = 1e9;
vector<long long> g[maxn], b[maxn];
long long bad[maxn][maxn];
long long res;
bool mark[maxn];
bool vis[maxn];
int32_t main() {
long long n = in(), k = in();
for (long long i = 0; i < k; i++) {
long long v = in(), u = in();
g[v].push_back(u);
g[u].push_back(v);
}
long long m = in();
for (long long i = 0; i < m; i++) {
long long v = in(), u = in();
b[v].push_back(u), b[u].push_back(v);
}
for (long long i = 1; i <= n; i++) {
if (vis[i]) continue;
for (long long x = 1; x <= n; x++) mark[x] = false;
long long cnt = 0;
queue<long long> q;
q.push(i);
vector<long long> vc;
while (q.empty() == false) {
long long v = q.front();
q.pop();
vc.push_back(v);
vis[v] = true;
mark[v] = true;
cnt++;
for (auto u : g[v]) {
if (!mark[u]) mark[u] = true, q.push(u);
}
}
for (auto v : vc) {
for (auto u : b[v]) {
if (mark[u]) {
cnt = 0;
}
}
}
res = max(res, cnt);
}
cout << res << "\n";
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> friends[2010];
vector<int> enemies[2010];
bool visited[2010];
int main() {
int n;
cin >> n;
int k;
cin >> k;
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
friends[a].push_back(b);
friends[b].push_back(a);
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
enemies[a].push_back(b);
enemies[b].push_back(a);
}
int best = 0;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
set<int> good;
set<int> bad;
stack<int> next;
next.push(i);
while (!next.empty()) {
int v = next.top();
good.insert(v);
next.pop();
if (visited[v]) continue;
visited[v] = true;
for (int j = 0; j < friends[v].size(); j++) {
if (!visited[friends[v][j]]) {
next.push(friends[v][j]);
}
}
for (int j = 0; j < enemies[v].size(); j++) {
bad.insert(enemies[v][j]);
}
}
bool found = true;
for (set<int>::iterator it = good.begin(); it != good.end(); ++it) {
if (bad.find(*it) != bad.end()) {
found = false;
break;
}
}
if (found) {
if (good.size() > best) best = good.size();
}
}
}
cout << best << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long component = 0, no_of_com = 0;
unordered_map<long long, long long> com;
void dfs(vector<long long> adj[], long long s) {
no_of_com++;
com[s] = component;
for (long long a : adj[s]) {
if (com[a] == 0) dfs(adj, a);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long k, m;
cin >> k;
vector<long long> adj[n + 1];
unordered_map<long long, long long> mp;
for (long long i = 0; i < k; i++) {
long long a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (long long i = 1; i <= n; i++) {
if (com[i] == 0) {
component++;
no_of_com = 0;
dfs(adj, i);
mp[com[i]] = no_of_com;
}
}
cin >> k;
for (long long i = 0; i < k; i++) {
long long a, b;
cin >> a >> b;
if (com[a] == com[b]) {
mp[com[a]] = 0;
}
}
long long maxx = -1;
for (long long i = 1; i <= component; i++) {
if (maxx < mp[i]) maxx = mp[i];
}
cout << maxx;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[2001];
vector<int> T[2001];
bool vist[2001];
bool no[2001];
bool here[2001];
int as;
bool dfs(int u) {
as++;
vist[u] = 1;
here[u] = 1;
bool f = true;
for (typeof T[u].begin() i = T[u].begin(); i != T[u].end(); i++) {
if (here[*i]) f = false;
no[*i] = 1;
}
for (typeof G[u].begin() i = G[u].begin(); i != G[u].end(); i++) {
if (no[*i]) f = false;
if (!vist[*i])
if (!dfs(*i)) f = false;
}
return f;
}
int main(int argc, char const *argv[]) {
int n, k, m, a, b;
cin >> n >> k;
for (int i = 0; i < k; ++i) {
cin >> a >> b;
a--, b--;
G[a].push_back(b);
G[b].push_back(a);
}
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> a >> b;
a--, b--;
T[a].push_back(b);
T[b].push_back(a);
}
int ans = 0;
memset(vist, 0, sizeof vist);
for (int i = 0; i < n; ++i) {
memset(no, 0, sizeof no);
memset(here, 0, sizeof here);
if (!vist[i]) {
as = 0;
if (dfs(i)) ans = max(as, ans);
}
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
string tostr(int n) {
stringstream rr;
rr << n;
return rr.str();
}
long long power(long long a, long long b) {
return b == 0 ?: a * power(a, b - 1);
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
vector<int> graph[2020];
bool vis[2020];
int dislike[2020];
int mp[2020];
int bfs(int s, int mx) {
bool ok = true;
vis[s] = 1;
queue<int> q;
vector<int> vec;
vec.clear();
vec.push_back(s);
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < graph[u].size(); i++) {
int v = graph[u][i];
if (vis[v] == 0) {
vec.push_back(v);
vis[v] = 1;
q.push(v);
}
}
}
for (int i = 0; i <= 2010; i++) mp[i] = 0;
int len = vec.size();
for (int i = 0; i < vec.size(); i++) mp[dislike[vec[i]]]++;
for (int i = 2; i <= 2010; i++) {
if (mp[i] > 1) {
ok = false;
break;
}
}
if (ok) mx = max(mx, len);
return mx;
}
int main() {
ios::sync_with_stdio(0);
int n, k;
while (cin >> n >> k) {
int c = 2, m, mx = 0;
for (int i = 0; i <= n; i++) graph[i].clear();
for (int i = 1; i <= k; i++) {
int a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
cin >> m;
for (int i = 0; i <= 2010; i++) dislike[i] = 0;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
if (dislike[a] == 0) dislike[a] = c;
if (dislike[b] == 0) dislike[b] = c;
c++;
}
for (int i = 0; i <= 2010; i++) vis[i] = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
mx = bfs(i, mx);
}
}
cout << mx << "\n";
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2005;
vector<long long> adj[N];
bool cant[N];
long long numcomp, comp[N], cursz, friends[N];
void dfs(long long v) {
comp[v] = numcomp;
cursz++;
for (auto &u : adj[v])
if (!comp[u]) dfs(u);
return;
}
int main() {
long long n, k, i, v, u, m, ans;
cin >> n >> k;
for (i = 1; i <= k; i++) {
cin >> v >> u;
adj[v].push_back(u);
adj[u].push_back(v);
}
numcomp = 0;
for (i = 1; i <= n; i++) {
if (!comp[i]) {
numcomp++;
cursz = 0;
dfs(i);
friends[numcomp] = cursz;
}
}
cin >> m;
for (i = 1; i <= m; i++) {
cin >> v >> u;
if (comp[v] == comp[u]) cant[comp[v]] = true;
}
ans = 0;
for (i = 1; i <= numcomp; i++) {
if (!cant[i]) ans = max(ans, friends[i]);
}
cout << ans << "\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int g[2048];
int num[2048];
void un(int a, int b);
int Find(int x);
int main() {
int n, like, dislike, a, b, grp;
while (cin >> n) {
grp = 0;
for (int i = 1; i <= n; i++) {
g[i] = i;
num[i] = 1;
}
cin >> like;
for (int i = 0; i < like; i++) {
cin >> a >> b;
un(a, b);
}
cin >> dislike;
for (int i = 0; i < dislike; i++) {
cin >> a >> b;
a = Find(a);
b = Find(b);
if (a == b) num[a] = 0;
}
for (int i = 1; i <= n; i++) {
grp = max(grp, num[i]);
}
cout << grp << endl;
}
return 0;
}
void un(int a, int b) {
a = Find(a);
b = Find(b);
if (a != b) {
if (num[a] > num[b]) {
g[b] = a;
num[a] += num[b];
num[b] = 0;
} else {
g[a] = b;
num[b] += num[a];
num[a] = 0;
}
}
}
int Find(int x) { return x == g[x] ? x : g[x] = Find(g[x]); }
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int inf = int(2e9);
const int _inf = -inf;
const int mod = inf + 7;
using namespace std;
bool bad[2002][2002];
vector<int> g[2002];
bool used[2002];
queue<int> q;
int cnt;
vector<int> res;
void bfs(int v) {
used[v] = 1;
cnt++;
res.push_back(v);
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to] && !bad[v][to]) {
bfs(to);
}
}
}
void solve() {
int n, k;
cin >> n >> k;
for (int i = 0; i < k; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
bad[u][v] = 1;
bad[v][u] = 1;
}
int mx = 0;
for (int i = 1; i <= n; ++i) {
if (!used[i]) {
cnt = 0;
res.clear();
bfs(i);
bool flag = 1;
for (int j = 0; j < res.size(); ++j) {
for (int k = j + 1; k < res.size(); ++k) {
if (bad[res[j]][res[k]]) flag = 0;
}
}
if (flag) mx = max(mx, (int)res.size());
}
}
cout << mx;
}
int main() {
solve();
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
array<vector<int>, 2001> adj;
bool vis[2001];
bool like[2001][2001];
vector<int> group;
void dfs(int f) {
vis[f] = true;
group.push_back(f);
for (auto to : adj[f])
if (like[f][to] && !vis[to]) dfs(to);
}
int main() {
adj.fill({});
memset(like, true, sizeof like);
int n, k, m, i, j;
cin >> n >> k;
while (k--) {
cin >> i >> j;
adj[i].push_back(j);
adj[j].push_back(i);
}
cin >> m;
while (m--) {
cin >> i >> j;
adj[i].push_back(j);
adj[j].push_back(i);
like[i][j] = like[j][i] = false;
}
int mx = 0;
for (int i = 1; i <= n; i++) {
group.clear();
memset(vis, false, sizeof vis);
dfs(i);
bool b = true;
for (auto f1 : group)
for (auto f2 : group)
if (f1 != f2 && !like[f1][f2]) {
b = false;
break;
}
if (b) mx = max(mx, int(group.size()));
}
cout << mx;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, p[2000], sz[2000], ans;
int root(int x) { return p[x] != x ? p[x] = root(p[x]) : x; }
void join(int x, int y) {
x = root(x), y = root(y);
if (x == y) return;
if (sz[x] <= sz[y])
sz[p[x] = y] += sz[x];
else
sz[p[y] = x] += sz[y];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) sz[p[i] = i] = 1;
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
join(x - 1, y - 1);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
if (root(--x) == root(--y)) sz[root(x)] = 0;
}
for (int i = 0; i < n; i++) ans = max(ans, sz[root(i)]);
printf("%d\n", ans);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 7;
vector<int> adj[MAX];
bool mark[MAX], group[MAX];
int gr[MAX], fr[MAX];
void dfs(int u, int groupID);
int n, k, m;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
int groupID = 1;
for (int i = 1; i <= n; ++i) {
if (!mark[i]) {
dfs(i, groupID);
group[groupID] = true;
++groupID;
}
}
cin >> m;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
if (gr[u] == gr[v]) {
group[gr[u]] = false;
}
}
memset(fr, 0, sizeof(fr));
int res = 0;
for (int i = 1; i <= n; ++i) {
fr[gr[i]]++;
}
for (int i = 1; i <= n; ++i) {
if (group[i]) {
res = max(res, fr[i]);
}
}
cout << res << "\n";
return 0;
}
void dfs(int u, int groupID) {
gr[u] = groupID;
mark[u] = true;
int size = adj[u].size();
for (int i = 0; i < size; ++i) {
if (!mark[adj[u][i]]) {
dfs(adj[u][i], groupID);
}
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
int par[2007];
int find(int x) {
if (par[x] == -1) return x;
return find(par[x]);
}
void uni(int x, int y) {
int u = find(x);
int v = find(y);
if (u != v) par[u] = v;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
memset(par, -1, sizeof(par));
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
uni(x, y);
}
map<int, int> mp;
for (int i = 1; i <= n; i++) mp[find(i)]++;
cin >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
int u = find(x);
int v = find(y);
if (u == v) mp[u] = 0;
}
int ans = 0;
for (auto it : mp) ans = max(ans, it.second);
cout << ans << "\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool F[2001][2001];
bool D[2001][2001];
int C[2001];
vector<int> V[2001];
int n;
void f(int v, int c) {
if (C[v]) return;
C[v] = c;
V[c].push_back(v);
for (int i = 1; i <= n; ++i)
if (F[v][i]) f(i, c);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
int k;
cin >> k;
while (k--) {
int a, b;
cin >> a >> b;
F[a][b] = 1;
F[b][a] = 1;
}
cin >> k;
while (k--) {
int a, b;
cin >> a >> b;
D[a][b] = 1;
D[b][a] = 1;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
f(i, i);
int t = V[i].size();
for (int j = 0; j < t; ++j)
for (int l = 0; l < t; ++l)
if (D[V[i][j]][V[i][l]]) goto skip;
ans = max(ans, t);
skip:;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << '\n';
err(++it, args...);
}
const long long mod = 1e9 + 7;
vector<int> par(20001), sz(20001, 1);
int find(int v) {
if (v == par[v]) return v;
return par[v] = find(par[v]);
}
void _union(int a, int b) {
a = find(a);
b = find(b);
if (a != b) {
if (sz[a] > sz[b]) swap(a, b);
par[b] = a;
sz[a] += sz[b];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int k;
cin >> k;
iota(par.begin(), par.end(), 0);
for (__typeof(k) i = (0) - (0 > k); i != (k) - (0 > k);
i += 1 - 2 * (0 > k)) {
int x, y;
cin >> x >> y;
_union(x, y);
}
int m;
cin >> m;
for (__typeof(m) i = (0) - (0 > m); i != (m) - (0 > m);
i += 1 - 2 * (0 > m)) {
int x, y;
cin >> x >> y;
if (find(x) == find(y)) {
sz[find(x)] = 0;
}
}
int ans = 0;
for (__typeof(n + 1) i = (1) - (1 > n + 1); i != (n + 1) - (1 > n + 1);
i += 1 - 2 * (1 > n + 1))
ans = max(ans, sz[find(i)]);
cout << ans << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)(1e5 + 123);
vector<int> gg[MAXN], gb[MAXN];
bool was[MAXN], been[MAXN];
int cnt = 0;
void dfs(int v) {
cnt++;
was[v] = been[v] = true;
for (auto to : gg[v]) {
if (was[to]) continue;
dfs(to);
}
}
int main() {
int n;
cin >> n;
int good;
cin >> good;
for (int i = 1; i <= good; i++) {
int a, b;
cin >> a >> b;
gg[a].push_back(b);
gg[b].push_back(a);
}
int bad;
cin >> bad;
for (int i = 1; i <= bad; i++) {
int a, b;
cin >> a >> b;
gb[a].push_back(b);
gb[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (was[i]) continue;
cnt = 0;
dfs(i);
bool no = false;
for (int j = 1; j <= n; j++) {
if (been[j]) {
for (auto to : gb[j])
if (been[to]) {
no = true;
break;
}
}
if (no) break;
}
if (!no) ans = max(ans, cnt);
for (int j = 1; j <= n; j++) been[j] = false;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
from sys import stdin, stdout
def find(node):
x = []
while dsu[node] > 0:
x.append(node)
node = dsu[node]
for i in x:
dsu[i] = node
return node
def union(node1, node2):
if node1 != node2:
if dsu[node1] > dsu[node2]:
node1, node2 = node2, node1
dsu[node1] += dsu[node2]
dsu[node2] = node1
n = int(stdin.readline().strip())
dsu = [-1]*(n+1)
m = int(stdin.readline().strip())
for __ in range(m):
a, b = map(int, stdin.readline().strip().split())
union(find(a), find(b))
k = int(stdin.readline().strip())
for __ in range(k):
a, b = map(int, stdin.readline().strip().split())
p_a = find(a)
p_b = find(b)
if p_a == p_b:
dsu[p_a] = 0
maxm = 0
for i in range(1, n+1):
if dsu[i] < 0:
maxm = max(maxm, abs(dsu[i]))
stdout.write(f'{maxm}')
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int p[120000], size[120000], br[120000], is[120000];
void make(int x) {
size[x] = 1;
p[x] = x;
}
int find(int x) {
if (x == p[x]) return x;
return p[x] = find(p[x]);
}
void uni(int x, int y) {
x = find(x);
y = find(y);
if (x != y) {
if (x < y) swap(x, y);
p[y] = x;
size[x] += size[y];
}
}
int main() {
int x, y, n, m, k, i, j;
cin >> n >> m;
for (i = 0; i < n; i++) make(i);
for (i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
uni(x, y);
}
cin >> k;
for (i = 0; i < k; i++) {
cin >> x >> y;
x--;
y--;
j = find(x);
if (j == find(y)) br[j] = 1;
}
int mx = 0;
for (i = 0; i < n; i++) {
j = find(i);
is[j] = 1;
}
for (i = 0; i < n; i++)
if (size[i] > mx && br[i] == 0 && is[i]) {
mx = size[i];
}
cout << mx << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct dsu {
int n;
int m;
int idx;
vector<int> e;
vector<int> root_hash;
vector<int> idx_hash;
dsu(int n_) : n(n_) {
m = n;
idx = 0;
e.resize(n, -1);
root_hash.resize(n, -1);
idx_hash.resize(n, -1);
}
int size(int first) { return -e[find(first)]; }
int find(int first) {
return e[first] < 0 ? first : e[first] = find(e[first]);
}
bool join(int a, int b) {
a = find(a);
b = find(b);
if (a == b) {
return false;
}
if (e[a] > e[b]) {
swap(a, b);
}
e[a] += e[b];
e[b] = a;
m--;
return true;
}
int get_root(int ix) {
assert(0 <= ix && ix < n);
assert(root_hash[ix] != -1);
return root_hash[ix];
}
int get_idx(int root) {
assert(0 <= root && root < n);
if (idx_hash[root] == -1) {
idx_hash[root] = idx;
root_hash[idx] = root;
idx++;
}
return idx_hash[root];
}
vector<vector<int>> groups() {
vector<vector<int>> ret(m);
for (int i = 0; i < n; i++) {
int root = find(i);
ret[get_idx(root)].push_back(i);
}
return ret;
}
};
void solve() {
int n;
cin >> n;
int m;
cin >> m;
dsu ds(n);
for (int i = 0; i < m; i++) {
int first, second;
cin >> first >> second;
first--, second--;
ds.join(first, second);
}
(void)ds.groups();
vector<int> g(n);
for (int i = 0; i < n; i++) {
g[i] = ds.find(i);
}
vector<int> invite(ds.m, 1);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int first, second;
cin >> first >> second;
first--, second--;
int rx = ds.find(first);
int ry = ds.find(second);
if (rx == ry) {
invite[ds.get_idx(rx)] = 0;
}
}
int ans = 0;
for (int i = 0; i < ds.m; i++) {
if (invite[i]) {
ans = max(ans, ds.size(ds.get_root(i)));
}
};
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int p[N], n, k, m, r[N];
int find(int x) {
if (x != p[x]) p[x] = find(p[x]);
return p[x];
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= k; i++) {
int a, b;
scanf("%d %d", &a, &b);
p[find(a)] = find(b);
}
unordered_set<int> S;
cin >> m;
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (find(a) == find(b)) S.insert(find(a));
}
for (int i = 1; i <= n; i++) {
if (!S.count(find(i))) r[find(i)]++;
}
int res = 0;
for (int i = 1; i <= n; i++) {
res = max(res, r[i]);
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> arr[2001], enemy[2001], ele;
bool vis[2001];
void dfs(int node) {
vis[node] = true;
ele.push_back(node);
for (int child : arr[node]) {
if (!vis[child]) {
dfs(child);
}
}
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, m, a, b;
cin >> n >> k;
while (k--) {
cin >> a >> b;
arr[a].push_back(b);
arr[b].push_back(a);
}
cin >> m;
while (m--) {
cin >> a >> b;
enemy[a].push_back(b);
enemy[b].push_back(a);
}
int res = 0;
bool flag;
for (int i = 1; i < n + 1; i++) {
if (!vis[i]) {
ele.clear();
flag = true;
dfs(i);
for (int per : ele) {
for (int ene : enemy[per]) {
for (int fri : ele) {
if (ene == fri) {
flag = false;
break;
}
if (!flag) {
break;
}
}
if (!flag) {
break;
}
}
}
if (flag) {
res = max(res, int(ele.size()));
}
}
}
cout << res;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int mas[4000][4000] = {0}, i, j, vers[4000] = {0}, n, k, m, u, v, ans = 0, sum,
b;
void dfs(int ver) {
for (int fi = 1; fi <= n; ++fi)
if (mas[ver][fi] == 1 && vers[fi] == 0) {
vers[fi] = 1;
dfs(fi);
} else if (mas[ver][fi] == -1 && vers[fi] == 1)
b = 0;
}
int main() {
cin >> n >> k;
for (i = 0; i < k; ++i) {
cin >> u >> v;
mas[u][v] = mas[v][u] = 1;
}
cin >> m;
for (i = 0; i < m; ++i) {
cin >> u >> v;
mas[u][v] = mas[v][u] = -1;
}
for (i = 1; i <= n; ++i) {
for (j = 1; j <= n; ++j) vers[j] = 0;
b = 1;
vers[i] = 1;
dfs(i);
sum = 0;
if (b == 1) {
for (j = 1; j <= n; ++j)
if (vers[j] == 1) ++sum;
if (ans < sum) ans = sum;
}
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 2e9;
const int maxn = 2e3 + 4;
vector<int> edge1[maxn];
vector<int> edge2[maxn];
int vis[maxn];
vector<int> cc;
int now;
void dfs(int u) {
vis[u] = now;
cc.push_back(u);
for (int i = 0; i < edge1[u].size(); i++) {
int v = edge1[u][i];
if (!vis[v]) dfs(v);
}
}
bool check(int u) {
for (int i = 0; i < edge2[u].size(); i++) {
int v = edge2[u][i];
if (vis[v] == now) return false;
}
return true;
}
int ans;
int main() {
int n;
cin >> n;
int k;
cin >> k;
for (int i = 0; i < k; i++) {
int u, v;
cin >> u >> v;
edge1[u].push_back(v);
edge1[v].push_back(u);
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
edge2[u].push_back(v);
edge2[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
now++;
cc.clear();
dfs(i);
bool flag = true;
for (int j = 0; j < cc.size(); j++) {
if (check(cc[j]) == false) {
flag = false;
break;
}
}
if (flag) ans = max(ans, (int)cc.size());
}
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, m, parent[2005], num[2005];
int largest = 0;
int find(int i) {
if (parent[i] == i) return i;
return parent[i] = find(parent[i]);
}
void Union(int x, int y) {
int xset = find(x);
int yset = find(y);
parent[xset] = yset;
}
void disjoin(int x, int y) {
int local = find(x);
if (local == find(y)) parent[local] = 0;
}
int main() {
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
};
for (int i = 0; i < 2005; i++) parent[i] = i;
memset(num, 0, sizeof(num));
cin >> n >> k;
int x, y;
for (int i = 0; i < k; i++) {
cin >> x >> y;
Union(x, y);
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
disjoin(x, y);
}
for (int i = 1; i <= n; i++) {
int local = find(i);
num[local]++;
if (local != 0 && num[local] > largest) largest = num[local];
}
cout << largest << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[2003];
set<int> s[2003], temp;
int ans[2003];
bool vis[2003];
int cnt = 0;
void dfs(int x) {
temp.insert(x);
vis[x] = 1;
cnt++;
for (int i = 0; i < v[x].size(); i++) {
if (!vis[v[x][i]]) dfs(v[x][i]);
}
}
int main() {
int bla = 0;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
int k;
cin >> k;
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
s[a].insert(b);
s[b].insert(a);
}
for (int i = 1; i <= n; i++) {
if (ans[i] == 0) {
temp.clear();
cnt = 0;
dfs(i);
for (auto nx : temp) {
for (auto nx1 : s[nx]) {
if (temp.find(nx1) != temp.end()) {
cnt = -1;
break;
}
}
if (cnt == -1) break;
}
for (auto nx : temp) {
ans[nx] = cnt;
}
bla = max(bla, cnt);
}
if (ans[i] == 0) ans[i] = 1;
bla = max(bla, ans[i]);
}
cout << bla << endl;
}
| 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() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
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;
bad_Relation[v][u] = 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;
const int N = 1e5 + 5, inf = 1e9 + 7;
int siz[N], par[N];
int _find(int x) {
if (x == par[x]) return x;
return par[x] = _find(par[x]);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) siz[i] = 1, par[i] = i;
while (m--) {
int u, v;
cin >> u >> v;
int p = _find(u);
int q = _find(v);
if (p == q) continue;
par[p] = q;
siz[q] += siz[p];
}
cin >> m;
while (m--) {
int u, v;
cin >> u >> v;
int p = _find(u);
int q = _find(v);
if (p != q) continue;
siz[q] = 0;
}
int res = 0;
for (int i = 1; i <= n; i++) res = max(res, siz[_find(i)]);
cout << res << "\n";
}
| 9 | CPP |
n = int(input())
num_likes = int(input())
like = [ [] for u in range(n + 1) ]
for i in range(num_likes):
u, v = map(int, input().split())
like[u].append(v)
like[v].append(u)
num_dislikes = int(input())
dislike = [ (n + 1) * [ False ] for u in range(n + 1) ]
for i in range(num_dislikes):
u, v = map(int, input().split())
dislike[u][v] = True
dislike[v][u] = True
result = 0
seen = (n + 1) * [ False ]
for u in range(1, n + 1):
if seen[u]:
continue
seen[u] = True
group = [ u ]
queue = [ u ]
tail = 0
while tail < len(queue):
u = queue[tail]
tail += 1
for v in like[u]:
if seen[v]:
continue
seen[v] = True
group.append(v)
queue.append(v)
okay = True
for i, u in enumerate(group):
for j in range(i + 1, len(group)):
v = group[j]
if dislike[u][v]:
okay = False
break
if not okay:
break
if okay:
result = max(result, len(group))
print(result)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
int prime[1000000 + 5], in;
bool isp[1000000 + 5];
using namespace std;
vector<int> ar[2005], v1, v2;
int vis[6000000];
int flag[2005][2005];
void dfs(int n) {
v1.push_back(n);
vis[n] = 1;
for (int i = 0; i < ar[n].size(); i++) {
if (!vis[ar[n][i]]) {
dfs(ar[n][i]);
}
}
}
int main() {
int n;
while (cin >> n) {
memset(vis, 0, sizeof(ar));
memset(flag, 0, sizeof(flag));
for (int i = 0; i < 1000; i++) {
ar[i].clear();
}
v1.clear();
v2.clear();
int k;
cin >> k;
int a, b;
for (int i = 0; i < k; i++) {
cin >> a >> b;
--a;
--b;
ar[a].push_back(b);
ar[b].push_back(a);
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a >> b;
--a;
--b;
flag[a][b] = 1;
flag[b][a] = 1;
}
int flu = 0, mx = 0;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
v1.clear();
dfs(i);
flu = 1;
for (int j = 0; j < v1.size() && flu; j++) {
for (int l = j + 1; l < v1.size() && flu; l++) {
if (flag[v1[j]][v1[l]]) flu = 0;
}
}
if (flu) mx = max(mx, (int)v1.size());
}
}
cout << mx << endl;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> e[2000];
int x[2000];
int c[2000];
void dfs(int from, int k) {
if (x[from] == 0) {
++c[k];
x[from] = k;
for (int i = 0; i < e[from].size(); ++i) dfs(e[from][i], k);
}
}
int main() {
int n;
cin >> n;
int m;
cin >> m;
while (m--) {
int a, b;
cin >> a >> b;
--a;
--b;
e[a].push_back(b);
e[b].push_back(a);
}
int k = 1;
for (int i = 0; i < n; ++i)
if (x[i] == 0) dfs(i, k++);
set<int> cand;
for (int i = 1; i < k; ++i) cand.insert(i);
cin >> m;
while (m--) {
int a, b;
cin >> a >> b;
--a;
--b;
if (x[a] == x[b]) cand.erase(x[a]);
}
int ans = 0;
for (set<int>::iterator i = cand.begin(); i != cand.end(); ++i) {
ans = max(ans, c[*i]);
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long po(long long a, long long b) {
if (b == 0) return 1;
long long ans = 1;
if (b % 2 == 0) {
ans = po(a, b / 2) % 1000000007;
ans = (ans % 1000000007 * ans % 1000000007) % 1000000007;
} else {
ans = po(a, (b - 1) / 2) % 1000000007;
ans = (ans % 1000000007 * ans % 1000000007 * a) % 1000000007;
}
return ans % 1000000007;
}
vector<string> tokens;
void separate_string(string line) {
stringstream check1(line);
string lav;
while (getline(check1, lav, '*')) {
tokens.push_back(lav);
}
}
vector<long long> divisors;
void get_Divisors(long long n) {
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i) {
divisors.push_back(n / i);
} else {
divisors.push_back(i);
divisors.push_back(n / i);
}
}
}
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
int parent[2002];
int ran[2002];
int findset(int i) {
if (parent[i] == -1) return i;
return parent[i] = findset(parent[i]);
}
void union_set(int x, int y) {
int sx = findset(x);
int sy = findset(y);
if (sx != sy) {
if (ran[sx] < ran[sy]) {
parent[sx] = sy;
ran[sy] = ran[sy] + ran[sx];
ran[sx] = 0;
} else {
parent[sy] = sx;
ran[sx] = ran[sx] + ran[sy];
ran[sy] = 0;
}
}
}
void solve() {
int n, m, i, j, u, v;
cin >> n >> m;
for (i = 0; i < 2002; i++) {
parent[i] = -1;
ran[i] = 1;
}
while (m--) {
cin >> u >> v;
union_set(u, v);
}
int k;
cin >> k;
while (k--) {
cin >> u >> v;
int aa = findset(u);
int bb = findset(v);
if (aa == bb) {
ran[aa] = 0;
}
}
int ma = 0;
for (i = 1; i <= n; i++) {
ma = max(ma, ran[i]);
}
cout << ma;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > graph;
int caninvite[2000];
int visited[2000];
int group[2000];
int qg;
int sz;
bool invalid;
void expand(int v) {
group[v] = qg;
visited[v] = true;
for (int i = 0; i < graph[v].size(); ++i) {
int nv = graph[v][i].first;
int r = graph[v][i].second;
if (r) {
if (!visited[nv]) expand(nv);
} else {
if (group[nv] == qg) {
invalid = true;
}
}
}
++sz;
}
int main() {
memset(visited, 0, sizeof caninvite);
memset(group, -1, sizeof group);
int n;
cin >> n;
graph.assign(n, vector<pair<int, int> >());
int k;
cin >> k;
int a, b;
for (int i = 0; i < k; ++i) {
cin >> a >> b;
--a;
--b;
graph[a].push_back(make_pair(b, 1));
graph[b].push_back(make_pair(a, 1));
}
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> a >> b;
--a;
--b;
graph[a].push_back(make_pair(b, 0));
graph[b].push_back(make_pair(a, 0));
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (!visited[i]) {
sz = 0;
qg = i;
invalid = false;
expand(i);
if (!invalid) ans = max(ans, sz);
}
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
void bfs(vector<vector<int> >& G, vector<int>& CC, vector<bool>& exp, int start,
int cca, map<int, int>& count) {
queue<int> Q;
Q.push(start);
while (not Q.empty()) {
int v = Q.front();
Q.pop();
if (not exp[v]) {
CC[v] = cca;
++count[cca];
exp[v] = true;
for (int i = 0; i < G[v].size(); ++i) Q.push(G[v][i]);
}
}
}
int main() {
int n;
cin >> n;
vector<vector<int> > G(n);
vector<int> CC(n, -1);
vector<bool> exp(n, false);
int m;
cin >> m;
while (m--) {
int u, v;
cin >> u >> v;
G[u - 1].push_back(v - 1);
G[v - 1].push_back(u - 1);
}
int cca = 0;
map<int, int> count;
for (int i = 0; i < n; ++i) {
if (not exp[i]) bfs(G, CC, exp, i, cca, count), ++cca;
}
int p;
cin >> p;
while (p--) {
int odio1, odio2;
cin >> odio1 >> odio2;
if (CC[odio1 - 1] == CC[odio2 - 1]) {
map<int, int>::iterator it = count.find(CC[odio1 - 1]);
if (it != count.end()) count.erase(it);
}
}
int max = 0;
map<int, int>::iterator it = count.begin();
while (it != count.end()) {
if (it->second > max) max = it->second;
++it;
}
cout << max << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3000;
int n, k, m;
vector<int> v[MAXN];
int x, y;
bool u[MAXN][MAXN];
vector<vector<int> > a;
bool vis[MAXN];
int sum;
void dfs(int uu) {
vis[uu] = true;
for (int i = 0; i < (int)(v[uu].size()); i++)
if (!vis[v[uu][i]]) dfs(v[uu][i]);
a.back().push_back(uu);
}
int main() {
cin >> n >> k;
for (int i = 0; i < (int)(k); i++) {
cin >> x >> y;
x--, y--;
v[x].push_back(y);
v[y].push_back(x);
}
cin >> m;
for (int i = 0; i < (int)(m); i++) {
cin >> x >> y;
x--, y--;
u[x][y] = true;
u[y][x] = true;
}
for (int i = 0; i < (int)(n); i++)
if (!vis[i]) {
a.push_back(vector<int>());
dfs(i);
}
for (int i = 0; i < (int)(a.size()); i++) {
bool flag = true;
for (int j = 0; j < (int)(a[i].size()); j++) {
for (int l = j + 1; l < a[i].size(); l++) {
if (u[a[i][j]][a[i][l]]) {
flag = false;
break;
}
}
if (!flag) break;
}
if (flag) sum = max(sum, (int)a[i].size());
}
cout << sum << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec(2002);
int findind(int i);
int main() {
int i, j, k, n, m, a, b, c;
cin >> n;
vector<int> res(n + 1, 0);
vector<int> incl(n + 1, 1);
for (i = 1; i <= n; i++) vec[i] = i;
cin >> k;
for (i = 0; i < k; i++) {
cin >> a >> b;
vec[findind(a)] = findind(b);
}
cin >> m;
for (i = 0; i < m; i++) {
cin >> a >> b;
if (findind(a) == findind(b)) {
incl[findind(a)] = 0;
}
}
for (i = 1; i <= n; i++) {
if (incl[findind(i)] == 1) res[findind(i)]++;
}
m = 0;
for (i = 1; i <= n; i++) {
m = max(m, res[i]);
}
cout << m << "\n";
return 0;
}
int findind(int i) {
if (i == vec[i])
return i;
else
return findind(vec[i]);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > G[2002];
int vis[2002];
void go(int i, int col) {
vis[i] = col;
for (int j = 0; j < G[i].size(); j++) {
int v = G[i][j].first;
int w = G[i][j].second;
if (w == 1) {
if (vis[v] != 3) go(v, col);
}
}
return;
}
int flag = 0;
void dfs(int i, int col) {
if (flag == 1) {
return;
}
if (vis[i] == 3) {
return;
}
if (vis[i] == 0) {
vis[i] = col;
} else {
if (vis[i] != col) {
go(i, 3);
flag = 1;
return;
} else {
return;
}
}
if (col == 1) {
for (int j = 0; j < G[i].size(); j++) {
int v = G[i][j].first;
int w = G[i][j].second;
if (w == 1) {
dfs(v, 1);
} else {
dfs(v, 2);
}
}
} else {
for (int j = 0; j < G[i].size(); j++) {
int v = G[i][j].first;
int w = G[i][j].second;
if (w == 1) {
dfs(v, 2);
}
}
}
}
int main() {
int n, k, m;
cin >> n;
cin >> k;
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(make_pair(b, 1));
G[b].push_back(make_pair(a, 1));
}
cin >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(make_pair(b, 2));
G[b].push_back(make_pair(a, 2));
}
int mx = 0;
for (int i = 1; i <= n; i++) {
flag = 0;
if (vis[i] == 0) {
dfs(i, 1);
if (flag == 0) {
int cnt = 0;
for (int j = 1; j <= n; j++) {
if (vis[j] == 1) {
vis[j] = 3;
cnt++;
} else if (vis[j] == 2) {
vis[j] = 0;
}
}
mx = max(mx, cnt);
}
}
}
cout << mx << "\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const long long INF64 = (long long)1e18;
const long double eps = 1e-9;
const long double pi = 3.14159265358979323846;
bool ineedoutputfile = false;
vector<int> g[2002];
int used[2002];
void dfs(int s, int cnt) {
used[s] = cnt;
for (int i = 0; i < int(g[s].size()); ++i)
if (!used[g[s][i]]) dfs(g[s][i], cnt);
}
int main() {
int n, t1, t2, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < int(k); ++i) {
scanf("%d %d", &t1, &t2);
t1--, t2--;
g[t1].push_back(t2);
g[t2].push_back(t1);
}
scanf("%d", &k);
int cnt = 1;
for (int i = 0; i < int(n); ++i)
if (!used[i]) dfs(i, cnt), cnt++;
bool ok[2002];
memset(ok, true, sizeof(ok));
for (int i = 0; i < int(k); ++i) {
scanf("%d %d", &t1, &t2);
t1--, t2--;
if (used[t1] != used[t2]) continue;
if (used[t1] == used[t2]) ok[used[t1]] = false;
}
int ans = 0;
for (int i = int(1); i <= int(cnt - 1); ++i) {
if (ok[i]) {
int res = 0;
for (int j = 0; j < int(n); ++j)
if (used[j] == i) res++;
ans = max(ans, res);
}
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> adj[N], dislikes[N];
int vis[N];
set<int> temp;
int mx = 0;
int vid = 1;
int ans = 0;
void DFS(int u) {
vis[u] = vid;
for (int i : adj[u])
if (!vis[i]) DFS(i), temp.insert(i);
}
int main() {
int n;
scanf("%d", &n);
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
dislikes[u].push_back(v);
dislikes[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
int cnt = 0;
if (!vis[i]) {
temp.insert(i);
DFS(i);
cnt = temp.size();
for (auto it = temp.begin(); it != temp.end(); it++) {
for (auto it1 = it; it1 != temp.end(); it1++) {
auto found = find(dislikes[*it].begin(), dislikes[*it].end(), *it1);
if (found != dislikes[*it].end()) {
cnt = 0;
break;
}
}
if (!cnt) break;
}
}
ans = max(ans, cnt);
temp.clear();
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int len(const T &c) {
return (int)c.size();
}
template <class T>
void cmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void cmax(T &a, T b) {
if (b > a) a = b;
}
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 groupId[2001];
vector<int> FGr[2001];
int grSize[2001];
vector<pair<int, int> > EN;
int dfs(int n, int grid) {
groupId[n] = grid;
for (int i = 0; i < FGr[n].size(); i++) {
if (groupId[FGr[n][i]] == -1) {
dfs(FGr[n][i], grid);
}
}
return 0;
}
int main() {
memset(groupId, -1, sizeof(groupId));
int n;
scanf("%d", &n);
int f;
scanf("%d", &f);
for (int i = 0; i < f; i++) {
int from, to;
scanf("%d %d", &from, &to);
--from;
--to;
FGr[from].push_back(to);
FGr[to].push_back(from);
}
int grid = -1;
for (int i = 0; i < n; i++) {
if (groupId[i] == -1) dfs(i, ++grid);
}
for (int i = 0; i < n; i++) {
grSize[groupId[i]]++;
}
++grid;
vector<bool> FailedGroup(grid, false);
int e;
scanf("%d", &e);
for (int i = 0; i < e; i++) {
int from, to;
scanf("%d %d", &from, &to);
--from;
--to;
if (groupId[from] == groupId[to]) {
FailedGroup[groupId[from]] = true;
}
}
int maxS = 0;
for (int i = 0; i < grid; i++) {
if (!FailedGroup[i]) maxS = max(maxS, grSize[i]);
}
printf("%d\n", maxS);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long hell = 1e9 + 7;
long long inf = 1e18;
const long long N = 1e5 + 9;
bool prime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
long long power(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
set<long long> adj[N], jkl[N];
long long parent[N];
long long f[N];
void initial() {
for (long long i = 0; i < N; i++) {
parent[i] = i;
adj[i].insert(i);
}
}
long long find(long long u) {
if (u == parent[u]) return u;
return find(parent[u]);
}
void union_(long long u, long long v) {
long long u_rep = find(u);
long long v_rep = find(v);
if (u_rep == v_rep) return;
if (adj[u_rep].size() >= adj[v_rep].size()) {
for (auto x : adj[v_rep]) adj[u_rep].insert(x);
adj[v_rep].clear();
parent[v_rep] = u_rep;
} else {
for (auto x : adj[u_rep]) adj[v_rep].insert(x);
adj[u_rep].clear();
parent[u_rep] = v_rep;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
initial();
long long n;
cin >> n;
vector<pair<long long, long long>> v;
long long m;
cin >> m;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
jkl[x].insert(y);
jkl[y].insert(x);
union_(x, y);
}
cin >> m;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
long long x_rep = find(x);
long long y_rep = find(y);
if (x_rep == y_rep) {
for (auto u : jkl[y]) {
if (jkl[x].lower_bound(u) != jkl[x].end()) adj[x_rep].clear();
}
if (adj[x_rep].size()) {
adj[x_rep].erase(y);
adj[y_rep].erase(x);
}
}
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans = max(ans, (long long)adj[i].size());
}
cout << ans;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
long long binpow(long long base, long long exp, int mod) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % mod;
exp = exp >> 1;
base = (base * base) % mod;
}
return res;
}
long long mod(long long x) {
return ((x % 1000000007LL + 1000000007LL) % 1000000007LL);
}
long long add(long long a, long long b) { return mod(mod(a) + mod(b)); }
long long mul(long long a, long long b) { return mod(mod(a) * mod(b)); }
bool isPrime(int n) {
if (n <= 1) return false;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
long long int n, k, m;
vector<bool> vis;
vector<long long int> friends;
vector<pair<long long int, vector<long long int>>> groups;
vector<pair<long long int, long long int>> enemy;
unordered_map<long long int, vector<long long int>> adj;
bool mysort(pair<long long int, vector<long long int>>& a,
pair<long long int, vector<long long int>>& b) {
if (a.first > b.first) {
return true;
} else {
return false;
}
}
long long int connected_nodes = 0;
void dfs(int x) {
vis[x] = true;
connected_nodes++;
friends.push_back(x);
for (auto u : adj[x]) {
if (vis[u] == false) {
dfs(u);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
cin >> k;
vis.resize(n + 1, false);
for (long long int i = 1; i <= k; i++) {
long long int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
cin >> m;
for (long long int i = 1; i <= m; i++) {
long long int a, b;
cin >> a >> b;
enemy.push_back({a, b});
}
for (int i = 1; i <= n; i++) {
friends.clear();
if (vis[i] == false) {
connected_nodes = 0;
dfs(i);
groups.push_back({connected_nodes, friends});
}
}
sort(groups.begin(), groups.end(), mysort);
for (auto x : groups) {
long long int count = 0;
vector<long long int> now = x.second;
for (auto y : enemy) {
long long int a = y.first;
long long int b = y.second;
if (find(now.begin(), now.end(), a) != now.end() &&
find(now.begin(), now.end(), b) != now.end()) {
count++;
}
}
if (count == 0) {
cout << x.first;
return 0;
}
}
cout << 0;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int parent[2000 + 342];
int sizze[2000 + 342];
bool possible[2000 + 342];
void init(int n) {
for (int i = 1; i <= n; i++) {
parent[i] = i;
sizze[i] = 1;
possible[i] = true;
}
}
int root(int x) {
while (parent[x] != x) {
parent[x] = parent[parent[x]];
x = parent[x];
}
return x;
}
void uni(int a, int b) {
int ra, rb;
ra = root(a);
rb = root(b);
if (ra == rb) return;
if (sizze[ra] < sizze[rb]) {
parent[ra] = rb;
sizze[rb] += sizze[ra];
} else {
parent[rb] = ra;
sizze[ra] += sizze[rb];
}
}
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n;
init(n);
cin >> k;
int x, y;
while (k--) {
cin >> x >> y;
uni(x, y);
}
cin >> k;
while (k--) {
cin >> x >> y;
x = root(x);
y = root(y);
if (x == y) {
possible[x] = false;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (possible[i]) {
if (parent[i] == i) {
ans = max(ans, sizze[i]);
}
}
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long parent[10000];
long long find(long long x) {
if (parent[parent[x]] == parent[x]) return parent[x];
return parent[x] = find(parent[x]);
}
void unite(long long x, long long y) {
long long px = find(x);
long long py = find(y);
if (px != py) parent[py] = px;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
for (int i = 0; i < n + 1; i++) parent[i] = i;
for (int i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
unite(x, y);
}
long long k;
cin >> k;
set<long long> s;
for (int i = 0; i < k; i++) {
long long x, y;
cin >> x >> y;
long long px = find(x);
long long py = find(y);
if (px == py) s.insert(px);
}
map<long long, long long> ma;
for (int i = 1; i <= n; i++) {
long long pi = find(i);
if (ma.find(pi) == ma.end())
ma[pi] = 1;
else
ma[pi]++;
}
long long ans = 0;
for (auto it : ma) {
long long x, y;
x = it.first;
y = it.second;
if (s.find(x) == s.end()) ans = max(ans, y);
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int f[2002], num[2002];
void init() {
for (int i = 1; i <= n; ++i) {
f[i] = i;
num[i] = 1;
}
}
int getroot(int x) { return x == f[x] ? x : f[x] = getroot(f[x]); }
void unions(int x, int y) {
x = getroot(x);
y = getroot(y);
if (x == y) return;
if (num[x] > num[y]) {
num[f[y] = x] += num[y];
num[y] = 0;
} else {
num[f[x] = y] += num[x];
num[x] = 0;
}
}
int main() {
ios::sync_with_stdio(false);
int mmin = 0, x, y, m;
cin >> n >> m;
init();
for (int i = 0; i < m; ++i) {
cin >> x >> y;
unions(x, y);
}
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
if (getroot(x) == getroot(y)) num[getroot(x)] = 0;
}
for (int i = 1; i <= n; ++i) {
mmin = max(mmin, num[i]);
}
cout << mmin << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> graph(2002);
bool visit[2002];
unordered_set<long long> us;
void dfs(long long n) {
if (visit[n] == true) return;
us.insert(n);
visit[n] = true;
for (auto u : graph[n]) dfs(u);
}
int main() {
memset(visit, sizeof(visit), false);
long long n, m;
cin >> n;
cin >> m;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
long long k;
cin >> k;
vector<pair<long long, long long>> vct(k);
for (long long i = 0; i < k; i++) cin >> vct[i].first >> vct[i].second;
if (n == 0) {
cout << "0" << endl;
exit(0);
}
long long max = 0;
for (long long i = 1; i <= m; i++) {
us.clear();
bool condition = true;
if (visit[i] == false) dfs(i);
for (long long i = 0; i < k; i++) {
if (us.find(vct[i].first) != us.end() &&
us.find(vct[i].second) != us.end()) {
condition = false;
break;
} else
condition == true;
}
if (condition == true) {
if (us.size() > max) max = us.size();
}
}
bool cond = true;
for (long long i = 1; i <= n; i++) {
if (visit[i] == false) cond = false;
}
if (cond == false && max == 0)
cout << 1 << endl;
else
cout << max << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> parent(1000001);
map<long long int, long long int> urank;
void create(long long int x) {
parent[x] = x;
urank[x] = 0;
}
long long int find(long long int x) {
if (parent[x] != x) {
parent[x] = find(parent[x]);
}
return parent[x];
}
void merge(long long int x, long long int y) {
long long int xroot = find(x);
long long int yroot = find(y);
if (urank[xroot] <= urank[yroot]) {
parent[xroot] = yroot;
urank[yroot] = urank[yroot] + urank[xroot];
} else {
parent[yroot] = xroot;
urank[xroot] = urank[xroot] + urank[yroot];
}
}
void solve() {
long long int n, m1, m2;
cin >> n >> m1;
for (long long int i = 1; i < n + 1; i++) create(i);
for (long long int i = 0; i < m1; i++) {
long long int a, b;
cin >> a >> b;
if (find(a) != find(b)) merge(a, b);
}
map<long long int, long long int> m;
for (long long int i = 1; i < n + 1; i++) {
m[find(i)]++;
}
cin >> m2;
for (long long int i = 0; i < m2; i++) {
long long int a, b;
cin >> a >> b;
long long int root1 = find(a);
long long int root2 = find(b);
if (root1 == root2) m.erase(root1);
}
map<long long int, long long int>::iterator it;
long long int max = 0;
for (it = m.begin(); it != m.end(); it++) {
if (it->second > max) max = it->second;
}
cout << max;
}
signed main() {
std::ios::sync_with_stdio(false);
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
solve();
return 0;
}
const int maxV = 2000;
const int maxE = 2000 * (2000 - 1) / 2;
int terminal1[maxE + 1];
int terminal2[maxE + 1];
int head[maxV + 1];
int next_el[maxE + 1];
int k = 0;
void add(int u, int v, int t) {
k++;
terminal1[k] = v;
terminal2[k] = t;
next_el[k] = head[u];
head[u] = k;
}
int dest[maxV + 1];
set<int> mn[maxV + 1];
int kol_mn = 0;
void DFS(int v) {
dest[v] = 1;
mn[kol_mn].insert(v);
int i = head[v];
while (i > 0) {
v = terminal1[i];
if (terminal2[i] && dest[v] == 0) {
DFS(v);
}
i = next_el[i];
}
}
int dest1[maxV + 1];
int BFS(int v, int mn_kol) {
queue<int> och;
och.push(v);
dest[v] = 1;
int i;
while (!och.empty()) {
v = och.front();
och.pop();
i = head[v];
while (i > 0) {
v = terminal1[i];
if (dest1[v] == 0 && terminal2[i] == 1) {
och.push(v);
dest1[v] = 1;
} else {
if (terminal2[i] == 0 && mn[mn_kol].find(v) != mn[mn_kol].end()) {
break;
}
}
i = next_el[i];
}
if (i) {
break;
}
}
if (!och.empty()) {
return 0;
} else {
return 1;
}
}
void solve() {
memset(dest, 0, sizeof(dest));
memset(dest1, 0, sizeof(dest1));
int n, K, m;
scanf("%d %d", &n, &K);
int u, v;
for (int i = 0; i < K; i++) {
scanf("%d %d", &u, &v);
add(u, v, 1);
add(v, u, 1);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
add(u, v, 0);
add(v, u, 0);
}
int max_size = 0;
for (int i = 1; i <= n; i++) {
if (dest[i] == 0) {
DFS(i);
if (BFS(*mn[kol_mn].begin(), kol_mn)) {
if (max_size < mn[kol_mn].size()) {
max_size = mn[kol_mn].size();
}
}
kol_mn++;
}
}
cout << max_size;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int par[2010], notinvited[2010];
int root(int i) { return par[i] < 0 ? i : (par[i] = root(par[i])); }
void merge(int x, int y) {
if ((x = root(x)) == (y = root(y))) return;
if (par[y] < par[x]) swap(x, y);
par[x] += par[y];
par[y] = x;
}
int main() {
int n, k, m, x, y;
cin >> n >> k;
for (int i = 0; i <= n; ++i) par[i] = -1;
for (int i = 0; i < k; ++i) {
cin >> x >> y;
merge(x, y);
}
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
if ((x = root(x)) == (y = root(y))) notinvited[x] = 1;
}
int cnt = 0;
for (int i = 1; i <= n; ++i)
if (par[i] < 0 && notinvited[i] == 0) cnt = max(cnt, -par[i]);
cout << cnt << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
unordered_map<int, vector<int> > g;
map<pair<int, int>, int> li;
unordered_map<int, bool> visited, dislikevisited;
int bfs(int i) {
queue<int> q;
visited[i] = true;
q.push(i);
int c = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto v : g[u]) {
if (li[{u, v}] == 1 && dislikevisited[u] == true) return 0;
if (li[{u, v}] == -1) {
dislikevisited[v] = true;
}
if (li[{u, v}] == 1 && !visited[v]) {
visited[v] = true;
++c;
q.push(v);
}
}
}
return c;
}
int dfs(int n) {
int i, j, c, m = 0, f;
for (i = 1; i <= n; ++i) {
if (!visited[i]) {
dislikevisited.clear();
c = 0;
f = 0;
c = bfs(i);
m = max(m, c);
}
}
return m;
}
int main() {
int n;
cin >> n;
int i, j, u, v, k, m;
cin >> k;
for (i = 1; i <= k; ++i) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
li[{u, v}] = li[{v, u}] = 1;
}
cin >> m;
for (i = 1; i <= m; ++i) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
li[{u, v}] = li[{v, u}] = -1;
}
int ans = dfs(n);
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> like[2010];
bool dislike[2010][2010], visted[2010];
void DFS(int x, int father, vector<int>& friends) {
friends.push_back(x);
visted[x] = true;
for (int i = 0; i < like[x].size(); ++i) {
if (like[x][i] != father && !visted[like[x][i]]) {
DFS(like[x][i], x, friends);
}
}
}
int check(int x) {
vector<int> friends;
DFS(x, -1, friends);
for (int i = 0; i < friends.size(); ++i) {
for (int j = 0; j < friends.size(); ++j) {
if (dislike[friends[i]][friends[j]]) {
return 0;
}
}
}
return friends.size();
}
int main() {
int n;
while (cin >> n) {
int k, m, x, y;
cin >> k;
for (int i = 0; i < k; ++i) {
cin >> x >> y;
like[x].push_back(y), like[y].push_back(x);
}
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
dislike[x][y] = dislike[y][x] = true;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (!visted[i]) {
ans = max(ans, check(i));
}
}
cout << ans << endl;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int parent[2100], invalid[2100], vis[2100];
std::vector<int> comp[2100], adj[2100];
void dfs(int v, int index) {
if (vis[v]) return;
vis[v] = 1;
comp[index].push_back(v);
parent[v] = index;
for (int i = 0; i < adj[v].size(); i++) {
dfs(adj[v][i], index);
}
}
int main() {
int n, i, m, index, temp1, temp2, ans = 0;
scanf("%d", &n);
int k;
scanf("%d", &k);
for (i = 0; i < k; i++) {
scanf("%d", &temp1);
scanf("%d", &temp2);
adj[temp1].push_back(temp2);
adj[temp2].push_back(temp1);
}
scanf("%d", &m);
index = 0;
for (i = 1; i <= n; i++) {
if (!vis[i]) dfs(i, index++);
}
for (i = 0; i < m; i++) {
scanf("%d", &temp1);
scanf("%d", &temp2);
if (parent[temp1] == parent[temp2]) invalid[parent[temp1]] = 1;
}
for (i = 0; i < index; i++) {
if (!invalid[i]) ans = max(ans, (int)comp[i].size());
}
printf("%d\n", ans);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int parent[(long long int)(1e6)], s[(long long int)(1e6)];
int findroot(int x) {
if (x == parent[x]) return x;
return parent[x] = findroot(parent[x]);
}
void initial(int n = (long long int)(1e6) - 1) {
for (int i = 1; i <= n; i++) {
parent[i] = i;
s[i] = 1;
}
}
void make_union(int a, int b) {
a = findroot(a);
b = findroot(b);
if (a != b) {
if (s[a] < s[b]) swap(a, b);
parent[b] = a;
s[a] += s[b];
}
}
void solve() {
int n, k, m, ans = 0;
cin >> n >> k;
vector<bool> eligible(n + 1, 1);
initial(n + 1);
while (k--) {
int u, v;
cin >> u >> v;
make_union(u, v);
}
cin >> m;
while (m--) {
int u, v;
cin >> u >> v;
if (findroot(u) == findroot(v)) {
eligible[parent[u]] = 0;
}
}
for (int i = 1; i <= n; i++) {
ans =
eligible[findroot(i)] ? (ans > s[parent[i]] ? ans : s[parent[i]]) : ans;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 9 | CPP |
class DSNode:
def __init__(self, val):
self.val = val
self.rank = 0
self.parent = self
self.correct = True
def __str__(self):
return str(self.find().val)
def find(self):
x = self
if x != x.parent:
x.parent = x.parent.find()
return x.parent
def union(x, y):
x = x.find()
y = y.find()
if x == y:
return
if x.rank > y.rank:
y.parent = x
else:
x.parent = y
if x.rank == y.rank:
y.rank += 1
# Amount of people
n = int(input())
# Pairs of friends
k = int(input())
P = [DSNode(x) for x in range(n+1)]
for i in range(k):
u, v = map(int, input().split(' '))
union(P[u], P[v])
# Pairs of people who dislike each other
m = int(input())
for i in range(m):
u, v = map(int, input().split(' '))
u1, v1 = P[u].find(), P[v].find()
if u1 == v1:
u1.correct = False
max_size = 0
A = [0 for _ in range(n + 1)]
for i in range(1, n+1):
p = P[i]
p = p.find()
if p.correct:
A[p.val] += 1
print(max(A))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int father[2005];
int c[2005];
int N, M;
int sum[2005];
int getfather(int x) {
return father[x] == x ? x : father[x] = getfather(father[x]);
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) father[i] = i;
for (int i = 1; i <= M; i++) {
int a, b;
scanf("%d%d", &a, &b);
a = getfather(a);
b = getfather(b);
if (a != b) father[a] = b;
}
scanf("%d", &M);
for (int i = 1; i <= M; i++) {
int a, b;
scanf("%d%d", &a, &b);
a = getfather(a);
b = getfather(b);
if (a == b) c[a] |= 1;
}
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= N; i++)
if (!c[getfather(i)]) sum[getfather(i)]++;
int ret = 0;
for (int i = 1; i <= N; i++) ret = max(ret, sum[i]);
cout << ret << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:67108864")
using namespace std;
template <class T>
inline T abs(T a) {
return (a) > 0 ? (a) : -(a);
}
template <class T>
inline T sqr(T a) {
return (a) * (a);
}
const long double PI = 3.1415926535897932, EPS = 1E-9;
const int INF = 1000 * 1000 * 1000, NMAX = 100005;
int ans = 0, cur = 0;
int used[NMAX];
vector<pair<int, int> > g[NMAX];
bool fail = false;
int y = 0;
void dfs(int v, int prev) {
if (fail) return;
++cur;
used[v] = y;
for (int i = 0; i < int((g[v]).size()); ++i) {
if (fail) return;
int to = g[v][i].first;
if (to == prev) continue;
int t = g[v][i].second;
if (t == 1) {
if (used[to] == 0) dfs(to, v);
} else {
if (used[to] == y) fail = true;
}
}
}
int main() {
for (int i = 0; i < int(NMAX); ++i) used[i] = 0;
int n, k, m;
scanf("%d%d", &n, &k);
for (int i = 0; i < int(k); ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
g[u].push_back(make_pair(v, 1));
g[v].push_back(make_pair(u, 1));
}
scanf("%d", &m);
for (int i = 0; i < int(m); ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
g[u].push_back(make_pair(v, 2));
g[v].push_back(make_pair(u, 2));
}
for (int i = 0; i < int(n); ++i)
if (used[i] == 0) {
++y;
fail = false;
cur = 0;
dfs(i, i);
if (!fail) ans = max(ans, cur);
}
printf("%d", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, k = 0, t1, t2, m;
cin >> n;
vector<int> c(n);
for (int i = 0; i < n; i++) c[i] = 0;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
if (c[a - 1] == 0 && c[b - 1] == 0) {
k++;
c[a - 1] = k;
c[b - 1] = k;
}
if (c[a - 1] == 0 && c[b - 1] > 0) c[a - 1] = c[b - 1];
if (c[b - 1] == 0 && c[a - 1] > 0) c[b - 1] = c[a - 1];
if (c[b - 1] && c[a - 1] && c[b - 1] != c[a - 1]) {
t1 = max(c[a - 1], c[b - 1]);
t2 = min(c[a - 1], c[b - 1]);
for (int j = 0; j < n; j++) {
if (c[j] == t1) c[j] = t2;
if (c[j] > t1) c[j]--;
}
k--;
}
}
for (int i = 0; i < n; i++) {
if (c[i] == 0) {
k++;
c[i] = k;
}
}
vector<int> numb(k);
for (int i = 0; i < k; i++) numb[i] = 0;
for (int i = 0; i < n; i++) {
numb[c[i] - 1]++;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
if (c[a - 1] == c[b - 1]) numb[c[a - 1] - 1] = 0;
}
sort(numb.begin(), numb.end());
;
cout << numb[k - 1] << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100100];
vector<int> enemies[100100];
bool vis[100100];
set<int> curgroup;
void dfs(int a) {
if (vis[a]) return;
vis[a] = true;
curgroup.insert(a);
for (int i = 0; i < (int)adj[a].size(); i++) {
int b = adj[a][i];
dfs(b);
}
}
int main() {
int n, k, m;
cin >> n;
cin >> k;
while (k--) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
cin >> m;
while (m--) {
int a, b;
cin >> a >> b;
a--;
b--;
enemies[a].push_back(b);
}
int bestsz = 0;
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
curgroup.clear();
dfs(i);
bool ok = true;
for (set<int>::iterator iter = curgroup.begin(); iter != curgroup.end();
iter++) {
int a = *iter;
for (int j = 0; j < (int)enemies[a].size(); j++) {
int b = enemies[a][j];
if (curgroup.count(b)) {
ok = false;
break;
}
}
if (!ok) break;
}
if (ok) bestsz = max(bestsz, (int)curgroup.size());
}
cout << bestsz << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> adj[1000005];
long long vis[1000005];
vector<long long int> a[1000005];
vector<long long int> v[1000005];
long long q[1000005];
long long n, k, m;
long long c = 1;
void dfs(long long i, long long p) {
if (vis[i]) return;
vis[i] = c;
v[p].push_back(i);
for (auto x : adj[i]) {
dfs(x, p);
}
}
void solve() {
cin >> n >> k;
for (long long i = 1; i <= k; i++) {
long long x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
cin >> m;
for (long long i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
long long z = 0;
for (long long i = 1; i <= n; i++) {
dfs(i, i);
for (auto x : v[i]) {
for (auto y : a[x]) {
if (vis[y] == c) {
q[i] = -1;
break;
}
}
if (q[i] == -1) {
break;
}
}
c++;
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
if (q[i] != -1 && v[i].size() > 0) {
long long sz = v[i].size();
ans = max(ans, sz);
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) solve();
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
bitset<2005> used, b;
vector<int> like[2005], dislike[2005];
int n;
int solve(int idx) {
b.reset();
queue<int> q;
q.push(idx);
b.set(idx);
used.set(idx);
int ans = 1;
bool flag = false;
while (!q.empty()) {
int curr = q.front();
q.pop();
for (int i = 0; i < like[curr].size(); i++) {
int u = like[curr][i];
if (b.test(u)) continue;
for (int j = 0; !flag && j < dislike[u].size(); j++) {
int v = dislike[u][j];
if (b.test(v)) flag = true;
}
q.push(u);
b.set(u);
used.set(u);
ans++;
}
}
if (flag) return 0;
return ans;
}
int solve() {
int ans = 0;
used.reset();
for (int i = 1; i <= n; i++) {
if (used.test(i)) continue;
ans = max(ans, solve(i));
}
return ans;
}
int main() {
int k, m, u, v;
scanf("%d", &n);
scanf("%d", &k);
for (int i = 0; i < k; i++) {
scanf("%d%d", &u, &v);
like[u].push_back(v);
like[v].push_back(u);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
dislike[u].push_back(v);
dislike[v].push_back(u);
}
printf("%d\n", solve());
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000;
int p[MAXN], size[MAXN], n, m;
int find_set(int v) { return v == p[v] ? v : p[v] = find_set(p[v]); }
void union_set(int x, int y) {
x = find_set(x);
y = find_set(y);
if (x != y) {
if (size[x] < size[y]) swap(x, y);
p[x] = y;
size[y] += size[x];
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) size[i] = 1, p[i] = i;
while (m--) {
int x, y;
cin >> x >> y;
union_set(x, y);
}
int mx = 0;
cin >> m;
while (m--) {
int x, y;
cin >> x >> y;
if (find_set(x) == find_set(y)) size[find_set(x)] = 0;
}
for (int i = 1; i <= n; i++) {
mx = max(mx, size[find_set(i)]);
}
cout << mx << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2020;
long long par[N], c[N];
long long getpar(int x) {
if (x == par[x]) return x;
return par[x] = getpar(par[x]);
}
bool mrg(int x, int y) {
x = getpar(x);
y = getpar(y);
if (x == y) return 1;
c[x] += c[y];
par[y] = x;
return 1;
}
int main() {
int n, m, x;
cin >> n;
for (int i = 0; i <= n; i++) {
par[i] = i;
c[i] = 1;
}
cin >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if (getpar(x) != getpar(y)) mrg(x, y);
}
cin >> x;
for (int i = 0; i < x; i++) {
int x, y;
cin >> x >> y;
x = getpar(x);
y = getpar(y);
if (getpar(x) == getpar(y)) c[x] = -1;
}
long long ans = 0;
for (int i = 1; i <= n; i++) ans = max(ans, c[getpar(i)]);
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20010;
int father[maxn];
bool Not[maxn];
int cnt[maxn];
void init() {
for (int i = 0; i < maxn; ++i) father[i] = i;
memset(Not, false, sizeof(Not));
memset(cnt, 0, sizeof(cnt));
}
int find(int x) {
if (father[x] != x) father[x] = find(father[x]);
return father[x];
}
void Union(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
father[a] = b;
}
int main() {
int n, k, m;
int u, v;
while (scanf("%d", &n) != EOF) {
init();
scanf("%d", &k);
for (int i = 0; i < k; ++i) {
scanf("%d %d", &u, &v);
Union(u, v);
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%d %d", &u, &v);
if (find(u) == find(v)) {
Not[find(u)] = true;
}
}
int ret = 0;
for (int i = 1; i <= n; ++i) {
if (!Not[find(i)]) cnt[find(i)]++;
}
for (int i = 1; i <= n; ++i) ret = max(ret, cnt[i]);
printf("%d\n", ret);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n = 0;
int **relation;
bool *invited;
int *result_set;
int cur_num = 0;
bool canInvite(int x) {
for (int i = 0; i < cur_num; i++) {
if (relation[x][result_set[i]] == -1) {
return false;
}
}
return true;
}
void fill(bool *filled, int x, bool value) {
invited[x] = value;
filled[x] = true;
for (int i = 0; i < n; i++) {
if (relation[x][i] == 1 && filled[i] == false) {
fill(filled, i, value);
}
}
}
void fillHisFriends(int x, bool value) {
bool *filled;
filled = new bool[n];
for (int i = 0; i < n; i++) {
filled[i] = false;
}
fill(filled, x, value);
}
bool invite(int x) {
if (invited[x] == true) {
return true;
}
if (canInvite(x) == true) {
result_set[cur_num++] = x;
invited[x] = true;
} else {
fillHisFriends(x, true);
cur_num = 0;
return false;
}
for (int i = 0; i < n; i++) {
if (relation[x][i] == 1) {
if (invite(i) == false) {
return false;
}
}
}
return true;
}
int main() {
cin >> n;
invited = new bool[n];
result_set = new int[n];
relation = new int *[n];
for (int i = 0; i < n; i++) {
relation[i] = new int[n];
invited[i] = false;
for (int j = 0; j < n; j++) {
relation[i][j] = 0;
}
}
int likes = 0;
cin >> likes;
for (int i = 0; i < likes; i++) {
int m = 0, n = 0;
cin >> m >> n;
relation[m - 1][n - 1] = 1;
relation[n - 1][m - 1] = 1;
}
int dislikes = 0;
cin >> dislikes;
for (int i = 0; i < dislikes; i++) {
int m = 0, n = 0;
cin >> m >> n;
relation[m - 1][n - 1] = -1;
relation[n - 1][m - 1] = -1;
}
int result = 0;
for (int i = 0; i < n; i++) {
if (invited[i] == false) {
cur_num = 0;
if (invite(i) == true) {
if (cur_num > result) {
result = cur_num;
}
}
}
}
cout << result;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const int N = 100100;
int adj[N], link_[N], head[N], x[N], y[N], n, m, k;
int lab[N], d[N], ans, num, ed, nd;
void dfs(int u) {
lab[u] = num;
d[++nd] = u;
int i = head[u];
while (i) {
int v = adj[i];
if (!lab[v]) dfs(v);
i = link_[i];
}
}
void add(int u, int v) {
link_[++ed] = head[u];
head[u] = ed;
adj[ed] = v;
}
int main() {
int u, v;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
add(u, v);
add(v, u);
}
cin >> k;
for (int i = 1; i <= k; i++) cin >> x[i] >> y[i];
for (int i = 1; i <= n; i++)
if (!lab[i]) {
bool ok = true;
num++;
nd = 0;
dfs(i);
for (int ii = 1; ii <= nd; ii++)
for (int j = 1; j <= k; j++)
if (d[ii] == x[j]) {
if (lab[d[ii]] == lab[y[j]]) ok = false;
} else if (d[ii] == y[j] && lab[d[ii]] == lab[x[j]])
ok = false;
if (ok) ans = max(ans, nd);
}
cout << ans;
}
| 9 | CPP |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.