text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 9;
int n, p[N], deg[N];
vector<int> G[N];
unordered_set<int> ust[N][2];
int dfs(int u, int p) {
int sz = 1;
for (int v : G[u])
if (v != p) {
int tmp = dfs(v, u);
ust[u][tmp & 1].insert(v);
sz += tmp;
}
if (p) ust[u][(n - sz) & 1].insert(p);
return sz;
}
bool vis[N];
void solve() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", p + i);
if (!p[i]) continue;
G[p[i]].push_back(i);
G[i].push_back(p[i]);
}
dfs(1, 0);
queue<int> Q;
vector<int> vc;
for (int i = 1; i <= n; ++i) {
if (ust[i][0].empty() && (~ust[i][1].size() & 1u)) {
Q.push(i);
vis[i] = true;
}
}
while (!Q.empty()) {
int u = Q.front();
Q.pop();
vc.push_back(u);
for (int v : G[u])
if (!vis[v]) {
ust[v][0].erase(u);
ust[v][1].erase(u);
if (ust[v][0].empty() && (~ust[v][1].size() & 1u)) {
Q.push(v);
vis[v] = true;
}
}
}
if ((int)vc.size() == n) {
printf("YES\n");
for (int u : vc) printf("%d\n", u);
} else {
printf("NO\n");
}
}
int main() {
int T = 1;
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> e[N];
int n, cnt[N];
void dfs(int x, int fa) {
cnt[x] = 1;
int len = e[x].size();
for (int i = 0; i < len; i++) {
if (e[x][i] == fa) continue;
dfs(e[x][i], x);
cnt[x] += cnt[e[x][i]];
}
}
void solve(int x, int fa) {
int len = e[x].size();
for (int i = 0; i < len; i++) {
if (e[x][i] == fa) continue;
if (cnt[e[x][i]] % 2 == 0) {
solve(e[x][i], x);
}
}
printf("%d\n", x);
for (int i = 0; i < len; i++) {
if (e[x][i] == fa) continue;
if (cnt[e[x][i]] % 2 == 1) {
solve(e[x][i], x);
}
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x == 0) continue;
e[i].push_back(x);
e[x].push_back(i);
}
dfs(1, 0);
if (cnt[1] & 1) {
printf("YES\n");
solve(1, 0);
} else {
printf("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int nextInt() {
int x;
scanf("%d", &x);
return x;
}
string nextString() {
string s;
cin >> s;
return s;
}
const int MAXN = 2e5;
vector<int> G[MAXN + 10];
int num[MAXN + 10];
int f[MAXN + 10];
vector<int> order;
void dfs(int v) {
for (auto u : G[v]) {
dfs(u);
}
order.push_back(v);
}
int main() {
int n = nextInt();
int root = -1;
for (int i = (1); i <= (n); ++i) {
int x = nextInt();
if (x == 0)
root = i;
else
num[i]++, num[x]++;
G[x].push_back(i);
f[i] = x;
}
dfs(root);
vector<int> ans0;
vector<int> ans1;
for (auto i : order) {
if (num[i] & 1) {
if (i == root) {
cout << "NO\n";
return 0;
}
ans1.push_back(i);
} else {
num[f[i]]--;
ans0.push_back(i);
}
}
reverse(begin(ans1), end(ans1));
ans0.insert(ans0.end(), begin(ans1), end(ans1));
cout << "YES\n";
for (auto i : ans0) {
cout << i << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 100000 + 100;
vector<int> e[N];
bool mark[N], del[N];
int n, cnt, par[N];
void destruct(int v) {
del[v] = true;
cout << v + 1 << endl;
for (int i = 0; i < e[v].size(); i++) {
int u = e[v][i];
if (u != par[v] && !del[u]) destruct(u);
}
}
int dfs(int v) {
mark[v] = true;
int s = 0, d = 0;
for (int i = 0; i < e[v].size(); i++) {
int u = e[v][i];
if (!mark[u]) {
par[u] = v;
int x = dfs(u);
s += x;
}
}
if (s % 2) destruct(v);
return s + 1;
}
int main() {
cin >> n;
if (n % 2 == 0) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (int i = 0; i < n; i++) {
int v;
cin >> v;
if (v == 0) continue;
v--;
e[v].push_back(i);
e[i].push_back(v);
}
dfs(0);
destruct(0);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graf[200005], stek;
bool mark[200005];
int root;
void dfsd(int s) {
if (mark[s]) return;
mark[s] = true;
stek.push_back(s);
for (int i = 0; i < graf[s].size(); i++) dfsd(graf[s][i]);
}
void dfs(int s) {
int deg = 0;
if (s != root) deg++;
for (int i = 0; i < graf[s].size(); i++) {
dfs(graf[s][i]);
if (!mark[graf[s][i]]) deg++;
}
if (deg % 2 == 0) dfsd(s);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
graf[t].push_back(i);
if (t == 0) root = i;
}
dfs(root);
if (stek.size() < n)
printf("NO");
else {
printf("YES\n");
for (int i = 0; i < n; i++) printf("%d\n", stek[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
stack<int> s;
int deg[200005];
int vis[200005];
int p[200005];
vector<int> ne[200005];
vector<int> ans;
void dfs(int u) {
s.push(u);
for (int i = 0; i < ne[u].size(); i++) {
dfs(ne[u][i]);
}
}
void dfs2(int u) {
vis[u] = 1;
ans.push_back(u);
for (int i = 0; i < ne[u].size(); i++) {
int v = ne[u][i];
deg[v]--;
if (!vis[v] && deg[v] % 2 == 0) {
dfs2(v);
}
}
deg[p[u]]--;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
deg[i] = 0;
}
for (int i = 1; i <= n; i++) {
vis[i] = 0;
cin >> p[i];
ne[p[i]].push_back(i);
if (p[i]) {
deg[i]++;
deg[p[i]]++;
}
}
if (n % 2 == 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
int root = ne[0][0];
dfs(root);
while (!s.empty()) {
int u = s.top();
s.pop();
if (!vis[u] && deg[u] % 2 == 0) {
dfs2(u);
}
}
for (int i = 0; i < n; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int xx = 0, ff = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
xx = xx * 10 + ch - '0';
ch = getchar();
}
return xx * ff;
}
const int maxn = 200010;
int N, root;
int lin[maxn], len, deg[maxn];
struct edge {
int y, next;
} e[maxn << 1];
inline void insert(int xx, int yy) {
e[++len].next = lin[xx];
lin[xx] = len;
e[len].y = yy;
deg[xx]++;
}
bool v[maxn];
int cnt[maxn][2];
bool dfs(int x, int fa) {
for (int i = lin[x]; i; i = e[i].next)
if (e[i].y != fa) cnt[x][dfs(e[i].y, x)]++;
if ((deg[x] - cnt[x][1]) % 2 == 0)
v[x] = 1;
else
v[x] = 0;
return v[x];
}
void print(int x, int fa) {
for (int i = lin[x]; i; i = e[i].next)
if (e[i].y != fa)
if (v[e[i].y]) print(e[i].y, x);
printf("%d\n", x);
for (int i = lin[x]; i; i = e[i].next)
if (e[i].y != fa)
if (!v[e[i].y]) print(e[i].y, x);
}
int main() {
N = read();
for (int i = 1; i <= N; i++) {
int temp = read();
if (!temp)
root = i;
else
insert(i, temp), insert(temp, i);
}
if (dfs(root, 0)) {
puts("YES");
print(root, 0);
} else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[200002], d[200002];
vector<int> ch[200002];
vector<int> ans, buf;
void bfs(int pos) {
for (int c : ch[pos]) bfs(c);
if (d[pos] & 1) {
buf.push_back(pos);
} else {
ans.push_back(pos);
d[p[pos]]--;
}
}
int main() {
int n;
cin >> n;
int root = 0;
for (int i = 1; i <= n; i++) {
cin >> p[i];
if (p[i] == 0) {
root = i;
} else {
ch[p[i]].push_back(i);
}
d[i]++;
d[p[i]]++;
}
if (n % 2 == 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
bfs(root);
for (int a : ans) cout << a << endl;
reverse(buf.begin(), buf.end());
for (int b : buf) cout << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int tot, z;
int head[1000010];
struct node {
int from;
int to;
int w;
int next;
} edge[1000010];
void add(int from, int to, int w) {
edge[tot].from = from;
edge[tot].to = to;
edge[tot].w = w;
edge[tot].next = head[from];
head[from] = tot++;
}
int vis[200100];
int deg[200100];
int ans[200100];
int n, tt, root;
void des(int p, int pre) {
vis[p] = 1;
ans[tt++] = p;
for (int i = head[p]; i != -1; i = edge[i].next) {
int v = edge[i].to;
deg[v]--;
if (v == pre) continue;
if (vis[v] == 0) {
if (deg[v] % 2 == 0) {
des(v, p);
}
}
}
}
bool dfs(int Q, int P) {
bool Ok = deg[Q] & 1;
for (int i = head[Q]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (v != P) Ok ^= dfs(v, Q);
}
if (!Ok) des(Q, P);
return !Ok;
}
int main() {
memset(head, -1, sizeof(head));
tot = 0;
tt = 0;
memset(ans, 0, sizeof(ans));
memset(deg, 0, sizeof(deg));
memset(vis, 0, sizeof(vis));
cin >> n;
if (n % 2 == 0) {
cout << "NO" << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
int aa;
cin >> aa;
if (aa == 0) {
root = i;
continue;
}
add(aa, i, 0);
add(i, aa, 0);
deg[aa]++;
deg[i]++;
}
cout << "YES" << endl;
dfs(root, 0);
for (int i = 0; i < tt; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int nxt() {
int x;
scanf("%d", &x);
return x;
}
const int N = 222222;
vector<int> a[N];
int sz[N];
int par[N];
void dfsSize(int v, int p = -1) {
for (int x : a[v]) {
if (x == p) {
continue;
}
dfsSize(x, v);
sz[v] += sz[x];
}
par[v] = p;
++sz[v];
}
vector<int> ans;
void dfs(int v) {
for (int x : a[v]) {
if (x == par[v]) {
continue;
}
if (sz[x] % 2 == 0) {
dfs(x);
}
}
ans.push_back(v);
for (int x : a[v]) {
if (x == par[v]) {
continue;
}
if (sz[x] % 2) {
dfs(x);
}
}
}
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n = nxt();
for (int i = 0; i < n; ++i) {
int u = nxt() - 1, v = i;
if (u == -1) {
continue;
}
a[u].push_back(v);
a[v].push_back(u);
}
if (n % 2 == 0) {
cout << "NO\n";
return 0;
}
dfsSize(0);
dfs(0);
printf("YES\n");
for (int x : ans) {
printf("%d\n", x + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modexpo(long long x, long long p) {
long long res = 1;
x = x % 1000000007;
while (p) {
if (p % 2) res = res * x;
p >>= 1;
x = x * x % 1000000007;
res %= 1000000007;
}
return res;
}
struct compare {
bool operator()(const pair<long long, long long> a,
const pair<long long, long long> b) const {
return a.first < b.first;
}
};
const long long nax = 2e5 + 5;
vector<long long> g[nax];
long long deg[nax];
long long n, root;
vector<long long> ans;
set<long long> s;
void topdowndfs(long long x, long long p) {
ans.push_back(x);
s.insert(x);
for (long long i : g[x]) {
if (i != p && s.find(i) == s.end()) {
topdowndfs(i, x);
}
}
}
void dfs(long long x, long long p) {
for (long long i : g[x]) {
if (i != p) {
dfs(i, x);
}
}
if (deg[x] % 2 == 0) {
topdowndfs(x, p);
deg[p]--;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
if (x == 0) {
root = i;
} else {
g[i].push_back(x);
g[x].push_back(i);
deg[i]++;
deg[x]++;
}
}
dfs(root, root);
if (ans.size() == n) {
cout << "YES\n";
for (long long i : ans) {
cout << i << " ";
}
cout << "\n";
} else {
cout << "NO"
<< "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
unordered_set<int> g[200005];
bool gone[200005];
void dfs1(int u, int p) {
printf("%d\n", u);
gone[u] = true;
for (auto v : g[u]) {
if (v == p) continue;
dfs1(v, u);
}
}
void dfs(int u, int p) {
if (gone[u]) return;
for (auto itr = g[u].begin(); itr != g[u].end();) {
int v = *itr;
auto nitr = next(itr);
if (v == p) {
itr = nitr;
continue;
}
dfs(v, u);
itr = nitr;
}
if (g[u].size() && (g[u].size() & 1) == 0) {
printf("%d\n", u);
gone[u] = true;
for (auto itr = g[u].begin(); itr != g[u].end();) {
int v = *itr;
auto nitr = next(itr);
g[u].erase(v);
g[v].erase(u);
if (v != p) {
dfs1(v, u);
}
itr = nitr;
}
}
}
int main() {
memset(gone, 0, sizeof(gone));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int u = i;
int v;
scanf("%d", &v);
if (v == 0) continue;
g[u].insert(v);
g[v].insert(u);
}
if ((n & 1) == 0) {
printf("NO\n");
return (0);
}
printf("YES\n");
dfs(1, 0);
for (int i = 1; i <= n; i++) {
if (gone[i] == false) printf("%d\n", i);
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> g[N];
bool seen[N][2], dp[N][2];
vector<pair<int, int> > bk[N][2];
bool solve(int i, bool p, int par);
void back(int i, bool p);
int main() {
int n;
cin >> n;
int root = -1;
for (int i = 1; i <= n; ++i) {
int p;
cin >> p;
if (!p) {
root = i;
} else {
g[i].push_back(p);
g[p].push_back(i);
}
}
if (solve(root, 0, 0)) {
cout << "YES\n";
back(root, 0);
} else {
cout << "NO\n";
}
}
bool solve(int i, bool p, int par) {
if (seen[i][p]) {
return dp[i][p];
}
seen[i][p] = true;
int tot = 0, codd = 0, ceven = 0, both = 0;
for (auto &j : g[i]) {
if (j == par) {
continue;
} else {
++tot;
int o = solve(j, 1, i);
int e = solve(j, 0, i);
if (!o and !e) {
dp[i][p] = false;
return false;
}
codd += o;
ceven += e;
}
}
if (tot % 2 == p) {
if ((tot - ceven) % 2) {
dp[i][p] = false;
} else {
dp[i][p] = true;
for (auto &j : g[i]) {
if (j != par and !solve(j, 0, i)) {
bk[i][p].push_back({j, 1});
}
}
bk[i][p].push_back({i, p});
for (auto &j : g[i]) {
if (j != par and solve(j, 0, i)) {
bk[i][p].push_back({j, 0});
}
}
}
} else {
if (!codd) {
dp[i][p] = false;
} else if ((codd - both) % 2) {
dp[i][p] = true;
for (auto &j : g[i]) {
if (j != par and !solve(j, 0, i)) {
bk[i][p].push_back({j, 1});
}
}
bk[i][p].push_back({i, p});
for (auto &j : g[i]) {
if (j != par and solve(j, 0, i)) {
bk[i][p].push_back({j, 0});
}
}
} else if (both) {
dp[i][p] = true;
int k = 0;
for (auto &j : g[i]) {
if (j != par and solve(j, 0, i) and solve(j, 1, i)) {
bk[i][p].push_back({j, 1});
k = j;
break;
}
}
for (auto &j : g[i]) {
if (j != par and !solve(j, 0, i)) {
bk[i][p].push_back({j, 1});
}
}
bk[i][p].push_back({i, p});
for (auto &j : g[i]) {
if (j != par and solve(j, 0, i) and j != k) {
bk[i][p].push_back({j, 0});
}
}
} else {
dp[i][p] = false;
}
}
return dp[i][p];
}
void back(int i, bool p) {
for (auto &cur : bk[i][p]) {
if (cur.first == i) {
cout << i << '\n';
} else {
back(cur.first, cur.second);
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-O2")
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
const int LIM = 2e5 + 5, MOD = 1e9 + 7;
int t, n, m, k, x, y;
vector<vector<int> > v;
vector<int> deg;
vector<int> nchild;
int dfs(int i, int par) {
int ans = 1;
for (auto &it : v[i])
if (it != par) ans += dfs(it, i);
return nchild[i] = ans;
}
bool vs[LIM];
void solve(int i, int par) {
if (vs[i]) return;
if (deg[i] == 0) {
cout << i + 1 << endl;
vs[i] = 1;
return;
}
int neven = 0;
for (auto &it : v[i])
if (!vs[it] && it != par && !(nchild[it] & 1)) neven++;
if (neven == 0 && !(deg[i] & 1)) {
cout << i + 1 << endl;
vs[i] = 1;
deg[i] = 0;
for (auto &it : v[i]) deg[it]--;
for (auto &it : v[i])
if (!vs[it] && it != par) solve(it, i);
} else {
for (auto &it : v[i])
if (!vs[it] && it != par) solve(it, i);
neven = 0;
for (auto &it : v[i])
if (!vs[it] && it != par && !(nchild[it] & 1)) neven++;
if (neven == 0 && !(deg[i] & 1)) {
cout << i + 1 << endl;
vs[i] = 1;
deg[i] = 0;
for (auto &it : v[i]) deg[it]--;
for (auto &it : v[i])
if (!vs[it] && it != par) solve(it, i);
} else {
return;
}
}
}
int main() {
cin >> n;
if (!(n & 1)) {
cout << "NO" << endl;
return 0;
}
v.assign(n, vector<int>(0));
deg.assign(n, 0);
nchild.assign(n, 0);
for (int i = 0; i < n; i++) {
cin >> x;
if (x == 0) continue;
x--;
deg[x]++;
deg[i]++;
v[x].push_back(i);
v[i].push_back(x);
}
dfs(0, -1);
cout << "YES\n";
solve(0, -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double PI = acos(-1);
int n, i, j, k, t;
vector<int> adj[200002], ans;
bool deleted[200002];
int sz[200002];
void dfs(int v, int p) {
for (int x : adj[v]) {
if (x == p) continue;
if (sz[x] % 2 == 0) {
dfs(x, v);
deleted[x] = true;
}
}
ans.push_back(v);
for (int x : adj[v]) {
if (x == p || deleted[x]) continue;
dfs(x, v);
}
}
void getsz(int v, int p) {
sz[v] = 1;
for (int x : adj[v]) {
if (x == p) continue;
getsz(x, v);
sz[v] += sz[x];
}
}
int main() {
memset(deleted, false, sizeof deleted);
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", &t);
if (t) {
adj[t].push_back(i);
adj[i].push_back(t);
}
}
if (n % 2 == 0) {
puts("NO");
return 0;
}
getsz(1, 1);
dfs(1, 1);
puts("YES");
for (int x : ans) printf("%d\n", x);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
char c = getchar();
int num = 0;
while ('0' > c || c > '9') c = getchar();
while ('0' <= c && c <= '9') num = num * 10 + c - '0', c = getchar();
return (num);
}
vector<int> e[400010];
vector<pair<int, int> > s[400010][2];
int f[400010][2], d[400010], n, m;
inline void Dp(int x, int y) {
for (int i = 0; i < e[x].size(); i++)
s[x][1].push_back(make_pair(-1, -1)), s[x][0].push_back(make_pair(-1, -1));
if (d[x] == 1 && y) {
f[x][0] = 1;
return;
}
int g0 = -1, g1 = -1;
for (int i = 0; i < e[x].size(); i++)
if (e[x][i] != y) {
Dp(e[x][i], x);
if (g0 == -1) {
if (f[e[x][i]][0]) g0 = 1, s[x][0][i] = make_pair(0, 0);
if (f[e[x][i]][1]) g1 = 1, s[x][1][i] = make_pair(1, 1);
if (g0 == -1) g0 = 0;
if (g1 == -1) g1 = 0;
continue;
}
int g0_ = g0, g1_ = g1;
g0 = g1 = 0;
if (g0_ && f[e[x][i]][1]) g1 = 1, s[x][1][i] = make_pair(0, 1);
if (g1_ && f[e[x][i]][0]) g1 = 1, s[x][1][i] = make_pair(1, 0);
if (g1_ && f[e[x][i]][1]) g0 = 1, s[x][0][i] = make_pair(1, 1);
if (g0_ && f[e[x][i]][0]) g0 = 1, s[x][0][i] = make_pair(0, 0);
}
if (x == 1) {
if (d[x] % 2 == 0)
f[x][0] = g0;
else
f[x][0] = g1;
} else {
if (d[x] % 2 == 0)
f[x][0] = g1, f[x][1] = g0;
else
f[x][0] = g0, f[x][1] = g1;
}
}
inline void Write(int x, int y, int w) {
if (x == 1) {
if (d[x] % 2 == 1) w ^= 1;
} else {
if (d[x] % 2 == 0) w ^= 1;
}
int w0 = w;
for (int i = e[x].size() - 1; i >= 0; i--)
if (e[x][i] != y) {
if (s[x][w][i].second == 1) Write(e[x][i], x, s[x][w][i].second);
w = s[x][w][i].first;
}
printf("%d\n", x);
if (x == 4) int deb = 0;
w = w0;
for (int i = e[x].size() - 1; i >= 0; i--)
if (e[x][i] != y) {
if (s[x][w][i].second == 0) Write(e[x][i], x, s[x][w][i].second);
w = s[x][w][i].first;
}
}
int p[400010];
int main() {
n = Read();
for (int i = 1; i <= n; i++) {
p[i] = Read();
if (p[i]) {
e[i].push_back(p[i]), e[p[i]].push_back(i);
d[p[i]]++, d[i]++;
}
}
Dp(1, 0);
if (!f[1][0]) {
puts("NO");
return (0);
}
puts("YES");
Write(1, 0, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[1000050], d[1000050], tim[1000050], ind[1000050];
set<int> e[1000050];
vector<int> g[1000050];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
int main() {
int n, i, x, vs, curx, curd, next, size;
pair<int, int> pa;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &x);
if (x) {
e[x].insert(i);
e[i].insert(x);
d[x]++;
d[i]++;
}
}
for (i = 1; i <= n; i++) q.push(make_pair(d[i], i));
for (; !q.empty();) {
pa = q.top();
curx = pa.second;
curd = pa.first;
q.pop();
if (d[curx] != curd) continue;
arr[++vs] = curx;
if (d[curx]) {
next = *e[curx].begin();
d[curx]--;
d[next]--;
e[curx].erase(next);
e[next].erase(curx);
q.push(make_pair(d[next], next));
if (tim[curx] % 2 == 0) {
tim[next]++;
g[next].push_back(curx);
ind[curx]++;
} else {
g[curx].push_back(next);
ind[next]++;
}
} else if (tim[curx] & 1) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
for (; !q.empty(); q.pop())
;
for (i = 1; i <= n; i++) q.push(make_pair(ind[i], i));
for (; !q.empty();) {
pa = q.top();
curx = pa.second;
curd = pa.first;
q.pop();
if (ind[curx] != curd) continue;
printf("%d\n", curx);
size = g[curx].size();
for (i = 0; i < size; i++) {
ind[g[curx][i]]--;
q.push(make_pair(ind[g[curx][i]], g[curx][i]));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, root, p[200001];
vector<int> ans, ch[200001], before[200001], after[200001];
bool vis[200001], par[200001];
void dfs(int u) {
if (ch[u].size() == 0) {
par[u] = false;
return;
}
for (int c : ch[u]) {
dfs(c);
if (par[c])
before[u].push_back(c);
else
after[u].push_back(c);
}
par[u] = after[u].size() % 2;
}
void get_ans(int u) {
for (int c : before[u]) get_ans(c);
ans.push_back(u);
for (int c : after[u]) get_ans(c);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
ch[i] = vector<int>();
before[i] = vector<int>();
after[i] = vector<int>();
}
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
p[i]--;
if (p[i] >= 0)
ch[p[i]].push_back(i);
else
root = i;
}
dfs(root);
if (par[root]) {
printf("NO\n");
return 0;
}
ans = vector<int>();
get_ans(root);
printf("YES\n%d", ans[0] + 1);
for (int i = 1; i < n; i++) printf(" %d", ans[i] + 1);
printf("\n");
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename T>
void _R(T& x) {
cin >> x;
}
template <typename T>
void _R(vector<T>& x) {
for (auto it = x.begin(); it != x.end(); it++) {
_R(*it);
}
}
void R() {}
template <typename T, typename... K>
void R(T& head, K&... tail) {
_R(head);
R(tail...);
}
template <typename T>
void _W(const T& x, const char c) {
cout << x;
}
template <typename T>
void _W(const vector<T>& x, const char c) {
for (auto it = x.cbegin(); it != x.cend(); it++) {
if (it != x.cbegin()) putchar(c);
_W(*it, c);
}
}
void W() {}
template <typename T, typename... K>
void W(const T& head, const K&... tail) {
_W(head, ' ');
cout << (sizeof...(tail) ? ' ' : '\n') << flush;
W(tail...);
}
const double PI =
3.14159265358979323846264338327950288419716939937510582097494459230;
template <typename T>
inline T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
inline void amin(T& x, T y) {
if (x > y) x = y;
}
template <typename T>
inline void amax(T& x, T y) {
if (x < y) x = y;
}
template <typename A, typename B>
class comp {
public:
bool operator()(const pair<A, B>& a, const pair<A, B>& b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.first > b.first;
}
};
long long fast_exp(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1LL) {
res *= a;
res %= 1000000007;
}
b >>= 1LL;
a *= a;
a %= 1000000007;
}
return res;
}
const int N = 200005;
int n;
vector<int> g[N];
vector<int> a;
bool b[N];
map<int, bool> m[N];
void preprocess(void) { return; }
bool dfs(int u, int p) {
int cnt = 0;
for (auto v : (g[u])) {
if (v == p) continue;
bool f = dfs(v, u);
m[u][v] = f;
if (f) cnt++;
}
if (p == -1) {
if ((cnt)&1)
return false;
else
return true;
}
cnt++;
if (cnt & 1)
return true;
else
return false;
}
void answ(int u, int p) {
for (auto v : (g[u])) {
if (v == p) continue;
if (!m[u][v]) {
answ(v, u);
}
}
a.push_back(u);
for (auto v : (g[u])) {
if (v == p) continue;
if (m[u][v]) {
answ(v, u);
}
}
}
signed main(int argc, char* argv[], char* envp[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
preprocess();
int teeee;
teeee = 1;
for (int zeeee = (1); zeeee <= (teeee); zeeee++) {
cin >> n;
for (int i = (0); i <= ((int)(n)-1); i++) {
int p;
cin >> p;
if (p == 0) continue;
p--;
g[i].push_back(p);
g[p].push_back(i);
}
fill(b, b + n, false);
bool ans = dfs(0, -1);
if (ans) {
cout << "YES\n";
answ(0, -1);
for (auto v : a) {
cout << v + 1 << "\n";
}
} else {
cout << "NO\n";
}
}
cerr << (((double)clock()) / ((double)CLOCKS_PER_SEC)) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[200005];
bool vis[200005] = {false};
long long degree[200005] = {0};
vector<long long> ans;
long long dfs(long long s) {
vis[s] = true;
long long i, ans = 0;
for (i = 0; i < adj[s].size(); i++) {
if (!vis[adj[s][i]]) ans += dfs(adj[s][i]);
}
degree[s] = ans + 1;
return degree[s];
}
void dfs1(long long s) {
vis[s] = true;
long long i;
for (i = 0; i < adj[s].size(); i++) {
if (!vis[adj[s][i]] && degree[adj[s][i]] % 2 == 0) dfs1(adj[s][i]);
}
ans.push_back(s);
for (i = 0; i < adj[s].size(); i++) {
if (!vis[adj[s][i]] && degree[adj[s][i]] % 2 == 1) dfs1(adj[s][i]);
}
}
int main() {
long long n, i, j, temp;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> temp;
if (temp == 0) continue;
adj[i].push_back(temp);
adj[temp].push_back(i);
}
if (n % 2 == 0) {
cout << "NO"
<< "\n";
return 0;
}
dfs(1);
for (i = 1; i <= n; i++) vis[i] = false;
dfs1(1);
cout << "YES"
<< "\n";
for (i = 0; i < ans.size(); i++) cout << ans[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int maxn = 2e5 + 11;
int N, M, T, P, Q;
list<int> G[maxn];
bool ok = 1;
int deg[maxn];
bool dele[maxn];
list<int> ans;
void del(int u, int pu) {
if (dele[u]) return;
dele[u] = 1;
ans.push_back(u);
for (int v : G[u]) {
if (v == pu) continue;
del(v, u);
}
}
void dfs(int u = 1, int pu = -1) {
for (int v : G[u]) {
if (v == pu) continue;
dfs(v, u);
if (dele[v]) deg[u]--;
}
if (deg[u] % 2 == 0) del(u, pu);
}
int main() {
cin >> N;
for (int i = 1, j; i <= N; i++) {
scanf("%d", &j);
if (j) G[i].push_back(j), G[j].push_back(i);
}
for (int i = 1; i <= N; i++) deg[i] = G[i].size();
dfs();
if (ans.size() < N)
puts("NO");
else {
puts("YES");
for (int x : ans) printf("%d\n", x);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
vector<int> g[N];
int sz[N];
bool vis[N];
int lvl[N];
void dfs(int node, int par) {
for (int nxt : g[node]) {
if (nxt == par) continue;
lvl[nxt] = lvl[node] + 1;
dfs(nxt, node);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int root;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (!x) {
root = i;
continue;
}
g[x].push_back(i);
g[i].push_back(x);
}
memset(sz, 0, sizeof(sz));
memset(vis, 0, sizeof(vis));
memset(lvl, 0, sizeof(lvl));
dfs(root, 0);
set<pair<int, int> > ss;
for (int i = 1; i <= n; i++) {
sz[i] = g[i].size();
if (sz[i] % 2 == 0) {
ss.insert(make_pair(lvl[i], i));
}
}
vector<int> vec;
while (ss.size()) {
pair<int, int> p = *ss.rbegin();
int node = p.second;
vec.push_back(node);
vis[node] = true;
ss.erase(prev(ss.end()));
for (int nxt : g[node]) {
if (vis[nxt]) continue;
sz[nxt]--;
if (sz[nxt] & 1) {
ss.erase(make_pair(lvl[nxt], nxt));
} else
ss.insert(make_pair(lvl[nxt], nxt));
}
}
if (vec.size() != n) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (int x : vec) {
cout << x << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sz[200001];
bool mark[200001];
set<int> tree[200001];
vector<int> destroy;
void predfs(int u, int p) {
sz[u] = 1;
for (int v : tree[u]) {
if (v != p) {
predfs(v, u);
sz[u] += sz[v];
}
}
}
void dfs(int u, int p) {
vector<int> rest;
for (int v : tree[u]) {
if (mark[v]) continue;
if (v != p && sz[v] % 2 == 0) {
dfs(v, u);
} else if (v != p) {
rest.push_back(v);
}
}
mark[u] = true;
destroy.push_back(u);
for (int v : rest) {
dfs(v, -1);
}
}
int main() {
int n, p;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> p;
if (p) {
tree[i].insert(p);
tree[p].insert(i);
}
}
if (n % 2 == 0) {
cout << "NO" << endl;
return 0;
}
fill(mark, mark + n + 1, false);
predfs(1, -1);
dfs(1, -1);
cout << "YES" << endl;
for (int u : destroy) {
cout << u << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
set<int> E[202020];
set<int> cand;
int C[202020];
vector<int> V;
int dfs(int cur, int pre) {
C[cur] = 1;
for (auto& e : E[cur])
if (e != pre) C[cur] += dfs(e, cur);
return C[cur];
}
void dfs2(int cur, int pre) {
if (C[cur] % 2 == 1) {
for (auto& e : E[cur])
if (e != pre) {
if (C[e] % 2 == 0) dfs2(e, cur);
}
V.push_back(cur);
for (auto& e : E[cur])
if (e != pre) {
if (C[e] % 2 == 1) dfs2(e, cur);
}
} else {
for (auto& e : E[cur])
if (e != pre) {
if (C[e] % 2 == 0) dfs2(e, cur);
}
V.push_back(cur);
for (auto& e : E[cur])
if (e != pre) {
if (C[e] % 2 == 1) dfs2(e, cur);
}
}
}
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N;
if (N % 2 == 0) return (void)printf("NO\n");
for (i = 1; i <= N; i++) {
cin >> x;
if (x) {
E[i].insert(x);
E[x].insert(i);
}
}
dfs(1, 1);
dfs2(1, 1);
cout << "YES" << endl;
for (auto& v : V) cout << v << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return {i, j};
}
struct printer {
~printer() { cerr << endl; }
template <class c>
printer& operator,(c x) {
cerr << boolalpha << x;
return *this;
}
printer& operator,(string x) {
cerr << x;
return *this;
}
template <class c, class d>
printer& operator,(pair<c, d> x) {
return *this, "(", x.first, ", ", x.second, ")";
}
template <class... d, template <class...> class c>
printer& operator,(c<d...> x) {
return *this, range(begin(x), end(x));
}
template <class c>
printer& operator,(rge<c> x) {
*this, "[";
for (auto it = x.b; it != x.e; ++it) *this, (it == x.b ? "" : ", "), *it;
return *this, "]";
}
};
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int my_rand(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
const int N = 200009;
vector<int> vec[N];
int ar[N], degree[N], level[N];
struct node {
int u, lv, id;
bool operator<(const node& p) const { return p.lv > lv; }
};
void dfs(int u, int par, int lv) {
level[u] = lv;
int v, i, sz = vec[u].size();
for (i = 0; i < sz; i++) {
v = vec[u][i];
if (v != par) {
dfs(v, u, lv + 1);
}
}
}
int main() {
int n, i, r;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &r);
if (r == 0) continue;
vec[i].push_back(r);
vec[r].push_back(i);
degree[r]++;
degree[i]++;
}
if (n % 2 == 0) {
printf("NO\n");
return 0;
}
for (i = 1; i <= n; i++) {
if (degree[i] == 1) {
dfs(i, -1, 0);
break;
}
}
priority_queue<node> pq;
for (i = 1; i <= n; i++) {
if (degree[i] % 2 == 0) pq.push({i, level[i], 0});
}
vector<int> ans;
while (!pq.empty()) {
node top = pq.top();
pq.pop();
if (top.id != ar[top.u]) continue;
ans.push_back(top.u);
int sz = vec[top.u].size();
for (i = 0; i < sz; i++) {
int v = vec[top.u][i];
if (degree[v] > 0) {
degree[v]--;
ar[v]++;
if (degree[v] == 0)
ans.push_back(v);
else if (degree[v] % 2 == 0) {
pq.push({v, level[v], ar[v]});
}
}
}
degree[top.u] = 0;
}
int sz = ans.size();
printf("YES\n");
for (i = 0; i < sz; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int maxm = 1e6 + 10;
const int INF = 0x3f3f3f3f;
int casn, n, m, k;
int st, pre[maxn], deg[maxn];
int to[maxn], nex[maxn], head[maxn], nume;
int dfn[maxn], cnt, ans1[maxn], ans2[maxn], cnt2;
void dfs(int now) {
for (int i = head[now]; i; i = nex[i]) {
if (to[i] != now) dfs(to[i]);
}
dfn[++cnt] = now;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> pre[i];
deg[pre[i]]++;
if (pre[i]) {
deg[i]++;
to[++nume] = i;
nex[nume] = head[pre[i]];
head[pre[i]] = nume;
} else
st = i;
}
dfs(st);
cnt = 0;
for (int i = 1; i < n; i++) {
if (deg[dfn[i]] & 1) {
ans2[++cnt2] = dfn[i];
} else
ans1[++cnt] = dfn[i], deg[pre[dfn[i]]]--;
}
if (deg[dfn[n]] & 1)
cout << "NO\n";
else {
ans1[++cnt] = dfn[n];
cout << "YES\n";
for (int i = 1; i <= cnt; i++) cout << ans1[i] << '\n';
for (int i = cnt2; i; i--) cout << ans2[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200050;
vector<int> graf[maxn];
int dp[2][maxn];
vector<int> data[maxn];
int n, root;
vector<int> v;
void bejar(int start) {
for (int s : graf[start]) {
if (dp[1][s]) {
bejar(s);
}
}
v.push_back(start);
for (int s : graf[start]) {
if (dp[0][s]) {
bejar(s);
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
int z;
cin >> z;
z--;
if (z >= 0) {
graf[z].push_back(i);
} else {
root = i;
}
}
vector<int> sor;
vector<int> apa;
sor.push_back(root);
int it = 0;
while (it < sor.size()) {
int akt = sor[it];
for (int s : graf[akt]) {
sor.push_back(s);
}
it++;
}
reverse(sor.begin(), sor.end());
for (int i = 0; i < n; i++) {
int akt = sor[i];
if (graf[akt].size() == 0) {
dp[0][akt] = true;
dp[1][akt] = false;
} else {
int with_akt = 0;
for (int s : graf[akt]) {
if (dp[0][s]) {
with_akt++;
}
}
if (with_akt % 2 == 0) {
dp[0][akt] = true;
dp[1][akt] = false;
} else {
dp[0][akt] = false;
dp[1][akt] = true;
}
}
}
if (dp[0][root]) {
cout << "YES" << endl;
bejar(root);
for (int d : v) {
cout << d + 1 << endl;
}
return 0;
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int xx = 0, ff = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
xx = xx * 10 + ch - '0';
ch = getchar();
}
return xx * ff;
}
const int maxn = 200010;
int N, root;
int lin[maxn], len, deg[maxn];
struct edge {
int y, next;
} e[maxn << 1];
inline void insert(int xx, int yy) {
e[++len].next = lin[xx];
lin[xx] = len;
e[len].y = yy;
deg[xx]++;
}
bool v[maxn];
int cnt[maxn][2];
bool dfs(int x, int fa) {
for (int i = lin[x]; i; i = e[i].next)
if (e[i].y != fa) cnt[x][dfs(e[i].y, x)]++;
if ((deg[x] - cnt[x][1]) % 2 == 0)
v[x] = 1;
else
v[x] = 0;
return v[x];
}
void print(int x, int fa) {
for (int i = lin[x]; i; i = e[i].next)
if (e[i].y != fa)
if (v[e[i].y]) print(e[i].y, x);
printf("%d\n", x);
for (int i = lin[x]; i; i = e[i].next)
if (e[i].y != fa)
if (!v[e[i].y]) print(e[i].y, x);
}
int main() {
N = read();
for (int i = 1; i <= N; i++) {
int temp = read();
if (!temp)
root = i;
else
insert(i, temp), insert(temp, i);
}
if (dfs(root, 0)) {
puts("YES");
print(root, 0);
} else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1147483646;
const long long MX2 = 9223372036854775800;
const int MOD = 1e9 + 9;
int n;
vector<int> tr[200011];
vector<int> destr[200011];
int sz[200011];
bool des[200011], visited[200011];
void dest(int& id) {
cout << id << "\n";
des[id] = 1;
for (int x : destr[id]) sz[x]--;
return;
}
void dfs(int id) {
bool rep = 1;
if (visited[id] && !des[id] && sz[id] % 2 == 0) {
rep = 0;
dest(id);
}
visited[id] = 1;
for (int x : tr[id]) {
if (des[x]) continue;
dfs(x);
}
if (!des[id] && sz[id] % 2 == 0) {
dest(id);
for (int x : tr[id]) {
if (des[x]) continue;
dfs(x);
}
}
return;
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
int i, x;
cin >> n;
int rt;
for (i = 1; i <= n; i++) {
cin >> x;
if (x) {
tr[x].push_back(i);
destr[x].push_back(i);
destr[i].push_back(x);
sz[i]++;
sz[x]++;
} else
rt = i;
}
if (n & 1) {
cout << "YES\n";
dfs(rt);
} else {
cout << "NO";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string itosm(long long x) {
if (x == 0) return "0";
string ans = "";
while (x > 0) {
ans += ((x % 10) + '0');
x /= 10;
}
reverse(ans.begin(), ans.end());
return ans;
}
long long stoim(string str) {
long long ans = 0;
long long k = 1;
int p = 0;
if (str[0] == '-') p++;
for (int i = str.length() - 1; i >= p; i--) {
ans += (str[i] - '0') * k;
k *= 10;
}
return ans;
}
const long long infll = 1e18 + 3;
const int inf = 1009000999;
const long double eps = 1e-7;
const int maxn = 1e6 + 1146;
const int baseint = 1000200013;
const long long basell = 1e18 + 3;
const long double PI = acos(-1.0);
const long long mod = 1e9 + 9;
vector<int> g[maxn];
int d[maxn];
int lvl[maxn];
bool del[maxn];
void dfs(int v, int an) {
for (int to : g[v]) {
if (to == an) continue;
lvl[to] = lvl[v] + 1;
dfs(to, v);
}
}
void solve() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "NO";
return;
}
int t;
cout << "YES\n";
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x == 0) {
t = i;
continue;
}
g[i].push_back(x);
g[x].push_back(i);
}
dfs(t, -1);
set<pair<int, int> > q;
for (int v = 1; v <= n; v++) {
d[v] = g[v].size();
if (g[v].size() % 2 == 0) q.insert({lvl[v], v});
}
vector<int> ans;
while (!q.empty()) {
int v = (*q.rbegin()).second;
q.erase({lvl[v], v});
ans.push_back(v);
del[v] = 1;
for (int to : g[v]) {
d[to]--;
if (d[to] % 2 == 0) {
if (!del[to]) q.insert({lvl[to], to});
} else {
q.erase({lvl[to], to});
}
}
}
for (int v : ans) cout << v << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
;
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
int B = 400;
using namespace std;
const long long inf = 1e12;
int MOD = 1e9 + 9;
const int mxn = 200010;
int deg[mxn];
bool del[mxn];
vector<int> ans;
vector<int> g[mxn];
void dell(int v, int p) {
if (del[v] != 0) return;
if (deg[v] % 2 != 0) return;
del[v] = 1;
ans.push_back(v);
for (int u : g[v]) deg[u]--;
for (int u : g[v]) {
if (!del[u] && u != p) dell(u, v);
}
}
void dfs(int v, int p) {
for (int u : g[v]) {
if (u != p) dfs(u, v);
}
if (deg[v] % 2 == 0) dell(v, p);
}
long long res = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
if (!a) continue;
g[i].push_back(a);
g[a].push_back(i);
deg[a]++, deg[i]++;
}
dfs(1, -1);
if (ans.size() == n) {
cout << "YES" << endl;
for (int u : ans) cout << u << endl;
} else
cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> G[N];
stack<int> S;
int in[N];
int pre[N];
int fa[N];
int dfss;
void dfs(int u, int fas) {
pre[u] = dfss++;
fa[u] = fas;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == fas) continue;
dfs(v, u);
}
if (in[u] % 2 == 1) S.push(u);
if (in[u] % 2 == 0) {
printf("%d\n", u);
in[fa[u]]--;
while (!S.empty()) {
int s = S.top();
if (pre[s] < pre[u]) break;
S.pop();
printf("%d\n", s);
in[fa[s]]--;
}
}
}
int main() {
int n;
scanf("%d", &n);
int x;
dfss = 0;
memset(in, 0, sizeof(in));
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (x == 0) continue;
in[x]++;
in[i]++;
G[i].push_back(x);
G[x].push_back(i);
}
if (n % 2 == 0) {
puts("NO");
return 0;
}
printf("YES\n");
dfs(1, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
int n, root;
int sz[N + 5];
vector<int> v[N + 5];
void dfs1(int nod) {
int ans = 0;
for (auto nou : v[nod]) {
dfs1(nou);
ans += sz[nou];
}
sz[nod] = ans + 1;
}
void dfs(int nod) {
for (auto nou : v[nod])
if (sz[nou] % 2 == 0) dfs(nou);
cout << nod << "\n";
for (auto nou : v[nod])
if (sz[nou] % 2 == 1) dfs(nou);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int nod = 1; nod <= n; nod++) {
int t;
cin >> t;
if (t == 0)
root = nod;
else
v[t].push_back(nod);
}
if (n % 2 == 0) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
dfs1(root);
dfs(root);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[200000 + 20];
bool mitParentKante[200000 + 20];
bool ohneParentKante[200000 + 20];
void dfs(int i, int parent) {
if (adj[i].size() == 1 && parent != -1) {
ohneParentKante[i] = true;
mitParentKante[i] = false;
return;
}
bool geradeAnzahlOhne = true;
for (int child : adj[i]) {
if (child != parent) {
dfs(child, i);
if (!mitParentKante[child] && !ohneParentKante[child]) {
cout << "NO" << endl;
exit(0);
}
if (ohneParentKante[child]) {
geradeAnzahlOhne = !geradeAnzahlOhne;
}
if (mitParentKante[child]) {
}
}
}
if (geradeAnzahlOhne) {
ohneParentKante[i] = true;
mitParentKante[i] = false;
} else {
ohneParentKante[i] = false;
mitParentKante[i] = true;
};
}
void deleteDFS(int i, int parent) {
for (int child : adj[i]) {
if (child != parent) {
;
;
;
if (mitParentKante[child]) {
deleteDFS(child, i);
}
}
}
cout << i + 1 << endl;
for (int child : adj[i]) {
if (child != parent) {
if (ohneParentKante[child]) {
deleteDFS(child, i);
}
}
}
}
int32_t main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int v;
cin >> v;
v--;
if (v != -1) {
adj[v].push_back(i);
adj[i].push_back(v);
}
}
dfs(0, -1);
if (!ohneParentKante[0]) {
cout << "NO" << endl;
exit(0);
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
;
;
;
}
deleteDFS(0, -1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, root;
vector<int> adj[N];
int dp[N][2], deg[N];
bool mark[N];
void dfs(int u, int pre) {
for (int v : adj[u]) {
if (v == pre) continue;
dfs(v, u);
}
for (int p = 0, _n = (2); p < _n; p++) {
int d = (deg[u] + ((p == 0 && pre != -1) ? -1 : 0));
vector<int> ban;
for (int v : adj[u])
if (v != pre) {
if (!dp[v][0]) ban.push_back(v);
}
bool flag = false;
for (int v : ban) {
if (!dp[v][1]) {
flag = true;
break;
}
}
if (flag) continue;
if ((d - ban.size()) % 2 == 1) {
flag = true;
for (int v : adj[u])
if (v != pre && dp[v][0]) {
if (dp[v][1]) flag = false;
}
if (flag) continue;
}
dp[u][p] = 1;
}
}
void print_ans(int u, int pre, int p) {
int d = (deg[u] + ((p == 0 && pre != -1) ? -1 : 0)), cnt = 0;
for (int v : adj[u])
if (v != pre) {
if (!dp[v][0]) {
cnt++;
print_ans(v, u, 1);
mark[v] = 1;
}
}
if ((d - cnt) % 2 == 1) {
for (int v : adj[u])
if (v != pre && dp[v][0] && dp[v][1]) {
print_ans(v, u, 1);
mark[v] = 1;
break;
}
}
cout << u << '\n';
for (int v : adj[u])
if (v != pre && !mark[v]) print_ans(v, u, 0);
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
clock_t tStart = clock();
cin >> n;
for (int i = (1), _b = (n); i <= _b; i++) {
int j;
cin >> j;
if (j == 0)
root = i;
else {
adj[i].push_back(j);
adj[j].push_back(i);
deg[i]++;
deg[j]++;
}
}
dfs(root, -1);
if (!dp[root][0]) {
cout << "NO" << '\n';
return 0;
} else {
cout << "YES" << '\n';
print_ans(root, -1, 0);
}
fprintf(stderr, "Time taken: %.2fs\n",
(double)(clock() - tStart) / CLOCKS_PER_SEC);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 9;
const int N = 2e5 + 10;
vector<int> v[N];
vector<int> v2[N];
int sons[N];
int flag[N];
vector<int> ans;
void dfs2(int x) {
ans.push_back(x);
for (auto &y : v2[x]) dfs2(y);
}
bool dfs(int x, int p = 0) {
if (p) sons[x] = 1;
for (auto &y : v[x]) {
dfs(y, x);
sons[x]++;
}
flag[x] = sons[x] & 1;
if (flag[x] == 0) {
ans.push_back(x);
for (auto &y : v2[x]) {
dfs2(y);
}
sons[p]--;
} else {
if (p == 0)
return false;
else
v2[p].push_back(x);
}
return true;
}
int main() {
int n;
cin >> n;
int rt = 0;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
v[x].push_back(i);
}
if (dfs(v[0].back())) {
puts("YES");
for (auto &x : ans) printf("%d\n", x);
} else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 2e5 + 5;
int n;
vector<int> adj[maxn];
int deg[maxn];
bool used[maxn];
int sz[maxn];
void dfsSize(int i, int p) {
sz[i] = 1;
for (int j : adj[i]) {
if (j == p) continue;
dfsSize(j, i);
sz[i] += sz[j];
}
}
vector<int> ans;
void dfs(int i, int p) {
for (int j : adj[i]) {
if (j == p) continue;
if (!(sz[j] & 1)) {
dfs(j, i);
}
}
ans.push_back(i);
for (int j : adj[i]) {
if (j == p) continue;
if (sz[j] & 1) {
dfs(j, i);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
if (!(n & 1)) {
cout << "NO\n";
return 0;
}
for (int i = 1; i <= n; i++) {
int p;
cin >> p;
if (p != 0) {
adj[i].push_back(p);
adj[p].push_back(i);
deg[i]++;
deg[p]++;
}
}
dfsSize(1, 1);
dfs(1, 1);
cout << "YES\n";
for (int i : ans) {
cout << i << '\n';
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
const int maxn = (long long)2e5 + 5;
const int mod = 1000000007;
const int inf = 0x3f3f3f3f;
vector<int> v[maxn];
vector<int> ans;
int in[maxn];
bool del[maxn];
int pre[maxn];
void dfs2(int x) {
ans.push_back(x);
del[x] = true;
for (auto &i : v[x]) {
--in[i];
if ((!del[i]) && (!(in[i] & 1))) dfs2(i);
}
}
void dfs(int x) {
for (auto &i : v[x])
if (!del[i]) dfs(i);
if (!(in[x] & 1)) {
--in[pre[x]];
dfs2(x);
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int root;
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
pre[i] = x;
if (x == 0)
root = i;
else {
v[x].push_back(i);
++in[x], ++in[i];
}
}
dfs(root);
if (ans.size() == n) {
cout << "YES" << '\n';
for (auto &i : ans) cout << i << '\n';
} else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
long long n, tot, rt, du[N], vis[N], F[N], zhan[N];
vector<long long> g[N], xu;
inline long long read() {
long long ret = 0, f = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
ret = ret * 10 + c - 48;
c = getchar();
}
if (f) return -ret;
return ret;
}
void dfs(long long u, long long fa) {
F[u] = fa;
for (long long i = 0; i < g[u].size(); i++) {
long long v = g[u][i];
if (v == fa) continue;
dfs(v, u);
}
if (du[u] % 2 == 0) {
du[fa]--;
xu.push_back(u);
}
if (u == rt && du[u] & 1) {
puts("NO");
exit(0);
}
}
void solve(long long u, long long fa) {
zhan[++tot] = u;
vis[u] = 1;
for (long long i = 0; i < g[u].size(); i++) {
long long v = g[u][i];
if (v == fa || vis[v]) continue;
solve(v, u);
}
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) {
long long x = read();
if (x > 0) {
g[x].push_back(i);
g[i].push_back(x);
du[i]++;
du[x]++;
} else
rt = i;
}
dfs(rt, 0);
puts("YES");
for (long long i = 0; i < xu.size(); i++) {
long long x = xu[i];
solve(x, F[x]);
}
for (long long i = 1; i <= n; i++) printf("%lld\n", zhan[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> G[maxn];
void insert(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
int sz[maxn];
void dfs(int u, int fa) {
sz[u] = 1;
for (int v : G[u]) {
if (v == fa) continue;
dfs(v, u);
sz[u] += sz[v];
}
}
void del(int u, int fa) {
for (int v : G[u]) {
if (v == fa) continue;
if (sz[v] % 2 == 0) del(v, u);
}
printf("%d\n", u);
for (int v : G[u]) {
if (v == fa) continue;
if (sz[v] & 1) del(v, u);
}
}
int n;
int main() {
scanf("%d", &n);
int rt;
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
if (x == 0)
rt = i;
else
insert(i, x);
}
if (n % 2 == 0) {
puts("NO");
return 0;
}
puts("YES");
dfs(rt, 0);
del(rt, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int vecinos[MAXN];
int prof[MAXN];
int n;
set<int> arbol[MAXN];
void dfs(int i, int p, int profund) {
prof[i] = profund;
for (int h : arbol[i]) {
if (h == p) continue;
dfs(h, i, profund + 1);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
int raiz;
for (int i = (0); i < (n); i++) {
int p;
cin >> p;
p--;
if (p != -1) {
arbol[p].insert(i);
vecinos[p]++;
arbol[i].insert(p);
vecinos[i]++;
} else {
raiz = i;
}
}
dfs(raiz, -1, 0);
set<pair<int, int> > q;
for (int i = (0); i < (n); i++) {
if (vecinos[i] % 2 == 0) {
q.insert({-prof[i], i});
}
}
vector<int> eliminados;
while (!q.empty()) {
auto actual = *q.begin();
q.erase(q.begin());
int act = actual.second;
if (vecinos[act] % 2) continue;
for (int h : arbol[act]) {
vecinos[h]--;
arbol[h].erase(arbol[h].find(act));
if (vecinos[h] % 2 == 0) {
q.insert({-prof[h], h});
}
}
arbol[act].clear();
eliminados.push_back(act);
}
if ((int)(eliminados).size() != n) {
cout << "NO\n";
} else {
cout << "YES\n";
for (int e : eliminados) {
cout << e + 1 << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> G[200000];
bool dpA[200000], dpB[200000];
void dfs(int x, int p) {
for (int t : G[x])
if (t != p) dfs(t, x);
int a_only = 0, both = 0;
for (int t : G[x])
if (t != p) {
bool a = dpA[t], b = dpB[t];
if (!a && !b) return;
if (a && !b) a_only++;
if (a && b) both++;
}
if ((a_only % 2 == 0) || (both > 0)) {
dpA[x] = true;
}
if ((a_only % 2 == 1) || (both > 0)) {
dpB[x] = true;
}
}
vector<int> perm;
void restore(int x, int p, bool par) {
vector<int> a_only, both, b_only;
for (int t : G[x])
if (t != p) {
bool a = dpA[t], b = dpB[t];
assert(a || b);
if (a && !b) a_only.push_back(t);
if (a && b) both.push_back(t);
if (!a && b) b_only.push_back(t);
}
for (int i = 0; i < (both.size()); i++)
if (i != 0) restore(both[i], x, true);
for (int v : b_only) restore(v, x, true);
if ((a_only.size() + par) % 2 == 0) {
if (both.size() > 0) restore(both[0], x, true);
}
perm.push_back(x);
for (int v : a_only) restore(v, x, false);
if ((a_only.size() + par) % 2 != 0) {
assert(both.size() > 0);
restore(both[0], x, false);
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (int i = 0; i < (N); i++) {
int p;
cin >> p;
p--;
if (p != -1) G[i].push_back(p), G[p].push_back(i);
}
dfs(0, -1);
if (dpA[0]) {
cout << "YES\n";
restore(0, -1, false);
assert(perm.size() == N);
for (int i = 0; i < (N); i++) cout << perm[i] + 1 << "\n";
} else {
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int k, n, m, x, Rt;
int h[N], nx[N << 1], t[N << 1], num;
int A[N], B[N], C[N], l1, l2, l3;
int a[N], cnt;
bool f[N][2], fl;
bool g[2][N], d[N];
set<int> S;
void Add(int x, int y) {
t[++num] = y;
nx[num] = h[x];
h[x] = num;
}
void Dfs(int x) {
for (int i = h[x]; i; i = nx[i]) Dfs(t[i]);
l1 = l2 = l3 = 0;
for (int i = h[x]; i; i = nx[i]) {
if (f[t[i]][0] && f[t[i]][1])
A[++l1] = t[i];
else if (f[t[i]][0])
B[++l2] = t[i];
else if (f[t[i]][1])
C[++l3] = t[i];
}
if (!l1) {
bool t = d[x] ^ (l2 & 1);
f[x][t] = 1;
for (int i = 1; i <= l3; i++) g[t][C[i]] = 1;
} else {
f[x][0] = f[x][1] = 1;
for (int t = 0; t < 2; t++) {
if (!(t ^ (l2 & 1) ^ d[x])) g[t][A[1]] = 1;
for (int i = 2; i <= l1; i++) g[t][A[i]] = 1;
for (int i = 1; i <= l3; i++) g[t][C[i]] = 1;
}
}
if (!f[x][0] && !f[x][1]) fl = 1;
}
void Get(int x, bool d) {
for (int i = h[x]; i; i = nx[i])
if (!g[d][t[i]]) Get(t[i], 0);
a[++cnt] = x;
for (int i = h[x]; i; i = nx[i])
if (g[d][t[i]]) Get(t[i], 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (x)
Add(x, i), d[x] ^= 1, d[i] ^= 1;
else
Rt = i;
}
Dfs(Rt);
if (fl || !f[Rt][0])
puts("NO");
else {
puts("YES");
Get(Rt, 0);
for (int i = 1; i <= n; i++) printf("%d\n", a[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> son[200050];
bool deleted[200500];
int seq[200050];
int dcnt, root;
void dfs2(int u) {
if (deleted[u]) return;
deleted[u] = 1;
seq[++dcnt] = u;
for (int i = 0; i < son[u].size(); ++i) dfs2(son[u][i]);
}
void dfs(int u) {
int d = 0;
if (u != root) d++;
for (int i = 0; i < son[u].size(); ++i) {
dfs(son[u][i]);
if (!deleted[son[u][i]]) d++;
}
if (d % 2 == 0) dfs2(u);
return;
}
int main() {
int n, fa;
scanf("%d", &n);
for (int j = 1; j <= n; ++j) {
scanf("%d", &fa);
if (!fa)
root = j;
else
son[fa].push_back(j);
}
dfs(root);
if (dcnt != n)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= dcnt; ++i) printf("%d\n", seq[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, sumsub[N], deg[N], par[N];
vector<int> adj[N];
bool mark[N];
void des(int v) {
if (!mark[v]) {
cout << v + 1 << '\n';
mark[v] = true;
}
for (auto u : adj[v])
if (!mark[u] && u != par[v]) des(u);
}
void dfs(int v) {
sumsub[v] = 1;
for (auto u : adj[v]) {
if (u != par[v]) {
par[u] = v;
dfs(u);
sumsub[v] += sumsub[u];
}
}
if (sumsub[v] % 2 == 0) des(v);
}
void input() {
cin >> n;
for (int i = 0; i < n; i++) {
int v;
cin >> v;
if (v) {
v--;
adj[i].push_back(v);
adj[v].push_back(i);
}
}
}
void solve() {
if (n % 2 == 0) cout << "NO", exit(0);
cout << "YES" << '\n';
int st = -1;
for (int i = 0; i < n; i++)
if (adj[i].size() == 1) st = i;
if (st == -1) cout << 1 << '\n', exit(0);
par[st] = -1;
dfs(st);
cout << st + 1 << '\n';
}
int main() {
ios ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
input(), solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int A[300002];
vector<int> ans;
vector<int> v[300002];
vector<int> lv[300002];
int papa[300002];
int done[300002];
int n;
int last = 0;
map<pair<int, int>, int> imap;
void dfs(int root, int par, int p) {
papa[root] = par;
if (A[root] % 2 == 0) {
lv[p].push_back(root);
}
last = max(last, p);
for (int i = 0; i < v[root].size(); i++) {
int num = v[root][i];
if (num != par) {
dfs(num, root, p + 1);
}
}
}
bool checkis(int root, int par) {
for (int i = 0; i < v[root].size(); i++) {
int num = v[root][i];
if (imap[make_pair(root, num)] == 0) {
return 1;
}
if (num != par) {
checkis(num, root);
}
}
return 0;
}
bool check(int root) {
for (int i = last; i >= 0; i--) {
for (int j = 0; j < lv[i].size(); j++) {
int num = lv[i][j];
if (A[num] % 2 == 1 || done[num] == 1) {
continue;
}
int pop = papa[num];
ans.push_back(num);
done[num] = 1;
for (int k = 0; k < v[num].size(); k++) {
int y = v[num][k];
imap[make_pair(num, y)] = 1;
imap[make_pair(y, num)] = 1;
A[y] -= 1;
if (A[y] % 2 == 0 && A[y] != 0) {
if (y == pop) {
lv[i - 1].push_back(y);
} else {
lv[i + 1].push_back(y);
}
}
}
}
}
for (int i = 0; i <= last; i++) {
for (int j = 0; j < lv[i].size(); j++) {
int num = lv[i][j];
if (A[num] % 2 == 1 || done[num] == 1) {
continue;
}
ans.push_back(num);
done[num] = 1;
for (int k = 0; k < v[num].size(); k++) {
int y = v[num][k];
A[y] -= 1;
if (A[y] % 2 == 0 && A[y] != 0) {
lv[i + 1].push_back(y);
}
imap[make_pair(num, y)] = 1;
imap[make_pair(y, num)] = 1;
}
}
}
if (!checkis(root, 0)) {
return 1;
}
return 0;
}
void solve(int root) {
dfs(root, 0, 0);
if (check(root)) {
cout << "YES" << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
for (int i = 1; i <= n; i++) {
if (done[i] == 0) {
cout << i << " ";
}
}
cout << endl;
} else {
cout << "NO" << endl;
}
}
int main() {
scanf("%d", &n);
int root;
for (int i = 1; i <= n; i++) {
int p;
scanf("%d", &p);
if (p != 0) {
A[p] += 1;
A[i] += 1;
v[i].push_back(p);
v[p].push_back(i);
} else {
root = i;
}
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (A[i] != 0) {
if (A[i] % 2 == 0) {
cnt++;
}
}
}
solve(root);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const long long INF = 1e12;
const double PI = acos(-1.0);
const double eps = 1e-10;
const int M = 1e9 + 9;
int de[N];
vector<int> G[N];
int num[N], vis[N];
void cot(int u, int p) {
num[u] = 1;
for (int v : G[u])
if (v != p) {
cot(v, u);
num[u] += num[v];
}
}
void dfs(int u, int p) {
for (int v : G[u])
if (v != p && !(num[v] & 1)) dfs(v, u);
printf("%d ", u);
for (int v : G[u])
if (v != p && (num[v] & 1)) dfs(v, u);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1, j; i <= n; i++) {
scanf("%d", &j);
if (j) {
de[i] ^= 1;
de[j] ^= 1;
G[i].push_back(j);
G[j].push_back(i);
}
}
bool f = n & 1;
printf("%s\n", f ? "YES" : "NO");
if (f) {
cot(1, 0);
dfs(1, 0);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
struct edge {
int y, next;
} e[maxn << 1];
int N, root;
int lin[maxn], len, deg[maxn];
bool v[maxn];
int cnt[maxn][2];
int read() {
int xx = 0, ff = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
xx = xx * 10 + ch - '0';
ch = getchar();
}
return xx * ff;
}
inline void inse(int xx, int yy) {
e[++len].next = lin[xx];
lin[xx] = len;
e[len].y = yy;
deg[xx]++;
}
bool dfs(int x, int f) {
for (int i = lin[x]; i; i = e[i].next)
if (e[i].y != f) cnt[x][dfs(e[i].y, x)]++;
if ((deg[x] - cnt[x][1]) % 2 == 0)
v[x] = 1;
else
v[x] = 0;
return v[x];
}
void print(int x, int f) {
for (int i = lin[x]; i; i = e[i].next)
if (e[i].y != f)
if (v[e[i].y]) print(e[i].y, x);
printf("%d\n", x);
for (int i = lin[x]; i; i = e[i].next)
if (e[i].y != f)
if (!v[e[i].y]) print(e[i].y, x);
}
int temp;
int main() {
N = read();
for (int i = 1; i <= N; i++) {
temp = read();
if (!temp)
root = i;
else
inse(i, temp), inse(temp, i);
}
if (dfs(root, 0)) {
puts("YES");
print(root, 0);
} else
puts("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
const long long mod = 1e9 + 7;
const long long INF = 100000000000000LL;
const double PI = acos(-1.0);
typedef struct EDGE {
int v;
int next;
} Edge;
Edge edge[maxn];
int head[maxn], cnt;
int deg[maxn];
int dp[maxn][2];
vector<int> g[200020];
int indeg[maxn];
void add(int u, int v) {
edge[cnt].v = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
int dfs(int u, int fa) {
int sum = 0;
for (int i = head[u], v; i != -1; i = edge[i].next) {
v = edge[i].v;
if (v == fa) continue;
dfs(v, u);
sum += dp[v][0];
}
if ((deg[u] - sum) % 2 == 0) {
if (fa == 0) return 1;
dp[u][0] = 1, indeg[fa]++, g[u].push_back(fa);
} else {
if (fa == 0) return 0;
dp[u][1] = 1, indeg[u]++, g[fa].push_back(u);
}
return 1;
}
int solve() {
memset(dp, 0, sizeof(dp));
memset(deg, 0, sizeof(deg));
memset(head, -1, sizeof(head));
memset(indeg, 0, sizeof(indeg));
cnt = 0;
int n;
cin >> n;
for (int i = 1, u, v; i <= n; i++) {
u = i;
scanf("%d", &v);
if (!v) continue;
add(u, v);
add(v, u);
deg[u]++;
deg[v]++;
}
if (!dfs(1, 0))
cout << "NO" << endl;
else {
queue<int> q;
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
if (!indeg[i]) q.push(i);
}
while (!q.empty()) {
int u = q.front();
q.pop();
cout << u << endl;
for (int i = 0; i < g[u].size(); i++) {
indeg[g[u][i]]--;
if (indeg[g[u][i]] == 0) q.push(g[u][i]);
}
}
}
return 0;
}
int main() {
long long t = 1e18;
while (t--) {
if (!solve()) break;
}
int mark_EOF;
if (scanf("%d", &mark_EOF) == EOF) return 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int N = 200100;
vector<int> g[N];
int n, deg[N], tin[N];
int timer;
void dfs(int u = 1, int par = 0) {
tin[u] = ++timer;
for (auto& v : g[u])
if (v != par) {
dfs(v, u);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
srand(time(0));
int root;
cin >> n;
for (int i = 1; i <= n; i++) {
int p;
cin >> p;
if (p != 0) {
g[p].emplace_back(i);
g[i].emplace_back(p);
} else
root = i;
}
timer = 0;
dfs(root);
set<pair<int, int>> x[2];
for (int i = 1; i <= n; i++) {
deg[i] = g[i].size();
x[deg[i] % 2].emplace(-tin[i], i);
}
if (x[0].size() % 2 == 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << '\n';
while (x[0].size() > 0) {
int u = x[0].begin()->second;
x[0].erase(x[0].begin());
cout << u << '\n';
for (auto& v : g[u]) {
if (deg[v] == 0) continue;
x[deg[v] % 2].erase({-tin[v], v});
deg[v]--;
x[deg[v] % 2].emplace(-tin[v], v);
}
deg[u] = 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d[200003];
int dd[200003];
bool vis[200003];
int siz[200003];
int f[200003];
int ans[200003];
queue<int> q;
int n, rt, sum;
struct Edge {
int to, next;
} edge[400003];
int head[200003];
int cnt;
void init() {
memset(head, -1, sizeof(head));
cnt = 0;
}
void add(int u, int v) {
edge[cnt].to = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
void getrt(int u, int fa) {
siz[u] = 1;
f[u] = 0;
bool flag = true;
for (int i = head[u]; ~i; i = edge[i].next) {
if (edge[i].to != fa && !vis[edge[i].to]) {
getrt(edge[i].to, u);
siz[u] += siz[edge[i].to];
f[u] = max(f[u], siz[edge[i].to]);
if (siz[edge[i].to] % 2 == 0) {
dd[u]++;
flag = false;
}
}
}
f[u] = max(f[u], sum - siz[u]);
if (sum - siz[u] != 0 && (sum - siz[u]) % 2 == 0) dd[u]++;
if (d[u] % 2 == 0 && flag) q.push(u);
}
void solve(int u) {
vis[u] = true;
printf("%d\n", u);
for (int i = head[u]; ~i; i = edge[i].next) {
dd[edge[i].to]--;
if (dd[edge[i].to] == 0) q.push(edge[i].to);
}
}
int main() {
init();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int v;
scanf("%d", &v);
if (v) {
add(v, i);
add(i, v);
d[v]++;
d[i]++;
}
}
if (n % 2 == 0) {
printf("NO\n");
} else {
f[0] = n + 1, sum = n;
printf("YES\n");
getrt(1, 0);
while (!q.empty()) {
rt = q.front();
q.pop();
solve(rt);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int INF = 1e9 + 5;
int child[MAXN];
bitset<MAXN> done;
vector<int> rta;
vector<int> G[MAXN];
int dfs1(int st) {
done[st] = true;
int sum = 0;
for (auto &i : G[st])
if (!done[i]) sum += dfs1(i);
return child[st] = sum + 1;
}
void dfs2(int st) {
done[st] = true;
for (auto &i : G[st])
if (!done[i] && !(child[i] & 1)) dfs2(i);
rta.push_back(st);
for (auto &i : G[st])
if (!done[i] && (child[i] & 1)) dfs2(i);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
;
int n;
cin >> n;
for (int i = 0; i < int(n); i++) {
int x;
cin >> x;
x--;
if (x >= 0) G[i].push_back(x), G[x].push_back(i);
}
if (!(n & 1)) return cout << "NO", 0;
dfs1(0);
done.reset();
dfs2(0);
cout << "YES\n";
for (auto &i : rta) cout << i + 1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200010];
int deg[200010];
vector<int> e[200010];
vector<int> ans;
int d[200010], c[200010];
int dfs2(int v, int p) {
if (deg[v] & 1) return 0;
ans.push_back(v);
d[v] = 1;
for (int i = 0; i < e[v].size(); i++) {
if (!d[e[v][i]]) {
--deg[e[v][i]];
if (!dfs2(e[v][i], v)) return 0;
}
}
return 1;
}
int dfs(int v, int p = -1) {
for (int i = 0; i < e[v].size(); i++) {
if (e[v][i] != p) {
if (dfs(e[v][i], v) == -1) return -1;
}
}
if (deg[v] & 1) return 0;
ans.push_back(v);
d[v] = 1;
for (int i = 0; i < e[v].size(); i++) {
if (e[v][i] == p) {
deg[p]--;
} else if (!d[e[v][i]]) {
deg[e[v][i]]--;
if (!dfs2(e[v][i], v)) return -1;
}
}
return 1;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (!a[i]) continue;
e[a[i]].push_back(i);
e[i].push_back(a[i]);
deg[i]++;
deg[a[i]]++;
}
if (n % 2 == 0) {
puts("NO");
return 0;
}
if (dfs(1) == 1) {
puts("YES");
for (int i = 0; i < ans.size(); i++) {
printf("%d\n", ans[i]);
}
} else {
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 220000;
int vis[MAXN], ans[MAXN];
struct Edge {
int u, v, nxt;
} e[MAXN << 1];
int e_cnt;
int head[MAXN];
void Add(int u, int v) {
int id = ++e_cnt;
e[id].u = u;
e[id].v = v;
e[id].nxt = head[u];
head[u] = id;
}
void DFS2(int u, int fa) {
ans[++ans[0]] = u;
vis[u] = true;
for (int id = head[u]; ~id; id = e[id].nxt) {
int v = e[id].v;
if (v == fa) continue;
if (!vis[v]) DFS2(v, u);
}
}
void DFS1(int u, int fa) {
int siz = (u != 1);
for (int id = head[u]; ~id; id = e[id].nxt) {
int v = e[id].v;
if (v == fa) continue;
DFS1(v, u);
if (!vis[v]) siz++;
}
if (siz % 2 == 0) DFS2(u, fa);
}
int main() {
memset(head, -1, sizeof(head));
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int j;
scanf("%d", &j);
if (j) Add(j, i), Add(i, j);
}
DFS1(1, 0);
if (ans[0] == n) {
printf("YES\n");
for (int i = 1; i <= ans[0]; ++i) printf("%d\n", ans[i]);
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long inf = 2147483647;
const long long ll = 9223372036854775807, ninf = 1000000000;
const double eps = 1e-6;
const long long nll = 1000000000000000000;
vector<int> node[200005];
vector<int> num;
int deg[200005] = {};
void dfs(int x) {
for (int i = 0; i < node[x].size(); i++) {
dfs(node[x][i]);
}
num.push_back(x);
}
int A[200005] = {};
int main() {
int a;
while (cin >> a) {
int r = 1;
for (int i = 1; i <= a; i++) {
cin >> A[i];
deg[A[i]]++;
if (A[i]) {
deg[i]++;
node[A[i]].push_back(i);
} else {
r = i;
}
}
if (a % 2 == 0) {
cout << "NO" << '\n';
continue;
}
dfs(r);
vector<int> ans1, ans2;
cout << "YES" << '\n';
for (int i = 0; i < num.size(); i++) {
int now = num[i];
if (deg[now] % 2 == 0) {
ans2.push_back(now);
deg[A[now]]--;
} else {
ans1.push_back(now);
}
}
for (int i = 0; i < ans2.size(); i++) {
cout << ans2[i] << '\n';
}
reverse(ans1.begin(), ans1.end());
for (int i = 0; i < ans1.size(); i++) {
cout << ans1[i] << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 9, MOD = 1e9 + 7;
int n, dp[maxN];
vector<int> adj[maxN];
vector<int> ans;
void dfs(int nd, int an) {
dp[nd] = 1;
for (int sn : adj[nd]) {
if (sn == an) continue;
dfs(sn, nd);
dp[nd] ^= dp[sn];
}
}
void cons(int nd, int an) {
for (int sn : adj[nd]) {
if (sn != an && dp[sn] == 0) {
cons(sn, nd);
}
}
ans.push_back(nd + 1);
for (int sn : adj[nd]) {
if (sn != an && dp[sn] == 1) {
cons(sn, nd);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0, inp; i < n; i++) {
cin >> inp;
inp--;
if (inp != -1) {
adj[i].push_back(inp);
adj[inp].push_back(i);
}
}
dfs(0, -1);
if (dp[0] == 0) {
cout << "NO\n";
return 0;
}
dp[0] = 0;
cons(0, -1);
cout << "YES\n";
for (int el : ans) cout << el << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 5 * 100000 + 50, inf = 1e13, N = 3050;
long long int par[maxn];
vector<long long int> v[maxn];
long long int dp[maxn];
vector<long long int> p;
bool f[maxn];
void dfs(long long int x) {
long long int y = 0;
p.push_back(x);
for (long long int i = 0; i < v[x].size(); i++) dfs(v[x][i]);
for (long long int i = 0; i < v[x].size(); i++) {
if (dp[v[x][i]] == 1) y++;
}
if (y % 2 == 1) {
dp[x] = 2;
f[x] = true;
} else
dp[x] = 1;
}
int main() {
long long int n;
cin >> n;
long long int rishe = -1;
for (long long int i = 1; i <= n; i++) {
long long int c;
cin >> c;
if (c == 0) {
rishe = i;
continue;
}
v[c].push_back(i);
par[i] = c;
}
for (long long int i = 1; i <= n; i++)
if (v[i].size() == 0) dp[i] = 1;
dfs(rishe);
if (dp[rishe] == 2) {
cout << "NO";
} else {
cout << "YES" << endl;
for (long long int i = p.size() - 1; i > -1; i--) {
if (f[p[i]] == true) cout << p[i] << endl;
}
for (long long int i = 0; i < p.size(); i++) {
if (f[p[i]] == true) continue;
cout << p[i] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 7;
int n, tim, tmp, cnt[MAXN];
int f[MAXN], vis[MAXN], rem[MAXN];
struct node {
int h, num;
friend bool operator<(node xx, node yy) { return xx.h < yy.h; }
} a[MAXN];
priority_queue<node> q;
queue<int> prin;
vector<int> v[MAXN];
void dfs(int x, int h) {
rem[x] = 1;
int k = v[x].size();
for (int i = 0; i < k; i++) {
if (rem[v[x][i]]) continue;
dfs(v[x][i], h + 1);
}
a[x].h = h;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &tmp);
v[tmp].push_back(i);
if (tmp) v[i].push_back(tmp), cnt[i]++;
cnt[tmp]++;
a[i].num = i;
}
if (!(n & 1)) {
printf("NO");
return 0;
}
dfs(1, 1);
for (int i = 1; i <= n; i++) {
if (cnt[i] & 1) continue;
q.push(a[i]);
}
while (!q.empty()) {
node tem = q.top();
q.pop();
if ((cnt[tem.num] & 1) || vis[tem.num]) continue;
vis[tem.num] = true;
prin.push(tem.num);
int k = v[tem.num].size();
for (int i = 0; i < k; i++) {
if (vis[v[tem.num][i]]) continue;
cnt[v[tem.num][i]]--;
if (cnt[v[tem.num][i]] & 1) continue;
q.push(a[v[tem.num][i]]);
}
}
printf("YES\n");
while (!prin.empty()) {
printf("%d\n", prin.front());
prin.pop();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, NX = 1e9 + 7;
int n, m, r, t, a, b, A[N], D[N], M[N];
set<int> V[N];
set<pair<int, int> > S;
void DFS(int v, int p) {
int c = 0;
for (auto X : V[v]) {
if (X == p) continue;
DFS(X, v);
c += !M[X];
}
if (c & 1) M[v] = 1, c++;
D[v] -= c;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &r);
if (r) V[i].insert(r), V[r].insert(i);
}
if (n % 2 == 0) return !printf("NO");
for (int i = 1; i <= n; i++) D[i] = V[i].size();
printf("YES\n");
DFS(1, 0);
for (int i = 1; i <= n; i++) S.insert({D[i], i});
while (S.size()) {
auto X = *S.begin();
S.erase(S.begin());
for (auto v : V[X.second]) {
V[v].erase(X.second);
S.erase({D[v], v});
D[v]--;
S.insert({D[v], v});
}
V[X.second].clear();
printf("%d\n", X.second);
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
int F() {
char ch;
int x, a;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-')
ch = getchar(), a = -1;
else
a = 1;
x = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - '0';
return a * x;
}
int n;
int fa[200010], in[200010];
set<int> edge[200010];
int deg(int u) { return in[fa[u]] + ((int)(edge[u]).size()); }
int stk[200010], cnt;
int del[200010], tp;
void clear(int u) {
stk[++cnt] = u;
in[u] = 0;
if (fa[u]) del[++tp] = u;
for (auto v : edge[u]) clear(v);
}
void dfs(int u) {
while (tp) {
int x = del[tp--];
if (fa[x]) edge[fa[x]].erase(x);
}
for (auto v : edge[u]) dfs(v);
while (tp) {
int x = del[tp--];
if (fa[x]) edge[fa[x]].erase(x);
}
if (!in[u]) return;
if (deg(u) & 1) return;
clear(u);
}
int main() {
((n) = F());
for (int i = 1; i <= n; ++i) {
((fa[i]) = F());
in[i] = 1;
if (fa[i]) edge[fa[i]].insert(i);
}
for (int i = 1; i <= n; ++i)
if (!fa[i]) dfs(i);
if (cnt != n) return puts("NO"), 0;
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d\n", stk[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> tree[200009], ans;
long long sz[200009];
void dfs(long long u, long long p) {
for (long long i = 0; i < tree[u].size(); i++) {
long long nd = tree[u][i];
if (nd == p) continue;
dfs(nd, u);
}
if (sz[u] % 2 != 0 || sz[u] == 0) return;
ans.push_back(u);
sz[u] = 0;
for (long long i = 0; i < tree[u].size(); i++) {
long long nd = tree[u][i];
sz[nd]--;
if (sz[nd] == 0) ans.push_back(nd);
}
}
void dfs2(long long u, long long p) {
if (sz[u] % 2 == 0 && sz[u] != 0) {
ans.push_back(u);
sz[u] = 0;
for (long long i = 0; i < tree[u].size(); i++) {
long long nd = tree[u][i];
sz[nd]--;
if (sz[nd] == 0) ans.push_back(nd);
}
}
for (long long i = 0; i < tree[u].size(); i++) {
long long nd = tree[u][i];
if (nd == p) continue;
dfs2(nd, u);
}
}
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
long long u;
scanf("%lld", &u);
if (u == 0) continue;
tree[u].push_back(i);
tree[i].push_back(u);
}
if (n == 1) {
cout << "YES" << endl << 1 << endl;
return 0;
}
for (long long i = 1; i <= n; i++) sz[i] = tree[i].size();
dfs(1, 0);
dfs2(1, 0);
if (ans.size() != n) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (long long i = 0; i < ans.size(); i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 20;
int n;
struct edge {
int y, nxt;
} e[N << 1];
int lin[N], len = 1;
int degree[N], ans[N], pos;
bool mark[N];
inline int read() {
int s = 0, f = 1;
char ch;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
s = (s << 1) + (s << 3) + ch - '0';
return s * f;
}
inline void add(int xx, int yy) {
e[++len] = (edge){yy, lin[xx]};
lin[xx] = len;
}
inline void dfs(int x, int fa, bool flag) {
if (!flag) {
for (int i = lin[x]; i; i = e[i].nxt) {
int y = e[i].y;
if (y == fa) continue;
if (!mark[y]) dfs(y, x, 0);
}
}
if (!(degree[x] % 2)) {
degree[x] = 0;
ans[++pos] = x;
mark[x] = 1;
for (int i = lin[x]; i; i = e[i].nxt) {
int y = e[i].y;
--degree[y];
if (y == fa) continue;
if (!mark[y]) dfs(y, x, 1);
}
}
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
int x = read();
if (x) {
add(i, x);
add(x, i);
degree[i]++;
degree[x]++;
}
}
dfs(1, 0, 0);
if (pos == n) {
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d\n", ans[i]);
} else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
const int N = 2 * (int)1e5;
vector<int> conns[N];
int siz[N];
int dfs(int i, int p) {
siz[i] = 1;
for (auto t : conns[i]) {
if (t != p) siz[i] += dfs(t, i);
}
return siz[i];
}
void solve(int i, int p, vector<int>& res) {
for (auto t : conns[i]) {
if (t != p && siz[t] % 2 == 0) solve(t, i, res);
}
res.push_back(i);
for (auto t : conns[i]) {
if (t != p && siz[t] % 2 == 1) solve(t, i, res);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int p;
cin >> p;
--p;
if (p != -1) {
conns[i].push_back(p);
conns[p].push_back(i);
}
}
if (n % 2 == 0) {
cout << "NO\n";
} else {
cout << "YES\n";
vector<int> res;
dfs(0, 0);
solve(0, 0, res);
for (auto i : res) cout << i + 1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
class Tree {
int n;
public:
int *deg, *p;
bool *EvenDeg, *erased;
vector<int> *adj;
Tree(int n);
void AddEdge(int u, int v);
void compEvenDeg(int x);
void Dfs(int x);
};
int root;
Tree::Tree(int n) {
this->n = n;
deg = new int[n];
p = new int[n];
EvenDeg = new bool[n];
erased = new bool[n];
adj = new vector<int>[n];
for (int i = 0; i < n; ++i) erased[i] = deg[i] = EvenDeg[i] = 0;
}
void Tree::AddEdge(int u, int v) {
adj[u].push_back(v);
++deg[u];
++deg[v];
p[v] = u;
}
void Tree::compEvenDeg(int u) {
EvenDeg[u] = false;
for (int v : adj[u]) {
compEvenDeg(v);
EvenDeg[u] |= (EvenDeg[v] | !(deg[v] % 2));
}
}
void Tree::Dfs(int u) {
bool ok = false;
if ((deg[u] % 2 == 0) && !EvenDeg[u]) {
erased[u] = true;
ok = true;
printf("%d\n", u + 1);
if (u != root) --deg[p[u]];
}
for (int v : adj[u]) {
if (erased[u]) --deg[v];
if (!erased[v] && ((deg[v] % 2 == 0) || EvenDeg[v])) Dfs(v);
}
if (!erased[u] && (deg[u] % 2 == 0)) {
erased[u] = true;
printf("%d\n", u + 1);
if (u != root) --deg[p[u]];
}
for (int v : adj[u]) {
if (erased[u] && !ok) --deg[v];
if (!erased[v]) Dfs(v);
}
}
int deg[200002];
int main() {
int n;
scanf("%d", &n);
if (n % 2) {
printf("YES\n");
Tree T(n);
for (int u = 0, v; u < n; ++u) {
scanf("%d", &v);
--v;
if (v == -1)
root = u;
else
T.AddEdge(v, u);
}
T.compEvenDeg(root);
T.Dfs(root);
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vowel(char che) {
if (che == 'A' || che == 'E' || che == 'I' || che == 'O' || che == 'U' ||
che == 'Y')
return true;
else
return false;
}
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
long long a[N], b[N], c[N], d, dis, dp[N], dg[N], pd[N];
pair<long long, long long> p;
vector<long long> vt[N], vm[N], vs;
stack<long long> st;
string s, s1;
char o;
bool mark[N], mark1[N], h;
long long n1 = 0;
void dfs(long long v, long long k, long long f) {
pd[v] = k;
vm[f].push_back(v);
n1 = max(n1, f);
f += 1;
for (int i = 0; i < vt[v].size(); i++) {
if (vt[v][i] != k) dfs(vt[v][i], v, f);
}
}
void dst(long long v, long long k) {
mark1[v] = true;
dg[k]--;
vs.push_back(v);
for (int i = 0; i < vt[v].size(); i++) {
if (vt[v][i] != k && !mark1[vt[v][i]]) dst(vt[v][i], v);
}
}
int main() {
long long t = 0, n, m = 0, k = 0, f = 0, sum = 0, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> m;
if (m) {
vt[i].push_back(m);
vt[m].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
dg[i] = vt[i].size();
}
if (n % 2 == 0)
cout << "NO\n";
else {
cout << "YES\n";
dfs(1, 0, 0);
for (int i = n1; i >= 0; i--) {
for (int j = 0; j < vm[i].size(); j++) {
m = vm[i][j];
if (dg[m] % 2 == 0) dst(m, pd[m]);
}
}
for (auto x : vs) {
cout << x << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int myRnd() { return abs(((rand() << 15) ^ rand())); }
int myRnd(int L, int R) {
return abs(((rand() << 15) ^ rand())) % (R - L + 1) + L;
}
void Parr(int *arr, int L, int R) {
for (int i = L; R >= i; i++) {
printf("%d%c", arr[i], " \n"[i == R]);
}
}
void Pvec(vector<int> v) {
for (int i = 0; ((int)(v).size()) > i; i++) {
printf("%d%c", v[i], " \n"[i == ((int)(v).size()) - 1]);
}
}
void Sarr(int *arr, int L, int R) {
for (int i = L; R >= i; i++) {
scanf("%d", &(arr[i]));
;
}
}
const int N = 2e5 + 6;
const int INF = 0x3f3f3f3f;
const int mod = 1000000000 + 7;
int a[N];
vector<int> G[N];
bool dp[2][N];
void dfs(int now, int par) {
vector<int> child;
for (int i : G[now]) {
if (i != par) {
child.push_back(i);
dfs(i, now);
}
}
if (((int)(child).size()) == 0) {
dp[1][now] = true;
dp[0][now] = false;
} else {
int _1L = 0, _1R = 0;
for (int i : child) {
if (dp[0][i] && dp[1][i]) {
_1R++;
} else if (dp[1][i]) {
_1L++;
_1R++;
}
}
if (_1R == _1L) {
if (_1L % 2 == 0) {
dp[1][now] = true;
dp[0][now] = false;
} else {
dp[0][now] = true;
dp[1][now] = false;
}
} else {
dp[0][now] = dp[1][now] = true;
}
}
}
vector<int> ans[2][N];
int lc[N], rc[N];
int head[2][N], tail[2][N];
void dfs2(int now, int par) {
vector<int> child;
for (int i : G[now]) {
if (i != par) {
child.push_back(i);
dfs2(i, now);
}
}
if (((int)(child).size()) == 0) {
head[1][now] = tail[1][now] = now;
} else {
int _1L = 0, _1R = 0;
for (int i : child) {
if (dp[0][i] && dp[1][i]) {
_1R++;
} else if (dp[1][i]) {
_1L++;
_1R++;
}
}
if (_1R == _1L) {
if (_1L % 2 == 0) {
int last = -1;
for (int i : child) {
if (!dp[1][i]) {
if (last == -1) {
head[1][now] = head[0][i];
last = tail[0][i];
} else {
int _ = head[0][i];
rc[last] = _;
lc[_] = last;
last = tail[0][i];
}
}
}
if (last == -1) {
head[1][now] = now;
last = now;
} else {
int _ = now;
rc[last] = now;
lc[_] = last;
last = now;
}
for (int i : child) {
if (dp[1][i]) {
int _ = head[1][i];
rc[last] = _;
lc[_] = last;
last = tail[1][i];
}
}
tail[1][now] = last;
} else {
int last = -1;
for (int i : child) {
if (!dp[1][i]) {
if (last == -1) {
head[0][now] = head[0][i];
last = tail[0][i];
} else {
int _ = head[0][i];
rc[last] = _;
lc[_] = last;
last = tail[0][i];
}
}
}
if (last == -1) {
head[0][now] = now;
last = now;
} else {
int _ = now;
rc[last] = now;
lc[_] = last;
last = now;
}
for (int i : child) {
if (dp[1][i]) {
int _ = head[1][i];
rc[last] = _;
lc[_] = last;
last = tail[1][i];
}
}
tail[0][now] = last;
}
} else {
vector<int> child1, child2;
vector<int> choice;
for (int i : child) {
if (dp[0][i] && dp[1][i]) {
choice.push_back(i);
} else if (dp[1][i]) {
child1.push_back(i);
child2.push_back(i);
}
}
if (((int)(child1).size()) % 2 == 1) {
child1.push_back(choice[0]);
} else if (((int)(child1).size()) % 2 == 0) {
child2.push_back(choice[0]);
}
int last = -1;
for (int i : child2) {
if (!dp[1][i]) {
if (last == -1) {
head[1][now] = head[0][i];
last = tail[0][i];
} else {
int _ = head[0][i];
rc[last] = _;
lc[_] = last;
last = tail[0][i];
}
}
}
if (last == -1) {
head[1][now] = now;
last = now;
} else {
int _ = now;
rc[last] = now;
lc[_] = last;
last = now;
}
for (int i : child2) {
if (dp[1][i]) {
int _ = head[1][i];
rc[last] = _;
lc[_] = last;
last = tail[1][i];
}
}
tail[1][now] = last;
last = -1;
for (int i : child1) {
if (!dp[1][i]) {
if (last == -1) {
head[0][now] = head[0][i];
last = tail[0][i];
} else {
int _ = head[0][i];
rc[last] = _;
lc[_] = last;
last = tail[0][i];
}
}
}
if (last == -1) {
head[0][now] = now;
last = now;
} else {
int _ = now;
rc[last] = now;
lc[_] = last;
last = now;
}
for (int i : child1) {
if (dp[1][i]) {
int _ = head[1][i];
rc[last] = _;
lc[_] = last;
last = tail[1][i];
}
}
tail[0][now] = last;
}
}
}
int main() {
srand(time(NULL));
int n;
scanf("%d", &(n));
;
for (int i = 1; (n) >= i; ++i) {
int p;
scanf("%d", &(p));
;
if (p) {
G[i].push_back(p);
G[p].push_back(i);
}
}
dfs(1, 1);
if (!dp[1][1]) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 1; n >= i; i++) {
lc[i] = rc[i] = i;
}
dfs2(1, 1);
int start = -1;
for (int i = 1; n >= i; i++) {
if (lc[i] == i) {
start = i;
break;
}
}
assert(start != -1);
for (int i = 1; n >= i; i++) {
printf("%d\n", start);
start = rc[start];
}
}
|
#include <bits/stdc++.h>
const int maxn = 2e5 + 10;
const int maxm = 2e5 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-7;
using namespace std;
vector<int> G[maxn];
int rt = 1;
int n, p, sz[maxn];
void dfs(int u, int fa) {
sz[u]++;
for (auto v : G[u]) {
if (v == fa) continue;
dfs(v, u);
sz[u] += sz[v];
}
}
void dfs1(int u, int fa) {
for (auto v : G[u]) {
if (v == fa) continue;
if (sz[v] % 2 == 0) dfs1(v, u);
}
cout << u << endl;
for (auto v : G[u]) {
if (v == fa) continue;
if (sz[v] & 1) dfs1(v, u);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p;
if (p == 0)
rt = i;
else {
G[i].push_back(p);
G[p].push_back(i);
}
}
if (n & 1) {
cout << "YES" << endl;
dfs(rt, 0);
dfs1(rt, 0);
} else
cout << "NO";
return ~~(0 - 0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n;
int sz[N];
int par[N];
int cnt[N];
bool visit[N];
vector<pair<int, int> > G[N];
void dfs(int u) {
sz[u] = 1;
for (auto v : G[u])
if (par[u] != v.first) {
par[v.first] = u, dfs(v.first), sz[u] += sz[v.first];
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
int p;
cin >> p;
if (p) G[p].push_back({i, 0}), G[i].push_back({p, 0});
}
if (n % 2 == 0) {
cout << "NO";
return 0;
}
dfs(1);
for (int i = 1; i <= n; ++i) {
sort(G[i].begin(), G[i].end());
for (auto &j : G[i]) {
if (par[i] == j.first) {
j.second = (n - sz[i]) & 1;
} else {
j.second = sz[j.first] & 1;
}
cnt[i] += !j.second;
}
}
queue<int> qu;
for (int i = 1; i <= n; ++i) {
if (!cnt[i]) qu.push(i), visit[i] = 1;
}
cout << "YES\n";
while (qu.size()) {
int u = qu.front();
qu.pop();
cout << u << '\n';
for (auto v : G[u]) {
auto i =
lower_bound(G[v.first].begin(), G[v.first].end(), make_pair(u, 0));
cnt[v.first] -= !(i->second);
if (!cnt[v.first] && !visit[v.first]) {
qu.push(v.first), visit[v.first] = 1;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
vector<int> g[N];
int sz[N];
bool vis[N];
int lvl[N];
void dfs(int node, int par) {
for (int nxt : g[node]) {
if (nxt == par) continue;
lvl[nxt] = lvl[node] + 1;
dfs(nxt, node);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int root;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (!x) {
root = i;
continue;
}
g[x].push_back(i);
g[i].push_back(x);
}
memset(sz, 0, sizeof(sz));
memset(vis, 0, sizeof(vis));
memset(lvl, 0, sizeof(lvl));
dfs(root, 0);
set<pair<int, int> > ss;
for (int i = 1; i <= n; i++) {
sz[i] = g[i].size();
if (sz[i] % 2 == 0) {
ss.insert(make_pair(lvl[i], i));
}
}
vector<int> vec;
while (ss.size()) {
pair<int, int> p = *ss.rbegin();
int node = p.second;
vec.push_back(node);
vis[node] = true;
ss.erase(prev(ss.end()));
for (int nxt : g[node]) {
if (vis[nxt]) continue;
sz[nxt]--;
if (sz[nxt] & 1) {
ss.erase(make_pair(lvl[nxt], nxt));
} else
ss.insert(make_pair(lvl[nxt], nxt));
}
}
if (vec.size() != n) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (int x : vec) {
cout << x << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int root;
int N, Fa[maxn], degree[maxn], vis[maxn] = {};
vector<int> v[maxn << 1], ans;
stack<int> s;
inline long long read() {
long long s = 0, f = 1;
char ch;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
s = (s << 3) + (s << 1) + ch - '0';
return s * f;
}
void dfs(int x, int fa) {
s.push(x);
for (int i = 0; i < v[x].size(); ++i) {
if (v[x][i] == fa) continue;
dfs(v[x][i], x);
}
}
void Dfs(int x) {
ans.push_back(x);
vis[x] = 1;
for (int i = 0; i < v[x].size(); ++i) {
--degree[v[x][i]];
if (v[x][i] == Fa[x] || vis[v[x][i]]) continue;
if ((degree[v[x][i]] & 1) == 0) Dfs(v[x][i]);
}
}
int main() {
N = read();
for (int i = 1; i <= N; ++i) {
Fa[i] = read();
if (Fa[i])
v[i].push_back(Fa[i]), v[Fa[i]].push_back(i), ++degree[Fa[i]],
++degree[i];
else
root = i;
}
dfs(root, 0);
while (!s.empty()) {
int x = s.top();
s.pop();
if (!(degree[x] & 1)) Dfs(x);
}
if (ans.size() == N) {
puts("YES");
for (int i = 0; i < ans.size(); ++i) printf("%d\n", ans[i]);
} else
puts("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const int ms = 1e6;
vector<int> adj[ms];
int root, n, sz[ms];
int precalc(int i) {
sz[i] = 1;
for (auto v : adj[i]) {
sz[i] += precalc(v);
}
return sz[i];
}
void dfs(int i) {
for (auto v : adj[i])
if (!(sz[v] & 1)) dfs(v);
cout << i << " ";
for (auto v : adj[i])
if (sz[v] & 1) dfs(v);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n, x;
cin >> n;
if (!(n & 1)) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x)
adj[x].push_back(i);
else
root = i;
}
precalc(root);
dfs(root);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[200100];
int n, dp[200100], anses[200100], tp;
void dfs(int u, int f) {
for (auto p : G[u])
if (p != f) dfs(p, u);
if (G[u].size() == 1) return (void)(dp[u] = 0);
int cnt = 0;
for (auto p : G[u])
if (p != f && dp[p] == 0) cnt++;
dp[u] = cnt & 1;
if (dp[u]) anses[++tp] = u;
if (f == 0 && dp[u] == 1) {
printf("NO\n");
exit(0);
}
}
void dfs2(int u, int f) {
if (!dp[u]) anses[++tp] = u;
for (auto p : G[u])
if (p != f) dfs2(p, u);
}
int main() {
scanf("%d", &n);
if (n == 1) return printf("YES\n1"), 0;
if (n == 2) return printf("NO"), 0;
for (int i = 1, u; i <= n; ++i) {
scanf("%d", &u);
if (u) G[u].push_back(i), G[i].push_back(u);
}
int rt = 0;
for (int i = 1; i <= n; ++i)
if (G[i].size() > 1) rt = i;
dfs(rt, 0), dfs2(rt, 0);
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d\n", anses[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> vt;
vector<int> dap;
int degree[200010];
int visited[200010];
int n;
void solve(int here) {
visited[here] = 1;
dap.push_back(here);
for (int i = 0; i < vt[here].size(); i++) {
int next = vt[here][i];
if (!visited[next]) solve(next);
}
}
void dfs(int here, int par) {
for (int i = 0; i < vt[here].size(); i++) {
dfs(vt[here][i], here);
}
if (degree[here] % 2 == 0) {
degree[par]--;
solve(here);
}
}
int main() {
scanf("%d", &n);
vt.resize(n + 1);
int ch = 0;
for (int i = 1; i <= n; i++) {
int q;
scanf("%d", &q);
if (q == 0) {
ch = i;
continue;
}
vt[q].push_back(i);
degree[q]++;
degree[i]++;
}
if (n % 2 == 0) {
puts("NO");
} else {
puts("YES");
dfs(ch, 0);
for (int i = 0; i < dap.size(); i++) printf("%d\n", dap[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v[200005];
long long int degree[200005], vis2[200005];
deque<long long int> dq2;
void DFS2(long long int x) {
if (vis2[x]) {
return;
}
vis2[x] = 1;
long long int i;
dq2.push_back(x);
for (i = 0; i < v[x].size(); i++) {
DFS2(v[x][i]);
}
}
void DFS1(long long int x, long long int par) {
long long int i;
for (i = 0; i < v[x].size(); i++) {
DFS1(v[x][i], x);
}
if (!(degree[x] % 2)) {
DFS2(x);
degree[par]--;
}
}
int main(void) {
long long int i, n, x, size = 0, lol;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x;
if (x != 0) {
v[x].push_back(i);
degree[i]++;
degree[x]++;
} else {
lol = i;
}
}
if (!(n % 2)) {
cout << "NO\n";
return 0;
}
DFS1(lol, 200002);
cout << "YES\n";
while (!dq2.empty()) {
cout << dq2.front() << "\n";
dq2.pop_front();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct X {
int id;
int sz;
int dep;
X() {}
X(int id, int sz, int dep) : id(id), sz(sz), dep(dep) {}
bool operator<(const X x) const {
if (sz % 2 == 0 && x.sz % 2 != 0) return 1;
if (sz % 2 != 0 && x.sz % 2 == 0) return 0;
if (dep > x.dep) return 1;
if (dep < x.dep) return 0;
return id < x.id;
}
};
set<X> st;
unordered_set<int> v[200005];
vector<int> ans;
int dep[200005];
void dfs(int now, int fa) {
dep[now] = dep[fa] + 1;
for (auto x : v[now]) {
if (x == fa) continue;
dfs(x, now);
}
}
int main(void) {
int n;
scanf("%d", &n);
int i;
for (i = 1; i <= n; i++) {
int p;
scanf("%d", &p);
if (p != 0) {
v[i].insert(p);
v[p].insert(i);
}
}
dfs(1, 1);
for (i = 1; i <= n; i++) {
st.insert(X(i, v[i].size(), dep[i]));
}
while (st.size()) {
X b = *st.begin();
if (b.sz % 2 != 0) break;
ans.push_back(b.id);
st.erase(st.begin());
for (auto nxt : v[b.id]) {
st.erase(X(nxt, v[nxt].size(), dep[nxt]));
v[nxt].erase(b.id);
st.insert(X(nxt, v[nxt].size(), dep[nxt]));
}
v[b.id].clear();
}
if (st.size() == 0) {
printf("YES\n");
for (auto g : ans) printf("%d\n", g);
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5, M = 4e5;
int head[N + 10], ver[M + 10], nxt[M + 10], tot, sz[N + 10];
void add(int x, int y) {
ver[++tot] = y;
nxt[tot] = head[x];
head[x] = tot;
ver[++tot] = x;
nxt[tot] = head[y];
head[y] = tot;
}
void dfs1(int x, int fa) {
sz[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (y == fa) continue;
dfs1(y, x);
sz[x] += sz[y];
}
}
int ans[N + 10], cnt = 0;
void dfs2(int x, int fa) {
vector<int> odd, even;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (y == fa) continue;
if (sz[y] & 1)
odd.push_back(y);
else
even.push_back(y);
}
for (int i = 0; i < even.size(); i++) {
int y = even[i];
dfs2(y, x);
}
ans[++cnt] = x;
for (int i = 0; i < odd.size(); i++) {
int y = odd[i];
dfs2(y, x);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (!x) continue;
add(i, x);
}
dfs1(1, -1);
if (!(sz[1] & 1))
printf("NO");
else {
printf("YES\n");
dfs2(1, -1);
for (int i = 1; i <= cnt; i++) printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int p[200002];
vector<int> ke[200002];
bool mark[200002];
bool dfs(int u, int p) {
int cnt = 0;
for (int v : ke[u]) {
if (v == p) continue;
if (dfs(v, u)) cnt++;
}
if (cnt % 2 == 0) {
return mark[u] = true;
}
return mark[u] = false;
}
void dfs2(int u, int p) {
for (int v : ke[u]) {
if (v == p) continue;
if (!mark[v]) {
dfs2(v, u);
}
}
cout << u << "\n";
for (int v : ke[u]) {
if (v == p) continue;
if (mark[v]) {
dfs2(v, u);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> p[i];
if (p[i]) {
ke[i].push_back(p[i]);
ke[p[i]].push_back(i);
}
}
if (dfs(1, 1)) {
cout << "YES\n";
dfs2(1, 1);
} else {
cout << "NO";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int u[maxn], par[maxn];
bool vis[maxn];
vector<int> rode[maxn];
stack<int> P;
queue<int> Q;
void dfs(int v, int pre) {
P.push(v);
par[v] = pre;
for (int i = 0; i < rode[v].size(); i++) {
if (rode[v][i] == pre) continue;
dfs(rode[v][i], v);
}
}
void dfs2(int x) {
Q.push(x);
vis[x] = 1;
for (int i = 0; i < rode[x].size(); i++) {
int to = rode[x][i];
u[to]--;
if (to == par[x] || vis[to]) continue;
if (u[to] % 2 == 0) dfs2(to);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x) {
rode[i].push_back(x), rode[x].push_back(i);
u[i]++, u[x]++;
}
}
dfs(1, 0);
while (!P.empty()) {
int x = P.top();
P.pop();
if (u[x] % 2 == 0) dfs2(x);
}
if (Q.size() == n) {
printf("YES\n");
while (!Q.empty()) {
printf("%d\n", Q.front());
Q.pop();
}
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 50;
int E, V[N], Next[N], Head[N];
bool vis[N];
void add(int a, int b) {
V[E] = b;
Next[E] = Head[a];
Head[a] = E++;
}
bool dfs(int u, int fa) {
bool ans = 0;
for (int i = Head[u]; i != -1; i = Next[i]) {
int v = V[i];
if (v == fa) continue;
vis[v] = dfs(v, u);
if (!vis[v]) ans = !ans;
}
return ans;
}
void print(int u, int fa) {
for (int i = Head[u]; i != -1; i = Next[i]) {
int v = V[i];
if (v == fa) continue;
if (vis[v]) print(v, u);
}
printf("%d\n", u);
for (int i = Head[u]; i != -1; i = Next[i]) {
int v = V[i];
if (v == fa) continue;
if (!vis[v]) print(v, u);
}
}
int main() {
int n, rt;
memset(Head, -1, sizeof(Head));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int p;
scanf("%d", &p);
if (p == 0) {
rt = i;
continue;
}
add(i, p), add(p, i);
}
if (!dfs(rt, -1)) {
puts("YES");
print(rt, -1);
} else
puts("NO");
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
vector<set<int>> graph;
vector<bool> seen;
vector<bool> removed;
vector<int> removedOrder;
void dfs(int from) {
seen[from] = true;
set<int> edges = graph[from];
for (auto to : edges) {
if (!seen[to] && !removed[from]) dfs(to);
}
const int deg = graph[from].size();
if (deg % 2 == 0) {
removed[from] = true;
removedOrder.push_back(from);
for (auto to : graph[from]) graph[to].erase(from);
graph[from].clear();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
graph.assign(n, set<int>());
for (int i = 0; i < n; ++i) {
int p;
cin >> p;
if (p) {
--p;
graph[i].insert(p);
graph[p].insert(i);
}
}
removed.assign(n, false);
for (int i = 0; i < n; ++i) {
if (!removed[i]) {
seen.assign(n, false);
dfs(i);
}
}
if (removedOrder.size() == n) {
cout << "YES\n";
for (auto v : removedOrder) cout << v + 1 << '\n';
} else {
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 9;
const int MAXN = 200200;
vector<int> g[MAXN];
int del[MAXN];
int deg[MAXN];
void dfs1(int v, int p = -1) {
del[v] = 1;
cout << v + 1 << endl;
for (int u : g[v]) {
if (u == p) {
continue;
}
if (!del[u]) {
dfs1(u, v);
}
}
}
void dfs(int v, int p = -1) {
for (int u : g[v]) {
if (u == p) {
continue;
}
dfs(u, v);
}
int deg = (int)(g[v]).size();
for (int u : g[v]) {
if (u == p) {
continue;
}
if (del[u]) {
--deg;
}
}
if (deg % 2 == 0) {
dfs1(v, p);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> p(n);
for (int i = 0; i < n; ++i) {
cin >> p[i];
--p[i];
if (p[i] != -1) {
g[p[i]].push_back(i);
g[i].push_back(p[i]);
}
}
if (n == 1) {
cout << "YES" << endl;
cout << 1 << endl;
return 0;
}
int e = 0;
for (int i = 0; i < n; ++i) {
if ((int)(g[i]).size() % 2 == 0) {
++e;
}
}
if (e % 2 == 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
dfs(0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
struct Gragh {
int cnt, y[N * 2], nxt[N * 2], fst[N];
void clear() {
cnt = 0;
memset(fst, 0, sizeof fst);
}
void add(int a, int b) { y[++cnt] = b, nxt[cnt] = fst[a], fst[a] = cnt; }
} g;
int n, dp[N];
vector<int> sted[N];
bool spec_cmp(int a, int b) { return dp[a] < dp[b]; }
void solve(int x, int pre) {
int cnt = 1;
sted[x].clear();
for (int i = g.fst[x]; i; i = g.nxt[i])
if (g.y[i] != pre) {
solve(g.y[i], x);
cnt++;
sted[x].push_back(g.y[i]);
}
sort(sted[x].begin(), sted[x].end(), spec_cmp);
if (sted[x].size() == 0) {
dp[x] = 1;
return;
}
for (int i = 0; i < sted[x].size(); i++) {
if (dp[sted[x][i]]) break;
cnt--;
}
dp[x] = cnt & 1;
}
void dfs2(int x) {
int i = 0;
while (i < sted[x].size() && dp[sted[x][i]] == 0) dfs2(sted[x][i]), i++;
printf("%d\n", x);
while (i < sted[x].size()) dfs2(sted[x][i]), i++;
}
int main() {
g.clear();
scanf("%d", &n);
for (int i = 1, p; i <= n; i++) {
scanf("%d", &p);
if (p != 0) g.add(i, p), g.add(p, i);
}
solve(1, 0);
if (dp[1] == 1) {
puts("YES");
dfs2(1);
} else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 1000005;
int n, v[Nmax], degree[Nmax], solved[Nmax];
vector<int> L[Nmax], Depend[Nmax], Sol;
void deleteNode(int node) {
solved[node] = 1;
Sol.push_back(node);
for (auto it : L[node]) --degree[it];
}
void clearNode(int node) {
deleteNode(node);
for (auto it : Depend[node]) clearNode(it);
}
void dfs(int node, int tata) {
vector<int> Bad, Good;
for (auto it : L[node]) {
if (it == tata) continue;
dfs(it, node);
if (solved[it]) continue;
Depend[node].push_back(it);
}
if (degree[node] % 2 == 0) clearNode(node);
}
int main() {
scanf("%d", &n);
int rad;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x == 0)
rad = i;
else {
L[x].push_back(i);
L[i].push_back(x);
degree[i]++;
degree[x]++;
}
}
dfs(rad, 0);
if (Sol.size() < n) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (auto it : Sol) cout << it << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> node[200005], ans;
int cnt;
int n, p, rt;
bool vis[200005];
void dfshelper(int x) {
if (vis[x]) return;
vis[x] = true;
ans.push_back(x);
for (int i = 0; i < node[x].size(); i++) dfshelper(node[x][i]);
}
void dfs(int x) {
int deg = 0;
if (x != rt) deg++;
for (int i = 0; i < node[x].size(); i++) {
dfs(node[x][i]);
if (!vis[node[x][i]]) deg++;
}
if (deg % 2 == 0) dfshelper(x);
}
int main() {
scanf("%d", &n);
memset(vis, 0, sizeof(vis));
cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &p);
if (p != 0) cnt++;
node[p].push_back(i);
if (p == 0) rt = i;
}
if (cnt % 2) {
printf("NO\n");
return 0;
}
dfs(rt);
puts("YES");
for (int i = 0; i < ans.size(); i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[200000 + 5];
vector<int> sol;
bool dp[200000 + 5];
bool dfs(int idx, int p = -1) {
vector<int> D, ND;
for (auto x : edge[idx])
if (x != p) {
if (dfs(x, idx))
ND.push_back(x);
else
D.push_back(x);
}
if (ND.empty() && D.empty()) return dp[idx] = true;
if (ND.size() & 1) return dp[idx] = false;
return dp[idx] = true;
}
void backT(int idx, int p = -1) {
for (auto x : edge[idx])
if (x != p) {
if (!dp[x]) {
backT(x, idx);
}
}
sol.push_back(idx);
for (auto x : edge[idx])
if (x != p) {
if (dp[x]) {
backT(x, idx);
}
}
}
int main() {
int i, n, p;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &p);
if (p) {
edge[p].push_back(i);
edge[i].push_back(p);
}
}
if (dfs(1)) {
puts("YES");
backT(1);
for (auto x : sol) printf("%d\n", x);
} else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200100];
int sz[200100], root;
bool vist[200100];
void delSubtree(int u) {
vist[u] = true;
printf("%d\n", u);
for (auto v : g[u])
if (!vist[v]) delSubtree(v);
}
void DFS(int u, int p) {
int degree = 0;
for (auto v : g[u]) {
if (v == p) continue;
DFS(v, u);
if (!vist[v]) degree++;
}
if (u != root) degree++;
if (!(degree & 1)) delSubtree(u);
}
int main() {
int n, u;
scanf("%d", &n);
for (int v = 1; v <= n; v++) {
scanf("%d", &u);
if (u)
g[u].push_back(v);
else
root = v;
}
if (n & 1)
printf("YES\n"), DFS(root, 0);
else
printf("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool read(T &num) {
char in;
bool IsN = false;
while (in = getchar(), in != '-' && (in < '0' || in > '9'))
if (in == EOF) return false;
in == '-' ? (IsN = true, num = 0) : num = in - '0';
while (in = getchar(), in >= '0' && in <= '9') num = num * 10 + in - '0';
return IsN ? num = -num : num, true;
}
const int maxn = 2e5 + 7;
const int inf = 2e9 + 7;
const int mod = 1e9 + 7;
stack<int> tree;
vector<int> edge[maxn];
int deg[maxn];
vector<int> ans;
int fa[maxn], vis[maxn];
void dfs(int u, int p) {
tree.push(u);
fa[u] = p;
for (int i = (0); i < (edge[u].size()); i++) {
if (edge[u][i] != p) dfs(edge[u][i], u);
}
}
void gao(int u) {
ans.push_back(u);
vis[u] = 1;
for (int i = (0); i < (edge[u].size()); i++) {
int v = edge[u][i];
deg[v]--;
if (v == fa[u]) continue;
if (vis[v]) continue;
if (deg[v] % 2 == 0) gao(v);
}
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int root;
for (int i = (1); i < (n + 1); i++) {
int k;
cin >> k;
if (k) {
edge[i].push_back(k);
edge[k].push_back(i);
deg[k]++;
deg[i]++;
} else
root = i;
}
dfs(root, -1);
while (!tree.empty()) {
int u = tree.top();
tree.pop();
if (deg[u] % 2 == 0) {
gao(u);
}
}
if (ans.size() == n) {
cout << "YES" << endl;
for (int i = (0); i < (ans.size()); i++) cout << ans[i] << endl;
} else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200005], sol;
queue<int> q;
int deg[200005], t[200005];
bool viz[200005];
void dfs(int i);
void afiseaza(int i);
int main() {
int n, i, a, wait, root;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> a;
t[i] = a;
if (a) {
v[i].push_back(a);
v[a].push_back(i);
++deg[a];
++deg[i];
} else {
root = i;
}
}
dfs(root);
if (sol.size() < n) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (auto it = sol.begin(); it != sol.end(); ++it) {
cout << *it << '\n';
}
}
void dfs(int i) {
for (auto it = v[i].begin(); it != v[i].end(); ++it) {
if (*it != t[i]) {
dfs(*it);
}
}
if (deg[i] % 2 == 0) {
afiseaza(i);
--deg[t[i]];
}
}
void afiseaza(int i) {
viz[i] = 1;
sol.push_back(i);
for (auto it = v[i].begin(); it != v[i].end(); ++it) {
if (*it != t[i] && !viz[*it]) {
afiseaza(*it);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long x) { return x * x; }
int mysqrt(long long x) {
int l = 0, r = 1e9 + 1;
while (r - l > 1) {
int m = (l + r) / 2;
if (m * (long long)m <= x)
l = m;
else
r = m;
}
return l;
}
mt19937 rnd(1227);
mt19937_64 rndll(12365);
long long AR = 19, BR = 13, CR = 23, XR = 228, YR = 322, MODR = 1e9 + 993;
long long myrand() {
long long ZR = (XR * AR + YR * BR + CR) % MODR;
XR = YR;
YR = ZR;
return ZR;
}
const int Mod = 1e9 + 9;
int bpow(int x, int y) {
if (y == 0) return 1;
if (y == 1) return x;
int ret = bpow(x, y >> 1);
ret = (ret * (long long)ret) % Mod;
if (y & 1) ret = (ret * (long long)x) % Mod;
return ret;
}
int bdiv(int x, int y) { return (x * (long long)bpow(y, Mod - 2)) % Mod; }
void setmin(int &x, int y) { x = min(x, y); }
void setmax(int &x, int y) { x = max(x, y); }
void setmin(long long &x, long long y) { x = min(x, y); }
void setmax(long long &x, long long y) { x = max(x, y); }
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
const long long llinf = 2e18 + 100;
const double eps = 1e-9;
const int maxn = 2e5 + 100, maxw = 1e7 + 100, inf = 2e9 + 100, sq = 300,
mod = 1e9 + 9, LG = 17;
int n;
vector<int> e[maxn];
int a[maxn];
vector<int> ans;
bool vis[maxn];
void go(int v, int par) {
ans.push_back(v);
vis[v] = 1;
for (int i : e[v])
if (i != par && !vis[i]) go(i, v);
}
void dfs(int v, int par) {
for (int i : e[v])
if (i != par) {
dfs(i, v);
if (vis[i]) a[v] ^= 1;
}
if (a[v] == 0) go(v, par);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int v = i, u;
cin >> u;
u--;
if (u >= 0) {
e[v].push_back(u);
e[u].push_back(v);
a[v] ^= 1;
a[u] ^= 1;
}
}
dfs(0, -1);
if (ans.size() < n)
cout << "NO";
else {
cout << "YES\n";
for (int i : ans) cout << i + 1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
void boost() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 1e6;
const long long inf = 1e9 + 9;
const long double PI = acos(-1);
long long bin_pow(long long x, long long y) {
long long res = 1, base = x;
while (y) {
if (y & 1) {
res *= base;
res %= inf;
}
base *= base;
base %= inf;
y /= 2;
}
return res;
}
int n;
vector<int> g[N];
int sz[N], cnt[N];
bool used[N];
queue<int> q;
void dfs(int v, int pr = -1) {
sz[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == pr) {
continue;
}
dfs(to, v);
sz[v] += sz[to];
if (sz[to] % 2 == 0) {
cnt[v]++;
}
}
if (v != 1 && (sz[v] & 1)) {
cnt[v]++;
}
}
int main() {
boost();
cin >> n;
if (n % 2 == 0) {
cout << "NO";
return 0;
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x != 0) {
g[x].push_back(i);
g[i].push_back(x);
}
}
dfs(1);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (cnt[i] == 0) {
q.push(i);
}
}
while (!q.empty()) {
int v = q.front();
q.pop();
ans.push_back(v);
used[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (used[to]) {
continue;
}
cnt[to]--;
if (cnt[to] == 0) {
q.push(to);
}
}
}
cout << "YES\n";
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d[200005], a[200005], id[200005], t;
vector<int> g[200005];
void dfs(int v, int p) {
t++;
id[t] = v;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
dfs(to, v);
}
if (d[v] % 2 == 0) {
cout << v << endl;
d[p]--;
a[v] = 1;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int p;
cin >> p;
if (p) {
g[i].push_back(p);
g[p].push_back(i);
d[i]++;
d[p]++;
}
}
if (n % 2 == 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
dfs(1, 0);
for (int i = 1; i <= n; i++)
if (!a[id[i]]) cout << id[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void gmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
inline void gmin(T &x, T y) {
x = x < y ? x : y;
}
const int MAXN = 200010;
int n, rt;
int f[MAXN];
int dp[MAXN];
vector<int> G[MAXN];
void dfs(int x) {
int sz = G[x].size();
for (register unsigned i = 0; i < G[x].size(); i++) {
int y = G[x][i];
dfs(y);
if (dp[y]) sz--;
}
dp[x] = sz & 1;
}
void dfs2(int x) {
for (register unsigned i = 0; i < G[x].size(); i++) {
int y = G[x][i];
if (dp[y]) dfs2(y);
}
printf("%d\n", x);
for (register unsigned i = 0; i < G[x].size(); i++) {
int y = G[x][i];
if (!dp[y]) dfs2(y);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &f[i]), G[f[i]].push_back(i);
for (int i = 1; i <= n; i++)
if (!f[i]) {
rt = i;
break;
}
dfs(rt);
if (!dp[rt]) {
puts("YES");
dfs2(rt);
} else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, p[N], la[N], ne[N], rt, d[N];
int an[N], ans, f[N][3], ct[N][3], b[N];
void dfs(int x) {
for (int i = la[x]; i; i = ne[i]) dfs(i);
int cnt = 0, cnt2 = 0, cnt3 = 0, cnt4 = 0;
for (int i = la[x]; i; i = ne[i]) {
cnt += f[i][2];
if (f[i][2])
cnt2 += f[i][1];
else
cnt3 += f[i][1];
}
ct[x][1] = cnt;
ct[x][2] = cnt2;
ct[x][3] = cnt3;
if ((!((d[x] - cnt) & 1) || cnt2 > 0) && (cnt3 + cnt == d[x])) f[x][1] = 1;
if ((((d[x] - cnt) & 1) || cnt2 > 0) && (cnt3 + cnt == d[x])) f[x][2] = 1;
}
void fi(int x, int st) {
int ne1;
b[x] = st;
if (st == 1)
ne1 = !((d[x] - ct[x][1]) & 1) && ct[x][2] > 0;
else
ne1 = ((d[x] - ct[x][1]) & 1) && ct[x][2] > 0;
for (int i = la[x]; i; i = ne[i]) {
if (f[i][2]) {
fi(i, 2);
if (ne1 && f[i][1]) ne1--, fi(i, 1);
}
}
an[++ans] = x;
for (int i = la[x]; i; i = ne[i])
if (!b[i]) fi(i, 1);
}
int main() {
scanf("%d", &n);
for (int i = 1, E = n; i <= E; i++)
scanf("%d", &p[i]),
(p[i] ? ne[i] = la[p[i]], la[p[i]] = i, d[p[i]]++ : rt = i);
dfs(rt);
if (f[rt][1]) {
printf("YES\n");
fi(rt, 1);
for (int i = 1, E = n; i <= E; i++) printf("%d ", an[i]);
} else
printf("NO\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int vis[200005], sum[200005], pre[200005], n, start;
vector<int> v[200005];
queue<int> q;
void del(int x) {
printf("%d\n", x);
vis[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
sum[y]--;
if (!vis[y] && y != pre[x] && sum[y] % 2 == 0) {
del(y);
}
}
}
void dfs(int p, int x) {
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (y != p) dfs(x, y);
}
q.push(x);
pre[x] = p;
}
int main() {
scanf("%d", &n);
memset(sum, 0, sizeof(sum));
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x) {
v[i].push_back(x);
v[x].push_back(i);
sum[i]++;
sum[x]++;
}
}
if (n & 1) {
printf("YES\n");
dfs(0, 1);
while (!q.empty()) {
int x = q.front();
q.pop();
if (sum[x] % 2 == 0) {
del(x);
}
}
} else {
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int MOD = 1e9 + 9;
int n;
vector<int> v[N];
int pa[N];
int f[N][2];
vector<int> t[N][2];
int q[N];
void BFS() {
int top = 1, bot = 1;
q[1] = 1;
while (top <= bot) {
int x = q[top++];
for (auto y : v[x])
if (y != pa[x]) {
pa[y] = x;
q[++bot] = y;
}
}
}
void trace(int x, int label) {
int n1 = v[x].size();
for (int i = n1 - 1; i >= 0; i--) {
int y = v[x][i];
if (y == pa[x]) continue;
int use = t[x][label][i];
if (use == 0) trace(y, use);
}
cout << x << " ";
for (int i = n1 - 1; i >= 0; i--) {
int y = v[x][i];
if (y == pa[x]) continue;
int use = t[x][label][i];
if (use == 1) trace(y, use);
}
}
int tr[2][2][N];
int cf[2][2], tf[2][2];
void solve() {
BFS();
for (int j = n; j >= 1; j--) {
int cur = q[j];
memset(cf, 0, sizeof(cf));
cf[1][0] = cf[0][1] = 1;
int n1 = v[cur].size();
for (int i = 0; i < n1; i++) {
int y = v[cur][i];
if (y == pa[cur]) continue;
for (int k0 = 0; k0 <= 1; k0++)
for (int k1 = 0; k1 <= 1; k1++) tf[k0][k1] = cf[k0][k1];
memset(cf, 0, sizeof(cf));
for (int k0 = 0; k0 <= 1; k0++)
for (int k1 = 0; k1 <= 1; k1++)
if (tf[k0][k1]) {
for (int last = 0; last <= 1; last++)
if (f[y][last]) {
cf[k0 ^ last][k1] = 1;
tr[k0 ^ last][k1][i] = last;
}
}
}
for (int i = 0; i <= 1; i++) {
f[cur][i] = cf[0][i];
int st = 0;
t[cur][i].resize(n1);
for (int j = n1 - 1; j >= 0; j--) {
int y = v[cur][j];
if (y == pa[cur]) continue;
t[cur][i][j] = tr[st][i][j];
st ^= tr[st][i][j];
}
}
}
if (f[1][1]) {
cout << "YES\n";
v[1].push_back(0);
t[1][0].push_back(0);
t[1][1].push_back(0);
trace(1, 1);
return;
}
cout << "NO";
}
int main() {
cin >> n;
if (n % 2 == 0) {
cout << "NO";
return 0;
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x != 0) {
v[x].push_back(i);
v[i].push_back(x);
}
}
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 1; j++) t[i][j].resize(v[i].size());
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 222222;
int n, p[N], f[N];
vector<int> v[N];
void dfs0(int u) {
int i = v[u].size();
while (i--) {
dfs0(v[u][i]);
f[u] ^= f[v[u][i]];
}
f[u] ^= 1;
}
void dfs(int u) {
int i = v[u].size(), x;
while (i--) {
x = v[u][i];
if (!f[x]) dfs(x);
}
cout << u << endl;
i = v[u].size();
while (i--) {
x = v[u][i];
if (f[x]) dfs(x);
}
}
int main() {
int i, rt;
scanf("%d", &n);
for (i = 1; i <= n; i = i + 1) {
scanf("%d", p + i);
if (p[i])
v[p[i]].push_back(i);
else
rt = i;
}
dfs0(rt);
if (!f[rt])
cout << "NO\n";
else {
cout << "YES\n";
dfs(rt);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, bb, first[200100], size[200100], ds[200100], ans[200100], aa;
struct Bn {
int to, next;
} bn[200100 << 1];
vector<int> vec[200100];
queue<int> que;
inline void add(int u, int v) {
bb++;
bn[bb].to = v;
bn[bb].next = first[u];
first[u] = bb;
}
void gs(int now, int last) {
int p, q;
size[now] = 1;
for (p = first[now]; p != -1; p = bn[p].next) {
if (bn[p].to == last) continue;
gs(bn[p].to, now);
size[now] += size[bn[p].to];
}
}
void dfs(int now, int last) {
int p;
for (p = first[now]; p != -1; p = bn[p].next) {
if (bn[p].to == last) continue;
if (size[bn[p].to] % 2) {
vec[now].push_back(bn[p].to);
ds[bn[p].to]++;
} else {
vec[bn[p].to].push_back(now);
ds[now]++;
}
dfs(bn[p].to, now);
}
}
int main() {
memset(first, -1, sizeof(first));
int i, j, p, q;
cin >> n;
for (i = 1; i <= n; i++) {
scanf("%d", &p);
if (p) add(p, i), add(i, p);
}
if (n % 2 == 0) {
puts("NO");
return 0;
}
puts("YES");
gs(1, -1);
dfs(1, -1);
for (i = 1; i <= n; i++) {
if (!ds[i]) que.push(i);
}
for (; !que.empty();) {
p = que.front();
que.pop();
printf("%d\n", p);
for (i = 0; i < vec[p].size(); i++) {
ds[vec[p][i]]--;
if (!ds[vec[p][i]]) {
que.push(vec[p][i]);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 212345;
int par[N];
vector<int> g[N];
int num[N], adj[N], ct, vis[N];
void dfs(int u) {
num[u] = ct++;
for (auto v : g[u]) dfs(v);
}
int main(void) {
int n;
scanf("%d", &n);
int root = -1;
for (int i = 1; i <= n; i++) {
int p;
scanf("%d", &p);
g[p].push_back(i);
par[i] = p;
if (!p)
root = i;
else {
adj[i]++;
adj[p]++;
}
}
dfs(root);
set<pair<int, int> > s;
for (int i = 1; i <= n; i++) {
if (par[i]) g[i].push_back(par[i]);
if (adj[i] % 2 == 0) {
s.emplace(-num[i], i);
}
}
vector<int> ans;
while (!s.empty()) {
int u = s.begin()->second;
s.erase(s.begin());
vis[u] = 1;
for (auto v : g[u]) {
if (vis[v]) continue;
if (adj[v] % 2) {
s.emplace(-num[v], v);
} else {
s.erase(make_pair(-num[v], v));
}
adj[v]--;
}
ans.push_back(u);
}
if (ans.size() == n) {
printf("YES\n");
for (int i = 0; i < n; i++) printf("%d\n", ans[i]);
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300100;
int n, x, l[N], deg[N];
bool mark[N];
set<pair<int, int> > v[N];
vector<int> g[N];
vector<int> q;
vector<int> res;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
x--;
if (x != -1) {
g[x].push_back(i);
g[i].push_back(x);
}
}
for (int i = 0; i < n; i++) {
l[i] = -1;
}
l[0] = 0;
q.push_back(0);
for (int i = 0; i < q.size(); i++) {
int now = q[i];
for (int j = 0; j < g[now].size(); j++) {
int tmp = g[now][j];
if (l[tmp] == -1) {
q.push_back(tmp);
l[tmp] = l[now] + 1;
}
}
}
for (int i = 0; i < n; i++) {
mark[i] = false;
deg[i] = g[i].size();
v[g[i].size() % 2].insert(make_pair(-l[i], i));
}
for (int i = 0; i < n; i++) {
if (v[0].size() == 0) {
puts("NO");
exit(0);
}
int now = (*v[0].begin()).second;
mark[now] = true;
v[0].erase(v[0].begin());
res.push_back(now + 1);
for (int j = 0; j < g[now].size(); j++) {
int tmp = g[now][j];
if (mark[tmp]) {
continue;
}
v[deg[tmp] & 1].erase(make_pair(-l[tmp], tmp));
deg[tmp]--;
v[deg[tmp] & 1].insert(make_pair(-l[tmp], tmp));
}
}
puts("YES");
for (int i = 0; i < res.size(); i++) {
printf("%d\n", res[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sz[200010];
int vis[200010];
int p[200010];
vector<int> son[200010];
void del(int x) {
vis[x] = 1;
cout << x << endl;
for (int i = 0; i < son[x].size(); i++)
if (!vis[son[x][i]]) del(son[x][i]);
}
void dfs(int x) {
sz[x] = 1;
for (int i = 0; i < son[x].size(); i++)
dfs(son[x][i]), sz[x] += sz[son[x][i]];
if (!(sz[x] & 1)) del(x);
}
int main() {
int n;
int root;
cin >> n;
if (n & 1)
cout << "YES" << endl;
else
return cout << "NO" << endl, 0;
for (int i = 1; i <= n; i++) {
cin >> p[i];
if (p[i])
son[p[i]].push_back(i);
else
root = i;
}
dfs(root);
del(root);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.