text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 100 * 1000 + 10;
int n, startPoint;
int sz[N], out[N];
vector<int> child[N], in[N];
void input() {
cin.tie(0);
cin >> n;
for (int i = 0, u; i < n; i++) {
cin >> u;
if (u != 0)
child[u - 1].push_back(i);
else
startPoint = i;
}
return;
}
int DFS(int v) {
int res = 1;
for (auto u : child[v]) {
int tmp = DFS(u);
if (tmp % 2) {
in[v].push_back(u);
out[u]++;
} else {
in[u].push_back(v);
out[v]++;
}
res += tmp;
}
return res;
}
void solve() {
cout.tie(0);
cout << "YES\n";
set<pair<int, int> > st;
for (int i = 0; i < n; i++) st.insert({out[i], i});
for (int i = 0; i < n; i++) {
pair<int, int> p = *(st.begin());
st.erase(st.begin());
cout << p.second + 1 << '\n';
for (auto u : in[p.second]) {
st.erase({out[u], u});
st.insert({--out[u], u});
}
}
return;
}
int main() {
ios::sync_with_stdio(false);
input();
if (n % 2) {
DFS(startPoint);
solve();
} else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
long long int gcd(long long int a, long long int b) {
return (a ? gcd(b % a, a) : b);
}
long long int modPow(long long int a, long long int b, long long int MOD) {
long long int x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y) % MOD;
}
b /= 2;
y = (y * y) % MOD;
}
return x;
}
long long int modInverse(long long int a, long long int p) {
return modPow(a, p - 2, p);
}
using namespace std;
const int N = 2e5 + 5;
vector<int> adj[N];
set<pair<int, int> > myset;
int degree[N], level[N], marked[N], deleted[N];
void dfs(int src, int lvl) {
marked[src] = 1;
level[src] = lvl;
if (degree[src] % 2 == 0) myset.insert({-level[src], src});
for (auto child : adj[src]) {
if (!marked[child]) dfs(child, (lvl + 1));
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, u, v, i, root;
cin >> n;
for (auto i = (1); i <= (n); i++) {
cin >> u;
if (u) {
adj[u].push_back(i);
adj[i].push_back(u);
degree[u]++;
degree[i]++;
} else
root = i;
}
dfs(root, 0);
vector<int> res;
while (!myset.empty()) {
auto itr = myset.begin();
res.push_back(itr->second);
deleted[itr->second] = 1;
for (auto x : adj[itr->second]) {
if (!deleted[x]) {
degree[x]--;
degree[itr->second]--;
if (degree[x] % 2 == 0)
myset.insert({-level[x], x});
else
myset.erase(myset.find({-level[x], x}));
}
}
myset.erase(itr);
}
for (auto i = (1); i <= (n); i++) {
if (degree[i]) {
cout << "NO";
return 0;
}
}
cout << "YES\n";
for (auto i = 0; i < (n); i++) cout << res[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void dfs(int u, int p, const vector<vector<int> >& g, vector<int>& depth) {
depth[u] = depth[p] + 1;
for (int v : g[u]) {
if (v == p) {
continue;
}
dfs(v, u, g, depth);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
if (n % 2 == 0) {
cout << "NO";
return 0;
}
vector<vector<int> > g(n);
vector<int> deg(n, 0);
int root = -1;
for (int i = 0; i < n; ++i) {
int p;
cin >> p;
--p;
if (p == -1) {
root = i;
} else {
g[p].push_back(i);
g[i].push_back(p);
++deg[i];
++deg[p];
}
}
vector<int> depth(n);
depth[root] = 0;
dfs(root, root, g, depth);
priority_queue<pair<int, int> > pq;
for (int i = 0; i < n; ++i) {
if (deg[i] % 2 == 0) {
pq.push(make_pair(depth[i], i));
}
}
vector<int> res;
vector<bool> deleted(n, false);
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
if (deleted[u] || deg[u] & 1) {
continue;
}
deg[u] = 0;
deleted[u] = true;
res.push_back(u);
for (int v : g[u]) {
if (!deleted[v]) {
--deg[v];
if (deg[v] % 2 == 0) {
pq.push(make_pair(depth[v], v));
}
}
}
}
cout << "YES\n";
for (int u : res) {
cout << u + 1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
unsigned char *f;
vector<vector<int>> subs;
int i, k;
int main() {
char dfs_f(int x);
void dfs_print(int x);
scanf("%d", &n);
if (n == 1) {
printf("YES\n1\n");
return 0;
} else if (n % 2 == 0) {
printf("NO\n");
return 0;
}
f = (unsigned char *)malloc(n + 1);
subs.resize(n + 1);
for (i = 0; i < n; ++i) {
scanf("%d", &k);
subs[k].push_back(i + 1);
}
k = subs[0].front();
dfs_f(k);
printf("YES\n");
dfs_print(k);
return 0;
}
char dfs_f(int x) {
f[x] = 0;
if (subs[x].size() == 0) return 0;
for (vector<int>::iterator it = subs[x].begin(); it != subs[x].end(); ++it)
if (dfs_f(*it) == 0) ++f[x];
f[x] &= 1;
return f[x];
}
void dfs_print(int x) {
for (vector<int>::iterator it = subs[x].begin(); it != subs[x].end(); ++it)
if (f[*it]) dfs_print(*it);
printf("%d\n", x);
for (vector<int>::iterator it = subs[x].begin(); it != subs[x].end(); ++it)
if (!f[*it]) dfs_print(*it);
}
|
#include <bits/stdc++.h>
using namespace std;
int p[200200];
vector<int> g[200200];
int size[200200];
vector<int> res;
void dfs(int v) {
size[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
dfs(g[v][i]);
size[v] += size[g[v][i]];
}
}
void solve(int v, bool f = 0) {
int cnt = 0;
for (int i = 0; i < g[v].size(); i++) {
if (size[g[v][i]] % 2 == 0) {
cnt++;
}
}
if (size[v] % 2) {
if (f == 1) {
printf("NO\n");
exit(0);
} else {
for (int i = 0; i < g[v].size(); i++) {
if (size[g[v][i]] % 2 == 0) solve(g[v][i], 1);
}
res.push_back(v);
for (int i = 0; i < g[v].size(); i++) {
if (size[g[v][i]] % 2 == 1) solve(g[v][i]);
}
}
} else {
if (f == 0) {
printf("NO\n");
exit(0);
} else {
for (int i = 0; i < g[v].size(); i++) {
if (size[g[v][i]] % 2 == 0) solve(g[v][i], 1);
}
res.push_back(v);
for (int i = 0; i < g[v].size(); i++) {
if (size[g[v][i]] % 2 == 1) solve(g[v][i]);
}
}
}
}
int main() {
int n;
scanf("%d", &n);
int v;
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
if (p[i] != 0)
g[p[i]].push_back(i);
else
v = i;
}
if (n % 2 == 0) {
printf("NO\n");
return 0;
}
dfs(v);
solve(v);
printf("YES\n");
for (int i = 0; i < res.size(); i++) {
printf("%d\n", res[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 3e6;
const long long mod = 1e9 + 7;
const long double PI = acos((long double)-1);
long long pw(long long a, long long b, long long md = mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = (a * res) % md;
}
a = (a * a) % md;
b >>= 1;
}
return (res);
}
int n;
vector<int> adj[maxn];
int par[maxn];
bool sik[maxn];
void solve(int v) {
cout << v << '\n';
sik[v] = 1;
for (auto u : adj[v])
if (!sik[u] and u != par[v]) solve(u);
}
int dfs(int v) {
int s = 0;
for (auto u : adj[v])
if (u != par[v]) par[u] = v, s += dfs(u);
if (s % 2) solve(v);
return (++s);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> par[i];
if (!par[i]) continue;
adj[i].push_back(par[i]);
adj[par[i]].push_back(i);
}
memset(par, 0, sizeof par);
;
if (n % 2 == 0) return (cout << "NO", 0);
;
cout << "YES" << '\n';
dfs(1);
solve(1);
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 5;
int deg[N];
vector<int> G[N];
bool done[N];
void split(int u, int f) {
cout << u << '\n';
done[u] = true;
for (int v : G[u]) deg[v] ^= 1;
for (int v : G[u])
if (v != f and !done[v]) {
if (!deg[v]) split(v, u);
}
}
void dfs(int u, int f) {
for (int v : G[u])
if (v != f) {
dfs(v, u);
}
if (!deg[u]) split(u, f);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x == 0) continue;
deg[x] ^= 1;
deg[i] ^= 1;
G[x].push_back(i);
G[i].push_back(x);
}
if (n % 2 == 0)
cout << "NO\n";
else
cout << "YES\n", dfs(1, 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void JIZZ(string output = "") {
cout << output;
exit(0);
}
const long double PI = 3.14159265358979323846264338327950288;
const long double eps = 1e-13;
const long long mod = 1e9 + 7;
vector<int> G[200005];
int p[200005], dep[200005], deg[200005];
bitset<200005> inq, del;
vector<int> ans;
void go(int now, int pa) {
if (del[now]) return;
ans.push_back(now);
del[now] = 1;
for (int i : G[now]) {
if (i != pa) go(i, now);
}
}
void dfs(int now, int pa) {
;
;
for (int i : G[now]) {
if (i == pa) continue;
dfs(i, now);
}
if (deg[now] % 2 == 0) {
go(now, pa);
--deg[pa];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
if (n == 1) exit((cout << "YES\n1\n", 0));
if (n == 2) exit((cout << "NO" << endl, 0));
int root = 0;
for (int i = 1; i <= n; ++i) {
int pa;
cin >> pa;
if (pa)
G[pa].push_back(i), G[i].push_back(pa);
else
root = i;
}
for (int i = 1; i <= n; ++i) deg[i] = G[i].size();
dfs(root, root);
;
;
if (ans.size() != n) exit((cout << "NO" << endl, 0));
cout << "YES" << endl;
for (int i : ans) cout << i << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
template <class T, class U>
inline void add_self(T &a, U b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
}
template <class T, class U>
inline void min_self(T &x, U y) {
if (y < x) x = y;
}
template <class T, class U>
inline void max_self(T &x, U y) {
if (y > x) x = y;
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
cout << t;
;
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <class T, class U>
void print_m(const map<T, U> &m, int w = 3) {
if (m.empty()) {
cout << "Empty" << endl;
return;
}
for (auto x : m) cout << "(" << x.first << ": " << x.second << ")," << endl;
cout << endl;
}
template <class T, class U>
void debp(const pair<T, U> &pr, bool end_line = 1) {
cout << "{" << pr.first << " " << pr.second << "}";
cout << (end_line ? "\n" : ", ");
}
template <class T>
void print_vp(const T &vp, int sep_line = 0) {
if (vp.empty()) {
cout << "Empty" << endl;
return;
}
if (!sep_line) cout << "{ ";
for (auto x : vp) debp(x, sep_line);
if (!sep_line) cout << "}\n";
cout << endl;
}
template <typename T>
void print(const T &v, bool show_index = false) {
int w = 2;
if (show_index) {
for (int i = 0; i < int((v).size()); i++) cout << setw(w) << i << " ";
cout << endl;
}
for (auto &el : v) cout << setw(w) << el << " ";
cout << endl;
}
template <typename T>
void print_vv(const T &vv) {
if (int((vv).size()) == 0) {
cout << "Empty" << endl;
return;
}
int w = 3;
cout << setw(w) << " ";
for (int j = 0; j < int((*vv.begin()).size()); j++)
cout << setw(w) << j << " ";
cout << endl;
int i = 0;
for (auto &v : vv) {
cout << i++ << " {";
for (auto &el : v) cout << setw(w) << el << " ";
cout << "},\n";
}
cout << endl;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
print(v);
return os;
};
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &vv) {
print_vv(vv);
return os;
};
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &m) {
print_m(m);
return os;
};
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &pr) {
debp(pr);
return os;
};
template <class T, class U>
ostream &operator<<(ostream &os, const vector<pair<T, U>> &vp) {
print_vp(vp);
return os;
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
while (cin >> n) {
vector<vector<int>> adj(n + 1);
int root = 0;
for (int i = int(1); i < int(n + 1); i++) {
int p;
cin >> p;
if (p) {
adj[i].push_back(p);
adj[p].push_back(i);
} else {
root = i;
}
}
if (n % 2 == 0) {
cout << "NO\n";
continue;
} else {
cout << "YES\n";
}
vector<int> order;
vector<bool> used(n + 1);
vector<int> cnt(n + 1);
for (int i = int(1); i < int(n + 1); i++) {
cnt[i] = int((adj[i]).size());
}
function<void(int, int)> dfs = [&](int node, int p) {
for (auto ad : adj[node]) {
if (ad == p) continue;
dfs(ad, node);
}
if (cnt[node] % 2 == 0) {
queue<int> q;
q.push(node);
while (!q.empty()) {
auto top = q.front();
q.pop();
assert(cnt[top] % 2 == 0);
order.push_back(top);
used[top] = 1;
for (auto ad : adj[top]) {
if (ad == p || used[ad]) continue;
cnt[ad]--;
q.push(ad);
}
}
cnt[p]--;
}
};
dfs(root, 0);
print(order);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int deg[200040], erased[200500], depth[200040];
void dfs(int x, int d, vector<vector<int>>& adj, int pa) {
for (auto u : adj[x])
if (u != pa) dfs(u, d + 1, adj, x);
depth[x] = d;
}
int main() {
int n;
cin >> n;
vector<vector<int>> adj(n + 1);
int root;
for (int i = 1; i <= n; i++) {
int p;
cin >> p;
if (p == 0) {
root = i;
continue;
}
adj[p].push_back(i);
adj[i].push_back(p);
deg[i]++;
deg[p]++;
}
dfs(root, 0, adj, 0);
set<pair<int, int>> S;
for (int i = 1; i <= n; i++) {
if (deg[i] % 2 == 0) S.insert({-depth[i], i});
}
vector<int> res;
while (!S.empty()) {
int x = (*S.begin()).second;
S.erase({-depth[x], x});
erased[x] = 1;
for (auto u : adj[x]) {
if (erased[u]) continue;
deg[u]--;
if (deg[u] % 2 == 0) {
S.insert({-depth[u], u});
} else
S.erase({-depth[u], u});
}
res.push_back(x);
}
if (res.size() != n) {
cout << "NO";
return 0;
}
cout << "YES\n";
for (auto u : res) {
cout << u << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
vector<int> edge[(int)2E5 + 10];
stack<int> sta;
int parent[(int)2E5 + 10];
int flag[(int)2E5 + 10];
int dge[(int)2E5 + 10];
void dfs(int p, int i) {
parent[i] = p;
sta.push(i);
int len = edge[i].size();
for (int j = 0; j < len; j++) {
int r = edge[i][j];
if (r == p) continue;
dfs(i, r);
}
}
void dfs2(int i) {
if (dge[i] % 2 == 0) {
ans.push_back(i);
flag[i] = 1;
for (int j = 0; j < edge[i].size(); j++) {
int r = edge[i][j];
dge[r]--;
if (r == parent[i] || flag[r]) continue;
dfs2(r);
}
} else {
for (int j = 0; j < edge[i].size(); j++) {
int r = edge[i][j];
if (r == parent[i] || flag[r]) continue;
dfs2(r);
}
}
}
int main() {
int n, x, heap;
while (~scanf("%d", &n)) {
memset(flag, 0, sizeof(flag));
memset(parent, 0, sizeof(parent));
memset(dge, 0, sizeof(dge));
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (x) {
edge[i].push_back(x);
edge[x].push_back(i);
dge[i]++;
dge[x]++;
} else
heap = i;
}
dfs(0, heap);
int len = sta.size();
for (int i = 1; i <= len; i++) {
int point = sta.top();
sta.pop();
if (dge[point] % 2 == 0) {
dfs2(point);
}
}
if (ans.size() == n) {
printf("YES\n");
for (int i = 0; i < n; i++) printf("%d\n", ans[i]);
} else
printf("NO\n");
vector<int>().swap(ans);
for (int i = 0; i <= n; i++) vector<int>().swap(edge[i]);
while (!sta.empty()) sta.pop();
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
int n, root, tag[300000], fa[300000];
vector<int> G[300000];
stack<int> S;
int DFS(int now) {
int chi = G[now].size() - 1;
int cnt = 0;
for (int i = 0; i <= chi; ++i) {
int to = G[now][i];
if (to == fa[now]) continue;
int now = DFS(to);
cnt += now;
}
if (cnt & 1 && !fa[now]) {
printf("NO\n");
exit(0);
}
if (cnt & 1 || (!(cnt & 1) && !fa[now])) {
tag[now] = 1;
S.push(now);
return 0;
} else
return 1;
}
void DFS2(int now) {
tag[now] = 1;
for (int i = 0; i < (int)G[now].size(); i++) {
if (G[now][i] == fa[now] || !tag[G[now][i]]) continue;
DFS2(G[now][i]);
}
printf("%d\n", now);
for (int i = 0; i < (int)G[now].size(); i++) {
if (G[now][i] == fa[now] || tag[G[now][i]]) continue;
DFS2(G[now][i]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", fa + i);
if (!fa[i]) {
root = i;
continue;
}
G[i].push_back(fa[i]);
G[fa[i]].push_back(i);
}
DFS(root);
if (!S.size()) return 0 * puts("NO");
printf("YES\n");
DFS2(root);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long m);
long long modInverse(long long n, long long m);
long long nCr(long long n, long long r, long long m);
long long ceiling(long long x, long long y);
bool sortbyth(const tuple<long long, int, int>& a,
const tuple<long long, int, int>& b) {
if (get<0>(a) != get<0>(b))
return get<0>(a) > get<0>(b);
else
return get<1>(a) < get<1>(b);
}
int dx[] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[] = {-1, 0, 1, 1, 1, 0, -1, -1};
void aksayushx() {
int n;
cin >> n;
vector<vector<int>> adj(n);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
--x;
if (x >= 0) {
adj[i].push_back(x);
adj[x].push_back(i);
}
}
vector<int> degree(n, 0);
for (int i = 0; i < n; i++) degree[i] = (long long)adj[i].size();
if (n % 2 == 0) {
cout << "NO\n";
return;
}
int root = -1;
vector<int> ans, dep(n);
vector<bool> seen(n, false);
function<void(int, int, int)> dfs = [&](int x, int p, int d) {
dep[x] = d;
for (int i : adj[x]) {
if (i != p) dfs(i, x, d + 1);
}
};
dfs(0, 0, 0);
priority_queue<pair<int, int>> q;
for (int i = 0; i < n; i++) q.push({dep[i], i});
while (!q.empty()) {
pair<int, int> x = q.top();
q.pop();
if (seen[x.second] || degree[x.second] % 2) continue;
seen[x.second] = true;
ans.push_back(x.second + 1);
for (int u : adj[x.second]) {
if (seen[u]) continue;
degree[u]--;
q.push({dep[u], u});
}
}
cout << "YES\n";
for (int u : ans) cout << u << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) aksayushx();
return 0;
}
long long power(long long x, long long y, long long m) {
long long res = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % m;
y = y >> 1;
x = (x * x) % m;
}
return res;
}
long long modInverse(long long n, long long m) { return power(n, m - 2, m); }
long long ceiling(long long x, long long y) { return (x + y - 1) / y; }
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 1007681537;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
const int maxn = 2e5 + 5;
int n;
vector<int> adj[maxn];
int par[maxn];
int size[maxn];
int f[maxn];
void dfs(int u, int p) {
size[u] = 1;
par[u] = p;
for (int v : adj[u]) {
if (v != p) {
dfs(v, u);
size[u] += size[v];
}
}
}
void chemthan() {
cin >> n;
for (int i = (0); i < (n); ++i) {
int u;
cin >> u;
u--;
if (u != -1) {
adj[u].push_back(i);
adj[i].push_back(u);
}
}
if (!(n & 1)) {
cout << "NO\n";
return;
}
dfs(0, -1);
for (int u = (0); u < (n); ++u) {
int tot = 0;
for (int v : adj[u]) {
if (v != par[u]) {
if (!(size[v] & 1)) {
f[u]++;
}
tot += size[v];
}
}
tot = n - tot - 1;
if (!(tot & 1) && tot) {
f[u]++;
}
}
static int deg[maxn];
static int rem[maxn];
for (int u = (0); u < (n); ++u) deg[u] = int((adj[u]).size());
set<int> st;
for (int u = (0); u < (n); ++u) {
if (!f[u] && !(deg[u] & 1)) {
st.insert(u);
}
}
vector<int> res;
while (int((st).size())) {
int u = *st.begin();
st.erase(u);
if (deg[u] & 1) {
continue;
}
res.push_back(u);
rem[u] = 1;
for (int v : adj[u]) {
deg[v]--;
f[v]--;
if (!f[v] && !rem[v] && !(deg[v] & 1)) {
st.insert(v);
}
}
}
if (int((res).size()) != n) {
cout << "NO\n";
return;
}
cout << "YES\n";
for (int u : res) {
cout << u + 1 << "\n";
}
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
chemthan();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > g;
vector<bool> used1;
vector<long long> sorted;
vector<long long> d;
void dfs(long long v) {
used1[v] = true;
for (long long to : g[v]) dfs(to);
sorted.push_back(v);
}
void dfs1(long long v, long long depth) {
d[v] = depth;
for (long long to : g[v]) dfs1(to, depth + 1);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
g.resize(n);
used1.assign(n, false);
vector<long long> cnt(n, 0);
vector<pair<long long, long long> > edges;
for (long long i = 0; i < n; i++) {
long long p;
cin >> p;
if (p == 0) continue;
p--;
g[p].push_back(i);
edges.push_back({i, p});
cnt[p]++;
cnt[i]++;
}
for (long long i = 0; i < n; i++)
if (!used1[i]) dfs(i);
d.resize(n);
dfs1(sorted.back(), 0);
vector<bool> used(n, false);
vector<long long> ans;
for (pair<long long, long long> x : edges) g[x.first].push_back(x.second);
set<pair<long long, long long> > s;
for (long long i = 0; i < n; i++) {
if (cnt[i] % 2 == 0) s.insert(pair<long long, long long>(-d[i], i));
}
while ((long long)(s).size()) {
long long v = s.begin()->second;
s.erase(s.begin());
used[v] = true;
ans.push_back(v);
for (long long to : g[v]) {
if (used[to] || cnt[to] == 0) continue;
if (cnt[to] % 2 == 0)
s.erase(pair<long long, long long>(-d[to], to));
else
s.insert(pair<long long, long long>(-d[to], to));
cnt[to]--;
}
}
if ((long long)(ans).size() != n) {
cout << "NO";
return 0;
}
cout << "YES" << '\n';
for (long long x : ans) cout << ++x << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const int maxn = (int)2e5 + 10;
int dp[maxn][2];
vector<int> ed[maxn];
void del(int v, int p) {
for (int i = 0; i < (int)ed[v].size(); i++) {
int u = ed[v][i];
if (u == p) {
swap(ed[v][i], ed[v].back());
ed[v].pop_back();
i--;
continue;
} else {
del(u, v);
}
}
}
int st[maxn];
int go(int v, int x) {
if (dp[v][x] != -1) {
return dp[v][x];
}
int a = 0, b = 0, c = 0;
for (int i = 0; i < (int)ed[v].size(); i++) {
int u = ed[v][i];
if (go(u, 0) && go(u, 1)) {
b++;
} else if (go(u, 0) && !go(u, 1)) {
a++;
} else if (!go(u, 0) && go(u, 1)) {
c++;
} else {
return dp[v][x] = 0;
}
}
int cnt = st[v] - x;
cnt -= a;
if (b == 0 && (cnt & 1)) {
return dp[v][x] = 0;
}
return dp[v][x] = 1;
}
void write(int v, int x) {
vector<int> a, b, c;
for (int i = 0; i < (int)ed[v].size(); i++) {
int u = ed[v][i];
if (go(u, 0) && go(u, 1)) {
b.push_back(u);
} else if (go(u, 0) && !go(u, 1)) {
a.push_back(u);
} else if (!go(u, 0) && go(u, 1)) {
c.push_back(u);
} else {
throw 1;
}
}
for (int i = 0; i < (int)a.size(); i++) {
write(a[i], 0);
}
int cnt = st[v] - x;
cnt -= (int)a.size();
if (cnt & 1) {
if (b.empty()) {
throw 1;
}
write(b.back(), 0);
b.pop_back();
}
printf("%d\n", v);
for (int i = 0; i < (int)c.size(); i++) {
write(c[i], 1);
}
for (int i = 0; i < (int)b.size(); i++) {
write(b[i], 1);
}
}
int main() {
memset(dp, -1, sizeof dp);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x != 0) {
ed[x].push_back(i);
ed[i].push_back(x);
st[i]++;
st[x]++;
}
}
del(1, -1);
if (go(1, 0) == 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
write(1, 0);
}
}
|
#include <bits/stdc++.h>
inline long long read() {
long long x = 0;
char ch = getchar(), w = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * w;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
using namespace std;
const int N = 3e5 + 666;
vector<int> G[N];
int n, siz[N];
void dfs(int x, int F) {
siz[x] = 1;
for (int y : G[x])
if (y != F) {
dfs(y, x);
siz[x] += siz[y];
}
}
vector<int> ans;
void del(int x, int F) {
for (int y : G[x])
if (y != F) {
if (siz[y] % 2 == 0) del(y, x);
}
if (x) ans.push_back(x);
for (int y : G[x])
if (y != F) {
if (siz[y] % 2) del(y, x);
}
}
int main() {
n = read();
if (n % 2 == 0) {
puts("NO");
return 0;
}
for (int i = 1; i <= n; ++i) {
int x = read();
G[x].push_back(i);
G[i].push_back(x);
}
dfs(0, 0);
del(0, 0);
puts("YES");
for (int i : ans) writeln(i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, p[maxn], r;
vector<int> ad[maxn];
vector<int> re;
bool ok[maxn];
void dfs2(int u) {
ok[u] = true;
re.push_back(u);
for (auto v : ad[u])
if (!ok[v]) {
dfs2(v);
}
}
bool dfs(int u) {
int x = 0;
for (auto v : ad[u]) {
if (dfs(v)) x++;
}
int y = x + ad[u].size() + 1;
if (u == r) y--;
if (y % 2)
return false;
else {
dfs2(u);
return true;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i < n + 1; ++i) {
cin >> p[i];
if (p[i]) {
ad[p[i]].push_back(i);
} else
r = i;
}
dfs(r);
if (re.size() == n) {
cout << "YES\n";
for (auto x : re) cout << x << endl;
} else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 200005;
int n, rad, nr[NMAX], sol[NMAX], dim;
vector<int> L[NMAX];
bitset<NMAX> viz;
inline void DFS_SOLVE(int x) {
viz[x] = 1;
sol[++dim] = x;
for (auto i : L[x])
if (!viz[i]) DFS_SOLVE(i);
}
void DFS(int node) {
nr[node] = 1;
for (auto i : L[node]) {
DFS(i);
nr[node] += nr[i];
}
if (!(nr[node] % 2)) DFS_SOLVE(node);
}
int main() {
int x;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
if (!x)
rad = i;
else
L[x].push_back(i);
}
DFS(rad);
DFS_SOLVE(rad);
if (dim > n)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 1; i <= dim; i++) cout << sol[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int ne[N << 1], fi[N], b[N << 1], d[N], n, k, rt;
vector<int> s[N], ans;
void add(int x, int y) {
ne[++k] = fi[x];
b[fi[x] = k] = y;
++d[x];
}
void era(int x) {
for (vector<int>::iterator i = s[x].begin(); i != s[x].end(); ++i)
if (*i == x)
ans.push_back(x);
else
era(*i);
s[x].clear();
}
void fst(int x, int fa) {
s[x].push_back(x);
for (int j = fi[x]; j; j = ne[j])
if (b[j] != fa) {
fst(b[j], x);
if (s[b[j]].size()) s[x].push_back(b[j]);
}
if (~d[x] & 1) {
--d[fa];
era(x);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
if (x == 0)
rt = i;
else
add(x, i), add(i, x);
}
fst(rt, 0);
if ((signed)ans.size() != n) return puts("NO"), 0;
puts("YES");
for (vector<int>::iterator i = ans.begin(); i != ans.end(); ++i)
printf("%d\n", *i);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
using namespace std;
const long long maxn = 5e5 + 123, N = 500, mod = 1e9 + 9;
vector<int> g[maxn];
int n, m, dp[maxn][2];
vector<int> ans;
void dfs(int v, int p) {
vector<int> v1, v2, v3;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to != p) {
dfs(to, v);
if (dp[to][0] && !dp[to][1]) v1.push_back(to);
if (dp[to][1] && !dp[to][0]) v2.push_back(to);
if (dp[to][0] && dp[to][1]) v3.push_back(to);
}
}
if ((v1.size() % 2 == 0 || v3.size() > 0)) dp[v][0] = 1;
if (v != 1 && (v1.size() % 2 == 1 || v3.size() > 0)) dp[v][1] = 1;
}
void dfs2(int v, int p, int hp) {
vector<int> v1, v2, v3;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to != p) {
if (dp[to][0] && !dp[to][1]) v1.push_back(to);
if (dp[to][1] && !dp[to][0]) v2.push_back(to);
if (dp[to][0] && dp[to][1]) v3.push_back(to);
}
}
if (v1.size() % 2 == 1 - hp) {
v1.push_back(v3.back());
v3.pop_back();
}
if (hp == 0) {
for (int i = 0; i < v2.size(); i++) dfs2(v2[i], v, 1);
for (int i = 0; i < v3.size(); i++) dfs2(v3[i], v, 1);
cout << v << endl;
for (int i = 0; i < v1.size(); i++) dfs2(v1[i], v, 0);
} else {
for (int i = 0; i < v2.size(); i++) dfs2(v2[i], v, 1);
for (int i = 0; i < v3.size(); i++) dfs2(v3[i], v, 1);
cout << v << endl;
for (int i = 0; i < v1.size(); i++) dfs2(v1[i], v, 0);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int v;
cin >> v;
if (v != 0) {
g[v].push_back(i);
g[i].push_back(v);
}
}
dfs(1, 1);
if (dp[1][0] == 0) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
dfs2(1, 1, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)2e9;
const long long INFL = (long long)9e18;
const int MAXINT = ((~0) ^ (1 << 31));
const long long MAXLL = ((~0) ^ ((long long)1 << 63));
template <class T>
inline T pow2(T a) {
return a * a;
}
template <class T>
inline bool mineq(T& a, T b) {
return (a > b) ? (a = b, true) : false;
}
template <class T>
inline bool maxeq(T& a, T b) {
return (a < b) ? (a = b, true) : false;
}
const int maxn = 4e5;
long long n, mark[maxn], p, r, val[maxn], d[maxn];
vector<long long> g[maxn];
deque<long long> dq, ans;
void dfs(long long v, long long p) {
dq.push_front(v);
mark[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
if (!mark[g[v][i]]) {
dfs(g[v][i], v);
val[v] += val[g[v][i]];
}
}
val[v]++;
if (d[v] % 2 == 0) {
for (int i = val[v] - 1; i >= 0; i--) ans.push_back(dq[i]);
for (int i = 0; i < val[v]; i++) dq.pop_front();
d[p]--;
val[v] = 0;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p;
if (p == 0)
r = i;
else {
g[p].push_back(i);
g[i].push_back(p);
}
}
for (int i = 1; i <= n; i++) d[i] = g[i].size();
dfs(r, 0);
if (ans.size() != n)
cout << "NO";
else {
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << ans[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
set<pair<int, int>> s;
vector<int> adj[N];
int deg[N];
int st[N], ind[N], tim = 0;
void dfs(int v, int p, int d = 0) {
st[v] = d;
for (auto u : adj[v])
if (u != p) dfs(u, v, d + 1);
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int rt = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x--;
if (x == -1) {
rt = i;
continue;
}
adj[x].push_back(i);
adj[i].push_back(x);
deg[x]++;
deg[i]++;
}
for (int i = 0; i < n; i++)
if (deg[i] % 2 == 0) rt = i;
dfs(rt, -1);
for (int i = 0; i < n; i++)
if (deg[i] % 2 == 0) s.insert({st[i], i});
vector<int> ans;
while (!s.empty()) {
int ind = (*s.rbegin()).second;
s.erase({st[ind], ind});
ans.push_back(ind);
for (auto v : adj[ind]) {
deg[v]--;
if (deg[v] >= 0) {
if (deg[v] % 2 == 0)
s.insert({st[v], v});
else
s.erase({st[v], v});
}
}
deg[ind] = -1;
}
if (ans.size() != n) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (int i = 0; i < n; i++) cout << ans[i] + 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[212345];
bitset<212345> destroyed;
int vcant[212345];
int solve1(int nodo, int cant) {
for (auto it = g[nodo].begin(); it != g[nodo].end(); it++)
cant += solve1(*it, 1);
if (cant % 2) {
vcant[nodo] = cant;
return 1;
}
destroyed.set(nodo);
for (auto it = g[nodo].begin(); it != g[nodo].end(); it++) vcant[*it]--;
cout << nodo + 1 << '\n';
return 0;
}
void solve2(int nodo) {
bool aux = !destroyed[nodo] && vcant[nodo] % 2 == 0;
if (aux) {
cout << nodo + 1 << '\n';
destroyed.set(nodo);
}
for (auto it = g[nodo].begin(); it != g[nodo].end(); it++) {
if (aux) vcant[*it]--;
solve2(*it);
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, p, root;
cin >> n;
if (n % 2 == 0) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (int i = (0); i < (n); i++) {
cin >> p;
if (p == 0)
root = i;
else {
g[p - 1].push_back(i);
}
}
solve1(root, 0);
solve2(root);
for (int i = (0); i < (n); i++)
if (!destroyed[i]) cout << i + 1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, R;
vector<long long> L, C, A, P;
vector<vector<long long>> g;
void dfs(long long u = R, long long p = 0) {
L[u] = L[p] + 1;
for (long long v : g[u]) {
if (v != p) {
dfs(v, u);
}
}
}
void dft(long long u) {
if (C[u] % 2 or C[u] < 0) return;
A.push_back(u);
C[u] = -1;
for (long long v : g[u]) {
C[v]--;
if (L[u] < L[v]) dft(v);
}
}
bool cmp(long long i, long long j) { return L[i] > L[j]; }
int main() {
cin >> n;
g.resize(n + 1);
C.assign(n + 1, 0);
L = C;
P.resize(n);
for (i = 1; i <= n; i++) {
cin >> j;
P[i - 1] = i;
if (j) {
C[i]++;
C[j]++;
g[i].push_back(j);
g[j].push_back(i);
} else
R = i;
}
dfs();
sort(P.begin(), P.end(), cmp);
for (long long i : P) dft(i);
if (A.size() != n)
cout << "NO\n";
else {
cout << "YES\n";
for (long long i : A) cout << i << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 3;
vector<int> ed[N];
int dp[N][2];
int PreDel[N];
int dps(int u, int ct) {
if (dp[u][ct] != -1) return dp[u][ct];
int t = 0, tr = 0, sz = ed[u].size();
int l, r;
for (int i = 0; i < sz; i++) {
l = dps(ed[u][i], 1);
r = dps(ed[u][i], 0);
if (!l && !r) return dp[u][ct] = 0;
if (l && r) {
PreDel[ed[u][i]] = 1;
t = ed[u][i];
} else if (!l && r) {
PreDel[ed[u][i]] = 0;
tr++;
} else
PreDel[ed[u][i]] = 1;
}
if ((tr % 2) != ct && !t) return dp[u][ct] = 0;
if ((tr % 2) != ct) PreDel[t] = 0;
return dp[u][ct] = 1;
}
void print(int u) {
int sz = ed[u].size();
for (int i = 0; i < sz; i++)
if (PreDel[ed[u][i]] == 1) print(ed[u][i]);
printf("%d\n", u);
for (int i = 0; i < sz; i++)
if (PreDel[ed[u][i]] == 0) print(ed[u][i]);
}
int main() {
int n;
scanf("%d", &n);
int fr, root;
for (int i = 1; i <= n; i++) {
scanf("%d", &fr);
if (fr)
ed[fr].push_back(i);
else
root = i;
}
memset(dp, 0xff, sizeof dp);
int ret = dps(root, 0);
if (!ret)
printf("NO");
else {
printf("YES\n");
print(root);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 5;
vector<int> G[maxN];
vector<int> ans;
bool vis[maxN];
int n, root;
int nextInt() {
int res = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
;
for (; isdigit(ch); ch = getchar()) {
res = res * 10 + ch - 48;
}
return res;
}
void getAns(int u) {
if (vis[u]) return;
vis[u] = true;
ans.push_back(u);
for (auto v : G[u]) {
getAns(v);
}
}
int dfs(int u) {
int res = u != root;
for (auto v : G[u]) {
res += dfs(v);
}
if (res & 1) return 1;
getAns(u);
return 0;
}
int main() {
n = nextInt();
for (int v = 1; v <= n; v++) {
int u = nextInt();
if (u == 0) root = v;
G[u].push_back(v);
}
if (dfs(root))
puts("NO");
else {
puts("YES");
for (auto p : ans) {
printf("%d\n", p);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> tree[200100];
bool vis[200100];
int size[200100];
int dfs_size(int u) {
vis[u] = 1;
size[u] = 1;
for (auto i = tree[u].begin(); i != tree[u].end(); i++) {
int v = *i;
if (!vis[v]) {
size[u] += dfs_size(v);
}
}
return size[u];
}
void dfs(int u) {
vis[u] = 1;
for (auto i = tree[u].begin(); i != tree[u].end(); i++) {
int v = *i;
if (!vis[v] && (size[v] % 2) == 0) {
dfs(v);
}
}
printf("%d ", u);
for (auto i = tree[u].begin(); i != tree[u].end(); i++) {
int v = *i;
if (!vis[v] && (size[v] % 2) == 1) {
dfs(v);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, i, j;
int root;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> j;
if (j != 0) {
tree[j].push_back(i);
tree[i].push_back(j);
} else
root = i;
}
if (n % 2 == 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
dfs_size(root);
for (i = 0; i <= n + 1; i++) vis[i] = 0;
dfs(root);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 7;
vector<int> vt[MAXN];
int ans[MAXN], sum, root;
bool flag[MAXN];
void dfs2(int u) {
if (flag[u]) return;
flag[u] = true;
ans[sum++] = u;
for (int i = 0; i < vt[u].size(); i++) dfs2(vt[u][i]);
}
void dfs(int u) {
int e = 0;
if (u != root) e++;
for (int i = 0; i < vt[u].size(); i++) {
int v = vt[u][i];
dfs(v);
if (!flag[v]) e++;
}
if (e % 2 == 0) dfs2(u);
}
int main() {
int n;
while (~scanf("%d", &n)) {
memset(ans, 0, sizeof(ans));
memset(flag, false, sizeof(flag));
sum = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x == 0)
root = i;
else
vt[x].push_back(i);
}
if (n % 2 == 0) {
printf("NO\n");
continue;
}
dfs(root);
if (sum == n) {
printf("YES\n");
for (int i = 0; i < sum; i++) printf("%d\n", ans[i]);
} else
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int n, x, a[N];
vector<int> g[N], q1, q2;
void dfs(int v, int pr = 0) {
for (int to : g[v]) {
if (to != pr) {
dfs(to, v);
}
}
if (a[v] % 2 == 0) {
q1.push_back(v);
a[pr]--;
} else {
q2.push_back(v);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x) {
a[x]++;
a[i]++;
g[i].push_back(x);
g[x].push_back(i);
}
}
dfs(1);
reverse(q2.begin(), q2.end());
for (auto it : q2) {
q1.push_back(it);
}
for (int i = 1; i <= n; i++) {
a[i] = g[i].size();
}
for (auto it : q1) {
if (a[it] & 1) {
return cout << "NO", 0;
}
for (auto to : g[it]) {
a[to]--;
}
}
cout << "YES\n";
for (auto it : q1) {
cout << it << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, p, root, child[N];
vector<int> adj[N], ans;
void dfs1(int u, int p) {
child[u] = 1;
for (int v : adj[u]) {
dfs1(v, u);
child[u] += child[v];
}
}
void dfs2(int u, int p) {
for (int v : adj[u]) {
if (child[v] % 2 == 0) {
dfs2(v, u);
}
}
ans.push_back(u);
for (int v : adj[u]) {
if (child[v] % 2 == 1) {
dfs2(v, u);
}
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p;
if (p == 0) {
root = i;
} else {
adj[p].push_back(i);
}
}
if (n % 2 == 0) {
cout << "NO";
return 0;
}
dfs1(root, root);
dfs2(root, root);
cout << "YES\n";
for (int i : ans) {
cout << i << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
long long mod = 1000000009LL;
long long mod2 = 998244353LL;
int t;
int n;
int p[200005];
int deg[200005];
int deg2[200005];
vector<int> edges[200005];
int main() {
cin >> n;
vector<int> ans(n, 0);
int l = 0, r = n - 1;
memset(deg, 0, sizeof(deg));
memset(deg2, 0, sizeof(deg2));
for (int i = 1; i <= n; ++i) {
scanf("%d", &p[i]);
if (p[i] == 0) continue;
edges[p[i]].push_back(i);
edges[i].push_back(p[i]);
deg[i]++;
deg[p[i]]++;
deg2[i]++;
deg2[p[i]]++;
}
if (n == 1) {
cout << "YES" << endl;
cout << 1 << endl;
return 0;
}
if (n % 2 == 0) {
cout << "NO" << endl;
return 0;
}
queue<int> q;
for (int i = 1; i <= n; ++i) {
if (deg[i] == 1) {
q.push(i);
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
if (deg[u] % 2) {
ans[r--] = u;
} else {
ans[l++] = u;
for (int i = 0; i < edges[u].size(); ++i) {
int v = edges[u][i];
deg[v]--;
}
}
for (int i = 0; i < edges[u].size(); ++i) {
int v = edges[u][i];
deg2[v]--;
if (deg2[v] == 1) {
q.push(v);
}
}
}
if (l > r) {
cout << "YES" << endl;
for (int i = 0; i < ans.size(); ++i) {
printf("%d\n", ans[i]);
}
} else {
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 200000 + 10;
const long long mod = 1e9 + 9;
vector<int> gra[maxn];
bool ispos[maxn];
bool dfs(int u, int pre) {
bool ans = 1;
int sz = gra[u].size();
for (int i = 0; i < sz; i++) {
int v = gra[u][i];
if (v == pre) continue;
ispos[v] = dfs(v, u);
if (ispos[v]) ans ^= 1;
}
return ans;
}
void print(int u, int pre) {
int sz = gra[u].size();
for (int i = 0; i < sz; i++) {
int v = gra[u][i];
if (v == pre) continue;
if (!ispos[v]) print(v, u);
}
printf("%d\n", u);
for (int i = 0; i < sz; i++) {
int v = gra[u][i];
if (v == pre) continue;
if (ispos[v]) print(v, u);
}
}
int main() {
int n, rt;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int u;
scanf("%d", &u);
if (!u) {
rt = i;
} else {
gra[u].push_back(i);
gra[i].push_back(u);
}
}
bool flag = dfs(rt, 0);
if (flag) {
printf("YES\n");
print(rt, 0);
} else {
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int siz = 2e5 + 5, siz2 = 1e5 + 5;
int n, parent[siz], degree[siz], still[siz];
vector<int> adj[siz], ans, child[siz], ready;
bool vis[siz], del[siz];
void root(int i) {
vis[i] = true;
for (auto v : adj[i]) {
if (vis[v]) continue;
child[i].push_back(v);
parent[v] = i;
degree[i]++;
degree[v]++;
root(v);
}
int sz = child[i].size();
still[i] = sz;
if (sz == 0) {
ready.push_back(i);
}
}
void propagate(int i) {
del[i] = true;
ans.push_back(i);
for (auto v : child[i]) {
if (!del[v]) {
propagate(v);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int v;
scanf("%d", &v);
if (v != 0) {
adj[v].push_back(i);
adj[i].push_back(v);
}
}
if (n == 1) {
printf("YES\n1\n");
return 0;
}
root(1);
while (!ready.empty()) {
int cur = ready.back();
ready.pop_back();
still[parent[cur]]--;
if (still[parent[cur]] == 0) {
ready.push_back(parent[cur]);
}
if (degree[cur] % 2 == 0) {
degree[parent[cur]]--;
propagate(cur);
}
}
int sz = ans.size();
if (sz == n) {
printf("YES\n");
for (auto v : ans) {
printf("%d\n", v);
}
} else {
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, root, deg[N], fa[N], del[N];
vector<int> g[N], ans;
void dfs2(int x) {
ans.push_back(x);
del[x] = 1;
for (int i = 0; i < g[x].size(); ++i) {
int v = g[x][i];
if (!del[v]) dfs2(v);
}
}
void dfs(int x) {
for (int i = 0; i < g[x].size(); ++i) {
int v = g[x][i];
dfs(v);
if (!del[v]) deg[x] ^= 1;
}
if (fa[x]) deg[x] ^= 1;
if (!deg[x]) dfs2(x);
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", &fa[i]);
if (!fa[i])
root = i;
else
g[fa[i]].push_back(i);
;
}
dfs(root);
if (ans.size() < n) {
puts("NO");
} else {
puts("YES");
for (i = 0; i < n; ++i) printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 99;
int n, x, rt, mark[N], deg[N], dist[N], par[N];
set<pair<int, int> > s;
vector<int> ans, g[N];
void update(int x) {
deg[x]--;
if (deg[x] % 2)
s.erase(make_pair(dist[x], x));
else
s.insert(make_pair(dist[x], x));
}
void dfs(int x, int dis) {
dist[x] = dis;
deg[x] = (g[x].size() + (x != rt));
if (deg[x] % 2 == 0)
s.insert(make_pair(dis, x)), deg[x] = (g[x].size() + (x != rt));
for (long long i = 0; i < g[x].size(); i++) dfs(g[x][i], dis + 1);
}
void dfs_del(int x) {
ans.push_back(x);
mark[x] = 1;
for (long long i = 0; i < g[x].size(); i++)
if (!mark[g[x][i]]) dfs_del(g[x][i]);
}
int main() {
cin >> n;
if (!(n % 2)) return cout << "NO", 0;
cout << "YES" << endl;
for (long long i = 1; i < n + 1; i++) {
scanf("%d", &x);
;
if (x == 0)
rt = i;
else
g[x].push_back(i), par[i] = x;
}
dfs(rt, 0);
while (s.size()) {
int u = (*s.rbegin()).second;
s.erase(make_pair(dist[u], u));
dfs_del(u);
if (u != rt) update(par[u]);
}
for (long long i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int n;
vector<vector<int>> ed;
vector<int> subt, answer;
void init() {
ed = vector<vector<int>>(n + 1);
subt = vector<int>(n + 1);
answer = vector<int>(n + 1);
}
int dfs(int fa, int u) {
int val = 1;
for (auto i : ed[u]) {
if (i != fa) {
val = val + dfs(u, i);
}
}
subt[u] = val;
return val;
}
void solve(int fa, int u) {
for (auto i : ed[u]) {
if (i != fa && subt[i] % 2 == 0) solve(u, i);
}
cout << u << "\n";
for (auto i : ed[u]) {
if (i != fa && subt[i] % 2) solve(u, i);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
init();
vector<int> inp(n);
for (int i = 0; i < n; i++) {
cin >> inp[i];
}
for (int i = 0; i < n; i++) {
if (inp[i]) {
int u = i + 1, v = inp[i];
ed[u].push_back(v);
ed[v].push_back(u);
}
}
if (n % 2 == 0) {
cout << "NO\n";
return 0;
}
dfs(0, 1);
cout << "YES\n";
solve(0, 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
const int inf = 1e9;
int h[N], e[N], ne[N], idx;
int st[N];
int vis[N], f[N];
vector<int> ans;
int sign;
void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
void dfs(int u, int fa) {
int i;
int cnt = 0;
for (i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
f[j] = u;
dfs(j, u);
if (vis[j]) {
continue;
} else {
cnt++;
}
}
if (cnt % 2 && u != 1) {
vis[u] = 1;
ans.push_back(u);
}
if (u == 1) {
sign = cnt;
}
}
void dfs1(int u, int fa) {
int i;
for (i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
if (vis[f[j]] && !vis[j]) {
ans.push_back(j);
vis[j] = 1;
}
dfs1(j, u);
}
}
int main() {
ios::sync_with_stdio(false);
memset(h, -1, sizeof h);
int i;
int n;
cin >> n;
for (i = 1; i <= n; i++) {
int x;
cin >> x;
if (x != 0) {
add(x, i);
add(i, x);
}
}
dfs(1, 0);
if (!vis[1] && sign % 2 == 0) {
ans.push_back(1);
vis[1] = 1;
}
dfs1(1, 0);
if ((int)ans.size() < n) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (auto x : ans) {
cout << x << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 200001;
struct tree {
int father;
vector<int> sons;
bool deleted;
int siz;
};
tree tr[SIZE];
void write(int x) {
int y;
for (int i = 0; i < tr[x].sons.size(); i++) {
y = tr[x].sons[i];
if (!tr[y].deleted && y != tr[x].father) {
printf("%d\n", y);
tr[y].deleted = true;
write(y);
}
}
}
void alg() {
int x, y;
queue<int> q;
stack<int> Q;
q.push(1);
Q.push(1);
while (!q.empty()) {
x = q.front();
for (int i = 0; i < tr[x].sons.size(); i++) {
y = tr[x].sons[i];
if (tr[x].father != y) {
tr[y].father = x;
q.push(y);
Q.push(y);
}
}
q.pop();
}
while (!Q.empty()) {
x = Q.top();
if ((tr[x].siz & 1) == 0) {
printf("%d\n", x);
tr[x].deleted = true;
tr[tr[x].father].siz--;
write(x);
}
Q.pop();
}
}
int main() {
int n, a;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
if (a != 0) {
tr[i].sons.push_back(a);
tr[a].sons.push_back(i);
}
}
for (int i = 1; i <= n; i++) tr[i].siz = tr[i].sons.size();
if ((n & 1) == 0)
printf("NO");
else {
printf("YES\n");
alg();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using GRAPH = std::vector<std::vector<int>>;
GRAPH G;
vector<int> P;
vector<int> D;
vector<int> V;
void dfs(int u) {
for (auto v : G[u]) {
dfs(v);
}
V.push_back(u);
}
int main() {
int n{};
cin >> n;
G.resize(n + 1);
P.resize(n + 1, 0);
D.resize(n + 1, 0);
int root{};
for (int i = 1; i <= n; ++i) {
cin >> P[i];
if (P[i] == 0) {
root = i;
} else {
++D[i];
}
++D[P[i]];
G[P[i]].push_back(i);
}
dfs(root);
vector<int> ans;
vector<int> e;
for (auto v : V) {
if (D[v] % 2 == 1) {
if (v == root) {
cout << "NO\n";
return 0;
}
e.push_back(v);
} else {
ans.push_back(v);
--D[P[v]];
}
}
cout << "YES" << endl;
for (auto u : ans) {
cout << u << endl;
}
for (int i = e.size() - 1; i >= 0; --i) {
cout << e[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const int N = 1 << 18;
vector<int> G[N];
int deg[N], d[N];
bool vis[N];
void dfs(int u, int fa, int dep) {
d[u] = dep;
for (auto& v : G[u])
if (v != fa) dfs(v, u, dep + 1);
}
int main() {
int n;
cin >> n;
int rt = 0;
for (int i = 1; i <= n; i++) {
static int p;
cin >> p;
if (p)
G[p].push_back(i), G[i].push_back(p), ++deg[i], ++deg[p];
else
rt = i;
}
dfs(rt, 0, 0);
priority_queue<pair<int, int> > q;
for (int i = 1; i <= n; i++)
if (deg[i] % 2 == 0) q.push({d[i], i});
vector<int> ans;
while (!q.empty()) {
pair<int, int> tmp = q.top();
q.pop();
int u = tmp.second;
if (deg[u] & 1 || vis[u]) continue;
vis[u] = 1;
ans.push_back(u);
for (auto& v : G[u])
if (--deg[v] % 2 == 0) q.push({d[v], v});
}
if (ans.size() != n) return cout << "NO", 0;
cout << "YES" << endl;
for (auto& t : ans) cout << t << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> Tree[200005], ans;
stack<int> S;
int root, a, x, odw[200005];
bool DFS(int n) {
odw[n] = true;
int cnt = 1;
if (n == root) cnt--;
for (int i = 0; i < Tree[n].size(); i++)
if (!odw[Tree[n][i]]) cnt += (int)DFS(Tree[n][i]);
if (cnt % 2)
S.push(n);
else {
ans.push_back(n);
return false;
}
return true;
}
int main() {
cin >> a;
for (int i = 1; i <= a; i++) {
cin >> x;
if (!x) {
root = i;
continue;
}
Tree[i].push_back(x);
Tree[x].push_back(i);
}
if (DFS(root)) {
cout << "NO";
return 0;
}
cout << "YES\n";
for (int i = 0; i < ans.size(); i++) cout << ans[i] << "\n";
while (!S.empty()) {
cout << S.top() << "\n";
S.pop();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, root, dis[200005], vis[200005];
set<int> adj[200005];
set<pair<int, int> > st;
vector<int> print;
void bfs(void) {
queue<int> q;
q.push(root);
while (q.size()) {
int u = q.front();
q.pop();
set<int>::iterator tt;
for (tt = adj[u].begin(); tt != adj[u].end(); tt++) {
int xx = *tt;
if (xx == root || dis[xx]) continue;
dis[xx] = dis[u] + 1;
q.push(xx);
}
}
}
void _delete(int xx) {
print.push_back(xx);
set<int>::iterator tt;
for (tt = adj[xx].begin(); tt != adj[xx].end(); tt++) {
int z = *tt;
adj[z].erase(xx);
if (vis[z] && adj[z].size() % 2 == 0) _delete(z);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x == 0)
root = i;
else {
adj[i].insert(x);
adj[x].insert(i);
}
}
bfs();
set<pair<int, int> >::iterator it;
for (int i = 1; i <= n; i++) st.insert(make_pair(-dis[i], i));
for (it = st.begin(); it != st.end(); it++) {
int xx = it->second;
vis[xx] = 1;
if ((adj[xx].size() * 1LL) % 2) continue;
_delete(xx);
}
if (print.size() != n) cout << "NO" << endl, exit(0);
cout << "YES" << endl;
for (int i = 0; i < print.size(); i++) cout << print[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1e6 + 7;
int n, size[maxn], vis[maxn];
std::vector<int> ch[maxn];
void dfs1(int u, int f) {
size[u] = 1;
for (int v : ch[u])
if (v != f) {
dfs1(v, u);
size[u] += size[v];
}
}
void dfs(int u, int f, int dx) {
int d = dx;
for (int v : ch[u])
if (v != f) d++;
for (int v : ch[u]) {
if (v != f && size[v] % 2 == 0) {
dfs(v, u, 1);
d--;
}
}
if (d % 2 == 0) {
printf("%d\n", u);
vis[u] = 1;
for (int v : ch[u])
if (v != f && !vis[v]) dfs(v, u, 0);
} else {
int t = 0;
for (int v : ch[u]) {
if (v == f || vis[v]) continue;
if (size[v] % 2 == 0) t = v;
}
assert(t);
dfs(t, u, 1);
printf("%d\n", u);
vis[u] = 1;
for (int v : ch[u])
if (v != f && v != t && (!vis[v])) dfs(v, u, 0);
}
}
int main() {
scanf("%d", &n);
if (n % 2 == 0) {
puts("NO");
return 0;
}
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
if (!x) continue;
ch[i].push_back(x);
ch[x].push_back(i);
}
puts("YES");
dfs1(1, 0);
dfs(1, 0, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, ne;
} edge[200010 << 1];
int ne[200010], tot, rt;
bool flag[200010];
vector<int> ans;
void add(int u, int v) {
edge[tot] = {v, ne[u]};
ne[u] = tot++;
}
void collect(int u, int fa) {
ans.push_back(u);
flag[u] = true;
for (int i = ne[u]; ~i; i = edge[i].ne) {
int v = edge[i].to;
if (v == fa || flag[v]) continue;
collect(v, u);
}
}
int dfs(int u, int fa) {
int tot = 0;
for (int i = ne[u]; ~i; i = edge[i].ne) {
int v = edge[i].to;
if (v == fa) continue;
tot += dfs(v, u);
}
if ((u == rt && !(tot & 1)) || (u != rt && tot & 1)) collect(u, fa);
return !(tot & 1);
}
int main() {
memset(ne, -1, sizeof ne);
int n, x;
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) {
scanf("%d", &x);
if (!x)
rt = i;
else
add(i, x), add(x, i);
}
if (dfs(rt, -1)) {
puts("YES");
for (auto x : ans) printf("%d\n", x);
} else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> edges[N];
int state[N];
void cal(int prt, int cur, vector<int> &ans) {
ans.push_back(cur);
state[cur] = 1;
for (int next : edges[cur]) {
if (next == prt) continue;
if (state[next] == 0) cal(cur, next, ans);
}
}
int dfs(int prt, int cur, vector<int> &ans) {
int dsum = 0;
for (int next : edges[cur]) {
if (next == prt) continue;
dsum += dfs(cur, next, ans);
}
if (prt != 0) dsum += 1;
if (dsum % 2 == 0) {
cal(prt, cur, ans);
return 0;
} else
return 1;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i += 1) {
int p;
cin >> p;
if (p != 0) {
edges[i].push_back(p);
edges[p].push_back(i);
}
}
vector<int> ans;
dfs(0, 1, ans);
if (ans.size() != n) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (int x : ans) cout << x << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, n;
} e[400005];
int head[200005], cnt, vis[200005], deg[200005];
inline void add(int u, int v) {
e[++cnt].v = v;
e[cnt].n = head[u];
head[u] = cnt;
}
inline void dfs2(int u, int fa) {
if (vis[u]) return;
if (u != 0) printf("%d\n", u);
vis[u] = 1;
for (int i = head[u]; i; i = e[i].n) {
if (vis[e[i].v]) continue;
if (e[i].v == fa) continue;
dfs2(e[i].v, u);
}
}
inline void dfs(int u, int fa) {
if (vis[u]) return;
for (int i = head[u]; i; i = e[i].n) {
if (e[i].v == fa) continue;
dfs(e[i].v, u);
}
if (deg[u] & 1) return;
dfs2(u, fa);
deg[fa]--;
}
int main(int argc, char** argv) {
int n;
cin >> n;
if (n % 2 == 0) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 1; i <= n; i++) {
int v;
scanf("%d", &v);
add(i, v);
add(v, i);
if (v == 0) --deg[i];
++deg[v], ++deg[i];
}
dfs(0, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename S, typename T>
ostream& operator<<(ostream& out, pair<S, T> const& p) {
out << '(' << p.first << ", " << p.second << ')';
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& v) {
int l = v.size();
for (int i = 0; i < l - 1; i++) out << v[i] << ' ';
if (l > 0) out << v[l - 1];
return out;
}
template <typename T>
void trace(const char* name, T&& arg1) {
cout << name << " : " << arg1 << endl;
}
template <typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
trace(comma + 1, args...);
}
const int N = 200200;
int done[N];
vector<int> g[N];
vector<int> order;
void purge(int x, int prev) {
if (done[x]) return;
order.push_back(x);
done[x] = 1;
for (int y : g[x]) {
if (y == prev) continue;
purge(y, x);
}
}
bool dfs(int x, int prev) {
bool leaf = true;
int par = 0;
for (int y : g[x]) {
if (y == prev) continue;
leaf = false;
if (!dfs(y, x)) par ^= 1;
}
if (leaf) return false;
if (prev != -1) {
if (par) {
purge(x, prev);
return true;
}
return false;
} else {
if (par) return false;
purge(x, prev);
return true;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
if (n == 1) {
cout << "YES" << endl;
cout << 1 << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x) {
g[x].push_back(i);
g[i].push_back(x);
}
}
bool res = dfs(1, -1);
if (!res) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (int x : order) {
cout << x << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 200010;
int n, root;
int fa[M];
template <typename T>
inline void read(T &x) {
x = 0;
char ch = getchar();
int f = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
x *= f;
}
int head[M], tot = 0;
struct edge {
int to, next;
} e[M];
inline void add(int u, int v) {
e[++tot] = (edge){v, head[u]};
head[u] = tot;
}
int size[M];
void get_size(int pos) {
size[pos] = 1;
for (int i = head[pos]; i; i = e[i].next)
get_size(e[i].to), size[pos] += size[e[i].to];
}
void dfs(int pos) {
for (int i = head[pos], v; i; i = e[i].next)
if (size[v = e[i].to] % 2 == 0) dfs(e[i].to);
printf("%d\n", pos);
for (int i = head[pos], v; i; i = e[i].next)
if (size[v = e[i].to] % 2 == 1) dfs(e[i].to);
}
int main() {
read(n);
if (n % 2 == 0) return printf("NO\n"), 0;
for (int i = 1; i <= n; i++) {
read(fa[i]);
if (fa[i])
add(fa[i], i);
else
root = i;
}
get_size(root);
printf("YES\n");
dfs(root);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
vector<int> g[maxn];
int dp[maxn];
int n;
struct Edge {
int u, v, next;
} edge[maxn * 10];
int head[maxn];
int tot = 0;
void init() {
memset(head, -1, sizeof(head));
tot = 0;
}
void addedge(int u, int v) {
edge[tot] = Edge{u, v, head[u]};
head[u] = tot++;
}
void dfs1(int u, int pre) {
dp[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == pre) continue;
dfs1(v, u);
dp[u] += dp[v];
}
}
int in[maxn];
void dfs2(int u, int pre) {
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (dp[v] % 2 == 0) {
addedge(v, u);
in[u]++;
} else {
addedge(u, v);
in[v]++;
}
dfs2(v, u);
}
}
void bfs() {
cout << "YES\n";
queue<int> q;
for (int i = 1; i <= n; i++) {
if (in[i] == 0) {
q.push(i);
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
cout << u << endl;
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
in[v]--;
if (!in[v]) {
q.push(v);
}
}
}
}
int p[maxn];
int main() {
cin >> n;
int rt = -1;
for (int i = 1; i <= n; i++) cin >> p[i];
if (n % 2 == 0) {
cout << "NO\n";
return 0;
}
for (int i = 1; i <= n; i++) {
if (p[i] == 0) rt = i;
g[p[i]].push_back(i);
}
dfs1(rt, -1);
init();
dfs2(rt, -1);
bfs();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200007;
vector<int> G[maxn];
int cnt[maxn], n;
vector<int> ans;
void addedge(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
int stat(int u, int fa) {
cnt[u] = 1;
for (int v : G[u])
if (v != fa) cnt[u] += stat(v, u);
return cnt[u];
}
void dfs(int u, int fa) {
for (int v : G[u])
if (v != fa && cnt[v] % 2 == 0) dfs(v, u);
printf("%d\n", u);
for (int v : G[u])
if (v != fa && cnt[v] % 2 == 1) dfs(v, u);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int j;
scanf("%d", &j);
if (j) addedge(i, j);
}
if (n % 2 == 0) {
puts("NO");
return 0;
}
puts("YES");
stat(1, 0);
dfs(1, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 7;
int n;
vector<int> g[N];
bool deg[N], dp[N], mark[N];
vector<int> result;
void dfs_pre(int v, int p) {
dp[v] = (deg[v] % 2 == 0);
for (auto u : g[v]) {
if (u == p) continue;
dfs_pre(u, v);
dp[v] ^= dp[u];
}
}
void solve(int v) {
mark[v] = true;
for (auto u : g[v]) {
if (mark[u]) continue;
if (dp[u] == 1) {
solve(u);
}
}
result.push_back(v + 1);
for (auto u : g[v]) {
if (mark[u]) continue;
solve(u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int root = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x--;
if (x == -1) {
root = i;
continue;
}
g[x].push_back(i), g[i].push_back(x);
deg[x] ^= 1, deg[i] ^= 1;
}
if (n % 2 == 0)
return cout << "NO" << endl, 0;
else
cout << "YES" << endl;
dfs_pre(root, root);
solve(root);
for (auto v : result) cout << v << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, INF = 1e9 + 7;
int rd() {
char ch = getchar();
int ret = 0;
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret;
}
int n, lat[N];
struct Edge {
int v, nxt;
} e[N << 1];
int hd[N], cnt;
void addedge(int u, int v) {
e[++cnt] = (Edge){v, hd[u]};
hd[u] = cnt;
}
void dfs(int u, int fat = 0) {
int sum = (fat != 0);
for (int i = hd[u]; i; i = e[i].nxt)
if (e[i].v != fat) dfs(e[i].v, u), sum += lat[e[i].v];
lat[u] = sum & 1;
}
void print(int u, int fat = 0) {
for (int i = hd[u]; i; i = e[i].nxt)
if (e[i].v != fat && !lat[e[i].v]) print(e[i].v, u);
printf("%d\n", u);
for (int i = hd[u]; i; i = e[i].nxt)
if (e[i].v != fat && lat[e[i].v]) print(e[i].v, u);
}
int main() {
int n = rd();
for (int i = 1; i <= n; i++) {
int p = rd();
if (p) addedge(i, p), addedge(p, i);
}
dfs(1);
if (!lat[1]) {
puts("YES");
print(1, 0);
puts("");
} else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 20;
vector<int> adj[maxn], a[maxn], b[maxn], c[maxn], ans;
bool dp[maxn], pd[maxn];
void dfs(int v, int p = -1) {
for (auto u : adj[v])
if (u != p) {
dfs(u, v);
if (dp[u] && pd[u]) a[v].push_back(u);
if (dp[u] && !pd[u]) b[v].push_back(u);
if (!dp[u] && pd[u]) c[v].push_back(u);
if (!dp[u] && !pd[u]) {
cout << "NO" << endl;
exit(0);
}
}
if (a[v].empty()) {
if ((int)c[v].size() % 2 != 0) dp[v] = 1;
if ((int)c[v].size() % 2 == 0) pd[v] = 1;
} else
dp[v] = pd[v] = 1;
}
void print(int v, bool has, int p = -1) {
if (a[v].empty()) {
for (auto u : b[v]) print(u, 1, v);
ans.push_back(v);
for (auto u : c[v]) print(u, 0, v);
} else {
int k = adj[v].size();
if (!has && p != -1) k--;
if ((int)c[v].size() % 2 == 0) {
for (auto u : a[v]) print(u, 1, v);
for (auto u : b[v]) print(u, 1, v);
ans.push_back(v);
for (auto u : c[v]) print(u, 0, v);
} else {
int node = a[v].back();
a[v].pop_back();
for (auto u : a[v]) print(u, 1, v);
for (auto u : b[v]) print(u, 1, v);
ans.push_back(v);
print(node, 0, v);
for (auto u : c[v]) print(u, 0, v);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int p;
cin >> p;
p--;
if (p != -1) adj[p].push_back(i), adj[i].push_back(p);
}
dfs(0);
if (!pd[0]) return cout << "NO" << endl, 0;
cout << "YES" << endl;
print(0, 0);
for (auto v : ans) cout << v + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, k;
const int ms = 2e5 + 17;
const int mod = 1e9 + 9;
vector<int> v[ms];
vector<int> answer;
bool killed[ms];
void kill(int x) {
killed[x] = true;
answer.push_back(x);
for (int i = 0; i < v[x].size(); ++i) {
int to = v[x][i];
if (!killed[to]) kill(to);
}
}
void dfs(int x, bool isRoot) {
int deg = isRoot ? 0 : 1;
for (int i = 0; i < v[x].size(); ++i) {
int to = v[x][i];
dfs(to, false);
if (!killed[to]) ++deg;
}
if (deg % 2 == 0) kill(x);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, root;
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
if (!x)
root = i;
else
v[x].push_back(i);
}
dfs(root, 1);
if (answer.size() < n)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 0; i < n; ++i) cout << answer[i] << '\n';
}
}
|
#include <bits/stdc++.h>
const long long INF = 1000000000;
const long long N = 300005;
const long long MOD = 1000000007;
const long long MAXN = 100005;
const long long rootval = 319;
using namespace std;
vector<long long> adj[N];
vector<long long> v;
long long dfs(long long u, long long par) {
long long curr = 1;
for (auto v : adj[u]) {
if (v == par) {
continue;
}
curr = curr + dfs(v, u);
}
if (curr % 2 == 0) {
cout << u + 1 << endl;
} else {
v.push_back(u + 1);
}
return curr;
}
int main() {
long long n;
cin >> n;
long long p[n + 1];
for (long long i = 0; i < n; i++) {
cin >> p[i];
if (p[i] == 0) {
continue;
}
adj[p[i] - 1].push_back(i);
adj[i].push_back(p[i] - 1);
}
if (n % 2 == 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
dfs(0, -1);
if (!v.empty()) {
reverse(v.begin(), v.end());
for (long long i = 0; i < v.size(); i++) {
cout << v[i] << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
const long long INF = 1e18 + 7;
int a[maxn];
int aa[maxn];
int pre[maxn];
int b[maxn];
int main() {
int i, j, m, n, t, z;
int k;
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= m; i++) {
scanf("%d", &a[i]);
aa[a[i]] = 1;
}
for (i = 1; i <= k; i++) {
scanf("%d", &b[i]);
}
if (aa[0]) {
puts("-1");
return 0;
}
for (i = 0; i < n; i++) {
if (!aa[i]) {
pre[i] = i;
} else {
pre[i] = pre[i - 1];
}
}
long long ans = 1e18;
for (i = 1; i <= k; i++) {
long long tem = 0;
int cnt = 0;
while (cnt < n) {
if (cnt + i >= n) {
tem++;
cnt = n;
break;
}
if (pre[cnt + i] <= cnt) {
break;
} else {
cnt = pre[cnt + i];
tem++;
}
}
if (cnt == n) {
ans = min(ans, b[i] * tem);
}
}
if (ans != INF)
printf("%lld\n", ans);
else {
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long v[1000001], p[1000001], mp[1000001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, k, x;
cin >> n >> m >> k;
for (long long i = 0; i < m; i++) {
cin >> x;
if (x == 0) {
cout << -1;
return 0;
}
mp[x] = 1;
}
for (long long i = 0; i < k; i++) {
cin >> v[i];
}
for (long long i = 0; i < n; i++) {
if (!mp[i])
p[i] = i;
else
p[i] = p[i - 1];
}
long long ans = LLONG_MAX;
for (long long i = 1; i <= k; i++) {
long long val = 0;
long long j = 0, first = 1;
while (j < n) {
val += v[i - 1];
if (j + i >= n) break;
long long nj = p[j + i];
if (nj == j) {
first = 0;
break;
}
j = nj;
}
if (first) ans = min(ans, val);
}
if (ans == LLONG_MAX) ans = -1;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e18;
int vis[1000010];
int pre[1000010];
long long cost[1000010];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
memset(vis, 0, sizeof(vis));
int x;
for (int i = 1; i <= m; i++) {
scanf("%d", &x);
vis[x] = 1;
}
for (int i = 1; i <= k; i++) scanf("%lld", &cost[i]);
if (vis[0]) return 0 * printf("-1\n");
pre[0] = 0;
for (int i = 1; i <= n; i++)
if (vis[i])
pre[i] = pre[i - 1];
else
pre[i] = i;
long long ans = MAXN;
for (int i = 1; i <= k; i++) {
long long res = 0;
int cur = 0;
while (1) {
if (cur + i >= n) {
res += cost[i];
break;
}
if (pre[cur + i] == cur) {
res = MAXN;
break;
}
res += cost[i];
cur = pre[cur + i];
}
ans = min(ans, res);
}
if (ans == MAXN)
printf("-1\n");
else
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
int n, m, k;
int s[N], c[N];
bool vis[N];
int fir[N];
long long ans = 1e15;
void can(int u) {
long long rep = 0;
for (int i = 1; i <= n;) {
if (fir[i + u] == i) {
return;
}
rep += c[u];
if (i + u > n) {
break;
}
i = fir[i + u];
}
ans = min(ans, rep);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d", &s[i]);
vis[s[i] + 1] = 1;
}
for (int i = 1; i <= k; i++) {
scanf("%d", &c[i]);
}
for (int i = 1; i <= n; i++) {
if (vis[i]) {
fir[i] = fir[i - 1];
} else {
fir[i] = i;
}
}
if (!fir[1]) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= k; i++) {
can(i);
}
if (ans == 1e15) {
printf("-1\n");
} else {
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e18;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> prev_ok(n + 1);
for (int i = 0; i <= n; i++) {
prev_ok[i] = i;
}
for (int i = 0; i < m; i++) {
int a;
scanf("%d", &a);
if (a == 0) {
cout << -1 << endl;
return 0;
}
prev_ok[a] = prev_ok[a - 1];
}
long long ans = INF;
for (int p = 1; p <= k; p++) {
int s;
scanf("%d", &s);
int i = 0;
bool ok = true;
int cur = 1;
while (i + p < n) {
int prev_i = i;
i += p;
i = prev_ok[i];
if (i == prev_i) {
ok = false;
break;
}
cur++;
}
if (ok) {
ans = min(ans, (long long)cur * s);
}
}
if (ans == INF) {
cout << -1;
} else {
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e+6 + 50;
const long long INF = 1e+18;
int n, m, k;
int len[MAXN];
int broken[MAXN];
long long lamp[MAXN];
int main(int argc, char *argv[]) {
while (cin >> n >> m >> k) {
memset(len, 0, sizeof(len));
memset(broken, 0, sizeof(broken));
for (int i = 1; i <= m; i++) {
int num;
cin >> num;
broken[num] = 1;
}
for (int i = 1; i <= k; i++) {
cin >> lamp[i];
}
if (broken[0] == 1) {
cout << "-1" << endl;
continue;
}
int cnt = 0;
for (int i = 0; i <= n; i++) {
if (broken[i] == 0) {
len[i] = 0;
} else {
len[i] = len[i - 1] + 1;
}
cnt = max(cnt, len[i]);
}
long long ans = INF;
for (int i = cnt + 1; i <= k; i++) {
long long count = 0;
for (int s = 0; s < n; s += i) {
if (broken[s] == 1) {
s -= len[s];
}
count++;
}
ans = min(ans, count * lamp[i]);
}
if (ans >= INF) {
cout << "-1" << endl;
} else
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589;
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... S>
void dbs(string str, T t, S... s) {
long long idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ", ";
dbs(str.substr(idx + 1), s...);
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const map<S, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void prc(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
const long long MAX = 1e6 + 5;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, k;
cin >> n >> m >> k;
vector<long long> s(m), a(k);
for (long long i = 0; i < m; i++) cin >> s[i];
for (long long i = 0; i < k; i++) cin >> a[i];
if (!m) {
long long ans = 1e18;
for (long long i = 0; i < k; i++) {
long long times = (n - 1) / (i + 1) + 1;
ans = min(ans, times * a[i]);
}
cout << ans << "\n";
return 0;
}
if (s[0] == 0) {
cout << "-1\n";
return 0;
}
long long last = s[0], cont = 1, curr = 1;
for (long long i = 1; i < m; i++) {
if (last != s[i] - 1) {
cont = max(curr, cont);
curr = 1;
} else
curr++;
last = s[i];
}
cont = max(curr, cont);
cont++;
vector<long long> pos(MAX, 0);
for (long long i = 0; i < m; i++) {
pos[s[i]] = 1;
}
long long cost = 1e18;
vector<long long> free;
long long ptr = 0;
for (long long i = 1; i <= n; i++) {
if (ptr < n and s[ptr] == i) {
ptr++;
} else
free.push_back(i);
}
for (long long i = cont - 1; i < k; i++) {
long long l = i + 1;
long long num_req = 1;
long long start = l;
while (start < n) {
if (pos[start]) {
start = *(lower_bound((free).begin(), (free).end(), start) - 1);
}
num_req++;
start += l;
}
cost = min(cost, num_req * a[i]);
}
if (cost == (long long)1e18) cost = -1;
cout << cost << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 1000000;
const int MAXN = 1000000;
bool B[1 + MAXN];
int n, F[1 + MAXN];
long long C[1 + MAXK];
vector<pair<long long, int>> L;
long long cost(int l) {
int x = 0;
long long c = 0;
while (x < n) {
x = F[x];
c += C[l];
x += l;
}
return c;
}
int main() {
int a, k, m;
scanf("%d %d %d", &n, &m, &k);
while (m--) {
scanf("%d", &a);
B[a] = true;
}
if (B[0]) {
puts("-1");
return 0;
}
for (int i = 1; i <= k; ++i) {
scanf("%lld", C + i);
}
m = 0;
a = B[0];
for (int i = 1; i <= n; ++i) {
if (B[i]) {
++a;
} else {
m = max(m, a);
a = 0;
}
}
m = max(m, a);
if (k <= m) {
puts("-1");
return 0;
}
for (int i = 0; i <= n; ++i) {
F[i] = i;
}
for (int i = 1; i <= n; ++i) {
if (B[i]) {
F[i] = F[i - 1];
}
}
for (int i = m + 1; i <= k; ++i) {
int j = n / i + !!(n % i);
L.push_back({j * C[i], i});
}
sort(L.begin(), L.end());
long long b = cost(L[0].second);
for (int i = 1; i < (int)L.size() && L[i].first < b; ++i) {
long long c = cost(L[i].second);
b = min(b, c);
}
printf("%lld\n", b);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int N = 1e6 + 10;
int n, m, k;
bool des[N];
int l[N], a[N];
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int t;
scanf("%d", &t);
des[t] = true;
}
for (int i = 1; i <= k; i++) scanf("%d", &a[i]);
if (des[0]) {
printf("-1\n");
return 0;
}
l[0] = 0;
for (int i = 1; i < n; i++)
if (des[i - 1])
l[i] = l[i - 1];
else
l[i] = i;
long long ans = 1ll << 62;
for (int i = 1; i <= k; i++) {
int cur = 0;
long long tmp = 0;
while (true) {
tmp += a[i];
cur += i;
if (cur >= n) break;
if (des[cur]) {
if (cur - l[cur] + 1 >= i) {
tmp = 1ll << 62;
break;
} else {
cur = l[cur] - 1;
}
}
}
ans = min(ans, tmp);
}
if (ans == 1ll << 62)
puts("-1");
else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
bool vis[N];
int id[N];
int main() {
ios::sync_with_stdio(false);
int k, n, x, m;
long long val;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
cin >> x;
vis[x] = 1;
}
if (vis[0]) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; i++) id[i] = vis[i] ? id[i - 1] : i;
long long ans = 1e18;
for (int i = 1; i <= k; i++) {
cin >> val;
long long ret = 0, pos = 0;
while (1) {
ret += val;
if (pos + i >= n) {
ans = min(ans, ret);
break;
}
if (id[pos + i] == id[pos]) break;
pos = id[pos + i];
}
}
if (ans == 1e18)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, m, k;
long long ans;
bool e[1000001];
int pre[1000001];
struct light {
int l, cost;
double c;
} s[1000001];
bool cmp(light a, light b) { return a.c > b.c; }
int dfs(int p, int sum, int l) {
int np = p + l;
if (np >= n) return sum + 1;
np = pre[np];
if (np == p)
return -1;
else
return dfs(np, sum + 1, l);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
ans = -1;
memset(e, false, sizeof(e));
for (int i = 0; i < m; i++) {
int a;
scanf("%d", &a);
e[a] = true;
}
for (int i = 1; i < n; i++) {
if (e[i])
pre[i] = pre[i - 1];
else
pre[i] = i;
}
for (int i = 0; i < k; i++) {
s[i].l = i + 1;
scanf("%d", &s[i].cost);
s[i].c = (double)((double)s[i].l / (double)s[i].cost);
}
if (e[0]) {
printf("-1\n");
return 0;
}
for (int i = 0; i < k; i++) {
int t = dfs(0, 0, s[i].l);
if (t == -1) continue;
long long tt = (long long)((long long)s[i].cost * (long long)t);
if (ans == -1) {
ans = tt;
} else {
ans = min(ans, tt);
}
}
if (ans != -1)
printf("%I64d\n", ans);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long INF = 1e18;
const int maxn = 1000010;
bool pos[maxn];
int lst[maxn], a[maxn], s[maxn];
int n, m, k;
int work(int l) {
int r = 0, i = -1, ret = 0;
while (r < n) {
if (lst[r] <= i) return inf;
i = lst[r];
r = lst[r] + l;
ret++;
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) scanf("%d", &s[i]);
for (int i = 1; i <= k; i++) scanf("%d", &a[i]);
memset(pos, 0, sizeof(pos));
for (int i = 1; i <= m; i++) pos[s[i]] = true;
for (int i = 0; i < n; i++) {
if (!pos[i])
lst[i] = i;
else if (i)
lst[i] = lst[i - 1];
else
lst[i] = -1;
}
long long ans = INF;
for (int i = 1; i <= k; i++) {
long long t = work(i);
if (t != inf) ans = min(ans, a[i] * t);
}
printf("%lld\n", ans == INF ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e6 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
int n, m, k;
int s[MX], a[MX];
int b[MX];
int main() {
while (cin >> n >> m >> k) {
for (int i = 1; i <= m; i++) scanf("%d", &s[i]), b[s[i]] = 1;
for (int i = 1; i <= k; i++) scanf("%d", &a[i]);
m = 0;
for (int i = 0; i <= n; i++)
if (!b[i]) s[++m] = i;
if (s[1] > 0) {
printf("-1\n");
continue;
}
int kk = 0;
for (int i = 1; i <= k; i++) {
while (kk > 0 && a[i] <= a[kk]) kk--;
a[++kk] = a[i];
b[kk] = i;
}
k = kk;
long long ans = INF;
for (int i = 1; i <= k; i++) {
int x = b[i], cnt = 0;
int index = 1, flag = 1;
while (index <= m) {
if (s[index] + x >= n) {
cnt++;
break;
}
int p = upper_bound(s + 1, s + m + 1, s[index] + x) - s - 1;
cnt++;
if (p == index) {
flag = 0;
break;
}
index = p;
}
if (flag) ans = min(ans, (long long)cnt * a[i]);
}
cout << (ans == INF ? -1 : ans) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, s[1000010], p[1000010], pre[1000010];
bool used[1000010];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d", &s[i]);
used[s[i] + 1] = true;
}
for (int i = 1; i <= k; i++) {
scanf("%d", &p[i]);
}
for (int i = 1; i <= n; i++) {
if (used[i]) {
pre[i] = pre[i - 1];
} else {
pre[i] = i;
}
}
long long ans = (long long)1000010 * 1000010 * 1000010;
for (int i = 1; i <= k; i++) {
int lst = 0;
long long now = 0;
for (int j = 1; j <= n; j += i) {
if (j > n) break;
j = pre[j];
if (j == lst) {
now = (long long)1000010 * 1000010 * 1000010;
break;
}
now += p[i];
lst = j;
}
ans = min(ans, now);
}
printf("%I64d\n", ans == (long long)1000010 * 1000010 * 1000010 ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const int N = 1e6 + 10;
vector<long long int> a(N), nxt(N);
long long int val, n, m, k;
bool check(long long int k) {
if (a[0]) return false;
long long int i = n;
val = 0;
while (i > 0) {
long long int j = nxt[max(0ll, i - k)];
if (j == i) return false;
i = j;
val++;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int T = clock();
cin >> n >> m >> k;
for (long long int i = 0; i < m; i++) {
long long int s;
cin >> s;
a[s] = 1;
}
a[n] = 1;
long long int cur = n;
for (long long int i = n; i >= 0; i--) {
if (!a[i]) cur = i;
nxt[i] = cur;
}
vector<long long int> c(k + 1);
for (long long int i = 1; i <= k; i++) cin >> c[i];
long long int ans = mod * mod;
for (long long int i = 1; i <= k; i++) {
if (check(i)) ans = min(ans, val * c[i]);
}
if (ans == mod * mod)
cout << -1;
else
cout << ans;
cerr << "\n\nTIME: " << (double)(clock() - T) / CLOCKS_PER_SEC << " sec\n";
T = clock();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 1007681537;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
const int maxn = 1e6 + 5;
int n, m, k;
int f[maxn];
int a[maxn];
int lst[maxn];
void volamtruyenkyii() {
cin >> n >> m >> k;
for (int i = (0); i < (m); ++i) {
int x;
cin >> x;
f[x] = 1;
}
f[n] = 1;
for (int i = (1); i < (k + 1); ++i) cin >> a[i];
if (f[0]) {
cout << -1 << "\n";
return;
}
int tmp = 0;
for (int i = (1); i < (n + 1); ++i) {
if (!f[i]) tmp = i;
lst[i] = tmp;
}
long long res = LINF;
for (int i = (1); i < (k + 1); ++i) {
int st = 0, cnt = 0;
while (st < n) {
if (!f[st]) {
cnt++;
st += i;
} else {
int pv = lst[st];
if (pv + i <= st) {
cnt = -1;
break;
} else {
cnt++;
st = pv + i;
}
}
}
if (cnt >= 0) {
chkmin(res, (long long)cnt * a[i]);
}
}
if (res == LINF) res = -1;
cout << res << "\n";
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
volamtruyenkyii();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[1000010], a[1000010];
int Next[1000010];
bool f[1000010];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; ++i) {
scanf("%d", &s[i]);
f[s[i]] = 1;
}
for (int i = 1; i <= k; ++i) {
scanf("%d", &a[i]);
}
Next[n] = n;
for (int i = n - 1; i >= 0; --i) {
if (f[i])
Next[i] = Next[i + 1];
else
Next[i] = i;
}
long long Ans = 1ll * 1e9 * 1e9;
for (int i = 1; i <= k; ++i) {
int t = 0;
int now = n;
bool flag = false;
while (now != 0) {
int l = Next[(now >= i ? now - i : 0)];
if (l >= now) {
flag = true;
break;
}
++t;
now = l;
}
if (flag == false) Ans = min(Ans, 1ll * t * a[i]);
}
if (Ans == 1ll * 1e9 * 1e9)
puts("-1");
else
printf("%lld\n", Ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int Gcd(int X, int Y) { return Y ? Gcd(Y, X % Y) : X; }
inline long long Gcd(long long X, long long Y) { return Y ? Gcd(Y, X % Y) : X; }
inline int Pow(int base, long long exp, int _mod) {
if (!(base %= _mod)) return 0;
int _ans = 1;
for (; exp; exp >>= 1, base = (long long)base * base % _mod)
exp& 1 ? _ans = (long long)_ans * base % _mod : 0;
return _ans;
}
inline long long Pow(long long base, long long exp, long long _mod) {
if (!(base %= _mod)) return 0;
long long _ans = 1;
for (; exp; exp >>= 1, base = base * base % _mod)
exp& 1 ? _ans = _ans * base % _mod : 0;
return _ans;
}
const long long INF = 0x3f3f3f3f3f3f3f3f;
int n, m, k;
int s[1000005], a[1000005];
int ib[1000005], r[1000005];
long long Ans = INF;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= (m); ++i) scanf("%d", s + i), ib[s[i] + 1] = 1;
for (int i = 1; i <= (k); ++i) scanf("%d", a + i);
r[n + 1] = n + 1;
for (int i = n; i >= (1); --i) r[i] = ib[i] ? r[i + 1] : i;
if (ib[1]) return 0 * puts("-1");
for (int i = 1; i <= (k); ++i) {
int now = n + 1, cnt = 0, ok = 1;
while (now > 1) {
int u = now - i >= 1 ? r[now - i] : 1;
if (u < now)
now = u, ++cnt;
else {
ok = 0;
break;
}
}
if (!ok) continue;
Ans = min(Ans, (long long)cnt * a[i]);
}
printf("%I64d", Ans == INF ? -1 : Ans);
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
constexpr long long MAX = 5100000;
constexpr long long INF = 1LL << 60;
constexpr int inf = 1 << 28;
constexpr long long mod = 1000000007LL;
using namespace std;
vector<int> last;
long long n, k, m;
long long cnt(long long len) {
int now = 0;
int pre = -1;
long long res = 0;
while (now < n) {
if (last[now] <= pre) return INF;
pre = last[now];
now = last[now] + len;
res++;
}
return res;
}
int main() {
scanf("%lld %lld %lld", &n, &m, &k);
vector<bool> flag(n, true);
vector<int> s(m);
for (int i = 0; i < m; i++) scanf("%d", &s[i]), flag[s[i]] = false;
vector<int> a(k);
for (int i = 0; i < k; i++) scanf("%d", &a[i]);
last.resize(n);
;
for (int i = 0; i < n; i++) {
if (i == 0) {
if (flag[i])
last[i] = i;
else
last[i] = -1;
} else {
if (flag[i])
last[i] = i;
else
last[i] = last[i - 1];
}
}
long long res = INF;
for (int i = 0; i < k; i++) {
long long tmp = cnt(i + 1);
if (tmp == INF) continue;
chmin(res, a[i] * tmp);
}
if (res == INF) res = -1;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INF64 = 1e18;
const int N = 1000 * 1000 + 13;
int n, m, k;
bool pos[N];
int lst[N], s[N], a[N];
int get(int l) {
int r = 0, i = -1, res = 0;
while (r < n) {
if (lst[r] <= i) return INF;
i = lst[r];
r = lst[r] + l;
++res;
}
return res;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) scanf("%d", &s[i]);
for (int i = 0; i < k; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) pos[i] = true;
for (int i = 0; i < m; i++) pos[s[i]] = false;
for (int i = 0; i < n; i++) {
if (pos[i])
lst[i] = i;
else if (i)
lst[i] = lst[i - 1];
else
lst[i] = -1;
}
long long ans = INF64;
for (int i = 0; i < k; i++) {
long long t = get(i + 1);
if (t != INF) ans = min(ans, a[i] * t);
}
if (ans == INF64) ans = -1;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int arr[1000001];
std::set<int> entry;
int main() {
int n, m, k, in, price, unavail = 1, max_unavail = 0;
long long res = LLONG_MAX;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < m; i += 1) {
scanf("%d", &in);
arr[in] = 1;
if (!in) {
printf("-1");
return 0;
} else if (arr[in - 1])
unavail += 1;
else {
max_unavail = std::max(max_unavail, unavail);
unavail = 1;
entry.insert(in - 1);
}
}
max_unavail = std::max(max_unavail, unavail);
if (!m) max_unavail = 0;
for (int i = 1; i <= k; i += 1) {
int ptr, count;
scanf("%d", &in);
if (i > max_unavail) {
ptr = count = 0;
while (ptr < n)
if (arr[ptr]) {
std::set<int>::iterator it = entry.lower_bound(ptr);
ptr = *(--it);
} else
count += 1, ptr += i;
res = std::min(res, (long long int)in * count);
}
}
if (res == LLONG_MAX) res = -1;
printf("%lld", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, i, j, nr, rez, x, prec;
bool b, S[1000005];
int A[1000005], Prv[1000005];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (i = 1; i <= m; i++) {
cin >> x;
S[x] = 1;
}
if (S[0] == 1) {
cout << "-1\n";
return 0;
}
for (i = 1; i <= n; i++) {
if (S[i] == 0)
Prv[i] = i;
else
Prv[i] = Prv[i - 1];
}
for (i = 1; i <= k; i++) cin >> A[i];
rez = 1000000000000000LL;
if (m == 0) rez = min(rez, 1LL * A[1] * n);
for (i = 2; i <= k; i++) {
b = 1;
nr = 0;
prec = 0;
for (j = i; j < n; j += i) {
if (S[j] == 1) {
if (prec == Prv[j]) {
b = 0;
break;
}
j = Prv[j];
}
nr++;
prec = j;
}
nr++;
if (b == 1) rez = min(rez, 1LL * A[i] * nr);
}
if (rez != 1000000000000000LL)
cout << rez << "\n";
else
cout << "-1\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int maxn = 1000005;
long long pre[maxn];
int vio[maxn];
void go() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i < m + 1; i++) {
int x;
cin >> x;
vio[x] = 1;
}
pre[0] = -1;
if (vio[0]) {
cout << -1 << '\n';
exit(0);
}
for (int i = 0; i < n + 1; i++) {
if (!vio[i]) {
pre[i] = i;
} else {
pre[i] = pre[i - 1];
}
}
long long mi = 1e18;
for (int i = 1; i < k + 1; i++) {
long long v;
cin >> v;
long long cur = 0;
int cnt = 0;
int last = -74751;
int f = 0;
while (cur < n) {
int x = pre[cur];
if (x == last) {
f = 1;
break;
}
cnt++;
last = x;
cur = x + i;
}
if (!f) {
mi = min(mi, cnt * v);
}
}
if (mi > 1e15) {
cout << -1 << '\n';
} else {
cout << mi << '\n';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int c = 0;
int t;
if (!c) {
t = 1;
} else {
cin >> t;
}
while (t--) {
go();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int maxn = 1e6 + 5;
bool b[maxn];
int a[maxn];
int main() {
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
memset(b, true, sizeof(b));
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (x == 0) {
cout << -1;
return 0;
}
b[x] = false;
if (b[x - 1])
a[x] = x - 1;
else
a[x] = a[x - 1];
}
long long ans = 1LL * INF * INF;
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
int j = 0;
long long res = 0;
int f = 0;
while (j < n) {
int k = j;
res += x;
j += i;
if (j < n && !b[j]) {
j = a[j];
if (j == k) {
f = 1;
break;
}
}
}
if (f == 0) ans = min(ans, res);
}
if (ans < 1LL * INF * INF)
cout << ans;
else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1e6 + 10;
int n;
int m;
int k;
int a[MAXN];
int cnt[MAXN];
bool blk[MAXN];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
int tmp;
scanf("%d", &tmp);
blk[tmp] = true;
}
for (int i = 1; i <= k; i++) scanf("%d", a + i);
if (blk[0]) {
puts("-1");
return 0;
}
int maxl = 0;
for (int i = 0; i < n; i++) {
if (blk[i]) {
cnt[i] = cnt[i - 1] + blk[i];
maxl = std::max(maxl, cnt[i]);
}
}
long long ans = LLONG_MAX;
for (int i = maxl + 1; i <= k; i++) {
int now = 0;
long long sum = 0;
while (now < n) {
if (blk[now])
now -= cnt[now];
else {
sum += a[i];
now += i;
}
}
ans = std::min(ans, sum);
}
if (ans == LLONG_MAX)
puts("-1");
else
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 1e2;
const long long int inf = 0x3f3f3f3f3f3f3f3fll;
int n, m, k, fail;
long long int ans = inf;
struct UnionFindSet {
int fa[maxn];
inline int findfa(int x) { return fa[x] == x ? x : fa[x] = findfa(fa[x]); }
inline void ban(int t) { fa[t] = t - 1; }
inline void init() {
for (int i = 1; i <= n; i++) fa[i] = i;
}
} ufs;
inline long long int calc(int pw, int cst) {
int used = 0, cur = 0;
while (cur < n) {
int fil = ufs.findfa(cur);
if (fil + pw <= cur) return inf;
++used, cur = fil + pw;
}
return (long long int)cst * used;
}
inline int getint() {
int ret = 0, ch;
while (!isdigit(ch = getchar()))
;
do ret = ret * 10 + ch - '0';
while (isdigit(ch = getchar()));
return ret;
}
int main() {
n = getint(), m = getint(), k = getint(), ufs.init();
for (int i = 1, t; i <= m; i++) {
ufs.ban(t = getint());
if (!t) fail = 1;
}
if (fail) return puts("-1"), 0;
for (int i = 1; i <= k; i++) ans = min(ans, calc(i, getint()));
printf("%lld\n", ans == inf ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int N = 1e6 + 20;
vector<int> v[N];
map<int, int> mp, ml, mr;
long long n, m, k, a[N], b[N], f[N];
int num[N];
long long did[N];
string s;
long long s1, s2, ans, flag, tot, t, sum;
int cnt;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
long long x;
for (int i = 0; i < m; i++) {
cin >> x;
if (x == 0) return cout << -1, 0;
did[x] = 1;
}
for (int i = 1; i <= k; i++) cin >> a[i];
int cnt = 0;
for (int i = 0; i <= n; i++) {
if (did[i])
num[i] = num[i - 1] + 1;
else
num[i] = 0;
cnt = max(cnt, num[i]);
}
long long ans = inf;
for (int i = cnt + 1; i <= k; i++) {
long long sum = 0;
for (int j = 0; j < n; j += i) {
if (did[j]) {
j -= num[j];
}
sum++;
}
ans = min(ans, a[i] * sum);
}
if (ans >= inf)
cout << -1;
else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
int n, m, k, p, mg = -1;
cin >> n >> m >> k;
vector<int> back(n + 1);
for (int i = 0; i < n + 1; ++i) back[i] = i;
while (m--) {
cin >> p;
if (p == 0) {
cout << "-1\n";
return 0;
}
back[p] = back[p - 1];
}
for (int i = 1; i < n; ++i) mg = max(mg, i - back[i]);
mg++;
vector<ll> prz(n);
ll ans = 1LL << 60;
for (int i = 0; i < k; ++i) {
ll cost;
int jmp = i + 1;
cin >> cost;
if (jmp < mg) continue;
int x = 0;
ll ile = 0;
while (x < n) {
x = back[min(n, x + jmp)];
ile++;
}
ans = min(ans, ile * cost);
}
cout << (ans == 1LL << 60 ? -1 : ans) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
long long int r = 1;
x = x % p;
while (y) {
if (y & 1) r = r * x % p;
y = y >> 1;
x = x * x % p;
}
return r;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int csrand(int l = 0, int r = 1e9) {
uniform_int_distribution<int> uid(l, r);
return uid(rng);
}
const int N = 1e6 + 99;
int road[N], prev1[N];
long long int cost[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
road[x] = 1;
}
for (int i = 0; i < k; i++) cin >> cost[i + 1];
if (road[0] == 1) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; i++) {
if (road[i] == 0)
prev1[i] = i;
else
prev1[i] = prev1[i - 1];
}
long long int ans = 1e18;
for (int i = 1; i <= k; i++) {
long long int ta = 0;
int j = 0;
while (j < n) {
ta += cost[i];
if (road[j] == 1)
if (j - prev1[j] >= i) {
ta = 1e17;
break;
} else
j = prev1[j];
j += i;
}
ans = min(ans, ta);
}
if (ans > 1e16) ans = -1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
bool blocked[1000002];
int lastFree[1000002];
long long costs[1000002];
int main() {
int k, n, m;
cin >> n >> m >> k;
int x;
for (int i = 1; i <= m; i++) {
scanf("%d", &x);
blocked[x + 1] = true;
}
memset(lastFree, -1, sizeof(lastFree));
for (int i = 1; i <= n; i++) {
if (blocked[i])
lastFree[i] = lastFree[i - 1];
else
lastFree[i] = i;
}
long long res = -1;
for (int i = 1; i <= k; i++) {
scanf("%d", &costs[i]);
int toPlace = 1;
int ctr = 0;
while (toPlace <= n && lastFree[toPlace] != -1 &&
lastFree[toPlace] + i > toPlace) {
toPlace = lastFree[toPlace] + i;
ctr++;
}
if (toPlace > n) {
if (res == -1)
res = costs[i] * ctr;
else
res = min(res, costs[i] * ctr);
}
}
cout << res << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 500;
long long n, m, k, s[N], a[N], pre[N];
bool b[N];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) cin >> s[i], b[s[i]] = 1;
for (int i = 1; i <= k; i++) cin >> a[i];
for (int i = 1; i < n; i++)
if (b[i] == 0)
pre[i] = i;
else
pre[i] = pre[i - 1];
if (b[0]) {
printf("-1");
return 0;
}
long long ans = 200000000000000000;
for (int i = 1; i <= k; i++) {
long long now = 0, sum = 0;
while (now < n) {
sum += a[i];
if (now >= pre[now] + i) {
sum = 200000000000000000;
break;
}
now = pre[now] + i;
}
ans = min(ans, sum);
}
if (ans == 200000000000000000) ans = -1;
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1000005], c[1000005], adj[1000005];
int n, m, k, s;
long long solve(int i) {
int cur = 0, pv = 0;
long long val = 0;
while (cur < n) {
pv = cur;
cur += i;
val += c[i];
if (cur >= n) break;
if (dp[cur]) cur = adj[cur];
if (pv >= cur) return 1e18;
}
return val;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i <= n; i++) adj[i] = i;
for (int i = 1; i <= m; i++) {
scanf("%d", &s);
dp[s] = 1;
}
for (int i = 1; i <= k; i++) {
scanf("%d", &c[i]);
}
for (int i = 1; i <= n; i++) {
if (dp[i] == 1) adj[i] = adj[i - 1];
}
if (dp[0] == 1) {
printf("-1\n");
return 0;
}
long long ans = 1e18;
for (int i = 1; i <= k; i++) {
long long res = solve(i);
if (res != 1e18) ans = min(ans, res);
}
if (ans == 1e18) ans = -1;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, m, k;
int mx, cnt;
int a[N], b[N], vis[N];
long long ans;
int main() {
scanf("%d%d%d", &n, &m, &k);
mx = cnt = 0;
ans = -1;
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
vis[a[i]] = 1;
}
for (int i = 1; i <= k; i++) scanf("%d", &b[i]);
sort(a + 1, a + m + 1);
if (a[1] == 0 && m > 0) {
puts("-1");
return 0;
}
for (int i = 1; i <= m; i++) {
if (a[i] == a[i - 1] + 1)
cnt++;
else
cnt = 1;
mx = max(mx, cnt);
}
for (int i = 1; i <= n; i++) {
if (vis[i])
a[i] = a[i - 1];
else
a[i] = i;
}
for (int i = k; i >= 1; i--) {
if (i <= mx) break;
if ((n + i - 1) / i * b[i] >= ans && ans != -1) continue;
int l = 0;
long long sum = 0;
while (l < n) {
sum += b[i];
if (l + i >= n) break;
l = a[l + i];
}
if (ans == -1) ans = sum;
ans = min(ans, sum);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int prv[2 * 1000005];
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 0; i <= 2 * n; i++) prv[i] = i;
int x;
for (int i = 1; i <= m; i++) {
cin >> x;
prv[x] = prv[x - 1];
if (x - prv[x] >= k || x == 0) {
cout << -1;
return 0;
}
}
long long ans = (1 << 25);
ans *= ans;
for (int i = 1; i <= k; i++) {
cin >> x;
long long ans1 = 0;
int p = 0;
for (; p < n && prv[p + i] != p; p = prv[p + i]) ans1 += x;
if (p >= n) ans = min(ans, ans1);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
bool blocked[(int)1e6] = {0};
int last[(int)1e6];
int f(const int p) {
int ans = 0;
int lastPlaced = -1;
for (int i = 0; i < n; i += p) {
if (blocked[i]) {
i = last[i];
if (i <= lastPlaced) return n + 5;
}
lastPlaced = i;
++ans;
assert(!blocked[i]);
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int m, k;
cin >> n >> m >> k;
vector<int> a(k + 1, 0);
for (int i = 0; i < m; ++i) {
int s;
cin >> s;
if (!s) {
cout << -1;
return 0;
}
last[s] = blocked[s - 1] ? last[s - 1] : s - 1;
blocked[s] = true;
}
for (int i = 1; i <= k; ++i) cin >> a[i];
long long ans = 4e18;
for (int i = k; i >= 1; --i) {
if ((long long)a[i] * ((n + i - 1) / i) >= ans) continue;
long long cnt = f(i);
if (cnt > n + 1) continue;
ans = min(ans, cnt * a[i]);
}
cout << (ans < (long long)4e18 ? ans : -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
const long long inf = 1ll << 60;
int n, m, k, a[maxn];
int lft[maxn];
bool avl[maxn];
long long ans = inf;
long long get_lamps(int p) {
int ans = 0, pos = 0, cur = -1;
while (pos < n) {
if (lft[pos] <= cur) {
return inf;
} else {
cur = lft[pos];
pos = lft[pos] + p;
++ans;
}
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i <= n; ++i) avl[i] = true;
for (int i = 1, s; i <= m; ++i) scanf("%d", &s), avl[s] = false;
for (int i = 1; i <= k; ++i) scanf("%d", a + i);
for (int i = 0; i <= n; ++i) {
if (avl[i])
lft[i] = i;
else if (i > 0)
lft[i] = lft[i - 1];
else
lft[i] = -1;
}
for (int i = 1; i <= k; ++i) {
long long num = get_lamps(i);
if (num < inf) ans = min(ans, num * a[i]);
}
printf("%I64d\n", ans < inf ? ans : -1ll);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int tinf = (int)1e9 + 7;
const long long inf = (long long)1e18 + 7;
const int N = 4e5 + 5;
long long d[2000001], r[2000001];
int main() {
{
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long long n, m, k;
cin >> n >> m >> k;
long long second[m], a[k];
for (int i = 0; i < m; i++) {
cin >> second[i];
d[second[i]] = 1;
}
for (int i = 0; i < k; i++) {
cin >> a[i];
}
if (d[0]) {
cout << -1;
return 0;
}
for (int i = 0; i < n; i++) {
if (d[i])
d[i] = d[i - 1];
else
d[i] = i;
}
long long Min = inf;
for (int i = 0; i < k; i++) {
long long g = i + 1, l = 0, e = 0, c = -1, t = 0;
while (l < n) {
if (d[l] == c) {
e = 1;
break;
} else
c = d[l];
if (l + g >= n) {
t++;
break;
} else
l = d[l + g], t++;
}
if (!e) {
Min = min(Min, a[i] * t);
}
}
if (Min == inf)
cout << -1;
else
cout << Min;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ast[1000009];
long long pos[1000009];
long long val[1000009];
long long power(long long a, long long b) {
long long r = 1;
while (b != 0) {
if (b % 2 != 0) {
r = r * a;
r %= 1000000007;
}
a = a * a;
a = a % 1000000007;
b = b / 2;
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
long long n, m, k, cr = 0, mm = 0;
cin >> n >> m >> k;
long long ast[m + 1], pos[n + 1];
pos[0] = 0;
for (int i = 1; i <= m; i++) {
cin >> ast[i];
pos[ast[i]] = -1;
}
long long val[k + 1];
for (int j = 1; j <= k; j++) {
cin >> val[j];
}
if (pos[0] == -1) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i < n; i++) {
if (pos[i] == -1) {
mm = max(mm, i - cr);
pos[i] = cr;
} else {
cr = i;
pos[i] = i;
}
}
long long ans = 1e18, v = 0;
if ((mm + 1) > k) {
cout << -1 << endl;
return 0;
}
for (int i = (mm + 1); i <= k; i++) {
long long j = 0;
v = 0;
while (j < n) {
if (pos[j] == j) {
v += val[i];
j = j + i;
} else {
v += val[i];
j = pos[j];
j = j + i;
}
}
ans = min(ans, v);
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int N, M, K, pos[maxn], a[maxn];
int bad[maxn];
int good[maxn];
int main() {
scanf("%d %d %d", &N, &M, &K);
for (int i = 1; i <= M; ++i) {
scanf("%d", &pos[i]);
bad[pos[i]] = 1;
}
for (int i = 1; i <= K; ++i) {
scanf("%d", &a[i]);
}
if (bad[0] == 1) {
printf("-1\n");
return 0;
}
good[0] = 0;
int low = 0;
for (int i = 1; i <= N; ++i) {
if (bad[i]) {
good[i] = good[i - 1];
} else {
good[i] = i;
}
low = max(low, i - good[i] + 1);
}
if (low > K) {
printf("-1\n");
return 0;
}
long long ans = 1e18;
for (int k = low; k <= K; ++k) {
int j = 0;
long long cnt = 0;
while (j < N) {
++cnt;
j += k;
if (j >= N) break;
if (bad[j]) {
++cnt;
j = good[j] + k;
}
}
ans = min(ans, cnt * a[k]);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
bool ba[1000010];
int p[1000010], l[1000010];
inline void read(register int &x) {
x = 0;
register char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
}
inline long long calc(int num) {
int pos = 0;
register long long ans = p[num];
if (ba[0]) return -1;
while (pos < n) {
register int nepos = pos + num;
if (nepos >= n) return ans;
if (ba[nepos]) {
if (l[nepos] == pos)
return -1;
else
nepos = l[nepos];
}
pos = nepos;
ans += (long long)p[num];
}
return ans;
}
int main() {
read(n), read(m), read(k);
for (register int i = 1; i <= m; i++) {
register int pos;
read(pos);
ba[pos] = 1;
}
for (register int i = 1; i <= k; i++) read(p[i]);
for (register int i = 1; i <= n; i++) {
if (ba[i])
l[i] = l[i - 1];
else
l[i] = i;
}
long long ans = 9999999999999LL;
for (register int i = 1; i <= k; i++) {
long long tmp = calc(i);
if (tmp != -1) ans = min(ans, tmp);
}
if (ans == 9999999999999)
cout << -1 << endl;
else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int n, m, k, arr[N], a, nxt[N], nj;
bool blocked[N];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
scanf("%d", &a);
blocked[a] = true;
}
nxt[0] = -1;
for (int i = 1; i <= n; i++) {
if (blocked[i - 1])
nxt[i] = nxt[i - 1];
else
nxt[i] = i - 1;
}
for (int i = 1; i <= k; i++) scanf("%d", &arr[i]);
long long ans = (long long)4e18, cur;
for (int i = 1; i <= k; i++) {
cur = 0;
for (int j = 0; j < n;) {
if (blocked[j]) {
cur = (long long)4e18;
break;
}
nj = j + i;
if (nj < n && blocked[nj]) {
nj = nxt[nj];
}
if (nj <= j) {
cur = (long long)4e18;
break;
}
cur += arr[i];
j = nj;
}
ans = min(ans, cur);
}
if (ans >= (long long)3e18) ans = -1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int IO_MAXCHARS = 1 << 16;
char input_buffer[IO_MAXCHARS + 1];
struct FastReader {
char *p, *q;
FastReader() : p(input_buffer), q(input_buffer) {}
char next_char() {
if (p >= q) {
p = input_buffer;
q = p + fread(input_buffer, 1, IO_MAXCHARS, stdin);
*q = '\0';
}
return *p++;
}
template <typename T = int>
T next_num() {
char c = firstnws();
if (c == '-') {
return -next_unum<T>();
} else {
--p;
return next_unum<T>();
}
}
void next_string(string &buff) {
buff.clear();
buff += firstnws();
char c;
while (!isspace(c = next_char())) {
buff += c;
}
}
string next_string() {
string s;
next_string(s);
return s;
}
private:
char firstnws() {
char c;
while (isspace(c = next_char()))
;
return c;
}
template <typename T>
T next_unum() {
char c;
T ret = firstnws() - '0';
while (isdigit(c = next_char())) {
ret = 10 * ret + (c - '0');
}
return ret;
}
} reader;
const int MAXN = 1000000 + 3;
const long long INF = 1234567890123456LL;
int B[MAXN];
int prev_unblocked[MAXN];
int n;
long long calc(int range, long long cost) {
int at = 0;
long long ret = 0;
while (at < n) {
if (prev_unblocked[at] == -1) return INF;
if (prev_unblocked[at] + range <= at) return INF;
at = prev_unblocked[at] + range;
ret += cost;
}
return ret;
}
int main() {
n = reader.next_num();
int blocks = reader.next_num();
int ntypes = reader.next_num();
for (int i = 0; i < blocks; ++i) {
B[i] = reader.next_num();
}
int b = 0;
for (int i = 0; i < n; ++i) {
if (b < blocks && B[b] == i) {
prev_unblocked[i] = (i == 0 ? -1 : prev_unblocked[i - 1]);
++b;
} else {
prev_unblocked[i] = i;
}
}
vector<int> costs(ntypes);
for (int i = 0; i < ntypes; ++i) {
costs[i] = reader.next_num();
}
vector<pair<int, int>> types = {{ntypes, costs.back()}};
for (int i = ntypes - 2; i >= 0; --i) {
if (costs[i] < types.back().second) {
types.emplace_back(i + 1, costs[i]);
}
}
reverse(types.begin(), types.end());
long long sol = INF;
for (const auto &t : types) {
sol = min(sol, calc(t.first, t.second));
}
printf("%I64d\n", sol == INF ? -1LL : sol);
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1000010];
bool b[1000010];
int pre[1000010];
int main() {
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int s;
cin >> s;
b[s] = true;
}
for (int i = 1; i <= k; i++) cin >> a[i];
if (b[0]) {
cout << -1 << "\n";
return 0;
}
int last = 0, maxd = 0;
pre[0] = 0;
for (int i = 1; i <= n; i++) {
if (!b[i]) {
last = i;
pre[i] = i;
} else {
pre[i] = last;
maxd = max(maxd, min(n, i + 1) - pre[i]);
}
}
if (maxd > k) {
cout << -1 << "\n";
return 0;
}
long long ans = 1000000000000000;
for (int i = max(1, maxd); i <= k; i++) {
int cur = 0, cnt = 0;
while (cur < n) {
if (b[cur]) {
cur = pre[cur] + i;
} else
cur = cur + i;
cnt++;
}
if (ans > a[i] * cnt) ans = a[i] * cnt;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int s[1000005];
long long a[1000005];
int head[1000005];
int main() {
memset(s, 0, sizeof(s));
memset(a, 0, sizeof(a));
scanf("%d%d%d", &n, &m, &k);
int tmp;
for (int i = 1; i <= m; i++) {
scanf("%d", &tmp);
s[tmp] = 1;
}
for (int i = 1; i <= k; i++) scanf("%lld", &a[i]);
if (s[0] == 1) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; i++) {
if (s[i])
head[i] = head[i - 1];
else
head[i] = i;
}
long long ans = 0x7fffffffffffffff;
for (int i = 1; i <= k; i++) {
int now = 0;
long long tmp = 1;
while (1) {
if (now + i > n - 1) {
long long ans1 = tmp * a[i];
ans = min(ans, ans1);
break;
}
if (now == head[now + i]) {
break;
}
now = head[now + i];
tmp++;
}
}
if (ans == 0x7fffffffffffffff)
printf("-1\n");
else
printf("%lld\n", ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.