text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, m, bp, bc;
vector<int> g[100001], p, c;
int b[100001];
bool yaman;
void dfs(int s, int k) {
b[s] = k;
if (k == 1) {
p.push_back(s);
bp++;
} else {
c.push_back(s);
bc++;
}
for (int i = 0; i < g[s].size(); i++) {
if (b[g[s][i]] == 2)
dfs(g[s][i], 1 - k);
else {
if (b[g[s][i]] == b[s]) yaman = true;
}
}
}
int main() {
yaman = false;
bp = bc = 0;
int x, y;
cin >> n >> m;
fill(b, b + 100001, 2);
for (int i = 1; i <= m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (b[i] == 2) dfs(i, 0);
}
if (yaman) {
cout << -1;
return 0;
}
cout << bp << endl;
for (int i = 0; i < p.size(); i++) {
cout << p[i] << " ";
}
cout << endl;
cout << bc << endl;
for (int i = 0; i < c.size(); i++) {
cout << c[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
vector<int> v[100005];
int n, m;
int clr[100005];
bool vis[100005];
bool dfs(int x, int cr) {
vis[x] = true;
clr[x] = cr ^ 1;
for (int i : v[x]) {
if (!vis[i] and dfs(i, clr[x]))
return 1;
else {
if (clr[i] == clr[x]) return 1;
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!vis[i] and dfs(i, 1)) {
cout << -1 << endl;
return 0;
}
}
vector<int> vec[2];
for (int i = 1; i <= n; i++) {
if (vis[i]) vec[clr[i]].push_back(i);
}
for (int i = 1; i >= 0; i--) {
cout << vec[i].size() << endl;
for (int j : vec[i]) cout << j << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100005];
int visited[100005] = {0};
int cv[100005];
int answer = 1;
void cdfs(int root, int prev) {
if (visited[root] == 1) {
if (cv[root] != prev) {
answer = 0;
}
return;
}
visited[root] = 1;
cv[root] = prev;
int i;
for (i = 0; i < v[root].size(); i++) {
cdfs(v[root][i], 1 - prev);
}
}
int power2(int x, unsigned int y) {
int res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
int i;
for (i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 1; i <= n; i++) {
cv[i] = -1;
}
for (i = 1; i <= n; i++) {
if (cv[i] == -1) {
cdfs(i, 0);
}
}
if (answer == 0)
cout << "-1";
else {
int counta = 0;
int countb = 0;
vector<int> va;
vector<int> vb;
for (i = 1; i <= n; i++) {
if (cv[i] == 1) {
counta++;
va.push_back(i);
} else if (cv[i] == 0) {
countb++;
vb.push_back(i);
}
}
cout << counta << "\n";
for (i = 0; i < va.size(); i++) {
cout << va[i] << " ";
}
cout << "\n";
cout << countb << "\n";
for (i = 0; i < vb.size(); i++) {
cout << vb[i] << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, x, y, b, f;
vector<int> A[100001];
int Ax[100001], Ay[100001];
int B[100001];
void fnc(int i, int z) {
if (B[i] != 0) return;
if (z % 2 == 0) {
B[i] = 1;
a++;
Ax[a] = i;
} else {
B[i] = 2;
b++;
Ay[b] = i;
}
for (int jj = 0; jj < A[i].size(); ++jj) {
int d = z + 1;
if (B[i] == B[A[i][jj]]) {
f = 1;
return;
}
fnc(A[i][jj], d);
}
return;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> x >> y;
A[x].push_back(y);
A[y].push_back(x);
}
for (int i = 1; i <= n; ++i) {
if ((B[i] == 0) && (A[i].size() > 0)) {
fnc(i, 0);
}
}
if ((a + b == 0) || (f == 1)) {
cout << -1;
return 0;
}
cout << b << endl;
for (int i = 1; i <= b; ++i) {
cout << Ay[i] << " ";
}
cout << endl;
cout << a << endl;
for (int i = 1; i <= a; ++i) {
cout << Ax[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
vector<int> vc[2];
vector<int> g[100010];
int mark[100010];
bool dfs(int v, int color = 2) {
mark[v] = color;
vc[color - 1].push_back(v);
for (int u : g[v]) {
if (!mark[u] && dfs(u, 3 - color)) return 1;
if (mark[u] != 3 - color) return 1;
}
return 0;
}
int main() {
int n, m;
n = read();
m = read();
for (int i = 0; i < m; i++) {
int u = read() - 1;
int v = read() - 1;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < n; i++)
if (!mark[i]) {
if (g[i].empty()) continue;
if (dfs(i)) {
cout << -1 << endl;
return 0;
}
}
for (int i = 0; i < 2; i++) {
cout << vc[i].size() << endl;
for (int v : vc[i]) cout << v + 1 << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
vector<int> vec[maxn];
vector<int> col(maxn, -1);
vector<bool> vis(maxn);
int ans;
void dfs(int nod, int c) {
if (vec[nod].size() == 0) return;
col[nod] = c;
vis[nod] = true;
for (auto i : vec[nod]) {
if (!vis[i])
dfs(i, 1 - c);
else if (col[i] == c)
ans = 1;
}
}
int main() {
int n, m, k, i;
cin >> n >> m;
while (m--) {
int a, b;
cin >> a >> b;
vec[a].push_back(b);
vec[b].push_back(a);
}
for (i = 1; i <= n; i++) {
if (!vis[i]) dfs(i, 0);
}
if (ans) {
cout << -1;
return 0;
}
vector<int> v1, v2;
for (int i = 1; i <= n; i++)
if (col[i] == 1)
v1.push_back(i);
else if (col[i] == 0)
v2.push_back(i);
cout << v1.size() << "\n";
for (auto i : v1) cout << i << " ";
cout << "\n";
cout << v2.size() << "\n";
for (auto i : v2) cout << i << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
template <typename C>
int sz(const C &c) {
return c.size();
}
using namespace std;
bool dfs(const vector<vector<int>> &g, int u, int n, vector<int> &s) {
bool ok = true;
s[u] = n % 2 + 1;
for (int i = 0; i < sz(g[u]) && ok; ++i) {
if (s[g[u][i]] != 0) {
ok = s[g[u][i]] != s[u];
} else {
ok = dfs(g, g[u][i], n + 1, s);
}
}
return ok;
}
int main() {
iostream::sync_with_stdio(false);
int n;
cin >> n;
int m;
cin >> m;
vector<vector<int>> g(n);
for (int i = 0; i < m; ++i) {
int u;
cin >> u;
int v;
cin >> v;
g[u - 1].push_back(v - 1);
g[v - 1].push_back(u - 1);
}
vector<int> s(n);
bool ok = true;
for (int i = 0; i < n && ok; ++i) {
if (s[i] == 0) {
ok = dfs(g, i, 0, s);
}
}
vector<int> r1;
vector<int> r2;
for (int i = 0; i < sz(s); ++i) {
if (s[i] == 1) {
r1.push_back(i + 1);
} else {
r2.push_back(i + 1);
}
}
if (!ok) {
cout << "-1\n";
} else {
cout << sz(r1) << "\n";
for (auto e : r1) {
cout << e << " ";
}
cout << "\n";
cout << sz(r2) << "\n";
for (auto e : r2) {
cout << e << " ";
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> p[100001];
int dd[100001], d[100001], ans[2], n, m;
void nhap() {
cin >> n >> m;
int u, v;
for (int i = 0; i < m; ++i) {
cin >> u >> v;
p[u].push_back(v);
p[v].push_back(u);
}
}
void danhdau(int u, int o) {
dd[u] = o;
d[u] = 1;
ans[o] += 1;
for (vector<int>::iterator i = p[u].begin(); i != p[u].end(); ++i) {
if (dd[*i] == o) {
cout << -1;
exit(0);
} else if (d[*i] == 0) {
danhdau(*i, o ^ 1);
}
}
}
int main() {
nhap();
ans[0] = ans[1] = 0;
for (int i = 1; i <= n; ++i) dd[i] = 2;
for (int i = 1; i <= n; ++i) {
if (dd[i] == 2) danhdau(i, 0);
}
for (int i = 1; i <= n; ++i) {
if (dd[i] == 0 && p[i].size() == 0)
ans[0] -= 1;
else if (dd[i] == 1 && p[i].size() == 0)
ans[1] -= 1;
}
cout << ans[0] << endl;
for (int i = 1; i <= n; ++i) {
if (dd[i] == 0 && p[i].size() != 0) cout << i << " ";
}
cout << endl;
cout << ans[1] << endl;
for (int i = 1; i <= n; ++i) {
if (dd[i] == 1 && p[i].size() != 0) cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch <= '9' && ch >= '0'; x = x * 10 + ch - 48, ch = getchar())
;
return x;
}
int i, j, k, m, n, x, y, cnt, last[100010], cl[100010], flag, ans;
struct edge {
int to, next;
} e[100010 << 1];
inline void add(int u, int v) {
e[++cnt] = (edge){v, last[u]}, last[u] = cnt;
e[++cnt] = (edge){u, last[v]}, last[v] = cnt;
}
void dfs(int x) {
if (flag) return;
for (int i = last[x]; i; i = e[i].next)
if (cl[e[i].to] == -1)
cl[e[i].to] = cl[x] ^ 1, dfs(e[i].to);
else if (cl[e[i].to] == cl[x]) {
flag = 1;
return;
}
}
int main() {
for (n = read(), m = read(), i = 1; i <= m; ++i) add(read(), read());
memset(cl, -1, sizeof cl);
for (i = 1; i <= n; ++i)
if (!flag && cl[i] == -1 && last[i]) cl[i] = 0, dfs(i);
if (flag)
puts("-1");
else {
for (i = 1; i <= n; ++i)
if (cl[i] == 1) ++ans;
for (printf("%d\n", ans), i = k = 1; i <= n; ++i)
if (cl[i] == 1) printf("%d%c", i, k++ == ans ? '\n' : ' ');
for (ans = 0, i = 1; i <= n; ++i)
if (!cl[i]) ++ans;
for (printf("%d\n", ans), i = k = 1; i <= n; ++i)
if (!cl[i]) printf("%d%c", i, k++ == ans ? '\n' : ' ');
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, vector<int>> m;
vector<bool> c;
bool bb = true;
int a[500000];
vector<int> p, q;
void find(int i, int j) {
if (c[i - 1] && a[i - 1] != j % 2) {
bb = false;
return;
} else if (c[i - 1])
return;
c[i - 1] = true;
a[i - 1] = j % 2;
if (j % 2 == 0)
p.push_back(i);
else
q.push_back(i);
int k;
for (k = 0; k < m[i].size(); k++) {
find(m[i][k], j + 1);
}
}
int main() {
int n;
int k;
cin >> n >> k;
int f, s;
int i, j;
for (i = 0; i < k; i++) {
cin >> f >> s;
m[s].push_back(f);
m[f].push_back(s);
}
for (i = 0; i < n; i++) c.push_back(false);
for (i = 0; i < n; i++) a[i] = -1;
for (i = 1; i < n; i++) {
if (!c[i - 1]) find(i, 0);
if (!bb) {
cout << -1;
return 0;
}
}
cout << p.size() << "\n";
for (i = 0; i < p.size(); i++) cout << p[i] << " ";
cout << "\n";
cout << q.size() << "\n";
for (i = 0; i < q.size(); i++) cout << q[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
vector<int> g[MAXN];
int n, m;
int color[MAXN];
vector<int> ans[3];
bool dfs(int v, int col = 1) {
color[v] = col;
for (int i = 0; i < (int)g[v].size(); ++i) {
int to = g[v][i];
if (!color[to]) {
if (dfs(to, 3 - col)) return true;
} else if (color[v] == color[to])
return true;
}
return false;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0, a, b; i < m; ++i) {
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; ++i) {
if (!color[i]) {
if (dfs(i)) {
puts("-1");
return 0;
}
}
}
for (int i = 1; i <= n; ++i) {
ans[color[i]].push_back(i);
}
printf("%d\n", (int)ans[1].size());
for (auto it : ans[1]) {
printf("%d ", it);
}
puts("");
printf("%d\n", (int)ans[2].size());
for (auto it : ans[2]) {
printf("%d ", it);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
vector<int> graph[N + 100];
int vis[N + 100];
vector<int> one, two;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
graph[u].push_back(v);
graph[v].push_back(u);
}
queue<int> q;
bool flag = true;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
q.push(i);
vis[i] = 1;
one.push_back(i);
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto it : graph[u]) {
if (!vis[it]) {
q.push(it);
if (vis[u] == 1) {
vis[it] = 2;
two.push_back(it);
} else {
vis[it] = 1;
one.push_back(it);
}
}
if (vis[it] == vis[u]) flag = false;
}
}
}
}
if (!flag) {
printf("-1\n");
} else {
printf("%d\n", (int)one.size());
for (auto it : one) {
printf("%d ", it);
}
printf("\n");
printf("%d\n", (int)two.size());
for (auto it : two) {
printf("%d ", it);
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, e, a, b;
vector<int> adjList[100000];
int color[100000];
vector<int> black, white;
bool bfs(int here, bool c) {
if (color[here] != -1) {
return color[here] == c;
}
color[here] = c;
bool r = true;
for (int i = 0; i < adjList[here].size(); i++) {
r = r && bfs(adjList[here][i], !c);
}
return r;
}
int main() {
scanf("%d%d", &n, &e);
for (int i = 0; i < e; i++) {
scanf("%d%d", &a, &b);
a--, b--;
adjList[a].push_back(b);
adjList[b].push_back(a);
}
memset(color, -1, sizeof(color));
bool ans = true;
for (int i = 0; i < n; i++) {
if (color[i] == -1) ans = ans && bfs(i, 0);
}
if (!ans) {
cout << -1 << endl;
} else {
for (int i = 0; i < n; i++) {
if (color[i] == 0) {
black.push_back(i + 1);
} else
white.push_back(i + 1);
}
printf("%d\n", black.size());
for (int i = 0; i < black.size(); i++) {
printf("%d", black[i]);
if (i != black.size() - 1) printf(" ");
}
printf("\n");
printf("%d\n", white.size());
for (int i = 0; i < white.size(); i++) {
printf("%d", white[i]);
if (i != white.size() - 1) printf(" ");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100010];
int marked[100010];
vector<int> color[2];
bool dfs_color(int s, int c = 2) {
marked[s] = c;
if (graph[s].empty()) return true;
color[c - 1].push_back(s);
for (int i = 0; i < (int)graph[s].size(); ++i) {
if ((!marked[graph[s][i]]) && !dfs_color(graph[s][i], 3 - c)) {
return false;
}
if (marked[graph[s][i]] == c) {
return false;
}
}
return true;
}
int main() {
memset(marked, 0, sizeof(marked));
int n, m;
int s, e;
cin >> n >> m;
while (m--) {
cin >> s >> e;
graph[s - 1].push_back(e - 1);
graph[e - 1].push_back(s - 1);
}
for (int i = 0; i < n; ++i) {
if (!marked[i] && !dfs_color(i)) {
cout << -1;
return 0;
}
}
for (int i = 0; i < 2; i++) {
cout << color[i].size() << '\n';
for (int j = 0; j < (int)color[i].size(); ++j)
cout << color[i][j] + 1 << ' ';
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC diagnostic ignored "-Wmissing-declarations"
inline int safe_mul(int x, int y) __attribute__((warn_unused_result));
int const maxn = 100005;
vector<int> gr[maxn];
int used[maxn];
bool good = true;
void dfs(int v, int val = 1) {
used[v] = val;
for (int x : gr[v])
if (used[x] == 0)
dfs(x, 3 - val);
else
good &= used[x] != val;
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
gr[v].push_back(u);
gr[u].push_back(v);
}
for (int i = 1; i <= n; ++i)
if (!used[i]) dfs(i);
if (!good) {
cout << (-1) << '\n';
exit(0);
};
vector<int> ans1;
vector<int> ans2;
for (int i = 1; i <= n; ++i)
if (used[i] == 1)
ans1.push_back(i);
else
ans2.push_back(i);
cout << ans1.size() << endl;
for (int i = 0; i < ans1.size(); ++i)
cout << ans1[i] << " \n"[i == ans1.size() - 1];
cout << ans2.size() << endl;
for (int i = 0; i < ans2.size(); ++i)
cout << ans2[i] << " \n"[i == ans2.size() - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
void cass() {
ios::sync_with_stdio(0);
cin.tie(0);
}
const int N = 2e5 + 2;
int n, m, pos[N];
vector<int> a[N];
void read() {
cin >> n >> m;
int u, v;
for (int i = 1; i <= m; ++i) {
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
}
void DFS(int u) {
for (int i = 0; i < a[u].size(); ++i) {
if (pos[a[u][i]] != -1 && pos[u] == pos[a[u][i]]) {
cout << -1;
exit(0);
} else if (pos[a[u][i]] == -1) {
pos[a[u][i]] = 1 - pos[u];
DFS(a[u][i]);
}
}
}
void solve() {
memset(pos, -1, sizeof(pos));
for (int i = 1; i <= n; ++i)
if (pos[i] == -1 && a[i].size()) {
pos[i] = 1;
DFS(i);
}
int dem1 = 0, dem0 = 0;
for (int i = 1; i <= n; ++i)
if (pos[i] == 1)
dem1++;
else if (!pos[i])
dem0++;
cout << dem0 << '\n';
for (int i = 1; i <= n; ++i)
if (!pos[i]) cout << i << " ";
cout << '\n' << dem1 << '\n';
for (int i = 1; i <= n; ++i)
if (pos[i] == 1) cout << i << " ";
}
int main() {
cass();
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int cnt[2] = {0};
vector<int> graph[100002];
int v[100002] = {0};
bool bad = false;
void dfs(int x) {
if (bad) return;
cnt[v[x] - 1]++;
for (int i = 0; i < graph[x].size(); i++) {
int y = graph[x][i];
if (v[x] == v[y]) {
bad = true;
return;
}
if (!v[y]) {
v[y] = v[x] ^ 3;
dfs(y);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
graph[x].push_back(y);
graph[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (v[i] == 0) {
v[i] = 1;
dfs(i);
}
}
if (bad) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= 2; i++) {
printf("%d\n", cnt[i - 1]);
for (int j = 1; j <= n; j++) {
if (v[j] == i) printf("%d ", j);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> G[10000000], colour, vis;
queue<long long int> q;
long long int color = 0, flag;
void BFS(long long int i) {
flag = 0;
vis[i] = 1;
if (colour[i] == -1) {
colour[i] = 1 - color;
}
color = colour[i];
for (auto it = G[i].begin(); it != G[i].end(); ++it) {
if (colour[*(it)] == -1) {
colour[*(it)] = 1 - color;
} else if (colour[*(it)] == color) {
flag = 1;
break;
}
if (vis[*(it)] == 0) {
q.push(*(it));
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m, x, y;
cin >> n >> m;
vector<long long int> A, B;
for (int i = 0; i < n + 1; i++) {
colour.push_back(-1);
vis.push_back(0);
}
for (int i = 0; i < m; i++) {
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 1; i < n; i++) {
if (vis[i] == 0) {
q.push(i);
color = 0;
}
while (!q.empty()) {
long long int s = q.front();
q.pop();
BFS(s);
if (flag == 1) {
cout << "-1";
return 0;
}
}
}
for (int i = 1; i < n + 1; i++) {
if (colour[i] == 0) {
A.push_back(i);
} else {
B.push_back(i);
}
}
cout << A.size() << endl;
for (int i = 0; i < A.size(); i++) {
cout << A[i] << " ";
}
cout << endl;
cout << B.size() << endl;
for (int i = 0; i < B.size(); i++) {
cout << B[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool viz[100002], c[100002];
int f[2], n, m;
vector<int> G[100002];
void dfs(int x, int cul) {
f[cul]++;
viz[x] = 1;
c[x] = cul;
for (auto it : G[x]) {
if (!viz[it])
dfs(it, 1 - cul);
else if (viz[it] && 1 - cul != c[it]) {
cout << -1;
exit(0);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
vector<pair<int, int> > edge;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
edge.push_back({x, y});
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (!viz[i]) dfs(i, 0);
bool ok = 1;
for (int i = 0; i < 2; i++) {
int cnt = 0;
for (auto it : edge)
if (c[it.first] == i || c[it.second] == i) cnt++;
if (cnt == m) {
ok = 0;
break;
}
}
if (ok) {
cout << -1;
return 0;
}
vector<int> a;
vector<int> b;
for (int i = 1; i <= n; i++)
if (c[i])
a.push_back(i);
else
b.push_back(i);
cout << a.size() << "\n";
for (auto it : a) cout << it << " ";
cout << "\n";
cout << b.size() << "\n";
for (auto it : b) cout << it << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> ans[1], v[100100];
int c[100100], che = 0;
int dfs(int s, int x) {
c[s] = x;
for (auto p : v[s]) {
if (c[p] == x) {
return 1;
}
if (c[p] == -1) {
che = 1;
if (dfs(p, !x)) return 1;
}
}
if (che) ans[x].push_back(s);
return 0;
}
int main() {
memset(c, -1, sizeof(c));
int n, m, x, y;
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (c[i] == -1) {
che = 0;
if (dfs(i, 0)) {
printf("-1");
return 0;
}
}
}
sort(ans[0].begin(), ans[0].end());
sort(ans[1].begin(), ans[1].end());
cout << ans[0].size() << endl;
for (auto p : ans[0]) cout << p << " ";
cout << '\n' << ans[1].size() << endl;
for (auto p : ans[1]) cout << p << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100500;
const int inf = 2e9;
const double eps = 1e-8;
const int base = 1073676287;
vector<int> edge[maxn];
bool used[maxn];
int color[maxn];
void dfs(int v, int col) {
used[v] = true;
color[v] = col;
int newCol;
if (col == 1)
newCol = 2;
else
newCol = 1;
int sz = edge[v].size();
for (int j = 0; j < sz; j++) {
int to = edge[v][j];
if (used[to]) {
if (color[to] == color[v]) {
printf("-1\n");
exit(0);
}
continue;
}
dfs(to, newCol);
}
}
int main() {
srand(time(0));
int n, m;
scanf("%d%d", &n, &m);
for (int j = 0; j < m; j++) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
edge[u].push_back(v);
edge[v].push_back(u);
}
for (int j = 0; j < n; j++) {
if (!used[j]) dfs(j, 1);
}
int ans = 0;
for (int j = 0; j < n; j++)
if (color[j] == 2) ++ans;
printf("%d\n", ans);
for (int j = 0; j < n; j++)
if (color[j] == 2) printf("%d ", j + 1);
printf("\n%d\n", n - ans);
for (int j = 0; j < n; j++)
if (color[j] != 2) printf("%d ", j + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> G[maxn], a, b;
int n, m, flag;
int col[maxn];
bool bfs(int s) {
queue<int> p;
p.push(s);
col[s] = 1;
while (!p.empty()) {
int from = p.front();
p.pop();
int len = G[from].size();
for (int i = 0; i < len; ++i) {
int v = G[from][i];
if (col[v] == -1) {
p.push(v);
col[v] = !col[from];
}
if (col[from] == col[v]) return false;
}
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
a.clear();
b.clear();
for (int i = 0; i <= n; ++i) G[i].clear();
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
flag = 0;
memset(col, -1, sizeof(col));
for (int i = 1; i <= n; i++)
if (col[i] == -1 && !bfs(i)) {
flag = true;
break;
}
if (flag) {
puts("-1");
} else {
for (int i = 1; i <= n; ++i) {
if (G[i].size() == 0) col[i] = -1;
if (col[i] == 0) {
a.push_back(i);
} else if (col[i] == 1) {
b.push_back(i);
}
}
int len = a.size();
printf("%d\n", len);
for (int i = 0; i < len; ++i) {
if (i) printf(" ");
printf("%d", a[i]);
}
len = b.size();
printf("\n%d\n", len);
for (int i = 0; i < len; ++i) {
if (i) printf(" ");
printf("%d", b[i]);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void addmod(int &a, long long b) {
a = (a + b);
if (a >= 1000000007) a -= 1000000007;
}
void mulmod(int &a, long long b) { a = (a * b) % 1000000007; }
int gi() {
int a;
scanf("%d", &a);
return a;
}
long long gll() {
long long a;
scanf("%I64d", &a);
return a;
}
class graphal {
public:
int n;
vector<vector<int> > ed;
vector<int> vs, va, vb;
bool ok;
graphal(const int &n) : n(n), ed(n), vs(n, 0), ok(true) {}
void add(int a, int b) {
ed[a].push_back(b);
ed[b].push_back(a);
}
void load(int m) {
for (int i = 0; i < m; i++) {
int a = gi(), b = gi();
add(a - 1, b - 1);
}
}
void dfs(int v = 0, int pa = -1, int d = 0) {
if (vs[v] && vs[v] != d) {
ok = false;
}
if (vs[v]) return;
vs[v] = d;
if (d == 1)
d = 2, va.push_back(v);
else
d = 1, vb.push_back(v);
for (auto i : ed[v])
if (i != pa) {
dfs(i, v, d);
}
}
};
int main() {
int n = gi(), m = gi();
graphal g(n);
g.load(m);
for (int i = 0; i < n && g.ok; i++)
if (g.vs[i] == 0 && g.ed[i].size() > 0) {
g.dfs(i, -1, 1);
}
if (!g.ok) {
cout << -1 << endl;
return 0;
}
printf("%d\n", (int)g.va.size());
for (int i = 0; i < g.va.size(); i++) {
if (i) putchar(' ');
printf("%d", g.va[i] + 1);
}
printf("\n%d\n", (int)g.vb.size());
for (int i = 0; i < g.vb.size(); i++) {
if (i) putchar(' ');
printf("%d", g.vb[i] + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > ra(100010);
vector<int> per;
vector<int> ar;
map<int, int> p;
map<int, int> r;
bool vis[100010];
void dfs(int root, int cnt) {
vis[root] = 1;
if (cnt & 1) {
per.push_back(root);
r[root] = 1;
} else {
ar.push_back(root);
r[root] = 2;
}
for (int i = 0; i < ra[root].size(); i++) {
int ch = ra[root][i];
if (vis[ch] == 0) {
dfs(ch, cnt + 1);
}
}
}
int main() {
int n, m;
cin >> n >> m;
int ans = 0;
vector<pair<int, int> > pair;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
pair.push_back({a, b});
ra[a].push_back(b);
ra[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
dfs(i, 0);
}
}
for (int i = 0; i < m; i++) {
int a = pair[i].first;
int b = pair[i].second;
if (r[a] != 0 && (r[a] == r[b])) {
cout << -1;
return 0;
}
}
cout << ar.size() << endl;
for (int i = 0; i < ar.size(); i++) {
cout << ar[i] << " ";
}
cout << endl;
cout << per.size() << endl;
for (int i = 0; i < per.size(); i++) {
cout << per[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> gr[1000000];
int visited[1000000], color[1000000];
int bfs(int start) {
visited[start] = 1;
color[start] = 1;
queue<int> q;
q.push(start);
while (!q.empty()) {
auto u = q.front();
q.pop();
visited[u] = 1;
for (auto i : gr[u]) {
if (!visited[i]) {
color[i] = (color[u] + 1) % 2;
q.push(i);
} else {
if (color[i] == color[u]) {
return -1;
}
}
}
}
return 1;
}
int main(void) {
int n, m;
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
gr[u].push_back(v);
gr[v].push_back(u);
}
int flag = 0;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
flag = bfs(i);
if (flag == -1) {
break;
}
}
}
if (flag == -1) {
cout << "-1" << endl;
} else {
int t = 0;
for (int i = 1; i <= n; i++) {
if (!color[i]) {
t++;
}
}
cout << t << endl;
for (int i = 1; i <= n; i++) {
if (!color[i]) {
cout << i << " ";
}
}
cout << endl << n - t << endl;
for (int i = 1; i <= n; i++) {
if (color[i]) {
cout << i << " ";
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int u, v;
Node* next;
} * h[100005], pool[100005 << 1];
int tot, vis[100005];
void addEdge(int u, int v) {
Node* p = &pool[++tot];
p->u = u;
p->v = v;
p->next = h[u];
h[u] = p;
}
bool dfs(int i, int grp) {
if (vis[i] != 0 && vis[i] != grp) return false;
if (vis[i] != 0) return true;
if (vis[i] == 0) vis[i] = grp;
for (Node* p = h[i]; p; p = p->next)
if (!dfs(p->v, grp * (-1))) return false;
return true;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
addEdge(u, v);
addEdge(v, u);
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 0)
if (dfs(i, -1) == false) {
printf("-1");
return 0;
}
}
int kn = 0, km = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == 1)
kn++;
else
km++;
}
printf("%d\n", kn);
for (int i = 1; i <= n; i++)
if (vis[i] == 1) printf("%d ", i);
printf("\n%d\n", km);
for (int i = 1; i <= n; i++)
if (vis[i] == -1) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool hash1[100010], hash2[100010], visited[100010];
std::vector<int> vec[100010];
void dfs(int root, bool mark) {
visited[root] = true;
if (mark == true)
hash1[root] = true;
else
hash2[root] = true;
for (int i = 0; i < vec[root].size(); i++) {
if (mark == true) {
if (hash1[vec[root][i]] == true) {
cout << -1 << endl;
exit(0);
} else if (visited[vec[root][i]] == false) {
hash2[vec[root][i]] = true;
visited[vec[root][i]] = true;
dfs(vec[root][i], false);
}
} else {
if (hash2[vec[root][i]] == true) {
cout << -1 << endl;
exit(0);
} else if (visited[vec[root][i]] == false) {
hash1[vec[root][i]] = true;
visited[vec[root][i]] = true;
dfs(vec[root][i], true);
}
}
}
}
int main(void) {
int i, j, k, n, m;
for (i = 0; i < 100010; i++) hash1[i] = hash2[i] = visited[i] = false;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> j >> k;
vec[j].push_back(k);
vec[k].push_back(j);
}
hash1[1] = true;
for (i = 1; i <= n; i++)
if (visited[i] != true) {
visited[i] = true;
dfs(i, true);
}
int count1 = 0, count2 = 0;
for (i = 1; i <= n; i++) {
if (hash1[i]) count1++;
if (hash2[i]) count2++;
}
cout << count1 << endl;
for (i = 1; i <= n; i++)
if (hash1[i] == true) cout << i << " ";
cout << endl;
cout << count2 << endl;
for (i = 1; i <= n; i++)
if (hash2[i] == true) cout << i << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100005];
int color[100005], vis[100005];
int flag = 0, n;
void dfs(int x) {
vis[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
if (vis[v[x][i]] != 1) {
color[v[x][i]] = !color[x];
if (flag == 0) dfs(v[x][i]);
} else {
if (color[v[x][i]] == color[x]) {
flag = 1;
return;
}
}
}
}
int count(int x) {
int cnt = 0;
for (int i = 1; i <= n; i++)
if (color[i] == x && v[i].size() != 0) cnt++;
return cnt;
}
void print(int x) {
for (int i = 1; i <= n; i++) {
if (color[i] == x && v[i].size() != 0) cout << i << " ";
}
cout << "\n";
}
int main() {
int m, i, a, b;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (i = 1; i <= n; i++) {
vis[i] = 0;
color[i] = -1;
}
for (i = 1; i <= n; i++) {
if (vis[i] != 1) {
color[i] = 1;
dfs(i);
if (flag == 1) break;
}
}
if (flag == 0) {
cout << count(0) << endl;
print(0);
cout << count(1) << endl;
print(1);
} else {
cout << "-1\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100010];
int marked[100010];
vector<int> color[2];
bool dfs_color(int s, int c = 2) {
marked[s] = c;
if (graph[s].empty()) return true;
color[c - 1].push_back(s);
for (int i = 0; i < (int)graph[s].size(); ++i) {
if ((!marked[graph[s][i]])) {
if (!dfs_color(graph[s][i], 3 - c)) {
return false;
}
}
if (marked[graph[s][i]] == c) {
return false;
}
}
return true;
}
int main() {
memset(marked, 0, sizeof(marked));
int n, m;
int s, e;
cin >> n >> m;
while (m--) {
cin >> s >> e;
graph[s - 1].push_back(e - 1);
graph[e - 1].push_back(s - 1);
}
for (int i = 0; i < n; ++i) {
if ((!marked[i])) {
if (!dfs_color(i)) {
cout << -1;
return 0;
}
}
}
for (int i = 0; i < 2; i++) {
cout << color[i].size() << '\n';
for (int j = 0; j < (int)color[i].size(); ++j)
cout << color[i][j] + 1 << ' ';
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int N = 1000000 + 5;
const int mod = 1e9 + 7;
const int inf = 2e9;
vector<int> vis(N + 5, -1);
vector<int> adj[N + 5];
vector<int> p(N, 0);
int fl;
bool cmp(pair<int, int> a, pair<int, int> b) { return a.first > b.first; }
void dfs(int second, int c) {
int i;
if (fl) return;
vis[second] = c;
for (i = 0; i < adj[second].size(); i++) {
int x = adj[second][i];
if (vis[x] == -1) {
dfs(x, !c);
} else {
if (vis[x] == c) {
fl = 1;
return;
}
}
}
}
void print(vector<int> vis) {
for (int i = 0; i < vis.size(); i++) cout << vis[i] << " ";
cout << "\n\n\n";
}
int main() {
int n, m, i, x, y, j;
long long ans = 0;
cin >> n >> m;
vis.resize(n + 2);
vector<int> a, b;
for (i = 0; i < m; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (i = 1; i <= n; i++) {
if (vis[i] == -1) {
dfs(i, 1);
}
}
if (fl)
cout << "-1";
else {
for (i = 1; i <= n; i++) {
if (vis[i] == 1)
a.push_back(i);
else
b.push_back(i);
}
cout << a.size() << "\n";
for (i = 0; i < a.size(); i++) cout << a[i] << " ";
cout << "\n" << b.size() << "\n";
for (i = 0; i < b.size(); i++) cout << b[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
int N, M;
template <int NNodes>
class UndirectedGraph {
public:
int N;
inline void AddEdge(int x, int y) {
Node[x].ADC.push_back(y);
Node[y].ADC.push_back(x);
}
void Print() {
std::cout << Count[2] << '\n';
for (int i = 0; i < N; ++i)
if (Node[i + 1].Color == 2) std::cout << i + 1 << ' ';
std::cout << '\n';
std::cout << Count[1] << '\n';
for (int i = 0; i < N; ++i)
if (Node[i + 1].Color == 1) std::cout << i + 1 << ' ';
std::cout << '\n';
}
bool CheckBipartit() {
bool bBipartit = 1;
for (int i = 0; i < N && bBipartit; ++i)
if (!Node[i + 1].Color) bBipartit &= DFS(i + 1);
return bBipartit;
}
private:
int Count[3];
struct NodeData {
int Color;
std::vector<int> ADC;
} Node[NNodes];
bool DFS(int Vertex = 1, int Color = 2) {
Node[Vertex].Color = Color;
++Count[Color];
bool bBipartit = 1;
for (auto Vecin : Node[Vertex].ADC)
if (Node[Vecin].Color == Color)
return false;
else if (!Node[Vecin].Color)
bBipartit &= DFS(Vecin, 3 - Color);
return bBipartit;
}
};
UndirectedGraph<100005> Graph;
void Citire() {
std::cin >> N >> M;
Graph.N = N;
for (int i = 0, x, y; i < M; ++i) std::cin >> x >> y, Graph.AddEdge(x, y);
}
void Rezolvare() {
if (Graph.CheckBipartit())
Graph.Print();
else
std::cout << "-1\n";
}
int main() {
Citire();
Rezolvare();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> A, B;
vector<vector<int>> adj;
vector<bool> visited;
vector<int> color;
bool bipartite = true;
void dfs(int u, int c = 0) {
visited[u] = true;
color[u] = c;
if (c == 0)
A.push_back(u);
else
B.push_back(u);
for (int v : adj[u]) {
if (visited[v] && color[v] == c) bipartite = false;
if (!visited[v]) dfs(v, 1 - c);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
visited.assign(n, false);
adj.resize(n);
color.assign(n, -1);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 0; i < n; i++) {
if (!visited[i]) dfs(i);
}
if (!bipartite) {
cout << -1 << '\n';
return 0;
}
cout << A.size() << '\n';
for (int i = 0; i < A.size(); i++) {
cout << A[i] + 1 << " \n"[i == A.size() - 1];
}
cout << B.size() << '\n';
for (int i = 0; i < B.size(); i++) {
cout << B[i] + 1 << " \n"[i == B.size() - 1];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> arr[100001];
vector<bool> visited(100001, false);
vector<int> result(100001, -1);
bool match = false;
vector<int> A, B;
void dfs(int i, int p) {
visited[i] = true;
if (p == -1)
result[i] = 0;
else
result[i] = result[p] ^ 1;
if (result[i] == 0)
A.push_back(i);
else
B.push_back(i);
for (auto it : arr[i]) {
if (visited[it] == false && it != p) {
dfs(it, i);
} else if (result[it] == result[i]) {
match = true;
}
}
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
arr[x].push_back(y);
arr[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
dfs(i, -1);
}
}
if (match)
cout << "-1\n";
else {
cout << A.size() << "\n";
for (auto it : A) cout << it << " ";
cout << "\n" << B.size() << "\n";
for (auto it : B) cout << it << " ";
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
int test;
test = 1;
while (test--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> out[2];
vector<int> graph[120025];
int check[120025];
bool dfs(int y, int x = 2) {
check[y] = x;
out[x - 1].push_back(y);
for (int i = 0; i < graph[y].size(); i++) {
if (!check[graph[y][i]] && dfs(graph[y][i], 3 - x)) return true;
if (check[graph[y][i]] != 3 - x) return true;
}
return false;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
graph[x].push_back(y);
graph[y].push_back(x);
}
for (int i = 0; i < n; i++)
if (!check[i]) {
if (graph[i].empty()) continue;
if (dfs(i)) {
cout << -1 << endl;
return 0;
}
}
for (int i = 0; i < 2; i++) {
cout << out[i].size() << endl;
for (int j = 0; j < out[i].size(); j++) cout << out[i][j] + 1 << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline void fast_and_furious() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
int n, m, u, v;
vector<int> node[100005], visited(100005), alloc(100005), one, two;
int part_of_any_edge[100005];
void dfs(int current) {
visited[current] = true;
for (auto child : node[current]) {
if (!alloc[child]) {
if (alloc[current] == 1)
alloc[child] = 2;
else
alloc[child] = 1;
} else if (alloc[child] == alloc[current]) {
cout << "-1";
exit(0);
}
if (!visited[child]) dfs(child);
}
}
int main() {
fast_and_furious();
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
part_of_any_edge[u] = true;
part_of_any_edge[v] = true;
node[u].emplace_back(v);
node[v].emplace_back(u);
}
for (int i = 1; i <= n; i++) {
if (!visited[i] && (part_of_any_edge[u] == true)) dfs(i);
}
for (int i = 1; i <= n; i++) {
if (part_of_any_edge[u] = true) {
if (alloc[i] == 1) one.emplace_back(i);
if (alloc[i] == 2) two.emplace_back(i);
}
}
cout << (int)one.size() << "\n";
for (auto it : one) cout << it << " ";
cout << "\n";
cout << (int)two.size() << "\n";
for (auto it : two) cout << it << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD5 = 1e5 + 7;
const int MOD = 1e9 + 7;
const int SIZE = 1e6 + 10;
std::vector<int> adj[MOD5];
int visited[MOD5];
int bpGraph[MOD5];
int bfs(int i) {
visited[i] = 1;
queue<int> q;
q.push(i);
while (!q.empty()) {
int e = q.front();
q.pop();
int c = bpGraph[e];
for (int j = 0; j < (adj[e].size()); ++j) {
if (!visited[adj[e][j]]) {
visited[adj[e][j]] = 1;
q.push(adj[e][j]);
bpGraph[adj[e][j]] = !c;
} else {
if (bpGraph[adj[e][j]] == c) {
printf("-1\n");
return -1;
}
}
}
}
return 0;
}
int main(int argc, char const *argv[]) {
int n, m, u, v;
scanf("%d %d", &n, &m);
for (int i = 0; i < (m); ++i) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int c = 0;
for (int i = (1); i < (n + 1); ++i) {
if (!visited[i]) {
int ans = bfs(i);
if (ans == -1) {
return 0;
}
}
}
int a = 0;
for (int i = (1); i < (n + 1); ++i) {
if (bpGraph[i]) a++;
}
printf("%d\n", n - a);
;
for (int i = (1); i < (n + 1); ++i) {
if (!bpGraph[i]) {
printf("%d ", i);
}
}
printf("\n");
printf("%d\n", a);
;
for (int i = (1); i < (n + 1); ++i) {
if (bpGraph[i]) {
printf("%d ", i);
}
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> mp[100010], ans1, ans2;
int color[100010];
int n, m;
bool DFS(int x) {
if (color[x] == 0) color[x] = 1;
if (color[x] == 1) ans1.push_back(x);
if (color[x] == -1) ans2.push_back(x);
for (int i = 0; i < mp[x].size(); i++) {
if (color[x] == color[mp[x][i]]) return false;
if (color[mp[x][i]] == 0) {
color[mp[x][i]] = -1 * color[x];
if (!DFS(mp[x][i])) return false;
}
}
return true;
}
int main() {
int a, b;
while (cin >> n >> m) {
for (int i = 1; i <= n; i++) mp[i].clear();
ans1.clear();
ans2.clear();
for (int i = 0; i < m; i++) {
cin >> a >> b;
mp[a].push_back(b);
mp[b].push_back(a);
}
bool flag = true;
memset(color, 0, sizeof(color));
for (int i = 1; i <= n; i++) {
if (color[i] == 0)
if (DFS(i) == false) {
flag = false;
break;
}
}
if (flag == false)
cout << -1 << endl;
else {
cout << ans1.size() << endl;
for (int i = 0; i < ans1.size(); i++) printf("%d ", ans1[i]);
cout << endl;
cout << ans2.size() << endl;
for (int i = 0; i < ans2.size(); i++) printf("%d ", ans2[i]);
cout << endl;
}
}
}
|
#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;
set<int> adj[100001];
vector<int> s1[2], hei(100001, 0);
bool exist = true;
vector<bool> vis(100001, false);
void bfs(int v) {
if (adj[v].size() == 0) return;
queue<int> q;
q.push(v);
hei[v] = 1;
vis[v] = true;
s1[1].push_back(v);
while (not q.empty()) {
int u = q.front();
q.pop();
for (int x : adj[u]) {
if (not vis[x]) {
vis[x] = true;
hei[x] = hei[u] + 1;
q.push(x);
s1[hei[x] % 2].push_back(x);
} else if (hei[u] % 2 == hei[x] % 2) {
exist = false;
return;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
for (__typeof(m) i = (0) - (0 > m); i != (m) - (0 > m);
i += 1 - 2 * (0 > m)) {
int x, y;
cin >> x >> y;
adj[x].insert(y);
adj[y].insert(x);
}
for (__typeof(n + 1) i = (1) - (1 > n + 1); i != (n + 1) - (1 > n + 1);
i += 1 - 2 * (1 > n + 1)) {
if (not vis[i]) bfs(i);
}
if (exist) {
cout << s1[0].size() << '\n';
for (int u : s1[0]) cout << u << ' ';
cout << '\n' << s1[1].size() << '\n';
for (int u : s1[1]) cout << u << ' ';
} else
cout << -1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool success = true;
int n, m;
vector<vector<int> > v;
vector<int> visited;
vector<vector<int> > vlist;
void dfs(int now, int col, int per) {
visited[now] = (col == -1 || col == 2) ? 1 : 2;
vlist[visited[now]].push_back(now);
for (int i = 0; i < v[now].size(); i++) {
int next = v[now][i];
if (next == per) continue;
if (visited[now] == visited[next]) {
success = false;
return;
}
if (visited[next] == -1) {
dfs(next, visited[now], now);
}
}
}
int main() {
cin >> n >> m;
v.resize(n + 1);
visited.resize(n + 1, -1);
vlist.resize(3);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (visited[i] == -1 && v[i].size() > 0) {
dfs(i, -1, -1);
}
}
if (!success)
cout << "-1\n";
else {
cout << vlist[1].size() << endl;
for (int i = 0; i < vlist[1].size(); i++) {
if (i == 0)
cout << vlist[1][i];
else
cout << " " << vlist[1][i];
}
cout << endl;
cout << vlist[2].size() << endl;
for (int i = 0; i < vlist[2].size(); i++) {
if (i == 0)
cout << vlist[2][i];
else
cout << " " << vlist[2][i];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool dfs(int u, vector<vector<int>>& v, vector<int>& visit,
vector<int>& color) {
int i;
bool b = true;
for (i = 0; i < v[u].size(); i++) {
int child = v[u][i];
if (visit[child] == 0) {
visit[child] = 1;
color[child] = 1 - color[u];
b = dfs(child, v, visit, color);
if (b == false) return false;
} else {
if (color[child] == color[u]) return false;
}
}
return b;
}
int main() {
int n, m, i, j;
cin >> n >> m;
vector<vector<int>> v(n + 1);
for (i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
vector<int> visit(n + 1);
for (i = 0; i <= n; i++) visit[i] = 0;
vector<int> color(n + 1);
for (i = 0; i <= n; i++) color[i] = -1;
bool b;
for (i = 1; i <= n; i++) {
if (visit[i] == 0) {
visit[i] = 1;
color[i] = 0;
b = dfs(i, v, visit, color);
if (b == false) break;
}
}
vector<int> p;
vector<int> q;
for (i = 1; i <= n; i++) {
if (v[i].size() == 0) continue;
if (color[i] == 0)
p.push_back(i);
else if (color[i] == 1)
q.push_back(i);
}
if (b == false)
cout << -1 << endl;
else {
cout << q.size() << endl;
for (i = 0; i < q.size(); i++) cout << q[i] << " ";
cout << endl;
cout << p.size() << endl;
for (i = 0; i < p.size(); i++) cout << p[i] << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100001];
int color[100001];
vector<int> b, w;
void bfs(int v) {
queue<int> q;
q.push(v);
color[v] = 1;
b.push_back(v);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int u : graph[v]) {
if (color[u] == 0) {
if (color[v] == 1)
color[u] = 2, w.push_back(u);
else
color[u] = 1, b.push_back(u);
q.push(u);
}
if (color[v] == color[u]) {
printf("-1");
exit(0);
}
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
while (m--) {
int a, b;
scanf("%d %d", &a, &b);
graph[a].push_back(b);
graph[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (color[i] == 0) bfs(i);
printf("%d\n", (int)b.size());
for (int i = 0; i < b.size(); i++) printf("%d ", b[i]);
printf("\n%d\n", (int)w.size());
for (int i : w) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 100005;
vector<int> L[Nmax];
int n, m;
short viz[Nmax];
bool ok = true;
queue<int> Q;
bitset<Nmax> M1;
bitset<Nmax> M2;
inline void BFS(int varf) {
int x, nd;
Q.push(varf);
viz[varf] = 1;
M1[varf] = 1;
while (!Q.empty()) {
nd = Q.front();
Q.pop();
for (auto i : L[nd]) {
if (!viz[i]) {
x = 3 - viz[nd];
if (x == 1)
M1[i] = 1;
else
M2[i] = 1;
viz[i] = x;
Q.push(i);
} else if ((M1[nd] && M1[i]) || (M2[nd] && M2[i]))
ok = false;
}
}
}
int main() {
int x, y;
cin >> n >> m;
while (m--) {
cin >> x >> y;
L[x].push_back(y);
L[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (!viz[i]) BFS(i);
if (!ok)
cout << "-1\n";
else {
cout << M1.count() << "\n";
for (int i = 1; i <= Nmax; i++)
if (M1[i]) cout << i << " ";
cout << "\n";
cout << M2.count() << "\n";
for (int i = 1; i <= Nmax; i++)
if (M2[i]) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, u, v, cand = 1;
cin >> n >> m;
vector<bool> vu(n + 1);
vector<vector<int>> adj(n + 1);
while (m--) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
if (!vu[u]) vu[u] = true;
if (!vu[v]) vu[v] = true;
}
vector<int> color(n + 1);
vector<vector<int>> ans(3);
while (true) {
while (cand <= n) {
if (vu[cand] and color[cand] == 0) break;
++cand;
}
if (cand > n) break;
queue<int> q;
q.push(cand);
color[cand] = 1;
ans[1].push_back(cand);
while (!q.empty()) {
int node = q.front();
int c = color[node];
q.pop();
for (int i : adj[node]) {
if (color[i] == c) {
cout << "-1";
return 0;
}
if (color[i] == 0) {
color[i] = 3 - c;
ans[3 - c].push_back(i);
q.push(i);
}
}
}
}
cout << ans[1].size() << '\n';
for (int i : ans[1]) cout << i << ' ';
cout << '\n';
cout << ans[2].size() << '\n';
for (int i : ans[2]) cout << i << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const long long INFF = 1e18;
const int INF = 1e9;
const int mod = 1e9 + 7;
const int MAX = 1e6 + 7;
struct Dsu {
int siz[MAX], gp[MAX];
void init(int n) {
for (int i = (1); i < (n + 1); ++i) siz[i] = 1, gp[i] = i;
}
int fd(int v) { return gp[v] == v ? v : gp[v] = fd(gp[v]); }
bool uni(int u, int v) {
u = fd(u);
v = fd(v);
if (u == v) return 0;
if (siz[u] > siz[v]) swap(u, v);
siz[v] += siz[u];
gp[u] = v;
return 1;
}
} dsu;
int pos[MAX];
int main(void) {
int n, m;
scanf("%d %d", &n, &m);
;
dsu.init(2 * n);
bool die = 0;
int u, v;
for (int i = (1); i < (m + 1); ++i) {
scanf("%d %d", &u, &v);
if (dsu.fd(u) == dsu.fd(v) || dsu.fd(u + n) == dsu.fd(v + n)) die = 1;
dsu.uni(u, v + n);
dsu.uni(u + n, v);
}
if (die)
puts("-1");
else {
vector<int> ans1, ans2;
for (int i = (1); i < (n + 1); ++i) {
int v1 = dsu.gp[dsu.fd(i)], v2 = dsu.gp[dsu.fd(i + n)];
if (!pos[v1]) pos[v1] = 1, pos[v2] = 2;
if (pos[v1] == 1)
ans1.push_back(i);
else
ans2.push_back(i);
}
printf("%d\n", ((int)ans1.size()));
for (int i = 0; i < (((int)ans1.size())); ++i)
printf("%d%c", ans1[i], " \n"[i == ((int)ans1.size()) - 1]);
printf("%d\n", ((int)ans2.size()));
for (int i = 0; i < (((int)ans2.size())); ++i)
printf("%d%c", ans2[i], " \n"[i == ((int)ans2.size()) - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
vector<int> G[maxn];
int color[maxn], vis[maxn];
int n, m;
void init() {
memset(color, 0, sizeof(color));
memset(vis, 0, sizeof(vis));
}
int dfs(int v, int c) {
color[v] = c;
vis[v] = 1;
for (int i = 0; i < (int)G[v].size(); i++) {
if (color[G[v][i]] == c) return false;
if (color[G[v][i]] == 0 && !dfs(G[v][i], -c)) return false;
}
return true;
}
void slove() {
int flag = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
if (!dfs(i, 1)) {
flag = 0;
break;
}
}
}
if (!flag)
printf("-1\n");
else {
int q = 0, p = 0;
for (int i = 1; i <= n; i++) {
if (color[i] == 1)
q++;
else
p++;
}
printf("%d\n", q);
for (int i = 1; i <= n; i++) {
if (color[i] == 1) printf("%d ", i);
}
printf("\n");
printf("%d\n", p);
for (int i = 1; i <= n; i++) {
if (color[i] == -1) printf("%d ", i);
}
printf("\n");
}
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
int u, v;
for (int i = 0; i <= n; i++) G[i].clear();
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
init();
slove();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void colourNode(vector<int> &A, int colour, int i) {
if (colour == 1) {
A[i] = 2;
} else if (colour == 2) {
A[i] = 1;
}
}
bool bfs(vector<int> &colour, vector<vector<int> > &A, vector<bool> &visited,
int node) {
if (A[node].empty()) {
visited[node] = true;
return true;
}
queue<int> q;
q.push(node);
colour[node] = 1;
while (!q.empty()) {
int f = q.front();
q.pop();
visited[f] = true;
for (int i = 0; i < A[f].size(); i++) {
if (!visited[A[f][i]]) {
q.push(A[f][i]);
if (colour[A[f][i]] == 0) {
colourNode(colour, colour[f], A[f][i]);
} else if (colour[A[f][i]] == colour[f]) {
return false;
} else {
continue;
}
}
}
}
return true;
}
void Print(vector<int> A, int n) {
int c = 0;
for (int i = 1; i < A.size(); i++) {
if (A[i] == n) {
c++;
}
}
cout << c << "\n";
for (int i = 0; i < A.size(); i++) {
if (A[i] == n) {
cout << i << " ";
}
}
cout << "\n";
}
int main() {
int n, e;
cin >> n >> e;
vector<vector<int> > A;
vector<int> temp;
A.resize(n + 1, temp);
for (int i = 0; i < e; i++) {
int a1, a2;
cin >> a1 >> a2;
A[a1].push_back(a2);
A[a2].push_back(a1);
}
vector<int> colour(n + 1, 0);
vector<bool> visited(n + 1, false);
bool flag = true;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
if (!bfs(colour, A, visited, i)) {
flag = false;
cout << -1 << "\n";
break;
}
}
}
if (flag) {
Print(colour, 1);
Print(colour, 2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
return b == 0 ? abs(a) : gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int prime[1000000];
void seive() {
int n_prime = 1000000;
fill_n(prime, n_prime, 1);
prime[0] = 0;
prime[1] = 0;
for (int i = 2; i * i <= n_prime; i++) {
if (prime[i]) {
for (int j = i * i; j <= n_prime; j += i) {
prime[j] = 0;
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
int x, y;
std::cin >> n >> m;
vector<int> adj[n];
vector<int> vis(n, 0);
vector<int> col(n, 0);
vector<int> ans1, ans2;
int temp = 0;
for (int i = 0; i < m; i++) {
std::cin >> x >> y;
adj[x - 1].push_back(y - 1);
adj[y - 1].push_back(x - 1);
}
for (int i = 0; i < n; i++) {
if (vis[i] == 0) {
queue<int> q;
vis[i] = 1;
q.push(i);
while (!q.empty()) {
int s = q.front();
q.pop();
for (auto u : adj[s]) {
if (vis[u] == 0) {
vis[u] = 1;
col[u] = col[s] ^ 1;
q.push(u);
} else {
if (col[u] == col[s]) {
temp = 1;
}
}
}
}
}
}
for (int i = 0; i < n; i++) {
if (col[i]) {
ans1.push_back(i + 1);
} else {
ans2.push_back(i + 1);
}
}
if (temp == 1) {
std::cout << -1 << '\n';
} else {
std::cout << (int)ans1.size() << '\n';
for (auto i : ans1) cout << i << " ";
std::cout << '\n';
std::cout << (int)ans2.size() << '\n';
for (auto i : ans2) cout << i << " ";
std::cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int head[100010], to[2 * 100010], nxt[2 * 100010], vst[100010], cnt[3];
bool dfs(int u, int id) {
if (head[u] == -1) return true;
vst[u] = id;
cnt[id]++;
for (int edge = head[u]; edge != -1; edge = nxt[edge]) {
int v = to[edge];
if (vst[v]) {
if (vst[v] == id) return false;
continue;
}
if (!dfs(v, 3 - id)) return false;
}
return true;
}
int main() {
int N, M, i, u, v;
scanf("%d %d", &N, &M);
int edge = 0;
memset(head, -1, sizeof(head));
for (i = 0; i < M; i++) {
scanf("%d %d", &u, &v);
nxt[edge] = head[u];
to[edge] = v;
head[u] = edge++;
nxt[edge] = head[v];
to[edge] = u;
head[v] = edge++;
}
for (i = 1; i <= N; i++) {
if (vst[i]) continue;
if (!dfs(i, 1)) {
puts("-1");
return 0;
}
}
for (int id = 1; id <= 2; id++) {
printf("%d\n", cnt[id]);
for (i = 1; i <= N; i++) {
if (vst[i] == id) printf("%d ", i);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int mark[maxn], a[maxn];
vector<int> yal[maxn], ans[3];
int dfs(int now, int t) {
mark[now] = 1;
ans[t].push_back(now);
a[now] = t;
for (int i = 0; i < yal[now].size(); i++) {
if (!mark[yal[now][i]]) {
int s;
if (t == 1)
s = dfs(yal[now][i], 2);
else
s = dfs(yal[now][i], 1);
if (s == -1) return -1;
} else {
if (a[yal[now][i]] == t) return -1;
}
}
return 0;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
yal[u].push_back(v);
yal[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!mark[i] and yal[i].size()) {
int ans = dfs(i, 1);
if (ans == -1) {
cout << -1 << endl;
return 0;
}
}
}
int s = ans[1].size();
cout << s << endl;
for (int i = 0; i < s; i++) cout << ans[1][i] << ' ';
cout << endl;
s = ans[2].size();
cout << s << endl;
for (int i = 0; i < s; i++) cout << ans[2][i] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b;
int Judge[100010], A[100005], B[100005];
typedef struct Node {
struct Node* next;
int num;
} Node;
struct {
Node* first;
} Graph[100005];
void Init() {
memset(Judge, 0, sizeof(Judge));
for (int i = 1; i <= n; i++) Graph[i].first = NULL;
}
void Insert(int x, int y) {
Node *p = new Node, *q = new Node;
p->num = y;
p->next = Graph[x].first;
Graph[x].first = p;
q->num = x;
q->next = Graph[y].first;
Graph[y].first = q;
}
bool Solve() {
a = 0;
b = 0;
Node* p;
bool judge = true;
queue<int> que;
for (int i = 1; i <= n && judge; i++) {
que.push(i);
while (!que.empty()) {
int k = que.front();
que.pop();
if (!Judge[k]) {
p = Graph[k].first;
if (p) {
A[a++] = k;
Judge[k] = 1;
}
while (p) {
B[b++] = p->num;
Judge[p->num] = 2;
que.push(p->num);
p = p->next;
}
} else if (Judge[k] == 1) {
p = Graph[k].first;
while (p) {
if (Judge[p->num] == 1)
judge = false;
else if (Judge[p->num] == 0) {
Judge[p->num] = 2;
B[b++] = p->num;
que.push(p->num);
}
p = p->next;
}
} else {
p = Graph[k].first;
while (p) {
if (Judge[p->num] == 2)
judge = false;
else if (Judge[p->num] == 0) {
Judge[p->num] = 1;
A[a++] = p->num;
que.push(p->num);
}
p = p->next;
}
}
}
}
return judge;
}
int main() {
int x, y;
scanf("%d%d", &n, &m);
Init();
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
Insert(x, y);
}
bool key = Solve();
if (key) {
printf("%d\n", a);
for (int i = 0; i < a; i++) printf("%d ", A[i]);
printf("\n%d\n", b);
for (int i = 0; i < b; i++) printf("%d ", B[i]);
printf("\n");
} else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
template <typename T>
using vv = vector<vector<T>>;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
inline int cind() {
int a;
scanf("%d", &a);
return a;
}
inline double cindl() {
double a;
scanf("%lf", &a);
return a;
}
vector<int> used(2e5, 0);
vector<int> first;
vector<int> second;
vector<vector<int>> g(2e5);
void dfs(int v, int c) {
used[v] = c;
if (c == 1) {
first.push_back(v);
} else {
second.push_back(v);
}
for (auto to : g[v]) {
if (used[to] == used[v]) {
cout << -1 << endl;
exit(0);
}
if (!used[to]) {
if (c == 1) {
dfs(to, 2);
} else {
dfs(to, 1);
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
g.resize(n);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; ++i) {
if (!used[i]) {
dfs(i, 1);
}
}
cout << first.size() << endl;
for (auto v : first) {
cout << v + 1 << " ";
}
cout << endl;
cout << second.size() << endl;
for (auto v : second) {
cout << v + 1 << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adjacencyList[100001];
int color[100001], visited[100001];
int whiteCount;
bool dfs(int v, int colour) {
visited[v] = 1;
color[v] = colour;
if (colour) whiteCount++;
for (int elem : adjacencyList[v]) {
if (!visited[elem]) {
if (dfs(elem, colour ^ 1) == false) return false;
} else {
if (color[v] == color[elem]) return false;
}
}
return true;
}
int main() {
int n, m, flag = 0;
cin >> n >> m;
int a, b;
for (int i = 1; i <= m; i++) {
cin >> a >> b;
adjacencyList[a].push_back(b);
adjacencyList[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!visited[i])
if (!dfs(i, 0)) {
cout << "-1\n";
flag = 1;
break;
}
}
if (!flag) {
cout << whiteCount << "\n";
for (int i = 1; i <= n; i++)
if (color[i]) cout << i << " ";
cout << "\n";
cout << n - whiteCount << "\n";
for (int i = 1; i <= n; i++)
if (!color[i]) cout << i << " ";
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 200000 + 10;
vector<long long int> v[maxn];
long long int a[maxn];
void def(long long int k, long long int x) {
if (a[k] == 2 && x == 1) {
cout << -1;
exit(0);
}
if (a[k] == 1 && x == 2) {
cout << -1;
exit(0);
}
if (a[k] != 0) return;
a[k] = x;
for (long long int i = 0; i < v[k].size(); i++) {
if (x == 1)
def(v[k][i], 2);
else {
def(v[k][i], 1);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int c, u;
cin >> c >> u;
v[c].push_back(u);
v[u].push_back(c);
}
for (long long int i = 1; i <= n; i++)
if (a[i] == 0) def(i, 1);
long long int y = 0;
for (long long int i = 1; i <= n; i++) {
if (a[i] == 1) y++;
}
cout << y << endl;
for (long long int i = 1; i <= n; i++)
if (a[i] == 1) cout << i << " ";
cout << endl << n - y << endl;
for (long long int i = 1; i <= n; i++)
if (a[i] == 2) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
const int inf = 1 << 30;
const long long llinf = 1ll << 60;
using namespace std;
const int MAXN = 100000 + 5;
const int MAXE = MAXN * 2;
int n, m;
int to[MAXE], nxt[MAXE], head[MAXN], ne = 0;
int col[MAXN];
void inline ae(int f, int t) {
to[++ne] = t;
nxt[ne] = head[f];
head[f] = ne;
}
bool bicolor(int x, int c) {
if (col[x]) return col[x] == c;
col[x] = c;
for (int i = head[x]; i; i = nxt[i]) {
int v = to[i];
if (!bicolor(v, 3 - c)) return false;
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
ae(u, v);
ae(v, u);
}
for (int i = 1; i <= n; i++)
if (!col[i])
if (!bicolor(i, 1)) {
puts("-1");
return 0;
}
int num[3];
memset(num, 0, sizeof(num));
for (int i = 1; i <= n; i++) {
num[col[i]]++;
}
printf("%d\n", num[1]);
for (int i = 1; i <= n; i++)
if (col[i] == 1) printf("%d ", i);
puts("");
printf("%d\n", num[2]);
for (int i = 1; i <= n; i++)
if (col[i] == 2) printf("%d ", i);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void display(T a[], int size) {
for (int i = 0; i < size; i++) {
cout << a[i] << " ";
}
cout << endl;
}
void display(vector<pair<int, int> > a) {
for (int i = 0; i < a.size(); i++) {
cout << "(" << a[i].first << "," << a[i].second << ")"
<< " ";
}
cout << endl;
}
void display(vector<int> a) {
for (int i = 0; i < a.size(); i++) {
cout << a[i];
if (i == a.size() - 1)
cout << endl;
else
cout << " ";
}
}
template <typename T>
void initialise(T a[], T value, int length) {
for (int i = 0; i < length; i++) a[i] = value;
}
template <typename T>
void initialise(vector<T>& a, T value) {
for (int i = 0; i < a.size(); i++) a[i] = value;
}
bool compare(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.second < b.second;
}
int max(int a[], int n) {
int max = -1000000000;
for (int i = 0; i < n; i++) {
if (a[i] > max) max = a[i];
}
return max;
}
bool find(string a[], string s, int n) {
int left = 0;
int right = n - 1;
while (left < right) {
int mid = (left + right) / 2;
if (s.compare(a[mid]) == 0)
return true;
else if (s.compare(a[mid]) < 0) {
right = mid;
} else {
left = mid + 1;
}
}
return false;
}
void factor(int a[], int base, int num, int n) {
for (int i = n - 1; i >= 0; i--) {
a[i] = num % base;
num = num / base;
}
}
int findLength(int n, int base) {
int i = 0;
while (n > 0) {
i++;
n = n / base;
}
return i;
}
int gcd(int a, int b) {
while (a % b != 0 && b % a != 0) {
if (b > a) {
b = b % a;
} else if (a > b) {
a = a % b;
}
}
if (a <= b)
return a;
else
return b;
}
int main() {
int n, m;
cin >> n >> m;
list<int> son[n];
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
son[u - 1].push_back(v - 1);
son[v - 1].push_back(u - 1);
}
int side[n];
initialise(side, -1, n);
for (int i = 0; i < n; i++) {
if (side[i] != -1) continue;
queue<int> q;
q.push(i);
side[i] = 0;
while (!q.empty()) {
int current = q.front();
q.pop();
for (auto fil : son[current]) {
if (side[fil] == -1) {
side[fil] = 1 - side[current];
q.push(fil);
} else if (side[fil] == side[current]) {
cout << -1 << endl;
return 0;
} else
continue;
}
}
}
vector<int> zero;
vector<int> one;
for (int i = 0; i < n; i++) {
if (side[i] == 0)
zero.push_back(i + 1);
else
one.push_back(i + 1);
}
cout << zero.size() << endl;
for (int i = 0; i < zero.size(); i++) {
cout << zero[i];
if (i == zero.size() - 1)
cout << endl;
else
cout << " ";
}
cout << one.size() << endl;
for (int i = 0; i < one.size(); i++) {
cout << one[i];
if (i == one.size() - 1)
cout << endl;
else
cout << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
inline int nxt() {
int wow;
scanf("%d", &wow);
return wow;
}
inline long long int lxt() {
long long int wow;
scanf("%lld", &wow);
return wow;
}
int visited[100002], color[100002], hit[100002], paint = 1, flag;
vector<int> v[100002];
void bfs(int x) {
visited[x] = 1;
color[x] = 1;
queue<int> q;
q.push(x);
while (q.empty() == false) {
int p = q.front();
q.pop();
if (color[p] == 1)
paint = 2;
else
paint = 1;
for (int i = 0; i < v[p].size(); i++) {
int c = v[p][i];
if (visited[c]) {
if (color[p] == color[c]) {
flag = 1;
return;
}
continue;
}
visited[c] = 1;
color[c] = paint;
q.push(c);
}
}
}
int main() {
int n = nxt(), m = nxt();
for (int i = 0; i < m; i++) {
int x = nxt(), y = nxt();
v[x].push_back(y);
v[y].push_back(x);
hit[x] = hit[y] = 1;
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) bfs(i);
}
if (flag) {
puts("-1");
return 0;
}
vector<int> red, green;
for (int i = 1; i <= n; i++) {
if (hit[i]) {
if (color[i] == 1)
red.push_back(i);
else
green.push_back(i);
}
}
printf("%d\n", red.size());
for (int i = 0; i < red.size(); i++) printf("%d ", red[i]);
puts("");
printf("%d\n", green.size());
for (int i = 0; i < green.size(); i++) printf("%d ", green[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > v;
vector<int> vis;
queue<int> pro;
vector<int> oe;
int alpha = 0;
void bfs() {
while (pro.size() != 0) {
int k = pro.front();
pro.pop();
for (int i = 0; i < v[k].size(); i++) {
if (vis[v[k][i]] == 0) {
pro.push(v[k][i]);
oe[v[k][i]] = oe[k] + 1;
vis[v[k][i]] = 1;
}
}
}
for (int i = alpha; i < vis.size(); i++) {
if (vis[i] == 0) {
vis[i] = 1;
if (v[i].size() != 0) {
pro.push(i);
alpha = i;
bfs();
break;
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
oe.resize(n, 0);
v.resize(n);
vis.resize(n, 0);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a - 1].push_back(b - 1);
v[b - 1].push_back(a - 1);
}
vis[0] = 1;
pro.push(0);
bfs();
for (int i = 0; i < n; i++) {
for (int j = 0; j < v[i].size(); j++) {
if ((oe[i] + oe[v[i][j]]) % 2 == 0) {
cout << -1 << endl;
return 0;
}
}
}
int a = 0, b = 0;
for (int i = 0; i < n; i++) {
if (oe[i] % 2 == 0) {
a++;
} else {
b++;
}
}
cout << a << endl;
for (int i = 0; i < n; i++) {
if (oe[i] % 2 == 0) {
cout << i + 1 << " ";
}
}
cout << endl;
cout << b << endl;
for (int i = 0; i < n; i++) {
if (oe[i] % 2 == 1) {
cout << i + 1 << " ";
}
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> G[100001];
int color[100001];
int bfs(int pos, int c) {
int i, j;
color[pos] = c;
for (i = 0; i < G[pos].size(); i++) {
if (color[G[pos][i]] == c) return 0;
if (color[G[pos][i]] == 0 && !bfs(G[pos][i], -c)) return 0;
}
return 1;
}
int solve() {
int i, j;
for (i = 1; i <= n; i++) {
if (color[i] == 0) {
if (bfs(i, 1) == 0) return 0;
}
}
return 1;
}
int main() {
int i, j;
int u, v;
while (~scanf("%d %d", &n, &m)) {
memset(color, 0, sizeof(color));
for (i = 1; i <= n; i++) G[i].clear();
for (i = 0; i < m; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
if (solve()) {
int a[100000];
int b[100000];
int t = 0;
int tt = 0;
for (i = 1; i <= n; i++) {
if (color[i] == 1) {
a[t++] = i;
} else if (color[i] == -1) {
b[tt++] = i;
}
}
printf("%d\n", t);
for (i = 0; i < t; i++) printf("%d ", a[i]);
printf("\n");
printf("%d\n", tt);
for (i = 0; i < tt; i++) printf("%d ", b[i]);
printf("\n");
} else
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> e[100010], a, b;
int f[100010];
int vis[100010];
bool dfs(int x, int s) {
vis[x] = 1;
f[x] = s;
for (int i = 0; i < e[x].size(); i++) {
if (!vis[e[x][i]] && !dfs(e[x][i], s ^ 1)) return 0;
if (vis[e[x][i]] && f[e[x][i]] == s) return 0;
}
return 1;
}
int main() {
int n, m, u, v;
cin >> n >> m;
while (m--) {
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!vis[i] && !dfs(i, 0)) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
if (f[i])
a.push_back(i);
else
b.push_back(i);
}
cout << a.size() << endl;
for (int i = 0; i < a.size(); i++) cout << a[i] << " ";
puts("");
cout << b.size() << endl;
for (int i = 0; i < b.size(); i++) cout << b[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> edge[N];
int color[N], vis[N];
queue<int> test;
int n, m;
void init() {
for (int i = 1; i <= n; i++) {
vis[i] = 0;
color[i] = -1;
}
}
int work(int u) {
vis[u] = 1;
color[u] = 1;
test.push(u);
while (!test.empty()) {
int ai = test.front();
test.pop();
for (int i = 0; i < (int)edge[ai].size(); i++) {
int v = edge[ai][i];
if (color[v] == -1) {
color[v] = 1 - color[ai];
vis[v] = 1;
test.push(v);
}
if (color[v] == color[ai]) return 0;
}
}
return 1;
}
int main() {
vector<int> a, b;
scanf("%d%d", &n, &m);
init();
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
int flag = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
flag = work(i);
if (!flag) return 0 * printf("-1\n");
}
}
for (int i = 1; i <= n; i++) {
if (color[i] == 1) {
a.push_back(i);
} else {
b.push_back(i);
}
}
cout << (int)a.size() << endl;
for (int i = 0; i < (int)a.size(); i++) {
printf("%d ", a[i]);
}
cout << endl;
cout << (int)b.size() << endl;
for (int i = 0; i < (int)b.size(); i++) {
printf("%d ", b[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int fast_exp(long long int a, long long int b) {
long long int res = 1;
res %= 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
}
b = b >> 1;
a = (a * a) % 1000000007;
}
return res;
}
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
vector<int> prime_factorize(int n) {
vector<int> res;
for (int i = 2; i * i <= n; ++i) {
while (n % i == 0) {
res.push_back(i);
n /= i;
}
}
if (n != 1) {
res.push_back(n);
}
return res;
}
int lg2(long long int x) {
int c = 0;
while (x) {
x = x >> 1;
c++;
}
return c - 1;
}
vector<vector<int> > v(100001);
vector<vector<int> > ans(2);
int arr[100001];
int vis[100001];
int par[100001];
int col[100001];
int f = 0, tim = 0;
void bfs(int w) {
queue<int> q;
q.push(w);
q.push(-1);
int co = 1;
ans[0].push_back(w);
col[w] = 0;
while (q.size() != 1) {
int x = q.front();
q.pop();
if (x == -1) {
co = 1 - co;
q.push(-1);
} else {
int i;
for (i = 0; i < v[x].size(); i++) {
if (col[v[x][i]] == -1) {
q.push(v[x][i]);
col[v[x][i]] = co;
ans[co].push_back(v[x][i]);
} else {
if (col[v[x][i]] == col[x]) {
f = -1;
return;
} else {
}
}
}
}
}
}
int main() {
std::ios_base::sync_with_stdio(false);
int n, m, i, j, x, y;
cin >> n >> m;
memset(vis, 0, sizeof(vis));
for (i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
f = 0;
memset(col, -1, sizeof(col));
for (i = 1; i < n + 1; i++) {
if (col[i] == -1) bfs(i);
}
if (f == -1)
cout << "-1\n";
else {
set<int> s;
for (i = 0; i < ans[0].size(); i++) {
s.insert(ans[0][i]);
}
cout << s.size() << endl;
set<int>::iterator it;
for (it = (s).begin(); it != (s).end(); it++) {
cout << (*it) << " ";
}
cout << endl;
s.clear();
for (i = 0; i < ans[1].size(); i++) {
s.insert(ans[1][i]);
}
cout << s.size() << endl;
for (it = (s).begin(); it != (s).end(); it++) {
cout << (*it) << " ";
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> sets;
bool bipartiteCheck(vector<vector<int>> &adj, vector<int> &color, int u) {
bool result = true;
for (auto i : adj[u]) {
if (color[i] == color[u]) {
return false;
} else if (color[i] == 0) {
color[i] = 3 - color[u];
result &= bipartiteCheck(adj, color, i);
}
}
return result;
}
bool bipartite(vector<vector<int>> &adj) {
vector<int> color(adj.size(), 0);
for (int i = 0; i < adj.size(); ++i) {
if (color[i] == 0) {
color[i] = 1;
if (!bipartiteCheck(adj, color, i)) {
return false;
}
}
}
sets = color;
return true;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<vector<int>> adj(n, vector<int>());
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d %d", &x, &y);
adj[x - 1].push_back(y - 1);
adj[y - 1].push_back(x - 1);
}
if (!bipartite(adj)) {
puts("-1");
} else {
vector<int> s1, s2;
for (int i = 0; i < n; ++i) {
if (sets[i] == 1 && adj[i].size() != 0) {
s1.push_back(i + 1);
} else if (sets[i] == 2 && adj[i].size() != 0) {
s2.push_back(i + 1);
}
}
printf("%d\n", s1.size());
for (auto i : s1) {
cout << i << " ";
}
cout << "\n";
printf("%d\n", s2.size());
for (auto i : s2) {
cout << i << " ";
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a, b;
int seen[100005];
bool go(int u, vector<vector<int> > &G) {
queue<int> q;
q.push(u);
seen[u] = 0;
a.push_back(u);
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (seen[v] == -1) {
seen[v] = 1 - seen[u];
if (seen[v] == 0)
a.push_back(v);
else
b.push_back(v);
q.push(v);
} else if (seen[v] == seen[u])
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
int n, m, u, v;
cin >> n >> m;
memset(seen, -1, sizeof seen);
vector<vector<int> > G(n + 1);
for (int i = 0; i < m; ++i) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
bool ok = true;
for (int i = 1; i <= n && ok; ++i)
if (seen[i] == -1) ok &= go(i, G);
if (!ok) {
cout << -1;
return 0;
}
cout << a.size() << '\n';
for (int i = 0; i < a.size(); ++i) {
if (i) cout << ' ';
cout << a[i];
}
cout << '\n' << b.size() << '\n';
for (int i = 0; i < b.size(); ++i) {
if (i) cout << ' ';
cout << b[i];
}
}
|
#include <bits/stdc++.h>
using namespace std;
string convertTostr(unsigned long long x) {
stringstream ss;
ss << x;
string st;
st = ss.str();
return st;
}
unsigned long long convertToint(string y) {
unsigned long long num;
stringstream ss(y);
ss >> num;
return num;
}
unsigned long long fpow(unsigned long long b, unsigned long long p,
unsigned long long m) {
if (p == 0) return 1;
if (p == 1) return b % m;
unsigned long long res = fpow(b, p / 2, m) % m;
res = (res * res) % m;
if (p % 2 != 0) res = (res * (b % m)) % m;
return res;
}
int gcd(int a, int b) {
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int n, m;
bool visited[100005];
int color[100005];
cin >> n >> m;
int u, v;
vector<vector<int> > g(n + 1);
for (int i = 0; i < m; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
memset(visited, 0, sizeof visited);
memset(color, -1, sizeof color);
for (int j = 1; j <= n; j++) {
if (color[j] == -1 && !g[j].empty()) {
u = j;
queue<int> check;
check.push(u);
color[u] = 1;
while (!check.empty()) {
u = check.front();
check.pop();
for (int i = 0; i < g[u].size(); i++) {
v = g[u][i];
if (color[v] == -1) {
color[v] = 1 - color[u];
check.push(v);
} else if (u != v && color[v] == color[u]) {
cout << -1;
return 0;
}
}
}
}
}
vector<int> vc1, vc2;
for (int i = 1; i <= n; i++) {
if (color[i] == 1)
vc1.push_back(i);
else if (color[i] == 0)
vc2.push_back(i);
}
cout << vc1.size() << endl;
for (int i = 0; i < vc1.size(); i++) cout << vc1[i] << " ";
cout << endl << vc2.size() << endl;
for (int i = 0; i < vc2.size(); i++) cout << vc2[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> edge[N];
int color[N], vis[N];
queue<int> test;
int n, m;
void init() {
for (int i = 1; i <= n; i++) {
vis[i] = 0;
color[i] = -1;
}
}
int work(int u) {
vis[u] = 1;
color[u] = 1;
test.push(u);
while (!test.empty()) {
int ai = test.front();
test.pop();
for (int i = 0; i < (int)edge[ai].size(); i++) {
int v = edge[ai][i];
if (color[v] == -1) {
color[v] = 1 - color[ai];
test.push(v);
} else {
if (color[v] == color[ai]) return 0;
}
}
}
return 1;
}
int main() {
vector<int> a, b;
scanf("%d%d", &n, &m);
init();
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
int ans = 1;
for (int i = 1; i <= n; i++) {
if (color[i] == -1 && work(i) == 0) {
ans = 0;
break;
}
}
if (ans == 0)
printf("-1\n");
else {
for (int i = 1; i <= n; i++) {
if (color[i] == 1) {
a.push_back(i);
} else {
b.push_back(i);
}
}
cout << (int)a.size() << endl;
for (int i = 0; i < (int)a.size(); i++) {
printf("%d ", a[i]);
}
cout << endl;
cout << (int)b.size() << endl;
for (int i = 0; i < (int)b.size(); i++) {
printf("%d ", b[i]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a[100010];
bool pres[100010];
int color[100010];
int flag = 1;
vector<pair<int, int> > v;
void dfs(int v, int co) {
int i, u;
color[v] = co;
int revco = co == 1 ? 2 : 1;
for (i = 0; i < a[v].size(); i++) {
u = a[v][i];
if (color[u] == revco)
continue;
else if (color[u] == 0)
dfs(u, revco);
else {
flag = 0;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
memset(color, 0, sizeof(color));
int n, m, i;
cin >> n >> m;
for (i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
pres[x] = 1;
pres[y] = 1;
}
for (i = 1; i <= n; i++)
if (pres[i] == 1 && color[i] == 0) dfs(i, 1);
if (flag == 1) {
int c1 = 0, c2 = 0;
for (i = 0; i <= n; i++) {
if (color[i] == 1)
c1++;
else if (color[i] == 2)
c2++;
}
cout << c1 << endl;
for (i = 1; i <= n; i++)
if (color[i] == 1) cout << i << " ";
cout << endl << c2 << endl;
for (i = 1; i <= n; i++)
if (color[i] == 2) cout << i << " ";
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int h5 = 100000, h6 = 100000, h3 = 1e3;
const unsigned long long int h9 = 100000000, h18 = 1e18;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int pow1(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (1ll * a * res) % 10000000007;
b = (b >> 1);
a = (1ll * a * a) % 10000000007;
}
return res;
}
int rr[] = {0, 1, 1, 1, 0, -1, -1, -1};
int cc[] = {1, 1, 0, -1, -1, -1, 0, 1};
int rx[] = {1, -1, 0, 0};
int ry[] = {0, 0, 1, -1};
void f1() {
ios::sync_with_stdio(0);
cin.tie(0);
ios::sync_with_stdio(0);
;
}
vector<long long int> al[h5 + 3];
long long int vis[h5 + 3], c[h5 + 3];
vector<long long int> ans[2];
void dfs(long long int node, long long int clr) {
if (vis[node]) {
if (c[node] != clr) {
cout << "-1";
exit(0);
}
return;
}
vis[node] = 1;
c[node] = clr;
ans[clr].push_back(node);
for (auto child : al[node]) dfs(child, clr ^ 1);
}
void solve() {
long long int n, m;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int s, e;
cin >> s >> e;
al[s].push_back(e);
al[e].push_back(s);
}
for (long long int i = 1; i < n + 1; i++)
if (!vis[i]) dfs(i, 0);
for (long long int i = 0; i < 2; i++) {
cout << ans[i].size() << "\n";
for (auto x : ans[i]) cout << x << ' ';
cout << "\n";
}
}
int main() {
f1();
long long int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T>
inline bool Min(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
inline bool Max(T &a, T b) {
return a < b ? (a = b, true) : false;
}
inline int ni() {
int a;
scanf("%d", &a);
return a;
}
inline ll nl() {
ll a;
scanf("%lld", &a);
return a;
}
inline double nd() {
double a;
scanf("%lf", &a);
return a;
}
inline void pi(int a) { printf("%d ", a); }
inline void pl(ll a) { printf("%lld ", a); }
inline void pd(double a) { printf("%.12lf ", a); }
const int N = 2e5 + 10;
vector<int> gp[N];
int dol[N];
bool used[N];
void no() {
puts("-1");
exit(0);
}
void dfs(int v, int par) {
used[v] = true;
dol[v] = par;
for (int next : gp[v]) {
if (!used[next]) dfs(next, par ^ 1);
if (dol[v] == dol[next]) {
no();
}
}
}
void solve() {
int n = ni();
int m = ni();
vector<pii> rib;
for (int i = (int)(1); i <= (int)(n); ++i) dol[i] = -1;
for (int i = 0; i < (int)(m); ++i) {
int a = ni();
int b = ni();
gp[a].push_back(b);
gp[b].push_back(a);
rib.push_back(make_pair(a, b));
}
int cnt = 0;
for (int i = (int)(1); i <= (int)(n); ++i) {
if (!used[i]) dfs(i, 0);
}
for (pii r : rib) {
if (dol[r.first] == dol[r.second]) {
no();
}
}
vector<int> a, b;
for (int i = (int)(1); i <= (int)(n); ++i)
if (dol[i] == 0)
b.push_back(i);
else if (dol[i] == 1)
a.push_back(i);
printf("%d\n", (int)a.size());
for (int v : a) printf("%d ", v);
puts("");
printf("%d\n", (int)b.size());
for (int v : b) printf("%d ", v);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
using ll = long long;
using vll = int64_t;
const int N = 1e6 + 1;
vector<int> adj[N];
vector<bool> vis(N, false);
vector<short> col(N, -1);
inline bool bfs(int src) {
queue<pair<int, int>> q;
q.push({src, 0});
vis[src] = true;
col[src] = 0;
while (!q.empty()) {
auto p = q.front();
q.pop();
for (int i : adj[p.first]) {
if (vis[i]) {
if (col[i] == col[p.first]) {
return false;
}
continue;
}
vis[i] = true;
col[i] = (p.second == 1 ? 0 : 1);
q.push({i, col[i]});
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int m;
cin >> m;
unordered_set<int> hs;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
hs.insert(a);
hs.insert(b);
}
for (int i = 0; i < n; i++) {
if (!vis[i] && hs.find(i) != hs.end()) {
bool ok = bfs(i);
if (!ok) {
cout << "-1\n";
return 0;
}
}
}
int red = 0, black = 0;
for (int i = 0; i < n; i++) {
if (col[i] == 1)
black++;
else if (col[i] == 0)
red++;
}
cout << red << "\n";
for (int i = 0; i < n; i++) {
if (col[i] == 0) cout << 1 + i << " ";
}
cout << "\n";
cout << black << "\n";
for (int i = 0; i < n; i++) {
if (col[i] == 1) cout << i + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100001];
vector<int> arya;
vector<int> pari;
int owner[100001];
bool bipartiteness(int src) {
owner[src] = 0;
queue<int> q;
q.push(src);
pari.push_back(src);
while (q.empty() == false) {
int top = q.front();
q.pop();
for (int i = 0; i < v[top].size(); i++) {
if (owner[v[top][i]] == -1) {
if (owner[top] == 1) {
owner[v[top][i]] = 0;
pari.push_back(v[top][i]);
} else if (owner[top] == 0) {
owner[v[top][i]] = 1;
arya.push_back(v[top][i]);
}
q.push(v[top][i]);
} else if (owner[v[top][i]] == owner[top])
return false;
}
}
return true;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int tmp1, tmp2;
cin >> tmp1 >> tmp2;
v[tmp1].push_back(tmp2);
v[tmp2].push_back(tmp1);
}
for (int i = 0; i < 100001; i++) owner[i] = -1;
bool flag = 0;
for (int i = 1; i < n + 1; i++) {
if (owner[i] == -1)
if (!bipartiteness(i)) {
flag = 1;
break;
}
}
if (flag)
cout << -1 << endl;
else {
cout << arya.size() << endl;
for (int i = 0; i < arya.size(); i++) cout << arya[i] << " ";
cout << endl;
cout << pari.size() << endl;
for (int i = 0; i < pari.size(); i++) cout << pari[i] << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int powmod(long long int a, long long int b) {
if (b == 0) return 1;
long long int x = powmod(a, b / 2);
long long int y = (x * x) % 1000000007;
if (b % 2) return (a * y) % 1000000007;
return y % 1000000007;
}
bool flag;
bool visited[100010];
int C[100010];
vector<int> col[2];
vector<int> graph[100010];
void dfs(int src, int c) {
visited[src] = true;
col[c].push_back(src);
C[src] = c;
for (int i = 0; i < (int)(graph[src].size()); i++) {
if (!visited[graph[src][i]])
dfs(graph[src][i], c ^ 1);
else if (C[graph[src][i]] == C[src])
flag = true;
}
}
int main() {
int n, m;
scanf("%d", &n), scanf("%d", &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d", &u), scanf("%d", &v);
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 1; i < n + 1; i++) {
if (!visited[i]) {
dfs(i, 0);
}
}
if (flag)
printf("-1\n");
else {
printf("%d\n", (int)(col[0].size()));
for (int i = 0; i < (int)(col[0].size()); i++) printf("%d ", col[0][i]);
printf("\n");
printf("%d\n", (int)(col[1].size()));
for (int i = 0; i < (int)(col[1].size()); i++) printf("%d ", col[1][i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = (long long)((1e5) + 10);
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
bool isPrime(long long N) {
for (long long i = 2; i * i <= N; ++i) {
if (N % i == 0) return false;
}
return true;
}
long long cbrt(long long x) {
long long lo = 1, hi = min(2000000ll, x);
while (hi - lo > 1) {
long long mid = (lo + hi) / 2;
if (mid * mid * mid < x) {
lo = mid;
} else
hi = mid;
}
if (hi * hi * hi <= x)
return hi;
else
return lo;
}
const long long dx[4] = {-1, 1, 0, 0};
const long long dy[4] = {0, 0, -1, 1};
const long long nax = (long long)(100000 + 10);
vector<string> v;
vector<long long> adj[200005], vec, nod, ans1, ans2;
stack<long long> st;
long long n, m, d, k, l = 0, r, mid, s = 0, a, b, q, t, flag = 1, bad = 0,
c = 0;
vector<vector<long long>> arr(200005, vector<long long>(3, 0));
long long vis[200005], par[200005], col[200005];
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
map<long long, map<long long, long long>> ab;
void bfs(long long u) {
vis[u] = 1;
col[u] = 1;
queue<long long> q;
q.push(u);
while (!q.empty()) {
long long u = q.front();
q.pop();
for (auto &i : adj[u]) {
if (col[i] && col[u] == col[i]) {
flag = false;
}
}
for (auto &i : adj[u]) {
if (!vis[i]) {
col[i] = col[u] % 2 + 1;
vis[i] = 1;
q.push(i);
}
}
}
}
signed main() {
cin >> n >> m;
for (long long i = 0; i < m; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (long long i = 1; i <= n; i++) {
if (!vis[i] && adj[i].size() != 0) {
bfs(i);
}
}
for (long long i = 1; i <= n; i++) {
if (col[i] == 1) {
ans1.push_back(i);
} else if (col[i] == 2) {
ans2.push_back(i);
}
}
if (!flag) {
cout << -1 << "\n";
return 0;
}
cout << ans1.size() << "\n";
for (long long x : ans1) {
cout << x << " ";
}
cout << "\n";
cout << ans2.size() << "\n";
for (long long x : ans2) {
cout << x << " ";
}
}
|
#include <bits/stdc++.h>
#pragma optimize("", off)
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma comment(linker, "/STACK:36777216")
const int mod = 1000000007;
using namespace std;
template <class T>
void smin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void smax(T& a, T val) {
if (a < val) a = val;
}
template <typename T>
inline std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
bool first = true;
os << "[";
for (auto i : v) {
if (!first) os << ", ";
os << i;
first = false;
}
return os << "]";
}
const int N = 1e5 + 10;
int n, m;
std::vector<int> v[N];
bool vis[N], good;
std::vector<int> ans[2];
int variety[N];
void dfs(int s, int type) {
if (!good) return;
vis[s] = 1;
variety[s] = type;
ans[type].push_back(s);
for (auto i : v[s]) {
if (!vis[i]) {
dfs(i, !type);
} else {
if (variety[i] == type) {
good = false;
return;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, w;
cin >> u >> w;
v[u].push_back(w);
v[w].push_back(u);
}
good = true;
for (int i = 1; i <= n; ++i) {
if (!vis[i] and int(v[i].size())) {
dfs(i, 1);
if (!good) {
cout << -1;
return 0;
}
}
}
for (int i = 0; i < 2; ++i) {
cout << int(ans[i].size()) << '\n';
for (auto j : ans[i]) cout << j << ' ';
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> c;
vector<int> a;
vector<int> a1;
vector<int> a2;
vector<int> used;
bool exitt = false;
void DFS(int k, int t) {
if (t == 1) {
a1.push_back(k);
used[k] = 1;
a[k] = 1;
} else {
a2.push_back(k);
used[k] = 1;
a[k] = 2;
}
for (int i = 0; i < c[k].size(); i++) {
if (a[c[k][i]] == t) {
exitt = true;
return;
} else {
if (used[c[k][i]] == 0) {
if (t == 1) {
DFS(c[k][i], 2);
} else {
DFS(c[k][i], 1);
}
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
a.resize(n);
c.resize(n);
used.resize(n);
for (int i = 0; i < m; i++) {
int a1, a2;
cin >> a1 >> a2;
a1--;
a2--;
c[a1].push_back(a2);
c[a2].push_back(a1);
}
for (int i = 0; i < n; i++) {
if (used[i] == 0) {
DFS(i, 1);
}
}
if (exitt) {
cout << "-1";
} else {
cout << a1.size() << endl;
for (int i = 0; i < a1.size(); i++) {
cout << a1[i] + 1 << " ";
}
cout << endl;
cout << a2.size() << endl;
for (int i = 0; i < a2.size(); i++) {
cout << a2[i] + 1 << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> e[110000];
int a, b, c[110000], f, g;
void dfs(int x, int y) {
if (f) return;
c[x] = y;
for (int i = 0; i < e[x].size(); i++)
if (!c[e[x][i]])
dfs(e[x][i], 3 - y);
else if (c[e[x][i]] == y) {
f = 1;
return;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
e[a].push_back(b);
e[b].push_back(a);
}
f = 0;
g = 1;
for (int i = 1; i <= n; i++)
if (!c[i]) {
dfs(i, g);
g = 3 - g;
}
if (f)
printf("-1\n");
else {
a = b = 0;
for (int i = 1; i <= n; i++)
if (c[i] == 1)
a++;
else if (c[i] == 2)
b++;
printf("%d\n", a);
for (int i = 1; i <= n; i++)
if (c[i] == 1) {
if (a) {
printf("%d", i);
a = 0;
} else
printf(" %d", i);
}
printf("\n%d\n", b);
for (int i = 1; i <= n; i++)
if (c[i] == 2) {
if (b) {
printf("%d", i);
b = 0;
} else
printf(" %d", i);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> mm[1000000], s[2];
int color[100005];
int f = 0;
void dfs(int v, int c) {
if (f) {
return;
}
if (color[v] != -1) {
if (color[v] != c) f = 1;
return;
}
color[v] = c;
s[c].push_back(v);
for (int i = 0; i < mm[v].size(); i++) {
dfs(mm[v][i], c ^ 1);
}
}
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
int x, y;
for (int i = 0; i < m; i++) {
scanf("%d", &x);
scanf("%d", &y);
mm[x].push_back(y);
mm[y].push_back(x);
}
memset(color, -1, sizeof(color));
for (int i = 1; i <= n; i++) {
if (color[i] == -1) {
dfs(i, 0);
}
}
if (f) {
puts("-1");
} else {
for (int i = 0; i < 2; i++) {
printf("%d\n", s[i].size());
for (int j = 0; j < s[i].size(); j++) {
if (j) puts(" ");
printf("%d", s[i][j]);
}
printf("\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, x[200005], y[200005];
vector<long long> dsk[200005];
long long gd[200005], kt, xh[200005];
void input() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) dsk[i].clear();
for (long long i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
dsk[x[i]].push_back(y[i]);
dsk[y[i]].push_back(x[i]);
}
}
void dfs(long long u) {
xh[u] = 1;
for (long long j = 0; j < dsk[u].size(); j++) {
long long v = dsk[u][j];
if (xh[v] == 0) {
gd[v] = 1 - gd[u];
}
if (xh[v] == 1 && gd[v] == gd[u]) {
kt = 0;
return;
} else if (xh[v]) {
continue;
}
dfs(v);
}
}
void output() {
if (kt == 0)
cout << "-1";
else {
long long d1 = 0, d2 = 0;
for (long long i = 1; i <= n; i++) {
if (gd[i] == 0) d1++;
}
cout << d1 << endl;
for (long long i = 1; i <= n; i++) {
if (gd[i] == 0) cout << i << " ";
}
cout << endl;
for (long long i = 1; i <= n; i++) {
if (gd[i] == 1) d2++;
}
cout << d2 << endl;
for (long long i = 1; i <= n; i++) {
if (gd[i] == 1) cout << i << " ";
}
}
}
void solve() {
kt = 1;
for (long long i = 1; i <= n; i++) {
gd[i] = -1;
xh[i] = 0;
}
for (long long i = 1; i <= n; i++) {
if (xh[i] == 0) gd[i] = 1;
dfs(i);
if (!kt) {
return;
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
input();
solve();
output();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> dp;
int col[100004];
bool ff;
bool vis[100004];
void dfs(int i, int j, int k) {
if (vis[i]) {
if (col[i] != -1 && col[i] != k) {
ff = true;
}
return;
}
vis[i] = true;
col[i] = k;
for (int kj : dp[i]) {
if (kj != j) {
dfs(kj, i, k ^ 1);
}
}
}
int main() {
int n, m;
cin >> n >> m;
dp.resize(n);
for (long long i = 0; i < m; i++) {
int xx, yy;
cin >> xx >> yy;
--xx;
--yy;
dp[xx].push_back(yy);
dp[yy].push_back(xx);
}
memset(col, -1, sizeof col);
ff = false;
vector<long long> ans[2];
memset(vis, false, sizeof vis);
for (long long i = 0; i < n; i++) {
if (!vis[i]) {
dfs(i, i, 0);
}
}
if (ff) {
cout << -1 << endl;
exit(0);
;
}
for (long long i = 0; i < n; i++) {
ans[col[i]].push_back(i + 1);
}
for (long long i = 0; i < 2; i++) {
cout << ans[i].size() << endl;
for (long long j = 0; j < ans[i].size(); j++) cout << ans[i][j] << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v1, v2;
map<int, int> mp;
set<int> st;
string s, s1;
vector<vector<int> > graph(100005);
int mark[100005] = {0};
int bfs(int src) {
int t[4] = {0, 1, 3, 2};
queue<int> q;
q.push(src);
mark[src] = 2;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto i = graph[u].begin(); i != graph[u].end(); i++) {
if (mark[*i] == mark[u])
return 1;
else if (mark[*i] == 0) {
q.push(*i);
mark[*i] = t[mark[u]];
}
}
}
}
int main() {
int n, m, a, b, two = 0, three = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (mark[i] == 0) {
int al = bfs(i);
if (al == 1) {
cout << "-1";
return 0;
}
}
}
for (int i = 1; i <= n; i++) {
if (mark[i] == 2)
v1.push_back(i);
else if (mark[i] == 3)
v2.push_back(i);
}
cout << v1.size() << endl;
for (int i = 0; i < v1.size(); i++) cout << v1[i] << ' ';
cout << endl << v2.size() << endl;
for (int i = 0; i < v2.size(); i++) cout << v2[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[100005];
int color[100005];
bool dfs(int u) {
int num = G[u].size();
for (int i = 0; i < num; i++) {
int v = G[u][i];
if (color[v] == -1) {
color[v] = 1 - color[u];
if (!dfs(v)) return false;
} else if (color[u] == color[v])
return false;
}
return true;
}
int main() {
int n, m, i;
int a, b;
scanf("%d%d", &n, &m);
for (i = 0; i <= n; i++) color[i] = -1;
for (i = 0; i < m; i++) {
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
for (i = 1; i <= n; i++) {
if (color[i] == -1) {
if (G[i].size() != 0) {
color[i] = 0;
if (!dfs(i)) {
cout << "-1" << endl;
return 0;
}
}
}
}
int n1 = 0, n2 = 0;
for (i = 1; i <= n; i++) {
if (color[i] == 1) n1++;
if (color[i] == 0) n2++;
}
cout << n1 << endl;
for (i = 1; i <= n; i++) {
if (color[i] == 1) cout << i << " ";
}
cout << endl << n2 << endl;
for (i = 1; i <= n; i++) {
if (color[i] == 0) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = N * 2;
int h[N], ne[M], e[M], idx;
int n, m, col[N];
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx++;
e[idx] = a, ne[idx] = h[b], h[b] = idx++;
}
bool dfs(int u, int c) {
col[u] = c;
for (int i = h[u]; ~i; i = ne[i]) {
if (!col[e[i]]) {
if (!dfs(e[i], 3 - c)) return false;
} else if (col[e[i]] == c)
return false;
}
return true;
}
int main() {
cin >> n >> m;
memset(h, -1, sizeof h);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d %d", &a, &b);
add(a, b);
}
for (int i = 1; i <= n; i++) {
if (!col[i]) {
if (!dfs(i, 1)) {
cout << -1 << endl;
return 0;
}
}
}
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= n; i++)
if (col[i] == 1)
cnt1++;
else
cnt2++;
printf("%d\n", cnt1);
for (int i = 1; i <= n; i++) {
if (col[i] == 1) printf("%d ", i);
}
printf("\n");
printf("%d\n", cnt2);
for (int i = 1; i <= n; i++)
if (col[i] == 2) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int v, e;
cin >> v >> e;
vector<int> adj[v];
for (int i = 0; i < e; i++) {
int f, s;
cin >> f >> s;
f--, s--;
adj[f].push_back(s);
adj[s].push_back(f);
}
int col[v];
for (int i = 0; i < v; i++) {
col[i] = -1;
}
int fircol = 0;
int seccol = 0;
for (int i = 0; i < v; i++) {
if (col[i] == -1) {
col[i] = 0;
fircol++;
queue<int> q;
q.push(i);
while (!q.empty()) {
int fr = q.front();
q.pop();
for (int j = 0; j < adj[fr].size(); j++) {
int next = adj[fr][j];
if (col[next] == -1) {
col[next] = !col[fr];
if (col[next] == 0) {
fircol++;
} else {
seccol++;
}
q.push(next);
} else if (col[next] == col[fr]) {
cout << -1;
return 0;
}
}
}
}
}
cout << fircol << endl;
for (int i = 0; i < v; i++) {
if (col[i] == 0) {
cout << i + 1 << ' ';
}
}
cout << endl;
cout << seccol << endl;
for (int i = 0; i < v; i++) {
if (col[i] == 1) {
cout << i + 1 << ' ';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, from, to, cost;
vector<int> g[100001];
vector<int> color, visited;
bool possible = true;
bool dfs(int v) {
for (int u : g[v]) {
if (visited[u] == false) {
visited[u] = true;
color[u] = !color[v];
if (!dfs(u)) return false;
} else if (color[u] == color[v])
return false;
}
return true;
}
int main() {
cin >> n >> m;
color.resize(n + 1);
visited.resize(n + 1, 0);
fill(color.begin(), color.end(), -1);
for (int i = 0; i < m; i++) {
cin >> from >> to;
g[from].push_back(to);
g[to].push_back(from);
}
color[1] = 0;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
if (!dfs(i)) {
cout << -1;
return 0;
}
}
}
vector<int> set1, set2;
for (int i = 1; i <= n; i++) {
if (color[i] == 1) {
set1.push_back(i);
} else if (color[i] == 0) {
set2.push_back(i);
}
}
cout << set1.size() << "\n";
for (auto a : set1) cout << a << " ";
cout << "\n";
cout << set2.size() << "\n";
for (auto a : set2) cout << a << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > v(100001);
vector<int> vis(100001);
vector<int> lvl(100001);
vector<int> col(100001);
vector<int> col1, col2;
int bfs(int s) {
queue<int> q;
q.push(s);
lvl[s] = 0;
col[s] = 0;
vis[s] = 1;
int f = 0;
if (v[s].size() == 0) return 0;
while (!q.empty()) {
int p = q.front();
q.pop();
if (col[p] == 1)
col1.push_back(p);
else if (col[p] == 0)
col2.push_back(p);
for (int i = 0; i < v[p].size(); i++) {
if (col[v[p][i]] == -1) {
col[v[p][i]] = !col[p];
lvl[v[p][i]] = lvl[p] + 1;
q.push(v[p][i]);
} else {
if (col[v[p][i]] == col[p]) f = 1;
}
}
}
if (f == 1) return -1;
return 1;
}
int main() {
int n, m;
cin >> n >> m;
fill(vis.begin(), vis.end(), 0);
fill(col.begin(), col.end(), -1);
fill(lvl.begin(), lvl.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);
}
int x = 1;
for (int i = 1; i <= n; i++) {
int a;
if (col[i] == -1) a = bfs(i);
if (a == -1) {
x = 0;
break;
}
}
if (x == 0)
cout << -1;
else {
cout << col1.size() << endl;
for (int i = 0; i < col1.size(); i++) cout << col1[i] << " ";
cout << endl;
cout << col2.size() << endl;
for (int i = 0; i < col2.size(); i++) cout << col2[i] << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
vector<int> g[N];
int color[N];
bool possible = true;
vector<int> color_vec[2];
int n, m;
void dfs(int curr, int prev) {
for (int next : g[curr]) {
if (next != prev && possible) {
int ncolor = 1 - color[curr];
if (color[next] == -1) {
color[next] = ncolor;
color_vec[ncolor].emplace_back(next);
dfs(next, curr);
} else if (color[next] != ncolor) {
possible = false;
return;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
color[i] = -1;
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].emplace_back(b);
g[b].emplace_back(a);
}
for (int start = 0; start < n; ++start) {
if (color[start] == -1 && possible) {
color[start] = 0;
color_vec[0].emplace_back(start);
dfs(start, -1);
}
}
if (possible) {
for (auto &c : color_vec) {
cout << c.size() << '\n';
for (int node : c) {
cout << node + 1 << ' ';
}
cout << '\n';
}
} else {
cout << -1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1e5 + 5;
int color[max_n];
vector<int> G[max_n];
vector<int> ans[2];
bool dfs(int now, int Color) {
color[now] = Color;
ans[Color].push_back(now);
for (int i = 0; i < G[now].size(); i++) {
if (color[now] == color[G[now][i]])
return false;
else if (color[G[now][i]] == -1 && !dfs(G[now][i], !Color))
return false;
}
return true;
}
int main() {
int T = 1;
while (T--) {
int n, m, st;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) color[i] = -1;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
bool flag = 1;
for (int i = 1; i <= n; i++)
if (color[i] == -1)
if (dfs(i, 0) == 0) flag = 0;
if (flag == 0)
printf("-1");
else {
printf("%d\n", ans[0].size());
for (int i = 0; i < ans[0].size(); i++) printf("%d ", ans[0][i]);
printf("\n%d\n", ans[1].size());
for (int i = 0; i < ans[1].size(); i++) printf("%d ", ans[1][i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e5 + 5;
int ver[N * 2], Next[N * 2], head[N], col[N];
int tot, n, m;
vector<int> Size[3];
bool flag;
void add(int x, int y) {
ver[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
}
void dfs(int x, int color) {
if (!flag) return;
col[x] = color;
Size[color].push_back(x);
for (int i = head[x]; ~i; i = Next[i]) {
int &y = ver[i];
if (!col[y])
dfs(y, 3 - color);
else if (col[y] == col[x]) {
flag = false;
return;
}
}
}
int main() {
scanf("%d%d", &n, &m);
flag = true;
memset(head, -1, sizeof(head));
int x, y;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
for (int i = 1; i <= n && flag; i++) {
if (!col[i]) dfs(i, 1);
}
if (!flag)
puts("-1");
else {
printf("%d\n", Size[1].size());
int len = Size[1].size();
for (int i = 0; i < len; i++) {
printf("%d%c", Size[1][i], i != len - 1 ? ' ' : '\n');
}
printf("%d\n", Size[2].size());
len = Size[2].size();
for (int i = 0; i < len; i++) {
printf("%d%c", Size[2][i], i != len - 1 ? ' ' : '\n');
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int flag, cnt[2];
const int MAXN = 1e5;
int vis[MAXN + 10];
int has[MAXN + 10];
int ans[2][MAXN + 10];
vector<int> e[MAXN + 10];
void dfs(int u, int f) {
has[u] = 1;
int k = (int)e[u].size();
for (int i = 0; i < k; i++) {
int v = e[u][i];
if (v == f) continue;
if (vis[v] == vis[u]) {
flag = 0;
return;
}
if (vis[v] == 0) {
if (vis[u] == 1)
vis[v] = 2;
else
vis[v] = 1;
ans[vis[v] - 1][cnt[vis[v] - 1]++] = v;
}
}
for (int i = 0; i < k; i++) {
int v = e[u][i];
if (has[v]) continue;
if (v == f) continue;
dfs(v, u);
if (!flag) return;
}
}
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
memset(vis, 0, sizeof vis);
memset(ans, 0, sizeof ans);
memset(has, 0, sizeof has);
for (int i = 0; i <= n; i++) e[i].clear();
for (int i = 0, u, v; i < m; i++) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
flag = 1;
cnt[0] = cnt[1] = 0;
for (int i = 1; i <= n && flag; i++) {
if (vis[i] == 0) {
vis[i] = 1;
ans[0][cnt[0]++] = i;
dfs(i, -1);
}
}
if (flag) {
printf("%d\n", cnt[0]);
for (int i = 0; i < cnt[0]; i++) {
printf("%d%c", ans[0][i], i == cnt[0] - 1 ? '\n' : ' ');
}
printf("%d\n", cnt[1]);
for (int i = 0; i < cnt[1]; i++) {
printf("%d%c", ans[1][i], i == cnt[1] - 1 ? '\n' : ' ');
}
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, next;
} edge[1000100];
int n, m, flag, vis[1000100];
int tot, head[1000100], ans;
void init() {
tot = 0;
memset(head, -1, sizeof(head));
}
void add_edge(int u, int v) {
edge[tot].to = v;
edge[tot].next = head[u];
head[u] = tot++;
}
void dfs(int u, int val) {
vis[u] = val;
if (vis[u]) ans++;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (vis[v] != -1) {
if (vis[v] == vis[u]) flag = 0;
continue;
}
dfs(v, vis[u] ^ 1);
}
}
int main() {
int t;
while (scanf("%d%d", &n, &m) != EOF) {
init();
memset(vis, -1, sizeof(vis));
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
flag = 1;
ans = 0;
for (int i = 1; i <= n; i++)
if (vis[i] == -1) dfs(i, 1);
if (!flag)
printf("-1\n");
else {
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (vis[i] == 1) printf("%d ", i);
printf("\n");
printf("%d\n", n - ans);
for (int i = 1; i <= n; i++)
if (!vis[i]) printf("%d ", i);
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v);
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
template <typename A, typename B>
istream &operator>>(istream &cin, pair<A, B> &p) {
cin >> p.first;
return cin >> p.second;
}
long long seed = std::chrono::steady_clock::now().time_since_epoch().count();
mt19937_64 rng(seed);
void usaco(string filename) {
freopen((filename + ".in").c_str(), "r", stdin);
freopen((filename + ".out").c_str(), "w", stdout);
}
const long double pi = 3.14159265358979323846;
long long n, m, k, q, l, r, x, y, z;
const long long template_array_size = 1e6 + 9097;
long long a[template_array_size];
long long b[template_array_size];
long long c[template_array_size];
string second, t;
long long ans = 0;
vector<long long> edges[100005];
bool vis[100005];
bool col[100005];
bool possible = 1;
void dfs(long long v, bool c) {
if (vis[v]) return;
vis[v] = 1;
col[v] = c;
for (long long x : edges[v]) {
if (!vis[x]) {
dfs(x, c ^ 1);
} else {
if (c == col[x]) {
possible = 0;
}
}
}
}
void solve(int tc = 0) {
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
--u;
--v;
edges[u].push_back(v);
edges[v].push_back(u);
}
for (long long i = 0; i < n; i++) {
if (!vis[i]) {
dfs(i, 0);
}
}
if (possible) {
long long cnt[2] = {0};
for (long long i = 0; i < n; i++) ++cnt[col[i]];
cout << cnt[0] << '\n';
for (long long i = 0; i < n; i++) {
if (col[i] == 0) {
cout << i + 1 << " ";
}
}
cout << '\n';
cout << cnt[1] << '\n';
for (long long i = 0; i < n; i++) {
if (col[i] == 1) {
cout << i + 1 << " ";
}
}
cout << '\n';
} else {
cout << -1 << '\n';
}
}
int main() {
{ ios_base::sync_with_stdio(false); }
{ cin.tie(NULL); }
cout << setprecision(12) << fixed;
int tc = 1;
for (int t = 0; t < tc; t++) solve(t);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> graph;
int n, m;
vector<int> reds;
vector<int> blacks;
vector<int> colours;
bool bfs(int s) {
queue<int> q;
q.push(s);
colours[s] = 1;
reds.push_back(s);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : graph[u]) {
if (colours[v] == 0) {
q.push(v);
if (colours[u] == 1) {
colours[v] = 2;
blacks.push_back(v);
} else {
colours[v] = 1;
reds.push_back(v);
}
} else if (colours[v] == colours[u]) {
return false;
}
}
}
return true;
}
bool is_bipartite() {
colours.resize(n);
fill(colours.begin(), colours.end(), 0);
for (int i = 0; i < n; i++) {
if (colours[i] == 0) {
if (!bfs(i)) {
return false;
}
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
graph.resize(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
graph[u].push_back(v);
graph[v].push_back(u);
}
if (!is_bipartite()) {
cout << -1 << '\n';
} else {
cout << reds.size() << '\n';
for (int u : reds) {
cout << u + 1 << ' ';
}
cout << '\n';
cout << blacks.size() << '\n';
for (int u : blacks) {
cout << u + 1 << ' ';
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> b[100000];
bool result = true;
int color[100000];
void f(int a) {
int col;
if (color[a] == 1)
col = 2;
else
col = 1;
for (int i = 0; i < b[a].size(); i++) {
int t = b[a].at(i);
if (color[t] != 0 && color[t] != col) {
result = false;
return;
}
if (color[t] == 0) {
color[t] = col;
f(t);
}
}
}
int main() {
cin >> n >> m;
int a[2];
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
b[u].push_back(v);
b[v].push_back(u);
}
for (int i = 0; i < n; i++) {
color[i] = 0;
}
color[0] = 1;
for (int i = 0; i < n; i++) {
f(i);
}
if (!result) {
cout << -1 << endl;
} else {
int counter = 0;
for (int i = 0; i < n; i++) {
if (color[i] != 2) {
counter++;
}
}
cout << counter << endl;
for (int i = 0; i < n; i++) {
if (color[i] != 2) {
cout << i + 1 << ' ';
}
}
cout << endl;
cout << n - counter << endl;
for (int i = 0; i < n; i++) {
if (color[i] == 2) {
cout << i + 1 << ' ';
}
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& out, vector<T>& v) {
for (auto a : v) out << a << " ";
return out;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& v) {
for (auto& a : v) in >> a;
return in;
}
template <typename T>
ostream& operator<<(ostream& out, multiset<T>& S) {
for (auto a : S) out << a << " ";
return out;
}
template <typename T>
ostream& operator<<(ostream& out, set<T>& S) {
for (auto a : S) out << a << " ";
return out;
}
template <typename T>
set<T> operator+(set<T> A, set<T> B) {
for (auto b : B) A.insert(b);
return A;
}
int V[100005];
vector<int> E[100005];
int D[100005];
int O[100005];
void dfs(int s) {
if (V[s]) return;
V[s] = 1;
for (auto t : E[s]) {
if (!V[t]) {
D[t] = D[s] + 1;
dfs(t);
} else {
if (D[s] > D[t] && (D[s] - D[t]) % 2 == 0) {
O[s] = 1;
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
while (m--) {
int a, b;
cin >> a >> b;
a--, b--;
E[a].push_back(b);
E[b].push_back(a);
}
for (int i = 0; i < n; i++) {
dfs(i);
}
int oddSum = accumulate(O, O + n, 0);
set<int> A;
set<int> B;
if (oddSum > 0) {
cout << -1 << endl;
} else {
for (int i = 0; i < n; i++) {
if (D[i] % 2 == 0)
A.insert(i + 1);
else
B.insert(i + 1);
}
cout << A.size() << endl;
cout << A << endl;
cout << B.size() << endl;
cout << B << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> edge[N];
int color[N], vis[N];
queue<int> test;
int n, m;
void init() {
for (int i = 1; i <= n; i++) {
vis[i] = 0;
color[i] = -1;
}
}
int work(int u) {
vis[u] = 1;
color[u] = 1;
test.push(u);
while (!test.empty()) {
int ai = test.front();
test.pop();
for (int i = 0; i < (int)edge[ai].size(); i++) {
int v = edge[ai][i];
if (color[v] == -1) {
color[v] = 1 - color[ai];
vis[v] = 1;
test.push(v);
}
if (color[v] == color[ai]) return 0;
}
}
return 1;
}
int main() {
vector<int> a, b;
scanf("%d%d", &n, &m);
init();
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
int flag = 1;
for (int i = 1; i <= n; i++) {
if (color[i] == -1) {
flag = work(i);
if (!flag) return 0 * printf("-1\n");
}
}
for (int i = 1; i <= n; i++) {
if (color[i] == 1) {
a.push_back(i);
} else {
b.push_back(i);
}
}
cout << (int)a.size() << endl;
for (int i = 0; i < (int)a.size(); i++) {
printf("%d ", a[i]);
}
cout << endl;
cout << (int)b.size() << endl;
for (int i = 0; i < (int)b.size(); i++) {
printf("%d ", b[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 1;
vector<int> zero;
vector<int> one;
int color[mx];
vector<int> nodes[mx];
bool isPosiible(int vertex) {
queue<int> Q;
Q.push(vertex);
color[vertex] = 0;
zero.push_back(vertex);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i < nodes[u].size(); i++) {
int v = nodes[u][i];
if (color[v] == -1) {
if (color[u] == 0) {
color[v] = 1;
one.push_back(v);
} else {
color[v] = 0;
zero.push_back(v);
}
Q.push(v);
}
if (color[u] == color[v]) {
return false;
}
}
}
}
int main() {
int n, m, a, b;
cin >> n >> m;
int ver = INT_MAX;
while (m--) {
cin >> a >> b;
ver = min(a, min(b, ver));
nodes[a].push_back(b);
nodes[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
color[i] = -1;
}
for (int i = 1; i <= n; i++) {
if (color[i] == -1) {
if (nodes[i].size() == 0) {
continue;
}
if (!isPosiible(i)) {
cout << "-1" << endl;
return 0;
}
}
}
cout << (int)zero.size() << endl;
for (int j = 0; j < zero.size(); j++) {
cout << zero[j] << " ";
}
cout << endl;
cout << (int)one.size() << endl;
for (int j = 0; j < one.size(); j++) {
cout << one[j] << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template class std::vector<int>;
bool flag = true;
vector<vector<int> > vec;
vector<int> color;
void dfs(int source, vector<bool>& visited, int parent) {
if (!visited[source]) {
visited[source] = true;
if (parent == -1)
color[source] = 0;
else {
color[source] = !color[parent];
}
for (auto child : vec[source]) dfs(child, visited, source);
} else {
if (parent != -1 && color[source] != !color[parent]) flag = false;
}
}
int main() {
ios ::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vec = vector<vector<int> >(n);
color = vector<int>(n, -1);
for (int i = 0; i < (m); i++) {
int u, v;
cin >> u >> v;
u--;
v--;
vec[u].push_back(v);
vec[v].push_back(u);
}
vector<bool> visited(n, false);
for (int i = 0; i < ((int)(visited).size()); i++) {
if (!visited[i]) dfs(i, visited, -1);
}
if (flag == false) {
cout << "-1\n";
} else {
int one = 0, zero = 0;
for (int i = 0; i < ((int)(color).size()); i++) {
if (color[i] == 0)
zero++;
else if (color[i] == 1)
one++;
}
if (one == 0 || zero == 0) {
cout << "-1\n";
return (0);
}
cout << zero << "\n";
for (int i = 0; i < ((int)(color).size()); i++) {
if (color[i] == 0) cout << i + 1 << " ";
}
cout << "\n" << one << "\n";
for (int i = 0; i < ((int)(color).size()); i++) {
if (color[i] == 1) cout << i + 1 << " ";
}
cout << "\n";
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
int root = -1;
double f(double n, double m, int& ans) {
if (n == m) {
return m;
}
if (n < m) {
ans += (m - ceil(n / 2));
return ceil(n / 2);
}
double a = ceil(n / 2);
double b = f(a, m, ans);
ans += (b - a);
++ans;
return a * 2;
}
bool bpC(vector<vector<long long int> >& gr, vector<int>& color, int u) {
queue<int> qu;
vector<bool> visit(gr.size());
color[u] = 1;
qu.push(u);
while (!qu.empty()) {
int c = qu.front();
qu.pop();
if (!visit[c]) {
for (int i = 0; i < gr[c].size(); i++) {
if (color[c] == color[gr[c][i]]) {
return 0;
}
color[gr[c][i]] = ((color[c]) % 2) + 1;
if (!visit[gr[c][i]]) {
qu.push(gr[c][i]);
}
}
}
visit[c] = 1;
}
return 1;
}
int main() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
vector<vector<long long int> > gr(n + 1);
int temp = -1;
vector<int> color(n + 1);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
root = u;
gr[u].push_back(v);
gr[v].push_back(u);
}
for (int i = 1; i < color.size(); i++) {
if (color[i] == 0) {
if (gr[i].size() != 0) {
if (bpC(gr, color, i) == 0) {
cout << -1 << "\n";
return 0;
}
}
}
}
long long int red = 0, blue = 0;
for (int i = 1; i < color.size(); i++) {
if (color[i] == 1) {
red++;
} else if (color[i] == 2) {
++blue;
}
}
cout << blue << "\n";
for (int i = 1; i < color.size(); i++) {
if (color[i] == 2) {
cout << i << " ";
}
}
cout << "\n";
cout << red << "\n";
for (int i = 1; i < color.size(); i++) {
if (color[i] == 1) {
cout << i << " ";
}
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int point[100050];
struct node {
int v;
int nex;
};
node b[200050];
int cnt;
void add(int u, int v) {
b[cnt].v = v;
b[cnt].nex = point[u];
point[u] = cnt;
cnt++;
}
int co[100050];
bool bfs(int z) {
queue<int> q;
q.push(z);
co[z] = 1;
while (!q.empty()) {
int f = q.front();
q.pop();
for (int tt = point[f]; tt != -1; tt = b[tt].nex) {
int v = b[tt].v;
if (co[v] == 0) {
if (co[f] == 1) {
co[v] = 2;
q.push(v);
} else {
co[v] = 1;
q.push(v);
}
} else if (co[v] == co[f]) {
return false;
} else {
continue;
}
}
}
return true;
}
int main() {
cin >> n >> m;
cnt = 0;
for (int i = 1; i <= n; i++) {
point[i] = -1;
co[i] = 0;
}
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
add(u, v);
add(v, u);
}
bool ans = true;
for (int i = 1; i <= n; i++) {
if (co[i] == 0) {
ans = bfs(i);
if (ans == false) {
printf("-1\n");
break;
}
}
}
if (ans == true) {
int res = 0;
for (int i = 1; i <= n; i++) {
if (co[i] == 1) {
res++;
}
}
printf("%d\n", res);
int c = 0;
for (int i = 1; i <= n; i++) {
if (co[i] == 1) {
printf("%d", i);
c++;
if (c == res)
printf("\n");
else
printf(" ");
}
}
c = 0;
res = 0;
for (int i = 1; i <= n; i++) {
if (co[i] != 1) {
res++;
}
}
printf("%d\n", res);
for (int i = 1; i <= n; i++) {
if (co[i] != 1) {
printf("%d", i);
c++;
if (c == res)
printf("\n");
else
printf(" ");
}
}
}
}
|
#include <bits/stdc++.h>
const int N = 200000;
struct edge {
int to, next;
} e[2 * N];
int n, m, head[N], cnt = 0;
int a[N], b[N], ca, cb;
int color[N];
std::queue<int> Q;
int main() {
scanf("%d%d", &n, &m);
int x, y;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
e[++cnt].to = y;
e[cnt].next = head[x];
head[x] = cnt;
e[++cnt].to = x;
e[cnt].next = head[y];
head[y] = cnt;
}
while (!Q.empty()) Q.pop();
for (int i = 1; i <= n; i++)
if (!color[i]) {
if (head[i] != 0) a[++ca] = i;
color[i] = 1;
Q.push(i);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = head[x]; i; i = e[i].next) {
if (!color[e[i].to]) {
if (color[x] == 1) {
color[e[i].to] = 2;
b[++cb] = e[i].to;
Q.push(e[i].to);
} else {
color[e[i].to] = 1;
a[++ca] = e[i].to;
Q.push(e[i].to);
}
} else {
if (color[x] == color[e[i].to]) {
printf("-1\n");
return 0;
}
}
}
}
}
printf("%d\n", ca);
for (int i = 1; i <= ca; i++) printf("%d ", a[i]);
printf("\n");
printf("%d\n", cb);
for (int i = 1; i <= cb; i++) printf("%d ", b[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
const int N = 1e5 + 10, M = 1e6 + 10, OOm = 0x3f3f3f3f;
string blank = "";
int n, m;
int color[N];
vector<int> edges[N];
bool bfs(int node) {
queue<int> q;
q.push(node);
color[node] = 0;
while (!q.empty()) {
node = q.front();
q.pop();
for (auto child : edges[node]) {
if (~color[child]) {
if (color[child] != 1 - color[node]) {
return true;
}
} else {
color[child] = 1 - color[node];
q.push(child);
}
}
}
return false;
}
void solve() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
edges[u].push_back(v);
edges[v].push_back(u);
}
memset(color, -1, sizeof color);
for (int i = 1; i <= n; i++) {
if (color[i] == -1) {
if (bfs(i)) {
cout << -1;
return;
}
}
}
vector<int> _0, _1;
for (int i = 1; i <= n; i++) {
if (~color[i]) {
if (color[i] == 0)
_0.push_back(i);
else
_1.push_back(i);
}
}
cout << _0.size() << endl;
for (auto x : _0) cout << x << ' ';
cout << endl << _1.size() << endl;
for (auto x : _1) cout << x << ' ';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
cerr << "Time elapsed: " << clock() / 1000 << " ms" << endl;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.