text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
using ii = pair<int, int>;
using ll = long long;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
void kill() {
cout << "No solution\n";
exit(0);
}
int n, m;
set<int> adj[N];
int dfs(int u) {
vector<int> out;
while (adj[u].size()) {
int v = *adj[u].begin();
adj[v].erase(u);
adj[u].erase(v);
int w = dfs(v);
if (~w) {
cout << u << ' ' << v << ' ' << w << '\n';
} else {
out.push_back(v);
}
}
for (int i = out.size() & 1; i < out.size(); i += 2) {
cout << out[i] << ' ' << u << ' ' << out[i + 1] << '\n';
}
if (out.size() & 1) return out[0];
return -1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
if (m & 1) {
kill();
}
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
adj[u].insert(v);
adj[v].insert(u);
}
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <typename T>
void DBG(const char* name, T&& H) {
cerr << name << " = " << H << ')' << '\n';
}
template <typename T, typename... Args>
void DBG(const char* names, T&& H, Args&&... args) {
const char* NEXT = strchr(names + 1, ',');
cerr.write(names, NEXT - names) << " = " << H << " |";
DBG(NEXT + 1, args...);
}
using ll = long long;
using ld = long double;
const long long mod = 1e9 + 7;
const long double PI = acos(-1.0);
const long long INF = 1e18;
const int maxN = 1e5 + 1;
int N, M;
vector<vector<pair<int, int>>> graph(maxN);
vector<bool> blocked(maxN, false);
void bad() {
cout << "No solution\n";
exit(0);
}
int dfs(int node) {
vector<int> freeedge, toVis;
for (auto i : graph[node]) {
if (blocked[i.second]) continue;
toVis.push_back(i.first);
blocked[i.second] = 1;
}
for (auto i : toVis) {
int end = dfs(i);
if (end != -1) {
cout << node << " " << i << " " << end << '\n';
} else
freeedge.push_back(i);
}
while (freeedge.size() >= 2) {
cout << freeedge.back() << " " << node << " "
<< freeedge[freeedge.size() - 2] << '\n';
freeedge.pop_back();
freeedge.pop_back();
}
if (freeedge.size())
return freeedge.back();
else
return -1;
}
void Solve() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
graph[a].push_back({b, i});
graph[b].push_back({a, i});
}
if (M % 2) bad();
dfs(1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt = 1;
while (tt--) {
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100005], b[100005], te[100005], dir[100005];
int summ[100005];
bool vis[100005];
vector<pair<int, int> > V[100005];
vector<int> res[100005];
void dfs(int id, int pv) {
vis[id] = 1;
for (int i = (0); i <= ((int)V[id].size() - 1); i++) {
pair<int, int> to = V[id][i];
if (to.first == pv || vis[to.first]) continue;
te[to.second] = 1;
dfs(to.first, id);
}
return;
}
void dfs2(int id, int pv, int fe) {
for (int i = (0); i <= ((int)V[id].size() - 1); i++) {
pair<int, int> to = V[id][i];
if (to.first == pv || !te[to.second]) continue;
dfs2(to.first, id, to.second);
}
if (summ[id] & 1) {
dir[fe] = id;
summ[id]++;
} else if (fe != -1) {
dir[fe] = a[fe] + b[fe] - id;
summ[dir[fe]]++;
}
return;
}
int main() {
scanf("%d %d", &n, &m);
if (m & 1) {
printf("No solution\n");
return 0;
}
for (int i = (1); i <= (m); i++) {
scanf("%d %d", &a[i], &b[i]);
V[a[i]].push_back(make_pair(b[i], i));
V[b[i]].push_back(make_pair(a[i], i));
}
dfs(1, -1);
for (int i = (1); i <= (m); i++)
if (!te[i]) summ[a[i]]++, dir[i] = a[i];
dfs2(1, -1, -1);
for (int i = (1); i <= (m); i++) res[dir[i]].push_back(a[i] + b[i] - dir[i]);
for (int i = (1); i <= (n); i++) {
for (int j = 0; j < res[i].size(); j += 2)
printf("%d %d %d\n", res[i][j], i, res[i][j + 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const int N = (int)1e5 + 5;
const int INF = 0x3f3f3f3f;
vector<int> g[N];
vector<int> bad[N];
vector<vector<int>> ans;
bool used[N];
int h[N];
int dfs(int v) {
if (used[v]) {
return bad[v][0];
}
used[v] = true;
for (int to : g[v]) {
if (used[to] && h[to] < h[v]) {
continue;
}
if (!used[to]) {
h[to] = h[v] + 1;
}
int q = dfs(to);
if (q == -1) {
bad[v].push_back(to);
} else {
ans.push_back({v, to, q});
bad[to].clear();
bad[to].push_back(-1);
}
}
while (bad[v].size() >= 2) {
int to = bad[v].back();
bad[v].pop_back();
int q = bad[v].back();
bad[v].pop_back();
ans.push_back({to, v, q});
}
if (bad[v].empty()) {
bad[v].push_back(-1);
}
return bad[v][0];
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
if (ans.size() != m / 2 || m % 2) {
return cout << "No solution", 0;
}
for (auto vec : ans) {
for (int to : vec) {
printf("%d ", to);
}
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 100000000;
set<int> adj[100005];
int n, m;
int dfs(int node) {
vector<int> lef;
while (adj[node].size()) {
int mm = *(adj[node].begin());
adj[mm].erase(node);
adj[node].erase(mm);
int t = dfs(mm);
if (t != -1) {
printf("%d %d %d\n", node, mm, t);
} else
lef.push_back(mm);
}
for (int i = (lef.size() % 2); i < lef.size(); i += 2) {
printf("%d %d %d\n", lef[i], node, lef[i + 1]);
}
if (lef.size() % 2)
return lef[0];
else
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
adj[a].insert(b);
adj[b].insert(a);
}
if (m % 2 == 1)
puts("No solution");
else
dfs(1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 100000 + 5;
int N, M, S;
set<int> V[NMAX];
bool Viz[NMAX];
void DFS(int nod, int tata) {
set<int>::iterator it;
set<int> W = V[nod];
Viz[nod] = 1;
for (it = W.begin(); it != W.end(); it++) {
if (Viz[*it]) continue;
DFS(*it, nod);
}
if (V[nod].size() % 2) V[nod].erase(tata);
for (it = V[nod].begin(); it != V[nod].end(); it++) {
printf("%d %d ", *it, nod);
V[*it].erase(nod);
it++;
printf("%d\n", *it);
V[*it].erase(nod);
}
}
int main() {
int x, y;
scanf("%d%d", &N, &M);
if (M % 2) {
printf("No solution\n");
return 0;
}
for (; M; --M) {
scanf("%d%d", &x, &y);
V[x].insert(y);
V[y].insert(x);
}
DFS(1, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100020;
bool ok[maxn];
int h[maxn];
bool mark[maxn];
vector<int> adj[maxn];
void dfs(int v, int par) {
mark[v] = 1;
vector<int> can;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (mark[u] != 1) {
h[u] = h[v] + 1;
dfs(u, v);
if (ok[u] != true) {
can.push_back(u);
}
} else if (u != par && h[u] < h[v]) {
can.push_back(u);
}
}
if (can.size() % 2 != 0) {
can.push_back(par);
ok[v] = true;
}
for (int i = 0; i < can.size() / 2; i++) {
cout << can[2 * i] << " " << v << " " << can[2 * i + 1];
cout << endl;
}
}
int main() {
int n, m;
cin >> n >> m;
if (m % 2 != 0) {
cout << "No solution";
return 0;
}
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1, -1);
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, nx;
} e[200050];
int head[200050];
int num = 0;
bool bo[200050];
void addedge(int x, int y) {
e[num].to = y;
e[num].nx = head[x];
head[x] = num++;
}
bool ok[200050];
int gao(int now) {
ok[now] = true;
queue<int> q;
for (int p = head[now]; p != -1; p = e[p].nx) {
if (!bo[p]) {
q.push(e[p].to);
bo[p] = bo[p ^ 1] = true;
}
}
queue<int> p;
while (!q.empty()) {
int u = q.front();
q.pop();
int w = gao(u);
if (w != 0)
printf("%d %d %d\n", w, u, now);
else
p.push(u);
}
while (p.size() >= 2) {
int u, v;
u = p.front();
p.pop();
v = p.front();
p.pop();
printf("%d %d %d\n", u, now, v);
}
if (!p.empty())
return p.front();
else
return 0;
}
int main() {
int i, j, k, n, m;
num = 0;
memset(head, -1, sizeof(head));
memset(ok, 0, sizeof(ok));
memset(bo, 0, sizeof(bo));
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
addedge(x, y);
addedge(y, x);
}
if (m % 2)
printf("No solution\n");
else {
for (i = 1; i <= n; i++)
if (!ok[i]) gao(i);
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline void setmin(int &x, int y) {
if (y < x) x = y;
}
inline void setmax(int &x, int y) {
if (y > x) x = y;
}
inline void setmin(long long &x, long long y) {
if (y < x) x = y;
}
inline void setmax(long long &x, long long y) {
if (y > x) x = y;
}
const int N = 100000;
const int inf = (int)1e9 + 1;
const long long big = (long long)1e18 + 1;
const int P = 239;
const int MOD = (int)1e9 + 7;
const int MOD1 = (int)1e9 + 9;
const double eps = 1e-9;
const double pi = atan2(0, -1);
const int ABC = 26;
vector<int> g[N];
bool used[N];
int height[N];
bool dfs(int u, int p, int h) {
used[u] = true;
height[u] = h;
vector<int> todo;
for (int v : g[u])
if (v != p) {
if (!used[v]) {
if (dfs(v, u, h + 1)) todo.push_back(v);
} else if (height[v] < height[u])
todo.push_back(v);
}
bool res = true;
if ((int)todo.size() % 2 == 1) {
todo.push_back(p);
res = false;
}
for (int i = 0; i < (int)todo.size() / 2; i++)
cout << todo[i * 2] + 1 << " " << u + 1 << " " << todo[i * 2 + 1] + 1
<< "\n";
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
cout << fixed;
int n, m;
cin >> n >> m;
if (m % 2 == 1) {
cout << "No solution\n";
return 0;
}
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);
}
dfs(0, -1, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
vector<pair<int, int>> mp[100005];
vector<pair<int, pair<int, int>>> ans;
bool vis[100005 * 2];
int cnt;
int dfs(int x, int pa) {
vector<int> v;
for (auto p : mp[x]) {
int c = p.first, id = p.second;
if (vis[id] || c == pa) continue;
vis[id] = 1;
vis[id ^ 1] = 1;
int rm = dfs(c, x);
if (rm != -1) {
ans.push_back({c, {x, rm}});
} else {
v.push_back(c);
}
}
while (v.size() > 1) {
int a = v.back();
v.pop_back();
int b = v.back();
v.pop_back();
ans.push_back({x, {a, b}});
}
if (v.empty()) return -1;
return v[0];
}
int main() {
scanf("%d%d", &n, &m);
int u, v;
if (m & 1) {
puts("No solution");
return 0;
}
for (int(i) = 0; (i) < (int)(m); (i)++) {
scanf("%d%d", &u, &v);
mp[u].push_back({v, cnt++});
mp[v].push_back({u, cnt++});
}
dfs(1, 0);
for (auto p : ans)
printf("%d %d %d\n", p.second.first, p.first, p.second.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool endline = false;
template <class T>
istream& operator>>(istream& inp, vector<T>& v) {
for (auto& it : v) inp >> it;
return inp;
}
template <class T>
ostream& operator<<(ostream& out, vector<T>& v) {
for (auto& it : v) out << it << (endline ? "\n" : " ");
return out;
}
template <class T, class U>
istream& operator>>(istream& inp, pair<T, U>& v) {
inp >> v.first >> v.second;
return inp;
}
template <class T, class U>
ostream& operator<<(ostream& out, pair<T, U>& v) {
out << v.first << ' ' << v.second;
return out;
}
void debug() { cout << endl; }
template <typename H, typename... T>
void debug(H a, T... b) {
cout << a << ' ';
debug(b...);
}
void FAST_IO(string filein = "", string fileout = "", string fileerr = "") {
if (fopen(filein.c_str(), "r")) {
freopen(filein.c_str(), "r", stdin);
freopen(fileout.c_str(), "w", stdout);
}
cin.tie(0), cout.tie(0)->sync_with_stdio(0);
}
void Hollwo_Pelw();
signed main() {
FAST_IO(".inp", ".out");
int testcases = 1;
for (int test = 1; test <= testcases; test++) {
Hollwo_Pelw();
}
return 0;
}
const int allmod[3] = {(int)1e9 + 7, 998244353, (int)1e9 + 9};
const int mod = allmod[0];
const int MAXN = 1e5 + 5;
const int inf = 2e9;
const long long linf = 1e18;
const long double eps = 1e-9;
int n, m, vis[MAXN], evis[MAXN];
vector<pair<int, int>> adj[MAXN];
int dfs(int u) {
vis[u] = 1;
int last = -1;
for (auto vi : adj[u]) {
int v = vi.first, id = vi.second;
if (evis[id]) continue;
evis[id] = 1;
int w = (vis[v] == 1 ? -1 : dfs(v));
if (w == -1) {
if (last != -1) cout << v << " " << u << " " << last << "\n";
last = (last == -1 ? v : -1);
} else {
cout << u << ' ' << v << ' ' << w << "\n";
}
}
return last;
}
void Hollwo_Pelw() {
cin >> n >> m;
if (m & 1) {
cout << "No solution";
return;
}
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v, adj[u].emplace_back(v, i), adj[v].emplace_back(u, i);
}
dfs(1);
}
|
#include <bits/stdc++.h>
using namespace std;
long n, m, a, b;
vector<long> g[200000];
set<pair<long, long> > done;
vector<pair<long, pair<long, long> > > ans;
long ptr[300000];
long dfs(long v) {
vector<long> dd;
dd.reserve(16);
for (; ptr[v] < g[v].size(); ptr[v]++) {
long q = g[v][ptr[v]];
pair<long, long> p = make_pair(min(v, q), max(v, q));
if (done.find(p) != done.end()) continue;
if (p.first > p.second) swap(p.first, p.second);
done.insert(p);
long t = dfs(q);
if (t == 0)
dd.push_back(q);
else {
ans.push_back(make_pair(v, make_pair(q, t)));
}
}
long t = dd.size() % 2;
for (int i = t; i < dd.size(); i += 2) {
long a, b;
a = dd[i];
b = dd[i + 1];
ans.push_back(make_pair(a, make_pair(v, b)));
done.insert(make_pair(min(a, v), max(a, v)));
done.insert(make_pair(min(b, v), max(b, v)));
}
if (dd.size() % 2 == 0) return 0;
done.insert(make_pair(min(dd[0], v), max(dd[0], v)));
return dd[0];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
if (m % 2) {
cout << "No solution" << endl;
return 0;
}
for (int i = 1; i <= m; i++) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(1);
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second.first << " "
<< ans[i].second.second << endl;
}
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000 + 20;
vector<int> adj[MAX_N];
int mark[MAX_N];
int lvl[MAX_N];
vector<pair<int, pair<int, int> > > ans;
int n, m;
void readInput() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
--v, u--;
adj[v].push_back(u);
adj[u].push_back(v);
}
for (int i = 0; i < n; ++i) lvl[i] = MAX_N;
}
int dfs(int v) {
if (mark[v]) return -1;
mark[v] = 1;
vector<int> seq;
for (int i = 0; i < adj[v].size(); ++i) {
int u = adj[v][i];
if (lvl[u] < lvl[v]) continue;
lvl[u] = (lvl[u] == MAX_N ? lvl[v] + 1 : lvl[u]);
int ver = dfs(u);
if (ver != -1)
ans.push_back(make_pair(v, make_pair(u, ver)));
else
seq.push_back(u);
}
while (seq.size() > 1) {
int u = seq.back();
seq.pop_back();
int ver = seq.back();
seq.pop_back();
ans.push_back(make_pair(u, make_pair(v, ver)));
}
return (seq.size() == 1 ? seq.back() : -1);
}
int main() {
readInput();
if (m % 2) {
cout << "No solution" << endl;
return 0;
}
lvl[0] = 0;
dfs(0);
for (int i = 0; i < ans.size(); ++i)
cout << ans[i].first + 1 << ' ' << ans[i].second.first + 1 << ' '
<< ans[i].second.second + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int pw(long long int a, long long int b, long long int mod) {
if (!b) return 1;
if (b & 1) return a * pw(a * a % mod, b / 2, mod) % mod;
return pw(a * a % mod, b / 2, mod) % mod;
}
const long long int MAXN = 2e5 + 10;
const long long int INF = 8e18;
const long long int MOD = 1e9 + 7;
int n, m, mark[MAXN], last[MAXN];
vector<int> adj[MAXN];
vector<pair<int, pair<int, int>>> ans;
void DFS(int u, int p = -1) {
mark[u] = 1;
vector<int> now;
for (int v : adj[u]) {
if (mark[v] == 2 || v == p) continue;
if (mark[v] == 1) {
now.push_back(v);
continue;
}
DFS(v, u);
if (last[v])
ans.push_back({last[v], {v, u}});
else
now.push_back(v);
}
for (int i = 0; i + 1 < now.size(); i += 2) {
ans.push_back({now[i], {u, now[i + 1]}});
}
if (now.size() % 2 == 1) last[u] = now[now.size() - 1];
mark[u] = 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m;
if (m % 2 == 1) return cout << "No solution" << '\n', 0;
;
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] == 0) {
DFS(i);
}
if (ans.size() != m / 2) return cout << "No solution" << '\n', 0;
;
for (auto p : ans) {
cout << p.first << ' ' << p.second.first << ' ' << p.second.second << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, u, v, flag, num, vis[100100];
vector<int> edge[100100];
queue<int> sk[100100];
struct G {
int a, b, c;
} ans[100100];
void dfs(int u, int father) {
vis[u] = true;
for (int i = 0; i < edge[u].size(); ++i) {
int v = edge[u][i];
if (vis[v] == false)
dfs(v, u);
else if (v != father && vis[v] == true)
sk[v].push(u);
}
while (sk[u].size() >= 2) {
int x = sk[u].front();
sk[u].pop();
int y = sk[u].front();
sk[u].pop();
ans[++num] = {x, u, y};
}
if (sk[u].size() == 1) {
if (father == 0) flag = 1;
int x = sk[u].front();
sk[u].pop();
ans[++num] = {x, u, father};
} else
sk[father].push(u);
}
int main() {
cin >> n >> m;
if (m % 2 == 1) {
cout << "No solution" << endl;
return 0;
}
for (int i = 1; i <= m; ++i) {
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
dfs(1, 0);
if (flag == 1)
cout << "No solution" << endl;
else {
for (int i = 1; i <= num; ++i) {
cout << ans[i].a << " " << ans[i].b << " " << ans[i].c << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
double pi = acos(-1);
using namespace std;
vector<int> g[100010];
bool visited[100010];
map<pair<int, int>, int> blocked;
int get(int u) {
if (visited[u]) return -1;
visited[u] = true;
stack<int> unpaired;
vector<int> vs;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!blocked.count(pair<int, int>(u, v)) &&
!blocked.count(pair<int, int>(v, u))) {
vs.push_back(v);
blocked[pair<int, int>(u, v)];
blocked[pair<int, int>(v, u)];
}
}
if (!vs.size()) return -1;
for (int i = 0; i < vs.size(); i++) {
int v = vs[i];
int res = get(v);
if (res != -1) {
printf("%d %d %d\n", u + 1, v + 1, res + 1);
} else {
unpaired.push(v);
}
}
while (unpaired.size()) {
if (unpaired.size() == 1) return unpaired.top();
printf("%d ", unpaired.top() + 1);
unpaired.pop();
printf("%d ", u + 1);
printf("%d\n", unpaired.top() + 1);
unpaired.pop();
}
return -1;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
if (m % 2 == 1) {
cout << "No solution" << endl;
return 0;
}
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
get(0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 20;
int h[maxn], e;
vector<pair<int, int> > adj[maxn];
vector<pair<pair<int, int>, pair<int, int> > > ans;
bool visited[maxn], evisited[maxn];
void dfs(int v) {
e += adj[v].size();
visited[v] = 1;
for (auto u : adj[v])
if (!visited[u.first]) h[u.first] = h[v] + 1, dfs(u.first);
vector<pair<int, int> > backedge, down, p;
for (auto u : adj[v]) {
if (evisited[u.second]) continue;
if (h[u.first] > h[v])
down.push_back(u);
else if (h[u.first] == h[v] - 1)
p.push_back(u);
else
backedge.push_back(u);
}
if (down.size()) {
for (int i = (int)down.size() - 2; i > -1; i -= 2) {
pair<int, int> a = down[i], b = down[i + 1];
down.pop_back();
down.pop_back();
ans.push_back({{a.first, v}, {v, b.first}});
evisited[a.second] = evisited[b.second] = 1;
}
if (down.size()) {
if (backedge.size()) {
pair<int, int> a = backedge.back(), b = down.back();
ans.push_back({{a.first, v}, {v, b.first}});
evisited[a.second] = evisited[b.second] = 1;
backedge.pop_back();
down.pop_back();
} else if (p.size()) {
pair<int, int> a = p.back(), b = down.back();
ans.push_back({{a.first, v}, {v, b.first}});
evisited[a.second] = evisited[b.second] = 1;
p.pop_back();
down.pop_back();
}
}
}
while (backedge.size() > 1) {
pair<int, int> a = backedge.back();
backedge.pop_back();
pair<int, int> b = backedge.back();
backedge.pop_back();
evisited[a.second] = evisited[b.second] = 1;
ans.push_back({{a.first, v}, {v, b.first}});
}
if (backedge.size()) {
pair<int, int> a = backedge.back(), b = p.back();
ans.push_back({{a.first, v}, {v, b.first}});
evisited[a.second] = evisited[b.second] = 1;
p.pop_back();
backedge.pop_back();
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[--a].push_back({--b, i});
adj[b].push_back({a, i});
}
for (int i = 0; i < n; i++)
if (!visited[i]) {
e = 0;
dfs(i);
e /= 2;
if (e & 1) {
cout << "No solution\n";
return 0;
}
}
for (auto u : ans)
cout << u.first.first + 1 << " " << u.first.second + 1 << " "
<< u.second.second + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int t, nxt;
bool block;
} edge[110000 << 1];
int headline[110000], E;
inline void add(int f, int t) {
edge[E].t = t;
edge[E].nxt = headline[f];
edge[E].block = false;
headline[f] = E++;
}
int n, m;
int dfs(int u) {
vector<int> adj;
for (int i = headline[u]; ~i; i = edge[i].nxt) {
if (edge[i].block) continue;
edge[i].block = edge[i ^ 1].block = true;
adj.push_back(edge[i].t);
}
int ss = adj.size();
queue<int> q;
for (int i = 0; i < ss; i++) {
int ww = dfs(adj[i]);
if (ww == 0) {
q.push(adj[i]);
} else {
printf("%d %d %d\n", u, adj[i], ww);
}
}
int x = -1, y = -1;
while (!q.empty()) {
if (x == -1) {
x = q.front();
q.pop();
} else {
y = q.front();
q.pop();
printf("%d %d %d\n", x, u, y);
x = y = -1;
}
}
if (x == -1) return 0;
return x;
}
void solve(void) {
memset(headline, -1, sizeof(headline));
E = 0;
for (int i = 0; i < (m); i++) {
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
add(b, a);
}
if (m % 2) {
printf("No solution\n");
return;
}
dfs(1);
}
int main(void) {
while (2 == scanf("%d%d", &n, &m)) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int N, M;
set<int> adj[MAXN];
bool vis[MAXN];
void dfs(int u, int p) {
vis[u] = true;
set<int> s = adj[u];
for (typeof(s.begin()) it = s.begin(); it != s.end(); it++) {
int t = (*it);
if (!vis[t]) {
dfs(t, u);
}
}
if (adj[u].size() & 1) {
adj[u].erase(p);
}
for (typeof(adj[u].begin()) it = adj[u].begin(); it != adj[u].end(); it++) {
cout << (*it) << ' ' << u << ' ';
adj[*it].erase(u);
it++;
cout << (*it) << '\n';
adj[*it].erase(u);
}
}
int main() {
cin >> N >> M;
if (M & 1) {
cout << "No solution\n";
return 0;
}
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
adj[a].insert(b);
adj[b].insert(a);
}
dfs(1, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e18;
const long long mod = 1e9 + 7;
const double Pi = acos(-1);
int n, m;
set<int> v[100009];
int dfs(int node) {
vector<int> out;
while (v[node].size()) {
int u = *v[node].begin();
v[node].erase(u);
v[u].erase(node);
int ret = dfs(u);
if (ret != -1) {
cout << node + 1 << " " << u + 1 << " " << ret + 1 << endl;
} else {
out.push_back(u);
}
}
for (int i = (out.size()) % 2; i < out.size(); i += 2) {
cout << out[i] + 1 << " " << node + 1 << " " << out[i + 1] + 1 << endl;
}
return (out.size() % 2 ? out[0] : -1);
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
v[a].insert(b);
v[b].insert(a);
}
if (m % 2) {
cout << "No solution" << endl;
return 0;
}
dfs(0);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long maxn = 1e5 + 500;
vector<long long> ger[maxn];
bool vis[maxn];
long long mond[maxn];
long long h[maxn];
long long jad[maxn][3];
long long j = 0;
void dfs(long long a, long long hh) {
vis[a] = 1;
long long v;
h[a] = hh;
for (long long i = 0; i < ger[a].size(); i++) {
v = ger[a][i];
if (!vis[v]) {
dfs(v, hh + 1);
}
}
}
void dfss(long long a) {
vis[a] = 1;
long long v;
vector<long long> vec;
for (long long i = 0; i < ger[a].size(); i++) {
v = ger[a][i];
if (!vis[v]) {
dfss(v);
if (mond[v] != -1) {
jad[j][0] = a;
jad[j][1] = v;
jad[j][2] = mond[v];
j++;
} else {
vec.push_back(v);
}
} else {
if (h[v] > h[a]) {
vec.push_back(v);
}
}
}
for (long long i = 1; i < vec.size(); i += 2) {
jad[j][0] = vec[i];
jad[j][1] = a;
jad[j][2] = vec[i - 1];
j++;
}
if (vec.size() & 1) {
mond[a] = vec.back();
} else {
mond[a] = -1;
}
}
int main() {
long long n, m, v, u;
cin >> n >> m;
if (m & 1) {
cout << "No solution";
return 0;
}
for (long long i = 0; i < m; i++) {
cin >> v >> u;
ger[--v].push_back(--u);
ger[u].push_back(v);
}
dfs(0, 0);
memset(&vis[0], 0, maxn);
dfss(0);
for (long long i = 0; i < j; i++) {
for (long long o = 0; o < 3; o++) {
cout << jad[i][o] + 1 << ' ';
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
vector<int> child[MAXN], adj[MAXN];
bitset<MAXN> b;
vector<array<int, 3>> ans;
array<int, 3> o;
void build(int v, int par) {
b[v] = true;
for (auto i : adj[v])
if (i != par && !b[i]) {
child[v].push_back(i);
build(i, v);
}
}
int dfs(int v, int par) {
b[v] = true;
vector<int> k;
for (auto i : adj[v])
if (b[i] && i != par) k.push_back(i);
for (auto i : child[v])
if (!b[i]) {
int now = dfs(i, v);
if (now) {
o[0] = v;
o[1] = i;
o[2] = now;
ans.push_back(o);
} else
k.push_back(i);
}
int t = k.size();
for (int i = 0; i + 1 < t; i += 2) {
o[0] = k[i];
o[1] = v;
o[2] = k[i + 1];
ans.push_back(o);
}
return (t % 2 ? k[t - 1] : 0);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
int a1, a2;
for (int i = 0; i < m; ++i) {
cin >> a1 >> a2;
adj[a1].push_back(a2);
adj[a2].push_back(a1);
}
build(1, 0);
for (int i = 0; i < MAXN; ++i) b[i] = false;
if (dfs(1, 0)) return cout << "No solution", 0;
for (auto i : ans) cout << i[0] << ' ' << i[1] << ' ' << i[2] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edg {
int v, nxt;
} E[100004 * 2];
int hd[100004], ide;
int s[100004];
void adde(int u, int v) {
E[ide].v = v;
E[ide].nxt = hd[u];
hd[u] = ide++;
}
void init() {
memset(hd, -1, sizeof(hd));
memset(s, 0, sizeof(s));
ide = 0;
}
int dfs(int u, int f) {
s[u] = 1;
int pre = 0;
for (int i = hd[u]; ~i; i = E[i].nxt) {
int v;
if ((v = E[i].v) != f && s[v] < 2) {
int q = (s[v] == 1) ? 0 : dfs(v, u);
if (q)
printf("%d %d %d\n", u, v, q);
else if (pre)
printf("%d %d %d\n", pre, u, v), pre = 0;
else
pre = v;
}
}
s[u] = 2;
return pre;
}
int n, m;
int main() {
while (~scanf("%d%d", &n, &m)) {
init();
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
adde(u, v);
adde(v, u);
}
if (m % 2)
puts("No solution");
else
dfs(1, -1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
set<int> adj[MAX];
int n, m;
int dfs(int source) {
vector<int> unpaired;
while (!adj[source].empty()) {
int each = *adj[source].begin();
adj[source].erase(each);
adj[each].erase(source);
int u = dfs(each);
if (u == 0) {
unpaired.push_back(each);
} else {
printf("%d %d %d\n", u, each, source);
}
}
while (unpaired.size() >= 2) {
int u = unpaired.back();
unpaired.pop_back();
int v = unpaired.back();
unpaired.pop_back();
printf("%d %d %d\n", u, source, v);
}
if (!unpaired.empty()) {
return unpaired.back();
}
return 0;
}
int main() {
scanf("%d %d", &n, &m);
if (m & 1) {
puts("No solution");
return 0;
}
for (int i = int(0); i < int(m); i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].insert(v);
adj[v].insert(u);
}
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
char ch = getchar();
long long f = 1, x = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
const long long maxn = 1e5 + 10;
long long n, h[maxn], cnt, m;
struct edge {
long long v, next;
} e[maxn << 1];
void addedge(long long u, long long v) {
e[++cnt].v = v;
e[cnt].next = h[u];
h[u] = cnt;
}
void insert(long long u, long long v) {
addedge(u, v);
addedge(v, u);
}
stack<long long> g[maxn];
struct answers {
long long a, b, c;
} ans[maxn];
long long vis[maxn], tot;
bool no;
void dfs(long long u, long long fa) {
vis[u] = 1;
for (long long i = h[u]; i; i = e[i].next) {
long long v = e[i].v;
if (!vis[v])
dfs(v, u);
else if (v != fa) {
g[v].push(u);
}
}
while (g[u].size() >= 2) {
ans[++tot].a = g[u].top();
ans[tot].b = u;
g[u].pop();
ans[tot].c = g[u].top();
g[u].pop();
}
if (g[u].size() == 1) {
if (fa == 0) {
no = 1;
return;
}
long long x = g[u].top();
ans[++tot].a = x;
ans[tot].b = u;
ans[tot].c = fa;
g[u].pop();
} else {
g[fa].push(u);
}
}
signed main() {
n = read();
m = read();
if (m & 1) {
cout << "No solution\n";
return 0;
}
for (long long i = 1; i <= m; i++) {
insert(read(), read());
}
dfs(1, 0);
if (no) {
cout << "No solution\n";
return 0;
}
for (long long i = 1; i <= tot; i++) {
cout << ans[i].a << " " << ans[i].b << " " << ans[i].c << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 1;
vector<int> g[MAXN];
vector<int> reverse_idx[MAXN];
vector<bool> blocked[MAXN];
int partition(const int v) {
vector<bool>::iterator is_blocked = blocked[v].begin();
vector<int>::iterator reverse = reverse_idx[v].begin();
int unpaired = false;
for (int u : g[v]) {
if (*is_blocked) {
++is_blocked;
++reverse;
continue;
}
*is_blocked = true;
blocked[u][*reverse] = true;
int w = partition(u);
if (w) {
printf("%d %d %d\n", v, u, w);
} else {
if (unpaired) {
printf("%d %d %d\n", unpaired, v, u);
unpaired = false;
} else {
unpaired = u;
}
}
++is_blocked;
++reverse;
}
return unpaired;
}
int main() {
int n, m;
scanf("%d %d ", &n, &m);
if (m % 2) {
printf("No solution\n");
return 0;
}
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d %d ", &a, &b);
reverse_idx[a].push_back(g[b].size());
reverse_idx[b].push_back(g[a].size());
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; ++i) {
blocked[i].resize(g[i].size(), false);
}
partition(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int edge[100000 + 10], first[100000 + 10], nxt[100000 + 10 << 1];
bool v[100000 + 10];
int mark[100000 + 10], vv[100000 + 10 << 1];
void dfs(int n, int fa) {
v[n] = 1;
for (int e = first[n]; e; e = nxt[e])
if (vv[e] != fa && !v[vv[e]]) dfs(vv[e], n);
int top = 0;
for (int e = first[n]; e; e = nxt[e])
if (vv[e] != fa && mark[vv[e]] != 1) edge[top++] = vv[e];
if (top & 1)
edge[top++] = fa, mark[n] = 1;
else
mark[n] = 2;
for (int i = 0; i < top; i += 2) {
printf("%d %d %d\n", edge[i], n, edge[i + 1]);
if (mark[edge[i]] == 2) mark[edge[i]] = 1;
if (mark[edge[i + 1]] == 2) mark[edge[i + 1]] = 1;
}
}
int main(void) {
int e = 1;
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
nxt[e] = first[u], vv[e] = v;
first[u] = e++;
nxt[e] = first[v], vv[e] = u;
first[v] = e++;
}
if (m & 1)
printf("No solution\n");
else
dfs(1, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 1e5 + 7;
const long long Inf = 1e9 + 7;
vector<long long> V[Maxn];
vector<pair<long long, pair<long long, long long> > > ans;
map<pair<long long, long long>, bool> mark;
bool vis[Maxn];
void True(long long u, long long v) {
mark[make_pair(u, v)] = mark[make_pair(v, u)] = true;
}
long long dfs(long long u, long long dad) {
if (vis[u]) return mark[make_pair(u, dad)];
vis[u] = true;
long long son = -1;
for (long long i = 0; i < V[u].size(); i++) {
long long v = V[u][i];
if (v == dad || mark[make_pair(u, v)]) continue;
bool t = dfs(v, u);
if (t)
continue;
else if (son != -1 && !mark[make_pair(son, u)]) {
ans.push_back(make_pair(son, make_pair(u, v)));
True(u, v);
True(u, son);
son = -1;
} else
son = v;
}
if (son == -1) return 0;
ans.push_back(make_pair(son, make_pair(u, dad)));
True(u, son);
True(u, dad);
return 1;
}
int main() {
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v;
cin >> u >> v;
V[u].push_back(v), V[v].push_back(u);
}
if (m % 2) {
cout << "No solution" << endl;
return 0;
}
dfs(1, -1);
for (long long i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second.first << " "
<< ans[i].second.second << endl;
}
|
#include <bits/stdc++.h>
bool aa[100000 << 1];
int a[100000], ab[100000], b[100000 << 1], c[100000 << 1], h[100000], n, m, i,
x, y, na, ma;
int go(int k) {
int ta = na, pa = ma, i, t;
for (i = h[k]; ~i; i = b[i])
if (!aa[i]) a[na++] = c[i], aa[i] = 1, aa[i >= m ? i - m : i + m] = 1;
for (i = ta; i < na; i++) {
t = go(a[i]);
if (!~t)
ab[ma++] = a[i];
else
printf("%d %d %d\n", k + 1, a[i] + 1, t + 1);
}
while (ma - pa >= 2) {
i = ab[--ma];
t = ab[--ma];
printf("%d %d %d\n", i + 1, k + 1, t + 1);
}
na = ta;
return ma > pa ? ab[--ma] : -1;
}
int main() {
scanf("%d%d", &n, &m);
if (m & 1) {
puts("No solution");
return 0;
}
for (i = 0; i < m * 2; i++) c[i] = -1;
for (i = 0; i < n; i++) h[i] = -1;
for (i = 0; i < m; ++i) {
scanf("%d%d", &x, &y);
--x, --y;
b[i] = h[x];
c[i] = y;
h[x] = i;
b[i + m] = h[y];
c[i + m] = x;
h[y] = i + m;
}
go(0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], b[maxn];
vector<pair<int, int>> G[maxn];
bool v[maxn], use[maxn];
struct data {
int a, b, c;
};
vector<data> ans;
void dfs(int now, int fa, int edge) {
v[now] = true;
int nxt = -1, cid = -1;
for (auto u : G[now])
if (u.first != fa) {
if (!v[u.first]) dfs(u.first, now, u.second);
if (use[u.second]) continue;
if (nxt == -1)
nxt = u.second, cid = u.first;
else if (nxt != -1) {
ans.emplace_back((data){u.first, now, cid});
use[nxt] = use[u.second] = true;
nxt = -1;
cid = -1;
}
}
if (nxt != -1) {
if (edge && !use[edge] && !use[nxt]) {
ans.emplace_back((data){cid, now, fa});
use[edge] = use[nxt] = true;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
if (m & 1) return cout << "No solution" << endl, 0;
for (int i = 1; i <= m; ++i) {
cin >> a[i] >> b[i];
G[a[i]].emplace_back(b[i], i);
G[b[i]].emplace_back(a[i], i);
}
for (int i = 1; i <= n; ++i) {
if (!v[i]) dfs(i, 0, 0);
}
if (ans.size() < m / 2) return cout << "No solution" << endl, 0;
for (auto e : ans) cout << e.a << ' ' << e.b << ' ' << e.c << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int inf = 1 << 30;
const long long INF = 1ll << 61;
using namespace std;
int n, m;
typedef struct Node {
int fro, to;
int nex;
int val;
};
Node edge[100000 * 2 + 55];
int head[100000 * 2 + 55];
bool vis[100000 * 2 + 55];
int tot;
void init() {
memset(vis, 0, sizeof(vis));
memset(head, -1, sizeof(head));
tot = 0;
}
void add(int u, int v) {
edge[tot].fro = u;
edge[tot].to = v;
edge[tot].nex = head[u];
head[u] = tot++;
}
bool input() {
while (cin >> n >> m) {
int q = m;
while (q--) {
int u, v;
scanf("%d %d", &u, &v);
add(u, v);
add(v, u);
}
return false;
}
return true;
}
int dfs(int u, int pre) {
queue<int> q;
for (int i = head[u]; i != -1; i = edge[i].nex) {
int v = edge[i].to;
if (vis[i] || v == pre) continue;
vis[i] = true;
vis[i ^ 1] = true;
int tmp = dfs(v, u);
if (tmp)
printf("%d %d %d\n", u, v, tmp);
else
q.push(v);
}
int len = q.size();
if (len & 1) {
while (q.size() > 1) {
int aa = q.front();
q.pop();
int bb = q.front();
q.pop();
printf("%d %d %d\n", aa, u, bb);
}
int aa = q.front();
q.pop();
return aa;
} else {
while (q.size()) {
int aa = q.front();
q.pop();
int bb = q.front();
q.pop();
printf("%d %d %d\n", aa, u, bb);
}
}
return 0;
}
void cal() {
if (m & 1) {
puts("No solution");
return;
}
dfs(1, -1);
}
void output() {}
int main() {
while (true) {
init();
if (input()) return 0;
cal();
output();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MXN = 100005;
int depth[MXN];
vector<int> ups[MXN];
set<int> children[MXN];
int parent[MXN];
vector<int> adj[MXN];
vector<pair<int, int>> cur_component;
int cur_edges = 0;
bool dealt_with[MXN];
bool weird[MXN];
void dfs(int v, int par) {
depth[v] = 1 + depth[par];
cur_component.push_back({depth[v], v});
children[par].insert(v);
parent[v] = par;
for (auto u : adj[v]) {
if (depth[u] > depth[v]) ups[u].push_back(v);
if (depth[u] == 0) dfs(u, v);
if (depth[u] < depth[v]) cur_edges++;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
vector<tuple<int, int, int>> ans;
for (int v = 1; v <= n; v++) {
if (depth[v] != 0) continue;
while (!cur_component.empty()) cur_component.pop_back();
dfs(v, 0);
if (cur_edges % 2 != 0) {
cout << "No solution\n";
return 0;
}
sort(cur_component.rbegin(), cur_component.rend());
for (auto thing : cur_component) {
int u = thing.second;
while (int((ups[u]).size()) > 1) {
ans.push_back({ups[u][int((ups[u]).size()) - 1], u,
ups[u][int((ups[u]).size()) - 2]});
ups[u].pop_back();
ups[u].pop_back();
}
}
priority_queue<tuple<int, int, int>> cur_components2;
for (auto c : cur_component) {
cur_components2.push({c.first, int((ups[c.second]).size()), c.second});
}
while (!cur_components2.empty()) {
int u = get<2>(cur_components2.top());
if (weird[u] && get<1>(cur_components2.top()) == 1) {
cur_components2.pop();
continue;
}
cur_components2.pop();
if (dealt_with[u] || u == v) continue;
if (int((ups[u]).size()) == 1) {
ans.push_back({parent[u], u, ups[u].back()});
ups[u].pop_back();
children[parent[u]].erase(u);
continue;
}
if (int((children[parent[u]]).size()) >= 2) {
children[parent[u]].erase(u);
int u2;
for (auto uu : children[parent[u]]) {
u2 = uu;
break;
}
children[parent[u]].erase(u2);
dealt_with[u2] = 1;
ans.push_back({u, parent[u], u2});
} else {
if (!ups[parent[u]].empty()) {
children[parent[u]].erase(u);
ans.push_back({u, parent[u], ups[parent[u]].back()});
ups[parent[u]].pop_back();
cur_components2.push({depth[parent[u]], 0, parent[u]});
weird[parent[u]] = 1;
} else {
ans.push_back({u, parent[u], parent[parent[u]]});
dealt_with[parent[u]] = 1;
children[parent[parent[u]]].erase(parent[u]);
}
}
}
}
for (auto a : ans)
cout << get<0>(a) << " " << get<1>(a) << " " << get<2>(a) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000 + 10;
int n, m;
vector<pair<int, int> > vertex[maxn];
bool mark[maxn];
stack<int> f[maxn];
stack<int> adj[maxn];
int build(int v) {
for (int i = 0; i < ((int(vertex[v].size()))); i++) {
int u = vertex[v][i].first, e = vertex[v][i].second;
if (!mark[e]) {
adj[v].push(u);
mark[e] = true;
}
}
while (!adj[v].empty()) {
int u = adj[v].top();
adj[v].pop();
int w = build(u);
if (w == 0)
f[v].push(u);
else
printf("%d %d %d\n", v, u, w);
}
while (((int(f[v].size()))) >= 2) {
int u = f[v].top();
f[v].pop();
int w = f[v].top();
f[v].pop();
printf("%d %d %d\n", u, v, w);
}
if (!f[v].empty()) {
int w = f[v].top();
f[v].pop();
return w;
} else
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
vertex[u].push_back(make_pair(v, i));
vertex[v].push_back(make_pair(u, i));
}
if (m & 1) {
printf("No solution");
return 0;
}
build(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod7 = 1000000007;
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
vector<int> gr[1000001];
pair<long long, long long> data[1000001];
bool used1[1000001];
bool used2[1000001];
int dfs(int v) {
vector<int> ch, ch2;
used2[v] = true;
for (int i = 0; i < gr[v].size(); ++i) {
int m = gr[v][i];
if (used1[m]) continue;
used1[m] = true;
int fr = data[m].first;
int to = data[m].second;
if (to == v) swap(fr, to);
ch2.push_back(to);
}
for (int i = 0; i < ch2.size(); ++i) {
if (!used2[ch2[i]]) {
int ret = dfs(ch2[i]);
if (ret) {
printf("%d %d %d\n", ret, ch2[i], v);
} else {
ch.push_back(ch2[i]);
}
} else
ch.push_back(ch2[i]);
}
for (int i = 0; i + 1 < ch.size(); i += 2) {
printf("%d %d %d\n", ch[i], v, ch[i + 1]);
}
if (ch.size() & 1) return ch.back();
return 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (m & 1) {
printf("No solution");
return 0;
}
for (int i = 0; i < m; ++i) {
scanf("%d%d", &data[i].first, &data[i].second);
gr[data[i].first].push_back(i);
gr[data[i].second].push_back(i);
}
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > adjlist[100005];
int num[100005];
bool visited[100005];
int n, m, u, v, d;
int dfs(int u) {
int c1 = -1, c2 = 0;
for (int i = 0; i < adjlist[u].size(); i++) {
pair<int, int> next = adjlist[u][i];
if (visited[next.second]) continue;
visited[next.second] = 1;
int res = dfs(next.first);
if (res > -1) {
printf("%d %d %d\n", res + 1, next.first + 1, u + 1);
} else {
if (c2 == 0) {
c1 = next.first;
c2 = 1;
} else {
printf("%d %d %d\n", next.first + 1, u + 1, c1 + 1);
c2 = 0;
}
}
}
if (c2 == 0) return -1;
return c1;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) visited[i] = false;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
adjlist[u].push_back(pair<int, int>(v, i));
adjlist[v].push_back(pair<int, int>(u, i));
}
if (m % 2) {
printf("No solution\n");
return 0;
}
dfs(0);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> con[110000];
int vis[110000], visE[110000], chk[110000];
int prv[110000], arr[110000][5];
int R[110000], RN;
int rn, q[110000 * 2];
int n, m;
int st, en;
struct Edge {
int x, y;
Edge(int x = 0, int y = 0) : x(x), y(y) {}
} E[110000];
void Push(int a, int b) {
arr[rn][0] = E[a].x;
arr[rn][1] = E[a].y;
arr[rn][2] = E[b].x;
arr[rn][3] = E[b].y;
sort(arr[rn], arr[rn] + 4);
rn++;
}
bool connect(int a, int b) {
if (E[a].x == E[b].x || E[a].x == E[b].y || E[a].y == E[b].x ||
E[a].y == E[b].y) {
Push(a, b);
return true;
}
return false;
}
void Chk(int e, int x) {
if (vis[x]) return;
vis[x] = 1;
for (int i = 0; i < con[x].size(); i++) {
int id = con[x][i];
if (visE[id]) continue;
visE[id] = 1;
q[en++] = id;
prv[id] = e;
}
}
int main() {
int i, k, j, x, y;
int a, b;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
E[i].x = --x;
E[i].y = --y;
con[x].push_back(i);
con[y].push_back(i);
}
if (m & 1) {
puts("No solution");
return 0;
}
q[en++] = 0, visE[0] = 1, prv[0] = -1;
while (st < en) {
int e = q[st++];
Chk(e, E[e].x);
Chk(e, E[e].y);
}
rn = 0;
for (i = m - 1; i >= 1; i--) {
RN = 0;
for (k = i; prv[q[k]] == prv[q[i]]; k--)
if (!chk[q[k]]) R[RN++] = q[k];
i = k + 1;
if (!prv[q[i]]) break;
for (j = 0; j < RN; j += 2)
if (j + 1 < RN) Push(R[j], R[j + 1]);
if (RN & 1) {
chk[prv[R[RN - 1]]] = 1;
Push(R[RN - 1], prv[R[RN - 1]]);
}
}
while (RN > 2) {
int a = R[--RN];
int b = R[--RN];
int c = R[--RN];
if (connect(a, b))
R[RN++] = c;
else if (connect(a, c))
R[RN++] = b;
else if (connect(b, c))
R[RN++] = a;
}
if (RN == 1)
Push(R[0], 0);
else if (RN == 2) {
puts("No solution");
return 0;
}
for (i = 0; i < rn; i++) {
for (k = 0; k < 3; k++)
if (arr[i][k] == arr[i][k + 1]) break;
int tmp[4], tn(0);
for (j = 0; j < 4; j++)
if (j != k && j != k + 1) tmp[tn++] = arr[i][j];
printf("%d %d %d\n", tmp[0] + 1, arr[i][k] + 1, tmp[1] + 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
vector<int> V[MAXN];
int N, M;
int pass[MAXN], instack[MAXN];
vector<int> atdep[MAXN], extra[MAXN];
void dfs(int u, int parr, int dep) {
pass[u] = true;
instack[u] = true;
atdep[dep].push_back(u);
for (int i = 0; i < V[u].size(); i++) {
if (instack[V[u][i]]) extra[u].push_back(V[u][i]);
if (V[u][i] != parr && !pass[V[u][i]]) dfs(V[u][i], u, dep + 1);
}
instack[u] = false;
}
int main() {
scanf("%d %d", &N, &M);
if (M % 2 == 1) {
printf("No solution\n");
return 0;
}
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);
}
dfs(1, -1, 0);
for (int dep = N - 1; dep >= 0; dep--) {
for (int i = 0; i < atdep[dep].size(); i++) {
while (extra[atdep[dep][i]].size() >= 2) {
int x = extra[atdep[dep][i]].back();
extra[atdep[dep][i]].pop_back();
int y = extra[atdep[dep][i]].back();
extra[atdep[dep][i]].pop_back();
printf("%d %d %d\n", x, atdep[dep][i], y);
}
if (!extra[atdep[dep][i]].empty()) {
int x = extra[atdep[dep][i]].back();
extra[atdep[dep][i]].pop_back();
extra[x].push_back(atdep[dep][i]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
static inline int Rint() {
struct X {
int dig[256];
X() {
for (int i = '0'; i <= '9'; ++i) dig[i] = 1;
dig['-'] = 1;
}
};
static X fuck;
int s = 1, v = 0, c;
for (; !fuck.dig[c = getchar()];)
;
if (c == '-')
s = 0;
else if (fuck.dig[c])
v = c ^ 48;
for (; fuck.dig[c = getchar()]; v = v * 10 + (c ^ 48))
;
return s ? v : -v;
}
template <typename T>
static inline void cmax(T& a, const T& b) {
if (b > a) a = b;
}
template <typename T>
static inline void cmin(T& a, const T& b) {
if (b < a) a = b;
}
vector<int> adj[100005];
int visited[100005];
int av[100005];
int xid;
void dfs(int curr, int prev) {
vector<int>& vec = adj[curr];
const int size = ((int)(vec).size());
visited[curr] = ++xid;
vector<int> orz;
for (int i = 0; i < size; ++i) {
int to = vec[i];
if (to == prev) continue;
if (visited[to]) {
if (visited[to] < visited[curr]) {
orz.push_back(to);
}
} else {
dfs(to, curr);
if (av[to] != 0) {
printf("%d %d %d\n", curr, to, av[to]);
} else {
orz.push_back(to);
}
}
}
int now = 0;
while (now + 1 < orz.size()) {
printf("%d %d %d\n", orz[now], curr, orz[now + 1]);
now += 2;
}
if (now < orz.size()) {
av[curr] = orz[now];
}
}
int main() {
int n = Rint(), m = Rint();
if (m & 1) {
puts("No solution");
return 0;
}
for (int i = 0; i < m; ++i) {
int s = Rint(), t = Rint();
adj[s].push_back(t), adj[t].push_back(s);
}
dfs(1, -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ok[200050];
vector<pair<int, int> > grafo[200050];
set<pair<int, int> > vis;
vector<pair<int, pair<int, int> > > ans;
bool possivel = true;
int dfs(int x) {
vector<int> filhos, exposed;
ok[x] = 1;
for (auto v : grafo[x]) {
int a = min(x, v.first), b = max(x, v.first);
if (vis.count({a, b})) continue;
vis.insert({a, b});
filhos.push_back(v.first);
}
for (auto v : filhos) {
int u = (ok[v] ? -1 : dfs(v));
if (u == -1)
exposed.push_back(v);
else
ans.push_back({x, {v, u}});
}
for (int i = 0; i < (int)exposed.size(); i += 2) {
if (i == (int)exposed.size() - 1) return exposed[i];
ans.push_back({exposed[i], {x, exposed[i + 1]}});
}
return -1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1, a, b; i <= m; i++) {
cin >> a >> b;
grafo[a].push_back({b, i});
grafo[b].push_back({a, i});
}
dfs(1);
if (2 * ans.size() == m) {
for (auto w : ans)
cout << w.first << " " << w.second.first << " " << w.second.second
<< "\n";
} else
cout << "No solution\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
int n, m, p[N], d[N];
bool vis[N];
vector<int> g[N], backw[N], vec[N];
void dfs(int x) {
for (int i : g[x]) {
if (p[i] == 0) {
d[i] = d[x] + 1;
p[i] = x;
dfs(i);
} else if (p[x] != i && d[x] > d[i]) {
backw[x].push_back(i);
}
}
}
void solve(int x) {
vis[x] = 1;
for (int i : g[x]) {
if (!vis[i]) {
solve(i);
}
}
while (vec[x].size() >= 2) {
int a = vec[x].back();
vec[x].pop_back();
int b = vec[x].back();
vec[x].pop_back();
cout << a << ' ' << x << ' ' << b << '\n';
}
if (vec[x].size() == 1) {
int a = vec[x].back();
vec[x].pop_back();
backw[x].push_back(a);
}
while (backw[x].size() >= 2) {
int a = backw[x].back();
backw[x].pop_back();
int b = backw[x].back();
backw[x].pop_back();
cout << a << ' ' << x << ' ' << b << '\n';
}
if (backw[x].size() == 1) {
int a = backw[x].back();
backw[x].pop_back();
cout << a << ' ' << x << ' ' << p[x] << '\n';
} else {
vec[p[x]].push_back(x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
if (m % 2 == 1) {
cout << "No solution";
return 0;
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
p[1] = 1;
dfs(1);
solve(1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int first[maxn], nxt[maxn << 1], vv[maxn << 1];
bool vis[maxn];
int mark[maxn];
int edge[maxn];
void dfs(int n, int fa) {
vis[n] = true;
for (int e = first[n]; e; e = nxt[e])
if (vv[e] != fa && !vis[vv[e]]) dfs(vv[e], n);
int top = 0;
for (int e = first[n]; e; e = nxt[e])
if (vv[e] != fa && mark[vv[e]] != 1) edge[top++] = vv[e];
if (top & 1)
edge[top++] = fa, mark[n] = 1;
else
mark[n] = 2;
for (int i = 0; i < top; i += 2) {
printf("%d %d %d\n", edge[i], n, edge[i + 1]);
if (mark[edge[i]] == 2) mark[edge[i]] = 1;
if (mark[edge[i + 1]] == 2) mark[edge[i + 1]] = 1;
}
}
int main() {
int e = 2;
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
nxt[e] = first[u], vv[e] = v, first[u] = e++;
nxt[e] = first[v], vv[e] = u, first[v] = e++;
}
if (m & 1)
puts("No solution");
else
dfs(1, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 1e5 + 10, INF = 1e9;
int n, m, from[MAX_N], to[MAX_N], tkhor[MAX_N], tvor[MAX_N], d[MAX_N];
vector<int> adj[MAX_N], khor[MAX_N], vor[MAX_N], fard, efkhor[MAX_N];
bool vis[MAX_N], avaz[MAX_N], mar[MAX_N];
int tyal(int v) {
vis[v] = 1;
int ret = adj[v].size();
for (int k : adj[v]) {
int u = from[k] ^ to[k] ^ v;
if (!vis[u]) {
ret += tyal(u);
}
}
return ret;
}
void ffar(int v) {
vis[v] = 1;
if (tkhor[v] % 2 == 1) fard.push_back(v);
for (int k : adj[v]) {
int u = from[k] ^ to[k] ^ v;
if (!vis[u]) {
ffar(u);
}
}
}
void avyal(int v, int yp = 0) {
mar[v] = 1;
for (int k : adj[v]) {
int u = from[k] ^ to[k] ^ v;
if (!mar[u]) {
avyal(u, k);
d[v] += d[u];
}
}
if (d[v] % 2 == 1) avaz[yp] = 1;
}
void hal(int v) {
fard.clear();
ffar(v);
memset(mar, 0, sizeof mar);
for (int i = 0; i < fard.size(); i++) {
d[fard[i]]++;
}
avyal(v);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
tkhor[a]++;
from[i] = a;
to[i] = b;
adj[a].push_back(i);
adj[b].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
if ((tyal(i) / 2) % 2 == 1) {
cout << "No solution" << endl;
return 0;
}
}
}
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
hal(i);
}
}
for (int i = 0; i < m; i++) {
if (avaz[i] == 1) {
efkhor[to[i]].push_back(from[i]);
} else {
efkhor[from[i]].push_back(to[i]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < efkhor[i].size(); j += 2) {
cout << efkhor[i][j] << " " << i << " " << efkhor[i][j + 1] << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int N, M;
vector<int> adj[maxn];
int cnt = 0, num[maxn];
vector<pair<int, pair<int, int>>> res;
bool dfs(int u, int p = 0) {
num[u] = ++cnt;
int cur = 0;
for (int v : adj[u]) {
if (v == p) continue;
if ((num[v] != 0 && num[v] < num[u]) || (num[v] == 0 && dfs(v, u))) {
if (cur == 0)
cur = v;
else
res.push_back(make_pair(cur, make_pair(u, v))), cur = 0;
}
}
if (cur == 0)
return true;
else {
if (p != 0) res.push_back(make_pair(p, make_pair(u, cur)));
return false;
}
}
signed main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> 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);
}
if (M & 1) {
cout << "No solution";
return 0;
}
for (int i = 1; i <= N; ++i) {
if (num[i] == 0) dfs(i);
}
for (auto& x : res)
cout << x.first << ' ' << x.second.first << ' ' << x.second.second << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[(int)(1e5 + 500)];
map<pair<int, int>, int> block, done;
int process[(int)(1e5 + 500)];
void print(int x, int y, int z) {
printf("%d", x);
printf(" ");
printf("%d", y);
printf(" ");
printf("%d", z);
printf(" ");
done[make_pair(x, y)] = done[make_pair(y, x)] = 1;
done[make_pair(y, z)] = done[make_pair(z, y)] = 1;
}
int cut(int x) {
vector<int> adj;
for (int i = 0; i < G[x].size(); i++) {
int to = G[x][i];
if (block.find(make_pair(x, to)) == block.end()) {
block[make_pair(x, to)] = block[make_pair(to, x)] = 1;
adj.push_back(to);
}
}
for (int i = 0; i < adj.size(); i++) {
int to = adj[i];
if (!process[to]) {
int z = cut(to);
if (z) {
print(x, to, z);
}
}
}
int other = 0;
for (int i = 0; i < adj.size(); i++) {
int to = adj[i];
if (!done[make_pair(x, to)]) {
if (other == 0) {
other = to;
} else {
print(other, x, to);
other = 0;
}
}
}
process[x] = 1;
return other;
}
void solve() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
if (m % 2) {
printf("No solution");
return;
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
G[x].push_back(y);
G[y].push_back(x);
}
cut(1);
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 100 + 5;
int n, m, t = -1;
vector<pair<int, int> > adj[MAXN];
bool mark[MAXN];
void DMP(int v) {
queue<int> q;
while (!q.empty()) {
q.pop();
}
for (int i = 0; i < adj[v].size(); i++) {
if (!mark[adj[v][i].second]) {
q.push(adj[v][i].first);
mark[adj[v][i].second] = true;
}
}
int siz = q.size();
for (int i = 0; i < siz; i++) {
int u = q.front();
DMP(u);
if (t == -1)
q.push(u);
else
cout << v + 1 << " " << u + 1 << " " << t + 1 << endl;
q.pop();
}
int s = q.size();
for (int i = 0; i < s - 1; i += 2) {
cout << q.front() + 1 << " ";
q.pop();
cout << v + 1 << " ";
cout << q.front() + 1 << endl;
q.pop();
}
if (s % 2 == 0)
t = -1;
else
t = q.back();
return;
}
int main() {
cin >> n >> m;
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
u--;
v--;
adj[u].push_back(make_pair(v, i));
adj[v].push_back(make_pair(u, i));
}
if (m % 2 == 1) {
cout << "No solution" << endl;
return 0;
}
DMP(0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 10;
const int inf = 522133279;
const int mod = 1000000007;
struct edge {
int s;
int t;
int next;
int vis;
} e[100100 * 2];
int n, m;
int cnt, head[100100];
int color[100100];
void add(int s, int t) {
e[cnt].s = s;
e[cnt].t = t;
e[cnt].next = head[s];
e[cnt].vis = 0;
head[s] = cnt++;
}
int dfs(int cur) {
queue<int> adjacent;
for (int i = head[cur]; ~i; i = e[i].next) {
if (!e[i].vis) {
adjacent.push(e[i].t);
e[i].vis = e[i ^ 1].vis = 1;
}
}
queue<int> unpair;
while (!adjacent.empty()) {
int u = adjacent.front();
adjacent.pop();
int w = dfs(u);
if (w == 0)
unpair.push(u);
else
printf("%d %d %d\n", cur, u, w);
}
while (unpair.size() >= 2) {
int u = unpair.front();
unpair.pop();
int v = unpair.front();
unpair.pop();
printf("%d %d %d\n", u, cur, v);
}
if (unpair.size()) return unpair.front();
return 0;
}
int main() {
scanf("%d%d", &n, &m);
memset(head, -1, sizeof(head));
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
add(b, a);
}
if (m % 2)
puts("No solution");
else
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
vector<vector<int>> G(MAX);
vector<int> odd(MAX, 0), lef(MAX, 0), vis(MAX, 0), par(MAX);
vector<tuple<int, int, int>> ans;
void dfs(int node, int p) {
vis[node] = 1;
par[node] = p;
for (int nxt : G[node]) {
if (!vis[nxt]) {
dfs(nxt, node);
}
}
vector<int> Ve;
for (int nxt : G[node]) {
if (nxt != p) {
if (par[nxt] == node && odd[nxt]) {
ans.push_back({node + 1, nxt + 1, lef[nxt] + 1});
} else if (vis[nxt] == 1 || par[nxt] == node)
Ve.push_back(nxt);
}
}
int sz = Ve.size();
if (sz & 1) {
odd[node] = 1;
lef[node] = Ve[sz - 1];
}
for (int i = 0; i + 1 < sz; i += 2) {
ans.push_back({Ve[i] + 1, node + 1, Ve[i + 1] + 1});
}
vis[node] = 2;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
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);
}
if (m & 1) {
cout << "No solution\n";
return 0;
}
dfs(0, -1);
for (auto x : ans) {
int a, b, c;
tie(a, b, c) = x;
cout << a << ' ' << b << ' ' << c << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long MAX = (long long)1e6 + 10;
long long inf = (long long)2e9;
long long mod = (long long)1e9 + 7;
;
long long m, n, q, used[MAX], parity[MAX], par[MAX];
set<long long> gr[MAX], useless[MAX];
vector<pair<long long, long long>> edg[MAX];
long long t = 0;
vector<long long> perm;
void dfs(long long v, long long p) {
par[v] = p;
used[v] = ++t;
set<long long> del;
del.insert(p);
for (auto u : gr[v]) {
if (u == p) continue;
if (used[u] && used[u] < used[v]) {
useless[v].insert(u);
del.insert(u);
} else if (used[u]) {
del.insert(u);
} else {
dfs(u, v);
}
}
for (auto u : del) gr[v].erase(u);
}
void tour(long long v, long long p) {
for (auto u : gr[v]) {
tour(u, v);
}
perm.push_back(v);
}
void solve() {
cin >> n >> m;
if (m % 2) {
cout << "No solution\n";
return;
}
for (int i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
gr[a].insert(b);
gr[b].insert(a);
}
dfs(1, 0);
tour(1, 0);
for (int i = 0; i < perm.size() - 1; i++) {
long long v = perm[i];
for (auto u : useless[v]) {
edg[v].push_back({u, v});
}
long long u = par[v];
if (edg[v].size() % 2) {
edg[v].push_back({u, v});
} else
edg[u].push_back({v, u});
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < edg[i].size(); j += 2) {
long long a = edg[i][j].first, b = edg[i][j + 1].first;
cout << a << " " << i << " " << b << "\n";
}
}
}
int main() {
ios::sync_with_stdio(0);
long long q;
q = 1;
while (q--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int n, m;
bool mark[MAXN];
vector<int> adj[MAXN];
vector<int> boom[MAXN];
bool DFS(int cur, int p) {
mark[cur] = true;
for (int i = 0; i < (int)adj[cur].size(); i++) {
int viz = adj[cur][i];
if (mark[viz]) {
if (viz != p) boom[viz].push_back(cur);
continue;
}
if (!DFS(viz, cur)) boom[cur].push_back(viz);
}
while ((int)boom[cur].size() > 1) {
int A = boom[cur].back();
boom[cur].pop_back();
int B = boom[cur].back();
boom[cur].pop_back();
printf("%d %d %d\n", A, cur, B);
}
if (boom[cur].empty()) return false;
printf("%d %d %d\n", p, cur, boom[cur].back());
return true;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int U, V;
scanf("%d %d", &U, &V);
adj[U].push_back(V);
adj[V].push_back(U);
}
if (m % 2 == 1) {
printf("No solution\n");
return 0;
}
DFS(1, 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, m, x[N], y[N];
vector<int> e[N], id[N], ans;
bool vn[N], ve[N];
int dfs(int nd) {
if (vn[nd]) return 0;
vn[nd] = 1;
int up = 0;
for (int i = 0; i < e[nd].size(); i++) {
if (!ve[id[nd][i]]) {
ve[id[nd][i]] = 1;
int k = dfs(e[nd][i]);
if (!k) {
if (up == 0) {
up = id[nd][i];
} else {
ans.push_back(id[nd][i]);
ans.push_back(up);
up = 0;
}
} else {
ans.push_back(id[nd][i]);
ans.push_back(k);
}
}
}
return up;
}
int main() {
if (fopen("E.in", "r")) freopen("E.in", "r", stdin);
cin >> n >> m;
if (m % 2) {
cout << "No solution";
return 0;
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", x + i, y + i);
e[x[i]].push_back(y[i]);
id[x[i]].push_back(i);
e[y[i]].push_back(x[i]);
id[y[i]].push_back(i);
}
dfs(1);
for (int i = 0; i < ans.size() - 1; i += 2) {
if (x[ans[i]] == x[ans[i + 1]]) {
printf("%d %d %d\n", y[ans[i]], x[ans[i]], y[ans[i + 1]]);
} else if (x[ans[i]] == y[ans[i + 1]]) {
printf("%d %d %d\n", y[ans[i]], x[ans[i]], x[ans[i + 1]]);
} else if (y[ans[i]] == x[ans[i + 1]]) {
printf("%d %d %d\n", x[ans[i]], y[ans[i]], y[ans[i + 1]]);
} else if (y[ans[i]] == y[ans[i + 1]]) {
printf("%d %d %d\n", x[ans[i]], y[ans[i]], x[ans[i + 1]]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
bool a[100000 << 1], aa[100000];
int b[100000 << 1], c[100000 << 1], h[100000], n, m, i, x, y;
int go(int k) {
if (aa[k]) return -1;
int i, t, x = -1;
for (i = h[k]; ~i; i = b[i])
if (!a[i]) {
aa[k] = 1;
a[i] = 1, a[i >= m ? i - m : i + m] = 1;
t = go(c[i]);
if (~t)
printf("%d %d %d\n", k + 1, c[i] + 1, t + 1);
else if (~x)
printf("%d %d %d\n", x + 1, k + 1, c[i] + 1), x = -1;
else
x = c[i];
}
return ~x ? x : -1;
}
int main() {
scanf("%d%d", &n, &m);
if (m & 1) {
puts("No solution");
return 0;
}
for (i = 0; i < m * 2; i++) c[i] = -1;
for (i = 0; i < n; i++) h[i] = -1;
for (i = 0; i < m; ++i) {
scanf("%d%d", &x, &y);
--x, --y;
b[i] = h[x];
c[i] = y;
h[x] = i;
b[i + m] = h[y];
c[i + m] = x;
h[y] = i + m;
}
go(0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> fact(100005);
vector<long long int> prime_check(1e7 + 2);
vector<long long int> primes;
long long powmod(long long x, long long y, long long m) {
long long res = 1LL;
while (y) {
if (y & 1) res = (res * x) % m;
x = (x * x) % m;
y /= 2;
}
return res;
}
void init_fact() {
fact[0] = 1;
for (long long int i = 1; i < 100005; i++) {
fact[i] = (fact[i - 1] * i) % 1000000009;
}
}
long long int C(long long int n, long long int r) {
if (n < r) return 0;
long long int temp =
fact[n] * powmod(fact[r], 1000000009 - 2, 1000000009) % 1000000009;
temp *= powmod(fact[n - r], 1000000009 - 2, 1000000009);
temp %= 1000000009;
return temp;
}
void Sieve() {
for (long long int i = 2; i <= 1e7 + 1; i++) {
if (prime_check[i]) continue;
primes.push_back(i);
for (long long int j = 2 * i; j <= 1e7 + 1; j += i) prime_check[j] = i;
}
}
long long int phi(long long int n) {
long long int i, res = n;
for (i = 2; i * i <= n; i++)
if (n % i == 0) {
while (n % i == 0) n /= i;
res -= res / i;
}
if (n > 1) res -= res / n;
return res;
}
long long int n, m;
vector<vector<pair<long long int, long long int>>> adj(100005);
vector<long long int> visited(100005);
vector<long long int> vis(100005);
long long int part(long long int u) {
vector<long long int> unpaired;
visited[u] = 1;
for (auto y : adj[u]) {
long long int x = y.first;
if (!visited[x]) {
vis[y.second] = 1;
long long int w = part(x);
if (w != 0)
cout << u << " " << x << " " << w << "\n";
else
unpaired.push_back(x);
} else if (!vis[y.second])
unpaired.push_back(x), vis[y.second] = 1;
}
while (unpaired.size() >= 2) {
cout << unpaired.back() << " " << u << " ";
unpaired.pop_back();
cout << unpaired.back() << "\n";
unpaired.pop_back();
}
if (unpaired.size() > 0) return unpaired.back();
return 0;
}
void input_adj(long long int n) {
for (long long int i = 0; i < n - 1; i++) {
long long int u, vector;
cin >> u >> vector;
adj[u].push_back({vector, i});
adj[vector].push_back({u, i});
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
input_adj(m + 1);
if (m % 2) {
cout << "No solution\n";
return 0;
}
part(1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10, mod = 1e9 + 7, base = 41, INF = 99999999999, sq = 502;
struct A {
int a, b, c;
};
vector<A> ans;
int q, n, m, h[MAX];
bool used[MAX], mark[MAX];
vector<int> adj[MAX];
inline void hdfs(int v) {
mark[v] = 1;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (!mark[u]) {
h[u] = h[v] + 1;
hdfs(u);
}
}
}
inline void dfs(int v, int p) {
mark[v] = 1;
queue<int> second;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (!mark[u]) {
dfs(u, v);
}
if (u != p && !used[u]) second.push(u);
}
while (second.size() > 1) {
int x = second.front();
second.pop();
int y = second.front();
used[x] = (h[x] > h[v]), used[y] = (h[y] > h[v]);
second.pop();
ans.push_back({x, v, y});
}
if (second.size()) {
int x = second.front();
used[x] = (h[x] > h[v]);
ans.push_back({x, v, p});
used[v] = 1;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
if (m & 1) return cout << "No solution", -0;
for (int u, v, i = 0; i < m; i++) {
cin >> u >> v;
adj[v].push_back(u), adj[u].push_back(v);
}
hdfs(1);
for (int i = 1; i <= n; i++) mark[i] = 0;
dfs(1, -1);
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].a << ' ' << ans[i].b << ' ' << ans[i].c << '\n';
}
return -0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 5;
const long long mod = 1e9 + 7;
const long long inf = 1e9;
const long long del = 728729;
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
long long n;
long long m;
long long visited[maxn];
vector<long long> adj[maxn];
vector<long long> back[maxn], dare[maxn];
long long par[maxn];
long long dis[maxn];
long long check[maxn];
vector<pair<pair<int, int>, long long> > ans;
bool dfs(long long root) {
visited[root] = 1;
long long cnt = 0;
long long test;
for (int i = 0; i < adj[root].size(); i++) {
long long u = adj[root][i];
if (!visited[u]) {
par[u] = root;
if (dfs(u) == false) {
cnt++;
if (cnt % 2 == 0) {
ans.push_back({{test, root}, u});
} else {
test = u;
}
}
}
}
check[root] = 1;
for (int i = 0; i < adj[root].size(); i++) {
long long u = adj[root][i];
if (u != par[root] && check[u] == 0) {
cnt++;
if (cnt % 2 == 0) {
ans.push_back({{test, root}, u});
} else {
test = u;
}
}
}
if (cnt % 2 == 1 && par[root] != -1) {
ans.push_back({{test, root}, par[root]});
return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> m;
for (long long i = 0; i < m; i++) {
long long x;
long long y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
if (m % 2 == 1) {
cout << "No solution";
return 0;
}
for (long long i = 1; i <= n; i++) {
if (!visited[i]) {
par[i] = -1;
dis[i] = 0;
dfs(i);
}
}
if (ans.size() != m / 2) {
cout << "No solution";
return 0;
}
while (ans.size()) {
cout << ans.back().first.first << " " << ans.back().first.second << " "
<< ans.back().second << endl;
ans.pop_back();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
struct sa {
int x, y, z;
sa(int x, int y, int z) : x(x), y(y), z(z) {}
sa() {}
};
vector<sa> ans;
vector<int> a[110000];
int v[110000], d[110000];
int n, m;
int dfs(int x, int dep) {
int i, y, z, last = 0;
v[x] = 1;
d[x] = dep;
for (i = 0; i < a[x].size(); i++) {
y = a[x][i];
if (v[y] && d[y] < d[x]) continue;
if (!v[y] && (z = dfs(y, dep + 1)) && z) {
sa t(x, y, z);
ans.push_back(t);
} else {
sa t(last, x, y);
last = last ? ans.push_back(t), 0 : y;
}
}
return last;
}
int main() {
int i, x, y, flag;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
flag = 1;
for (i = 1; i <= n; i++)
if (!v[i] && dfs(i, 0)) flag = 0;
if (!flag) return puts("No solution"), 0;
for (i = 0; i < ans.size(); i++)
printf("%d %d %d\n", ans[i].x, ans[i].y, ans[i].z);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000 * 100 + 10;
vector<int> v[MAX_N], a[MAX_N], b[MAX_N], javab, c;
bool check[MAX_N], edge[MAX_N];
map<pair<int, int>, int> m;
int parent[MAX_N];
void DFS(int x) {
check[x] = true;
for (int i = 0; i < v[x].size(); i++) {
if (check[v[x][i]] == false) {
parent[v[x][i]] = x;
DFS(v[x][i]);
} else if (parent[x] != v[x][i] &&
edge[m[make_pair(x, v[x][i])]] == false) {
b[x].push_back(v[x][i]);
edge[m[make_pair(x, v[x][i])]] = true;
edge[m[make_pair(v[x][i], x)]] = true;
}
}
c.push_back(x);
if (parent[x] != x) a[x].push_back(parent[x]);
}
int main() {
int n, mm, x, y;
ios::sync_with_stdio(false);
cin >> n >> mm;
for (int i = 0; i < mm; i++) {
cin >> x >> y;
x--;
y--;
v[x].push_back(y);
v[y].push_back(x);
m[make_pair(x, y)] = i;
m[make_pair(y, x)] = i;
}
if (mm % 2 == 1) {
cout << "No solution" << endl;
return 0;
}
DFS(0);
for (int i = 0; i < c.size(); i++) {
int ras = c[i];
if ((a[ras].size() + b[ras].size()) % 2 == 0) {
if (a[ras].size() % 2 == 0) {
for (int j = 0; j < b[ras].size(); j += 2) {
javab.push_back(b[ras][j] + 1);
javab.push_back(ras + 1);
javab.push_back(b[ras][j + 1] + 1);
}
for (int j = 0; j < a[ras].size(); j += 2) {
javab.push_back(a[ras][j] + 1);
javab.push_back(ras + 1);
javab.push_back(a[ras][j + 1] + 1);
}
} else {
for (int j = 0; j < b[ras].size() - 1; j += 2) {
javab.push_back(b[ras][j] + 1);
javab.push_back(ras + 1);
javab.push_back(b[ras][j + 1] + 1);
}
for (int j = 0; j < a[ras].size() - 1; j += 2) {
javab.push_back(a[ras][j] + 1);
javab.push_back(ras + 1);
javab.push_back(a[ras][j + 1] + 1);
}
javab.push_back(b[ras][b[ras].size() - 1] + 1);
javab.push_back(ras + 1);
javab.push_back(a[ras][a[ras].size() - 1] + 1);
}
} else {
if (b[ras].size() % 2 == 0)
for (int j = 0; j < b[ras].size(); j += 2) {
javab.push_back(b[ras][j] + 1);
javab.push_back(ras + 1);
javab.push_back(b[ras][j + 1] + 1);
}
if (b[ras].size() % 2 == 1) {
for (int j = 0; j < b[ras].size() - 1; j += 2) {
javab.push_back(b[ras][j] + 1);
javab.push_back(ras + 1);
javab.push_back(b[ras][j + 1] + 1);
}
javab.push_back(b[ras][b[ras].size() - 1] + 1);
javab.push_back(ras + 1);
javab.push_back(a[ras][a[ras].size() - 1] + 1);
a[ras].pop_back();
}
if (a[ras].size() % 2 == 0)
for (int j = 0; j < a[ras].size(); j += 2) {
javab.push_back(a[ras][j] + 1);
javab.push_back(ras + 1);
javab.push_back(a[ras][j + 1] + 1);
}
else
for (int j = 0; j < a[ras].size() - 1; j += 2) {
javab.push_back(a[ras][j] + 1);
javab.push_back(ras + 1);
javab.push_back(a[ras][j + 1] + 1);
}
b[a[ras][a[ras].size() - 1]].push_back(ras);
}
}
for (int i = 0; i < javab.size(); i += 3)
cout << javab[i] << " " << javab[i + 1] << " " << javab[i + 2] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int xx[4] = {0, 0, 1, -1};
int yy[4] = {1, -1, 0, 0};
int n, m;
vector<int> a[int(1e5 + 100)];
vector<int> d[int(1e5 + 100)];
int cha[int(1e5 + 100)];
void dfs(int x) {
for (int i = (0), _b = (a[x].size() - 1); i <= _b; i++) {
int y = a[x][i];
if (y != cha[x]) {
cha[y] = x;
dfs(y);
if (d[y].size() % 2 == 1) {
d[y].push_back(x);
} else {
d[x].push_back(y);
}
}
}
}
int lab[int(1e5 + 100)];
int root(int x) {
while (lab[x] > 0) x = lab[x];
return x;
}
void uni(int x, int y) {
if (lab[x] > lab[y]) swap(x, y);
lab[x] += lab[y];
lab[y] = x;
}
int main() {
scanf("%d%d", &n, &m);
if (m % 2 == 1) {
cout << "No solution" << endl;
return 0;
}
for (int i = (1), _b = (n); i <= _b; i++) lab[i] = -1;
for (int i = (1), _b = (m); i <= _b; i++) {
int x, y;
scanf("%d%d", &x, &y);
int u = root(x);
int v = root(y);
if (u != v) {
uni(u, v);
a[x].push_back(y);
a[y].push_back(x);
} else {
d[x].push_back(y);
}
}
dfs(1);
for (int i = (1), _b = (n); i <= _b; i++)
for (int j = 0; j + 1 < d[i].size(); j += 2) {
printf("%d %d %d\n", d[i][j], i, d[i][j + 1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, h[N];
vector<int> e[N];
bool mark[N];
int dfs(int v, int p = 0) {
vector<int> vec;
mark[v] = 1;
for (auto u : e[v]) {
if (mark[u]) {
if (h[u] > h[v]) vec.push_back(u);
continue;
}
h[u] = h[v] + 1;
int x = dfs(u, v);
if (x != -1)
cout << x << ' ' << u << ' ' << v << "\n";
else if (h[u] > h[v])
vec.push_back(u);
}
int x = -1;
if (vec.size() & 1) {
x = vec.back();
vec.pop_back();
}
for (int i = 0; i < vec.size(); i += 2)
cout << vec[i] << ' ' << v << ' ' << vec[i + 1] << "\n";
return x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
if (m & 1) return cout << "No solution", 0;
while (m--) {
int u, v;
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000 + 5;
bool Mark[maxn];
vector<pair<int, int> > adj[maxn];
int decompose(int v) {
queue<int> q;
while (q.size()) q.pop();
for (int i = 0; i < adj[v].size(); i++) {
int e = adj[v][i].second;
if (!Mark[e]) {
q.push(adj[v][i].first);
Mark[e] = true;
}
}
int t = q.size();
for (int i = 0; i < t; i++) {
int nei = q.front();
int dc = decompose(nei);
if (dc == -1)
q.push(nei);
else
cout << v << " " << nei << " " << dc << endl;
q.pop();
}
t = q.size();
for (int i = 0; i < t - 1; i += 2) {
cout << q.front() << " " << v << " ";
q.pop();
cout << q.front() << endl;
q.pop();
}
if (t % 2 == 0) return -1;
return q.back();
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
adj[u].push_back(make_pair(v, i));
adj[v].push_back(make_pair(u, i));
}
if (m & 1) {
cout << "No solution" << endl;
return 0;
}
decompose(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, h[N];
vector<int> e[N];
bool mark[N];
void sfd(int v, int p = 0) {
mark[v] = 1;
h[v] = h[p] + 1;
for (auto u : e[v])
if (!mark[u]) sfd(u, v);
}
int dfs(int v, int p = 0) {
vector<int> vec;
mark[v] = 1;
for (auto u : e[v]) {
if (mark[u]) {
if (h[u] > h[v]) vec.push_back(u);
continue;
}
int x = dfs(u, v);
if (x != -1)
cout << x << ' ' << u << ' ' << v << "\n";
else if (h[u] > h[v])
vec.push_back(u);
}
int x = -1;
if (vec.size() & 1) {
x = vec.back();
vec.pop_back();
}
for (int i = 0; i < vec.size(); i += 2)
cout << vec[i] << ' ' << v << ' ' << vec[i + 1] << "\n";
return x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
if (m & 1) return cout << "No solution", 0;
while (m--) {
int u, v;
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
}
sfd(1);
memset(mark, 0, sizeof mark);
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int Maxn3 = 1e3 + 10;
const long long int Maxn4 = 1e4 + 10;
const long long int Maxn5 = 1e5 + 10;
const long long int Maxn6 = 1e6 + 10;
const long long int Maxn7 = 1e7 + 10;
const long long int Maxn8 = 1e8 + 10;
const long long int Maxn9 = 1e9 + 10;
const long long int Maxn18 = 1e18 + 10;
const long long int Mod1 = 1e7 + 7;
const long long int Mod2 = 1e9 + 7;
const long long int LLMax = LLONG_MAX;
const long long int LLMin = LLONG_MIN;
const long long int INTMax = INT_MAX;
const long long int INTMin = INT_MIN;
long long int mn = LLMax, mx = LLMin;
vector<long long int> g[Maxn6];
long long int h[Maxn6];
bool mark[Maxn6];
vector<pair<long long int, pair<long long int, long long int> > > res;
int dfs(long long int x, long long int p) {
mark[x] = 1;
vector<long long int> a, child;
for (long long int i = 0; i < g[x].size(); i++) {
long long int c = g[x][i];
if (c == p) continue;
if (mark[c]) {
if (h[c] < h[x]) a.push_back(c);
continue;
}
h[c] = h[x] + 1;
long long int t = dfs(c, x);
if (t == 1) child.push_back(c);
}
bool m = ((a.size() % 2) == 1), mm = ((child.size() % 2) == 1);
for (long long int i = 1; i < child.size(); i += 2) {
long long int u = child[i], v = child[i - 1];
res.push_back(make_pair(x, make_pair(u, v)));
}
for (long long int i = 1; i < a.size(); i += 2) {
long long int u = a[i], v = a[i - 1];
res.push_back(make_pair(x, make_pair(u, v)));
}
if (m and mm) {
res.push_back(
make_pair(x, make_pair(child[child.size() - 1], a[a.size() - 1])));
return 1;
}
if (m) {
res.push_back(make_pair(x, make_pair(a[a.size() - 1], p)));
return 0;
}
if (mm) {
res.push_back(make_pair(x, make_pair(child[child.size() - 1], p)));
return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, m;
cin >> n >> m;
if (m % 2 == 1) return cout << "No solution", 0;
for (long long int i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
g[u].push_back(v), g[v].push_back(u);
}
dfs(1, 1);
for (long long int i = 0; i < res.size(); i++)
cout << res[i].second.first << ' ' << res[i].first << ' '
<< res[i].second.second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& t) {
return in >> t.first >> t.second;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2>& t) {
return out << t.first << " " << t.second << endl;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& t) {
for (int i = 0; i < t.size(); i++) in >> t[i];
return in;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T>& t) {
for (int i = 0; i < t.size(); i++) out << t[i] << " ";
return out;
}
vector<int> is;
vector<vector<int>> answ;
struct G {
map<int, int> to;
};
vector<G> g;
int dfs1(int v, int p = -1) {
for (auto i : g[v].to) {
g[i.first].to.erase(v);
}
int last = -1;
for (auto it = g[v].to.begin(); it != g[v].to.end();) {
auto& i = *it;
int ans = dfs1(i.first, v);
if (ans != -1) {
answ.push_back({v, i.first, ans});
int t = i.first;
g[i.first].to.erase(ans);
g[v].to.erase(i.first);
it = g[v].to.upper_bound(t);
continue;
}
if (last == -1) {
last = i.first;
it++;
} else {
answ.push_back({last, v, i.first});
int t = i.first;
g[v].to.erase(last);
g[v].to.erase(i.first);
it = g[v].to.upper_bound(t);
last = -1;
continue;
}
}
return last;
}
int main() {
int n, m;
scanf(
"%"
"d",
&n);
scanf(
"%"
"d",
&m);
g.resize(n);
is.resize(m);
for (int i = 0; i < m; i++) {
int a, b;
scanf(
"%"
"d",
&a);
scanf(
"%"
"d",
&b);
a--;
b--;
g[a].to[b] = i;
g[b].to[a] = i;
}
if (dfs1(0) != -1) {
puts("No solution");
return 0;
}
for (int i = 0; i < answ.size(); i++) {
printf("%d %d %d\n", answ[i][0] + 1, answ[i][1] + 1, answ[i][2] + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int getint() {
unsigned int c;
int x = 0;
while (((c = getchar()) - '0') >= 10) {
if (c == '-') return -getint();
if (!~c) exit(0);
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while (((c = getchar()) - '0') < 10);
return x;
}
int getstr(char* s) {
int c, n = 0;
while ((c = getchar()) <= ' ') {
if (!~c) exit(0);
}
do {
s[n++] = c;
} while ((c = getchar()) > ' ');
s[n] = 0;
return n;
}
template <class T>
inline bool chmin(T& a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
inline bool chmax(T& a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class S, class T, class U>
struct Tuple {
S s;
T t;
U u;
Tuple() {}
Tuple(S s, T t, U u) : s(s), t(t), u(u) {}
bool operator==(const Tuple<S, T, U>& a) const {
return (s == a.s and t == a.t and u == a.u) ? 1 : 0;
}
bool operator!=(const Tuple<S, T, U>& a) const {
return !this->operator==(a);
}
};
template <class S>
struct Compare {
bool operator()(const S& a, const S& b) const {
if (a.s != b.s) return a.s < b.s;
if (a.t != b.t) return a.t < b.t;
if (a.u != b.u) return a.u < b.u;
return 0;
}
};
template <class S, class T, class U>
ostream& operator<<(ostream& os, const Tuple<S, T, U>& a) {
os << '(' << a.s << ' ' << a.t << ' ' << a.u << ')';
return os;
}
struct edge {
int to, rev, used;
edge(int to, int rev, int used) : to(to), rev(rev), used(used){};
edge() { used = 0; }
};
int n, m;
vector<edge> graph[100100];
vector<Tuple<int, int, int> > res;
void add_edge(int u, int v) {
int us = graph[u].size();
int vs = graph[v].size();
graph[u].push_back(edge(v, vs, 0));
graph[v].push_back(edge(u, us, 0));
}
int dfs(int u, int par) {
int i, j;
vector<int> child;
for (i = 0; i < graph[u].size(); i++) {
int v = graph[u][i].to;
if (graph[u][i].used == 1) continue;
graph[u][i].used = 1;
int revidx = graph[u][i].rev;
graph[v][revidx].used = 1;
if (v != par) {
int remu = dfs(v, u);
if (remu != -1) {
res.push_back(Tuple<int, int, int>(u + 1, v + 1, remu + 1));
} else {
child.push_back(v);
}
}
}
for (i = 0; i + 1 < child.size(); i += 2) {
res.push_back(Tuple<int, int, int>(child[i] + 1, u + 1, child[i + 1] + 1));
}
if (child.size() & 1) {
return child.back();
}
return -1;
}
int main() {
int i, j, tcc, tc = 1 << 28;
for (tcc = 0; tcc < tc; tcc++) {
n = getint(), m = getint();
for (i = 0; i < m; i++) {
int u = getint() - 1;
int v = getint() - 1;
add_edge(u, v);
}
if (m & 1) {
puts("No solution");
continue;
}
dfs(0, -1);
for (i = 0; i < res.size(); i++) {
cout << res[i].s << ' ' << res[i].t << ' ' << res[i].u << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const mxn = 2e5 + 10;
int r;
vector<pair<int, pair<int, int> > > ans, ans2;
vector<int> adj[mxn];
vector<int> back[mxn];
int mark[mxn];
void dfs(int v, int p) {
mark[v] = 1;
for (auto u : adj[v]) {
if (!mark[u]) {
dfs(u, v);
} else if (u != p) {
back[u].push_back(v);
}
}
for (int i = 0; i < back[v].size() - back[v].size() % 2; i += 2) {
ans.push_back({back[v][i], {v, back[v][i + 1]}});
}
if (back[v].size() % 2 == 1 and back[v][back[v].size() - 1] != r)
ans.push_back({back[v][back[v].size() - 1], {v, p}});
else
back[p].push_back(v);
return;
}
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 (!mark[i]) {
r = i;
dfs(i, 0);
}
}
if (m % 2 == 0) {
for (auto i : ans) {
if (i.first != 0 and i.second.first != 0 and i.second.second != 0)
ans2.push_back(i);
}
for (auto i : ans2) {
cout << i.first << " " << i.second.first << " " << i.second.second
<< endl;
}
} else
cout << "No solution";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
bool vis[MAX];
vector<int> g[MAX];
map<pair<int, int>, bool> M;
void DFS(int v, int par) {
vis[v] = 1;
int last = -1;
for (int i = 0; i < (int)g[v].size(); i++) {
int u = g[v][i];
if (!vis[u]) DFS(u, v);
if (M[make_pair(v, u)] == 1 && u != par) {
if (last == -1)
last = u;
else {
M[make_pair(v, u)] = M[make_pair(u, v)] = 0;
M[make_pair(v, last)] = M[make_pair(last, v)] = 0;
printf("%d %d %d\n", u, v, last);
last = -1;
}
}
}
if (last != -1) {
M[make_pair(v, par)] = M[make_pair(par, v)] = 0;
M[make_pair(v, last)] = M[make_pair(last, v)] = 0;
printf("%d %d %d\n", par, v, last);
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int sum = 0;
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
sum++;
g[a].push_back(b);
g[b].push_back(a);
M[make_pair(a, b)] = 1;
M[make_pair(b, a)] = 1;
}
if (sum % 2 == 0) {
DFS(1, -1);
} else
printf("No solution\n");
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> node[100001];
bool blocked[100000];
int partition(int v) {
queue<int> q;
for (int i = 0; i < node[v].size(); i++) {
int e = node[v][i].second;
if (blocked[e] == false) {
blocked[e] = true;
q.push(node[v][i].first);
}
}
int t = q.size();
for (int i = 0; i < t; i++) {
int top = q.front();
int neighbour = partition(top);
if (neighbour == 0)
q.push(top);
else
cout << v << " " << top << " " << neighbour << endl;
q.pop();
}
t = q.size();
for (int i = 0; i < t - 1; i += 2) {
cout << q.front() << " " << v << " ";
q.pop();
cout << q.front() << endl;
;
q.pop();
}
if (t % 2 == 0)
return 0;
else
return q.front();
}
int main() {
std::ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
if (m % 2) {
cout << "No solution" << endl;
return 0;
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
node[u].push_back(make_pair(v, i));
node[v].push_back(make_pair(u, i));
}
memset(blocked, false, sizeof(blocked));
partition(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, nx;
} e[200050];
int head[200050];
int num = 0;
bool bo[200050];
void addedge(int x, int y) {
e[num].to = y;
e[num].nx = head[x];
head[x] = num++;
}
bool ok[200050];
int gao(int now) {
ok[now] = true;
queue<int> q;
for (int p = head[now]; p != -1; p = e[p].nx) {
if (!bo[p]) {
q.push(e[p].to);
bo[p] = bo[p ^ 1] = true;
}
}
queue<int> p;
while (!q.empty()) {
int u = q.front();
q.pop();
int w = gao(u);
if (w != 0)
printf("%d %d %d\n", w, u, now);
else
p.push(u);
}
while (p.size() >= 2) {
int u, v;
u = p.front();
p.pop();
v = p.front();
p.pop();
printf("%d %d %d\n", u, now, v);
}
if (!p.empty())
return p.front();
else
return 0;
}
int main() {
int i, n, m;
num = 0;
memset(head, -1, sizeof(head));
memset(ok, 0, sizeof(ok));
memset(bo, 0, sizeof(bo));
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
addedge(x, y);
addedge(y, x);
}
if (m % 2)
printf("No solution\n");
else {
gao(1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<pair<int, int>> vec[N];
bool vis[N];
int solve(int v) {
vector<int> remain;
for (int i = 0; i < vec[v].size(); ++i) {
int u = vec[v][i].first, k;
if (!vis[vec[v][i].second]) {
vis[vec[v][i].second] = true;
k = solve(u);
if (k)
printf("%d %d %d\n", k, u, v);
else
remain.push_back(u);
}
}
while (remain.size() > 1) {
printf("%d %d ", remain.back(), v);
remain.pop_back();
printf("%d\n", remain.back());
remain.pop_back();
}
if (remain.size()) return remain[0];
return 0;
}
int main() {
int n, m, root;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
vec[a].push_back({b, i});
vec[b].push_back({a, i});
if (vec[a].size() > 1) root = a;
if (vec[b].size() > 1) root = b;
}
if (m & 1) {
printf("No solution\n");
return 0;
}
solve(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210000;
struct Edge {
int next, to;
Edge(int to = 0, int next = -1) : to(to), next(next) {}
};
int head[N], countedge;
Edge edge[N];
void AddEdge(const int& s, const int& t) {
edge[countedge] = Edge(t, head[s]);
head[s] = countedge++;
}
void init() {
memset(head, -1, sizeof(head));
countedge = 0;
}
bool vis[N];
int dfs(int u) {
int temp;
queue<int> que;
vector<int> unpair;
for (temp = head[u]; temp != -1; temp = edge[temp].next) {
int v = edge[temp].to;
if (vis[temp]) continue;
vis[temp] = true;
vis[temp ^ 1] = true;
que.push(v);
}
while (!que.empty()) {
int v = que.front();
que.pop();
int w = dfs(v);
if (w)
printf("%d %d %d\n", u, v, w);
else
unpair.push_back(v);
}
int len = unpair.size();
while (len >= 2) {
printf("%d %d %d\n", unpair[len - 1], u, unpair[len - 2]);
len -= 2;
}
if (len) return unpair[0];
return 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
init();
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
AddEdge(u, v);
AddEdge(v, u);
}
if (m & 1) {
printf("No solution\n");
return 0;
} else
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int N = 2e5 + 10;
int mark[N];
vector<int> g[N];
vector<pair<int, pair<int, int> > > ans;
bool dfs(int v, int par = 0) {
mark[v] = 1;
vector<int> V;
for (auto u : g[v]) {
if (!mark[u]) {
if (dfs(u, v)) {
V.push_back(u);
}
} else if (u != par && mark[u] == 1)
V.push_back(u);
}
mark[v] = 2;
for (int i = 1; i < V.size(); i += 2) {
ans.push_back({V[i], {v, V[i - 1]}});
}
if (V.size() % 2 != 0 && par != 0) {
ans.push_back({V[V.size() - 1], {v, par}});
return 0;
}
return 1;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
if (m % 2 == 1) return cout << "No solution", 0;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!mark[i]) dfs(i);
for (auto e : ans) {
cout << e.first << ' ' << e.second.first << ' ' << e.second.second << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(2e5) + 5;
const int inf = (int)1e9 + 7;
int n, m;
vector<pair<int, int> > g[N];
int ban[N];
int dfs(int v) {
vector<int> to;
for (pair<int, int> i : g[v]) {
if (ban[i.second]) {
continue;
}
ban[i.second] = 1;
to.push_back(i.first);
}
vector<int> all;
for (int i : to) {
int w = dfs(i);
if (w == 0) {
all.push_back(i);
} else {
printf("%d %d %d\n", w, i, v);
}
}
while ((int)all.size() >= 2) {
printf("%d %d %d\n", all.back(), v, all[(int)all.size() - 2]);
all.pop_back(), all.pop_back();
}
return all.empty() ? 0 : all.back();
}
int main() {
scanf("%d %d", &n, &m);
if (m & 1) {
printf("No solution");
return 0;
}
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d %d", &x, &y);
g[x].push_back({y, i});
g[y].push_back({x, i});
}
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
const int INF = 1e9 + 10;
int n, m;
int u, v;
bool vis[maxn];
struct Edge {
int v;
};
Edge e[maxn];
int en;
int head[maxn], nex[maxn];
void addedge(int u, int v) {
e[en].v = v;
nex[en] = head[u];
head[u] = en;
en++;
}
int dfs(int u, int f) {
int p[2], pn = 0;
for (int i = head[u]; ~i; i = nex[i]) {
int v = e[i].v;
if (v == f) continue;
if (vis[i] || vis[i ^ 1]) continue;
vis[i] = vis[i ^ 1] = 1;
int r = dfs(v, u);
if (r)
printf("%d %d %d\n", u, v, r);
else
p[pn++] = v;
if (pn == 2) printf("%d %d %d\n", p[0], u, p[1]), pn = 0;
}
return pn ? p[0] : 0;
}
void solve() {
if (m % 2) {
puts("No solution");
return;
}
memset(vis, 0, sizeof(vis));
dfs(1, 0);
}
int main() {
while (cin >> n >> m) {
memset(head, -1, sizeof(head));
memset(nex, -1, sizeof(nex));
en = 0;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > ans;
struct Edge {
int x, y, num, joft;
Edge(int p, int q, int w) {
x = p;
y = q;
num = w;
}
Edge() {}
int other(int p) {
if (p == y)
return x;
else
return y;
}
};
const int MAXN = 100000 + 100;
int n, m;
vector<int> v[MAXN];
Edge e[MAXN];
bool mark[MAXN];
int seen[MAXN];
void Input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
seen[i] = 0;
e[i] = Edge(x, y, i);
v[x].push_back(i);
v[y].push_back(i);
}
}
int par[MAXN];
void Dfs(int x) {
mark[x] = true;
for (int i = 0; i < v[x].size(); i++) {
int u = e[v[x][i]].other(x);
if (!mark[u]) {
par[u] = x;
Dfs(u);
}
}
vector<int> w;
int pp;
for (int i = 0; i < v[x].size(); i++) {
int u = e[v[x][i]].other(x);
int t = v[x][i];
if (seen[t] == 0)
if (u != par[x]) w.push_back(t);
if (e[v[x][i]].other(x) == par[x]) pp = v[x][i];
}
if (w.size() % 2 == 0) {
for (int i = 0; i < w.size(); i += 2) {
ans.push_back(make_pair(w[i], w[i + 1]));
seen[w[i]] = 1;
seen[w[i + 1]] = 1;
}
} else {
for (int i = 0; i < w.size(); i += 2) {
if (i == (w.size() - 1)) {
ans.push_back(make_pair(w[i], pp));
seen[pp] = 1;
seen[w[i]] = 1;
} else {
ans.push_back(make_pair(w[i], w[i + 1]));
seen[w[i]] = 1;
seen[w[i + 1]] = 1;
}
}
}
}
bool Check() {
for (int i = 0; i < m; i++)
if (!seen[i]) return 0;
return 1;
}
int main() {
Input();
if (m % 2 == 1) {
cout << "No solution" << endl;
return 0;
}
Dfs(1);
if (!Check() || ans.size() != (m / 2) || (m % 2) == 1)
cout << "No solution" << endl;
else {
for (int i = 0; i < ans.size(); i++) {
if (e[ans[i].first].x == e[ans[i].second].x)
cout << e[ans[i].first].y << " " << e[ans[i].first].x << " "
<< e[ans[i].second].y << endl;
else if (e[ans[i].first].x == e[ans[i].second].y)
cout << e[ans[i].first].y << " " << e[ans[i].first].x << " "
<< e[ans[i].second].x << endl;
else if (e[ans[i].first].y == e[ans[i].second].x)
cout << e[ans[i].first].x << " " << e[ans[i].first].y << " "
<< e[ans[i].second].y << endl;
else if (e[ans[i].first].y == e[ans[i].second].y)
cout << e[ans[i].first].x << " " << e[ans[i].first].y << " "
<< e[ans[i].second].x << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 100005;
int N, M, X, Y;
set<int> S[NMAX];
vector<int> V[NMAX];
bitset<NMAX> viz;
void DFS(int Node, int Father) {
for (vector<int>::iterator it = V[Node].begin(); it != V[Node].end(); it++)
if (!viz[*it]) {
viz[*it] = 1;
DFS(*it, Node);
}
if (S[Node].size() & 1) S[Node].erase(S[Node].find(Father));
for (set<int>::iterator it1 = S[Node].begin(); it1 != S[Node].end(); it1++) {
set<int>::iterator it2 = it1;
it2++;
printf("%d %d %d\n", *it1, Node, *it2);
S[*it1].erase(Node);
S[*it2].erase(Node);
it1 = it2;
}
}
int main() {
scanf("%d%d", &N, &M);
if (M & 1) {
printf("No solution\n");
return 0;
}
for (; M; M--) {
scanf("%d%d", &X, &Y);
V[X].push_back(Y);
V[Y].push_back(X);
S[X].insert(Y);
S[Y].insert(X);
}
viz[1] = 1;
DFS(1, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 100000 + 10;
int u[N << 1], v[N << 1], nt[N << 1], ft[N];
int n, m, cnt;
int vis[N << 1];
void add(int a, int b) {
u[cnt] = a;
v[cnt] = b;
nt[cnt] = ft[a];
ft[a] = cnt++;
}
int dfs(int x, int f) {
queue<int> vec;
for (int i = ft[x]; i != -1; i = nt[i]) {
int nx = v[i];
if (vis[i] || nx == f) continue;
vis[i] = vis[i ^ 1] = 1;
int r = dfs(nx, x);
if (r) {
printf("%d %d %d\n", x, nx, r);
} else {
vec.push(nx);
}
}
while (vec.size() >= 2) {
int a = vec.front();
vec.pop();
int b = vec.front();
vec.pop();
printf("%d %d %d\n", a, x, b);
}
if (!vec.empty()) {
int a = vec.front();
vec.pop();
return a;
}
return 0;
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
cnt = 0;
memset(ft, -1, sizeof ft);
memset(vis, 0, sizeof vis);
int a, b;
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
add(a, b);
add(b, a);
}
if (m & 1) {
puts("No solution");
continue;
}
dfs(1, -1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int first[maxn], nxt[maxn << 1], vv[maxn << 1];
bool vis[maxn];
int mark[maxn];
int edge[maxn];
void dfs(int n, int fa) {
vis[n] = true;
for (int e = first[n]; e; e = nxt[e])
if (vv[e] != fa && !vis[vv[e]]) dfs(vv[e], n);
int top = 0;
for (int e = first[n]; e; e = nxt[e])
if (vv[e] != fa && mark[vv[e]] != 1) edge[top++] = vv[e];
if (top & 1)
edge[top++] = fa, mark[n] = 1;
else
mark[n] = 2;
for (int i = 0; i < top; i += 2) {
printf("%d %d %d\n", edge[i], n, edge[i + 1]);
if (mark[edge[i]] == 2) mark[edge[i]] = 1;
if (mark[edge[i + 1]] == 2) mark[edge[i + 1]] = 1;
}
}
int main() {
int e = 2;
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
nxt[e] = first[u], vv[e] = v, first[u] = e++;
nxt[e] = first[v], vv[e] = u, first[v] = e++;
}
if (m & 1)
puts("No solution");
else
dfs(1, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') positive = 0;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline char RC() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long lcm(long long a, long long b, long long MOD) {
return a / gcd(a, b) * b % MOD;
}
inline long long Sub(long long x, long long y, long long mod) {
long long res = x - y;
while (res < 0) res += mod;
return res;
}
inline long long Add(long long x, long long y, long long mod) {
long long res = x + y;
while (res >= mod) res -= mod;
return res;
}
inline long long POW_MOD(long long x, long long y, long long mod) {
long long ret = 1;
while (y > 0) {
if (y & 1) ret = ret * x % mod;
x = x * x % mod;
y >>= 1;
}
return ret;
}
const int N = 100000 + 50;
const int inf = 2100000000;
const long long INF = 1LL << 60;
const double PI = 3.14159265358;
int n, m;
vector<int> e[N];
unordered_set<long long> mp;
int dfs(int u) {
vector<int> adj;
queue<int> unPairs;
for (int v : e[u]) {
long long id = min((long long)v * N + u, (long long)u * N + v);
if (mp.find(id) == mp.end()) {
adj.push_back(v);
mp.insert(id);
}
}
for (int v : adj) {
int w = dfs(v);
if (w)
printf("%d %d %d\n", u, v, w);
else
unPairs.push(v);
}
while (unPairs.size() >= 2) {
int v = unPairs.front();
unPairs.pop();
int w = unPairs.front();
unPairs.pop();
printf("%d %d %d\n", v, u, w);
}
if (unPairs.size()) {
return unPairs.front();
} else {
return 0;
}
}
int main() {
cin >> n >> m;
int cnt = 0;
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);
cnt++;
}
if (cnt & 1)
cout << "No solution" << endl;
else
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
#pragma clang diagnostic push
#pragma ide diagnostic ignored "cert-err58-cpp"
#pragma ide diagnostic ignored "cppcoreguidelines-pro-type-member-init"
using namespace std;
const int maxiii = 100022;
struct node {
bool seen;
vector<pair<int, bool>> Adj;
vector<int> B;
};
node graph[maxiii];
void dfs(int v, int p, int e) {
graph[v].seen = true;
for (int i = 0; i < graph[v].Adj.size(); ++i)
if (!graph[v].Adj[i].second) {
int u = graph[v].Adj[i].first;
if (!graph[u].seen)
dfs(u, v, i);
else if (u != p) {
graph[u].B.push_back(v);
graph[v].Adj[i].second = true;
}
}
if (graph[v].B.size() % 2 == 1)
graph[v].B.push_back(p);
else if (p != -1) {
graph[p].B.push_back(v);
graph[p].Adj[e].second = true;
}
for (int i = 0; i < graph[v].B.size(); i += 2)
cout << graph[v].B[i] << " " << v << " " << graph[v].B[i + 1] << "\n";
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
if (m % 2) {
cout << "No solution";
return 0;
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
graph[a].Adj.emplace_back(b, false);
graph[b].Adj.emplace_back(a, false);
}
dfs(1, -1, -1);
}
#pragma clang diagnostic pop
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
int bio[MAXN];
vector<int> E[MAXN];
int dfs(int x, int dad) {
bio[x] = 1;
int unused = -1;
for (int to : E[x]) {
if (to == dad) continue;
if (bio[to] == 0) {
int t = dfs(to, x);
if (t != -1)
printf("%d %d %d\n", t + 1, to + 1, x + 1);
else if (unused != -1) {
printf("%d %d %d\n", unused + 1, x + 1, to + 1);
unused = -1;
} else
unused = to;
} else if (bio[to] == 1) {
if (unused != -1) {
printf("%d %d %d\n", unused + 1, x + 1, to + 1);
unused = -1;
} else
unused = to;
}
}
bio[x] = 2;
return unused;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
E[a].push_back(b);
E[b].push_back(a);
}
if (m & 1) return printf("No solution\n"), 0;
dfs(0, -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
vector<int> adj[MAXN];
vector<int> edges[MAXN];
int cnt[MAXN], vis[MAXN];
int cont = 0;
int precalc(int v, int prev) {
int res = 0;
vis[v] = 1;
for (int i = 0; i < int((adj[v]).size()); ++i) {
int k = adj[v][i];
if (prev == k) continue;
if (vis[k] == 2) continue;
res++;
if (vis[k] == 0) res += precalc(k, v);
}
vis[v] = 2;
return cnt[v] = res;
}
void solve(int v, int prev) {
vis[v] = 1;
for (int i = 0; i < int((adj[v]).size()); ++i) {
int k = adj[v][i];
if (k == prev) continue;
if (vis[k] == 2) continue;
if (vis[k] == 1) {
edges[v].push_back(k);
} else {
if (cnt[k] & 1)
edges[k].push_back(v);
else
edges[v].push_back(k);
solve(k, v);
}
}
vis[v] = 2;
}
int main() {
int n, m;
while (scanf(" %d %d", &n, &m) != EOF) {
for (int i = 0; i < n; ++i) adj[i].clear(), edges[i].clear();
for (int i = 0; i < m; ++i) {
int a, b;
scanf(" %d %d", &a, &b);
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
if (m & 1) {
cout << "No solution" << endl;
} else {
memset(vis, 0, sizeof vis);
precalc(0, -1);
memset(vis, 0, sizeof vis);
solve(0, -1);
for (int i = 0; i < n; ++i) {
cont += int((edges[i]).size());
if (int((edges[i]).size()) & 1) cout << "opa" << endl;
for (int j = 0; j < int((edges[i]).size()); ++j) {
cout << (edges[i][j] + 1) << " " << (i + 1) << " "
<< (edges[i][j + 1] + 1) << endl;
j++;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 3;
int who[MAXN];
int kol[MAXN];
bool odw[MAXN];
set<int> v[MAXN];
vector<int> ans;
vector<int> tree[MAXN];
int ile = 0, kra = 0;
void DFS(int x) {
int k, me = ile;
who[me] = x;
odw[x] = true;
while (!v[x].empty()) {
k = *v[x].begin();
v[x].erase(v[x].begin());
v[k].erase(x);
ile++;
kra++;
tree[me].push_back(ile);
DFS(k);
}
}
bool DFS2(int x) {
vector<int> kat;
for (auto it : tree[x]) {
if (DFS2(it)) {
ans.push_back(who[x]);
ans.push_back(who[it]);
ans.push_back(kol[it]);
} else
kat.push_back(who[it]);
}
while (kat.size() > 1) {
ans.push_back(kat.back());
kat.pop_back();
ans.push_back(who[x]);
ans.push_back(kat.back());
kat.pop_back();
}
if (!kat.empty()) {
kol[x] = kat.back();
return true;
}
return false;
}
int main() {
int n, m;
int x, y;
scanf("%d %d", &n, &m);
while (m--) {
scanf("%d %d", &x, &y);
v[x].insert(y);
v[y].insert(x);
}
for (int i = 1; i <= n; i++) {
if (!odw[i]) {
ile++;
y = ile;
DFS(i);
if (kra % 2 != 0) {
printf("No solution");
return 0;
}
DFS2(y);
}
}
for (int i = 0; i < (int)(ans.size()); i += 3)
printf("%d %d %d\n", ans[i], ans[i + 1], ans[i + 2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<long long, long long> ll;
typedef vector<long long> vl;
typedef vector<ll> vll;
typedef vector<vl> vvl;
template <typename T>
ostream &operator<<(ostream &o, vector<T> v) {
if (v.size() > 0) o << v[0];
for (unsigned i = 1; i < v.size(); i++) o << " " << v[i];
return o << "\n";
}
template <typename U, typename V>
ostream &operator<<(ostream &o, pair<U, V> p) {
return o << "(" << p.first << ", " << p.second << ") ";
}
template <typename T>
istream &operator>>(istream &in, vector<T> &v) {
for (unsigned i = 0; i < v.size(); i++) in >> v[i];
return in;
}
template <typename T>
istream &operator>>(istream &in, pair<T, T> &p) {
in >> p.first;
in >> p.second;
return in;
}
vvl g(111000);
vl ind(111000, 0), vis(111000, false);
long long c = 0;
bool rec(long long node, long long p) {
vl ch;
ind[node] = c++;
vis[node] = 1;
for (auto &it : g[node]) {
if (it == p) continue;
if (!vis[it]) {
if (!rec(it, node)) ch.push_back((it));
} else if (ind[node] < ind[it])
ch.push_back((it));
}
for (long long i = 0; i + 1 < ch.size(); i += 2)
cout << ch[i] << " " << node << " " << ch[i + 1] << "\n";
if (ch.size() % 2 == 1) {
cout << p << " " << node << " " << ch[ch.size() - 1] << "\n";
return true;
}
return false;
}
int main() {
long long n, m;
cin >> n >> m;
if (m % 2 == 1) {
cout << "No solution"
<< "\n";
return 0;
}
while (m--) {
long long x, y;
cin >> x >> y;
g[x].push_back((y));
g[y].push_back((x));
}
rec(1, -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
char ch = getchar();
long long f = 1, x = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
const long long maxn = 1e5 + 10;
long long n, h[maxn], cnt, m;
struct edge {
long long v, next;
} e[maxn << 1];
void addedge(long long u, long long v) {
e[++cnt].v = v;
e[cnt].next = h[u];
h[u] = cnt;
}
void insert(long long u, long long v) {
addedge(u, v);
addedge(v, u);
}
stack<long long> g[maxn];
struct answers {
long long a, b, c;
} ans[maxn];
long long vis[maxn], tot;
bool no;
void dfs(long long u, long long fa) {
vis[u] = 1;
for (long long i = h[u]; i; i = e[i].next) {
long long v = e[i].v;
if (!vis[v])
dfs(v, u);
else if (v != fa) {
g[v].push(u);
}
}
while (g[u].size() >= 2) {
ans[++tot].a = g[u].top();
ans[tot].b = u;
g[u].pop();
ans[tot].c = g[u].top();
g[u].pop();
}
if (g[u].size() == 1) {
if (fa == 0) {
no = 1;
return;
}
long long x = g[u].top();
ans[++tot].a = x;
ans[tot].b = u;
ans[tot].c = fa;
g[u].pop();
} else {
g[fa].push(u);
}
}
signed main() {
n = read();
m = read();
if (m & 1) {
cout << "No solution\n";
return 0;
}
for (long long i = 1; i <= m; i++) {
insert(read(), read());
}
dfs(1, 0);
if (no) {
cout << "No solution\n";
return 0;
}
for (long long i = 1; i <= tot; i++) {
cout << ans[i].a << " " << ans[i].b << " " << ans[i].c << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 100;
bool mark[maxN];
vector<pair<int, int> > adj[maxN];
int n, m;
int decompose(int v) {
queue<int> q;
while (q.size()) q.pop();
for (int i = 0; i < adj[v].size(); i++) {
int e = adj[v][i].second;
if (!mark[e]) {
q.push(adj[v][i].first);
mark[e] = true;
}
}
int t = q.size();
for (int i = 0; i < t; i++) {
int nei = q.front();
int dc = decompose(nei);
if (dc == -1)
q.push(nei);
else
cout << v << " " << nei << " " << dc << endl;
q.pop();
}
t = q.size();
for (int i = 0; i < t - 1; i += 2) {
cout << q.front() << " " << v << " ";
q.pop();
cout << q.front() << endl;
q.pop();
}
if (t % 2 == 0) return -1;
return q.back();
}
void input() {
cin >> n >> m;
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
adj[u].push_back(make_pair(v, i));
adj[v].push_back(make_pair(u, i));
}
}
int main() {
input();
if (m & 1) {
cout << "No solution" << endl;
return 0;
}
decompose(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int T = 1e5 + 5;
struct node {
int num, x;
} t;
vector<node> p[T];
bool flag[T];
int dfs(int now) {
queue<int> q;
int l = p[now].size();
for (int i = 0; i < l; i++) {
node k = p[now][i];
if (flag[k.num])
continue;
else
flag[k.num] = 1;
int r = dfs(k.x);
if (r)
printf("%d %d %d\n", now, k.x, r);
else
q.push(k.x);
}
while (q.size() >= 2) {
int v1 = q.front();
q.pop();
int v2 = q.front();
q.pop();
printf("%d %d %d\n", v1, now, v2);
}
while (!q.empty()) {
int v3 = q.front();
q.pop();
return v3;
}
return 0;
}
int main() {
int n, m, a, b;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < n; i++) p[i].clear();
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
t.num = i;
t.x = a;
p[b].push_back(t);
t.x = b;
p[a].push_back(t);
}
if (m % 2 == 1)
printf("No solution\n");
else {
memset(flag, 0, sizeof(flag));
dfs(1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const long long mod = 1e9 + 7;
const double pi = acos(-1);
vector<vector<int> > adj(N);
map<pair<int, int>, bool> mp, vis;
pair<int, int> f(int x, int y) { return {min(x, y), max(x, y)}; }
bool sa5eef[N];
int dfs(int u) {
int ret = -1;
vector<int> meh;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (mp[f(u, v)]) continue;
meh.push_back(v);
mp[f(u, v)] = 1;
}
for (int i = 0; i < meh.size(); i++) {
int v = meh[i];
if (sa5eef[v]) continue;
int p = dfs(v);
if (p != -1) {
printf("%d %d %d\n", u, v, p);
vis[f(u, v)] = vis[f(v, p)] = 1;
}
}
for (int i = 0; i < meh.size(); i++) {
int v = meh[i];
if (!vis[f(u, v)]) {
if (ret == -1)
ret = v;
else {
printf("%d %d %d\n", v, u, ret);
ret = -1;
}
}
}
sa5eef[u] = 1;
return ret;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int x, y;
int cntr = 1;
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
if (m % 2)
puts("No solution");
else
dfs(1);
return 0;
}
long long fastpow(long long b, long long e) {
if (!e) return 1;
long long ret = fastpow(b, e / 2);
ret = (ret * ret) % mod;
if (e % 2) ret = (ret * b) % mod;
return ret;
}
long long modinv(long long x) { return fastpow(x, mod - 2); }
double torad(double ang) { return ang * pi / 180.0; }
|
#include <bits/stdc++.h>
using namespace std;
set<int> a[100005];
int dfs(int v) {
vector<int> adj;
for (auto it = a[v].begin(); it != a[v].end(); it++) {
adj.push_back(*it);
a[*it].erase(v);
}
a[v].clear();
vector<int> unpaired;
for (int i = 0; i < adj.size(); i++) {
int u = adj[i];
int w = dfs(u);
if (w == 0)
unpaired.push_back(u);
else
printf("%d %d %d\n", v, u, w);
}
adj.clear();
int i = (int)unpaired.size() - 1;
while (i >= 1) {
int u = unpaired[i];
int w = unpaired[i - 1];
printf("%d %d %d\n", u, v, w);
i -= 2;
}
if (i >= 0) {
unpaired.clear();
return unpaired[i];
} else {
unpaired.clear();
return 0;
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x].insert(y);
a[y].insert(x);
}
if (m % 2 == 0)
dfs(1);
else
cout << "No solution" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 123;
vector<int> v[maxn];
int n, m, High[maxn];
bool mark[maxn];
int Dfs(int Vert, int Dad) {
mark[Vert] = true;
vector<int> now;
now.clear();
for (__typeof(v[Vert].begin()) i = v[Vert].begin(); i != v[Vert].end(); ++i)
if (!mark[*i]) {
High[*i] = High[Vert] + 1;
if (Dfs(*i, Vert) == 1) now.push_back(*i);
} else if (*i != Dad and High[*i] < High[Vert])
now.push_back(*i);
while (now.size() >= 2) {
int x = now.back();
now.pop_back();
int y = now.back();
now.pop_back();
printf("%d %d %d\n", x, Vert, y);
}
if (now.empty())
return 1;
else {
printf("%d %d %d\n", now[0], Vert, Dad);
return 0;
}
}
int main() {
int fi, se;
cin >> n >> m;
if (m % 2) {
puts("No solution");
return 0;
}
while (m--) {
cin >> fi >> se;
v[fi].push_back(se);
v[se].push_back(fi);
}
Dfs(1, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int edge[100000 + 10], first[100000 + 10], nxt[100000 + 10 << 1];
bool v[100000 + 10];
int mark[100000 + 10], vv[100000 + 10 << 1];
void dfs(int n, int fa) {
v[n] = 1;
for (int e = first[n]; e != -1; e = nxt[e])
if (vv[e] != fa && !v[vv[e]]) dfs(vv[e], n);
int top = 0;
for (int e = first[n]; e != -1; e = nxt[e])
if (vv[e] != fa && mark[vv[e]] != 1) edge[top++] = vv[e];
if (top & 1)
edge[top++] = fa, mark[n] = 1;
else
mark[n] = 2;
for (int i = 0; i < top; i += 2) {
printf("%d %d %d\n", edge[i], n, edge[i + 1]);
if (mark[edge[i]] == 2) mark[edge[i]] = 1;
if (mark[edge[i + 1]] == 2) mark[edge[i + 1]] = 1;
}
}
int main(void) {
int e = 0;
int n, m;
scanf("%d %d", &n, &m);
memset(first, -1, sizeof(first));
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
nxt[e] = first[u], vv[e] = v;
first[u] = e++;
nxt[e] = first[v], vv[e] = u;
first[v] = e++;
}
if (m & 1)
printf("No solution\n");
else
dfs(1, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100005], s[100005], A, B, C;
int i, j, k, t, l, m, n, w, f[100005], V[10005];
int go(int v) {
vector<int> V;
for (int i = 0; i < g[v].size(); i++)
if (!f[s[v][i]]) {
f[s[v][i]] = 1;
w = go(g[v][i]);
if (w) {
A.push_back(v);
B.push_back(g[v][i]);
C.push_back(w);
} else
V.push_back(g[v][i]);
}
for (int i = 1; i < V.size(); i += 2)
A.push_back(V[i]), B.push_back(v), C.push_back(V[i - 1]);
if (V.size() % 2) return V.back();
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
s[x].push_back(i);
s[y].push_back(i);
}
for (i = 1; i <= n; i++)
if (go(i)) {
cout << "No solution" << endl;
return 0;
}
for (i = 0; i < A.size(); i++) printf("%d %d %d\n", A[i], B[i], C[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> adj(100005);
map<int, int> vis;
int vis2[100005], p[100005];
void DFS(int s, int edge) {
vis2[s] = 1;
deque<int> dq;
for (auto i = adj[s].begin(); i != adj[s].end(); i++) {
if (!vis2[i->first]) {
p[i->first] = s;
DFS(i->first, i->second);
if (vis[i->second]) {
vis[i->second] = 0;
dq.push_back(i->first);
}
} else if (vis[i->second] && p[s] != i->first) {
vis[i->second] = 0;
dq.push_back(i->first);
}
}
if (dq.size() % 2) {
vis[edge] = 0;
dq.push_back(p[s]);
}
while (!dq.empty()) {
printf("%d %d %d\n", dq.front(), s, dq.back());
dq.pop_front();
dq.pop_back();
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
if (m % 2) {
printf("No solution");
return 0;
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
adj[x].push_back(make_pair(y, i));
adj[y].push_back(make_pair(x, i));
vis[i] = 1;
}
DFS(1, 100006);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void die() {
cout << "No solution\n";
exit(0);
}
vector<int> edges[100005];
int ans[100005];
set<pair<int, int> > ret;
bool seen[100005];
void dfs(int curr, int par = -1) {
for (int out : edges[curr]) {
if (out == par) continue;
if (seen[out]) continue;
seen[out] = true;
dfs(out, curr);
if (ans[out] % 2 && ret.count({curr, out})) {
ans[out]++;
ans[curr]--;
ret.erase({curr, out});
ret.insert({out, curr});
}
if (ans[out] % 2 && ret.count({out, curr})) {
ans[out]--;
ans[curr]++;
ret.erase({out, curr});
ret.insert({curr, out});
}
}
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
ret.insert({a, b});
edges[a].push_back(b);
edges[b].push_back(a);
ans[a]++;
}
seen[1] = true;
dfs(1);
for (int i = 1; i <= n; i++) {
if (ans[i] % 2) die();
}
auto it = ret.begin();
while (it != ret.end()) {
cout << it->second << " " << it->first << " ";
it++;
cout << it->second << "\n";
it++;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 100 + 10;
vector<pair<int, bool> > g[maxn];
vector<int> ans[maxn];
int deg[2][maxn], mark[maxn];
int n, m;
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(make_pair(v, 1));
g[v].push_back(make_pair(u, 0));
deg[1][u]++, deg[0][v]++;
}
}
int dfs(int v, int par) {
int res = 0;
mark[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
pair<int, bool> u = g[v][i];
if (par == u.first) res = i;
if (!mark[u.first]) {
int x = dfs(u.first, v);
if (deg[1][u.first] % 2) {
deg[u.second][v]--, deg[!u.second][v]++;
g[v][i].second = !u.second, g[u.first][x].second = u.second;
}
}
}
return res;
}
int main() {
input();
if (m % 2) {
cout << "No solution";
return 0;
}
dfs(0, -1);
for (int i = 0; i < n; i++)
for (auto &u : g[i])
if (u.second) ans[i].push_back(u.first);
for (int i = 0; i < n; i++)
for (int j = 0; j < ans[i].size() / 2; j++)
cout << ans[i][j * 2] + 1 << " " << i + 1 << " " << ans[i][j * 2 + 1] + 1
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
bool a[100000 << 1];
int b[100000 << 1], c[100000 << 1], h[100000], n, m, i, x, y;
int go(int k) {
int i, t, x = -1;
for (i = h[k]; ~i; i = b[i])
if (!a[i]) {
a[i] = 1, a[i >= m ? i - m : i + m] = 1;
t = go(c[i]);
if (~t)
printf("%d %d %d\n", k + 1, c[i] + 1, t + 1);
else if (~x)
printf("%d %d %d\n", x + 1, k + 1, c[i] + 1), x = -1;
else
x = c[i];
}
return ~x ? x : -1;
}
int main() {
scanf("%d%d", &n, &m);
if (m & 1) {
puts("No solution");
return 0;
}
for (i = 0; i < m * 2; i++) c[i] = -1;
for (i = 0; i < n; i++) h[i] = -1;
for (i = 0; i < m; ++i) {
scanf("%d%d", &x, &y);
--x, --y;
b[i] = h[x];
c[i] = y;
h[x] = i;
b[i + m] = h[y];
c[i + m] = x;
h[y] = i + m;
}
go(0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T>
inline T sqr(T x) {
return x * x;
}
const double eps = 1e-10;
const double pi = acos(-1.0);
const long long INF = 1LL << 62;
const int inf = 1 << 29;
vector<pair<int, int> > graph[100010];
bool used[100010];
int n, m;
int dfs(int cur) {
int l = -1, r;
for (int i = (0); i < (graph[cur].size()); ++i) {
int m = graph[cur][i].first;
if (used[graph[cur][i].second]) continue;
used[graph[cur][i].second] = true;
r = dfs(graph[cur][i].first);
if (r == -1) {
if (l == -1) {
l = m;
} else {
cout << l << " " << cur << " " << m << endl;
l = -1;
}
} else
cout << cur << " " << m << " " << r << endl;
}
return l;
}
int main(void) {
scanf("%d %d", &n, &m);
for (int i = (0); i < (m); ++i) {
int f, t;
scanf("%d %d", &f, &t);
pair<int, int> in;
in.second = i;
in.first = t;
graph[f].push_back(in);
in.first = f;
graph[t].push_back(in);
}
if (m & 1) {
printf("No solution\n");
return 0;
}
for (int i = (0); i < (100010); ++i) used[i] = false;
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct node {
int v;
node* next;
} E[N + N], *tot, *head[N];
int n, m, u, v, clk, dfn[N], cnt, ans[N][3];
void add(int u, int v) {
tot->v = v;
tot->next = head[u];
head[u] = tot++;
}
void pc(int a, int b, int c) {
ans[cnt][0] = a;
ans[cnt][1] = b;
ans[cnt][2] = c;
++cnt;
}
int dfs(int u) {
int ret = 0;
dfn[u] = ++clk;
for (node* p = head[u]; p; p = p->next) {
int v = p->v;
if (!dfn[v]) {
int w = dfs(v);
if (w)
pc(u, v, w);
else {
if (ret) {
pc(v, u, ret);
ret = 0;
} else
ret = v;
}
} else if (dfn[v] > dfn[u]) {
if (ret) {
pc(v, u, ret);
ret = 0;
} else
ret = v;
}
}
return ret;
}
void print() {
for (int i = 0; i < cnt; ++i) {
printf("%d %d %d\n", ans[i][0], ans[i][1], ans[i][2]);
}
}
int main() {
tot = E;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
if (m & 1)
printf("No solution\n");
else {
dfs(1);
print();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], b[maxn];
vector<pair<int, int>> G[maxn];
bool v[maxn], use[maxn];
struct data {
int a, b, c;
};
vector<data> ans;
void dfs(int now, int fa, int edge) {
v[now] = true;
int nxt = -1, cid = -1;
for (auto u : G[now])
if (u.first != fa) {
if (!v[u.first]) dfs(u.first, now, u.second);
if (use[u.second]) continue;
if (nxt == -1)
nxt = u.second, cid = u.first;
else if (nxt != -1) {
ans.emplace_back((data){u.first, now, cid});
use[nxt] = use[u.second] = true;
nxt = -1;
cid = -1;
}
}
if (nxt != -1) {
if (edge && !use[edge] && !use[nxt]) {
ans.emplace_back((data){cid, now, fa});
use[edge] = use[nxt] = true;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
if (m & 1) return cout << "No solution" << endl, 0;
for (int i = 1; i <= m; ++i) {
cin >> a[i] >> b[i];
G[a[i]].emplace_back(b[i], i);
G[b[i]].emplace_back(a[i], i);
}
for (int i = 1; i <= n; ++i) {
if (!v[i]) dfs(i, 0, 0);
}
if (ans.size() < m / 2) return cout << "No solution" << endl, 0;
for (auto e : ans) cout << e.a << ' ' << e.b << ' ' << e.c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max1 = 100010;
long long a[max1], b[max1];
int main() {
int n, x, y = 0, z = 0;
cin >> n;
if (n == 1) {
cout << "NO\n";
} else {
for (int i = 0; i < n; i++) {
cin >> x;
if (x == 200) {
z++;
}
y += x;
}
if ((y % 200 == 0)) {
if ((z == n) && (z % 2 != 0)) {
cout << "NO\n";
} else {
cout << "YES\n";
}
} else {
cout << "NO\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
long long a[n];
long long sum = 0;
map<int, int> m;
for (size_t i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
m[a[i]]++;
}
for (size_t i = 0; i <= m[100]; i++) {
for (size_t j = 0; j <= m[200]; j++) {
if (i * 100 + j * 200 == sum - (i * 100 + j * 200)) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void striker() {
int n;
cin >> n;
int a1 = 0, a2 = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x == 100)
a1++;
else
a2++;
}
if (n & 1 == 1 && (a1 == 0 || a2 == 0))
cout << "NO";
else if (2 * (a1 / 2) + a2 == n)
cout << "YES";
else
cout << "NO";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
for (int i = 0; i < t; i++) {
striker();
cout << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.