text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using repType = int;
const int MAXN = 1e5 + 5;
struct Edge {
int u, v, w;
Edge() = default;
Edge(int _u, int _v, int _w) : u(_u), v(_v), w(_w) {}
};
vector<Edge> edges;
vector<int> G[MAXN];
void add_edge(int u, int v, int w) {
edges.push_back(Edge(u, v, w));
G[u].push_back(int(edges.size()) - 1);
}
int ans = 0x3f3f3f3f;
int color[MAXN], zcnt = 0, ocnt = 0;
bool ok = true;
void dfs(int pnt, int clr) {
if (!ok) return;
color[pnt] = clr;
for (auto i : G[pnt]) {
auto& v = edges[i].v;
if (color[v] == clr) {
ok = false;
return;
} else if (color[v] == -1) {
if ((clr ^ 1) == 0)
zcnt++;
else
ocnt++;
dfs(v, clr ^ 1);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (repType i = (1); i <= (m); ++i) {
int u, v;
cin >> u >> v;
add_edge(u, v, 1);
add_edge(v, u, 1);
}
memset(color, -1, sizeof(color));
for (repType i = (1); i <= (n); ++i) {
if (color[i] == -1) {
if (zcnt == 0) {
zcnt++;
dfs(i, 0);
} else {
ocnt++;
dfs(i, 1);
}
}
if (!ok) break;
}
if (!ok)
cout << -1 << endl;
else {
cout << ocnt << endl;
for (repType i = (1); i <= (n); ++i)
if (color[i] == 1) cout << i << " ";
cout << endl;
cout << zcnt << endl;
for (repType i = (1); i <= (n); ++i)
if (color[i] == 0) cout << i << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
std::vector<int> edges[1 + 100000];
int vizNode[1 + 100000];
bool ok = 1;
void dfs(int node, int tmp) {
vizNode[node] = tmp;
tmp = tmp % 2 + 1;
for (int i = 0; i < edges[node].size(); ++i) {
int newNode = edges[node][i];
if (vizNode[newNode] != tmp && vizNode[newNode]) {
ok = 0;
}
if (!vizNode[newNode]) dfs(newNode, tmp);
}
}
int main() {
int N, M;
std::cin >> N >> M;
int x, y;
for (int i = 1; i <= M; ++i) {
std::cin >> x >> y;
edges[x].push_back(y);
edges[y].push_back(x);
}
for (int i = 1; i <= N; ++i)
if (!vizNode[i]) dfs(i, 1);
if (ok == 0)
std::cout << "-1\n";
else {
int ans = 0;
for (int i = 1; i <= N; ++i)
if (vizNode[i] == 1) ++ans;
std::cout << ans << '\n';
for (int i = 1; i <= N; ++i)
if (vizNode[i] == 1) std::cout << i << ' ';
std::cout << '\n' << N - ans << '\n';
for (int i = 1; i <= N; ++i)
if (vizNode[i] == 2) std::cout << i << ' ';
std::cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
queue<long long> MineA;
queue<long long> MineB;
struct Vertex {
vector<long long> WhatVertices;
bool Who;
bool Visited;
};
long long N, M, A, B;
Vertex V[100005];
bool DFS(long long a) {
V[a].Visited = true;
for (long long o : V[a].WhatVertices) {
if (V[o].Visited && V[a].Who == V[o].Who) {
return false;
}
if (!V[o].Visited) {
V[o].Who = !V[a].Who;
if (!DFS(o)) {
return false;
}
}
}
return true;
}
bool Can() {
for (long long i = 1; i <= N; i++) {
if (!V[i].Visited) {
if (!DFS(i)) {
return false;
}
}
}
return true;
}
int main() {
cin >> N >> M;
for (long long i = 0; i < M; i++) {
cin >> A >> B;
V[A].WhatVertices.push_back(B);
V[B].WhatVertices.push_back(A);
}
if (Can()) {
for (long long i = 1; i <= N; i++) {
(V[i].Who) ? MineA.push(i) : MineB.push(i);
}
cout << MineA.size() << endl;
while (!MineA.empty()) {
cout << MineA.front() << ' ';
MineA.pop();
}
cout << endl << MineB.size() << endl;
while (!MineB.empty()) {
cout << MineB.front() << ' ';
MineB.pop();
}
} else {
cout << "-1" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[100010];
int color[100010];
bool bfs(int src) {
queue<int> q;
q.push(src);
color[src] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (color[v] == -1) {
color[v] = color[u] xor 1;
q.push(v);
} else if (color[u] == color[v]) {
return false;
}
}
}
return true;
}
vector<int> A, B;
int main() {
int n, k, a, b;
while (cin >> n >> k) {
for (int i = 0; i < k; i++) {
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
memset(color, -1, sizeof color);
bool f = true;
for (int i = 1; i <= n; i++) {
if (color[i] == -1 && bfs(i) == false) {
f = false;
}
}
if (f == false) {
puts("-1");
} else {
for (int i = 1; i <= n; i++) {
if (color[i] == 1)
A.push_back(i);
else
B.push_back(i);
}
cout << A.size() << "\n";
for (int i = 0; i < A.size(); i++) {
cout << A[i] << " ";
}
cout << "\n";
cout << B.size() << "\n";
for (int i = 0; i < B.size(); i++) {
cout << B[i] << " ";
}
cout << "\n";
A.clear();
B.clear();
}
for (int i = 0; i <= n; i++) G[i].clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int father[100005 * 2];
int A[100005];
int B[100005];
bool vis[100005];
void init(int n) {
for (int i = 1; i <= 2 * n + 5; i++) father[i] = i;
}
int getfather(int x) {
if (x != father[x]) father[x] = getfather(father[x]);
return father[x];
}
void Union(int x, int y) {
x = getfather(x);
y = getfather(y);
if (x != y) father[y] = x;
}
int same(int x, int y) { return getfather(x) == getfather(y); }
int main() {
int n, m;
int x, y;
scanf("%d%d", &n, &m);
int flag = 1;
init(n);
int a, b;
scanf("%d%d", &a, &b);
vis[a] = vis[b] = 1;
Union(a, b + n);
Union(a + n, b);
m--;
while (m--) {
scanf("%d%d", &x, &y);
vis[x] = vis[y] = 1;
if (same(x, y))
flag = 0;
else {
Union(x, y + n);
Union(x + n, y);
}
}
if (flag) {
int ans1 = 0;
int ans2 = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] && getfather(i) <= n) A[ans1++] = i;
if (vis[i] && getfather(i) > n) B[ans2++] = i;
}
printf("%d\n", ans1);
printf("%d", A[0]);
for (int i = 1; i < ans1; i++) printf(" %d", A[i]);
printf("\n");
printf("%d\n", ans2);
printf("%d", B[0]);
for (int i = 1; i < ans2; i++) printf(" %d", B[i]);
printf("\n");
} else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
vector<vector<int> > adj(MAXN);
int col[MAXN];
bool res = true;
int t[3];
void dfs(int cur) {
for (int next : adj[cur]) {
if (!col[next]) {
col[next] = 3 - col[cur];
++t[col[next]];
dfs(next);
}
if (col[next] && col[next] == col[cur]) res = false;
}
}
int main() {
int N, M;
cin >> N >> M;
for (int i = 0; i < M; ++i) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= N; ++i) {
if (!col[i]) {
++t[1];
col[i] = 1;
dfs(i);
}
}
if (!res) {
cout << -1;
return 0;
}
cout << t[1] << "\n";
for (int i = 1; i <= N; ++i) {
if (col[i] == 1) cout << i << " ";
}
cout << "\n";
cout << t[2] << "\n";
for (int i = 2; i <= N; ++i) {
if (col[i] == 2) cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> G[100001];
int chk[100001];
bool bfs(long long start) {
queue<long long> q;
q.push(start);
chk[start] = 0;
while (!q.empty()) {
long long top = q.front();
q.pop();
for (int i = 0; i < G[top].size(); i++) {
if (chk[G[top][i]] == -1) {
q.push(G[top][i]);
chk[G[top][i]] = chk[top] == 1 ? 0 : 1;
} else if (chk[G[top][i]] == chk[top]) {
return false;
}
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
long long n, m;
long long u, v;
cin >> n >> m;
memset(chk, -1, sizeof(chk));
for (int i = 0; i < m; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
bool result = true;
for (int i = 1; i <= n; i++) {
if (chk[i] == -1) {
result = bfs(i) & result;
}
}
if (result) {
long long ctr1 = 0, ctr0 = 0;
for (int i = 1; i <= n; i++) {
if (chk[i] == 1)
ctr1++;
else if (chk[i] == 0)
ctr0++;
}
cout << ctr0 << endl;
for (int i = 1; i <= n; i++)
if (chk[i] == 0) cout << i << ' ';
cout << endl;
cout << ctr1 << endl;
for (int i = 1; i <= n; i++)
if (chk[i] == 1) cout << i << ' ';
cout << endl;
} else
cout << "-1\n";
}
|
#include <bits/stdc++.h>
std::vector<int> adj[100000];
bool bipartite = true;
int color[100000];
bool visited[100000];
int count[2];
void dfs(int v, int c) {
if (visited[v]) return;
visited[v] = true;
color[v] = c;
count[c]++;
for (int u : adj[v]) {
if (!visited[u]) {
dfs(u, 1 - c);
} else {
if (color[u] == color[v]) {
bipartite = false;
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, m;
std::cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
std::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, 0);
if (!bipartite) break;
}
if (bipartite) {
for (int c = 0; c < 2; ++c) {
std::cout << count[c] << '\n';
for (int i = 0; i < n; ++i) {
if (color[i] == c) std::cout << (i + 1) << ' ';
}
std::cout << '\n';
}
} else {
std::cout << -1 << '\n';
}
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;
}
vector<int> V(100005, 0);
vector<vector<int> > E(100005, vector<int>());
vector<int> D(100005, 0);
vector<int> O(100005, 0);
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.begin(), O.begin() + 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;
long long int n, m;
vector<long long int> ar[100001];
vector<long long int> res[2];
long long int vis[100001];
long long int col[100001];
bool dfs(long long int node, long long int c) {
vis[node] = 1;
res[c].push_back(node);
col[node] = c;
for (long long int child : ar[node]) {
if (vis[child] == 0) {
if (dfs(child, c ^ 1) == false) return false;
} else if (col[node] == col[child])
return false;
}
return true;
}
void solve() {
long long int test = 1;
while (test--) {
cin >> n >> m;
while (m--) {
long long int a, b;
cin >> a >> b;
ar[a].push_back(b);
ar[b].push_back(a);
}
long long int count = 1;
vector<long long int> von;
memset(vis, 0, sizeof(vis));
for (long long int i = 1; i <= n; i++) {
if (vis[i] == 0) {
if (ar[i].empty()) continue;
if (dfs(i, 0) == false) {
cout << -1 << endl;
return;
}
}
}
for (long long int i = 0; i < 2; i++) {
cout << res[i].size() << endl;
for (auto x : res[i]) cout << x << " ";
cout << endl;
}
}
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 10;
bool mark[MAXN];
bool color[MAXN];
vector<int> adj[MAXN];
bool dfs(int v, bool c) {
mark[v] = 1;
color[v] = c;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (mark[u] != 1) {
bool r = dfs(u, !c);
if (r == 0) return 0;
}
if (color[u] == c) return 0;
}
return 1;
}
int main() {
int n, m;
cin >> n >> m;
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
if (!dfs(i, 0)) {
cout << -1;
return 0;
}
}
}
vector<int> h, h2;
for (int i = 1; i <= n; i++) {
if (color[i]) {
h.push_back(i);
} else {
h2.push_back(i);
}
}
cout << h.size() << '\n';
for (int i = 0; i < h.size(); i++) {
cout << h[i] << ' ';
}
cout << '\n';
cout << h2.size() << '\n';
for (int i = 0; i < h2.size(); i++) {
cout << h2[i] << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
int vis[N];
vector<int> v[N];
int col[N];
int flag = 1;
void bfs(int node, int color) {
vis[node] = 1;
col[node] = color;
for (auto it = v[node].begin(); it != v[node].end(); it++) {
if (col[*it] == color) {
flag = 0;
return;
}
if (!vis[*it]) bfs(*it, color ? 0 : 1);
}
}
int main() {
int n, m, x, y;
cin >> n >> m;
for (int i = 1; i <= n; i++) col[i] = -1;
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
flag = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i]) bfs(i, 1);
}
if (!flag) {
cout << "-1";
return 0;
} else {
int cnt0, cnt1;
cnt0 = cnt1 = 0;
for (int i = 1; i <= n; i++) {
if (col[i] == 1)
++cnt1;
else if (!col[i])
++cnt0;
}
cout << cnt0 << "\n";
for (int i = 1; i <= n; i++) {
if (!col[i]) cout << i << " ";
}
cout << "\n";
cout << cnt1 << "\n";
for (int i = 1; i <= n; i++) {
if (col[i] == 1) cout << i << " ";
}
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[100100];
bool cycle;
int colour[100100];
int even[100100];
int parent[100100];
void dfs(int p) {
colour[p] = 1;
for (int i = 0; i < g[p].size(); i++) {
int to = g[p][i];
if (parent[p] == to) continue;
if (colour[to] == 0) {
parent[to] = p;
even[to] = (even[p] + 1) % 2;
dfs(to);
} else if (colour[to] == 1) {
if (even[to] == even[p]) {
cycle = true;
}
}
}
}
int main() {
memset(even, -1, sizeof(even));
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (colour[i] == 0) {
even[i] = 0;
dfs(i);
}
}
if (cycle) {
cout << "-1" << endl;
} else {
int counter = 0;
for (int i = 1; i <= n; i++) {
if (even[i]) counter++;
}
cout << counter << endl;
bool first = true;
for (int i = 1; i <= n; i++) {
if (even[i]) {
if (first) {
cout << i;
} else {
cout << " " << i;
}
first = false;
}
}
cout << endl;
cout << n - counter << endl;
first = true;
for (int i = 1; i <= n; i++) {
if (!even[i]) {
if (first) {
cout << i;
} else {
cout << " " << i;
}
first = false;
}
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100004];
int main() {
int n, m;
cin >> n >> m;
int present[n + 1];
int colour[n + 1];
memset(present, 0, sizeof present);
memset(colour, 0, sizeof colour);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if (present[x] == 0) present[x] = 1;
if (present[y] == 0) present[y] = 1;
graph[x].push_back(y);
graph[y].push_back(x);
}
queue<int> q;
vector<int> red;
vector<int> blue;
int next;
for (int i = 1; i < n + 1; i++) {
if (present[i] == 1) {
if (colour[i] == 0) {
q.push(i);
next = q.front();
colour[next] = 1;
red.push_back(next);
}
while (q.empty() == false) {
next = q.front();
for (int j = 0; j < graph[next].size(); j++) {
if (colour[graph[next][j]] == 0) {
if (colour[next] == 1) {
colour[graph[next][j]] = 2;
q.push(graph[next][j]);
blue.push_back(graph[next][j]);
} else if (colour[next] == 2) {
colour[graph[next][j]] = 1;
red.push_back(graph[next][j]);
q.push(graph[next][j]);
}
}
if (colour[next] == colour[graph[next][j]]) {
cout << -1;
return 0;
}
}
q.pop();
}
}
}
cout << red.size() << endl;
for (int h = 0; h < red.size(); h++) cout << red[h] << " ";
cout << endl;
cout << blue.size() << endl;
for (int h = 0; h < blue.size(); h++) cout << blue[h] << " ";
cout << endl;
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int used[100000];
int n, m;
vector<int> v[100000], groups[2];
void f(int point, int group) {
used[point] = group;
groups[group - 1].push_back(point);
for (int i = 0; i < v[point].size(); i++) {
if (used[v[point][i]]) {
if (used[v[point][i]] == group) {
cout << -1;
exit(0);
}
} else
f(v[point][i], 3 - group);
}
}
int main() {
cin >> n >> m;
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x - 1].push_back(y - 1);
v[y - 1].push_back(x - 1);
}
for (int i = 0; i < n; i++) {
if (!used[i]) f(i, 1);
}
for (int j = 0; j < 2; j++) {
cout << groups[j].size() << endl;
for (int i = 0; i < groups[j].size(); i++) cout << groups[j][i] + 1 << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int vis[100005], col[100005];
vector<long long int> a, b;
void util(long long int i, vector<vector<long long int>> &v, long long int c) {
vis[i] = 1;
col[i] = c;
if (c == 1)
a.push_back(i + 1);
else
b.push_back(i + 1);
for (long long int j = 0; j < v[i].size(); j++)
if (vis[v[i][j] - 1] == 0)
util(v[i][j] - 1, v, c == 0 ? 1 : 0);
else if (col[v[i][j] - 1] == c) {
cout << "-1";
exit(0);
}
}
void dfs(vector<vector<long long int>> v) {
for (long long int i = 0; i < v.size(); i++)
if (vis[i] == 0) util(i, v, 0);
}
int main() {
long long int n, m;
cin >> n >> m;
vector<vector<long long int>> v(n);
for (long long int i = 0; i < m; i++) {
long long int l, r;
cin >> l >> r;
v[l - 1].push_back(r);
v[r - 1].push_back(l);
}
dfs(v);
cout << a.size() << endl;
for (long long int i = 0; i < a.size(); i++) cout << a[i] << " ";
cout << endl << b.size() << endl;
for (long long int i = 0; i < b.size(); i++) cout << b[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
struct comp {
bool operator()(int a, int b) { return a > b; }
};
vector<int> node[100005];
int result[100005] = {};
vector<int> ans[5];
bool valid = true;
void solve(int current, int last, int player) {
if (result[current] == (3 - player))
valid = false;
else if (result[current] == 0) {
result[current] = player;
ans[player].push_back(current);
int n = node[current].size();
for (int i = 0; i <= n - 1; i++)
if (node[current][i] != last) {
solve(node[current][i], current, 3 - player);
}
}
}
int main() {
int n, m, a, b;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &a, &b);
node[a].push_back(b);
node[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (result[i] == 0 && node[i].size() > 0) {
solve(i, 0, 1);
}
if (!valid)
printf("-1\n");
else {
printf("%d\n", ans[1].size());
for (int i = 0; i <= ans[1].size() - 1; i++)
printf("%s%d", (i > 0 ? " " : ""), ans[1][i]);
printf("\n");
printf("%d\n", ans[2].size());
for (int i = 0; i <= ans[2].size() - 1; i++)
printf("%s%d ", (i > 0 ? " " : ""), ans[2][i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
cin >> m;
vector<vector<long long int> > g(n + 1, std::vector<long long int>(0));
vector<long long> color(n + 1, -1);
queue<long long> q;
for (long long i = 0; i < m; i++) {
int s, d;
cin >> s;
cin >> d;
g[s].push_back(d);
g[d].push_back(s);
}
vector<int> s1;
vector<int> s2;
for (int i = 1; i <= n; i++) {
if (color[i] == -1) {
color[i] = 1;
q.push(i);
if (color[i] == 1)
s1.push_back(i);
else
s2.push_back(i);
while (!q.empty()) {
long long curr = q.front();
q.pop();
for (long long ne : g[curr]) {
if (color[ne] == color[curr]) {
cout << "-1" << endl;
return 0;
} else if (color[ne] == -1) {
color[ne] = 1 - color[curr];
q.push(ne);
if (color[ne] == 1)
s1.push_back(ne);
else
s2.push_back(ne);
}
}
}
}
}
cout << s1.size() << endl;
for (unsigned long long int i = 0; i < s1.size(); ++i) {
cout << s1[i] << " ";
}
cout << endl;
cout << s2.size() << endl;
for (unsigned long long int i = 0; i < s2.size() - 1; ++i) {
cout << s2[i] << " ";
}
cout << s2[s2.size() - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> sz[100001];
vector<int> sor;
bool volt[100001];
int szint[100001];
int sk = 0;
int n, m;
vector<int> a, b;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
sz[x].push_back(y);
sz[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!volt[i]) {
sor.push_back(i);
volt[i] = true;
while (sk < sor.size()) {
int akt = sor[sk];
sk++;
for (int s : sz[akt]) {
if (!volt[s]) {
sor.push_back(s);
volt[s] = true;
szint[s] = szint[akt] + 1;
}
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int s : sz[i]) {
if (szint[i] % 2 == szint[s] % 2) {
cout << -1 << endl;
return 0;
}
}
if (szint[i] % 2 == 0)
a.push_back(i);
else
b.push_back(i);
}
cout << a.size() << endl;
for (int x : a) cout << x << " ";
cout << endl << b.size() << endl;
for (int x : b) cout << x << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x6fffffff;
const int MINF = 0x80000000;
const long long mod = 1000000007;
const int cons = 100001;
const double pi = 3.141592653589793;
vector<vector<int> > adj;
int f[100001];
int fn(int u) {
if (f[u] == u) return f[u];
return f[u] = fn(f[u]);
}
void unite(int u, int v) { f[fn(u)] = fn(v); }
vector<int> ans[2];
int chk[100001];
bool vis[100001];
void dfs(int u, int par, int h) {
ans[h % 2].push_back(u);
chk[u] = h % 2;
vis[u] = true;
for (auto v : adj[u]) {
if (v == par) continue;
dfs(v, u, h + 1);
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
adj.resize(n + 1);
vector<pair<int, int> > e;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
e.push_back(make_pair(u, v));
}
for (int i = 1; i <= n; i++) {
f[i] = i;
}
for (int i = 0; i < e.size(); i++) {
int u = e[i].first;
int v = e[i].second;
int fu = fn(u);
int fv = fn(v);
if (fu == fv) continue;
unite(fu, fv);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
if (adj[i].size() == 0) continue;
dfs(i, -1, 0);
}
for (int i = 0; i < 2; i++) {
for (int j = 0; j < e.size(); j++) {
int u = e[j].first;
int v = e[j].second;
if (chk[u] != i && chk[v] != i) {
puts("-1");
return 0;
}
}
}
for (int i = 0; i < 2; i++) {
printf("%d\n", ans[i].size());
for (int j = 0; j < ans[i].size(); j++) {
printf("%d ", ans[i][j]);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int color[100001];
int n, m;
vector<int> v[100001];
bool visited[100001];
bool check_bipartite(int s) {
color[s] = 1;
queue<int> q;
visited[s] = true;
q.push(s);
while (!q.empty()) {
s = q.front();
q.pop();
for (__typeof(v[s].begin()) it = v[s].begin(); it != v[s].end(); it++) {
if (color[*it] == -1) {
color[*it] = 1 - color[s];
q.push(*it);
visited[*it] = true;
} else if (color[s] == color[*it])
return false;
}
}
return true;
}
void scan() {
for (int i = (1); i <= (n); i++) v[i].clear();
int v1, v2;
for (int i = (0); i <= (m - 1); i++) {
cin >> v1 >> v2;
v[v1].push_back(v2);
v[v2].push_back(v1);
}
}
int main() {
cin >> n >> m;
scan();
for (int i = (1); i <= (n); i++) color[i] = -1;
for (int i = (1); i <= (n); i++) {
if (visited[i] == false) {
bool ret = check_bipartite(i);
if (ret == false) {
cout << -1 << endl;
return 0;
}
}
}
vector<int> tmp, tmp2;
tmp.clear();
tmp2.clear();
for (int i = (1); i <= (n); i++)
if (color[i] == 1)
tmp.push_back(i);
else
tmp2.push_back(i);
cout << (int)(tmp.size()) << endl;
for (__typeof(tmp.begin()) it = tmp.begin(); it != tmp.end(); it++)
cout << *it << " ";
cout << endl;
cout << (int)(tmp2.size()) << endl;
for (__typeof(tmp2.begin()) it = tmp2.begin(); it != tmp2.end(); it++)
cout << *it << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int N = 100010;
vector<int> E[N];
int color[N];
void init() {
for (int i = 0; i < N; i++) E[i].clear();
memset(color, 0, sizeof(color));
}
bool bfs(int s) {
queue<int> Q;
int i;
Q.push(s);
color[s] = 1;
while (!Q.empty()) {
int now = Q.front();
Q.pop();
int SZ = E[now].size();
for (i = 0; i < SZ; ++i) {
int v = E[now][i];
if (!color[v]) {
color[v] = (color[now] == 1 ? 2 : 1);
Q.push(v);
} else if (color[v] && color[v] == color[now])
return false;
}
}
return true;
}
int main(void) {
int n, m, i, j, k, a, b, c, flag;
while (~scanf("%d%d", &n, &m)) {
init();
flag = 1;
for (i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
E[a].push_back(b);
E[b].push_back(a);
}
for (i = 1; i <= n; i++) {
if (!color[i] && E[i].size() > 0) {
if (!bfs(i)) flag = 0;
}
}
if (!flag)
puts("-1");
else {
int cnta = 0, cntb = 0;
vector<int> va, vb;
for (i = 1; i <= n; i++) {
if (color[i] == 1) {
va.push_back(i);
cnta++;
} else if (color[i] == 2) {
vb.push_back(i);
cntb++;
}
}
if ((!cnta) || (!cntb)) {
puts("-1");
continue;
}
printf("%d\n", cnta);
for (i = 0; i < cnta; i++)
printf("%d%s", va[i], i == cnta - 1 ? "\n" : " ");
printf("%d\n", cntb);
for (i = 0; i < cntb; i++)
printf("%d%s", vb[i], i == cntb - 1 ? "\n" : " ");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num, q[200005], ne[200005], head[100005];
int col[100005], n, m, x, y, num1, num2, flag;
void addnum(int x, int y) {
num++;
q[num] = y;
ne[num] = head[x];
head[x] = num;
}
void dfs(int t, int fa, int type) {
if (type == 1) {
col[t] = 1;
num1++;
} else {
col[t] = 2;
num2++;
}
for (int i = head[t]; i; i = ne[i]) {
if (q[i] == fa) continue;
if (col[q[i]] == col[t]) {
flag = -1;
return;
} else if (col[q[i]] == 0)
dfs(q[i], t, 3 - type);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
addnum(x, y);
addnum(y, x);
}
for (int i = 1; i <= n; i++) {
if (head[i] == 0 || col[i] != 0) continue;
dfs(i, 0, 1);
if (flag == -1) {
printf("-1");
return 0;
}
}
printf("%d\n", num1);
for (int i = 1; i <= n; i++)
if (col[i] == 1) printf("%d ", i);
printf("\n");
printf("%d\n", num2);
for (int i = 1; i <= n; i++)
if (col[i] == 2) printf("%d ", i);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_MEM = (int)1e8;
int mpos = 0;
char mem[MAX_MEM];
inline void *operator new(size_t n) {
char *res = mem + mpos;
mpos += n;
return (void *)res;
}
inline void operator delete(void *) {}
struct __io_dev {
__io_dev(const bool &__fastio = false) {
if (__fastio) ios_base::sync_with_stdio(false), cin.tie(nullptr);
srand(time(nullptr));
if (!string("").empty())
freopen(
""
".in",
"r", stdin),
freopen(
""
".out",
"w", stdout);
}
~__io_dev() { fprintf(stderr, "%.6f ms\n", 1e3 * clock() / CLOCKS_PER_SEC); }
} __io(false);
const long long inf = (long long)1e+9 + 7ll;
const long long linf = (long long)1e+18 + 7ll;
const long double eps = (long double)1e-9;
const long double pi = acosl((long double)-1.0);
const int alph = 26;
const int maxs = 512l;
static char buff[(int)2e6 + 17];
long long __p[3] = {29ll, 31ll, 33ll};
long long __mod[3] = {inf, inf + 2ll, 14881337ll};
const int maxn = (int)2e5 + 17;
int n, m;
vector<int> g[maxn], ans[3];
bool used[maxn];
int cl[maxn];
bool dfs(int v, int c) {
used[v] = true;
cl[v] = c;
ans[c].push_back(v);
for (auto to : g[v])
if (!used[to]) {
if (!dfs(to, c ^ 3)) return false;
} else {
if (cl[to] == cl[v]) return false;
}
return true;
}
int main() {
scanf("%d %d", &n, &m);
for (long long i = 0ll; i < (long long)m; ++i) {
int a, b;
scanf("%d %d", &a, &b);
g[a - 1].push_back(b - 1);
g[b - 1].push_back(a - 1);
}
for (long long i = 0ll; i < (long long)n; ++i)
if (!used[i])
if (!dfs(i, 1)) return printf("-1"), 0;
printf("%d\n", ((int)(ans[1].size())));
for (auto i : ans[1]) printf("%d ", i + 1);
printf("\n%d\n", ((int)(ans[2].size())));
for (auto i : ans[2]) printf("%d ", i + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 1e3 + 100, OO = 0x3f3f3f;
int coloured[N], n, m;
vector<int> adj[N];
int Bipartite = 1;
void DFS(int src) {
for (int i : adj[src]) {
if (!coloured[i]) {
coloured[i] = coloured[src] ^ 3;
DFS(i);
} else if (coloured[i] == coloured[src])
Bipartite = 0;
}
}
int main() {
cin >> n >> m;
int ok[N] = {0};
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
ok[x] = ok[y] = 1;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= n; ++i) {
if (!coloured[i] && ok[i]) {
coloured[i] = 1;
DFS(i);
}
}
if (!Bipartite)
cout << -1;
else {
int cnt[N] = {0};
for (int i = 1; i <= n; ++i) cnt[coloured[i]]++;
cout << cnt[1] << "\n";
for (int i = 1; i <= n; ++i)
if (coloured[i] == 1 && ok[i]) cout << i << " ";
cout << "\n" << cnt[2] << "\n";
for (int i = 1; i <= n; ++i)
if (coloured[i] == 2 && ok[i]) cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 120021;
vector<int> vc[2];
vector<int> g[N];
int mark[N];
bool dfs(int v, int color = 2) {
mark[v] = color;
vc[color - 1].push_back(v);
for (int i = 0; i < g[v].size(); ++i) {
int u = g[v][i];
if (!mark[u] && dfs(u, 3 - color)) return 1;
if (mark[u] != 3 - color) return 1;
}
return 0;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u = in() - 1;
int v = in() - 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 j = 0; j < vc[i].size(); ++j) {
int v = vc[i][j];
cout << v + 1 << " ";
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int nodes, edges;
vector<int> adj[100005];
int sett[100005];
bool visited[100005];
int vis;
int imp;
void dfs(int node) {
if (sett[node] == 1) {
int uslo = 0;
for (int i = 0; i < adj[node].size(); i++) {
if (sett[adj[node][i]] == 1) {
imp = 1;
return;
} else if (sett[adj[node][i]] == 0) {
vis++;
uslo = 1;
visited[adj[node][i]] = true;
sett[adj[node][i]] = 2;
dfs(adj[node][i]);
}
}
if (uslo == 0) return;
} else if (sett[node] == 2) {
int uslo = 0;
for (int i = 0; i < adj[node].size(); i++) {
if (sett[adj[node][i]] == 2) {
imp = 1;
return;
} else if (sett[adj[node][i]] == 0) {
vis++;
visited[adj[node][i]] = true;
uslo = 1;
sett[adj[node][i]] = 1;
dfs(adj[node][i]);
}
}
if (uslo == 0) return;
} else if (sett[node] == 0) {
vis++;
visited[node] = true;
sett[node] = 1;
dfs(node);
}
}
int main() {
cin >> nodes >> edges;
for (int i = 0; i < edges; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
imp = 0;
vis = 0;
sett[nodes + 1] = {0};
while (vis != nodes) {
for (int i = 1; i <= nodes; i++) {
if (adj[i].size() == 0) {
visited[i] = true;
vis++;
}
if (visited[i] == false) dfs(i);
}
}
vector<int> set1;
vector<int> set2;
if (imp == 0) {
for (int i = 0; i <= nodes; i++) {
if (sett[i] == 1)
set1.push_back(i);
else if (sett[i] == 2)
set2.push_back(i);
}
if (set1.size() < set2.size()) {
cout << set1.size() << endl;
for (int i = 0; i < set1.size(); i++) cout << set1[i] << " ";
cout << endl;
cout << set2.size() << endl;
for (int i = 0; i < set2.size(); i++) cout << set2[i] << " ";
cout << endl;
} else {
cout << set2.size() << endl;
for (int i = 0; i < set2.size(); i++) cout << set2[i] << " ";
cout << endl;
cout << set1.size() << endl;
for (int i = 0; i < set1.size(); i++) cout << set1[i] << " ";
cout << endl;
}
} else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, max;
vector<int> a[100000];
bool visited[100000] = {0};
char col[100000] = {'Z'};
void f(int x) {
queue<int> q;
q.push(x);
visited[x] = 1;
char temp = 'A';
col[x] = temp;
while (!q.empty()) {
int p = q.front();
q.pop();
temp = col[p];
if (temp == 'A')
temp = 'B';
else
temp = 'A';
for (int i = 0; i < a[p].size(); i++) {
if (visited[a[p][i]] == false) {
q.push(a[p][i]);
visited[a[p][i]] = true;
col[a[p][i]] = temp;
} else if (col[a[p][i]] != temp) {
puts("-1");
exit(0);
}
}
}
}
int main() {
cin >> n >> m;
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
a[x].push_back(y);
a[y].push_back(x);
}
f(x);
for (int i = 0; i < 100000; i++) {
if (a[i].size() && visited[i] == 0) f(i);
}
int c1 = 0;
for (int i = 0; i < 100000; i++)
if (col[i] == 'B') c1++;
cout << c1 << "\n";
for (int i = 0; i < 100000; i++)
if (col[i] == 'B') cout << i + 1 << " ";
cout << "\n";
c1 = 0;
for (int i = 0; i < 100000; i++)
if (col[i] == 'A') c1++;
cout << c1 << "\n";
for (int i = 0; i < 100000; i++)
if (col[i] == 'A') cout << i + 1 << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, color[100005];
map<int, set<int> > G;
void readf() {
int u, v;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
G[u].insert(v);
G[v].insert(u);
}
memset(color, -1, sizeof(color));
}
bool dfs(int u, int &cnt) {
cnt++;
for (set<int>::iterator it = G[u].begin(); it != G[u].end(); it++) {
int v = *it;
if (color[v] == -1) {
color[v] = 1 - color[u];
if (dfs(v, cnt) == false) return false;
} else if (color[v] == color[u]) {
return false;
}
}
return true;
}
void print() {
for (int u = 1; u <= n; u++) {
int cnt = 0;
if (color[u] == -1) {
color[u] = 0;
if (dfs(u, cnt) == false) {
printf("-1\n");
return;
}
}
if (cnt == 1) color[u] = 2;
}
vector<int> ans[3];
for (int u = 1; u <= n; u++) ans[color[u]].push_back(u);
printf("%d\n", (int)ans[0].size());
for (int i = 0; i < (int)ans[0].size(); i++) printf("%d ", ans[0][i]);
printf("\n");
printf("%d\n", (int)ans[1].size());
for (int i = 0; i < (int)ans[1].size(); i++) printf("%d ", ans[1][i]);
printf("\n");
}
int main() {
readf();
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> myvec[100001];
set<int> myset[2];
set<int>::iterator it;
int mark[100001];
bool isbipartite(int src) {
int color[100001];
memset(color, -1, sizeof(color));
queue<int> q;
q.push(src);
mark[src] = 1;
color[src] = 1;
myset[color[src]].insert(src);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v = 0; v < myvec[u].size(); v++) {
if (color[myvec[u][v]] == -1)
color[myvec[u][v]] = 1 - color[u], q.push(myvec[u][v]),
myset[color[myvec[u][v]]].insert(myvec[u][v]), mark[myvec[u][v]] = 1;
else if (color[myvec[u][v]] == color[u])
return false;
}
}
return true;
}
int main() {
long long int x, y;
int a, b;
cin >> a >> b;
while (b--) {
cin >> x >> y;
myvec[x].push_back(y);
myvec[y].push_back(x);
}
bool solve = true;
for (int i = 1; i <= a; i++) {
if (mark[i] == 0) {
solve = (solve && isbipartite(i));
}
}
if (solve == true) {
cout << myset[0].size() << endl;
for (it = myset[0].begin(); it != myset[0].end(); it++) {
cout << *it << " ";
}
cout << endl;
cout << myset[1].size() << endl;
for (it = myset[1].begin(); it != myset[1].end(); it++) {
cout << *it << " ";
}
cout << endl;
} else
cout << "-1" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 120021;
vector<int> vc[2];
vector<int> g[N];
int mark[N];
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;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u = in() - 1;
int v = in() - 1;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < n; i++)
if (!mark[i]) {
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 fx[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
const int fxx[8][2] = {{0, 1}, {1, 1}, {1, 0}, {1, -1},
{0, -1}, {-1, -1}, {-1, 0}, {-1, 1}};
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
inline void print_f(int n) { printf("Case #%d: ", n); }
inline int bounds_4(int xi, int xj, int yi, int yj, int i, int j) {
return ((i >= xi) && (i <= xj) && (j >= yi) && (j <= yj));
}
inline int Bounds(int i, int j, int S) {
return bounds_4(0, 0, S - 1, S - 1, i, j);
}
vector<string> split(const string& s, char delim) {
stringstream ss(s);
string item;
vector<string> tokens;
while (getline(ss, item, delim)) {
tokens.push_back(item);
}
return tokens;
}
vector<vector<int> > edges;
void insert(int a, int b, bool dir) {
edges[a].push_back(b);
if (!dir) insert(b, a, true);
}
vector<int> color;
set<int> white;
set<int> black;
bool bfs(int src) {
color[src] = 1;
white.insert(src);
;
queue<int> q;
q.push(src);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < edges[u].size(); i++) {
int v = edges[u][i];
if (color[v] != 0) {
if (color[v] == color[u])
return false;
else
continue;
} else {
if (color[u] == 1) {
color[v] = 2;
black.insert(v);
;
} else {
color[v] = 1;
white.insert(v);
;
}
q.push(v);
}
}
}
return true;
}
int main() {
int N, M;
cin >> N >> M;
edges.resize(N);
color.resize(N);
for (int i = 0; i < N; i++) color[i] = 0;
int u, v;
for (int i = 0; i < M; i++) {
cin >> u >> v;
u--;
v--;
insert(u, v, false);
}
bool possible = true;
for (int i = 0; i < N && possible; i++) {
if (color[i] == 0) {
possible = bfs(i);
}
}
if (!possible) {
cout << -1 << "\n";
;
} else {
cout << white.size() << "\n";
;
for (set<int>::iterator it = white.begin(); it != white.end(); it++)
cout << ((*it) + 1) << " ";
cout << "\n";
;
cout << black.size() << "\n";
;
for (set<int>::iterator it = black.begin(); it != black.end(); it++)
cout << ((*it) + 1) << " ";
cout << "\n";
;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 100;
int n, m, cnt;
int color[N];
struct Edge {
int to, w, next;
} edge[N << 1];
int head[N];
void init() {
memset(color, 0, sizeof color);
for (int i = 0; i <= n; i++) head[i] = -1;
cnt = 0;
}
void addedge(int u, int v, int w) {
edge[cnt].to = v;
edge[cnt].w = w;
edge[cnt].next = head[u];
head[u] = cnt++;
}
bool dfs(int v, int c) {
color[v] = c;
for (int i = head[v]; i != -1; i = edge[i].next) {
if (color[edge[i].to] == c) return false;
if (color[edge[i].to] == 0 && !dfs(edge[i].to, -c)) return false;
}
return true;
}
bool get_color() {
for (int i = 1; i <= n; i++) {
if (color[i] == 0 && !dfs(i, 1)) return false;
}
return true;
}
int main() {
while (cin >> n >> m) {
init();
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
addedge(u, v, 1);
addedge(v, u, 1);
}
if (!get_color())
cout << -1 << endl;
else {
int cnt1 = 0;
int set1[N];
for (int i = 1; i <= n; i++) {
if (color[i] == 1) set1[cnt1++] = i;
}
int cnt2 = 0;
int set2[N];
for (int i = 1; i <= n; i++) {
if (color[i] == -1) set2[cnt2++] = i;
}
cout << cnt1 << endl;
for (int i = 0; i < cnt1; i++)
cout << set1[i] << ((i == cnt1 - 1) ? '\n' : ' ');
cout << cnt2 << endl;
for (int i = 0; i < cnt2; i++)
cout << set2[i] << ((i == cnt2 - 1) ? '\n' : ' ');
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18L + 5;
long long gcd(unsigned long long x, unsigned long long y) {
if (x == 0) return y;
return gcd(y % x, x);
}
long long gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
unsigned long long findGCD(vector<unsigned long long> &v) {
unsigned long long result = v[0];
for (long long i = 1; i < v.size(); i++) {
result = gcd(v[i], result);
if (result == 1) {
return 1;
}
}
return result;
}
long long lcm(long long a, long long b) { return ((a * b) / gcd(a, b)); }
bool sortbysec(long long a, long long b) { return (a > b); }
vector<long long> primeFactors(long long n) {
vector<long long> ans;
while (n % 2 == 0) {
ans.push_back(2);
n = n / 2;
}
for (long long i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
ans.push_back(i);
n = n / i;
}
}
if (n > 2) ans.push_back(n);
return ans;
}
vector<long long> all_prime(long long n) {
vector<long long> sieve(n + 1, 0);
for (long long x = 2; x <= n; x++) {
if (sieve[x]) continue;
for (int u = 2 * x; u <= n; u += x) {
if (sieve[u] == 0) {
sieve[u] = x;
}
}
}
return sieve;
}
long long power(long long x, long long n) {
if (n == 0) return 1;
long long temp = power(x, n / 2);
if (n % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
unsigned long long powerper(unsigned long long x, long long y, long long p) {
unsigned long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
unsigned long long modInverse(unsigned long long n, long long p) {
return powerper(n, p - 2, p);
}
unsigned long long nCrModPFermat(unsigned long long n, long long r, long long p,
unsigned long long fac[]) {
if (n < r) return 0;
if (r == 0) return 1;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
void dfs(vector<vector<long long>> &v, vector<long long> &df, long long seen[],
long long i) {
df.push_back(i);
for (long long j = 0; j < v[i].size(); j++) {
if (seen[v[i][j]] == 0) {
seen[v[i][j]] = seen[i];
dfs(v, df, seen, v[i][j]);
}
}
}
bool BFS(vector<vector<long long>> &adj, long long src, long long dest,
long long n, long long pred[], long long dist[]) {
list<long long> queue;
bool visited[n];
for (long long i = 0; i < n; i++) {
visited[i] = false;
dist[i] = INF;
pred[i] = -1;
}
visited[src] = true;
dist[src] = 0;
queue.push_back(src);
while (!queue.empty()) {
long long u = queue.front();
queue.pop_front();
for (long long i = 0; i < adj[u].size(); i++) {
if (visited[adj[u][i]] == false) {
visited[adj[u][i]] = true;
dist[adj[u][i]] = dist[u] + 1;
pred[adj[u][i]] = u;
queue.push_back(adj[u][i]);
if (adj[u][i] == dest) return true;
}
}
}
return false;
}
long long findConnComp(vector<vector<long long>> &v, long long seen[],
long long n) {
long long j = 0;
vector<long long> df;
for (long long i = 0; i < n; i++) seen[i] = 0;
for (long long i = 0; i < n; i++) {
if (!seen[i]) {
seen[i] = ++j;
dfs(v, df, seen, i);
}
}
return j;
}
vector<long long> dijkstra_set(vector<vector<pair<long long, long long>>> &adj,
long long src, long long V) {
set<pair<long long, long long>> setds;
vector<long long> dist(V, INF);
setds.insert(make_pair(0LL, src));
dist[src] = 0;
vector<long long> parent(V);
parent[src] = src;
while (!setds.empty()) {
pair<long long, long long> tmp = *(setds.begin());
setds.erase(setds.begin());
long long u = tmp.second;
for (auto it = adj[u].begin(); it != adj[u].end(); it++) {
long long v = (*it).first;
long long weight = (*it).second;
if (dist[v] > dist[u] + weight) {
parent[v] = u;
if (dist[v] != INF) setds.erase(setds.find(make_pair(dist[v], v)));
dist[v] = dist[u] + weight;
setds.insert(make_pair(dist[v], v));
}
}
}
return dist;
}
void printpath(vector<long long> &v1, long long dest) {
if (v1[dest] == dest) {
cout << dest << ' ';
return;
}
printpath(v1, v1[dest]);
cout << dest << ' ';
}
bool bi = true;
void dfs1(vector<vector<long long>> &v, long long seen[], long long i,
long long colour) {
seen[i] = colour;
for (long long j = 0; j < v[i].size(); j++) {
if (seen[v[i][j]] == -1) {
dfs1(v, seen, v[i][j], 1 - colour);
} else if (seen[i] == seen[v[i][j]]) {
bi = false;
break;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
vector<vector<long long>> v(n);
long long seen[n];
for (long long i = 0; i < n; i++) seen[i] = -1;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
v[x - 1].push_back(y - 1);
v[y - 1].push_back(x - 1);
}
for (long long i = 0; i < n; i++) {
if (seen[i] == -1) {
dfs1(v, seen, i, 0);
}
}
if (!bi)
cout << -1;
else {
vector<long long> v1, v2;
for (long long i = 0; i < n; i++)
if (seen[i] == 0) {
v1.push_back(i);
} else
v2.push_back(i);
cout << v1.size() << "\n";
for (long long i = 0; i < v1.size(); i++) cout << v1[i] + 1 << " ";
cout << "\n";
cout << v2.size() << "\n";
for (long long i = 0; i < v2.size(); i++) cout << v2[i] + 1 << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e+5 + 10;
vector<int> v[N], res[3];
int col[N];
void dfs(int cur, int num) {
if (col[cur] != 0) {
if (col[cur] != num) {
printf("-1");
exit(0);
}
return;
}
col[cur] = num;
res[num].push_back(cur);
for (auto x : v[cur]) {
dfs(x, num ^ 3);
}
}
int main() {
int n, m, i;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
v[l].push_back(r);
v[r].push_back(l);
}
for (i = 1; i <= n; i++) {
if (!col[i]) {
dfs(i, 1);
}
}
for (int num = 1; num < 3; num++) {
printf("%d\n", res[num].size());
for (auto x : res[num]) {
printf("%d ", x);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[100005], v1, v2;
long long color[100005], visited[100005] = {0}, visited2[100005] = {0},
truev1[100005] = {0};
bool cycle;
long long n, m;
void dfs(long long v, long long parent) {
if (parent == 0)
color[v] = 1;
else
color[v] = 1 - color[parent];
visited[v] = 1;
for (auto u : adj[v]) {
if (!visited[u]) {
dfs(u, v);
}
if (visited[u] && color[u] == color[v]) cycle = true;
}
}
void dfs2(long long v) {
visited2[v] = 1;
if (color[v] == 1) {
v1.push_back(v);
truev1[v] = 1;
}
for (auto u : adj[v]) {
if (!visited2[u]) dfs2(u);
}
}
int main() {
memset(color, -1, sizeof(color));
cin >> n >> m;
while (m--) {
long long x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (long long i = 1; i <= n; i++) {
if (!visited[i]) {
cycle = false;
dfs(i, 0);
if (cycle == false) {
dfs2(i);
} else {
cout << "-1";
return 0;
}
}
}
for (long long i = 1; i <= n; i++) {
if (truev1[i] == 0) v2.push_back(i);
}
if (cycle == false) {
cout << v1.size() << endl;
for (auto k : v1) cout << k << " ";
cout << endl << v2.size() << endl;
for (auto j : v2) cout << j << " ";
return 0;
}
cout << "-1";
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 1e5 + 3;
int N, M;
vector<int> adj[mxN], vis(mxN, -1);
vector<int> a, b;
void dfs(int u, bool g) {
vis[u] = g;
if (g)
a.push_back(u);
else
b.push_back(u);
for (int v : adj[u]) {
if (vis[v] == -1) {
dfs(v, !g);
} else if (g == vis[v]) {
cout << -1 << '\n';
exit(0);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= N; i++) {
if (vis[i] == -1) dfs(i, 0);
}
cout << a.size() << '\n';
for (auto i : a) cout << i << ' ';
cout << '\n';
cout << b.size() << '\n';
for (auto i : b) cout << i << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> G[100010];
int color[100010] = {0};
bool dfs(int node, int col) {
bool res = true;
color[node] = col;
for (int i = 0; res && i < G[node].size(); i++) {
int to = G[node][i];
if (color[to] == 0) {
res = dfs(to, col == 1 ? 2 : 1);
} else if (color[to] == col) {
res = false;
} else {
continue;
}
}
return res;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].push_back(y);
G[y].push_back(x);
}
bool good = true;
for (int i = 0; i < n; i++) {
if (color[i] == 0) {
if (!dfs(i, 1)) {
good = false;
break;
}
}
}
if (!good) {
cout << -1;
} else {
vector<int> res[3];
for (int i = 0; i < n; i++) {
res[color[i]].push_back(i);
}
for (int i = 1; i < 3; i++) {
cout << res[i].size() << endl;
for (int j = 0; j < res[i].size(); j++) {
cout << (res[i][j] + 1) << " ";
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<long long> g[n];
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
queue<long long> temp;
int colour[n];
for (long long i = 0; i < n; i++) {
colour[i] = -1;
}
unordered_map<long long, bool> visite;
bool visited[n];
for (long long i = 0; i < n; i++) {
visited[i] = false;
visite[i] = false;
}
long long count = 0;
bool flag = false;
while (count != n) {
auto it = visite.begin();
long long x = it->first;
temp.push(x);
visited[x] = true;
count++;
colour[x] = 0;
visite.erase(it);
while (!temp.empty()) {
long long s = temp.front();
temp.pop();
for (auto u : g[s]) {
if (visited[u]) {
if (colour[u] == colour[s]) {
flag = true;
}
continue;
}
visited[u] = true;
visite.erase(u);
count++;
if (colour[s] == 0) {
colour[u] = 1;
} else {
colour[u] = 0;
}
temp.push(u);
}
}
}
if (flag) {
cout << "-1" << endl;
} else {
vector<long long> A, B;
for (long long i = 0; i < n; i++) {
if (colour[i] == 0) {
A.push_back(i + 1);
}
}
for (long long i = 0; i < n; i++) {
if (colour[i] == 1 || colour[i] == -1) {
B.push_back(i + 1);
}
}
cout << A.size() << endl;
for (auto temp1 : A) {
cout << temp1 << " ";
}
cout << endl;
cout << B.size() << endl;
for (auto temp1 : B) {
cout << temp1 << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int color[1000000];
bool flag = true;
vector<vector<int> > g;
void dfs(int v, int prevColor) {
int curColor = 3 - prevColor;
color[v] = curColor;
for (int i = 0; i < g[v].size(); i++) {
if (color[g[v][i]] == curColor) {
flag = false;
} else {
if (color[g[v][i]] == 0) {
dfs(g[v][i], curColor);
}
}
}
}
int main(int argc, const char* argv[]) {
int n, m;
cin >> n >> m;
g.resize(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0; i < n; i++) {
if (color[i] == 0) dfs(i, 2);
}
if (!flag) {
cout << "-1";
return 0;
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (color[i] == 1) {
cnt++;
}
}
cout << cnt << endl;
for (int i = 0; i < n; i++) {
if (color[i] == 1) {
cout << i + 1 << " ";
}
}
cout << endl << n - cnt << endl;
for (int i = 0; i < n; i++) {
if (color[i] == 2) cout << i + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, u, v;
vector<vector<int> > adj;
vector<int> col;
bool colorear(int u, int c) {
col[u] = c;
bool p = 1;
for (int j : adj[u]) {
if (col[j] != -1) {
if (col[u] == col[j]) return false;
} else {
p &= colorear(j, 1 - c);
}
}
return p;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
adj = vector<vector<int> >(n + 1);
col = vector<int>(n + 1, -1);
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
bool pos = 1;
for (int i = 1; i <= n; i++)
if (col[i] == -1) pos &= colorear(i, 0);
if (pos) {
vector<int> a[2];
for (int i = 1; i <= n; i++) {
a[col[i]].push_back(i);
}
cout << a[0].size() << '\n';
for (int x : a[0]) cout << x << " ";
cout << '\n' << a[1].size() << '\n';
for (int x : a[1]) cout << x << " ";
cout << '\n';
} else {
cout << -1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
int main() {
ios::sync_with_stdio(0);
int V, E, i, j, x, k, y, w = 0;
cin >> V >> E;
vector<int> P(100000);
vector<int> p[2];
vector<bool> C(100000);
vector<vector<int> > G(V);
for (i = 0; i < E; i++) {
cin >> x >> y;
G[y - 1].push_back(x - 1);
G[x - 1].push_back(y - 1);
}
for (k = 0; k < V; k++) {
if (C[k] == 0) {
P[k] = 1;
p[0].push_back(k);
C[k] = 1;
q.push(k);
int a;
while (!q.empty()) {
a = q.front();
q.pop();
for (int i = 0; i < G[a].size(); i++) {
if (P[a] == P[G[a][i]]) {
w = 1;
goto label;
} else if (C[G[a][i]] == 0) {
p[2 - P[a]].push_back(G[a][i]);
C[G[a][i]] = 1;
P[G[a][i]] = 3 - P[a];
q.push(G[a][i]);
}
}
}
}
}
cout << p[0].size() << '\n';
for (i = 0; i < p[0].size(); i++) {
cout << p[0][i] + 1 << " ";
}
cout << '\n' << p[1].size() << '\n';
for (i = 0; i < p[1].size(); i++) {
cout << p[1][i] + 1 << " ";
}
label:
if (w == 1) cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > v;
const int N = 1e5 + 5;
int vis[N], inc[N];
bool bigraph;
void dfs(int n) {
for (int i = 0; i < v[n].size(); i++) {
if (vis[v[n][i]] == -1) {
vis[v[n][i]] = !vis[n];
dfs(v[n][i]);
} else if (vis[v[n][i]] == vis[n]) {
bigraph = 0;
}
}
}
int main() {
int m, n;
bigraph = 1;
scanf("%d%d", &n, &m);
memset(vis, -1, sizeof vis);
int x, y;
v.resize(n + 1);
while (m--) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
inc[x] = 1;
inc[y] = 1;
}
for (int i = 1; i <= n; i++) {
if (vis[i] == -1 && inc[i]) {
vis[i] = 1;
dfs(i);
}
}
if (bigraph) {
vector<int> a, b;
for (int i = 1; i <= n; i++)
if (inc[i]) {
if (vis[i] == 1)
a.push_back(i);
else
b.push_back(i);
}
cout << a.size() << endl;
for (int i = 0; i < a.size(); i++) cout << a[i] << " \n"[i == a.size() - 1];
cout << b.size() << endl;
for (int i = 0; i < b.size(); i++) cout << b[i] << " \n"[i == b.size() - 1];
} else
cout << "-1" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 1;
int kolory[MAX];
bool koloruj(vector<vector<int> > &a, int s, short kol) {
kolory[s] = kol;
bool odp = true;
for (int i = 0; i < a[s].size(); i++)
if (kolory[a[s][i]] == 0) {
odp = (odp && koloruj(a, a[s][i], -kol));
} else if (kolory[a[s][i]] == kol) {
return false;
}
return odp;
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<vector<int> > g(n);
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
g[a - 1].push_back(b - 1);
g[b - 1].push_back(a - 1);
}
bool odp = koloruj(g, 0, 1);
for (int i = 1; i < n; i++) {
if (kolory[i] == 0) odp = (odp && koloruj(g, i, 1));
}
vector<int> lista;
int ile = 0;
if (odp) {
for (int i = 0; i < n; i++) {
if (kolory[i] == 1) {
ile++;
lista.push_back(i + 1);
}
}
cout << ile << endl;
for (int i = 0; i < lista.size(); i++) cout << lista[i] << " ";
cout << endl;
lista.clear();
ile = 0;
for (int i = 0; i < n; i++) {
if (kolory[i] == -1) {
ile++;
lista.push_back(i + 1);
}
}
cout << ile << endl;
for (int i = 0; i < lista.size(); i++) cout << lista[i] << " ";
} else
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> vis(n);
vector<bool> azul(n);
int blu = 0;
vector<vector<int> > adj(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
stack<pair<int, bool> > fs;
fs.push(make_pair(i, 1));
int x;
bool color;
while (!fs.empty()) {
pair<int, bool> wtf = fs.top();
fs.pop();
x = wtf.first;
color = wtf.second;
if (!vis[x]) {
vis[x] = 1;
if (color) {
blu++;
azul[x] = 1;
}
for (int j = 0; j < adj[x].size(); j++) {
if (vis[adj[x][j]]) {
if (color == azul[adj[x][j]]) {
cout << -1 << endl;
return 0;
}
} else {
fs.push(make_pair(adj[x][j], color ^ 1));
}
}
}
}
}
}
cout << blu << endl;
for (int i = 0; i < n; i++) {
if (azul[i]) {
cout << i + 1 << " ";
}
}
cout << endl;
cout << n - blu << endl;
for (int i = 0; i < n; i++) {
if (!azul[i]) {
cout << i + 1 << " ";
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[100005], f;
vector<int> v[100005];
void check(int x, int c) {
if (arr[x] == c) return;
if (arr[x] == 3 - c) {
f = 1;
return;
}
arr[x] = c;
for (int i = 0; i < v[x].size(); i++) check(v[x][i], 3 - c);
}
int main() {
int n, m, i, x, y;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 1; i <= n; i++) {
if (!arr[i]) check(i, 1);
}
if (f)
cout << -1;
else {
int a = 0, b = 0;
for (i = 1; i <= n; i++) {
if (arr[i] == 1) a++;
if (arr[i] == 2) b++;
}
cout << a << '\n';
for (i = 1; i <= n; i++)
if (arr[i] == 1) cout << i << " ";
cout << "\n" << b << "\n";
for (i = 1; i <= n; i++)
if (arr[i] == 2) cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e5 + 1;
vector<int> graph[inf];
vector<int> color(inf, -1);
vector<int> visited(inf, 0);
int flag = 1;
void dfs(int root) {
visited[root] = 1;
for (auto child : graph[root]) {
if (!visited[child]) {
color[child] = (color[root] ^ 1);
dfs(child);
} else {
if (color[child] != (color[root] ^ 1)) {
flag = 0;
return;
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
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);
}
for (int i = 0; i < n; i++) {
if (graph[i].size() == 0) {
continue;
}
if (!visited[i]) {
color[i] = 0;
dfs(i);
}
}
if (!flag) {
cout << -1 << endl;
} else {
vector<int> a;
vector<int> b;
for (int i = 0; i < n; i++) {
if (color[i] == 0) {
a.push_back(i + 1);
} else if (color[i] == 1) {
b.push_back(i + 1);
}
}
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] << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 3e6;
const long long mod = 1e9 + 7;
const long double PI = acos((long double)-1);
long long pw(long long a, long long b, long long md = mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = (a * res) % md;
}
a = (a * a) % md;
b >>= 1;
}
return (res);
}
int n, m;
vector<int> adj[maxn];
int mark[maxn];
void dfs(int v) {
if (!mark[v]) mark[v] = 1;
for (auto u : adj[v]) {
if (!mark[u]) mark[u] = ((mark[v] == 1) ? 2 : 1), dfs(u);
if (mark[u] == mark[v]) cout << -1, exit(0);
}
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!mark[i]) dfs(i);
int cnt = 0;
for (int i = 1; i <= n; i++) cnt += mark[i] == 1;
cout << cnt << '\n';
for (int i = 1; i <= n; i++)
if (mark[i] == 1) cout << i << ' ';
cout << '\n';
cout << n - cnt << '\n';
for (int i = 1; i <= n; i++)
if (mark[i] != 1) cout << i << ' ';
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
int color[100005];
int main() {
ios_base::sync_with_stdio(0);
int i, j, n, m;
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
bool f = true;
memset(color, -1, sizeof(color));
for (int p = 1; p <= n; p++) {
if (color[p] != -1) continue;
if (adj[p].size() == 0) continue;
queue<int> q;
q.push(p);
color[p] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int j = 0; j < adj[u].size(); j++) {
int v = adj[u][j];
if (color[v] == -1) {
color[v] = 1 - color[u];
q.push(v);
} else if (color[v] == color[u]) {
f = false;
break;
}
}
}
}
if (f == 0) {
cout << "-1" << '\n';
return 0;
}
int k = 0;
for (i = 1; i <= n; i++)
if (color[i] == 0) k++;
cout << k << '\n';
for (i = 1; i <= n; i++)
if (color[i] == 0) cout << i << ' ';
cout << '\n';
k = 0;
for (i = 1; i <= n; i++)
if (color[i] == 1) k++;
cout << k << '\n';
for (i = 1; i <= n; i++)
if (color[i] == 1) cout << i << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, u, v;
bool vis[100007], vis2[100007], cycle;
vector<int> adj[100007], sol1, sol2;
int color[100007];
void DFS(int node, int par, bool white) {
if (vis[node] && color[node] != white) {
cycle = true;
return;
}
if (vis[node]) return;
vis[node] = true;
color[node] = white;
if (white) {
sol1.push_back(node);
} else
sol2.push_back(node);
for (int i = 0; i < adj[node].size(); i++) {
if (adj[node][i] != par) DFS(adj[node][i], node, 1 - white);
}
return;
}
void mod_DFS(int node, int par) {
if (vis2[node]) return;
vis[node] = true;
vis2[node] = true;
for (int i = 0; i < adj[node].size(); i++) {
if (adj[node][i] != par) mod_DFS(adj[node][i], node);
}
return;
}
int main() {
cin >> n >> m;
while (m--) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
cycle = false;
if (!vis[i]) {
DFS(i, -1, 1);
if (cycle) {
cout << -1;
return 0;
} else {
mod_DFS(i, -1);
}
}
}
cout << sol1.size() << endl;
for (int j = 0; j < sol1.size(); j++) {
cout << sol1[j] << ' ';
}
cout << endl;
cout << sol2.size() << endl;
for (int j = 0; j < sol2.size(); j++) {
cout << sol2[j] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
int color[100005];
bool visited[100005];
bool isbipartite = true;
vector<int> g[3];
void dfs(int u, int c) {
visited[u] = true;
color[u] = c;
g[c].push_back(u);
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (color[v] == -1) {
color[v] = 1 - color[u];
int c = color[v];
dfs(v, c);
} else {
if (color[v] == color[u]) {
isbipartite = false;
}
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
memset(color, -1, sizeof(color));
memset(visited, false, sizeof(visited));
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
dfs(i, 0);
}
}
if (isbipartite == false) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < 3; i++) {
if (g[i].size() != 0) {
cout << g[i].size() << endl;
for (int j = 0; j < g[i].size(); j++) {
cout << g[i][j] << " ";
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
int mul(int x, int y) { return 1LL * x * y % mod; }
int qpow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = mul(res, x);
y >>= 1;
x = mul(x, x);
}
return res;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
using namespace std;
const int maxn = 1e5 + 500;
int n, m, co[maxn];
vector<int> G[maxn];
bool dfs(int x) {
for (auto v : G[x]) {
if (co[v] == -1) {
co[v] = co[x] ^ 1;
if (!dfs(v)) return false;
} else if (co[v] == co[x])
return false;
}
return true;
}
int main(int argc, char *argv[]) {
n = read(), m = read();
memset(co, -1, sizeof(co));
for (int(i) = (1); (i) <= (m); ++(i)) {
int u = read(), v = read();
G[u].push_back(v);
G[v].push_back(u);
}
for (int(i) = (1); (i) <= (n); ++(i))
if (co[i] == -1) {
co[i] = 0;
if (!dfs(i)) {
printf("-1\n");
return 0;
}
}
vector<int> A, B;
for (int(i) = (1); (i) <= (n); ++(i))
if (co[i] == 0)
A.push_back(i);
else
B.push_back(i);
printf("%d\n", A.size());
for (auto it : A) printf("%d ", it);
printf("\n");
printf("%d\n", B.size());
for (auto it : B) printf("%d ", it);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<int> edge[100001];
int val[100001];
vector<int> ans[2];
void dfs(int i, int fi) {
if (val[i] != 0 && fi != val[i]) {
cout << "-1\n";
exit(0);
}
if (val[i] != 0 && fi == val[i]) {
return;
}
val[i] = fi;
ans[(fi + 1) / 2].push_back(i);
for (int j = 0; j < edge[i].size(); j++) {
dfs(edge[i][j], -fi);
}
}
int main() {
ios_base::sync_with_stdio(false);
if (fopen("cf688c.in", "r")) {
freopen("cf688c.in", "r", stdin);
freopen("cf688c.out", "w", stdout);
}
cin >> N >> M;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
edge[a].push_back(b);
edge[b].push_back(a);
}
for (int i = 0; i < N; i++) {
if (val[i] == 0) {
if (ans[0].size() == 0) {
dfs(i, -1);
} else {
dfs(i, 1);
}
}
}
if (ans[0].size() == 0 || ans[1].size() == 0) {
cout << "-1\n";
return 0;
}
cout << ans[0].size() << '\n';
for (int i = 0; i < ans[0].size(); i++) {
cout << ans[0][i] + 1 << ' ';
}
cout << '\n';
cout << ans[1].size() << '\n';
for (int i = 0; i < ans[1].size(); i++) {
cout << ans[1][i] + 1 << ' ';
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, next;
} a[200001];
int vis[100001], st[100001], cnt = 0;
void add(int x, int y) {
a[++cnt] = (node){y, st[x]};
st[x] = cnt;
}
bool dfs(int x, int y) {
if (vis[x])
if (vis[x] + y == 3)
return 0;
else
return 1;
vis[x] = y;
int i, to;
for (i = st[x]; i; i = a[i].next) {
to = a[i].to;
if (!dfs(to, 3 - y)) return 0;
}
return 1;
}
int main() {
int n, m;
int i;
int x, y;
int ans1 = 0, ans2 = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
for (i = 1; i <= n; i++)
if (!vis[i])
if (!dfs(i, 1)) break;
if (i <= n) {
printf("-1");
goto end;
}
for (i = 1; i <= n; i++)
if (vis[i] == 1)
ans1++;
else
ans2++;
if (ans2 == 0) ans1--, ans2 = 1, vis[1] = 2;
printf("%d\n", ans1);
for (i = 1; i <= n; i++)
if (vis[i] == 1) printf("%d ", i);
printf("\n");
printf("%d\n", ans2);
for (i = 1; i <= n; i++)
if (vis[i] == 2) printf("%d ", i);
printf("\n");
end:;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5;
vector<int> G[N];
vector<int> ans[3];
int n, m;
int col[N];
int dfs(int u, int x, int fa) {
col[u] = x;
ans[x].push_back(u);
for (auto v : G[u]) {
if (col[u] == col[v]) return 1;
if (v != fa && !col[v] && dfs(v, 3 - x, u)) return 1;
}
return 0;
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
memset(col, 0, sizeof(col));
ans[1].clear(), ans[2].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);
}
int flag = 0;
for (int i = 1; i <= n; i++) {
if (!G[i].size()) col[i] = 2;
if (!col[i]) flag = dfs(i, 2, 0);
if (flag) break;
}
if (flag)
puts("-1");
else {
printf("%d\n", ans[1].size());
for (auto u : ans[1]) printf("%d ", u);
puts("");
printf("%d\n", ans[2].size());
for (auto u : ans[2]) printf("%d ", u);
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
vector<int> adj[MAXN];
int mark[MAXN];
bool color[MAXN];
int m, n;
void dfs(int v) {
mark[v] = true;
for (int u : adj[v]) {
if (mark[u] == false) {
color[u] = !color[v];
dfs(u);
}
if (color[u] == color[v]) {
cout << -1 << '\n';
exit(0);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--, y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 0; i < n; i++)
if (!mark[i]) dfs(i);
int black = 0;
int white = 0;
for (int i = 0; i < n; i++) {
if (color[i])
black++;
else
white++;
}
cout << black << '\n';
for (int i = 0; i < n; i++)
if (color[i]) cout << i + 1 << " ";
cout << '\n' << white << '\n';
for (int i = 0; i < n; i++)
if (!color[i]) cout << i + 1 << " ";
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
bool ans = true;
int const MAX = 1000 * 100 + 10;
vector<int> adj[MAX];
int cnt[3];
int part[MAX];
void dfs(int v) {
for (int i = 0; i < adj[v].size(); i++) {
if (part[adj[v][i]] == 0) {
part[adj[v][i]] = 3 - part[v];
cnt[part[adj[v][i]]]++;
dfs(adj[v][i]);
} else if (part[adj[v][i]] == part[v])
ans = false;
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (part[i] == 0) {
part[i] = 1;
dfs(i);
cnt[1]++;
}
}
if (ans == false) {
cout << -1;
return 0;
}
cout << cnt[1] << endl;
for (int i = 1; i <= n; i++) {
if (part[i] == 1) {
cout << i << " ";
}
}
cout << endl << cnt[2] << endl;
for (int i = 1; i <= n; i++) {
if (part[i] == 2) {
cout << i << " ";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T BMOD(T p, T e, T m) {
T ret = 1;
while (e) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
e >>= 1;
}
return (T)ret;
}
template <class T>
inline T MODINV(T a, T m) {
return BMOD(a, m - 2, m);
}
template <class T>
inline T isPrime(T a) {
for (T i = 2; i <= sqrt(double(a)); i++) {
if (a % i == 0) {
return 0;
}
}
return 1;
}
template <class T>
inline T lcm(T a, T b) {
return (a / __gcd(a, b)) * b;
}
template <class T>
inline T power(T a, T b) {
return (b == 0) ? 1 : a * power(a, b - 1);
}
int vs[1000100], fl = 0;
vector<int> g[1000100];
void dfs(int s, int f) {
if (fl) return;
vs[s] = f;
for (int i = 0; i < (int)g[s].size(); i++) {
if (vs[g[s][i]] == -1) {
dfs(g[s][i], f ^ 1);
} else if (vs[s] == vs[g[s][i]])
fl = 1;
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, d, a, b, f = 0;
cin >> n >> d;
for (int i = 0; i < d; i++) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
memset(vs, -1, sizeof vs);
for (int i = 1; i <= n; i++) {
if (vs[i] == -1) dfs(i, 0);
}
if (fl == 1)
cout << -1 << endl;
else {
int one = 0, zero = 0;
for (int i = 1; i <= n; i++) {
if (vs[i] == 1) one++;
if (vs[i] == 0) zero++;
}
cout << one << endl;
for (int i = 1; i <= n; i++) {
if (vs[i] == 1) cout << i << " ";
}
cout << endl;
cout << zero << endl;
for (int i = 1; i <= n; i++) {
if (vs[i] == 0) cout << i << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, e;
cin >> n >> e;
vector<int> adj[n + 1];
for (int i = 0; i < e; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
bool is_bipartite = 1;
vector<int> side(n + 1, -1);
queue<int> q;
for (int node = 1; node <= n; node++) {
if (side[node] == -1) {
q.push(node);
side[node] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (side[v] == -1) {
side[v] = 1 ^ side[u];
q.push(v);
} else {
is_bipartite &= side[v] != side[u];
}
}
}
}
}
if (!is_bipartite) {
cout << -1 << "\n";
} else {
vector<int> v1, v2;
for (int i = 1; i <= n; i++) {
if (adj[i].size() != 0) {
if (side[i] == 0)
v1.push_back(i);
else
v2.push_back(i);
}
}
cout << v1.size() << "\n";
for (int i = 0; i < v1.size(); i++) cout << v1[i] << " ";
cout << "\n";
cout << v2.size() << "\n";
for (int i = 0; i < v2.size(); i++) cout << v2[i] << " ";
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e5 + 10;
int fa[Max * 2];
int find(int x) { return fa[x] == -1 ? x : fa[x] = find(fa[x]); }
void Union(int x, int y) {
int f1 = find(x), f2 = find(y);
if (f1 != f2) fa[f1] = f2;
}
vector<int> ans1, ans2;
int vis[Max];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
memset(fa, -1, sizeof(fa));
memset(vis, 0, sizeof(vis));
int u, v, flag = 0;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
if (flag) continue;
if (find(u) == find(v) || find(u + n) == find(v + n)) flag = 1;
Union(u, v + n);
Union(u + n, v);
vis[u] = vis[v] = 1;
}
ans1.clear();
ans2.clear();
for (int i = 1; i <= n; i++) {
if (!vis[i]) continue;
if (find(i) <= n)
ans1.push_back(i);
else
ans2.push_back(i);
}
if (ans1.empty() || ans2.empty() || flag)
puts("-1");
else {
if (ans1.size() > ans2.size()) swap(ans1, ans2);
printf("%d\n", ans1.size());
for (int i = 0; i < ans1.size(); i++) {
if (i) printf(" ");
printf("%d", ans1[i]);
}
printf("\n%d\n", ans2.size());
for (int i = 0; i < ans2.size(); i++) {
if (i) printf(" ");
printf("%d", ans2[i]);
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100005];
bool vis[100005];
set<int> A, B;
bool dfs(int x, bool st) {
vis[x] = true;
if (!st) {
A.insert(x);
} else {
B.insert(x);
}
int i, ans = 1;
for (i = 0; i < graph[x].size(); i++) {
int s = graph[x][i];
if (!vis[s]) {
bool ts = !st;
ans = ans && dfs(s, ts);
} else {
if ((!st && A.find(s) != A.end()) || (st && B.find(s) != B.end())) {
return false;
}
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
int ans = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i] && graph[i].size()) {
ans &= dfs(i, 0);
}
}
if (!ans) {
cout << "-1" << endl;
} else {
set<int>::iterator it;
cout << A.size() << endl;
for (it = A.begin(); it != A.end(); ++it) {
cout << *it << " ";
}
cout << endl;
cout << B.size() << endl;
for (it = B.begin(); it != B.end(); ++it) {
cout << *it << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
vector<int> adj[N + 2], ans[N + 2];
int color[N + 2];
void inv(void) {
cout << "-1" << endl;
exit(0);
}
void dfs(int node, int h) {
if (!color[node])
color[node] = (h % 2 + 1);
else {
if (color[node] != (h % 2 + 1)) inv();
return;
}
ans[h].push_back(node);
for (auto x : adj[node]) dfs(x, h + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
set<int> x, y;
while (m--) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!color[i]) dfs(i, 1);
vector<int> s1, s2;
for (int i = 1; i <= n; i += 2)
s1.insert(s1.end(), ans[i].begin(), ans[i].end());
for (int i = 2; i <= n; i += 2)
s2.insert(s2.end(), ans[i].begin(), ans[i].end());
cout << s1.size() << endl;
for (auto x : s1) cout << x << " ";
cout << endl;
cout << s2.size() << endl;
for (auto x : s2) cout << x << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
vector<int> G[maxn];
int v;
int color[maxn];
int a[maxn];
int b[maxn];
bool dfs(int v, int c) {
color[v] = c;
for (int i = 0; i < 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;
}
bool solve() {
for (int i = 1; i <= v; i++) {
if (color[i] == 0) {
if (!dfs(i, 1)) return false;
}
}
return true;
}
int main() {
int e;
while (~scanf("%d%d", &v, &e)) {
memset(color, 0, sizeof(color));
for (int i = 1; i <= v; i++) G[i].clear();
for (int i = 0; i < e; i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
int k1 = 0, k2 = 0;
if (solve()) {
for (int i = 1; i <= v; i++) {
if (color[i] == -1) {
a[k1++] = i;
} else
b[k2++] = i;
}
printf("%d\n", k1);
printf("%d", a[0]);
for (int i = 1; i < k1; i++) printf(" %d", a[i]);
printf("\n");
printf("%d\n", k2);
printf("%d", b[0]);
for (int i = 1; i < k2; i++) printf(" %d", b[i]);
printf("\n");
} else
printf("-1\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> a[((long)1e5 + 10)];
bool invalid = false;
bool visited[((long)1e5 + 10)];
bool used[((long)1e5 + 10)];
int color[((long)1e5 + 10)];
void visit(int u) {
int v;
visited[u] = true;
for (unsigned i = 0; i < a[u].size(); i++) {
v = a[u][i];
if (!visited[v]) {
color[v] = 3 - color[u];
visit(v);
} else if (color[v] == color[u])
invalid = true;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int p, q;
cin >> p >> q;
used[p] = used[q] = true;
a[p].push_back(q);
a[q].push_back(p);
}
for (int i = 1; i <= n; i++)
if (!visited[i]) {
color[i] = 1;
visit(i);
}
if (invalid)
cout << -1;
else {
int cnt = 0;
for (int i = 1; i <= n; i++)
if (visited[i] && used[i] && color[i] == 1) cnt++;
cout << cnt << '\n';
for (int i = 1; i <= n; i++)
if (visited[i] && used[i] && color[i] == 1) cout << i << ' ';
cnt = 0;
for (int i = 1; i <= n; i++)
if (visited[i] && used[i] && color[i] == 2) cnt++;
cout << '\n' << cnt << '\n';
for (int i = 1; i <= n; i++)
if (visited[i] && used[i] && color[i] == 2) cout << i << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int col[123456];
vector<int> g[123456];
void dfs(int v) {
for (int u : g[v]) {
if (col[u] == -1) {
col[u] = 1 - col[v];
dfs(u);
} else if (col[u] == col[v]) {
cout << "-1\n";
exit(0);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
memset(col, -1, sizeof col);
for (int i = 0; i < n; ++i)
if (col[i] == -1) {
col[i] = 0;
dfs(i);
}
int x = 0;
for (int i = 0; i < n; ++i)
if (col[i] == 0) x++;
cout << x << '\n';
for (int i = 0; i < n; ++i)
if (col[i] == 0) cout << i + 1 << ' ';
cout << '\n';
cout << n - x << '\n';
for (int i = 0; i < n; ++i)
if (col[i] == 1) cout << i + 1 << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long zero = 0;
long long one = 1;
int max_int = INT_MAX;
int min_int = INT_MIN;
void printArray(long long a[], long long n) {
for (long long i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
}
void printVector(vector<long long> v) {
long long n = v.size();
for (long long i = 0; i < n; i++) cout << v[i] << " ";
cout << endl;
}
string reversed(string s) {
string t = "";
for (long long i = s.length() - 1; i >= 0; i--) t += s[i];
return t;
}
string binary(long long n, long long val) {
string s = "";
while (n > 0) {
if (n % 2 == 1)
s = s + '1';
else
s = s + '0';
n = n / 2;
}
long long k = val - s.size();
for (long long i = 0; i < k; i++) s += '0';
return reversed(s);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
vector<vector<long long> > adj_list(n + 1);
vector<long long> x(m), y(m);
for (long long i = 0; i < m; i++) {
cin >> x[i] >> y[i];
adj_list[x[i]].push_back(y[i]);
adj_list[y[i]].push_back(x[i]);
}
vector<long long> level(n + 1, 0);
vector<bool> check(n + 1, false);
for (long long j = 1; j <= n; j++) {
if (check[j] == false) {
level[j] = 0;
queue<long long> q;
q.push(j);
while (q.size() != 0) {
long long node = q.front();
check[node] = true;
q.pop();
vector<long long> v = adj_list[node];
for (long long i = 0; i < v.size(); i++) {
long long x1 = v[i];
if (check[x1] == false) {
level[x1] = level[node] + 1;
q.push(x1);
}
}
}
}
}
bool possible = true;
for (long long i = 0; i < m; i++) {
long long l1 = level[x[i]];
long long l2 = level[y[i]];
long long diff = abs(l1 - l2);
if (diff % 2 == 0) {
possible = false;
break;
}
}
if (possible == false) {
cout << -1 << endl;
} else {
vector<long long> s1, s2;
for (long long i = 1; i <= n; i++) {
if (level[i] % 2 == 0) {
s1.push_back(i);
} else if (level[i] % 2 != 0) {
s2.push_back(i);
}
}
cout << s1.size() << endl;
printVector(s1);
cout << s2.size() << endl;
printVector(s2);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 1e5 + 10;
int n, m, u, v, belong[N];
vector<int> g[N];
bool dfs(int cur, int color = 0) {
belong[cur] = color + 1;
bool ret = true;
for (int i = 0, to; ret && i < g[cur].size(); i++) {
to = g[cur][i];
if (!belong[to])
ret &= dfs(to, !color);
else if (belong[to] != !color + 1)
ret = false;
}
return ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
bool can = true;
for (int i = 1; can && i <= n; i++)
if (!belong[i]) can &= dfs(i);
if (!can)
cout << -1 << endl;
else {
int cnt1 = 0, cnt2;
for (int i = 1; i <= n; i++) cnt1 += belong[i] == 1;
cnt2 = n - cnt1;
cout << cnt1 << endl;
for (int i = 1; i <= n; i++)
if (belong[i] == 1) printf("%d%c", i, "\n "[bool(--cnt1)]);
cout << cnt2 << endl;
for (int i = 1; i <= n; i++)
if (belong[i] == 2) printf("%d%c", i, "\n "[bool(--cnt2)]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[100005];
int s[100005];
void addEdge(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
bool flag;
int n, m;
void dfs(int k, int color) {
s[k] = color;
int len = G[k].size();
for (int i = 0; i < len; i++) {
if (s[G[k][i]] == 0)
dfs(G[k][i], 3 - color);
else {
if (s[G[k][i]] == color) {
flag = true;
return;
}
}
}
}
int main() {
for (int i = 0; i <= 100000; i++) G[i].clear();
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
addEdge(x - 1, y - 1);
}
flag = false;
memset(s, 0, sizeof s);
for (int i = 0; i < n; i++) {
if (s[i] == 0) {
dfs(i, 1);
}
}
if (flag) {
printf("-1\n");
return 0;
} else {
int num1 = 0, num2 = 0;
for (int i = 0; i < n; i++)
if (s[i] == 1)
num1++;
else
num2++;
printf("%d\n", num1);
for (int i = 0; i < n; i++)
if (s[i] == 1) printf("%d ", i + 1);
printf("\n");
printf("%d\n", num2);
for (int i = 0; i < n; i++)
if (s[i] == 2) printf("%d ", i + 1);
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct lines {
int who;
lines *nexts;
} all[100010];
int color[100010];
void marry(int a, int b) {
lines *p = new lines;
p->who = a;
p->nexts = all[b].nexts;
all[b].nexts = p;
}
int pre[100010];
void init(int n) {
for (int i = 0; i <= n; ++i) {
all[i].nexts = NULL;
pre[i] = i;
}
}
vector<int> ans1, ans2;
queue<int> q;
int find(int x) {
if (x == pre[x]) {
return x;
} else {
return pre[x] = find(pre[x]);
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
init(n);
int a, b;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
marry(a, b);
marry(b, a);
int xa = find(a);
int xb = find(b);
if (xa < xb) {
pre[xa] = xb;
} else {
pre[xb] = xa;
}
}
for (int i = 1; i <= n; ++i) {
if (i == find(i)) {
q.push(i);
}
}
int ok = 1;
while (!q.empty()) {
int who = q.front();
q.pop();
if (color[who] == 0) {
color[who] = 1;
lines *p = all[who].nexts;
while (p != NULL) {
color[p->who] = -1;
q.push(p->who);
p = p->nexts;
}
} else if (color[who] == 1) {
lines *p = all[who].nexts;
while (p != NULL) {
if (color[p->who] == 1) {
ok = 0;
break;
}
if (color[p->who] == 0) color[p->who] = -1;
q.push(p->who);
p = p->nexts;
}
} else if (color[who] == -1) {
lines *p = all[who].nexts;
while (p != NULL) {
if (color[p->who] == -1) {
ok = 0;
break;
}
if (color[p->who] == 0) q.push(p->who);
color[p->who] = 1;
p = p->nexts;
}
}
if (!ok) {
break;
}
}
if (!ok) {
printf("-1\n");
} else {
for (int i = 1; i <= n; ++i) {
if (color[i] == 1) {
ans1.push_back(i);
} else if (color[i] == -1) {
ans2.push_back(i);
}
}
int ans11 = ans1.size();
int ans22 = ans2.size();
printf("%d\n", ans11);
for (int i = 0; i < ans11; ++i) {
printf("%d ", ans1[i]);
}
printf("\n");
printf("%d\n", ans22);
for (int i = 0; i < ans22; ++i) {
printf("%d ", ans2[i]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int E = 0, mark[100005];
bool op;
vector<int> v[100005];
void dfs(int a) {
if (mark[a] == 0) mark[a] = 1;
for (int i = 0; i < v[a].size(); i++) {
int k = v[a][i];
if (mark[k] == mark[a]) {
cout << "-1";
exit(0);
} else if (mark[k] == 0) {
mark[k] = 3 - mark[a];
dfs(k);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; 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 (mark[i] == 0) {
dfs(i);
}
}
int EE = 0;
for (int i = 1; i <= n; i++) {
if (mark[i] != 2)
E++;
else
EE++;
}
cout << EE << endl;
for (int i = 1; i <= n; i++) {
if (mark[i] == 2) cout << i << " ";
}
cout << endl;
cout << E << endl;
for (int i = 1; i <= n; i++) {
if (mark[i] != 2) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
bool flag;
int n, m;
int c[100005];
vector<int> a[2], e[100005];
void dfs(int x, int t) {
if (c[x] != -1) {
if (c[x] != t) flag = 1;
return;
}
c[x] = t;
a[t].push_back(x);
for (int i = 0; i < e[x].size(); i++) dfs(e[x][i], t ^ 1);
}
void output(vector<int> &x) {
printf("%d\n", x.size());
for (int i = 0; i < x.size() - 1; i++) {
printf("%d ", x[i]);
}
printf("%d\n", x[x.size() - 1]);
}
int main() {
memset(c, -1, sizeof(c));
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (c[i] == -1) dfs(i, 1);
if (flag)
puts("-1\n");
else {
sort(a[0].begin(), a[0].end());
sort(a[1].begin(), a[1].end());
if (a[0].size() < a[1].size()) {
output(a[0]);
output(a[1]);
} else {
output(a[1]);
output(a[0]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void init() {}
const int N = 1e6 + 34;
const int INF = 1e9 + 34;
vector<int> ans[2];
vector<int> es[N];
int n, m, v1, v2;
int c[N];
void dfs(int v, int q) {
if (c[v] && c[v] != q + 1) {
cout << "-1";
exit(0);
}
if (c[v]) return;
c[v] = q + 1;
ans[q].push_back(v + 1);
for (int w : es[v]) {
dfs(w, 1 - q);
}
}
int main() {
init();
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> v1 >> v2;
v1--;
v2--;
es[v1].push_back(v2);
es[v2].push_back(v1);
}
for (int i = 0; i < n; i++)
if (!c[i]) dfs(i, 0);
for (int i = 0; i < 2; i++) {
cout << ans[i].size() << "\n";
for (int w : ans[i]) cout << w << " ";
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100010];
int vis[100010];
int flag;
void dfs(int v, int c) {
vis[v] = c;
for (int i = 0; i < adj[v].size(); i++) {
if (!vis[adj[v][i]]) {
dfs(adj[v][i], c == 1 ? 2 : 1);
} else if (vis[adj[v][i]] != (c == 1 ? 2 : 1)) {
flag = 1;
}
}
}
int main() {
int n, m;
cin >> n >> m;
flag = 0;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
memset(vis, 0, sizeof vis);
int first = 1;
int numAdj = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, 1);
}
}
int sizes[3];
memset(sizes, 0, sizeof sizes);
if (flag || numAdj > 1) {
cout << -1 << "\n";
return 0;
}
for (int i = 1; i <= n; i++) {
sizes[vis[i]]++;
}
cout << sizes[1] << "\n";
for (int i = 1; i <= n; i++) {
if (vis[i] == 1) cout << i << " ";
}
cout << "\n";
cout << sizes[2] << "\n";
for (int i = 1; i <= n; i++) {
if (vis[i] == 2) cout << i << " ";
}
cout << "\n";
}
|
#include <bits/stdc++.h>
int edge[300000], next[300000], first[120000];
int p[120000];
int i, m, n, x, y, t1, t2, sum_edge;
inline void addedge(int x, int y) {
sum_edge++, edge[sum_edge] = y, next[sum_edge] = first[x],
first[x] = sum_edge;
return;
}
inline bool checkgraph(int x, int y) {
p[x] = y;
for (int i = first[x]; i != 0; i = next[i]) {
if ((!p[edge[i]]) && (!checkgraph(edge[i], 3 - y))) return false;
if (p[edge[i]] == y) return false;
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
addedge(x, y), addedge(y, x);
}
for (i = 1; i <= n; i++)
if ((!p[i]) && (!checkgraph(i, 1))) return puts("-1"), 0;
for (i = 1; i <= n; i++)
if (p[i] == 1)
t1++;
else
t2++;
printf("%d\n", t1);
for (i = 1; i <= n; i++)
if (p[i] == 1) printf("%d ", i);
printf("\n");
printf("%d\n", t2);
for (i = 1; i <= n; i++)
if (p[i] == 2) printf("%d ", i);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> first, second, g[100001];
int used[100001];
int n, m;
void DFS(int v) {
if (used[v] == 1)
first.push_back(v);
else
second.push_back(v);
for (int i = 0; i < g[v].size(); i++) {
int x = g[v][i];
if (used[x] == 0) {
if (used[v] == 1)
used[x] = 2;
else
used[x] = 1;
DFS(x);
} else if (used[x] == used[v]) {
cout << -1;
exit(0);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (used[i] == 0) {
used[i] = 1;
DFS(i);
}
}
cout << first.size() << endl;
for (int i = 0; i < first.size(); i++) cout << first[i] << " ";
cout << endl;
cout << second.size() << endl;
for (int t = 0; t < second.size(); t++) cout << second[t] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[100005];
int num[100005];
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
bool yes = true;
for (int i = 1; i <= n; i++) {
if (num[i] == 0) {
queue<int> q;
q.push(i);
while (!q.empty()) {
int cur = q.front();
q.pop();
if (adj[cur].size() == 0) continue;
if (num[cur] != 0) continue;
bool one = false;
bool two = false;
for (int j = 0; j < adj[cur].size(); j++) {
if (num[adj[cur][j]] == 1) one = true;
if (num[adj[cur][j]] == 2) two = true;
q.push(adj[cur][j]);
}
if (one && two) yes = false;
if (one) num[cur] = 2;
if (two) num[cur] = 1;
if (!one && !two) num[cur] = 1;
}
}
}
vector<int> one;
vector<int> two;
for (int i = 1; i <= n; i++) {
if (num[i] == 1) one.push_back(i);
if (num[i] == 2) two.push_back(i);
}
if (!yes)
cout << -1 << endl;
else {
cout << one.size() << "\n";
if (one.size() >= 1) cout << one[0];
for (int i = 1; i < one.size(); i++) cout << " " << one[i];
cout << "\n";
cout << two.size() << "\n";
if (two.size() >= 1) cout << two[0];
for (int i = 1; i < two.size(); i++) cout << " " << two[i];
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > v(100010);
vector<int> vi(100010, -1);
vector<int> a, b;
void dfs(int c, int p, int t) {
if (vi[c] != -1) {
if (vi[c] != t) {
cout << "-1" << endl;
exit(0);
} else
return;
}
vi[c] = t;
if (t == 1)
a.push_back(c);
else
b.push_back(c);
int i;
for (i = 0; i < v[c].size(); i++) {
if (v[c][i] != p) dfs(v[c][i], c, (t + 1) % 2);
}
}
int main() {
int n, m, i, x, y;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 1; i <= n; i++) {
if (vi[i] == -1) {
dfs(i, -1, 0);
}
}
cout << a.size() << endl;
for (i = 0; i < a.size(); i++) cout << a[i] << " ";
cout << endl;
cout << b.size() << endl;
for (i = 0; i < b.size(); i++) cout << b[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, ok = 0;
vector<int> gf[N], ans[2];
bool vis[N];
int co[N];
void dfs(int i, int j) {
if (ok == 1) {
return;
}
vis[i] = 1;
if (co[i] != -1) {
if (co[i] != (j)) ok = 1;
return;
}
co[i] = j;
ans[j].push_back(i);
for (auto ch : gf[i]) {
dfs(ch, j ^ 1);
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
while (m--) {
int a, b;
cin >> a >> b;
gf[a].push_back(b);
gf[b].push_back(a);
}
memset(co, -1, sizeof(co));
ok = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, 0);
}
}
if (ok == 1) {
cout << "-1" << endl;
} else {
int tmp1 = ans[0].size();
int tmp2 = ans[1].size();
cout << tmp1 << endl;
for (auto i : ans[0]) cout << i << " ";
cout << endl;
cout << tmp2 << endl;
for (auto i : ans[1]) cout << i << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool visited[100000];
bool player[100000];
vector<vector<int> > graph;
bool valid = true;
int vcount = 0;
void visit(int pos) {
if (player[pos]) vcount++;
for (auto s : graph[pos]) {
if (valid && visited[s])
valid = player[s] != player[pos];
else if (valid) {
visited[s] = true;
player[s] = !player[pos];
visit(s);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(12) << fixed;
int N, M;
cin >> N >> M;
graph.resize(N);
for (int i = (0); i < (M); ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
graph[a].push_back(b);
graph[b].push_back(a);
}
fill_n(visited, N, false);
for (int pos = (0); pos < (N); ++pos) {
if (!visited[pos]) {
visited[pos] = true;
player[pos] = true;
visit(pos);
}
}
if (valid) {
cout << vcount << endl;
bool space = false;
for (int i = (0); i < (N); ++i)
if (player[i]) {
if (space) {
cout << " ";
} else {
space = true;
}
cout << i + 1;
}
cout << endl;
cout << N - vcount << endl;
space = false;
for (int i = (0); i < (N); ++i)
if (!player[i]) {
if (space) {
cout << " ";
} else {
space = true;
}
cout << i + 1;
}
cout << endl;
} else {
cout << "-1" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
if (e == 0) return 1;
if (e % 2 == 0) {
T t = bigmod(p, e / 2, M);
return (t * t) % M;
}
return (bigmod(p, e - 1, M) * p) % M;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T multimod(T a, T b, T m) {
T ans = 0ll;
a %= m, b %= m;
while (b) {
if (b & 1ll) ans = m - ans > a ? (ans + a) : (ans + a - m);
b >>= 1ll;
a = (m - a) > a ? a + a : a + a - m;
}
return (T)ans;
}
vector<int> V[(100000 + 7)];
bool vis[(100000 + 7)];
int col[(100000 + 7)];
void DFS(int u, int c) {
assert(c < 3);
if (vis[u]) {
return;
}
col[u] = c;
vis[u] = 1;
int sz = V[u].size();
for (int i = 0; i < sz; i++) DFS(V[u][i], c % 2 + 1);
return;
}
int fst[(100000 + 7)];
int snd[(100000 + 7)];
pair<int, int> take[(100000 + 7)];
int main() {
int i, j, k, K;
int x, n, m, u, v;
cin >> n >> m;
int tmp = -1;
for (i = 0; i < m; i++) {
cin >> u >> v;
take[i] = make_pair(u, v);
V[u].push_back(v);
V[v].push_back(u);
tmp = v;
}
for (i = 1; i <= n; i++)
if (!vis[i]) DFS(i, 1);
int ind = 0, idx = 0;
for (i = 1; i <= n; i++) {
if (col[i] == 1)
fst[idx++] = i;
else if (col[i] == 2)
snd[ind++] = i;
}
for (i = 0; i < m; i++) {
if (col[take[i].first] == col[take[i].second]) {
cout << -1 << endl;
return 0;
}
if (!col[take[i].first] || !col[take[i].second]) {
cout << -1 << endl;
return 0;
}
}
assert(ind || idx);
cout << idx << endl;
for (i = 0; i < idx; i++) cout << fst[i] << " ";
cout << endl;
cout << ind << endl;
for (i = 0; i < ind; i++) cout << snd[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int N = 100005;
set<char> vowel = {'A', 'O', 'Y', 'E', 'U', 'I', 'a', 'o', 'y', 'e', 'u', 'i'};
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
int n, m, k = 0, ans = 0, res = 2, posmin, posmax, x, y, z, xmax = 0, ymax = 0;
string ch, ch1, ch2;
int tab[N];
deque<int> q1, q2, q3, q4;
map<int, set<int> > adj;
map<pair<int, int>, int> mapai;
set<int> sx, sy;
set<char> sc;
map<char, int> mc;
vector<int> v, vv;
bool visit[N], check = true;
void dfs(int i, int w) {
if (visit[i]) return;
visit[i] = 1;
tab[i] = w;
if (w == 1)
v.push_back(i);
else if (w == -1)
vv.push_back(i);
w *= -1;
for (auto t : adj[i]) {
if (tab[i] == tab[t]) {
check = false;
return;
}
dfs(t, w);
}
}
int main() {
ios_base::sync_with_stdio(false);
memset(tab, 0, sizeof(tab));
memset(visit, 0, sizeof(visit));
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
sx.insert(x);
sx.insert(y);
adj[x].insert(y);
adj[y].insert(x);
}
for (auto l : sx) {
if (visit[l] == 0) {
tab[l] = 1;
dfs(l, 1);
}
}
if (check == false)
cout << -1;
else {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] + 1 << " ";
}
cout << "" << endl;
cout << vv.size() << endl;
for (int i = 0; i < vv.size(); i++) {
cout << vv[i] + 1 << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int color[maxn], n, m;
bool mark[maxn];
vector<int> v[maxn], rang[4];
void dfs(int root, int col) {
mark[root] = true;
color[root] = col;
rang[col].push_back(root);
for (int i = 0; i < (int)v[root].size(); i++) {
if (mark[v[root][i]]) {
if (color[v[root][i]] == col) {
cout << "-1\n";
exit(0);
}
} else
dfs(v[root][i], 3 - col);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; 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 (!mark[i]) {
dfs(i, 2);
}
cout << (int)rang[1].size() << endl;
for (int i = 0; i < (int)rang[1].size(); i++) cout << rang[1][i] << ' ';
cout << endl;
cout << (int)rang[2].size() << endl;
for (int i = 0; i < (int)rang[2].size(); i++) cout << rang[2][i] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool col[100005];
bool vis[100005];
vector<long long> edges[100005];
bool possible = 1;
void dfs(long long v, bool c) {
if (!vis[v]) {
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;
}
}
}
}
}
int main() {
long long n, m;
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";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> v[maxn];
int b[maxn];
bool dfs(int node, int c) {
b[node] = c;
int size = v[node].size();
for (int i = 0; i < size; ++i) {
int u = v[node][i];
if (b[u] == -1) {
if (dfs(u, c ^ 1) == 0) {
return false;
}
} else if (b[u] == c) {
return false;
}
}
return true;
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
memset(b, -1, sizeof(b));
int flag = 1;
for (int i = 1; i <= n; ++i) {
if (b[i] == -1) {
if (dfs(i, 0) == 0) {
flag = 0;
break;
}
}
}
if (flag) {
int sum = 0;
for (int i = 1; i <= n; ++i) {
sum += b[i];
}
cout << sum << endl;
for (int i = 1; i <= n; ++i) {
if (b[i]) {
cout << i << " ";
}
}
cout << endl;
cout << n - sum << endl;
for (int i = 1; i <= n; ++i) {
if (b[i] == 0) {
cout << i << " ";
}
}
cout << endl;
} else {
cout << "-1\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v1, v2, adj[100100];
int col[100100], n, m;
bool f, mark[100100];
void dfs(int x) {
mark[x] = true;
for (int i = 0; i < adj[x].size(); i++) {
int v = adj[x][i];
if (!mark[v]) {
col[v] = 1 - col[x];
if (col[v]) v2.push_back(v);
if (!col[v]) v1.push_back(v);
dfs(v);
} else if (col[v] == col[x])
f = false;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
f = true;
for (int i = 1; i <= n; i++)
if (!mark[i] && adj[i].size()) v1.push_back(i), dfs(i);
if (!f)
cout << -1;
else {
cout << v1.size() << endl;
sort(v1.begin(), v1.end());
for (int i = 0; i < v1.size(); i++) cout << v1[i] << " ";
cout << endl << v2.size() << endl;
sort(v2.begin(), v2.end());
for (int i = 0; i < v2.size(); i++) cout << v2[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> adj(1e5 + 1);
vector<int> vis(1e5 + 1), t(1e5 + 1);
vector<set<int>> g(2);
int dfs(int curr, int type = 0) {
if (vis[curr]) {
return type == t[curr];
}
vis[curr] = 1;
t[curr] = type;
g[type].insert(curr);
for (int next : adj[curr]) {
if (!dfs(next, !type)) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
int ret = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
ret = ret && dfs(i);
}
}
if (!ret) {
cout << -1;
return 0;
}
for (auto& a : g) {
cout << a.size() << '\n';
for (int i : a) cout << i << ' ';
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a, b;
vector<int> g[1000006];
bool cycle = false;
map<int, bool> visited, used;
int col[10000006];
void dfs(int u) {
visited[u] = true;
for (int i = 0, v; v = g[u][i]; i++) {
if (!visited[v]) {
col[v] = 3 - col[u];
dfs(v);
} else {
if (col[v] == col[u]) cycle = true;
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a >> b;
used[a] = used[b] = true;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; i++) g[i].push_back(0);
for (int i = 1; i <= n; i++)
if (!visited[i]) {
col[i] = 1;
dfs(i);
}
if (cycle == 1)
cout << -1;
else {
int ct = 0;
for (int i = 1; i <= n; i++)
if (visited[i] && used[i] && col[i] == 1) ct++;
cout << ct << '\n';
for (int i = 1; i <= n; i++)
if (visited[i] && used[i] && col[i] == 1) cout << i << ' ';
ct = 0;
for (int i = 1; i <= n; i++)
if (visited[i] && used[i] && col[i] == 2) ct++;
cout << '\n' << ct << '\n';
for (int i = 1; i <= n; i++)
if (visited[i] && used[i] && col[i] == 2) cout << i << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a[100005];
bool visited[100005];
int color[100005];
bool dfs(int second, int c) {
visited[second] = true;
color[second] = c;
for (auto x : a[second]) {
if (visited[x] == false) {
if (dfs(x, (-1 * c)) == false) return false;
} else {
if (color[x] == (c)) return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (visited[i] == false && (a[i].size() > 0)) {
if (dfs(i, 1) == false) return cout << -1, 0;
}
}
int aa = 0, bb = 0;
for (int i = 1; i < n + 1; i++) {
if (color[i] == 1)
aa++;
else if (color[i] == -1)
bb++;
}
cout << aa << endl;
for (int i = 1; i < n + 1; i++)
if (color[i] == 1) cout << i << " ";
cout << endl;
cout << bb << endl;
for (int i = 1; i < n + 1; i++)
if (color[i] == -1) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(long long x, long long y) { return x > y; }
int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int main() {
int v, e;
scanf("%d %d", &v, &e);
vector<vector<int> > adj(v);
for (int i = 0; i < e; i++) {
int from, to;
scanf("%d %d", &from, &to);
from--;
to--;
adj[from].push_back(to);
adj[to].push_back(from);
}
bool isBipartite = true;
vector<int> color(v, 2000000000);
int start = -1;
for (int i = 0; i < v; i++) {
if (color[i] == 2000000000) {
start = i;
queue<int> q;
q.push(start);
color[start] = 0;
while (!q.empty() && isBipartite) {
int u = q.front();
q.pop();
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (color[v] == 2000000000) {
color[v] = 1 - color[u];
q.push(v);
} else if (color[v] == color[u]) {
isBipartite = false;
break;
}
}
}
}
}
if (isBipartite) {
int zeros = 0, ones = 0;
for (int i = 0; i < v; i++) {
if (color[i] == 0)
zeros++;
else if (color[i] == 1)
ones++;
}
printf("%d\n", zeros);
for (int i = 0; i < v; i++)
if (color[i] == 0) printf("%d ", i + 1);
printf("\n");
printf("%d\n", ones);
for (int i = 0; i < v; i++)
if (color[i] == 1) printf("%d ", i + 1);
printf("\n");
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> v[maxn];
int book[maxn];
vector<int> v1, v2;
int flag = 1;
void dfs(int x, int fa) {
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (y == fa) continue;
if (book[x] == 1) {
if (book[y] == 1) {
flag = 0;
return;
}
if (book[y] == 0) {
book[y] = 2;
dfs(y, x);
}
}
if (book[x] == 2) {
if (book[y] == 2) {
flag = 0;
return;
}
if (book[y] == 0) {
book[y] = 1;
dfs(y, x);
}
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (book[i] == 0 && v[i].size()) {
book[i] = 1;
dfs(i, 0);
}
}
if (flag) {
for (int i = 1; i <= n; i++) {
if (book[i] == 1) v1.push_back(i);
if (book[i] == 2) v2.push_back(i);
}
printf("%d\n", v1.size());
for (auto i : v1) printf("%d ", i);
printf("\n");
printf("%d\n", v2.size());
for (auto i : v2) printf("%d ", i);
} else
printf("-1");
}
|
#include <bits/stdc++.h>
int n, m, t[100005];
std::vector<int> e[100005], ans;
bool v[100005];
void dfs(int x, int y) {
v[x] = true;
t[x] = t[y] ^ 3;
for (int i = 0; i < e[x].size(); i++)
if (!v[e[x][i]]) dfs(e[x][i], x);
}
bool impossible() {
for (int i = 1; i <= n; i++)
for (int j = 0; j < e[i].size(); j++)
if (t[i] == t[e[i][j]]) return true;
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
t[0] = 1;
v[0] = true;
for (int i = 1; i <= n; i++)
if (!v[i]) dfs(i, 0);
if (impossible())
printf("-1\n");
else {
ans.clear();
for (int i = 1; i <= n; i++)
if (t[i] == 1) ans.push_back(i);
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d%c", ans[i], i == ans.size() - 1 ? '\n' : ' ');
ans.clear();
for (int i = 1; i <= n; i++)
if (t[i] == 2) ans.push_back(i);
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d%c", ans[i], i == ans.size() - 1 ? '\n' : ' ');
}
scanf("\n");
return 0;
}
|
#include <bits/stdc++.h>
const int MAX = 1e5 + 5;
using namespace std;
vector<int> mp[MAX], ans1, ans2;
int d[MAX], n, m;
int dfs(int x) {
if (d[x] == 0) d[x] = 1;
if (d[x] == 1) ans1.push_back(x);
if (d[x] == -1) ans2.push_back(x);
for (int i = 0; i < mp[x].size(); i++) {
if (d[x] == d[mp[x][i]]) return 0;
if (d[mp[x][i]] == 0) {
d[mp[x][i]] = -1 * d[x];
if (!dfs(mp[x][i])) return 0;
}
}
return 1;
}
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++) {
scanf("%d%d", &a, &b);
mp[a].push_back(b);
mp[b].push_back(a);
}
int flag = 1;
memset(d, 0, sizeof(d));
for (int i = 1; i <= n; i++) {
if (d[i] == 0) {
if (!dfs(i)) {
flag = 0;
break;
}
}
}
if (!flag)
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;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
vector<vector<long long>> g1(200005, vector<long long>());
vector<long long> ans(200005, -1);
void dfs(long long n, long long color) {
ans[n] = color;
for (auto x1 : g1[n]) {
if (ans[x1] == -1)
dfs(x1, color ^ 1);
else if (ans[n] == ans[x1]) {
cout << -1 << endl;
exit(0);
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, m, i;
cin >> n >> m;
ans = vector<long long>(n + 1, -1);
for (i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
g1[a].push_back(b);
g1[b].push_back(a);
}
for (i = 1; i < n + 1; i++) {
if (ans[i] == -1) {
dfs(i, 0);
}
}
long long zero = count(ans.begin(), ans.end(), 0);
long long one = count(ans.begin(), ans.end(), 1);
cout << one << endl;
for (i = 1; i < n + 1; i++) {
if (ans[i] == 1) cout << i << " ";
}
cout << endl;
cout << zero << endl;
for (i = 1; i < n + 1; i++) {
if (ans[i] == 0) cout << i << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
bool visited[1000000];
long long temp[1000000];
vector<long long> g[1000000];
bool galat;
void dfs(long long x, long long p) {
visited[x] = true;
temp[x] = p;
for (long long i = 0; i < g[x].size(); i++) {
if (temp[g[x][i]] == p) {
galat = true;
return;
}
if (!visited[g[x][i]]) {
if (galat == true) {
return;
}
dfs(g[x][i], 1 - p);
}
}
}
long long ca, cb;
vector<long long> a, b;
int main() {
long long n, m, i, x, y;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (i = 1; i <= n; i++) {
temp[i] = -1;
}
galat = false;
for (i = 1; i <= n; i++) {
if (!visited[i]) {
dfs(i, 0);
}
}
if (galat) {
cout << "-1";
return 0;
}
ca = 0LL;
for (i = 1; i <= n; i++) {
if (temp[i]) {
a.push_back(i);
ca++;
}
}
cb = 0LL;
for (i = 1; i <= n; i++) {
if (!temp[i]) {
b.push_back(i);
cb++;
}
}
cout << ca << "\n";
for (i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
cout << "\n" << cb << "\n";
for (i = 0; i < b.size(); i++) {
cout << b[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int visited[100002], parent[100002], color[100002];
vector<int> graph[100002];
int type1 = 0, type2 = 0;
long long exp(long long a, long long b, long long m) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % m;
a = (a * a) % m;
b >>= 1;
}
return ans;
}
long long nc2(long long a) { return (a * (a - 1)) / 2; }
bool dfs(int u) {
visited[u] = 1;
color[u] = color[parent[u]] ^ 1;
if (color[u])
type1++;
else
type2++;
for (auto v : graph[u]) {
if (!visited[v]) {
parent[v] = u;
if (!dfs(v)) return false;
} else {
if (color[v] == color[u]) {
return false;
}
}
}
return true;
}
bool dfs_alt(int u, int col) {
if (color[u] != 0) {
if (color[u] == col)
return true;
else
return false;
}
color[u] = col;
if (color[u] == 1)
type1++;
else
type2++;
visited[u] = 1;
for (auto v : graph[u]) {
if (!dfs_alt(v, -col)) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
memset(parent, 0, sizeof(parent));
memset(visited, 0, sizeof(visited));
memset(color, -1, sizeof(color));
color[0] = 0;
bool flag = true;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
if (!dfs(i)) {
flag = false;
break;
}
}
}
if (!flag) {
cout << -1;
return 0;
} else if (type1 == 0 || type2 == 0) {
cout << -1;
return 0;
} else {
cout << type1 << endl;
for (int i = 1; i <= n; i++) {
if (color[i] == 1) cout << i << " ";
}
cout << endl;
;
cout << type2 << endl;
for (int i = 1; i <= n; i++) {
if (color[i] == 0) cout << i << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int> > edge(100010);
long long int vis[100010];
vector<long long int> color[2];
bool dfs(long long int a, long long int c = 2) {
vis[a] = c;
color[c - 1].push_back(a);
for (auto x : edge[a]) {
if (!vis[x] && dfs(x, 3ll - c)) {
return 1;
}
if (vis[x] != 3ll - c) {
return 1;
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, x, y;
cin >> n >> m;
for (long long int i = 1; i <= m; i++) {
cin >> x >> y;
edge[x].push_back(y);
edge[y].push_back(x);
}
for (long long int i = 1; i <= n; i++) {
if (!vis[i]) {
if (edge[i].size() == 0) {
continue;
}
if (dfs(i)) {
cout << -1 << endl;
return 0;
}
}
}
for (long long int i = 0; i < 2; i++) {
cout << color[i].size() << endl;
for (auto x : color[i]) {
cout << x << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> vis, ans;
vector<vector<int>> adj;
void dfs(int u) {
for (auto v : adj[u])
if (vis[v] == -1) vis[v] = !vis[u], dfs(v);
}
int main() {
int n, m, a, b;
cin >> n >> m;
vis.assign(n, -1);
adj.assign(n, vector<int>());
while (m--) {
cin >> a >> b, a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 0; i < n; i++)
if (vis[i] == -1) vis[i] = 0, dfs(i);
for (int i = 0; i < n; i++)
for (auto v : adj[i])
if (vis[i] == vis[v]) {
cout << -1;
return 0;
}
for (int i = 0; i < n; i++)
if (vis[i]) ans.push_back(i);
cout << ans.size() << '\n';
for (auto x : ans) cout << x + 1 << ' ';
cout << '\n' << n - ans.size() << '\n';
for (int i = 0; i < n; i++)
if (!vis[i]) cout << i + 1 << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
int ans;
const int MAXN = 100005;
vector<int> Map[MAXN], ansM[5];
int d[MAXN];
int n, m;
void dfs(int u) {
for (auto v : Map[u]) {
if (d[v] == -1) {
d[v] = d[u] ^ 1;
dfs(v);
} else if (d[v] != d[u] ^ 1) {
ans = -1;
return;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
Map[x].push_back(y);
Map[y].push_back(x);
}
for (int i = 1; i <= n; i++) d[i] = -1;
for (int i = 1; i <= n; i++)
if (Map[i].size() > 0 && d[i] == -1) {
d[i] = 0;
dfs(i);
if (ans < 0) {
cout << -1 << endl;
return 0;
}
}
for (int i = 1; i <= n; i++) {
if (d[i] == 0)
ansM[0].push_back(i);
else if (d[i] == 1)
ansM[1].push_back(i);
}
cout << ansM[0].size() << endl;
cout << ansM[0][0];
for (int i = 1; i < ansM[0].size(); i++) cout << ' ' << ansM[0][i];
cout << endl;
cout << ansM[1].size() << endl;
cout << ansM[1][0];
for (int i = 1; i < ansM[1].size(); i++) cout << ' ' << ansM[1][i];
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, c;
vector<int> adj[100001];
const int N = 1000000;
vector<int> v1, v2;
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
vector<int> d(n + 1, -1);
for (int i = 1; i <= n; ++i) {
if (d[i] == -1 && adj[i].size() > 0) {
queue<int> q;
q.push(i);
d[i] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
if (!d[v])
v1.push_back(v);
else
v2.push_back(v);
for (int j = 0; j < adj[v].size(); ++j) {
if (d[adj[v][j]] == -1) {
d[adj[v][j]] = !d[v];
q.push(adj[v][j]);
} else if (d[adj[v][j]] == 1) {
if (d[v] == 1) {
cout << -1;
return 0;
}
} else {
if (d[v] == 0) {
cout << -1;
return 0;
}
}
}
}
}
}
cout << v1.size() << "\n";
for (int i = 0; i < v1.size(); ++i) cout << v1[i] << " ";
cout << "\n" << v2.size() << "\n";
for (int i = 0; i < v2.size(); ++i) cout << v2[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, a, b;
vector<int> g[N];
set<int> s[2];
bool vis[N];
void dfs(int x, bool b) {
s[b].insert(x);
for (int v : g[x]) {
if (vis[v]) continue;
vis[v] = true;
dfs(v, !b);
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; i++) {
if (!vis[i]) dfs(i, 1);
}
for (int i = 0; i < n; i++) {
for (int v : g[i]) {
for (int j = 0; j < 2; j++) {
if (s[j].count(i) && s[j].count(v)) {
cout << -1;
return 0;
}
}
}
}
for (int i = 0; i < 2; i++) {
cout << s[i].size() << '\n';
for (auto v : s[i]) cout << v + 1 << ' ';
cout << '\n';
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.