text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, kezd[200002], veg[200002], pos[200002], inv[200002], x, csa, csb;
vector<pair<pair<int, int>, int> > sz;
vector<int> v;
priority_queue<pair<int, int> > q;
void p() {
for (int i = 1; i <= n; i++) inv[pos[i]] = i;
for (int i = 1; i <= n; i++) cout << inv[i] << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int a, b;
cin >> a >> b, kezd[i] = a, veg[i] = b;
sz.push_back({{a, b}, i});
}
sort(sz.begin(), sz.end());
for (int i = 1; i <= n; i++) {
while (x < n && sz[x].first.first == i)
q.push({-sz[x].first.second, sz[x].second}), x++;
pos[i] = q.top().second, q.pop();
}
for (int i = 1; i <= n; i++) {
while (v.size() > 0 && veg[pos[v.back()]] < i) {
v.pop_back();
}
int a = kezd[pos[i]], b = veg[pos[i]];
if (v.size() > 0 && a <= v.back()) {
csa = i, csb = v.back();
}
while (v.size() > 0 && b >= veg[pos[v.back()]]) v.pop_back();
v.push_back(i);
}
if (!csa) {
cout << "YES"
<< "\n";
p();
} else {
cout << "NO"
<< "\n";
p(), swap(pos[csa], pos[csb]), p();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
using ll = long long;
using ld = long double;
const string FILENAME = "input";
const int MAXN = 200228;
int n;
int a[MAXN], b[MAXN];
int c[MAXN];
vector<pair<int, int> > g[MAXN];
bool ok(int i, int val) { return a[i] <= val && val <= b[i]; }
int who[MAXN];
vector<int> ending[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
g[a[i]].push_back({b[i], i});
}
set<pair<int, int> > s;
for (int i = 1; i <= n; i++) {
for (auto x : g[i]) {
s.insert(x);
}
auto x = *s.begin();
s.erase(x);
c[x.second] = i;
}
for (int i = 0; i < n; i++) {
who[c[i]] = i;
ending[b[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (!s.empty()) {
auto x = *s.rbegin();
int t = x.second;
if (x.first >= a[who[i]]) {
assert(ok(t, i) && ok(who[i], c[t]));
}
if (ok(t, i) && ok(who[i], c[t])) {
cout << "NO\n";
for (int is = 0; is < n; is++) {
cout << c[is] << ' ';
}
cout << '\n';
swap(c[t], c[who[i]]);
for (int is = 0; is < n; is++) {
cout << c[is] << ' ';
}
cout << '\n';
return 0;
}
}
s.insert(make_pair(i, who[i]));
for (auto x : ending[i]) {
s.erase(make_pair(c[x], x));
}
}
for (int i = 0; i < n - 1; i++) {
if (ok(i, c[i + 1]) && ok(i + 1, c[i])) {
cout << "NO\n";
for (int is = 0; is < n; is++) {
cout << c[is] << ' ';
}
cout << '\n';
swap(c[i], c[i + 1]);
for (int is = 0; is < n; is++) {
cout << c[is] << ' ';
}
cout << '\n';
return 0;
}
}
cout << "YES\n";
for (int i = 0; i < n; i++) {
cout << c[i] << ' ';
}
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 200000;
int n;
int a[mxn], b[mxn], first[mxn], ff[mxn];
vector<int> v[mxn];
auto cmp = [](int x, int y) { return b[x] > b[y]; };
priority_queue<int, vector<int>, decltype(cmp)> pq(cmp);
map<int, int> second;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
a[i]--, b[i]--;
v[a[i]].push_back(i);
}
int p = -1, q = -1;
for (int i = 0; i < n; i++) {
for (int j : v[i]) pq.push(j);
int x = pq.top();
pq.pop();
first[i] = x, ff[x] = i + 1;
if (!~p) {
auto it = second.lower_bound(i);
if (it != second.end() && it->second >= a[x]) {
p = first[it->second], q = x;
} else {
it = second.insert({b[x], i}).first;
if (it->second < i) {
if (next(it) != second.end() && i <= next(it)->second)
it = second.erase(it);
while (it != second.begin() && (--it)->second <= i)
it = second.erase(it);
}
}
}
}
cout << (!~p ? "YES" : "NO") << '\n';
for (int i = 0; i < 1 + !!~p; i++) {
cout << ff[0];
for (int i = 1; i < n; i++) cout << " " << ff[i];
cout << '\n';
if (~p) swap(ff[p], ff[q]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7, lim = 4 * maxn;
pair<int, int> segtree[lim];
set<pair<int, int> > s;
vector<pair<int, pair<int, int> > > v;
int ip[maxn][2], ans[maxn], pos[maxn], n, swapl = -1, swapr = -1;
void build(int cur, int l, int r) {
if (l == r) {
segtree[cur] = {ip[pos[l]][0], l};
return;
}
int lc = 2 * cur, rc = lc + 1, mid = (l + r) / 2;
build(lc, l, mid);
build(rc, mid + 1, r);
segtree[cur] = min(segtree[lc], segtree[rc]);
}
pair<int, int> query(int cur, int l, int r, int ql, int qr) {
if (l > qr || r < ql || ql > qr) {
return {INT_MAX, INT_MAX};
}
if (l >= ql && r <= qr) {
return segtree[cur];
}
int lc = 2 * cur, rc = lc + 1, mid = (l + r) / 2;
return min(query(lc, l, mid, ql, qr), query(rc, mid + 1, r, ql, qr));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> ip[i][0] >> ip[i][1];
v.push_back({ip[i][0], {ip[i][1], i}});
}
sort(v.rbegin(), v.rend());
for (int i = 1; i <= n; i++) {
while (!v.empty() && v.back().first <= i) {
s.insert(v.back().second);
v.pop_back();
}
pair<int, int> cur = *s.begin();
s.erase(s.begin());
ans[cur.second] = i;
pos[i] = cur.second;
}
build(1, 1, n);
for (int i = 1; i < n; i++) {
int j = query(1, 1, n, i + 1, ip[pos[i]][1]).second;
if (j == INT_MAX || ip[pos[j]][0] > i) continue;
swapl = i;
swapr = j;
}
if (swapl == -1) {
cout << "YES\n";
} else {
cout << "NO\n";
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << '\n';
if (swapl != -1) {
swap(ans[pos[swapl]], ans[pos[swapr]]);
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
for (; b; a %= b, swap(a, b))
;
return a;
}
int n;
struct pos {
int l;
int r;
int idx;
bool operator<(const pos p) const {
if (r != p.r)
return r < p.r;
else if (l != p.l)
return l < p.l;
return idx < p.idx;
}
};
bool comp(pos p1, pos p2) { return p1.l < p2.l; }
const int N = 200001;
pos p[N], tmp[N];
set<pos> st;
int ans1[N], ans2[N];
int ans_idx[N];
pair<int, int> segTree[N * 4];
void update(int ptr, int l, int r, int i, pair<int, int> val) {
if (l > i || r < i) return;
if (l == r) {
segTree[ptr] = val;
return;
}
update(ptr * 2, l, (l + r) / 2, i, val);
update(ptr * 2 + 1, (l + r) / 2 + 1, r, i, val);
segTree[ptr] = max(segTree[ptr * 2], segTree[ptr * 2 + 1]);
}
pair<int, int> getVal(int ptr, int l, int r, int i, int j) {
if (l > j || r < i) return {0, 0};
if (i <= l && r <= j) return segTree[ptr];
return max(getVal(ptr * 2, l, (l + r) / 2, i, j),
getVal(ptr * 2 + 1, (l + r) / 2 + 1, r, i, j));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].l >> p[i].r;
p[i].idx = i;
tmp[i] = p[i];
}
sort(p, p + n, comp);
int ptr = 0;
bool isYes = true;
for (int i = 0; i < n; i++) {
while (ptr < n && p[ptr].l == i + 1) st.insert(p[ptr++]);
pos cur = *st.begin();
st.erase(st.begin());
ans1[cur.idx] = i + 1;
ans2[cur.idx] = i + 1;
ans_idx[i + 1] = cur.idx;
}
for (int i = 1; i <= n; i++) {
int idx = ans_idx[i];
pair<int, int> v = {tmp[idx].r, idx};
update(1, 1, n, i, v);
if (i > 1 && isYes) {
pair<int, int> res = getVal(1, 1, n, tmp[idx].l, i - 1);
if (res.first >= i) {
isYes = false;
swap(ans2[res.second], ans2[idx]);
}
}
}
if (isYes) {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << ans1[i] << ' ';
} else {
cout << "NO\n";
for (int i = 0; i < n; i++) cout << ans1[i] << ' ';
cout << "\n";
for (int i = 0; i < n; i++) cout << ans2[i] << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> label[200005];
pair<pair<int, int>, int> sortedLabel[200005];
int order[200005];
int lastInd[200005];
int ans[200005];
int n;
int tree[400005];
int query(int l, int r) {
int res = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = max(res, tree[l++]);
if (r & 1) res = max(res, tree[--r]);
}
return res;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> label[i].first >> label[i].second;
label[i].first--;
label[i].second--;
sortedLabel[i].first = label[i];
sortedLabel[i].second = i;
}
sort(sortedLabel, sortedLabel + n);
set<pair<pair<int, int>, int> > end_start;
int cur = 0;
for (int i = 0; i < n; i++) {
while (cur < n && sortedLabel[cur].first.first <= i) {
end_start.insert(
{{sortedLabel[cur].first.second, sortedLabel[cur].first.first},
sortedLabel[cur].second});
cur++;
}
auto x = end_start.begin();
order[i] = x->second;
end_start.erase(x);
}
for (int i = 0; i < n; i++) {
lastInd[i] = label[order[i]].second;
}
for (int i = 0; i < n; i++) tree[n + i] = lastInd[i];
for (int i = n - 1; i > 0; i--) tree[i] = max(tree[i << 1], tree[i << 1 | 1]);
pair<int, int> xchng = {-1, -1};
for (int i = 1; i < n; i++) {
int maxVal = query(label[order[i]].first, i);
if (maxVal >= i) {
xchng.first = i;
for (int j = label[order[i]].first; j < i; j++) {
if (label[order[j]].second >= i) {
xchng.second = j;
break;
}
}
break;
}
}
for (int i = 0; i < n; i++) ans[order[i]] = i;
if (xchng.second != -1) {
cout << "NO\n";
for (int i = 0; i < n; i++) cout << ans[i] + 1 << " ";
cout << "\n";
swap(order[xchng.first], order[xchng.second]);
for (int i = 0; i < n; i++) ans[order[i]] = i;
for (int i = 0; i < n; i++) cout << ans[i] + 1 << " ";
} else {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << ans[i] + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int _w;
set<int> S;
priority_queue<pair<int, int> > Q;
int n, L[N], R[N], match[N], fr[N], vis[N];
void another(int u, int v) {
static int rmp[N];
puts("NO");
for (int i = 1; i <= n; ++i) rmp[match[i]] = i;
for (int i = 1; i <= n; ++i) printf("%d ", rmp[i]);
putchar('\n');
int x = u;
while (x != v) x = match[rmp[x]] = fr[x];
match[rmp[v]] = u;
for (int i = 1; i <= n; ++i) rmp[match[i]] = i;
for (int i = 1; i <= n; ++i) printf("%d ", rmp[i]);
exit(0);
}
void dfs(int u) {
set<int>::iterator it;
vector<int> del;
vis[u] = 1;
int v;
while (!S.empty()) {
it = S.lower_bound(L[u]);
if (it != S.end() && match[*it] == u) {
del.push_back(*it);
++it;
}
if (it == S.end()) break;
if (*it > R[u]) break;
v = match[*it];
if (vis[v] == 1) another(u, v);
del.push_back(*it);
if (vis[v] == 2) continue;
fr[v] = u;
dfs(v);
}
while (!del.empty()) {
if (S.count(del.back())) S.erase(del.back());
del.pop_back();
}
vis[u] = 2;
}
int main(void) {
static int id[N];
_w = scanf("%d", &n);
for (int i = 1; i <= n; ++i)
_w = scanf("%d%d", L + i, R + i), id[i] = i, S.insert(i);
sort(id + 1, id + 1 + n, [](int a, int b) { return L[a] < L[b]; });
for (int i = 1, cur = 1; i <= n; ++i) {
while (cur <= n && L[id[cur]] == i)
Q.push(pair<int, int>(-R[id[cur]], id[cur])), ++cur;
match[i] = Q.top().second;
Q.pop();
}
for (int i = 1; i <= n; ++i) id[match[i]] = i;
for (int i = 1; i <= n; ++i)
if (!vis[i]) dfs(i);
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d ", id[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
class DebugStream {
} LOG;
template <typename T>
DebugStream &operator<<(DebugStream &s, const T &) {
return s;
}
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const int maxN = 2e5 + 9, maxV = 1e6 + 9, MOD = 1e9 + 7, SQ = 335, lg = 20,
bs = 29;
int le[maxN], ri[maxN], n, rsp = -1, nxt[maxN];
vector<int> solve(int cnd) {
vector<int> inds(n), ret(n);
iota(inds.begin(), inds.end(), 0);
sort(inds.begin(), inds.end(), [&](int a, int b) { return le[a] < le[b]; });
auto compare = [&](int a, int b) {
return ri[a] > ri[b] || (ri[a] == ri[b] && a > b);
};
priority_queue<int, vector<int>, decltype(compare)> pq(compare);
int cr = 0;
auto fn = [&]() {
int tpp = pq.top();
pq.pop();
if (pq.size()) {
nxt[tpp] = pq.top();
}
ret[tpp] = cr++;
};
for (int i = 0, j = 0; i < n; i = j) {
while (le[inds[i]] > cr) fn();
for (; j < n && le[inds[i]] == le[inds[j]]; j++) pq.push(inds[j]);
}
while (pq.size()) fn();
return ret;
}
void prt(vector<int> vc) {
for (auto el : vc) cout << el + 1 << ' ';
cout << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> le[i] >> ri[i];
le[i]--;
42;
nxt[i] = -1;
}
auto uno = solve(1);
for (int i = 0; i < n; i++) {
if (nxt[i] != -1 && uno[nxt[i]] < ri[i]) {
cout << "NO\n";
prt(uno);
swap(uno[i], uno[nxt[i]]);
prt(uno);
exit(0);
}
}
cout << "YES\n";
prt(uno);
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
struct interv {
int x, y, p;
bool operator<(const interv &aux) const {
if (x != aux.x) return x < aux.x;
return y < aux.y;
}
};
interv a[200005];
int n;
int which[200005], ans[200005], aux[200005];
set<pair<int, int> > s;
int Arb[800020], where[800020];
void update(int pos, int val, int st = 1, int dr = n, int nod = 1) {
if (st == dr) {
Arb[nod] = val;
if (val == 1)
where[nod] = pos;
else
where[nod] = 0;
return;
}
int mij = (st + dr) / 2;
if (pos <= mij) update(pos, val, st, mij, nod * 2);
if (mij + 1 <= pos) update(pos, val, mij + 1, dr, nod * 2 + 1);
Arb[nod] = Arb[nod * 2] + Arb[nod * 2 + 1];
where[nod] = max(where[nod * 2], where[nod * 2 + 1]);
}
int query(int x, int y, int st = 1, int dr = n, int nod = 1) {
if (x <= st && dr <= y) return where[nod];
int mij = (st + dr) / 2;
int ans = 0;
if (x <= mij) ans = max(ans, query(x, y, st, mij, nod * 2));
if (mij + 1 <= y) ans = max(ans, query(x, y, mij + 1, dr, nod * 2 + 1));
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a[i].x, &a[i].y);
a[i].p = i;
}
sort(a + 1, a + n + 1);
int j = 1;
for (int val = 1; val <= n; ++val) {
while (j <= n && a[j].x <= val) {
s.insert({a[j].y, j});
++j;
}
which[val] = s.begin()->second;
aux[s.begin()->second] = val;
s.erase(s.begin());
}
for (int val = 1; val <= n; ++val) ans[a[which[val]].p] = val;
j = 1;
for (int val = 1; val <= n; ++val) {
while (j <= n && a[j].x <= val) {
update(aux[j], 1);
s.insert({a[j].y, j});
++j;
}
int q = 0;
int ind = which[val];
if (a[ind].x < val) q = max(q, query(a[ind].x, val - 1));
if (val < a[ind].y && q == 0) q = max(q, query(val + 1, a[ind].y));
if (q != 0) {
printf("NO\n");
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
ans[a[ind].p] = q;
ans[a[which[q]].p] = val;
printf("\n");
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
while (!s.empty() && s.begin()->first == val) {
int j = s.begin()->second;
update(aux[j], 0);
s.erase(s.begin());
}
}
printf("YES\n");
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct node {
int l, r;
int id;
};
void ans_swap(vector<int> &vec, int a, int b) {
int p1, p2;
for (int i = 1; i < vec.size(); i++) {
if (vec[i] == a) p1 = i;
if (vec[i] == b) p2 = i;
}
swap(vec[p1], vec[p2]);
}
void out(vector<int> &vec) {
for (int i = 1; i < vec.size(); i++) {
cout << vec[i] << ' ';
}
cout << '\n';
}
int F_Min[N][20], F_Max[N][20];
int Min(int l, int r) {
if (l > r) {
return 1e9;
}
int k = (int)(log(double(r - l + 1)) / log((double)2));
return min(F_Min[l][k], F_Min[r - (1 << k) + 1][k]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<node> v(n + 1), v2(n + 1);
vector<int> ans(n + 1);
set<int> s;
for (int i = 1; i <= n; i++) {
s.insert(i);
cin >> v[i].l >> v[i].r;
v[i].id = i;
v2[i] = v[i];
}
sort(v.begin(), v.end(), [](node &a, node &b) { return a.r < b.r; });
for (int i = 1; i <= n; i++) {
int p = v[i].id;
int l = v[i].l;
int val = *s.lower_bound(l);
ans[p] = val;
s.erase(val);
}
for (int i = 1; i <= n; i++) {
v2[i].id = ans[i];
}
sort(v2.begin(), v2.end(), [](node &a, node &b) { return a.id < b.id; });
for (int i = 1; i <= n; i++) {
F_Min[i][0] = F_Max[i][0] = v2[i].l;
}
for (int i = 1; (1 << i) <= n; i++) {
for (int j = 1; j + (1 << i) - 1 <= n; j++) {
F_Max[j][i] = max(F_Max[j][i - 1], F_Max[j + (1 << (i - 1))][i - 1]);
F_Min[j][i] = min(F_Min[j][i - 1], F_Min[j + (1 << (i - 1))][i - 1]);
}
}
for (int i = 1; i <= n; i++) {
int t_min = Min(i + 1, v2[i].r);
if (t_min <= i) {
cout << "NO" << endl;
out(ans);
for (int j = i + 1; j <= n; j++) {
if (v2[j].l == t_min && i <= v2[j].r) {
ans_swap(ans, i, j);
break;
}
}
out(ans);
return 0;
}
}
cout << "YES" << endl;
out(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
function<void(void)> ____ = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
const int MAXN = 2e5 + 7;
const int INF = 0x3f3f3f3f;
int n, dz[MAXN];
vector<pair<int, pair<int, int>>> vec[MAXN];
int rmax[MAXN];
template <typename T>
struct SegmentTree {
T maxx[MAXN << 2], lazy[MAXN << 2];
int l[MAXN << 2], r[MAXN << 2];
void build(int L, int R, int rt) {
l[rt] = L;
r[rt] = R;
lazy[rt] = 0;
if (L + 1 == R) return;
int mid = (L + R) >> 1;
build(L, mid, rt << 1);
build(mid, R, rt << 1 | 1);
}
void pushdown(int rt) {
if (!lazy[rt]) return;
lazy[rt << 1] += lazy[rt];
lazy[rt << 1 | 1] += lazy[rt];
maxx[rt << 1] += lazy[rt];
maxx[rt << 1 | 1] += lazy[rt];
lazy[rt] = 0;
}
void update(int L, int R, int rt, T x) {
if (L >= r[rt] || l[rt] >= R) return;
if (L <= l[rt] && r[rt] <= R) {
lazy[rt] += x;
maxx[rt] += x;
return;
}
pushdown(rt);
update(L, R, rt << 1, x);
update(L, R, rt << 1 | 1, x);
maxx[rt] = max(maxx[rt << 1], maxx[rt << 1 | 1]);
}
T query(int L, int R, int rt) {
if (L >= r[rt] || l[rt] >= R) return -INF;
if (L <= l[rt] && r[rt] <= R) return maxx[rt];
pushdown(rt);
return max(query(L, R, rt << 1), query(L, R, rt << 1 | 1));
}
};
SegmentTree<int> ST;
int main() {
____();
cin >> n;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
l--, r--;
rmax[i] = r;
vec[l].push_back(make_pair(r, make_pair(l, i)));
}
priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>,
greater<pair<int, pair<int, int>>>>
que;
ST.build(0, n, 1);
bool unq = true;
vector<int> ret1, ret2;
for (int i = 0; i < n; i++) {
for (auto seg : vec[i]) que.push(seg);
auto p = que.top();
que.pop();
ret1.push_back(p.second.second);
if (!unq) {
ret2.push_back(p.second.second);
continue;
}
ST.update(i, i + 1, 1, p.first);
if (!i) continue;
int maxx = ST.query(p.second.first, i, 1);
if (maxx < i) continue;
unq = false;
int pos = 0;
for (int j = p.second.first; j < i; j++) {
if (rmax[ret1[j]] >= i) {
pos = j;
break;
}
}
copy(ret1.begin(), ret1.end(), back_inserter(ret2));
swap(ret2[pos], ret2[i]);
}
if (unq) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) dz[ret1[i]] = i + 1;
for (int i = 0; i < n; i++) cout << dz[i] << ' ';
cout << endl;
} else {
cout << "NO" << endl;
for (int i = 0; i < n; i++) dz[ret1[i]] = i + 1;
for (int i = 0; i < n; i++) cout << dz[i] << ' ';
cout << endl;
for (int i = 0; i < n; i++) dz[ret2[i]] = i + 1;
for (int i = 0; i < n; i++) cout << dz[i] << ' ';
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
const int mod = 1e9 + 7;
long long qp(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
template <class T>
inline bool scan(T& ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
int n;
set<pair<int, int> > st;
vector<pair<int, int> > a[maxn];
int res[maxn];
void pt(const vector<int>& x) {
for (auto i : x) printf("%d ", i);
printf("\n");
}
int main(int argc, char* argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int l, r;
scanf("%d%d", &l, &r);
a[l].emplace_back(r, i);
}
for (int i = 1; i <= n; ++i) {
for (auto j : a[i]) st.emplace(j);
res[st.begin()->second] = i;
st.erase(st.begin());
}
for (int i = 1; i <= n; ++i) {
for (auto j : a[i]) st.emplace(j);
if (st.size() > 1 && res[next(st.begin())->second] <= st.begin()->first) {
puts("NO");
pt(vector<int>(res, res + n));
swap(res[next(st.begin())->second], res[st.begin()->second]);
pt(vector<int>(res, res + n));
exit(0);
}
st.erase(st.begin());
}
puts("YES");
pt(vector<int>(res, res + n));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
const int N = 2e5 + 10;
int n, l[N], r[N], p[N];
vector<ii> interval[N];
multiset<ii> st;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &l[i], &r[i]);
interval[l[i]].push_back({r[i], i});
}
for (int i = 1; i <= n; i++) {
while (!interval[i].empty()) {
st.insert(interval[i].back());
interval[i].pop_back();
}
auto it = *st.begin();
st.erase(st.begin());
p[it.second] = i;
}
for (int i = 1; i <= n; i++) {
interval[p[i]].push_back({i, +1});
interval[r[i] + 1].push_back({i, -1});
}
vector<int> ord(n, 0);
iota(ord.begin(), ord.end(), 1);
sort(ord.begin(), ord.end(), [&](int x, int y) { return p[x] < p[y]; });
st.clear();
int p1 = -1, p2;
for (int i : ord) {
for (auto work : interval[p[i]])
if (work.second == -1) st.erase(st.find({p[work.first], work.first}));
if (!st.empty()) {
auto it = *st.rbegin();
int mx = it.first;
if (l[i] <= mx) {
p1 = i;
p2 = it.second;
break;
}
}
for (auto work : interval[p[i]])
if (work.second == 1) st.insert({p[work.first], work.first});
}
if (p1 + 1) {
puts("NO");
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
puts("");
swap(p[p1], p[p2]);
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
puts("");
} else {
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
const int N = 2e5 + 5;
int n, l[N], r[N], atob[N], btoa[N];
vector<ii> ops[N], rng[N];
set<int> unvis, stk;
int par[N];
int anc = -1, des = -1;
void dfs(int a, int dad = -1) {
par[a] = dad;
unvis.erase(a);
stk.insert(a);
int b = atob[a];
for (auto &[x, y] : rng[b]) {
auto tmp = stk.lower_bound(x);
if (tmp != stk.end() && *tmp <= y) {
anc = *tmp, des = b;
return;
}
for (auto it = unvis.lower_bound(x); it != unvis.end() && *it <= y;) {
int i = *it;
dfs(i, b);
if (~anc) return;
it = unvis.lower_bound(i + 1);
}
}
stk.erase(a);
}
int main(int argc, char const *argv[]) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d %d", l + i, r + i);
ops[l[i]].emplace_back(i, +1);
ops[r[i] + 1].emplace_back(i, -1);
}
set<ii> bag;
for (int i = 1; i <= n; ++i) {
for (ii &o : ops[i]) {
int j = o.first;
if (o.second == -1) {
bag.erase(ii(r[j], j));
} else {
bag.insert(ii(r[j], j));
}
}
atob[i] = bag.begin()->second;
bag.erase(bag.begin());
}
for (int i = 1; i <= n; ++i) {
btoa[atob[i]] = i;
}
for (int i = 1; i <= n; ++i) {
int &m = btoa[i];
if (l[i] <= m - 1) rng[i].emplace_back(l[i], m - 1);
if (m + 1 <= r[i]) rng[i].emplace_back(m + 1, r[i]);
}
for (int i = 1; i <= n; ++i) unvis.insert(i);
for (int i = 1; i <= n; ++i) {
if (unvis.count(i)) {
dfs(i);
if (~anc) break;
}
}
if (!~anc) {
puts("YES");
for (int i = 1; i <= n; ++i) {
printf("%d%c", btoa[i], " \n"[i == n]);
}
return 0;
}
puts("NO");
for (int i = 1; i <= n; ++i) {
printf("%d%c", btoa[i], " \n"[i == n]);
}
int cura = btoa[des];
int curb = par[cura];
while (cura != anc) {
int nxta = btoa[curb];
int nxtb = par[nxta];
atob[cura] = curb;
btoa[curb] = cura;
cura = nxta;
curb = nxtb;
}
btoa[des] = anc;
atob[anc] = des;
for (int i = 1; i <= n; ++i) {
printf("%d%c", btoa[i], " \n"[i == n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p);
template <class T>
ostream &operator<<(ostream &os, vector<T> &v);
template <class T>
ostream &operator<<(ostream &os, set<T> &v);
template <class T1, class T2>
ostream &operator<<(ostream &os, map<T1, T2> &v);
const long long mod = 1e9 + 7;
const int N = 2e5 + 5;
void Print(vector<int> &v) {
for (int i = 0; i < v.size(); i++) {
printf("%d ", v[i]);
}
printf("\n");
}
bool check(pair<int, int> a, pair<int, int> b, int ans1, int ans2) {
return ans1 >= b.first && ans1 <= b.second && ans2 >= a.first &&
ans2 <= a.second;
}
vector<int> ans;
bool comp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
return ans[a.second] < ans[b.second];
}
void TEST_CASES(int cas) {
int n;
scanf("%d", &n);
ans.resize(n);
vector<pair<pair<int, int>, int> > v(n);
vector<multiset<pair<int, int> > > st(n + 1);
for (int i = 0; i < n; i++) {
scanf("%d %d", &v[i].first.first, &v[i].first.second);
v[i].second = i;
st[v[i].first.first].insert({v[i].first.second, v[i].second});
}
priority_queue<pair<int, int> > pq;
for (int i = 1; i <= n; i++) {
for (auto it : st[i]) {
pq.push({-it.first, it.second});
}
pair<int, int> p = pq.top();
pq.pop();
ans[p.second] = i;
}
sort(v.begin(), v.end(), comp);
for (int i = 0; i < n - 1; i++) {
if (check(v[i].first, v[i + 1].first, ans[v[i].second],
ans[v[i + 1].second])) {
printf("NO\n");
Print(ans);
swap(ans[v[i].second], ans[v[i + 1].second]);
Print(ans);
return;
}
}
sort(v.begin(), v.end());
for (int i = 0; i < n - 1; i++) {
if (check(v[i].first, v[i + 1].first, ans[v[i].second],
ans[v[i + 1].second])) {
printf("NO\n");
Print(ans);
swap(ans[v[i].second], ans[v[i + 1].second]);
Print(ans);
return;
}
}
printf("YES\n");
Print(ans);
}
int main() {
int t = 1, cas = 0;
while (t--) {
TEST_CASES(++cas);
}
return 0;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << "{" << p.first << ", " << p.second << "} ";
return os;
}
template <class T>
ostream &operator<<(ostream &os, vector<T> &v) {
os << "[ ";
for (int i = 0; i < v.size(); i++) {
os << v[i] << " ";
}
os << " ]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, set<T> &v) {
os << "[ ";
for (T i : v) {
os << i << " ";
}
os << " ]";
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, map<T1, T2> &v) {
for (auto i : v) {
os << "Key : " << i.first << " , Value : " << i.second << endl;
}
return os;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC optimize(3, "Ofast", "inline")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
const double esp = 1e-6, pi = acos(-1);
const int N = 1e6 + 10, INF = 0x3f3f3f3f, mod = 1e9 + 7;
int val[N], p[N], n, L[N], R[N];
struct node {
int l, r, id;
bool operator<(const node &a) const {
if (l != a.l) return l < a.l;
return r < a.r;
}
} e[N];
int sum[N * 4];
void up(int rt) { sum[rt] = sum[rt << 1] + sum[rt << 1 | 1]; }
void update(int rt, int l, int r, int pos, int k) {
if (l == r) {
sum[rt] += k;
return;
}
int mid = l + r >> 1;
if (pos <= mid)
update(rt << 1, l, mid, pos, k);
else
update(rt << 1 | 1, mid + 1, r, pos, k);
up(rt);
}
int ask(int rt, int l, int r, int ql, int qr) {
if (l == r) {
if (sum[rt]) return l;
return 0;
}
int ans = 0, mid = l + r >> 1;
if (ql <= mid && sum[rt << 1]) ans = ask(rt << 1, l, mid, ql, qr);
if (qr > mid && sum[rt << 1 | 1] && !ans)
ans = ask(rt << 1 | 1, mid + 1, r, ql, qr);
return ans;
}
int work() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &L[i], &R[i]);
e[i] = {L[i], R[i], i};
}
sort(e + 1, e + n + 1);
set<pair<int, int> > s;
for (int i = 1, j = 1; i <= n; i++) {
while (j <= n && e[j].l == i) s.insert({e[j].r, e[j].id}), j++;
p[i] = (*s.begin()).second;
val[p[i]] = i;
s.erase(s.begin());
}
for (int i = 1, j = 1; i <= n; i++) {
int id = p[i];
while (j <= n && e[j].l == i) update(1, 1, n, val[e[j].id], 1), j++;
update(1, 1, n, val[id], -1);
int ans = ask(1, 1, n, L[id], R[id]);
if (ans) {
puts("NO");
for (int i = 1; i <= n; i++) cout << val[i] << " ";
puts("");
swap(val[id], val[p[ans]]);
for (int i = 1; i <= n; i++) cout << val[i] << " ";
puts("");
return 0;
}
}
puts("YES");
for (int i = 1; i <= n; i++) cout << val[i] << " ";
puts("");
return 0;
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
int n, ans1 = -1, ans2, par[N];
pair<int, int> m, p[N], tree[N * 2];
vector<pair<int, int> > v[N];
set<pair<int, int> > s;
pair<int, int> query(int l, int r) {
pair<int, int> res;
res.first = res.second = -1;
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) {
if (tree[l].first > res.first) res = tree[l];
l++;
}
if (r & 1) {
if (tree[--r].first > res.first) res = tree[r];
}
}
return res;
}
void make_tree() {
for (int i = n - 1; i >= 1; i--) {
pair<int, int> p1 = tree[i * 2], p2 = tree[i * 2 + 1];
if (p1.first > p2.first)
tree[i] = p1;
else
tree[i] = p2;
}
}
int main() {
cin >> n;
for (long long i = 0; i < n; i++) {
scanf("%d%d", &p[i].first, &p[i].second);
;
p[i].first--, p[i].second--;
v[p[i].first].push_back(make_pair(p[i].second, i));
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < v[i].size(); j++) s.insert(v[i][j]);
pair<int, int> u = *s.begin();
s.erase(u);
tree[i + n] = u;
par[u.second] = i;
}
make_tree();
for (long long i = 0; i < n; i++) {
m = query(p[i].first, par[i] - 1);
if (m.first >= par[i]) ans1 = i, ans2 = m.second;
}
if (ans1 == -1)
cout << "YES" << endl;
else
cout << "NO" << endl;
for (long long i = 0; i < n; i++) cout << par[i] + 1 << " ";
cout << endl;
if (ans1 != -1) {
swap(par[ans1], par[ans2]);
for (long long i = 0; i < n; i++) cout << par[i] + 1 << " ";
}
}
|
#include <bits/stdc++.h>
class Segtree {
private:
std::vector<int> t_;
int n_;
public:
int Query(int n, int lft, int rgt, int rs, int re) {
if (lft >= rs && rgt <= re) return t_[n];
if (lft > re || rgt < rs) return 0;
const int mid = (lft + rgt) / 2;
return std::max(Query(2 * n, lft, mid, rs, re),
Query(2 * n + 1, mid + 1, rgt, rs, re));
}
void Set(int n, int lft, int rgt, int pt, int v) {
if (lft == rgt) {
t_[n] = v;
return;
}
const int mid = (lft + rgt) / 2;
if (pt <= mid) {
Set(2 * n, lft, mid, pt, v);
} else {
Set(2 * n + 1, mid + 1, rgt, pt, v);
}
t_[n] = std::max(t_[2 * n], t_[2 * n + 1]);
}
Segtree(int n) : n_(n), t_(4 * n + 1) {}
};
template <typename T>
void print_vector(const std::vector<T>& v, int lo, int hi,
bool newline = true) {
while (lo <= hi) {
std::cout << v[lo++] << ' ';
}
if (newline) {
std::cout << '\n';
}
}
void Run() {
int n;
std::cin >> n;
std::vector<std::array<int, 2>> inter(n);
std::vector<std::vector<int>> start(n + 1);
std::vector<int> greed(n + 1);
std::vector<int> who(n + 1);
for (int i = 0; i < n; ++i) {
std::cin >> inter[i][0] >> inter[i][1];
start[inter[i][0]].push_back(i);
}
std::set<std::pair<int, int>> by_end;
for (int i = 1; i <= n; ++i) {
for (int j : start[i]) {
by_end.emplace(inter[j][1], j);
}
greed[by_end.begin()->second] = i;
who[i] = by_end.begin()->second;
by_end.erase(by_end.begin());
}
Segtree t(n + 1);
for (int i = 1; i <= n; ++i) {
std::array<int, 2> interval = inter[who[i]];
if (t.Query(1, 0, n - 1, interval[0], i) >= i) {
std::cout << "NO\n";
print_vector(greed, 0, n - 1);
for (int j = interval[0]; j <= i; ++j) {
if (inter[who[j]][1] >= i) {
std::swap(greed[who[j]], greed[who[i]]);
print_vector(greed, 0, n - 1);
return;
}
}
assert(false);
}
t.Set(1, 0, n - 1, i, interval[1]);
}
std::cout << "YES\n";
print_vector(greed, 0, n - 1);
}
int main() {
srand(time(0));
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
Run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long P = 7340033;
const int arrn = 2e5 + 1;
template <typename T>
class segtree {
private:
int N;
T lambda(T a, T b) { return min(a, b); }
T rseg(int l, int r, int i, int lt, int rt) {
if (l == lt && r == rt)
return tree[i];
else {
int m = (lt + rt) >> 1;
if (m < r && m >= l)
return lambda(rseg(l, m, i << 1, lt, m),
rseg(m + 1, r, ((i << 1) | 1), m + 1, rt));
else if (r <= m)
return rseg(l, r, i << 1, lt, m);
else if (l > m)
return rseg(l, r, ((i << 1) | 1), m + 1, rt);
else
assert(false);
}
}
void upseg(int index, T val, int i, int l, int r) {
if (l == r)
tree[i] = val;
else {
int m = (l + r) >> 1;
if (index <= m)
upseg(index, val, i << 1, l, m);
else if (index > m)
upseg(index, val, ((i << 1) | 1), m + 1, r);
tree[i] = lambda(tree[i << 1], tree[((i << 1) | 1)]);
}
}
void preseg(int i, int l, int r, const vector<T> &in) {
if (l == r)
tree[i] = in[l];
else {
int m = (l + r) >> 1;
preseg(i << 1, l, m, in);
preseg(((i << 1) | 1), m + 1, r, in);
tree[i] = lambda(tree[i << 1], tree[((i << 1) | 1)]);
}
}
public:
vector<T> tree;
segtree(int siz) {
N = siz;
tree.resize(4 * N);
}
segtree(const vector<T> &in) {
N = in.size();
tree.resize(4 * N);
preseg(1, 0, N - 1, in);
}
T rng(int l, int r) { return rseg(l, r, 1, 0, N - 1); }
void upd(int ind, T val) { upseg(ind, val, 1, 0, N - 1); }
};
void solve() {
int n;
cin >> n;
vector<pair<pair<int, int>, int>> tem(n);
for (int i = 0; i < n; i++) {
cin >> tem[i].first.first >> tem[i].first.second;
tem[i].first.first--;
tem[i].first.second--;
tem[i].second = i;
}
sort(tem.begin(), tem.end());
vector<pair<int, int>> inter(n);
vector<int> aind(n);
for (int i = 0; i < n; i++) {
inter[i] = tem[i].first;
aind[i] = tem[i].second;
}
set<pair<pair<int, int>, int>> proc;
int ind = 0;
vector<int> lo(n, -1), hi(n, -1), ans1(n, -1), ans2;
for (int i = 0; i < n; i++) {
while (ind < n && inter[ind].first <= i) {
proc.insert(
make_pair(make_pair(inter[ind].second, inter[ind].first), aind[ind]));
ind++;
}
auto it = proc.begin();
assert(it->first.first >= i);
lo[i] = it->first.second;
hi[i] = it->first.first;
ans1[it->second] = i;
proc.erase(it);
}
segtree<pair<int, int>> tree(n);
for (int i = 0; i < n; i++) {
tree.upd(i, make_pair(lo[i], i));
}
ans2 = ans1;
bool chk = 0;
for (int i = 0; i < n; i++) {
int l = i + 1, r = hi[i];
if (l > r) continue;
auto tem = tree.rng(l, r);
if (tem.first <= i) {
int u = -1, v = -1;
for (int j = 0; j < n; j++) {
if (ans2[j] == i) u = j;
if (ans2[j] == tem.second) v = j;
}
swap(ans2[u], ans2[v]);
chk = 1;
break;
}
}
if (!chk) {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << ans1[i] + 1 << ' ';
return;
}
cout << "NO\n";
for (int i = 0; i < n; i++) cout << ans1[i] + 1 << ' ';
cout << '\n';
for (int i = 0; i < n; i++) cout << ans2[i] + 1 << ' ';
cout << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int T = 1;
for (int c = 0; c < T; c++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7, mod = 1e9 + 7;
int n, l[N], r[N], ans[N], nxt[N];
vector<pair<int, int> > p[N];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pr;
void print() {
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
p[l[i]].push_back(make_pair(r[i], i));
}
for (int i = 1; i <= n; i++) {
for (auto t : p[i]) {
pr.push(t);
}
int now = pr.top().second;
ans[now] = i;
pr.pop();
if (!pr.empty()) {
nxt[now] = pr.top().second;
}
}
for (int i = 1; i <= n; i++) {
if (nxt[i] == 0) continue;
int nx = nxt[i];
if (l[nx] <= ans[i] && r[nx] >= ans[i] && l[i] <= ans[nx] &&
r[i] >= ans[nx]) {
cout << "NO\n";
print();
swap(ans[i], ans[nx]);
print();
return 0;
}
}
cout << "YES\n";
print();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > vec[200005];
int pos[200005];
int ans1[200005], ans2[200005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a, b;
scanf("%d %d", &a, &b);
vec[a].push_back({b, i});
}
set<pair<int, int> > se;
for (int i = 1; i <= n; i++) {
for (pair<int, int> p : vec[i]) se.insert(p);
pos[i] = se.begin()->second;
se.erase(se.begin());
}
for (int i = 1; i <= n; i++) ans1[pos[i]] = i;
for (int i = 1; i <= n; i++) ans2[i] = ans1[i];
bool flag = true;
for (int i = 1; i <= n; i++) {
for (pair<int, int> p : vec[i]) se.insert(p);
if (se.size() == 1) {
se.erase(se.begin());
continue;
}
auto it = se.begin();
++it;
int j = it->second;
if (ans1[j] <= se.begin()->first) {
swap(ans2[pos[i]], ans2[j]);
flag = false;
break;
}
se.erase(se.begin());
}
printf("%s\n", flag ? "YES" : "NO");
for (int i = 1; i <= n; i++) printf("%d ", ans1[i]);
printf("\n");
if (!flag) {
for (int i = 1; i <= n; i++) printf("%d ", ans2[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
using namespace std;
const int mod = (int)1e9 + 7;
const int N = (int)2e5 + 123;
const long long inf = (long long)1e18 + 1;
const double pi = acos(-1.0);
const double eps = 1e-7;
const int dx[] = {0, 0, 1, 0, -1};
const int dy[] = {0, 1, 0, -1, 0};
int n, a[N], b[N], p[N], t[4 * N];
vector<int> add[N], del[N];
set<pair<int, int> > s;
void upd(int pos, int val, int v = 1, int tl = 1, int tr = n) {
if (tl == tr) {
if (val < 0)
t[v] = mod;
else
t[v] = val;
return;
}
int tm = tl + tr >> 1;
if (pos <= tm)
upd(pos, val, v + v, tl, tm);
else
upd(pos, val, v + v + 1, tm + 1, tr);
t[v] = min(t[v + v], t[v + v + 1]);
}
int get(int l, int r, int v = 1, int tl = 1, int tr = n) {
if (tl > r || tr < l) return mod;
if (l <= tl && tr <= r) return t[v];
int tm = tl + tr >> 1;
return min(get(l, r, v + v, tl, tm), get(l, r, v + v + 1, tm + 1, tr));
}
inline void boost() {
ios_base ::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
inline void Solve() {
cin >> n;
set<int> s;
for (int i = 1; i <= n; i++) s.insert(i);
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i], add[b[i]].push_back(i);
for (int i = 1; i <= n; i++) {
for (auto it : add[i]) {
p[it] = *s.lower_bound(a[it]);
s.erase(p[it]);
}
}
for (int i = 1; i <= n; i++) add[i].clear();
for (int i = 1; i < 4 * N; i++) t[i] = mod;
for (int i = 1; i <= n; i++) {
add[a[i]].push_back(i);
del[b[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
for (auto it : add[i]) upd(p[it], a[it]);
for (auto it : del[i]) {
if (get(p[it] + 1, b[it]) <= p[it]) {
int x = it, y = -1;
for (int j = 1; j <= n; j++) {
if (x == j) continue;
if (p[x] < p[j] && p[j] <= b[it] && a[j] <= p[it]) {
y = j;
break;
}
}
if (y == -1) cout << 1 / 0, exit(0);
cout << "NO\n";
for (int z = 1; z <= n; z++) cout << p[z] << ' ';
cout << '\n';
swap(p[x], p[y]);
for (int z = 1; z <= n; z++) cout << p[z] << ' ';
exit(0);
}
}
for (auto it : del[i]) upd(p[it], -a[it]);
}
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << p[i] << ' ';
}
signed main() {
int tt = 1;
while (tt--) {
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2, class T3 = hash<T1>>
using umap = unordered_map<T1, T2, T3>;
template <class T>
using uset = unordered_set<T>;
template <class T>
using vec = vector<T>;
const long long infll = numeric_limits<long long>::max() >> 1;
const int inf = numeric_limits<int>::max() >> 1;
const int N = 4e5 + 5;
const int M = 2e5 + 1;
int n;
int pos[N];
int ind[N];
pair<int, int> p[N];
vec<pair<int, int>> upd[N];
set<pair<int, int>> opt;
set<int> ins;
bool vis[N];
bool stk[N];
vec<int> cycle;
vec<int> st;
struct Dsu {
int par[N];
int cnt[N];
int nxt[N];
} dsu;
bool dfs(int);
bool visit(int, int);
int root(int u) { return dsu.par[u] == u ? u : dsu.par[u] = root(dsu.par[u]); }
void unite(int u, int v) {
u = root(u);
v = root(v);
if (dsu.cnt[u] < dsu.cnt[v]) {
swap(u, v);
}
dsu.nxt[u] = max(dsu.nxt[u], dsu.nxt[v]);
dsu.cnt[u] += dsu.cnt[v];
dsu.par[v] = u;
}
void input() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> p[i].first;
cin >> p[i].second;
upd[p[i].first].push_back({p[i].second, i});
}
}
void construct_matching() {
for (int i = 1; i <= n; ++i) {
for (pair<int, int> p : upd[i]) {
opt.insert(p);
}
ind[opt.begin()->second] = i;
pos[i] = opt.begin()->second;
opt.erase(opt.begin());
}
}
bool visit(int l, int r, int p) {
int x = *ins.lower_bound(l);
if (x == p) {
x = *ins.upper_bound(p);
}
if (x <= r) {
while (st.back() != x) {
cycle.push_back(st.back());
st.pop_back();
}
cycle.push_back(st.back());
st.pop_back();
return 1;
}
for (int i = dsu.nxt[root(l)]; i <= r; i = dsu.nxt[root(i + 1)]) {
if (i == p) {
continue;
}
unite(i, i + 1);
if (dfs(i)) {
return 1;
}
}
return 0;
}
bool dfs(int u) {
st.push_back(u);
ins.insert(u);
vis[u] = 1;
stk[u] = 1;
if (u <= n) {
if (visit(p[u].first + n, p[u].second + n, ind[u] + n)) {
return 1;
}
} else {
if (visit(pos[u - n], pos[u - n], 0)) {
return 1;
}
}
stk[u] = 0;
st.pop_back();
ins.erase(u);
return 0;
}
void answer() {
cout << "NO\n";
for (int i = 1; i <= n; ++i) {
cout << ind[i] << " ";
}
cout << "\n";
for (int i = 0; i < (int)cycle.size(); ++i) {
if (cycle[i] <= n) {
ind[cycle[i]] =
cycle[(i - 1 + (int)cycle.size()) % (int)cycle.size()] - n;
}
}
for (int i = 1; i <= n; ++i) {
cout << ind[i] << " ";
}
cout << "\n";
}
void solve() {
ins.insert(inf);
construct_matching();
for (int i = 1; i <= 2 * n + 1; ++i) {
dsu.cnt[i] = 1;
dsu.par[i] = i;
dsu.nxt[i] = i;
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
if (dfs(i)) {
answer();
return;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; ++i) {
cout << ind[i] << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
input();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p);
template <class T>
ostream &operator<<(ostream &os, vector<T> &v);
template <class T>
ostream &operator<<(ostream &os, set<T> &v);
template <class T1, class T2>
ostream &operator<<(ostream &os, map<T1, T2> &v);
const long long mod = 1e9 + 7;
const int N = 2e5 + 5;
void Print(vector<int> &v) {
for (int i = 0; i < v.size(); i++) {
printf("%d ", v[i]);
}
printf("\n");
}
bool check(pair<int, int> a, pair<int, int> b, int ans1, int ans2) {
return ans1 >= b.first && ans1 <= b.second && ans2 >= a.first &&
ans2 <= a.second;
}
vector<int> ans;
bool comp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
return ans[a.second] < ans[b.second];
}
void TEST_CASES(int cas) {
int n;
scanf("%d", &n);
ans.resize(n);
vector<pair<pair<int, int>, int> > v(n);
vector<multiset<pair<int, int> > > st(n + 1);
for (int i = 0; i < n; i++) {
scanf("%d %d", &v[i].first.first, &v[i].first.second);
v[i].second = i;
st[v[i].first.first].insert({v[i].first.second, v[i].second});
}
priority_queue<pair<int, int> > pq;
for (int i = 1; i <= n; i++) {
for (auto it : st[i]) {
pq.push({-it.first, it.second});
}
pair<int, int> p = pq.top();
pq.pop();
ans[p.second] = i;
}
sort(v.begin(), v.end(), comp);
for (int i = 0; i < n - 1; i++) {
if (check(v[i].first, v[i + 1].first, ans[v[i].second],
ans[v[i + 1].second])) {
printf("NO\n");
Print(ans);
swap(ans[v[i].second], ans[v[i + 1].second]);
Print(ans);
return;
}
}
if (0 != n - 1 && check(v[0].first, v[n - 1].first, ans[v[0].second],
ans[v[n - 1].second])) {
printf("NO\n");
Print(ans);
swap(ans[v[0].second], ans[v[n - 1].second]);
Print(ans);
return;
}
sort(v.begin(), v.end());
for (int i = 0; i < n - 1; i++) {
if (check(v[i].first, v[i + 1].first, ans[v[i].second],
ans[v[i + 1].second])) {
printf("NO\n");
Print(ans);
swap(ans[v[i].second], ans[v[i + 1].second]);
Print(ans);
return;
}
}
printf("YES\n");
Print(ans);
}
int main() {
int t = 1, cas = 0;
while (t--) {
TEST_CASES(++cas);
}
return 0;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << "{" << p.first << ", " << p.second << "} ";
return os;
}
template <class T>
ostream &operator<<(ostream &os, vector<T> &v) {
os << "[ ";
for (int i = 0; i < v.size(); i++) {
os << v[i] << " ";
}
os << " ]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, set<T> &v) {
os << "[ ";
for (T i : v) {
os << i << " ";
}
os << " ]";
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, map<T1, T2> &v) {
for (auto i : v) {
os << "Key : " << i.first << " , Value : " << i.second << endl;
}
return os;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 2e5 + 100;
int n, m, k;
vector<int> g[2 * NMAX];
int used[2 * NMAX];
int l[2 * NMAX];
void bfs() {
queue<int> q;
for (int i = 0; i < m + n; i++) l[i] = -1;
for (int i = 0; i < n; i++)
if (used[i] == -1) q.push(i), l[i] = 0;
k = 1e9;
while (!q.empty()) {
int v = q.front();
if (l[v] >= k) return;
if (l[v] % 2 == 0) {
for (int i : g[v])
if (l[i] == -1) {
q.push(i);
l[i] = l[v] + 1;
if (used[i] == -1) k = l[i];
}
} else if (l[used[v]] == -1) {
if (used[v] == -1) cout << "WARNING\n";
l[used[v]] = l[v] + 1;
q.push(used[v]);
}
q.pop();
}
}
bool dfs(int v) {
if (v == -1) return true;
for (int to : g[v])
if ((used[to] == -1) or (l[used[to]] == l[v] - 2))
if (dfs(used[to])) {
used[to] = v;
used[v] = to;
return true;
}
l[v] = -1;
return false;
}
void SARA() {
for (int i = 0; i < n + m; i++) used[i] = -1;
while (true) {
bfs();
if (k == 1e9) break;
for (int i = 0; i < m + n; i++)
if ((l[i] == k) and (used[i] == -1)) dfs(i);
}
}
void add_edge(int i, int j) {
g[i - 1].push_back(n + j - 1);
g[n + j - 1].push_back(i - 1);
}
int N;
int lt[NMAX];
int rt[NMAX];
set<vector<int> > answers;
void add(vector<int> ans) {
answers.insert(ans);
if (answers.size() > 1) {
cout << "NO\n";
for (auto it = answers.begin(); it != answers.end(); it++, cout << "\n")
for (int i : *it) cout << i << " ";
exit(0);
}
}
void try_() {
for (int i = 0; i < 2 * N; i++) g[i].clear();
vector<int> pr;
for (int i = 1; i <= n; i++) pr.push_back(i);
random_shuffle(pr.begin(), pr.end());
vector<int> bck(n);
for (int i = 0; i < n; i++) bck[pr[i] - 1] = i + 1;
for (int i = 1; i <= N; i++) {
if (rt[i] - lt[i] < 6)
for (int j = lt[i]; j <= rt[i]; j++) add_edge(pr[i - 1], pr[j - 1]);
else {
set<int> st;
while (st.size() < 5) st.insert(rand() % (rt[i] - lt[i] + 1) + lt[i]);
for (int j : st) add_edge(pr[i - 1], pr[j - 1]);
}
}
SARA();
int q = 0;
for (int i = 0; i < n; i++)
if (used[i] != -1) q++;
if (q < n) return;
vector<int> ans(n);
for (int i = 0; i < n; i++) ans[i] = bck[used[pr[i] - 1] - n];
add(ans);
}
void gridi() {
vector<int> ans(n);
set<pair<pair<int, int>, int> > st;
set<pair<int, int> > bef;
for (int i = 1; i <= n; i++) st.insert({{lt[i], rt[i]}, i - 1});
for (int i = 1; i <= n; i++) {
while ((st.size() > 0) and ((*st.begin()).first.first <= i)) {
bef.insert({(*st.begin()).first.second, (*st.begin()).second});
st.erase(st.begin());
}
if (bef.size() == 0) return;
ans[(*bef.begin()).second] = i;
bef.erase(bef.begin());
}
add(ans);
}
void gridi2() {
for (int i = 1; i <= n; i++)
lt[i] = n + 1 - lt[i], rt[i] = n + 1 - rt[i], swap(lt[i], rt[i]);
vector<int> ans(n);
set<pair<pair<int, int>, int> > st;
set<pair<int, int> > bef;
for (int i = 1; i <= n; i++) st.insert({{lt[i], rt[i]}, i - 1});
for (int i = 1; i <= n; i++) {
while ((st.size() > 0) and ((*st.begin()).first.first <= i)) {
bef.insert({(*st.begin()).first.second, (*st.begin()).second});
st.erase(st.begin());
}
if (bef.size() == 0) {
for (int i = 1; i <= n; i++)
lt[i] = n + 1 - lt[i], rt[i] = n + 1 - rt[i], swap(lt[i], rt[i]);
return;
}
ans[(*bef.begin()).second] = i;
bef.erase(bef.begin());
}
for (int i = 1; i <= n; i++)
lt[i] = n + 1 - lt[i], rt[i] = n + 1 - rt[i], swap(lt[i], rt[i]);
for (int& i : ans) i = n + 1 - i;
add(ans);
}
void gridi3() {
vector<int> ans(n);
set<pair<pair<int, int>, int> > st;
set<pair<int, int> > bef;
for (int i = 1; i <= n; i++) st.insert({{lt[i], rt[i]}, -i + 1});
for (int i = 1; i <= n; i++) {
while ((st.size() > 0) and ((*st.begin()).first.first <= i)) {
bef.insert({(*st.begin()).first.second, (*st.begin()).second});
st.erase(st.begin());
}
if (bef.size() == 0) return;
ans[-(*bef.begin()).second] = i;
bef.erase(bef.begin());
}
add(ans);
}
void gridi4() {
for (int i = 1; i <= n; i++)
lt[i] = n + 1 - lt[i], rt[i] = n + 1 - rt[i], swap(lt[i], rt[i]);
vector<int> ans(n);
set<pair<pair<int, int>, int> > st;
set<pair<int, int> > bef;
for (int i = 1; i <= n; i++) st.insert({{lt[i], rt[i]}, -i + 1});
for (int i = 1; i <= n; i++) {
while ((st.size() > 0) and ((*st.begin()).first.first <= i)) {
bef.insert({(*st.begin()).first.second, (*st.begin()).second});
st.erase(st.begin());
}
if (bef.size() == 0) {
for (int i = 1; i <= n; i++)
lt[i] = n + 1 - lt[i], rt[i] = n + 1 - rt[i], swap(lt[i], rt[i]);
return;
}
ans[-(*bef.begin()).second] = i;
bef.erase(bef.begin());
}
for (int i = 1; i <= n; i++)
lt[i] = n + 1 - lt[i], rt[i] = n + 1 - rt[i], swap(lt[i], rt[i]);
for (int& i : ans) i = n + 1 - i;
add(ans);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
cin >> N;
for (int i = 1; i <= N; i++) cin >> lt[i] >> rt[i];
n = m = N;
gridi();
gridi2();
gridi3();
gridi4();
while (clock() * 1.0 / CLOCKS_PER_SEC < 0.5) try_();
cout << "YES\n";
if (answers.empty()) cout << 1 / 0;
for (int i : (*answers.begin())) cout << i << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200009;
const long long MOD = 119 << 23 | 1;
class {
public:
vector<pair<int, int> > V[maxn];
int a[maxn], b[maxn];
int ans[maxn];
int n;
void solve() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i] >> b[i];
V[a[i]].emplace_back(b[i], i);
}
priority_queue<pair<int, int> > que;
for (int i = 1; i <= n; ++i) {
for (auto j : V[i]) {
que.emplace(-j.first, j.second);
}
ans[i] = que.top().second;
que.pop();
}
build(1, 1, n);
for (int i = 1; i <= n; ++i) {
if (a[ans[i]] == i) continue;
int res = query(1, 1, n, a[ans[i]], i - 1);
if (res >= i) {
cout << "NO\n";
out();
for (int j = a[ans[i]]; j <= i - 1; ++j) {
if (b[ans[j]] >= i) {
swap(ans[j], ans[i]);
break;
}
}
out();
return;
}
}
cout << "YES\n";
out();
}
int c[maxn];
void out() {
for (int i = 1; i <= n; ++i) {
c[ans[i]] = i;
}
for (int i = 1; i <= n; ++i) cout << c[i] << " ";
cout << '\n';
}
int Max[maxn << 2];
void build(int rt, int l, int r) {
if (l == r) {
Max[rt] = b[ans[l]];
return;
}
int mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
Max[rt] = max(Max[rt << 1], Max[rt << 1 | 1]);
}
int query(int rt, int l, int r, int ll, int rr) {
if (ll <= l && rr >= r) return Max[rt];
int mid = l + r >> 1;
int res = 0;
if (ll <= mid) res = max(res, query(rt << 1, l, mid, ll, rr));
if (rr > mid) res = max(res, query(rt << 1 | 1, mid + 1, r, ll, rr));
return res;
}
} NSPACE;
int main() {
;
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
NSPACE.solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int pos[(int)(1e6 + 10)], L[(int)(1e6 + 10)], R[(int)(1e6 + 10)],
ans[(int)(1e6 + 10)];
struct nod {
int l, r, id;
} a[(int)(1e6 + 10)];
struct tnod {
int val, id;
} c[(int)(1e6 + 10)];
int cmp(nod x, nod y) {
if (x.l == y.l) {
if (x.r == y.r) return x.id < y.id;
return x.r < y.r;
}
return x.l < y.l;
}
set<pair<int, int> > st;
void build(int rt, int l, int r) {
if (l == r) {
c[rt].val = L[pos[l]];
c[rt].id = l;
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
tnod ls = c[rt << 1], rs = c[rt << 1 | 1];
tnod minn = ls.val < rs.val ? ls : rs;
c[rt] = minn;
}
pair<int, int> query(int rt, int l, int r, int ql, int qr) {
if (qr < l || ql > r) return make_pair(0x7f7f7f7f, -2);
if (qr >= r && ql <= l) return make_pair(c[rt].val, c[rt].id);
int mid = (l + r) >> 1;
pair<int, int> ls = query(rt << 1, l, mid, ql, qr);
pair<int, int> rs = query(rt << 1 | 1, mid + 1, r, ql, qr);
return ls.first < rs.first ? ls : rs;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].l, &a[i].r);
a[i].id = i, L[i] = a[i].l, R[i] = a[i].r;
}
sort(a + 1, a + 1 + n, cmp);
int p = 1;
for (int i = 1; i <= n; i++) {
while (p <= n && a[p].l <= i) {
st.insert(make_pair(a[p].r, a[p].id));
p++;
}
pos[i] = st.begin()->second;
st.erase(st.begin());
}
for (int i = 1; i <= n; i++) ans[pos[i]] = i;
build(1, 1, n);
int flag = 0, u, v;
for (int i = 1; i <= n; i++) {
if (i + 1 > R[pos[i]]) continue;
pair<int, int> temp = query(1, 1, n, i + 1, R[pos[i]]);
if (temp.first <= i) {
flag = 1;
u = pos[temp.second], v = pos[i];
break;
}
}
if (!flag) {
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
} else {
printf("NO\n");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
swap(ans[u], ans[v]);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
struct AAAA {
int n, cnt[MAXN];
struct seg {
struct node {
int sum, maxv, maxfrm;
} tree[530000];
int lim;
void init(int n) {
for (lim = 1; lim <= n; lim <<= 1)
;
}
node merge(node a, node b) {
node ret;
ret.sum = a.sum + b.sum;
if (a.maxv >= a.sum + b.maxv) {
ret.maxv = a.maxv;
ret.maxfrm = a.maxfrm;
} else {
ret.maxv = a.sum + b.maxv;
ret.maxfrm = b.maxfrm;
}
return ret;
}
void set(int x, int v) {
x += lim;
tree[x] = {v, max(v, 0), x - lim};
while (x > 1) {
x >>= 1;
tree[x] = merge(tree[2 * x], tree[2 * x + 1]);
}
}
node query() { return tree[1]; }
} seg;
struct intv {
int s, e, v;
bool operator<(const intv &i) const {
return pair<int, int>(e, v) < pair<int, int>(i.e, i.v);
}
} a[MAXN];
struct rmq {
pair<int, int> tree[530000];
int lim;
void init(int n) {
for (lim = 1; lim <= n; lim <<= 1)
;
fill(tree, tree + 530000, pair<int, int>(1e9, 1e9));
}
void add(int x, pair<int, int> v) {
x += lim;
tree[x] = v;
while (x > 1) {
x >>= 1;
tree[x] = min(tree[2 * x], tree[2 * x + 1]);
}
}
pair<int, int> query(int s, int e) {
s += lim;
e += lim;
pair<int, int> ret(1e9, 1e9);
while (s < e) {
if (s % 2 == 1) ret = min(ret, tree[s++]);
if (e % 2 == 0) ret = min(ret, tree[e--]);
s >>= 1;
e >>= 1;
}
if (s == e) ret = min(ret, tree[s]);
return ret;
}
} rmq;
vector<intv> st[MAXN];
pair<int, int> orv[MAXN];
vector<int> orz(vector<int> v) {
n = v.size() / 2;
for (int i = 1; i <= n; i++) {
a[i].s = v[2 * i - 2];
a[i].e = v[2 * i - 1];
orv[i] = pair<int, int>(a[i].s, a[i].e);
a[i].v = i;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
st[a[i].s].push_back(a[i]);
cnt[i]--;
cnt[a[i].e]++;
}
seg.init(n);
rmq.init(n);
for (int i = 1; i <= n; i++) seg.set(i, cnt[i]);
vector<int> ans;
for (int i = 1; i <= n; i++) {
int lst = i;
cnt[i]++;
seg.set(i, cnt[i]);
if (seg.query().maxv > 0)
lst = seg.query().maxfrm;
else
lst = n;
for (auto &j : st[i]) {
auto it = lower_bound(a + 1, a + n + 1, j) - a;
rmq.add(it, pair<int, int>(j.v, it));
}
int l = lower_bound(a + 1, a + n + 1, (intv){-1, lst, 2222222}) - a;
auto k = rmq.query(1, l - 1);
int ev = orv[k.first].second;
rmq.add(k.second, pair<int, int>(1e9, 1e9));
cnt[ev]--;
seg.set(ev, cnt[ev]);
ans.push_back(k.first);
}
return ans;
}
} F, G;
int n;
pair<int, int> a[MAXN];
int f[MAXN];
vector<int> rev(vector<int> v) {
for (int i = 0; i < v.size(); i++) f[v[i]] = i + 1;
return vector<int>(f + 1, f + n + 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d %d", &a[i].first, &a[i].second);
vector<int> sexF, sexG;
for (int i = 1; i <= n; i++) {
sexF.push_back(a[i].first);
sexF.push_back(a[i].second);
sexG.push_back(a[n + 1 - i].first);
sexG.push_back(a[n + 1 - i].second);
}
auto X = F.orz(sexF);
auto Y = G.orz(sexG);
for (auto &i : Y) i = n + 1 - i;
X = rev(X);
Y = rev(Y);
if (X == Y) {
puts("YES");
for (auto &i : X) printf("%d ", i);
} else {
puts("NO");
for (auto &i : X) printf("%d ", i);
puts("");
for (auto &i : Y) printf("%d ", i);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int N, a[200010], b[200010], ans[200010], pos[200010];
vector<pair<int, int> > d[200010];
int base;
pair<int, int> tree[1 << 19];
void init() {
for (base = 1; base < N; base <<= 1)
;
for (int i = 0; i < (1 << 19); i++) tree[i] = {inf, inf};
for (int i = 1; i <= N; i++) tree[base + i - 1] = {a[pos[i]], pos[i]};
for (int i = base - 1; i; i--) tree[i] = min(tree[i << 1], tree[i << 1 | 1]);
}
pair<int, int> query(int l, int r) {
l += base - 1;
r += base - 1;
pair<int, int> ret = {inf, inf};
while (l <= r) {
if (l & 1) ret = min(ret, tree[l]);
if (~r & 1) ret = min(ret, tree[r]);
l = (l + 1) >> 1;
r = (r - 1) >> 1;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> a[i] >> b[i];
d[a[i]].push_back({b[i], i});
}
set<pair<int, int> > curr;
for (int i = 1; i <= N; i++) {
for (auto j : d[i]) curr.insert(j);
pair<int, int> x = *curr.begin();
curr.erase(curr.begin());
ans[x.second] = i;
pos[i] = x.second;
}
init();
for (int i = 1; i <= N; i++) {
pair<int, int> x = query(i + 1, b[pos[i]]);
if (x.first <= i) {
cout << "NO" << '\n';
for (int i = 1; i <= N; i++) cout << ans[i] << ' ';
cout << '\n';
swap(ans[pos[i]], ans[x.second]);
for (int i = 1; i <= N; i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
}
cout << "YES" << '\n';
for (int i = 1; i <= N; i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int it[800005];
int a[200005], b[200005];
int at[200005];
int pos[200005];
vector<pair<pair<int, int>, int> > ax;
void update(int id, int l, int r, int pos, int val) {
if (l == r) {
it[id] = val;
return;
}
int mid = (l + r) / 2;
if (pos > mid) {
update(id * 2 + 1, mid + 1, r, pos, val);
} else {
update(id * 2, l, mid, pos, val);
}
it[id] = min(it[id * 2], it[id * 2 + 1]);
}
int get(int id, int l, int r, int u, int v) {
if (l > v || r < u) {
return 1000000000;
}
if (u <= l && v >= r) {
return it[id];
}
int mid = (l + r) / 2;
return min(get(id * 2, l, mid, u, v), get(id * 2 + 1, mid + 1, r, u, v));
}
void build_tree(int id, int l, int r) {
if (l == r) {
it[id] = l;
return;
}
int mid = (l + r) / 2;
build_tree(id * 2, l, mid);
build_tree(id * 2 + 1, mid + 1, r);
it[id] = min(it[id * 2], it[id * 2 + 1]);
}
signed main() {
cin >> n;
build_tree(1, 1, n);
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
ax.push_back({{b[i], a[i]}, i});
}
sort(ax.begin(), ax.end());
for (auto i : ax) {
int ok = get(1, 1, n, i.first.second, i.first.first);
at[ok] = i.second;
pos[i.second] = ok;
update(1, 1, n, ok, 100000000);
}
memset(it, 0, sizeof(it));
for (int i = 1; i <= n; i++) {
update(1, 1, n, i, -b[at[i]]);
}
for (int i = 1; i <= n; i++) {
if (a[at[i]] == i) continue;
int ok = get(1, 1, n, a[at[i]], i - 1);
if (abs(ok) >= i) {
for (int j = a[at[i]]; j < i; j++) {
if (b[at[j]] >= i) {
cout << "NO\n";
for (int k = 1; k <= n; k++) {
cout << pos[k] << " ";
}
cout << endl;
swap(pos[at[i]], pos[at[j]]);
for (int k = 1; k <= n; k++) {
cout << pos[k] << " ";
}
return 0;
}
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++) {
cout << pos[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool inotr(long long l, long long x, long long r) {
return (x >= l) && (x < r);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
pair<long long, long long> a[n];
vector<pair<long long, long long> > b[n];
for (long long i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
a[i].first--;
b[a[i].first].push_back({a[i].second, i});
}
long long ans[n];
long long u[n];
set<pair<long long, pair<long long, long long> > > v;
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < b[i].size(); ++j) {
pair<long long, long long> curr = b[i][j];
v.insert({curr.first, {i, curr.second}});
}
pair<long long, pair<long long, long long> > h = (*v.begin());
v.erase(h);
ans[i] = h.second.second;
}
for (long long i = 0; i < n; ++i) {
u[ans[i]] = i;
}
for (long long i = 0; i < (n - 1); ++i) {
if (inotr(a[ans[i]].first, i + 1, a[ans[i]].second) &&
inotr(a[ans[i + 1]].first, i, a[ans[i + 1]].second)) {
cout << "NO" << endl;
for (long long i = 0; i < n; ++i) {
cout << u[i] + 1 << " ";
}
cout << endl;
swap(ans[i], ans[i + 1]);
for (long long i = 0; i < n; ++i) {
u[ans[i]] = i;
}
for (long long i = 0; i < n; ++i) {
cout << u[i] + 1 << " ";
}
return 0;
}
}
for (long long i = 0; i < n; ++i) {
sort(b[i].begin(), b[i].end());
if (b[i].size() >= 2) {
long long x = u[b[i][1].second];
if (x < b[i][0].first) {
cout << "NO" << endl;
for (long long i = 0; i < n; ++i) {
cout << u[i] + 1 << " ";
}
cout << endl;
swap(ans[x], ans[b[i][0].second]);
for (long long i = 0; i < n; ++i) {
u[ans[i]] = i;
}
for (long long i = 0; i < n; ++i) {
cout << u[i] + 1 << " ";
}
return 0;
}
}
}
cout << "YES" << endl;
for (long long i = 0; i < n; ++i) {
cout << u[i] + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, res[200500], st1[200500][20], st2[200500][20];
int l2(int n) {
int r = 0;
while (n - 1) {
r++;
n >>= 1;
}
return r;
}
int chk1(int l, int r) {
int k = l2(r - l + 1);
return max(st1[l][k], st1[r - (1 << k) + 1][k]);
}
int chk2(int l, int r) {
int k = l2(r - l + 1);
return min(st2[l][k], st2[r - (1 << k) + 1][k]);
}
struct sb {
int id, l, r;
bool operator<(const sb x) const { return r > x.r; }
} tmp, s[200500];
vector<sb> v[200500];
priority_queue<sb> q;
void ans() {
for (int i = 1; i <= n; i++) {
printf("%d ", res[i]);
}
puts("");
}
int main() {
memset(st2, 0x3f, sizeof(st2));
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &j, &k);
s[i].id = i;
s[i].l = j;
s[i].r = k;
v[j].push_back(s[i]);
}
for (i = 1; i <= n; i++) {
for (auto j : v[i]) {
q.push(j);
}
s[i] = q.top();
q.pop();
res[s[i].id] = i;
st1[i][0] = s[i].r;
st2[i][0] = s[i].l;
}
for (j = 1; j <= 18; j++) {
for (i = 1; i + (1 << j) - 1 <= n; i++) {
st1[i][j] = max(st1[i][j - 1], st1[i + (1 << (j - 1))][j - 1]);
st2[i][j] = min(st2[i][j - 1], st2[i + (1 << (j - 1))][j - 1]);
}
}
for (i = 1; i <= n; i++) {
if (s[i].l < i && chk1(s[i].l, i - 1) >= i) {
puts("NO");
ans();
for (j = i - 1;; j--) {
if (s[j].r >= i) {
swap(res[s[i].id], res[s[j].id]);
break;
}
}
ans();
return 0;
}
if (s[i].r > i && chk2(i + 1, s[i].r) <= i) {
puts("NO");
ans();
for (j = i + 1;; j++) {
if (s[j].l <= i) {
swap(res[s[i].id], res[s[j].id]);
break;
}
}
ans();
return 0;
}
}
puts("YES");
ans();
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 __MT(chrono::system_clock::now().time_since_epoch().count());
const int maxn = 200000 + 10;
pair<int, int> itvl[maxn];
int n;
int id[maxn];
int ans[maxn];
int inv[maxn];
struct segtree {
int maxv[maxn << 2];
int maxid[maxn << 2];
int n, ql, qr, idx, rm;
void init(int n) {
this->n = n;
build(1, n, 1);
}
void maintain(int l, int r, int o) {
if (l != r) {
maxv[o] = max(maxv[o << 1], maxv[o << 1 | 1]);
if (maxv[o << 1] == maxv[o]) maxid[o] = maxid[o << 1];
if (maxv[o << 1 | 1] == maxv[o]) maxid[o] = maxid[o << 1 | 1];
}
}
void build(int l, int r, int o) {
if (l == r) {
maxv[o] = itvl[inv[l]].second;
maxid[o] = l;
return;
}
int mid = l + r >> 1;
build(l, mid, o << 1), build(mid + 1, r, o << 1 | 1);
maintain(l, r, o);
}
void update(int o) {
if (rm < maxv[o]) {
rm = maxv[o];
idx = maxid[o];
}
}
void query(int l, int r, int o) {
if (ql <= l && qr >= r)
update(o);
else {
int mid = l + r >> 1;
if (ql <= mid) query(l, mid, o << 1);
if (qr > mid) query(mid + 1, r, o << 1 | 1);
}
}
pair<int, int> Query(int l, int r) {
rm = -1;
idx = -1;
ql = l, qr = r;
query(1, n, 1);
return (pair<int, int>){rm, idx};
}
};
segtree tree;
inline void solve() {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
int p = 1;
for (auto i = (1); i <= (n); ++i) {
if (p <= n && itvl[id[p]].first == i)
q.push({itvl[id[p]].second, id[p]}), ++p;
while (p <= n && itvl[id[p]].first == itvl[id[p - 1]].first) {
q.push({itvl[id[p]].second, id[p]});
++p;
}
auto e = q.top();
q.pop();
ans[e.second] = i;
}
for (auto i = (1); i <= (n); ++i) inv[ans[i]] = i;
tree.init(n);
pair<int, int> swp;
int amb = 0;
swp.first = swp.second = -1;
for (auto i = (2); i <= (n); ++i) {
int j = inv[i];
assert(itvl[j].first <= i);
auto e = tree.Query(itvl[j].first, i - 1);
if (e.first >= i) {
swp.first = i;
swp.second = e.second;
amb = 1;
break;
}
}
if (!amb) {
puts("YES");
} else {
puts("NO");
}
for (auto i = (1); i <= (n); ++i) printf("%d ", ans[i]);
puts("");
if (amb) {
swap(ans[inv[swp.first]], ans[inv[swp.second]]);
for (auto i = (1); i <= (n); ++i) printf("%d ", ans[i]);
puts("");
}
}
int main(void) {
scanf("%d", &(n));
for (auto i = (1); i <= (n); ++i)
scanf("%d%d", &itvl[i].first, &itvl[i].second), id[i] = i;
sort(id + 1, id + 1 + n,
[](const int& a, const int& b) { return itvl[a] < itvl[b]; });
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5;
const int TSIZE = 1 << 19;
int T[TSIZE];
int tget(int x, int l, int r, int L, int R) {
int m = min(r, R);
int M = max(l, L);
if (M <= m) {
if (M == L && m == R) {
return T[x];
}
int mid = (L + R + 1) / 2;
return max(tget(2 * x + 1, l, r, L, mid - 1),
tget(2 * x + 2, l, r, mid, R));
}
return 0;
}
int tget(int l, int r) { return tget(0, l, r, 0, TSIZE / 2 - 1); }
void tset(int x, int v, int p, int L, int R) {
if (L == R) {
T[x] = v;
return;
}
int mid = (L + R + 1) / 2;
if (p < mid)
tset(2 * x + 1, v, p, L, mid - 1);
else
tset(2 * x + 2, v, p, mid, R);
T[x] = max(T[2 * x + 1], T[2 * x + 2]);
}
void tset(int p, int v) { tset(0, v, p, 0, TSIZE / 2 - 1); }
int A[MAXN][2];
int B[MAXN];
int BI[MAXN];
int idx[MAXN];
struct ev {
int x, t;
bool operator<(const ev &p) const {
if (x != p.x) return x < p.x;
return t < p.t;
}
};
ev E[MAXN * 2];
bool cmp(int a, int b) {
if (A[a][1] != A[b][1]) return A[a][1] < A[b][1];
return A[a][0] < A[b][0];
}
void solve() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d%d", &A[i][0], &A[i][1]);
for (int i = 0; i < n; ++i) idx[i] = i;
sort(idx, idx + n, cmp);
set<int> have;
for (int i = 1; i <= n; ++i) have.insert(i);
int vi = -1, vj = -1;
for (int i = 0; i < n; ++i) {
int x = idx[i];
set<int>::iterator f = have.lower_bound(A[x][0]);
int v = *f;
have.erase(f);
B[x] = v;
if (vi == -1) {
int m = tget(A[x][0], v);
if (m >= v) {
vi = v;
for (int i = A[x][0]; i <= v; ++i) {
if (tget(i, i) >= v) {
vj = i;
break;
}
}
}
}
tset(v, A[x][1]);
}
for (int i = 0; i < n; ++i) {
BI[B[i] - 1] = i;
}
for (int i = 0; i < n; ++i) {
E[2 * i].t = (i + 1);
E[2 * i].x = A[i][0];
E[2 * i + 1].t = -(i + 1);
E[2 * i + 1].x = A[i][1] + 1;
}
sort(E, E + 2 * n);
printf((vi == -1 ? "YES\n" : "NO\n"));
for (int i = 0; i < n; ++i) printf("%d ", B[i]);
printf("\n");
if (vi != -1) {
int i = BI[vi - 1];
int j = BI[vj - 1];
swap(B[i], B[j]);
for (int i = 0; i < n; ++i) printf("%d ", B[i]);
printf("\n");
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 5;
int n, m, k;
int a[maxn], p[maxn], x[maxn], y[maxn];
int tmp, cnt;
int flag;
int ans[maxn];
vector<pair<int, int> > vc[maxn];
struct node {
int id, val;
} c[maxn << 1];
template <typename T>
inline void read(T &X) {
X = 0;
int w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
if (w) X = -X;
}
void build(int rt, int l, int r) {
if (l == r) {
c[rt].id = p[l];
c[rt].val = x[p[l]];
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
if (c[rt << 1].val < c[rt << 1 | 1].val)
c[rt] = c[rt << 1];
else
c[rt] = c[rt << 1 | 1];
}
pair<int, int> query(int rt, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
return make_pair(c[rt].val, c[rt].id);
}
int mid = (l + r) >> 1;
pair<int, int> tmp1, tmp2;
tmp1.first = -1;
tmp2.first = -1;
if (ql <= mid) tmp1 = query(rt << 1, l, mid, ql, qr);
if (qr > mid) tmp2 = query(rt << 1 | 1, mid + 1, r, ql, qr);
if (tmp1.first == -1) return tmp2;
if (tmp2.first == -1) return tmp1;
if (tmp1.first > tmp2.first) return tmp2;
return tmp1;
}
void prt() {
for (register int i = (1); i <= (n); i++)
printf("%d%c", ans[i], i == n ? '\n' : ' ');
}
int main() {
read(n);
for (register int i = (1); i <= (n); i++) {
int l, r;
read(l);
read(r);
x[i] = l;
y[i] = r;
vc[l].push_back(make_pair(r, i));
}
set<pair<int, int> > st;
for (register int i = (1); i <= (n); i++) {
st.insert(vc[i].begin(), vc[i].end());
int y = (*st.begin()).second;
st.erase(st.begin());
ans[y] = i;
p[i] = y;
}
build(1, 1, n);
for (register int i = (1); i <= (n); i++) {
if (i + 1 > y[p[i]]) continue;
pair<int, int> k = query(1, 1, n, i + 1, y[p[i]]);
if (k.first <= i) {
puts("NO");
prt();
swap(ans[p[i]], ans[k.second]);
prt();
return 0;
}
}
puts("YES");
prt();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T>
struct sparse {
int n, h;
vector<vector<T>> table;
function<T(T, T)> func;
sparse(vector<T> a, function<T(T, T)> f) {
n = a.size();
func = f;
h = 32 - __builtin_clz(n);
table.resize(h);
table[0] = a;
for (int j = 1; j < h; j++) {
table[j].resize(n - (1 << j) + 1);
for (int i = 0; i <= n - (1 << j); i++) {
table[j][i] = func(table[j - 1][i], table[j - 1][i + (1 << (j - 1))]);
}
}
}
T get(int from, int to) const {
int k = 32 - __builtin_clz(to - from + 1) - 1;
return func(table[k][from], table[k][to - (1 << k) + 1]);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n), b(n);
vector<vector<int>> p(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
a[i]--, b[i]--;
p[a[i]].emplace_back(i);
}
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
vector<int> ans(n);
vector<int> c(n), l(n), r(n);
for (int i = 0; i < n; i++) {
for (int j : p[i]) {
pq.emplace(b[j], j);
}
pair<int, int> t = pq.top();
pq.pop();
ans[t.second] = i;
c[i] = t.second;
l[i] = a[t.second];
r[i] = b[t.second];
}
sparse<int> s(l, [&](int a, int b) { return min(a, b); });
sparse<int> t(r, [&](int a, int b) { return max(a, b); });
;
for (int i = 0; i < n; i++) {
pair<int, int> sw = {-1, i};
if (i + 1 <= r[i] && s.get(i + 1, r[i]) <= i) {
for (int j = i + 1; j <= r[i]; j++) {
if (l[j] <= i) {
sw.first = j;
break;
}
}
}
if (i <= i - 1 && t.get(l[i], i - 1) >= i) {
for (int j = i - 1; j >= l[i]; j--) {
if (r[j] >= i) {
sw.first = j;
break;
}
}
}
if (sw.first != -1) {
;
cout << "NO" << '\n';
for (int j : ans) {
cout << j + 1 << " ";
}
cout << '\n';
swap(ans[c[sw.first]], ans[c[sw.second]]);
for (int j : ans) {
cout << j + 1 << " ";
}
cout << '\n';
return 0;
}
}
cout << "YES" << '\n';
for (int i : ans) {
cout << i + 1 << " ";
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int unx() {
int x = 0, n = 0;
char c = getchar();
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return (n) ? -x : x;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int l, int r) { return l + rng() % (r - l + 1); }
const int N = 2e5 + 5;
int n;
pair<int, int> a[N];
int s[N], pos[N], id[N];
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
h;
vector<pair<int, int>> event[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
for (int i = 1, _c = n = unx(); i <= _c; ++i) {
a[i] = {unx(), unx()};
}
for (int i = 1, _c = n; i <= _c; ++i)
event[a[i].first].push_back(make_pair(a[i].second, i));
for (int i = 1, _c = n; i <= _c; ++i) {
for (auto &v : event[i]) h.push(v);
int ri, index;
tie(ri, index) = h.top();
h.pop();
id[index] = i;
pos[i] = index;
if (h.size()) s[index] = h.top().second;
}
for (int i = 1, _c = n; i <= _c; ++i) {
int cur = i, nxt = s[i];
if (nxt && a[cur].first <= id[nxt] && id[nxt] <= a[cur].second &&
a[nxt].first <= id[cur] && id[cur] <= a[nxt].second) {
cout << "NO\n";
for (int i = 1, _c = n; i <= _c; ++i) cout << id[i] << ' ';
cout << '\n';
swap(id[cur], id[nxt]);
for (int i = 1, _c = n; i <= _c; ++i) cout << id[i] << ' ';
return 0;
}
}
cout << "YES\n";
for (int i = 1, _c = n; i <= _c; ++i) cout << id[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 3;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
pair<int, int> t[N * 4];
void upd(int v, int l, int r, int pos, int val) {
if (l == r) {
t[v] = make_pair(val, l);
return;
}
int mid = (l + r) / 2;
if (pos <= mid)
upd(v * 2, l, mid, pos, val);
else
upd(v * 2 + 1, mid + 1, r, pos, val);
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
pair<int, int> get(int v, int l, int r, int L, int R) {
if (l > r || L > r || l > R) return make_pair(0, 0);
if (L <= l && r <= R) return t[v];
int mid = (l + r) / 2;
return max(get(v * 2, l, mid, L, R), get(v * 2 + 1, mid + 1, r, L, R));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
pair<pair<int, int>, int> p[n + 4];
for (int i = 1; i <= n; ++i) {
int l, r;
cin >> l >> r;
p[i].first.first = r, p[i].first.second = l;
p[i].second = i;
}
sort(p + 1, p + 1 + n);
set<int> s;
for (int i = 1; i <= n; ++i) s.insert(i);
int a[n + 4], pos[n + 4];
vector<pair<int, int> > L[n + 4];
for (int i = 1; i <= n; ++i) {
int id = p[i].second;
int l = p[i].first.second, r = p[i].first.first;
a[id] = *s.lower_bound(l);
s.erase(a[id]);
L[l].push_back(make_pair(a[id], r));
pos[a[id]] = i;
}
int x = -1, y = -1;
int last = 0;
for (int i = 1; i <= n; ++i) {
int id = p[pos[i]].second;
int l = p[pos[i]].first.second, r = p[pos[i]].first.first;
for (auto it : L[i]) upd(1, 1, n, it.first, it.second);
pair<int, int> rr = get(1, 1, n, l, r);
if (a[id] <= rr.first && rr.second != a[id]) {
x = a[id], y = rr.second;
}
}
if (x != -1 && y != -1) {
cout << "NO\n";
for (int i = 1; i <= n; ++i) cout << a[i] << ' ';
cout << "\n";
for (int i = 1; i <= n; ++i) {
if (a[i] == x)
cout << y << ' ';
else if (a[i] == y)
cout << x << ' ';
else
cout << a[i] << ' ';
}
} else {
cout << "YES\n";
for (int i = 1; i <= n; ++i) cout << a[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 2e5 + 10;
const int INF = 0x3f3f3f3f;
int n;
int st[N], en[N];
std::vector<std::pair<int, int> > v[N];
int ans[N], re_ans[N];
std::pair<int, int> minn[N << 1];
void Build() {
for (int i = 1; i <= n; ++i)
minn[i + n - 1] = std::make_pair(st[re_ans[i]], i);
for (int i = n - 1; i >= 1; --i)
minn[i] = std::min(minn[i << 1], minn[i << 1 | 1]);
}
int Find(int l, int r) {
l += n, r += n;
std::pair<int, int> res(INF, INF);
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = std::min(res, minn[l++]);
if (r & 1) res = std::min(res, minn[--r]);
}
return res.second == INF ? -1 : res.second;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", &st[i], &en[i]);
for (int i = 1; i <= n; ++i) v[st[i]].push_back(std::make_pair(en[i], i));
std::set<std::pair<int, int> > s;
for (int i = 1; i <= n; ++i) {
s.insert(v[i].begin(), v[i].end());
ans[s.begin()->second] = i;
re_ans[i] = s.begin()->second;
s.erase(s.begin());
}
Build();
for (int i = 1; i <= n; ++i) {
int p = Find(i, en[re_ans[i]]);
if (p == -1) continue;
if (st[re_ans[p]] <= i) {
printf("NO\n");
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
std::swap(ans[re_ans[i]], ans[re_ans[p]]);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
return 0;
}
}
printf("YES\n");
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
int n, l[200005], r[200005], rk[200005], rk1[200005], p[200005];
struct cmp {
bool operator()(int a, int b) { return r[a] > r[b]; }
};
int cmp1(int a, int b) { return l[a] < l[b]; }
int cmp2(int a, int b) { return p[a] < p[b]; }
std::priority_queue<int, std::vector<int>, cmp> q;
std::vector<int> G[200005];
struct segmentTree {
int min[200005 << 2];
int gmin(int a, int b) {
if (r[a] > r[b]) return a;
return b;
}
void modify(int l, int r, int p, int v, int rt) {
if (l == r) {
min[rt] = gmin(v, min[rt]);
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
modify(l, mid, p, v, rt << 1);
else
modify(mid + 1, r, p, v, rt << 1 | 1);
min[rt] = gmin(min[rt << 1], min[rt << 1 | 1]);
}
int query(int l, int r, int L, int R, int rt) {
if (l > R || r < L) return 0;
if (l <= L && R <= r) return min[rt];
return gmin(query(l, r, L, (L + R) >> 1, rt << 1),
query(l, r, ((L + R) >> 1) + 1, R, rt << 1 | 1));
}
} sgt;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &l[i], &r[i]);
rk[i] = i;
rk1[i] = i;
G[l[i]].push_back(i);
}
for (int i = 1; i <= n; ++i) {
for (int v : G[i]) q.push(v);
int u = q.top();
q.pop();
p[u] = i;
}
std::sort(rk1 + 1, rk1 + n + 1, cmp1);
std::sort(rk + 1, rk + n + 1, cmp2);
int p1 = 0;
for (int i = 1; i <= n; ++i) {
while (p1 < n && l[rk1[p1 + 1]] <= p[rk[i]]) {
p1++;
sgt.modify(1, n, p[rk1[p1]], rk1[p1], 1);
}
int d = sgt.gmin(sgt.query(l[rk[i]], p[rk[i]] - 1, 1, n, 1),
sgt.query(p[rk[i]] + 1, r[rk[i]], 1, n, 1));
if (r[d] < r[rk[i]]) continue;
printf("NO\n");
for (int i = 1; i <= n; ++i) printf("%d ", p[i]);
puts("");
std::swap(p[rk[i]], p[d]);
for (int i = 1; i <= n; ++i) printf("%d ", p[i]);
return 0;
}
printf("YES\n");
for (int i = 1; i <= n; ++i) printf("%d ", p[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void print_ans(const vector<int>& p) {
vector<int> ans(p.size());
for (int i = 0; i < (int)p.size(); ++i) ans[p[i]] = i;
for (int i = 0; i < (int)ans.size(); ++i)
printf("%d%c", ans[i] + 1, i + 1 == (int)ans.size() ? '\n' : ' ');
}
int main() {
int n;
scanf("%d", &n);
vector<int> a(n), b(n);
vector<pair<int, int>> events;
for (int i = 0; i < n; ++i) {
scanf("%d %d", &a[i], &b[i]);
--a[i], --b[i];
events.emplace_back(a[i], i);
}
sort(events.begin(), events.end());
vector<int> p;
priority_queue<pair<int, int>> pq;
for (int i = 0, e = 0; i < n; ++i) {
while (e < (int)events.size() && events[e].first <= i) {
int v = events[e].second;
pq.emplace(-b[v], v);
++e;
}
int v = pq.top().second;
pq.pop();
p.emplace_back(v);
}
int lef = -1, rig = -1;
stack<int> vrig;
for (int i = n - 1; i >= 0; --i) {
int v = p[i];
while (!vrig.empty() && a[p[vrig.top()]] > i) vrig.pop();
if (!vrig.empty() && vrig.top() <= b[v]) {
lef = i, rig = vrig.top();
break;
}
while (!vrig.empty() && a[p[vrig.top()]] >= a[v]) vrig.pop();
vrig.push(i);
}
if (lef == -1) {
puts("YES");
} else {
puts("NO");
print_ans(p);
swap(p[lef], p[rig]);
}
print_ans(p);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> l(n), r(n);
vector<pair<int, int>> st[n];
for (int i = 0; i < n; i++) {
scanf("%d%d", &l[i], &r[i]), l[i]--, r[i]--;
st[l[i]].push_back({r[i], i});
}
set<pair<int, int>> sii;
pair<int, int> prs = {-1, -1};
vector<int> ans(n), dq;
for (int i = 0; i < n; i++) {
for (auto& p : st[i]) sii.insert(p);
int x = sii.begin()->second;
sii.erase(sii.begin());
ans[x] = i;
while (!dq.empty() && r[dq.back()] < i) dq.pop_back();
if (!dq.empty() && l[x] <= ans[dq.back()]) prs = {dq.back(), x};
dq.push_back(x);
}
printf(~prs.first ? "NO\n" : "YES\n");
for (int& i : ans) printf("%d ", i + 1);
printf("\n");
if (prs.first == -1) return 0;
swap(ans[prs.first], ans[prs.second]);
for (int& i : ans) printf("%d ", i + 1);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
class SegmentTree {
private:
vector<pair<int, int>> aint;
vector<int> lazy;
int mode;
public:
SegmentTree(int n, int mode_) {
aint.resize(1 + 4 * n);
lazy.resize(1 + 4 * n);
mode = mode_;
}
void cleannode(int node, int from, int to) {
if (from < to) {
int mid = (from + to) / 2;
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
aint[node].first += lazy[node];
lazy[node] = 0;
}
pair<int, int> join(pair<int, int> f1, pair<int, int> f2) {
if (mode == 1)
return min(f1, f2);
else
return max(f1, f2);
}
void computenode(int node, int from, int to) {
if (from < to) aint[node] = join(aint[node * 2], aint[node * 2 + 1]);
}
void build(int node, int from, int to) {
if (from < to) {
int mid = (from + to) / 2;
build(node * 2, from, mid);
build(node * 2 + 1, mid + 1, to);
computenode(node, from, to);
} else
aint[node] = {0, from};
}
void update(int node, int from, int to, int x, int y, int val) {
if (y < x) return;
if (from == x && to == y) {
lazy[node] += val;
cleannode(node, from, to);
} else {
int mid = (from + to) / 2;
cleannode(node * 2, from, mid);
cleannode(node * 2 + 1, mid + 1, to);
if (x <= mid)
update(node * 2, from, mid, x, (((y) < (mid)) ? (y) : (mid)), val);
if (mid + 1 <= y)
update(node * 2 + 1, mid + 1, to, (((mid + 1) < (x)) ? (x) : (mid + 1)),
y, val);
computenode(node, from, to);
}
}
pair<int, int> _query(int node, int from, int to, int x, int y) {
if (y < x) return {0, 0};
cleannode(node, from, to);
if (from == x && to == y)
return aint[node];
else {
int mid = (from + to) / 2;
if (y <= mid)
return _query(node * 2, from, mid, x, y);
else if (mid + 1 <= x)
return _query(node * 2 + 1, mid + 1, to, x, y);
else
return join(_query(node * 2, from, mid, x, mid),
_query(node * 2 + 1, mid + 1, to, mid + 1, y));
}
}
pair<int, int> query() { return aint[1]; }
};
int const nmax = 200000;
struct Event {
int y;
int id;
bool operator<(Event const &a) const {
if (y != a.y)
return y < a.y;
else
return id < a.id;
}
};
vector<Event> events[1 + nmax];
int sol1[1 + nmax];
int sol2[1 + nmax];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
SegmentTree aint(n, 1);
for (int i = 1; i <= n; i++) aint.update(1, 1, n, i, i, i);
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
events[x].push_back({y, i});
aint.update(1, 1, n, y, n, -1);
}
set<Event> myset;
set<Event> myset2;
bool valid = 0;
for (int i = 1; i <= n; i++) {
for (int h = 0; h < events[i].size(); h++) {
myset.insert(events[i][h]);
myset2.insert(events[i][h]);
}
sol1[myset.begin()->id] = i;
myset.erase(myset.begin());
set<Event>::iterator it = myset2.begin(), target = myset2.begin();
it++;
if (it != myset2.end() && 0 < aint._query(1, 1, n, i, it->y - 1).first) {
target = it;
valid = 1;
} else
target = myset2.begin();
aint.update(1, 1, n, i, target->y - 1, -1);
sol2[target->id] = i;
myset2.erase(target);
}
if (valid == 0) {
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << sol1[i] << " ";
} else {
cout << "NO\n";
for (int i = 1; i <= n; i++) cout << sol1[i] << " ";
cout << '\n';
for (int i = 1; i <= n; i++) cout << sol2[i] << " ";
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500010;
int l[N];
int r[N];
int p[N];
int q[N];
vector<pair<int, int> > g[N];
int t[N];
void upd(int n, int pos, int x) {
for (; pos <= n; pos |= pos + 1) t[pos] += x;
}
int get(int pos) {
int sum = 0;
for (; pos > 0; pos &= pos + 1, pos--) sum += t[pos];
return sum;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int> > v;
for (int i = 1; i <= n; i++)
cin >> l[i] >> r[i], g[l[i]].push_back({r[i], i});
set<pair<int, int> > st;
for (int i = 1; i <= n; i++) {
for (auto cur : g[i]) {
st.insert(cur);
}
int ind = (*st.begin()).second;
p[ind] = i;
st.erase(st.begin());
if (!st.empty()) {
v.push_back({ind, (*st.begin()).second});
}
}
for (auto cur : v) {
int i = cur.first;
int j = cur.second;
if (p[j] >= l[i] && p[j] <= r[i] && p[i] >= l[j] && p[i] <= r[j]) {
cout << "NO\n";
for (int t = 1; t <= n; t++) cout << p[t] << " ";
cout << '\n';
swap(p[i], p[j]);
for (int t = 1; t <= n; t++) cout << p[t] << " ";
cout << '\n';
return 0;
}
}
cout << "YES\n";
for (int t = 1; t <= n; t++) cout << p[t] << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> T[4 * 200005];
void update(int n, int b, int e, int p, int v) {
if (b == p && e == p) {
T[n] = make_pair(v, p);
} else {
int m = (b + e) / 2;
if (p <= m)
update(2 * n, b, m, p, v);
else
update(2 * n + 1, m + 1, e, p, v);
T[n] = max(T[2 * n], T[2 * n + 1]);
}
}
pair<int, int> query(int n, int b, int e, int l, int r) {
if (b == l && e == r) {
return T[n];
} else {
int m = (b + e) / 2;
if (m >= r) return query(2 * n, b, m, l, r);
if (l > m) return (query(2 * n + 1, m + 1, e, l, r));
return max(query(2 * n, b, m, l, m), query(2 * n + 1, m + 1, e, m + 1, r));
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<pair<pair<int, int>, int> > arr(n);
vector<pair<int, int> > ori(n);
int a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
arr[i] = make_pair(make_pair(a, b), i);
ori[i] = make_pair(a, b);
}
sort(arr.begin(), arr.end());
priority_queue<pair<int, int> > q;
vector<int> result1(n);
vector<int> result2(n);
int index = 0;
map<int, int> comp;
for (int i = 1; i <= n; i++) {
while (index < n && arr[index].first.first == i) {
q.push(make_pair(-1 * arr[index].first.second, arr[index].second));
index++;
}
pair<int, int> current = q.top();
q.pop();
result1[current.second] = i;
comp[i] = current.second;
}
for (int i = 0; i < n; i++) {
result2[i] = result1[i];
}
bool one = true;
for (int i = 1; i <= n; i++) {
int l = ori[comp[i]].first;
int r = ori[comp[i]].second;
pair<int, int> res = query(1, 0, 200005, l, r);
if (res.first >= i) {
one = false;
result2[comp[i]] = result1[comp[res.second]];
result2[comp[res.second]] = result1[comp[i]];
break;
}
update(1, 0, 200005, i, r);
}
if (one) {
cout << "YES" << '\n';
for (int i = 0; i < n; i++) {
cout << result1[i] << " ";
}
cout << '\n';
} else {
cout << "NO" << '\n';
for (int i = 0; i < n; i++) {
cout << result1[i] << " ";
}
cout << '\n';
for (int i = 0; i < n; i++) {
cout << result2[i] << " ";
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000;
struct edge {
long long to, cost;
edge(int a, int b) : to(a), cost(b) {}
};
void debug(vector<int>& db) {
for (auto x : db) cout << x << " ";
cout << endl;
}
long long mod = 1000000007;
long long my_pow(long long a, long long b) {
long long re = 1;
while (b) {
if (b & 1) re = (re * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return re;
}
struct P {
int l, r, idx;
P(int tl, int tr, int tidx) : l(tl), r(tr), idx(tidx) {}
};
struct cmp {
bool operator()(const P& a, const P& b) { return a.l < b.l; }
} cmp;
struct setcmp {
bool operator()(const P& a, const P& b) { return a.r < b.r; }
};
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n;
cin >> n;
vector<P> da;
multiset<P, setcmp> sp;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
da.push_back(P(l, r, i));
}
sort(da.begin(), da.end(), cmp);
vector<P> vp;
vector<int> ans(n);
int now = 0;
for (int i = 1; i <= n; i++) {
while (now < n && da[now].l <= i) {
sp.insert(da[now++]);
}
vp.push_back(*sp.begin());
sp.erase(sp.begin());
}
for (int i = 0; i < n; i++) {
ans[vp[i].idx] = i + 1;
}
map<int, pair<int, int>, greater<int>> mp;
for (int i = 0; i < n; i++) {
while (mp.begin() != mp.end() && mp.begin()->second.second < i + 1)
mp.erase(mp.begin());
if (mp.begin() != mp.end() && vp[i].l <= mp.begin()->first) {
cout << "NO" << endl;
debug(ans);
swap(ans[vp[i].idx], ans[mp.begin()->second.first]);
debug(ans);
return 0;
}
if (mp.find(i + 1) == mp.end())
mp[i + 1] = {vp[i].idx, vp[i].r};
else if (mp[i + 1].second < vp[i].r)
mp[i + 1] = {vp[i].idx, vp[i].r};
}
cout << "YES" << endl;
debug(ans);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma G++ optimize(2)
using namespace std;
const int MAX_N = 2e5 + 5;
const int inf = 1e9;
struct node {
int l, r, mn, pos;
} tr[MAX_N << 2];
void pushup(int k) {
if (tr[k << 1].mn < tr[k << 1 | 1].mn)
tr[k].mn = tr[k << 1].mn, tr[k].pos = tr[k << 1].pos;
else
tr[k].mn = tr[k << 1 | 1].mn, tr[k].pos = tr[k << 1 | 1].pos;
}
void build(int k, int l, int r) {
tr[k].l = l, tr[k].r = r, tr[k].mn = inf, tr[k].pos = -1;
if (l == r) {
tr[k].pos = l;
return;
}
int mid = (l + r) >> 1;
build(k << 1, l, mid), build(k << 1 | 1, mid + 1, r);
}
void update(int k, int l, int r, int pos, int val) {
if (l == r) {
tr[k].mn = val;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
update(k << 1, l, mid, pos, val);
else
update(k << 1 | 1, mid + 1, r, pos, val);
pushup(k);
}
pair<int, int> query(int k, int l, int r, int L, int R) {
if (l == L && r == R) return pair<int, int>(tr[k].pos, tr[k].mn);
int mid = (l + r) >> 1;
if (L > mid)
return query(k << 1 | 1, mid + 1, r, L, R);
else if (R <= mid)
return query(k << 1, l, mid, L, R);
else {
pair<int, int> t1 = query(k << 1, l, mid, L, mid),
t2 = query(k << 1 | 1, mid + 1, r, mid + 1, R);
return (t1.second < t2.second) ? t1 : t2;
}
}
struct node2 {
int l, r, id, pos;
} p[MAX_N];
bool cmp(node2 a, node2 b) {
if (a.r != b.r)
return a.r < b.r;
else
return a.l < b.l;
}
set<int> s;
int id_pos[MAX_N], pos_id[MAX_N];
int main() {
int n;
scanf("%d", &n);
for (register int i = 1; i <= n; ++i)
scanf("%d", &p[i].l), scanf("%d", &p[i].r), p[i].id = i, s.insert(i);
sort(p + 1, p + 1 + n, cmp);
build(1, 1, n);
for (register int i = 1; i <= n; ++i) {
auto it = s.lower_bound(p[i].l);
id_pos[p[i].id] = *it, pos_id[*it] = p[i].id, p[i].pos = *it;
update(1, 1, n, *it, p[i].l);
s.erase(*it);
}
for (register int i = 1; i <= n; ++i) {
int tmp = p[i].pos;
if (tmp + 1 > n || tmp + 1 > p[i].r) continue;
pair<int, int> tn = query(1, 1, n, tmp + 1, p[i].r);
if (tn.second <= tmp) {
puts("NO");
for (register int j = 1; j <= n; ++j)
printf("%d%c", id_pos[j], j == n ? '\n' : ' ');
swap(id_pos[p[i].id], id_pos[pos_id[tn.first]]);
for (register int j = 1; j <= n; ++j)
printf("%d%c", id_pos[j], j == n ? '\n' : ' ');
return 0;
}
}
puts("YES");
for (register int i = 1; i <= n; ++i)
printf("%d%c", id_pos[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, pos[maxn];
struct Node {
int l, r, id;
bool operator<(const Node& b) const { return r < b.r; }
} p[maxn];
pair<int, int> pp[maxn], st[maxn << 2];
void build(int rt, int L, int R) {
if (L == R) {
st[rt] = pp[L];
return;
}
int mid = (L + R) >> 1;
build((rt << 1), L, mid);
build((rt << 1 | 1), mid + 1, R);
st[rt] = min(st[(rt << 1)], st[(rt << 1 | 1)]);
}
pair<int, int> query(int rt, int l, int r, int L, int R) {
if (l <= L && R <= r) return st[rt];
int mid = (L + R) >> 1;
pair<int, int> ans = {n + 1, 0};
if (l <= mid) ans = min(ans, query((rt << 1), l, r, L, mid));
if (r > mid) ans = min(ans, query((rt << 1 | 1), l, r, mid + 1, R));
return ans;
}
void print() {
for (int i = 1; i <= n; ++i) printf("%d%c", pos[i], i == n ? '\n' : ' ');
}
int main() {
set<int> s;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &p[i].l, &p[i].r);
p[i].id = i;
s.insert(i);
}
sort(p + 1, p + 1 + n);
for (int i = 1; i <= n; ++i) {
auto it = s.lower_bound(p[i].l);
pos[p[i].id] = *it;
pp[*it] = {p[i].l, p[i].id};
s.erase(it);
}
build(1, 1, n);
for (int i = 1; i <= n; ++i) {
int Pi = pos[p[i].id], Ri = p[i].r;
if (Pi + 1 > Ri) continue;
pair<int, int> res = query(1, Pi + 1, Ri, 1, n);
if (res.first > Pi) continue;
puts("NO");
print();
swap(pos[res.second], pos[p[i].id]);
print();
return 0;
}
puts("YES");
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, u = -1, v = -1;
struct A {
int id, l, r;
} p[200000], q[200001];
int ans[200000];
bool operator<(A a, A b) { return a.r > b.r; }
bool operator>(A a, A b) { return a.r < b.r; }
inline bool comp(A a, A b) { return a.l < b.l; }
priority_queue<A> h;
void read(void) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &p[i].l, &p[i].r);
p[i].id = i;
}
sort(p, p + n, comp);
int pos = 0;
for (int i = 1; i <= n; i++) {
while (pos < n && p[pos].l < i) pos++;
while (pos < n && p[pos].l == i) {
h.push(p[pos]);
pos++;
}
ans[h.top().id] = i;
h.pop();
}
return;
}
int x, y;
int mini[800001], maxi[800001];
inline void build(int i, int l, int r) {
if (l == r) {
mini[i] = maxi[i] = l;
return;
}
int m = (l + r) >> 1;
build(i << 1, l, m);
build(i << 1 | 1, m + 1, r);
if (q[mini[i << 1]].l < q[mini[i << 1 | 1]].l)
mini[i] = mini[i << 1];
else
mini[i] = mini[i << 1 | 1];
if (q[maxi[i << 1]].l > q[maxi[i << 1 | 1]].l)
maxi[i] = maxi[i << 1];
else
maxi[i] = maxi[i << 1 | 1];
return;
}
inline int mn(int i, int l, int r) {
if (x <= l && r <= y) return mini[i];
int res, m = (l + r) >> 1, a = -1, b = -1;
if (x <= m) a = mn(i << 1, l, m);
if (m < y) b = mn(i << 1 | 1, m + 1, r);
if (a != -1) res = a;
if (b != -1 && (a == -1 || q[b].l < q[a].l)) res = b;
return res;
}
inline int querymn(int l, int r) {
x = l;
y = r;
return mn(1, 1, n);
}
inline int mx(int i, int l, int r) {
if (x <= l && r <= y) return maxi[i];
int res, m = (l + r) >> 1, a = -1, b = -1;
if (x <= m) a = mx(i << 1, l, m);
if (m < y) b = mx(i << 1 | 1, m + 1, r);
if (a != -1) res = a;
if (b != -1 && (a == -1 || q[b].r > q[a].r)) res = b;
return res;
}
inline int querymx(int l, int r) {
x = l;
y = r;
return mx(1, 1, n);
}
void print(void) {
if (u == -1 || v == -1) {
printf("YES\n%d", ans[0]);
for (int i = 1; i < n; i++) printf(" %d", ans[i]);
putchar('\n');
} else {
printf("NO\n%d", ans[0]);
for (int i = 1; i < n; i++) printf(" %d", ans[i]);
for (int i = 0; i < n; i++)
if (ans[i] == u)
ans[i] = v;
else if (ans[i] == v)
ans[i] = u;
printf("\n%d", ans[0]);
for (int i = 1; i < n; i++) printf(" %d", ans[i]);
putchar('\n');
}
return;
}
int main(void) {
read();
for (int i = 0; i < n; i++) q[ans[p[i].id]] = p[i];
build(1, 1, n);
for (int i = 1; i <= n; i++) {
if (q[i].l < i) {
int t = querymx(q[i].l, i - 1);
if (q[t].r >= i) {
u = i;
v = t;
break;
}
}
if (i < q[i].r) {
int t = querymn(i + 1, q[i].r);
if (i >= q[t].l) {
u = i;
v = t;
break;
}
}
}
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
struct segment_tree {
int n;
vector<pair<int, int>> a;
segment_tree(int n) : n(n), a(2 * n, make_pair(inf, 0)) {}
void update(int p, pair<int, int> v) {
for (a[p += n] = v; p /= 2;) a[p] = min(a[2 * p], a[2 * p + 1]);
}
pair<int, int> query(int l, int r) {
pair<int, int> g = {inf, 0};
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l & 1) g = min(g, a[l++]);
if (r & 1) g = min(g, a[--r]);
}
return g;
}
};
struct info {
int a, b, id;
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
vector<info> a(n);
for (auto &i : a) cin >> i.a >> i.b, --i.a, --i.b, i.id = &i - &a[0];
stable_sort(a.begin(), a.end(),
[](const info &x, const info &y) { return x.b < y.b; });
segment_tree st(n);
for (int i = 0; i < n; ++i) st.update(i, {0, i});
vector<int> ans(n), id(n);
for (auto &i : a) {
int p = st.query(i.a, i.b + 1).second;
ans[i.id] = p;
id[p] = &i - &a[0];
st.update(p, {inf, p});
}
for (int i = 0; i < n; ++i) st.update(ans[i], {a[id[ans[i]]].a, i});
vector<int> ans2 = ans;
for (int i = 0; i < n; ++i) {
int x = ans2[i];
if (x < a[id[x]].b) {
auto q = st.query(x + 1, a[id[x]].b + 1);
if (q.first <= x) {
swap(ans2[i], ans2[q.second]);
break;
}
}
}
if (ans == ans2) {
cout << "YES\n";
for (auto &i : ans) cout << i + 1 << " \n"[i == ans.back()];
} else {
cout << "NO\n";
for (auto &i : ans) cout << i + 1 << " \n"[i == ans.back()];
for (auto &i : ans2) cout << i + 1 << " \n"[i == ans2.back()];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
if (e == 0) return 1;
if (e % 2 == 0) {
T t = bigmod(p, e / 2, M);
return (t * t) % M;
}
return (bigmod(p, e - 1, M) * p) % M;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T multimod(T a, T b, T m) {
T res = 0;
a %= m, b %= m;
while (b) {
if (b & 1) res = m - res > a ? (res + a) : (res + a - m);
b >>= 1;
a = (m - a) > a ? a + a : a + a - m;
}
return (T)res;
}
void sc(int &a) { scanf("%d", &a); }
void sc(long long &a) { scanf("%lld", &a); }
void sc(double &a) { scanf("%lf", &a); }
void sc(int &a, int &b) { scanf("%d %d", &a, &b); }
void sc(long long &a, long long &b) { scanf("%lld %lld", &a, &b); }
void sc(int &a, int &b, int &c) { scanf("%d %d %d", &a, &b, &c); }
void sc(int &a, int &b, long long &c) { scanf("%d %d %lld", &a, &b, &c); }
void sc(long long &a, long long &b, long long &c) {
scanf("%lld %lld %lld", &a, &b, &c);
}
void sc(string &str) { cin >> str; }
void sc(char *(str)) { scanf(" %s", str); }
void sc(char &c) { scanf(" %c", &c); }
int dr[] = {0, 1, 0, -1};
int dc[] = {1, 0, -1, 0};
struct Z {
int l, r, p;
Z() {}
Z(int _, int __, int ___) {
l = _;
r = __;
p = ___;
}
bool operator<(const Z &A) const {
if (l < A.l)
return true;
else if (l > A.l)
return false;
return r < A.r;
}
};
Z arr[(200000 + 7)];
Z save[(200000 + 7)];
int ans[(200000 + 7)];
int can[(200000 + 7)];
int main() {
int i, t, cases = 1, j, pos;
int n;
sc(n);
for (int i = 0; i < n; i++) {
sc(arr[i].l, arr[i].r);
arr[i].l--;
arr[i].r--;
arr[i].p = i;
save[i] = arr[i];
}
sort(arr, arr + n);
set<pair<int, int> > store;
set<pair<int, int> >::iterator it;
int ind = 0;
int p1 = -1, p2 = -1;
memset(can, -1, sizeof can);
for (int pos = 0; pos < n; pos++) {
while (ind < n && arr[ind].l <= pos) {
store.insert(make_pair(arr[ind].r, arr[ind].p));
ind++;
}
it = store.begin();
int p = it->second;
ans[p] = pos;
store.erase(it);
if (store.size() > 0) {
can[p] = store.begin()->second;
}
}
for (int i = 0; i < n; i++) {
int nxt = can[i];
if (nxt == -1) continue;
if (save[i].l <= ans[nxt] && ans[nxt] <= save[i].r) {
p1 = i;
p2 = nxt;
}
}
if (p1 == -1) {
cout << "YES\n";
for (int i = 0; i < n; i++) {
cout << ans[i] + 1 << " ";
}
cout << "\n";
} else {
cout << "NO\n";
for (int i = 0; i < n; i++) {
cout << ans[i] + 1 << " ";
}
cout << "\n";
swap(ans[p1], ans[p2]);
for (int i = 0; i < n; i++) {
cout << ans[i] + 1 << " ";
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, inf = 0x3f3f3f3f;
set<pair<int, int> > hllw;
vector<pair<int, int> > vec[N];
int n, A[N], B[N];
int ans[N], where[N];
pair<int, int> st[N << 1];
int query(int l, int r) {
l--;
pair<int, int> res;
res.first = inf;
res.second = inf;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, st[l++]);
if (r & 1) res = min(res, st[--r]);
}
return res.second;
}
void cout_ans() {
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i] >> B[i];
vec[A[i]].push_back(make_pair(B[i], i));
}
cout << endl;
for (int i = 1; i <= n; i++) {
hllw.insert(vec[i].begin(), vec[i].end());
ans[hllw.begin()->second] = i;
where[i] = hllw.begin()->second;
hllw.erase(hllw.begin());
}
for (int i = 0; i < n; i++) {
st[i + n].first = A[where[i + 1]];
st[i + n].second = i + 1;
}
for (int i = n - 1; i > 0; i--) {
st[i] = min(st[i << 1 | 1], st[i << 1]);
}
for (int i = 1; i <= n; i++) {
int j = query(i + 1, B[where[i]]);
if (j == inf) continue;
if (A[where[j]] <= i) {
cout << "NO" << endl;
cout_ans();
swap(ans[where[i]], ans[where[j]]);
cout_ans();
return 0;
}
}
cout << "YES" << endl;
cout_ans();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long mod = 1000000007;
const long long linf = 0x3f3f3f3f3f3f3f3f;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n;
int ans[200100];
int a[200100], b[200100];
set<pair<int, int> > s;
pair<int, int> e[200100];
pair<int, int> change;
set<pair<int, int> > l, r;
pair<int, int> pos[200100];
void solve() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
for (int i = 0; i < n; i++) e[i].first = a[i], e[i].second = i;
sort(e, e + n);
int j = 1;
for (int i = 0; i < n; i++) {
while (e[i].first > j) {
pair<int, int> r = *s.begin();
s.erase(r);
ans[r.second] = j;
j++;
}
s.insert({b[e[i].second], e[i].second});
}
for (auto r : s) {
ans[r.second] = j;
j++;
}
for (int i = 0; i < n; i++) {
pos[i].first = ans[i];
pos[i].second = i;
}
sort(pos, pos + n);
change = {-1, -1};
for (int i = 0; i < n; i++) {
while (!r.empty() && pos[i].first > (*r.begin()).first) {
int j = (*r.begin()).second;
l.erase({pos[j].first, j});
r.erase(r.begin());
}
if (!l.empty()) {
auto it = l.lower_bound({a[pos[i].second], 0});
if (it != l.end()) {
change.first = pos[i].second;
change.second = pos[(*it).second].second;
break;
}
}
l.insert({pos[i].first, i});
r.insert({b[pos[i].second], i});
}
if (change.first != -1) {
cout << "NO\n";
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
cout << "\n";
swap(ans[change.first], ans[change.second]);
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
cout << "\n";
} else {
cout << "YES\n";
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
}
int main() {
cin.tie(0)->sync_with_stdio(0);
;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int perm[N];
pair<int, int> v[N];
vector<pair<int, int>> s[N];
signed main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i].first >> v[i].second;
s[v[i].first].push_back({v[i].second, i});
}
set<pair<int, int>> best;
vector<pair<int, int>> ch;
for (int i = 1; i <= n; i++) {
for (auto elem : s[i]) best.insert(elem);
assert(!best.empty());
int p = (*best.begin()).second;
perm[p] = i;
best.erase(best.begin());
if (!best.empty()) {
ch.push_back({p, (*best.begin()).second});
}
}
pair<int, int> res = {-1, -1};
for (auto [a, b] : ch) {
if (v[b].first <= perm[a] && perm[a] <= v[b].second) {
if (v[a].first <= perm[b] && perm[b] <= v[a].second) {
res = {a, b};
break;
}
}
}
if (res.first == -1) {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << perm[i] << ' ';
cout << endl;
} else {
cout << "NO" << endl;
for (int i = 1; i <= n; i++) cout << perm[i] << ' ';
cout << endl;
swap(perm[res.first], perm[res.second]);
for (int i = 1; i <= n; i++) cout << perm[i] << ' ';
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 200005;
struct SegmentTree {
vector<pair<int, int>> IT;
vector<int> Low, High;
void InitTree(int x, int Left, int Right) {
Low[x] = Left;
High[x] = Right;
if (Left == Right) {
IT[x] = make_pair(0, 0);
return;
}
int Mid = (Left + Right) / 2;
InitTree(x * 2, Left, Mid);
InitTree(x * 2 + 1, Mid + 1, Right);
IT[x] = max(IT[x * 2], IT[x * 2 + 1]);
}
void Update(int x, int Left, int Right, pair<int, int> Val) {
if (Low[x] > Right || High[x] < Left) {
return;
}
if (Low[x] >= Left && High[x] <= Right) {
IT[x] = Val;
return;
}
Update(x * 2, Left, Right, Val);
Update(x * 2 + 1, Left, Right, Val);
IT[x] = max(IT[x * 2], IT[x * 2 + 1]);
}
pair<int, int> Get(int x, int Left, int Right) {
if (Low[x] > Right || High[x] < Left) {
return make_pair(-1, -1);
}
if (Low[x] >= Left && High[x] <= Right) {
return IT[x];
}
return max(Get(x * 2, Left, Right), Get(x * 2 + 1, Left, Right));
}
void Init(int n) {
IT.resize(4 * n + 5);
Low.resize(4 * n + 5);
High.resize(4 * n + 5);
InitTree(1, 0, n + 1);
}
};
int n;
pair<int, int> d[MaxN];
int x[MaxN], a[MaxN], ansA[MaxN], ansB[MaxN];
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
pqMin;
SegmentTree SMT;
bool cmp(int x, int y) {
return (d[x].first != d[y].first ? d[x].first < d[y].first
: d[x].second < d[y].second);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> d[i].first >> d[i].second;
x[i] = i;
}
sort(x + 1, x + n + 1, cmp);
int j = 1;
for (int i = 1; i <= n; i++) {
while (j <= n && d[x[j]].first <= i) {
pqMin.push(make_pair(d[x[j]].second, x[j]));
j++;
}
a[i] = pqMin.top().second;
ansA[a[i]] = i;
ansB[a[i]] = i;
pqMin.pop();
}
SMT.Init(n);
bool ok = true;
for (int i = 1; i <= n; i++) {
pair<int, int> t = SMT.Get(1, d[a[i]].first, i - 1);
if (t.first >= i) {
swap(ansB[t.second], ansB[a[i]]);
ok = false;
break;
}
SMT.Update(1, i, i, make_pair(d[a[i]].second, a[i]));
}
if (ok) {
cout << "YES\n";
for (int i = 1; i <= n; i++) {
cout << ansA[i] << ' ';
}
} else {
cout << "NO\n";
for (int i = 1; i <= n; i++) {
cout << ansA[i] << ' ';
}
cout << '\n';
for (int i = 1; i <= n; i++) {
cout << ansB[i] << ' ';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
struct I {
int i, l, r;
I(int i, int l, int r) : i(i), l(l), r(r) {}
};
const int INF = 1e9;
template <class T>
struct MinSegmentTree {
const T ID = {INF, INF};
T comb(T a, T b) { return min(a, b); }
int n;
std::vector<T> seg;
void init(int _n) {
n = _n;
seg.assign(2 * n, ID);
}
void pull(int p) { seg[p] = comb(seg[2 * p], seg[2 * p + 1]); }
void upd(int p, T val) {
seg[p += n] = val;
for (p /= 2; p; p /= 2) pull(p);
}
void add(int p, T val) {
seg[p += n] += val;
for (p /= 2; p; p /= 2) pull(p);
}
T query(int l, int r) {
if (l > r) return ID;
T ra = ID, rb = ID;
for (l += n, r += n + 1; l < r; l /= 2, r /= 2) {
if (l & 1) ra = comb(ra, seg[l++]);
if (r & 1) rb = comb(seg[--r], rb);
}
return comb(ra, rb);
}
};
template <class T>
struct MaxSegmentTree {
const T ID = {-INF, -INF};
T comb(T a, T b) { return min(a, b); }
int n;
std::vector<T> seg;
void init(int _n) {
n = _n;
seg.assign(2 * n, ID);
}
void pull(int p) { seg[p] = comb(seg[2 * p], seg[2 * p + 1]); }
void upd(int p, T val) {
seg[p += n] = val;
for (p /= 2; p; p /= 2) pull(p);
}
void add(int p, T val) {
seg[p += n] += val;
for (p /= 2; p; p /= 2) pull(p);
}
T query(int l, int r) {
if (l > r) return ID;
T ra = ID, rb = ID;
for (l += n, r += n + 1; l < r; l /= 2, r /= 2) {
if (l & 1) ra = comb(ra, seg[l++]);
if (r & 1) rb = comb(seg[--r], rb);
}
return comb(ra, rb);
}
};
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<I> ivals;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
a--, b--;
ivals.push_back(I(i, a, b));
}
vector<vector<I>> beg(n);
for (int i = 0; i < n; ++i) {
beg[ivals[i].l].push_back(ivals[i]);
}
set<pair<int, int>> match;
vector<int> m1(n);
for (int i = 0; i < n; ++i) {
for (auto& e : beg[i]) {
match.emplace(e.r, e.i);
}
auto x = *match.begin();
match.erase(match.begin());
m1[x.second] = i;
}
vector<int> m2(n);
auto double_finish = [&]() {
cout << "NO\n";
for (auto& e : m1) cout << e + 1 << " ";
cout << '\n';
for (auto& e : m2) cout << e + 1 << " ";
cout << '\n';
exit(0);
};
m2 = m1;
auto contains = [&](int l, int r, int i) -> int { return l <= i && i <= r; };
vector<int> segs(n);
MaxSegmentTree<pair<int, int>> Left;
MinSegmentTree<pair<int, int>> Right;
Left.init(n);
Right.init(n);
for (int i = 0; i < n; ++i) {
segs[m1[i]] = i;
}
for (int i = 0; i < n; ++i) {
int id = segs[i];
Right.upd(i, {ivals[id].l, i});
Left.upd(i, {ivals[id].r, i});
}
for (int i = 0; i < n; ++i) {
int id = segs[i];
int l = ivals[id].l;
int r = ivals[id].r;
auto qq = Right.query(i + 1, r);
if (qq.first <= i) {
int j = qq.second;
swap(m2[segs[i]], m2[segs[j]]);
double_finish();
}
qq = Left.query(l, i - 1);
if (qq.first >= i) {
int j = qq.second;
swap(m2[segs[i]], m2[segs[j]]);
double_finish();
}
}
cout << "YES" << '\n';
for (auto& e : m1) cout << e + 1 << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
struct Item {
int idx, L, R;
Item() = default;
Item(int _i, int _L, int _R) : idx(_i), L(_L), R(_R) {}
bool operator<(const Item& rhs) const {
return (L == rhs.L) ? ((R == rhs.R) ? idx < rhs.idx : R < rhs.R)
: L < rhs.L;
}
} C[MAXN];
int n;
int A[MAXN], B[MAXN];
set<int> Vertex;
multiset<pair<int, int> > S;
int pre[MAXN], vis[MAXN], Idx[MAXN], Pos[MAXN];
void MultiAns(int u, int nxt) {
static int Cyc[MAXN], nC;
puts("NO");
for (int i = 1; i <= n; ++i) printf("%d%c", Idx[i], " \n"[i == n]);
Cyc[nC = 1] = Pos[nxt];
for (int v = u; v != Pos[nxt]; v = pre[v]) Cyc[++nC] = v;
int v = Idx[Cyc[nC]];
for (int i = 1; i <= nC; ++i) swap(v, Idx[Cyc[i]]);
for (int i = 1; i <= n; ++i) printf("%d%c", Idx[i], " \n"[i == n]);
exit(0);
}
void dfs(int u) {
vector<int> Nxt;
vis[u] = 1;
while (true) {
auto ite = Vertex.lower_bound(A[u]);
if (ite != Vertex.end() && *ite == Idx[u]) Nxt.push_back(*ite), ++ite;
if (ite == Vertex.end() || *ite > B[u]) break;
int v = Pos[*ite];
if (vis[v] == 1) return MultiAns(u, *ite);
Nxt.push_back(*ite);
if (vis[v] == 2) continue;
pre[v] = u, dfs(v);
}
vis[u] = 2;
for (const int& v : Nxt) Vertex.erase(v);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", A + i, B + i);
for (int i = 1; i <= n; ++i) C[i] = Item(i, A[i], B[i]);
sort(C + 1, C + 1 + n);
for (int p = 1, i = 1; i <= n; ++i) {
while (p <= n && C[p].L <= i)
S.insert(pair<int, int>(C[p].R, C[p].idx)), ++p;
int d = S.begin()->second;
Pos[i] = d, Idx[d] = i, S.erase(*S.begin());
}
for (int i = 1; i <= n; ++i) Vertex.insert(i);
for (int i = 1; i <= n; ++i)
if (!vis[i]) dfs(i);
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d%c", Idx[i], " \n"[i == n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long INFF = 1000000000000000005LL;
int n;
vector<pair<long long, int>> arr;
struct segtree {
vector<pair<long long, int>> tree, lazy;
segtree(int size) {
lazy = tree = vector<pair<long long, int>>(4 * size);
for (int i = 0; i < 4 * size; i++) lazy[i].first = 0, tree[i].second = i;
}
void construct(int l = 0, int r = n - 1, int node = 1) {
if (l == r) {
tree[node] = arr[l];
return;
}
int mid = (l + r) / 2;
construct(l, mid, 2 * node);
construct(mid + 1, r, 2 * node + 1);
tree[node] = min(tree[2 * node], tree[2 * node + 1]);
}
pair<long long, int> minquery(int ql, int qr, int l = 0, int r = n - 1,
int node = 1) {
if (qr < 0) return {-1, -1};
if (ql >= n) return {-1, -1};
if (ql > qr) return {-1, -1};
if (lazy[node].first) {
tree[node].first += lazy[node].first;
if (l != r) {
lazy[2 * node].first += lazy[node].first;
lazy[2 * node + 1].first += lazy[node].first;
}
lazy[node].first = 0;
}
if (l > r || l > qr || ql > r) return {INFF, -1};
if (ql <= l && qr >= r) return {tree[node].first, tree[node].second};
int mid = (l + r) / 2;
return min(minquery(ql, qr, l, mid, 2 * node),
minquery(ql, qr, mid + 1, r, 2 * node + 1));
}
void display() {
for (auto u : tree) {
cout << u.first << " ";
}
cout << "\n";
for (auto u : tree) {
cout << u.second << " ";
}
cout << "\n";
}
};
void solve(vector<int> &ans, vector<pair<int, int>> &mem) {
deque<pair<pair<int, int>, int>> v;
for (int i = 0; i < n; i++) v.push_back({{mem[i].first, mem[i].second}, i});
sort(v.begin(), v.end());
multiset<pair<int, int>> mst;
for (int i = 0; i < n; i++) {
while ((int)v.size() > 0 && v[0].first.first <= i) {
mst.insert({v[0].first.second, v[0].second});
v.pop_front();
}
ans[mst.begin()->second] = i + 1;
mst.erase(mst.find(*mst.begin()));
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
segtree st(n);
vector<int> ans(n), ch(n);
vector<pair<int, int>> range(n);
vector<pair<int, int>> mem(n);
arr.resize(n);
for (int i = 0; i < n; i++) {
cin >> mem[i].first >> mem[i].second;
mem[i].first--, mem[i].second--;
}
solve(ans, mem);
for (int i = 0; i < n; i++) {
ch[ans[i] - 1] = i;
arr[ans[i] - 1] = {mem[i].first, i};
}
st.construct();
for (int i = 0; i < n; i++) {
pair<long long, int> a = st.minquery(i + 1, mem[ch[i]].second);
if (a.first == -1) continue;
if (a.first <= i) {
cout << "NO\n";
for (auto u : ans) cout << u << " ";
cout << "\n";
swap(ans[ch[i]], ans[a.second]);
for (auto u : ans) cout << u << " ";
return 0;
}
}
cout << "YES\n";
for (auto u : ans) cout << u << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ans = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) ans = (ans << 3) + (ans << 1) + (c ^ 48);
return ans * f;
}
inline int cmin(int &a, int b) { return a = min(a, b); }
inline int cmax(int &a, int b) { return a = max(a, b); }
struct data {
int id, l, r;
bool operator<(const data &rhs) const {
return l == rhs.l ? r < rhs.r : l < rhs.l;
}
} a[200005];
int n;
int ans[200005];
int pos[200005];
struct node {
int id, l;
bool operator<(const node &rhs) const { return l < rhs.l; }
} t[800005];
inline void push_up(int p) { t[p] = min(t[(p << 1)], t[(p << 1 | 1)]); }
void build(int p, int l, int r) {
if (l == r) {
t[p] = node{pos[l], a[pos[l]].l};
return;
}
int mid = l + r >> 1;
build((p << 1), l, mid);
build((p << 1 | 1), mid + 1, r);
push_up(p);
}
int query(int p, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return t[p].id;
int mid = l + r >> 1;
int ret = 0, val = 1e9;
if (ql <= mid) {
int tmp = query((p << 1), l, mid, ql, qr);
if (a[tmp].l < val) val = a[tmp].l, ret = tmp;
}
if (qr > mid) {
int tmp = query((p << 1 | 1), mid + 1, r, ql, qr);
if (a[tmp].l < val) val = a[tmp].l, ret = tmp;
}
return ret;
}
int flag = 0, x, y;
multiset<node> s;
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i].id = i, a[i].l = read(), a[i].r = read();
sort(a + 1, a + n + 1);
for (int i = 1, j = 1; i <= n; i++) {
while (j <= n && a[j].l <= i) {
s.insert({j, a[j].r});
j++;
}
auto x = s.lower_bound({0, i});
ans[a[x->id].id] = i;
pos[i] = x->id;
s.erase(x);
}
build(1, 1, n);
for (int i = 1; i < n; i++) {
if (a[pos[i]].r == i) continue;
int j = query(1, 1, n, i + 1, a[pos[i]].r);
if (a[j].l <= i && a[j].l) {
flag = 1, x = i, y = j;
break;
}
}
if (!flag) {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
} else {
cout << "NO" << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
swap(ans[a[pos[x]].id], ans[a[y].id]);
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e6 + 5;
int ans1, ans2;
int l[MAXN];
int r[MAXN];
int res[MAXN];
int pos[MAXN];
int n;
vector<int> v2;
priority_queue<pair<int, int>> q1;
vector<pair<pair<int, int>, int>> v1;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
v1.push_back(make_pair(make_pair(l[i], r[i]), i));
}
sort(v1.begin(), v1.end());
int ind = 0;
for (int i = 1; i <= n; i++) {
while (ind < n && v1[ind].first.first <= i) {
q1.push(make_pair(-v1[ind].first.second, v1[ind].second));
ind++;
}
res[i] = q1.top().second;
q1.pop();
}
for (int i = 1; i <= n; i++) {
while (v2.size() && r[res[v2.back()]] < i) {
v2.pop_back();
}
int currl = l[res[i]];
int currr = r[res[i]];
if (v2.size() && currl <= v2.back()) {
ans1 = i;
ans2 = v2.back();
}
while (v2.size() && currr >= r[res[v2.back()]]) {
v2.pop_back();
}
v2.push_back(i);
}
if (ans1) {
cout << "NO" << endl;
;
for (int i = 1; i <= n; i++) {
pos[res[i]] = i;
}
for (int i = 1; i <= n; i++) {
cout << pos[i] << " ";
}
cout << endl;
for (int i = 1; i <= n; i++) {
if (i == ans1) {
pos[res[ans2]] = i;
} else if (i == ans2) {
pos[res[ans1]] = i;
} else {
pos[res[i]] = i;
}
}
for (int i = 1; i <= n; i++) {
cout << pos[i] << " ";
}
} else {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
pos[res[i]] = i;
}
for (int i = 1; i <= n; i++) {
cout << pos[i] << " ";
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
constexpr int MX = 2e5 + 5;
template <typename T>
struct seg_tree {
T seg[4 * MX], tmp[4 * MX];
inline T pull(const T& a, const T& b) { return min(a, b); }
void update(int x, T v, int l = 0, int r = MX - 1, int n = 1) {
if (l == r) {
seg[n] = v;
return;
}
int m = l + r >> 1;
x <= m ? update(x, v, l, m, n << 1) : update(x, v, m + 1, r, n << 1 | 1);
seg[n] = pull(seg[n << 1], seg[n << 1 | 1]);
}
T query(int a, int b, int l = 0, int r = MX - 1, int n = 1) {
if (a > b || l > b || r < a) return ii(1e9, 0);
if (l >= a && r <= b) return seg[n];
int m = l + r >> 1;
return pull(query(a, b, l, m, n << 1), query(a, b, m + 1, r, n << 1 | 1));
}
};
vector<ii> v[MX];
int a[MX], b[MX], P[MX], ans[MX];
seg_tree<ii> seg;
int main() {
if (fopen("in", "r")) freopen("in", "r", stdin), freopen("out", "w", stdout);
cin.tie(0)->sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i];
--a[i], --b[i];
v[a[i]].emplace_back(b[i], i);
}
set<ii> S;
for (int i = 0; i < n; ++i) {
S.insert(begin(v[i]), end(v[i]));
ans[begin(S)->second] = i, P[i] = begin(S)->second;
S.erase(begin(S));
}
for (int i = 0; i < n; ++i) seg.update(i, ii(a[P[i]], i));
for (int i = 0; i < n; ++i) {
ii j = seg.query(i + 1, b[P[i]]);
if (j.first < 1e9 && a[P[j.second]] <= i) {
cout << "NO\n";
for (int _ : {0, 1}) {
for (int k = 0; k < n; ++k) cout << ans[k] + 1 << ' ';
cout << '\n';
swap(ans[P[i]], ans[P[j.second]]);
}
return 0;
}
}
cout << "YES\n";
for (int k = 0; k < n; ++k) cout << ans[k] + 1 << ' ';
cout << '\n';
}
|
#include <bits/stdc++.h>
const int N = 2e5 + 10;
const int inf = 0x3f3f3f3f;
int n, m, i, j, k;
int l[N], r[N];
int a[N], rev[N], pos[N], senq[N];
struct Segment_Tree1 {
int mn[N << 2];
inline void push_up(int u) { mn[u] = std::min(mn[u << 1], mn[u << 1 | 1]); }
void build(int l, int r, int u) {
if (l == r) {
mn[u] = l;
return;
}
int mid = (l + r) >> 1;
build(l, mid, u << 1);
build(mid + 1, r, u << 1 | 1);
push_up(u);
}
int range_min(int ql, int qr, int l, int r, int u) {
if (ql <= l && r <= qr) {
return mn[u];
}
int mid = (l + r) >> 1, res = inf;
if (ql <= mid) {
res = std::min(res, range_min(ql, qr, l, mid, u << 1));
}
if (mid < qr) {
res = std::min(res, range_min(ql, qr, mid + 1, r, u << 1 | 1));
}
return res;
}
void modify(int pos, int l, int r, int u, int val) {
if (l == r) {
mn[u] = val;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid) {
modify(pos, l, mid, u << 1, val);
} else {
modify(pos, mid + 1, r, u << 1 | 1, val);
}
push_up(u);
}
} st1;
struct Segment_Tree2 {
int mn[N << 2];
inline int cmpl(int a, int b) { return l[rev[a]] < l[rev[b]] ? a : b; }
inline void push_up(int u) { mn[u] = cmpl(mn[u << 1], mn[u << 1 | 1]); }
void build(int l, int r, int u) {
if (l == r) {
mn[u] = l;
return;
}
int mid = (l + r) >> 1;
build(l, mid, u << 1);
build(mid + 1, r, u << 1 | 1);
push_up(u);
}
int range_min(int ql, int qr, int l, int r, int u) {
if (ql <= l && r <= qr) {
return mn[u];
}
int mid = (l + r) >> 1, res = 0;
if (ql <= mid) {
res = cmpl(res, range_min(ql, qr, l, mid, u << 1));
}
if (mid < qr) {
res = cmpl(res, range_min(ql, qr, mid + 1, r, u << 1 | 1));
}
return res;
}
} st2;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", l + i, r + i);
senq[i] = i;
}
std::sort(senq + 1, senq + n + 1, [](int a, int b) { return r[a] < r[b]; });
l[0] = inf;
st1.build(1, n, 1);
for (int i = 1; i <= n; i++) {
pos[senq[i]] = st1.range_min(l[senq[i]], r[senq[i]], 1, n, 1);
rev[pos[senq[i]]] = senq[i];
st1.modify(pos[senq[i]], 1, n, 1, n);
}
st2.build(1, n, 1);
int x = -1, y = -1;
bool flag = 0;
for (int i = 1, cur; i <= n; i++) {
if (l[cur = rev[st2.range_min(i + 1, r[rev[i]], 1, n, 1)]] <= i) {
x = rev[i];
y = cur;
flag = 1;
break;
}
}
if (!flag) {
puts("YES");
for (int i = 1; i <= n; i++) {
printf("%d%c", pos[i], " \n"[i == n]);
}
} else {
puts("NO");
for (int i = 1; i <= n; i++) {
printf("%d%c", pos[i], " \n"[i == n]);
}
std::swap(pos[x], pos[y]);
for (int i = 1; i <= n; i++) {
printf("%d%c", pos[i], " \n"[i == n]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
pair<int, int> intervals[MAXN];
vector<pair<int, int> > add_to_q[MAXN];
int ordered_friends[MAXN];
int minimum[MAXN][20];
int ans[MAXN];
int query(int l, int r) {
if (l > r) return 2e9;
int cur = l;
int ans = 2e9;
for (int i = 19; i >= 0; i--) {
if ((1 << i) & (r - l + 1)) {
ans = min(ans, minimum[cur][i]);
cur += (1 << i);
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> intervals[i].first >> intervals[i].second;
for (int i = 1; i <= n; i++) {
add_to_q[intervals[i].first].push_back(
pair<int, int>(intervals[i].second, i));
}
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
for (int i = 1; i <= n; i++) {
for (pair<int, int> j : add_to_q[i]) pq.push(j);
ordered_friends[i] = pq.top().second;
pq.pop();
}
for (int i = 1; i <= n; i++)
minimum[i][0] = intervals[ordered_friends[i]].first;
for (int i = 1; i <= 19; i++) {
for (int j = 1; j <= n; j++) {
minimum[j][i] = minimum[j][i - 1];
if (j + (1 << (i - 1)) <= n)
minimum[j][i] = min(minimum[j][i], minimum[j + (1 << (i - 1))][i - 1]);
}
}
for (int i = n; i >= 1; i--) {
if (i + 1 <= intervals[ordered_friends[i]].second) {
if (query(i + 1, intervals[ordered_friends[i]].second) <= i) {
cout << "NO" << '\n';
for (int i = 1; i <= n; i++) ans[ordered_friends[i]] = i;
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << '\n';
for (int j = i + 1; j <= intervals[ordered_friends[i]].second; j++) {
if (intervals[ordered_friends[j]].first <= i) {
swap(ans[ordered_friends[i]], ans[ordered_friends[j]]);
break;
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
return 0;
}
}
}
cout << "YES" << '\n';
for (int i = 1; i <= n; i++) ans[ordered_friends[i]] = i;
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000007;
const long long INFL = 1000000000000000007;
const long double INFS = 0.00000001;
const long long MOD = 1000000007;
const long double PI = 3.14159265;
const int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
const int dir2[8][2] = {{1, 1}, {1, 0}, {1, -1}, {0, 1},
{0, -1}, {-1, 1}, {-1, 0}, {-1, -1}};
long long min(long long x, long long y) { return x < y ? x : y; }
long long minr(vector<long long> x) {
long long Min = INFL;
for (auto i : x) Min = min(Min, i);
return Min;
}
long long max(long long x, long long y) { return x > y ? x : y; }
long long maxr(vector<long long> x) {
long long Max = -INFL;
for (auto i : x) Max = max(Max, i);
return Max;
}
void ex_gcd(long long a, long long b, long long &d, long long &x,
long long &y) {
if (!b)
d = a, x = 1, y = 0;
else
ex_gcd(b, a % b, d, y, x), y -= x * (a / b);
}
long long modinv(long long x) {
long long ret, tr1, tr2;
ex_gcd(x, MOD, tr1, ret, tr2);
while (ret < 0) ret += MOD;
return ret;
}
pair<pair<int, int>, int> a[200001];
set<pair<int, int> > val;
bool ansone = true;
int ans[2][200001];
struct node {
int l, r;
int lc, rc;
int i;
};
node seg[1000001];
void add(int p, int l, int r, int d) {
if (seg[p].l >= l && seg[p].r <= r) {
seg[p].i += d;
} else {
if (l < (seg[p].l + seg[p].r) / 2) add(seg[p].lc, l, r, d);
if (r > (seg[p].l + seg[p].r) / 2) add(seg[p].rc, l, r, d);
int x = seg[p].lc, y = seg[p].rc;
seg[p].i = min(seg[x].i, seg[y].i);
}
}
int mini(int p, int l, int r) {
if (seg[p].l >= l && seg[p].r <= r)
return seg[p].i;
else {
int ret = INF;
if (l < (seg[p].l + seg[p].r) / 2) ret = min(ret, mini(seg[p].lc, l, r));
if (r > (seg[p].l + seg[p].r) / 2) ret = min(ret, mini(seg[p].rc, l, r));
return ret;
}
}
void build(int p, int l, int r) {
seg[p].l = l, seg[p].r = r;
seg[p].lc = 0, seg[p].rc = 0;
seg[p].i = 0;
if (l + 1 < r) {
seg[p].lc = 2 * p, seg[p].rc = 2 * p + 1;
build(2 * p, l, (l + r) / 2);
build(2 * p + 1, (l + r) / 2, r);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
int i, j;
cin >> n;
for (i = 1; i <= n; i++)
cin >> a[i].first.first >> a[i].first.second, a[i].second = i;
sort(a + 1, a + n + 1);
build(1, 1, n + 1);
int cur = 1;
for (i = 1; i <= n; i++) {
while (cur <= n && a[cur].first.first <= i)
val.insert({a[cur].first.second, cur}), cur++;
int f = val.begin()->second;
val.erase(val.begin());
ans[0][a[f].second] = i, ans[1][a[f].second] = i;
add(1, i, i + 1, a[f].first.first);
}
for (i = 1; i <= n; i++) {
int pos1 = ans[0][a[i].second];
if (a[i].first.second > pos1 &&
mini(1, pos1 + 1, a[i].first.second + 1) <= pos1) {
for (j = 1; j <= n; j++) {
int pos2 = ans[0][a[j].second];
if (j != i && pos2 > pos1 && pos2 <= a[i].first.second &&
a[j].first.first <= pos1) {
int t = ans[1][a[i].second];
ans[1][a[i].second] = ans[1][a[j].second];
ans[1][a[j].second] = t;
break;
}
}
ansone = false;
break;
}
}
if (ansone) {
cout << "YES" << endl;
for (i = 1; i < n; i++) cout << ans[0][i] << " ";
cout << ans[0][n] << endl;
} else {
cout << "NO" << endl;
for (i = 1; i < n; i++) cout << ans[0][i] << " ";
cout << ans[0][n] << endl;
for (i = 1; i < n; i++) cout << ans[1][i] << " ";
cout << ans[1][n] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005;
int n, a[MX], b[MX], res[MX], ot[MX], f[MX];
vector<long long> pos[MX], del[MX];
set<pair<int, int> > st;
set<int> in;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
pos[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
for (int j : pos[i]) st.emplace(b[j], j);
f[i] = st.begin()->second;
res[f[i]] = i;
st.erase(st.begin());
}
for (int i = 1; i <= n; i++) {
if (in.size() && *in.rbegin() >= a[f[i]]) {
for (int i = 0; i < n; i++) ot[i] = res[i];
swap(ot[f[i]], ot[f[*in.rbegin()]]);
cout << "NO" << '\n';
for (int i = 0; i < n; i++) cout << res[i] << " ";
cout << '\n';
for (int i = 0; i < n; i++) cout << ot[i] << " ";
cout << '\n';
return 0;
}
in.insert(i);
del[b[f[i]]].push_back(i);
for (int j : del[i]) in.erase(j);
}
cout << "YES" << '\n';
for (int i = 0; i < n; i++) cout << res[i] << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int n, x, y;
int ans[200005];
vector<pair<int, int>> l[200005];
set<pair<int, int>> s;
pair<int, int> v[200005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
l[x].push_back({y, i});
v[i] = {x, y};
}
for (int i = 1; i <= n; i++) {
for (auto &j : l[i]) s.insert(j);
ans[s.begin()->second] = i;
s.erase(s.begin());
}
bool ok = 0;
for (int i = 1; i <= n; i++) {
for (auto &j : l[i]) s.insert(j);
if (s.size() > 1) {
auto it = s.begin();
it++;
if (ans[it->second] <= s.begin()->first) {
cout << "NO\n";
for (int j = 1; j <= n; j++) cout << ans[j] << " ";
cout << "\n";
swap(ans[s.begin()->second], ans[it->second]);
for (int j = 1; j <= n; j++) cout << ans[j] << " ";
ok = 1;
break;
}
}
s.erase(s.begin());
}
if (!ok) {
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353, N = (int)2e5 + 50;
struct Tree {
pair<int, int> dat[N * 4];
void init_dat() { fill(dat, dat + N * 4, pair<int, int>{-1, -1}); }
void update(int pos, int x, int l, int r, pair<int, int> p) {
int mid = (l + r) / 2;
if (l == r) {
dat[x] = p;
return;
}
if (pos <= mid)
update(pos, 2 * x + 1, l, mid, p);
else
update(pos, 2 * x + 2, mid + 1, r, p);
dat[x] = max(dat[2 * x + 1], dat[2 * x + 2]);
}
pair<int, int> query(int a, int b, int x, int l, int r) {
if (r < a || b < l) return {-1, -1};
int mid = (l + r) / 2;
if (a <= l && r <= b) return dat[x];
return max(query(a, b, 2 * x + 1, l, mid),
query(a, b, 2 * x + 2, mid + 1, r));
}
} tree;
struct rg {
int l, r, idx, loc;
};
int n;
rg rgs[N];
int res[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < (n); ++i) {
cin >> rgs[i].l >> rgs[i].r;
rgs[i].l--, rgs[i].r--;
rgs[i].idx = i;
}
set<int> S;
for (int i = 0; i < (n); ++i) S.insert(i);
sort(rgs, rgs + n, [](const rg &a, const rg &b) { return a.r < b.r; });
for (int i = 0; i < (n); ++i) {
auto it = S.lower_bound(rgs[i].l);
assert(it != S.end());
rgs[i].loc = *it;
S.erase(it);
}
for (int i = 0; i < (n); ++i) res[rgs[i].idx] = rgs[i].loc;
tree.init_dat();
sort(rgs, rgs + n, [](const rg &a, const rg &b) { return a.loc < b.loc; });
for (int i = 0; i < (n); ++i) {
pair<int, int> p = tree.query(rgs[i].l, rgs[i].r, 0, 0, n - 1);
if (p.first >= rgs[i].loc) {
cout << "NO\n";
for (int j = 0; j < (n); ++j) cout << res[j] + 1 << " ";
cout << '\n';
swap(res[rgs[i].idx], res[p.second]);
for (int j = 0; j < (n); ++j) cout << res[j] + 1 << " ";
cout << '\n';
return 0;
}
tree.update(rgs[i].loc, 0, 0, n - 1, {rgs[i].r, rgs[i].idx});
}
cout << "YES\n";
for (int j = 0; j < (n); ++j) cout << res[j] + 1 << " ";
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
clock_t start;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());
template <typename T>
void _F(const char *name, T arg1) {
cerr << name << " = " << arg1 << '\n';
}
template <typename T, typename... Args>
void _F(const char *names, T arg1, Args... args) {
const char *name = strchr(names, ',');
cerr.write(names, name - names) << " = " << arg1 << '\n';
_F(name + 2, args...);
}
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &q) {
in >> q.first >> q.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &q) {
out << q.first << " " << q.second;
return out;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(pair<T1, T2> p1, pair<T1, T2> p2) {
return {p1.first + p2.first, p1.second + p2.second};
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> p1, pair<T1, T2> p2) {
return {p1.first - p2.first, p1.second - p2.second};
}
const long long N = 2e5 + 10;
long long l[N], r[N], ans[N], tmp[N], pos[N];
long long n;
vector<pair<long long, long long> > Q[N];
struct segm {
long long seg[4 * N];
segm() {
for (long long i = 0; i < 4 * N; i++) {
seg[i] = -1;
}
}
void build(long long s, long long e, long long v) {
if (s == e)
seg[v] = ans[s];
else {
long long mid = (s + e) / 2;
build(s, mid, 2 * v), build(mid + 1, e, 2 * v + 1);
long long left = 2 * v, right = 2 * v + 1;
if (r[seg[left]] < r[seg[right]]) swap(left, right);
seg[v] = seg[left];
}
}
long long query(long long s, long long e, long long v, long long ll,
long long rr) {
if (ll > e || rr < s)
return -1;
else if (ll <= s && rr >= e)
return seg[v];
else {
long long mid = (s + e) / 2;
long long left = query(s, mid, 2 * v, ll, rr);
long long right = query(mid + 1, e, 2 * v + 1, ll, rr);
if (left == -1) return right;
if (right == -1) return left;
if (r[left] < r[right]) swap(left, right);
return left;
}
}
} st;
void PrintAns() {
for (long long i = 1; i <= n; i++) tmp[ans[i]] = i;
for (long long i = 1; i <= n; i++) cout << tmp[i] << " ";
cout << '\n';
}
void solve() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
Q[l[i]].push_back(make_pair(r[i], i));
}
for (long long i = 1; i <= n; i++) sort((Q[i]).begin(), (Q[i]).end());
set<pair<long long, long long> > open;
for (long long i = 1; i <= n; i++) {
while ((long long)((Q[i]).size())) {
open.insert(Q[i].back());
Q[i].pop_back();
}
while ((long long)((open).size()) && (*begin(open)).first < i) {
open.erase(begin(open));
}
ans[i] = (*begin(open)).second;
pos[ans[i]] = i;
open.erase(begin(open));
}
st.build(1, n, 1);
for (long long i = 2; i <= n; i++) {
long long j = st.query(1, n, 1, l[ans[i]], i - 1);
if (j != -1 && r[j] >= i) {
cout << "NO" << '\n';
PrintAns();
swap(ans[i], ans[pos[j]]);
PrintAns();
return;
}
}
cout << "YES" << '\n';
PrintAns();
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
start = clock();
cout << fixed << setprecision(20);
for (long long i = 1; i <= t; ++i) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
int A[200009], B[200009], ans[200009], R[200009];
vector<int> Q[200009];
int main() {
int N;
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d%d", &A[i], &B[i]);
Q[A[i]].push_back(i);
}
priority_queue<pii> pq;
for (int i = 1; i <= N; i++) {
for (auto& it : Q[i]) pq.push({-B[it], it});
int x = pq.top().second;
pq.pop();
ans[x] = i;
R[i] = x;
}
int x = -1, y = -1;
set<int> S = {-1, N + 1};
for (int i = 1; i <= N; i++) {
for (auto& it : Q[i]) {
pq.push({-B[it], it});
S.insert(ans[it]);
}
auto it = S.find(i);
if (*next(it) <= B[R[i]]) x = R[i], y = R[*next(it)];
if (A[R[i]] <= *prev(it)) x = R[i], y = R[*prev(it)];
while (pq.size() && -pq.top().first == i) {
S.erase(ans[pq.top().second]);
pq.pop();
}
}
if (x == -1) {
puts("YES");
for (int i = 1; i <= N; i++) printf("%d ", ans[i]);
} else {
puts("NO");
for (int i = 1; i <= N; i++) printf("%d ", ans[i]);
puts("");
swap(ans[x], ans[y]);
for (int i = 1; i <= N; i++) printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int inf;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T, class T2>
int chkmin(T &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <class T, class T2>
int chkmax(T &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T, class T2>
T mmin(T a, T2 b) {
return a < b ? a : b;
}
template <class T, class T2>
T mmax(T a, T2 b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
int dcmp(T a, T b) {
return a > b;
}
template <int *a>
int cmp_a(int first, int second) {
return a[first] < a[second];
}
struct __INIT__ {
__INIT__() { memset(&inf, 0x3f, sizeof(inf)); }
} __INIT___;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(char &first) {
while ((first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
first == '\n' || first == '\r')
;
return first != EOF;
}
inline bool read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
;
if (*first == EOF) return 0;
while (!(*first == '\n' || *first == ' ' || *first == '\r' || *first == EOF))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*first = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
return read(first) && read(second...);
}
template <typename A>
inline bool write(A first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char first) {
putc(first);
return 0;
}
inline bool write(const char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
inline bool write(char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
return write(first) || write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
int l[200005], r[200005];
vector<pair<int, int> > to[200005];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
int n;
int a[200005], ins[400005], ym[200005];
int stk[400005], t, vis[400005];
set<int> ya, yb;
int w[400005];
void find_cir(int first, int second) {
write("NO\n");
for (int i = 1; i <= n; ++i) write(a[i], i == n ? '\n' : ' ');
stk[++t] = second;
int m;
for (int i = t; i; --i)
if (stk[i] == first) {
for (int j = i; j <= t; ++j) w[j - i] = stk[j];
m = t - i + 1;
}
for (int i = 0; i < m; ++i)
if (w[i] <= n) {
a[w[i]] ^= (w[(i + 1) % m] - n) ^ (w[(i + m - 1) % m] - n);
}
for (int i = 1; i <= n; ++i) write(a[i], i == n ? '\n' : ' ');
exit(0);
}
void dfs(int first) {
if (first <= n) {
auto it = yb.lower_bound(l[first]);
while (it != yb.end() && *it <= r[first]) {
if (*it == a[first]) {
++it;
} else {
find_cir(*it + n, first);
}
}
vis[first] = 1;
ins[first] = 1;
stk[++t] = first;
while (1) {
it = ya.lower_bound(l[first]);
if (it != ya.end() && *it == a[first]) ++it;
if (it != ya.end() && *it <= r[first])
dfs(*it + n);
else
break;
}
ins[first] = 0;
--t;
} else {
if (ins[ym[first - n]]) {
find_cir(ym[first - n], first);
} else {
stk[++t] = first;
ins[first] = 1;
vis[first] = 1;
ya.erase(first - n);
yb.insert(first - n);
dfs(ym[first - n]);
yb.erase(first - n);
ins[first] = 0;
--t;
}
}
}
signed main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(l[i], r[i]);
to[l[i]].push_back(make_pair(r[i], i));
}
for (int i = 1; i <= n; ++i) {
for (auto j : to[i]) pq.push(j);
a[pq.top().second] = i;
ym[i] = pq.top().second;
pq.pop();
}
for (int i = 1; i <= n; ++i) ya.insert(i);
for (int i = 1; i <= n; ++i)
if (!vis[i]) dfs(i);
write("YES\n");
for (int i = 1; i <= n; ++i) write(a[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 2e5 + 10;
int tree[maxn << 2], id[maxn << 2];
int ans[maxn], pos[maxn], L[maxn], R[maxn];
int n;
vector<pair<int, int> > v[maxn];
void build(int o, int l, int r) {
if (l == r) {
tree[o] = L[pos[l]];
id[o] = l;
return;
}
int mid = l + r >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
if (tree[o << 1] < tree[o << 1 | 1])
id[o] = id[o << 1];
else
id[o] = id[o << 1 | 1];
tree[o] = min(tree[o << 1 | 1], tree[o << 1]);
}
pair<int, int> query(int o, int l, int r, int x, int y) {
if (x <= l && y >= r) return make_pair(tree[o], id[o]);
int mid = l + r >> 1;
pair<int, int> tmp1 = make_pair(-1, -1), tmp2 = make_pair(-1, -1);
if (mid >= x) tmp1 = query(o << 1, l, mid, x, y);
if (mid < y) tmp2 = query(o << 1 | 1, mid + 1, r, x, y);
if (tmp1.first == -1) return tmp2;
if (tmp2.first == -1) return tmp1;
if (tmp1.first > tmp2.first)
return tmp2;
else
return tmp1;
}
void print() {
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &L[i], &R[i]);
v[L[i]].push_back(make_pair(R[i], i));
}
set<pair<int, int> > s;
for (int i = 1; i <= n; i++) {
s.insert(v[i].begin(), v[i].end());
ans[(*s.begin()).second] = i;
pos[i] = (*s.begin()).second;
s.erase(s.begin());
}
build(1, 1, n);
for (int i = 1; i <= n; i++) {
pair<int, int> tmp = query(1, 1, n, i + 1, R[pos[i]]);
if (i + 1 > R[pos[i]]) continue;
if (tmp.first <= i) {
printf("NO\n");
print();
swap(ans[pos[tmp.second]], ans[pos[i]]);
print();
return 0;
}
}
printf("YES\n");
print();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
int n, a[N], b[N], p[N], pa[N];
vector<pair<int, int>> g[N];
void output() {
static int out[N];
for (int i = 1; i <= n; ++i) {
out[p[i]] = i;
}
for (int i = 1; i <= n; ++i) {
cout << out[i] << " \n"[i == n];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i] >> b[i];
g[a[i]].emplace_back(b[i], i);
}
set<pair<int, int>> st;
for (int i = 1; i <= n; ++i) {
st.insert(g[i].begin(), g[i].end());
p[i] = st.begin()->second;
st.erase(st.begin());
}
set<int> ps;
for (int i = 1; i <= n; ++i) ps.insert(i);
for (int i = 1; i <= n; ++i) {
if (!ps.count(i)) continue;
function<bool(int)> dfs;
dfs = [&](int u) -> bool {
int ut = p[u], v;
for (auto it = ps.lower_bound(a[ut]);
it != ps.end() && (v = *it) <= b[ut]; it = ps.upper_bound(v)) {
if (v == u) continue;
if (pa[v]) {
cout << "NO\n";
output();
for (; u != v; u = pa[u]) {
p[u] = p[pa[u]];
}
p[v] = ut;
output();
return true;
}
pa[v] = u;
if (dfs(v)) return true;
pa[v] = 0;
ps.erase(v);
}
return false;
};
pa[i] = i;
if (dfs(i)) return 0;
pa[i] = 0;
ps.erase(i);
}
cout << "YES\n";
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
priority_queue<pair<int, int> > Q;
int id[maxn], reid[maxn];
int idtonum[maxn];
int lef[maxn], rght[maxn];
struct node {
int l, r, id;
} Node[maxn];
bool cmp(node a, node b) {
if (a.l == b.l) return a.r < b.r;
return a.l < b.l;
}
queue<int> output;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &Node[i].l, &Node[i].r), Node[i].id = i, lef[i] = Node[i].l,
rght[i] = Node[i].r;
sort(Node + 1, Node + 1 + n, cmp);
int pos = 1;
for (int i = 1; i <= n; i++) {
while (Node[pos].l == i) {
Q.push(make_pair(-Node[pos].r, Node[pos].id));
pos++;
}
int fval, sval;
fval = -Q.top().first;
sval = Q.top().second;
Q.pop();
id[sval] = i;
reid[i] = sval;
idtonum[sval] = i;
}
for (int i = 1; i <= n; i++) output.push(id[i]);
bool flag = true;
for (int i = 1; i < n; i++) {
int numrgh = rght[reid[i]];
int numlef = lef[reid[i + 1]];
if (i >= numlef && i + 1 <= numrgh) {
swap(id[reid[i]], id[reid[i + 1]]);
flag = false;
break;
}
}
if (flag) {
sort(Node + 1, Node + 1 + n, cmp);
for (int i = 1; i < n; i++) {
int numrgh = min(Node[i].r, Node[i + 1].r);
int numlef = max(Node[i + 1].l, Node[i].l);
int idfst = id[Node[i].id], idscd = id[Node[i + 1].id];
if (numlef < numrgh && idfst >= numlef && idfst <= numrgh &&
idscd >= numlef && idscd <= numrgh) {
swap(id[Node[i].id], id[Node[i + 1].id]);
flag = false;
break;
}
}
}
if (flag) {
cout << "YES" << endl;
int outputflag = false;
while (!output.empty()) {
if (outputflag) cout << " ";
outputflag = true;
cout << output.front();
output.pop();
}
cout << endl;
} else {
cout << "NO" << endl;
int outputflag = false;
while (!output.empty()) {
if (outputflag) cout << " ";
outputflag = true;
cout << output.front();
output.pop();
}
cout << endl;
for (int i = 1; i <= n; i++) {
if (i != 1) cout << " ";
cout << id[i];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[206000], b[206000], ans[206000], p[206000];
vector<pair<int, int> > v[206000];
struct node {
int id, val;
} tree[1009000];
void build(int i, int l, int r) {
if (l == r) {
tree[i].id = l;
tree[i].val = a[p[l]];
return;
}
int mid = (l + r) >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
if (tree[i << 1].val < tree[i << 1 | 1].val)
tree[i] = tree[i << 1];
else
tree[i] = tree[i << 1 | 1];
}
node q;
void query(int i, int l, int r, int x, int y) {
if (r < x || l > y) return;
if (r <= y && x <= l) {
if (tree[i].val < q.val) q = tree[i];
return;
}
int mid = (l + r) >> 1;
query(i << 1, l, mid, x, y);
query(i << 1 | 1, mid + 1, r, x, y);
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
int l, r;
scanf("%d%d", &l, &r);
a[i] = l;
b[i] = r;
v[l].push_back(make_pair(r, i));
}
set<pair<int, int> > st;
for (int i = 1; i <= n; ++i) {
st.insert(v[i].begin(), v[i].end());
int y = (*st.begin()).second;
st.erase(st.begin());
ans[y] = i;
p[i] = y;
}
build(1, 1, n);
for (int i = 1; i <= n; ++i) {
if (i + 1 > b[p[i]]) continue;
q.val = 99999999;
query(1, 1, n, i + 1, b[p[i]]);
if (q.val <= i) {
cout << "NO" << endl;
for (int j = 1; j <= n; ++j) printf("%d%c", ans[j], j == n ? '\n' : ' ');
swap(ans[p[i]], ans[p[q.id]]);
for (int j = 1; j <= n; ++j) printf("%d%c", ans[j], j == n ? '\n' : ' ');
return 0;
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; ++i) printf("%d%c", ans[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int N = 2e5 + 5;
const int M = 3005;
const int inf = 0x3f3f3f3f;
const int mod = 300;
const double eps = 1e-9;
const long double pi = acos(-1.0L);
long long read() {
long long x = 0, t = 1;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') t = -1;
while (isdigit(ch)) {
x = 10 * x + ch - '0';
ch = getchar();
}
return x * t;
}
struct node {
int x, y;
node() {}
node(int X, int Y) {
x = X;
y = Y;
}
friend bool operator<(node t1, node t2) { return t1.x > t2.x; }
};
int c[N << 2], L[N], R[N], id[N], pos[N];
vector<node> a[N];
priority_queue<node> q;
void build(int i, int l, int r) {
if (l == r) {
c[i] = L[id[l]];
return;
}
int mid = l + r >> 1;
build((i << 1), l, mid);
build((i << 1 | 1), mid + 1, r);
c[i] = min(c[(i << 1)], c[(i << 1 | 1)]);
}
int query(int i, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) return c[i];
int mid = l + r >> 1;
int t1 = inf, t2 = inf;
if (mid >= ll) t1 = query((i << 1), l, mid, ll, rr);
if (mid < rr) t2 = query((i << 1 | 1), mid + 1, r, ll, rr);
return min(t1, t2);
}
int main() {
int n = read();
for (int i = 1; i <= n; i++) {
L[i] = read();
R[i] = read();
a[L[i]].push_back(node(R[i], i));
}
for (int i = 1; i <= n; i++) {
for (auto x : a[i]) q.push(x);
id[i] = q.top().y;
pos[id[i]] = i;
q.pop();
}
build(1, 1, n);
for (int i = 1; i <= n; i++) {
int tmp = inf;
if (i < R[id[i]]) tmp = query(1, 1, n, i + 1, R[id[i]]);
if (tmp <= i) {
int j;
for (j = i + 1; j <= R[id[i]]; j++)
if (L[id[j]] <= i) break;
printf("NO\n");
for (int j = 1; j <= n; j++) printf("%d%c", pos[j], j == n ? '\n' : ' ');
swap(pos[id[i]], pos[id[j]]);
for (int j = 1; j <= n; j++) printf("%d%c", pos[j], j == n ? '\n' : ' ');
return 0;
}
}
printf("YES\n");
for (int j = 1; j <= n; j++) printf("%d%c", pos[j], j == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int a[200005], b[200005];
int label[200005];
int label2[200005];
void perfectMatch() {
deque<pair<pair<int, int>, int>> v;
for (int i = 1; i <= N; i++) v.push_back({{a[i], b[i]}, i});
sort(v.begin(), v.end());
multiset<pair<int, int>> mst;
for (int i = 1; i <= N; i++) {
while ((int)v.size() > 0 && v[0].first.first <= i) {
mst.insert({v[0].first.second, v[0].second});
v.pop_front();
}
label2[i] = mst.begin()->second;
label[mst.begin()->second] = i;
mst.erase(mst.find(*mst.begin()));
}
}
set<int> active;
int vis[200005];
int from[200005];
int ans[200005];
void foundAnother(int node, int nextNode) {
vector<int> v;
int cur = node;
while (cur != label2[nextNode]) {
v.push_back(cur);
cur = from[cur];
}
reverse(v.begin(), v.end());
v.push_back(label2[nextNode]);
reverse(v.begin(), v.end());
cout << "NO" << endl;
for (int i = 1; i <= N; i++) cout << label[i] << ' ';
cout << endl;
for (int i = 1; i <= N; i++) ans[i] = label[i];
int temp = ans[v.back()];
for (int i = 0; i < (int)v.size(); i++) swap(temp, ans[v[i]]);
for (int i = 1; i <= N; i++) cout << ans[i] << ' ';
cout << endl;
exit(0);
}
void dfs(int node) {
vis[node] = 1;
queue<int> toRemove;
for (;;) {
auto it = active.lower_bound(a[node]);
if (it != active.end() && *it == label[node]) {
toRemove.push(*it);
it++;
}
if (it == active.end() || *it > b[node]) break;
if (vis[label2[*it]] == 1) foundAnother(node, *it);
toRemove.push(*it);
if (vis[label2[*it]] == 2) continue;
from[label2[*it]] = node;
dfs(label2[*it]);
}
while (!toRemove.empty()) {
if (active.count(toRemove.front())) active.erase(toRemove.front());
toRemove.pop();
}
vis[node] = 2;
}
int main() {
cin >> N;
for (int i = 1; i <= N; i++) cin >> a[i] >> b[i];
perfectMatch();
for (int i = 1; i <= N; i++) active.insert(i);
for (int i = 1; i <= N; i++)
if (vis[i] == 0) dfs(i);
cout << "YES" << endl;
for (int i = 1; i <= N; i++) cout << label[i] << ' ';
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long int INF = 1e18;
long long int po(long long int a, long long int b) {
long long int re = 1;
while (b) {
if (b % 2 == 1) {
re = (re * a);
re %= mod;
}
a = (a * a);
a %= mod;
b >>= 1;
}
return re;
}
struct arr {
int i;
int a, b;
};
bool che(arr a, arr b) {
if (a.a == b.a) return a.b < b.b;
return a.a < b.a;
}
pair<int, int> t[800100];
void update(int v, int tl, int tr, int pos, int new_val, int p) {
if (tl == tr) {
t[v] = make_pair(new_val, p);
} else {
int tm = (tl + tr) / 2;
if (pos <= tm)
update(v * 2, tl, tm, pos, new_val, p);
else
update(v * 2 + 1, tm + 1, tr, pos, new_val, p);
t[v] = min(t[2 * v], t[2 * v + 1]);
}
return;
}
pair<int, int> sum(int v, int tl, int tr, int l, int r) {
if (l > r) return make_pair(1000000, 0);
if (l == tl && r == tr) {
return t[v];
}
int tm = (tl + tr) / 2;
return min(sum(v * 2, tl, tm, l, min(r, tm)),
sum(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
int main() {
int test = 1;
while (test--) {
int n;
cin >> n;
arr a[n];
int backup[n];
for (int i = (0); i < (n); i++) {
cin >> a[i].a >> a[i].b;
a[i].i = i;
backup[i] = a[i].a;
}
sort(a, a + n, che);
pair<int, int> u;
set<pair<int, int> > fil;
int ar[n], br[n];
int j = 0;
for (int i = (0); i < (n); i++) {
while (j < n && a[j].a == i + 1) {
fil.insert(make_pair(a[j].b, a[j].i));
j++;
}
u = *fil.begin();
fil.erase(u);
ar[u.second] = i + 1;
br[u.second] = i + 1;
update(1, 0, n, i + 1, backup[u.second], u.second);
}
bool f = 0;
for (int i = (0); i < (n); i++) {
u = sum(1, 0, n, ar[a[i].i] + 1, a[i].b);
if (u.first <= ar[a[i].i]) {
swap(br[a[i].i], br[u.second]);
f = 1;
break;
}
}
if (f) {
cout << "NO\n";
for (int i = (0); i < (n); i++) cout << ar[i] << ' ';
cout << '\n';
for (int i = (0); i < (n); i++) cout << br[i] << ' ';
} else {
cout << "YES\n";
for (int i = (0); i < (n); i++) cout << ar[i] << ' ';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 2e5 + 5;
tuple<int, int, int> P[N];
void output(vector<int> &res, int n) {
vector<int> a(n);
for (int i = 0; i < res.size(); i++) {
a[res[i]] = i + 1;
}
for (int i = 0; i < n; i++) {
if (i != 0) cout << " ";
cout << a[i];
}
cout << "\n";
}
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
P[i] = {a - 1, b - 1, i};
}
sort(P, P + n);
int pos = 0;
int p = 0;
set<tuple<int, int, int>> ss;
vector<int> res;
while (pos < n) {
while (p < n && get<0>(P[p]) <= pos) {
ss.insert({get<1>(P[p]), get<2>(P[p]), get<0>(P[p])});
p++;
}
int l, r, idx;
tie(r, idx, l) = *ss.begin();
res.push_back(idx);
ss.erase(ss.begin());
pos++;
}
vector<int> res2 = res;
bool hasT = false;
ss.clear();
set<int> sa;
vector<int> idxToP(n);
for (int i = 0; i < n; i++) {
idxToP[get<2>(P[i])] = i;
};
for (int i = 0; i < n; i++) {
int p = idxToP[res[i]];
if (ss.size() > 0)
;
while (ss.size() > 0 && get<0>(*ss.begin()) < i) {
int t1 = get<2>(*ss.begin());
;
sa.erase(t1);
ss.erase(ss.begin());
}
if (sa.size() > 0 && *sa.rbegin() >= get<0>(P[p])) {
hasT = true;
int l = *sa.rbegin();
swap(res2[i], res2[l]);
break;
} else {
ss.insert({get<1>(P[p]), p, i});
sa.insert(i);
}
}
if (hasT) {
;
;
cout << "NO\n";
output(res, n);
output(res2, n);
} else {
cout << "YES\n";
output(res, n);
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(10);
int T = 1;
for (int i = 1; i <= T; i++) {
solve();
}
cout.flush();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 10;
const int maxn = 2e5 + 10;
int n, ans[maxn], root, topt, lc[maxn];
struct da {
int a, b, id;
} q[maxn];
struct daa {
int lc, rc, mi, id;
} a[4 * maxn];
priority_queue<pair<int, int> > qq;
inline bool cmp(da aa, da bb) {
if (aa.a == bb.a) return aa.b < bb.b;
return aa.a < bb.a;
}
void build_tree(int &n, int l, int r) {
n = ++topt;
a[n].mi = inf;
if (l == r) return;
int mid = (l + r) >> 1;
build_tree(a[n].lc, l, mid);
build_tree(a[n].rc, mid + 1, r);
}
void updata(int n) {
if (a[a[n].lc].mi < a[a[n].rc].mi)
a[n].mi = a[a[n].lc].mi, a[n].id = a[a[n].lc].id;
else
a[n].mi = a[a[n].rc].mi, a[n].id = a[a[n].rc].id;
}
void tree_add(int n, int l, int r, int lc, int k, int idd) {
if (l == r) {
a[n].mi = k;
a[n].id = idd;
return;
}
int mid = (l + r) >> 1;
if (lc <= mid)
tree_add(a[n].lc, l, mid, lc, k, idd);
else
tree_add(a[n].rc, mid + 1, r, lc, k, idd);
updata(n);
}
daa qury(int n, int L, int R, int l, int r) {
if (L == l && R == r) return a[n];
int mid = (L + R) >> 1;
if (r <= mid)
return qury(a[n].lc, L, mid, l, r);
else if (l >= mid + 1)
return qury(a[n].rc, mid + 1, R, l, r);
else {
daa now1 = qury(a[n].lc, L, mid, l, mid);
daa now2 = qury(a[n].rc, mid + 1, R, mid + 1, r);
if (now1.mi < now2.mi)
return now1;
else
return now2;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &q[i].a, &q[i].b), q[i].id = i;
sort(q + 1, q + n + 1, cmp);
build_tree(root, 1, n);
int p = 0;
for (int i = 1; i <= n; i++) {
while (p + 1 <= n && q[p + 1].a <= i) p++, qq.push(make_pair(-q[p].b, p));
pair<int, int> now = qq.top();
qq.pop();
ans[q[now.second].id] = i;
lc[i] = now.second;
}
for (int i = 1; i <= n; i++) tree_add(root, 1, n, i, q[lc[i]].a, q[lc[i]].id);
for (int i = 1; i <= n; i++) {
tree_add(root, 1, n, i, inf, 0);
daa now = qury(root, 1, n, i, q[lc[i]].b);
if (now.mi <= i) {
printf("NO\n");
for (int j = 1; j <= n; j++)
printf("%d%c", ans[j], (j == n ? '\n' : ' '));
swap(ans[q[lc[i]].id], ans[now.id]);
for (int j = 1; j <= n; j++)
printf("%d%c", ans[j], (j == n ? '\n' : ' '));
return 0;
}
tree_add(root, 1, n, i, q[i].a, q[i].id);
}
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], (i == n ? '\n' : ' '));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 998244353;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
ll binpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
ll modInv(ll a) { return binpow(a, MOD - 2); }
const double PI = acos(-1);
const int INF = 0x3f3f3f3f;
const int NINF = 0xc0c0c0c0;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll NINFLL = 0xc0c0c0c0c0c0c0c0;
const int mxN = 200001;
pair<int, int> arr[mxN];
pair<pair<int, int>, int> nn[mxN];
int ans[mxN];
int rans[mxN];
int n;
int sgmin[2 * mxN];
int sgmax[2 * mxN];
void init() {
for (int i = (n); i < (2 * n); ++i) {
sgmin[i] = arr[rans[i - n]].first;
sgmax[i] = arr[rans[i - n]].second;
}
for (int i = (n)-1; i >= (1); --i) {
sgmin[i] = min(sgmin[i << 1], sgmin[i << 1 | 1]);
sgmax[i] = max(sgmax[i << 1], sgmax[i << 1 | 1]);
}
}
int qmax(int l, int r) {
r++;
int res = -1;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = max(res, sgmax[l++]);
if (r & 1) res = max(res, sgmax[--r]);
}
return res;
}
int qmin(int l, int r) {
r++;
int res = INF;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, sgmin[l++]);
if (r & 1) res = min(res, sgmin[--r]);
}
return res;
}
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
cin.tie(0)->sync_with_stdio(0);
cin >> n;
for (int i = (0); i < (n); ++i) {
cin >> arr[i].first >> arr[i].second;
arr[i].first--;
arr[i].second--;
nn[i].first = arr[i];
nn[i].second = i;
}
sort(nn, nn + n);
int idx = 0;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
for (int i = (0); i < (n); ++i) {
while (idx < n && nn[idx].first.first == i) {
pq.push({nn[idx].first.second, nn[idx].second});
idx++;
}
ans[pq.top().second] = i;
rans[i] = pq.top().second;
pq.pop();
}
pair<int, int> swp = {-1, -1};
init();
for (int i = (0); i < (n); ++i) {
int l = arr[rans[i]].first;
int r = arr[rans[i]].second;
if (qmax(l, i - 1) >= i) {
for (int j = (l); j < (i); ++j) {
if (arr[rans[j]].second >= i) {
swp = {rans[j], rans[i]};
break;
}
}
break;
}
if (qmin(i + 1, r) <= i) {
for (int j = (i + 1); j < (r + 1); ++j) {
if (arr[rans[j]].first <= i) {
swp = {rans[j], rans[i]};
break;
}
}
break;
}
}
if (swp.first == swp.second) {
cout << "YES\n";
for (int i = (0); i < (n); ++i) {
cout << (ans[i] + 1) << " ";
}
} else {
cout << "NO\n";
for (int i = (0); i < (n); ++i) {
cout << (ans[i] + 1) << " ";
}
cout << "\n";
swap(ans[swp.first], ans[swp.second]);
for (int i = (0); i < (n); ++i) {
cout << (ans[i] + 1) << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LEN = 100000;
struct fastio {
int it, len;
char s[LEN + 5];
fastio() { it = len = 0; }
char get() {
if (it < len) return s[it++];
it = 0, len = fread(s, 1, LEN, stdin);
return len ? s[it++] : EOF;
}
bool notend() {
char c;
for (c = get(); c == ' ' || c == '\n' || c == '\r'; c = get())
;
if (it) it--;
return c != EOF;
}
void put(char c) {
if (it == LEN) fwrite(s, 1, LEN, stdout), it = 0;
s[it++] = c;
}
void flush() { fwrite(s, 1, it, stdout); }
} buff;
inline int getint() {
char c;
int res = 0, sig = 1;
for (c = buff.get(); c < '0' || c > '9'; c = buff.get())
if (c == '-') sig = -1;
for (; c >= '0' && c <= '9'; c = buff.get()) res = res * 10 + (c - '0');
return sig * res;
}
inline long long getll() {
char c;
long long res = 0, sig = 1;
for (c = buff.get(); c < '0' || c > '9'; c = buff.get())
if (c == '-') sig = -1;
for (; c >= '0' && c <= '9'; c = buff.get()) res = res * 10 + (c - '0');
return sig * res;
}
int n;
vector<int> ans1, ans2;
struct Info {
int a, b, id;
bool operator<(const Info &x) const {
return make_pair(a, b) < make_pair(x.a, x.b);
}
} m[200005], chk[200005];
bool cmpid(Info x, Info y) { return x.id < y.id; }
int t[18][200005];
int qmin(int l, int r) {
if (l > r) return n + 1;
int ro = 31 - __builtin_clz(r - l);
return min(t[ro][l], t[ro][r - (1 << ro) + 1]);
}
int main() {
n = getint();
ans1.resize(n + 1);
ans2.resize(n + 1);
for (int i = 1; i <= n; i++) {
m[i].a = getint(), m[i].b = getint(), m[i].id = i;
}
sort(m + 1, m + n + 1);
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
que;
int k = 1;
for (int i = 1; i <= n; i++) {
while (k <= n && m[k].a == i) {
que.push(make_pair(m[k].b, m[k].id));
k++;
}
ans1[que.top().second] = i;
que.pop();
}
ans2 = ans1;
sort(m + 1, m + n + 1, cmpid);
for (int i = 1; i <= n; i++) chk[ans1[i]] = (Info){m[i].a, m[i].b, i};
for (int i = 1; i <= n; i++) t[0][i] = chk[i].a;
for (int i = 1; i <= 17; i++) {
for (int j = 1; j + (1 << i) - 1 <= n; j++) {
t[i][j] = min(t[i - 1][j], t[i - 1][j + (1 << (i - 1))]);
}
}
bool ok = true;
for (int i = n; i >= 1; i--) {
if (chk[i].b == i) continue;
int mini = qmin(i + 1, chk[i].b);
if (mini > i) continue;
for (int j = i + 1; j <= chk[i].b; j++) {
if (chk[j].a <= i) {
swap(ans2[chk[i].id], ans2[chk[j].id]);
break;
}
}
ok = false;
break;
}
if (ok) {
puts("YES");
for (int i = 1; i <= n; i++) printf("%d%c", ans1[i], i == n ? '\n' : ' ');
} else {
puts("NO");
for (int i = 1; i <= n; i++) printf("%d%c", ans1[i], i == n ? '\n' : ' ');
for (int i = 1; i <= n; i++) printf("%d%c", ans2[i], i == n ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int K = 22;
namespace SP {
int p[N];
int sp[K][N];
int n;
vector<int> a;
void run() {
for (int i = 0; i < n; i++) {
sp[0][i] = i;
}
for (int i = 0; i + 1 < K; i++) {
for (int j = 0; j + (2 << i) <= n; j++) {
if (a[sp[i][j]] > a[sp[i][j + (1 << i)]]) {
sp[i + 1][j] = sp[i][j + (1 << i)];
} else {
sp[i + 1][j] = sp[i][j];
}
}
}
p[1] = 0;
for (int i = 2; i <= n; i++) {
p[i] = p[i / 2] + 1;
}
}
void init(vector<int> a_) {
a = a_;
n = (int)a.size();
run();
}
int min(int l, int r) {
int pw = p[r - l];
int f = sp[pw][l];
int s = sp[pw][r - (1 << pw)];
if (a[f] < a[s])
return f;
else
return s;
}
} // namespace SP
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
vector<int> b(n);
vector<vector<pair<int, int>>> op(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
a[i]--;
b[i]--;
op[a[i]].push_back({b[i], i});
}
vector<int> p(n);
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
q;
for (int i = 0; i < n; i++) {
for (auto t : op[i]) {
q.push(t);
}
auto tp = q.top();
q.pop();
p[tp.second] = i;
while (!q.empty() && q.top().first == i) {
q.pop();
}
}
vector<int> wr(n);
vector<int> pa(n);
for (int i = 0; i < n; i++) {
pa[p[i]] = a[i];
wr[p[i]] = i;
}
SP::init(pa);
for (int i = 0; i < n; i++) {
if (p[i] == b[i]) continue;
int vl = SP::min(p[i] + 1, b[i] + 1);
if (a[wr[vl]] <= p[i]) {
cout << "NO\n";
for (auto t : p) {
cout << t + 1 << ' ';
}
cout << '\n';
swap(p[i], p[wr[vl]]);
for (auto t : p) {
cout << t + 1 << ' ';
}
cout << '\n';
return 0;
}
}
cout << "YES\n";
for (auto t : p) {
cout << t + 1 << ' ';
}
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210000;
vector<int> arr[maxn];
vector<int> parent(maxn);
vector<int> siz(maxn, 1);
vector<int> max_rep(maxn, -1);
int find_rep(int v) {
if (parent[v] == v) return v;
return parent[v] = find_rep(parent[v]);
}
void union_set(int a, int b) {
int ra = find_rep(a);
int rb = find_rep(b);
if (ra != rb) {
if (siz[ra] < siz[rb]) swap(ra, rb);
parent[rb] = ra;
int mx = max(max_rep[ra], max_rep[rb]);
max_rep[ra] = max_rep[rb] = mx;
siz[ra] += siz[rb];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
for (int i = 1; i < maxn; i++) parent[i] = i, max_rep[i] = i;
int n;
cin >> n;
vector<pair<int, int>> a(n);
map<pair<int, int>, queue<int>> ans;
for (auto& i : a)
cin >> i.first >> i.second, arr[i.second].emplace_back(i.first);
for (int i = 1; i <= n; i++) sort(arr[i].begin(), arr[i].end());
vector<pair<int, int>> pr(n);
vector<int> b(n);
for (int i = 1; i <= n; i++)
for (int& k : arr[i]) {
int x = max_rep[find_rep(k)];
union_set(x, x + 1);
assert(x <= i);
ans[{k, i}].push(x);
}
for (int i = 0; i < n; i++) {
b[i] = ans[a[i]].front();
ans[a[i]].pop();
pr[b[i] - 1] = a[i];
}
map<pair<int, int>, int> mp;
for (auto& k : a) {
if (mp[k]) {
cout << "NO\n";
int index1 = -1, index2 = -1;
for (int i = 0; i < n; i++) {
if (a[i] == k) {
if (index1 == -1) {
index1 = i;
continue;
}
if (index1 != -1 && index2 == -1)
index2 = i;
else
break;
}
}
for (int i = 0; i < n; i++) cout << b[i] << ' ';
cout << '\n';
swap(b[index1], b[index2]);
for (int i = 0; i < n; i++) cout << b[i] << ' ';
cerr << "\n\nTime elapsed: " << 1000.00 * clock() / CLOCKS_PER_SEC
<< " ms.\n";
return 0;
}
mp[k]++;
}
bool flag = false;
auto check = [](const pair<int, int>& p, int it) -> bool {
return it >= p.first && it <= p.second;
};
int ni = -1;
for (int i = 0; i < n - 1; i++) {
if (check(pr[i + 1], i + 1) && check(pr[i], i + 2)) {
flag = true;
ni = i + 1;
break;
}
}
if (!flag)
cout << "YES\n";
else
cout << "NO\n";
for (int& i : b) cout << i << ' ';
if (flag) {
cout << '\n';
for (int& i : b) {
if (ni == i)
cout << i + 1 << ' ';
else if (ni + 1 == i)
cout << i - 1 << ' ';
else
cout << i << ' ';
}
}
cerr << "\n\nTime elapsed: " << 1000.00 * clock() / CLOCKS_PER_SEC
<< " ms.\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353;
const long double error = 2e-6;
const long double PI = acosl(-1);
mt19937 rng((unsigned)chrono::system_clock::now().time_since_epoch().count());
inline long long int MOD(long long int x, long long int m = mod) {
long long int y = x % m;
return (y >= 0) ? y : y + m;
}
const int inf = 1e9;
const long long int infl = 1061109567;
const int nmax = 2e5 + 10;
int L[nmax], R[nmax];
int indice[nmax], ans[nmax];
vector<int> start[nmax];
const int lgn = 32 - __builtin_clz(nmax);
int sparse[nmax][lgn];
void buildsparse(int n) {
for (int i = 1; i <= n; i++) sparse[i][0] = indice[i];
for (int k = 1, p = 1; k < lgn; k++, p <<= 1)
for (int i = 1; i + p + p <= n + 1; i++)
sparse[i][k] = ((L[sparse[i][k - 1]] < L[sparse[i + p][k - 1]])
? (sparse[i][k - 1])
: (sparse[i + p][k - 1]));
}
int query(int l, int r) {
int len = r - l + 1;
int k = 32 - __builtin_clz(len) - 1;
return ((L[sparse[l][k]] < L[sparse[r - (1 << k) + 1][k]])
? (sparse[l][k])
: (sparse[r - (1 << k) + 1][k]));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> L[i] >> R[i];
start[L[i]].push_back(i);
}
priority_queue<pair<int, int>> pq;
int cur = 1;
while (cur <= n) {
for (int x : start[cur]) pq.push({-R[x], x});
int x = pq.top().second;
pq.pop();
indice[cur] = x;
cur++;
}
for (int i = 1; i <= n; i++) ans[indice[i]] = i;
buildsparse(n);
int s1 = 0, s2 = 0;
for (int i = 1; i <= n; i++) {
int x = indice[i];
int r = R[x];
if (i == r) continue;
int y = query(i + 1, r);
if (L[y] <= i) {
s1 = x, s2 = y;
break;
}
}
if (s1)
cout << "NO\n";
else
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
if (s1 == 0) return 0;
swap(ans[s1], ans[s2]);
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int as[200005], bs[200005];
vector<pair<int, int> > start[200005];
int ans[200005];
int where[200005];
int N;
void show() {
for (int i = 1; i <= N; i++) cout << ans[i] << ' ';
cout << endl;
}
pair<int, int> st[400005];
int query(int l, int r) {
l--;
pair<int, int> res{INF, INF};
for (l += N, r += N; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, st[l++]);
if (r & 1) res = min(res, st[--r]);
}
return res.second;
}
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> as[i] >> bs[i];
start[as[i]].push_back({bs[i], i});
}
set<pair<int, int> > active;
for (int i = 1; i <= N; i++) {
active.insert(start[i].begin(), start[i].end());
ans[active.begin()->second] = i;
where[i] = active.begin()->second;
active.erase(active.begin());
}
for (int i = 0; i < N; i++) {
st[i + N] = {as[where[i + 1]], i + 1};
}
for (int i = N - 1; i > 0; i--) {
st[i] = min(st[i << 1], st[i << 1 | 1]);
}
for (int i = 1; i <= N; i++) {
int j = query(i + 1, bs[where[i]]);
if (j == INF) continue;
if (as[where[j]] <= i) {
cout << "NO" << endl;
show();
swap(ans[where[i]], ans[where[j]]);
show();
return 0;
}
}
cout << "YES" << endl;
show();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, inf = 1e9 + 7;
set<pair<int, int> > hllw;
vector<pair<int, int> > vec[200005];
int n, A[200005], B[200005];
int ans[200005], where[200005];
pair<int, int> st[400005];
int query(int l, int r) {
l--;
pair<int, int> res;
res.first = inf;
res.second = inf;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, st[l++]);
if (r & 1) res = min(res, st[--r]);
}
return res.second;
}
void cout_ans() {
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i] >> B[i];
vec[A[i]].push_back(make_pair(B[i], i));
}
cout << endl;
for (int i = 1; i <= n; i++) {
hllw.insert(vec[i].begin(), vec[i].end());
ans[hllw.begin()->second] = i;
where[i] = hllw.begin()->second;
hllw.erase(hllw.begin());
}
for (int i = 0; i < n; i++) {
st[i + n].first = A[where[i + 1]];
st[i + n].second = i + 1;
}
for (int i = n - 1; i > 0; i--) {
st[i] = min(st[i << 1 | 1], st[i << 1]);
}
for (int i = 1; i <= n; i++) {
int j = query(i + 1, B[where[i]]);
if (j == inf) continue;
if (A[where[j]] <= i) {
cout << "NO" << endl;
cout_ans();
swap(ans[where[i]], ans[where[j]]);
cout_ans();
return 0;
}
}
cout << "YES" << endl;
cout_ans();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 212345;
const int inf = 0x3f3f3f3f;
inline int lowbit(int x) { return x & -x; }
int n;
int fen[maxn], id[maxn], l[maxn], r[maxn], ans[maxn];
vector<pair<int, int> > G[maxn];
void upd(int x, int v) {
while (x <= n) {
fen[x] = min(fen[x], v);
x += lowbit(x);
}
}
int query(int x) {
int ret = inf;
while (x > 0) {
ret = min(ret, fen[x]);
x -= lowbit(x);
}
return ret;
}
int main() {
scanf("%d", &n);
for (int(i) = (1); (i) <= (n); (i)++) {
scanf("%d%d", l + i, r + i);
G[l[i]].emplace_back(r[i], i);
}
set<pair<int, int> > s;
for (int(i) = (1); (i) <= (n); (i)++) {
for (auto _ : G[i]) s.emplace(_);
if (!s.empty() && s.begin()->first >= i) {
ans[s.begin()->second] = i;
id[i] = s.begin()->second;
s.erase(s.begin());
}
}
memset(fen, 0x3f, sizeof(fen));
for (int(i) = (n); (i) >= (1); (i)--) {
if (query(r[id[i]]) <= i)
for (int(j) = (i + 1); (j) <= (n); (j)++)
if (l[id[j]] <= i) {
puts("NO");
for (int(k) = (1); (k) <= (n); (k)++) printf("%d ", ans[k]);
putchar('\n');
swap(ans[id[i]], ans[id[j]]);
for (int(k) = (1); (k) <= (n); (k)++) printf("%d ", ans[k]);
return 0;
}
upd(i, l[id[i]]);
}
puts("YES");
for (int(i) = (1); (i) <= (n); (i)++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> st[1000005], mn;
pair<pair<int, int>, int> a[200005];
pair<int, pair<pair<int, int>, int> > b[200005];
int n, kq[200005];
set<int> s;
void update(int id, int l, int r, int vt, pair<int, int> gt) {
if (l > r || l > vt || r < vt) return;
if (l == r) {
st[id] = min(st[id], gt);
return;
}
int mid = (l + r) / 2;
update(id * 2, l, mid, vt, gt);
update(id * 2 + 1, mid + 1, r, vt, gt);
st[id] = min(st[id * 2], st[id * 2 + 1]);
}
pair<int, int> get(int id, int l, int r, int u, int v) {
if (l > r || l > v || r < u) return {1e9, 0};
if (l >= u && r <= v) return st[id];
int mid = (l + r) / 2;
return min(get(id * 2, l, mid, u, v), get(id * 2 + 1, mid + 1, r, u, v));
}
bool cmp(pair<pair<int, int>, int> x, pair<pair<int, int>, int> y) {
if (x.first.second != y.first.second) return x.first.second < y.first.second;
return x.first.first < y.first.first;
}
void build(int id, int l, int r) {
if (l > r) return;
st[id] = {1e9, 0};
if (l == r) return;
int mid = (l + r) / 2;
build(id * 2, l, mid);
build(id * 2 + 1, mid + 1, r);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i].first.first >> a[i].first.second;
a[i].second = i;
}
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; ++i) s.insert(i);
for (int i = 1; i <= n; ++i) {
kq[a[i].second] = (*s.lower_bound(a[i].first.first));
s.erase(kq[a[i].second]);
b[i] = {kq[a[i].second], a[i]};
}
build(1, 1, n);
sort(b + 1, b + n + 1);
for (int i = n; i > 0; --i) {
mn = get(1, 1, n, b[i].first + 1, b[i].second.first.second);
if (mn.first <= b[i].first) {
cout << "NO" << '\n';
for (int i = 1; i <= n; ++i) cout << kq[i] << ' ';
cout << '\n';
swap(kq[b[i].second.second], kq[b[mn.second].second.second]);
for (int i = 1; i <= n; ++i) cout << kq[i] << ' ';
return 0;
}
update(1, 1, n, b[i].first, {b[i].second.first.first, i});
}
cout << "YES" << '\n';
for (int i = 1; i <= n; ++i) cout << kq[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
struct P {
int l, r, id;
} p[MAXN];
struct cmp {
bool operator()(P a, P b) { return a.r > b.r; }
};
int n, a[MAXN], b[MAXN], xl[MAXN], xr[MAXN], rev[MAXN];
bool cmp1(P a, P b) { return a.l < b.l; }
bool cmp2(P a, P b) { return a.r > b.r; }
priority_queue<P, vector<P>, cmp> q, q2;
multiset<int> ms;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i].l, &p[i].r);
p[i].id = i;
}
multiset<int>::iterator it;
sort(p + 1, p + n + 1, cmp1);
int cur = 1, flg = 0;
for (int i = 1; i <= n; i++) {
while (cur <= n && p[cur].l <= i) {
q.push(p[cur]);
cur++;
}
P tmp = q.top();
q.pop();
a[tmp.id] = b[tmp.id] = i, xl[tmp.id] = tmp.l, xr[tmp.id] = tmp.r,
rev[i] = tmp.id;
q2.push(tmp);
while (!q2.empty() && q2.top().r < i) {
P tmp2 = q2.top();
q2.pop();
it = ms.find(a[tmp2.id]);
ms.erase(it);
}
if (!ms.empty() && !flg) {
it = ms.end();
it--;
if (*it >= tmp.l) {
flg = 1;
swap(b[tmp.id], b[rev[*it]]);
}
}
ms.insert(i);
}
if (flg) {
printf("NO\n");
for (int i = 1; i <= n; i++) {
printf("%d ", a[i]);
}
printf("\n");
for (int i = 1; i <= n; i++) {
printf("%d ", b[i]);
}
printf("\n");
} else {
printf("YES\n");
for (int i = 1; i <= n; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int X, Y, Z;
};
const int N = (int)1e6 + 7;
const int MOD = (int)1e9 + 7;
const long long INF = (long long)1e18 + 7;
int IT[N];
data a[N], b[N];
int n;
bool cmp(data a, data b) { return (a.X != b.X) ? a.X < b.X : a.Y < b.Y; }
void Insert(int i, int l, int r, int x, int val) {
if (x < l || x > r) return;
if (l == r) {
IT[i] = val;
return;
}
int m = (l + r) >> 1;
Insert(i * 2, l, m, x, val);
Insert(i * 2 + 1, m + 1, r, x, val);
IT[i] = max(IT[i * 2], IT[i * 2 + 1]);
return;
}
int Get(int i, int l, int r, int L, int R) {
if (l >= L && r <= R) return IT[i];
if (L > r || R < l) return 0;
int m = (l + r) >> 1;
int x = Get(i * 2, l, m, L, R);
int y = Get(i * 2 + 1, m + 1, r, L, R);
return max(x, y);
}
void show() {
vector<int> ans(n + 1);
for (int i = 1; i <= n; i++) ans[a[i].Z] = i;
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
void builda() {
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
q;
sort(a + 1, a + n + 1, cmp);
int l = 1;
for (int i = 1; i <= n; i++) {
while (a[l].X == i && l <= n) q.push({a[l].Y, l++});
pair<int, int> gt = q.top();
q.pop();
b[i] = a[gt.second];
}
for (int i = 1; i <= n; i++) a[i] = b[i];
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].X >> a[i].Y;
a[i].Z = i;
}
builda();
Insert(1, 1, n, 1, a[1].Y);
int l = 0;
for (int i = 2; i <= n; i++) {
int R = i, L = a[i].X;
int ck = Get(1, 1, n, L, R);
Insert(1, 1, n, i, a[i].Y);
if (ck >= i) {
l = i;
break;
}
}
int r = 0;
for (int i = a[l].X; i < l; i++)
if (a[i].Y >= l) {
r = i;
break;
}
if (l) {
cout << "NO\n";
show();
swap(a[l], a[r]);
cout << "\n";
show();
return 0;
}
cout << "YES\n";
show();
}
|
#include <bits/stdc++.h>
struct Seg {
int a;
int b;
int id;
};
int n;
const int maxN(200010);
Seg seg[maxN];
int order[maxN];
int p[maxN];
std::pair<int, int> tree[maxN * 2];
int ans[maxN];
bool cmpA(int a, int &b) { return seg[a].a < seg[b].a; }
bool operator>(const Seg &a, const Seg &b) { return a.b > b.b; }
void output() {
for (int i(1); i <= n; ++i) ans[p[i]] = i;
for (int i(1); i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
}
int query(int l, int r) {
std::pair<int, int> ans{std::numeric_limits<int>::max(), -1};
--l;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) ans = std::min(ans, tree[l++]);
if (r & 1) ans = std::min(ans, tree[--r]);
}
return ans.second;
}
int main() {
scanf("%d", &n);
for (int i(1); i <= n; ++i) {
scanf("%d %d", &seg[i].a, &seg[i].b);
seg[i].id = i;
order[i] = i;
}
std::sort(order + 1, order + n + 1, cmpA);
std::priority_queue<Seg, std::vector<Seg>, std::greater<Seg> > heap;
for (int i(1), j(1); i <= n; ++i) {
while (j <= n && seg[order[j]].a <= i) {
heap.push(seg[order[j]]);
++j;
}
tree[n + i - 1].first = heap.top().a;
tree[n + i - 1].second = i;
p[i] = heap.top().id;
heap.pop();
}
for (int i(n - 1); i >= 1; --i) {
tree[i] = std::min(tree[i << 1], tree[i << 1 | 1]);
}
for (int i(1); i <= n; ++i) {
int j(query(i + 1, seg[p[i]].b));
if (j != -1 && seg[p[j]].a <= i) {
printf("NO\n");
output();
std::swap(p[i], p[j]);
output();
return 0;
}
}
printf("YES\n");
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e9;
const long long MB = 31;
const long long MOD = 1e9 + 7;
void solve() {
long long n;
cin >> n;
vector<pair<long long, long long>> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
a[i].first--;
a[i].second--;
}
vector<vector<pair<long long, long long>>> b(n);
for (long long i = 0; i < n; i++) {
b[a[i].first].push_back({a[i].second, i});
}
vector<long long> id(n);
set<pair<long long, long long>> st;
for (long long i = 0; i < n; i++) {
for (auto& p : b[i]) {
st.insert(p);
}
auto p = *st.begin();
st.erase(p);
id[p.second] = i;
}
vector<long long> add(n);
for (long long i = 0; i < n; i++) add[id[i]] = i;
vector<vector<long long>> del(n);
for (long long i = 0; i < n; i++)
if (a[i].second + 1 < n) del[a[i].second + 1].push_back(i);
st.clear();
for (long long i = 0; i < n; i++) {
for (long long j : del[i]) {
st.erase({id[j], j});
}
if (!st.empty() && st.rbegin()->first >= a[add[i]].first) {
long long ind = st.rbegin()->second;
cout << "NO\n";
for (long long i : id) cout << i + 1 << " ";
cout << '\n';
swap(id[st.rbegin()->second], id[add[i]]);
for (long long i : id) cout << i + 1 << " ";
return;
}
st.insert({i, add[i]});
}
cout << "YES\n";
for (long long i : id) cout << i + 1 << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(12);
cout << fixed;
long long t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
int n, ans1 = -1, ans2, par[N];
pair<int, int> m, p[N], tree[N * 2];
vector<pair<int, int> > v[N];
set<pair<int, int> > s;
pair<int, int> query(int l, int r) {
pair<int, int> res;
res.first = res.second = -1;
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) {
if (tree[l].first > res.first) res = tree[l];
l++;
}
if (r & 1) {
if (tree[--r].first > res.first) res = tree[r];
}
}
return res;
}
void make_tree() {
for (int i = n - 1; i >= 1; i--) {
pair<int, int> p1 = tree[i * 2], p2 = tree[i * 2 + 1];
if (p1.first > p2.first)
tree[i] = p1;
else
tree[i] = p2;
}
}
int main() {
cin >> n;
for (long long i = 0; i < n; i++) {
scanf("%d%d", &p[i].first, &p[i].second);
;
p[i].first--, p[i].second--;
v[p[i].first].push_back(make_pair(p[i].second, i));
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < v[i].size(); j++) s.insert(v[i][j]);
pair<int, int> u = *s.begin();
s.erase(u);
tree[i + n] = u;
par[u.second] = i;
}
make_tree();
for (long long i = 0; i < n; i++) {
m = query(p[i].first, par[i] - 1);
if (m.first >= par[i]) ans1 = i, ans2 = m.second;
}
if (ans1 == -1)
cout << "YES" << endl;
else
cout << "NO" << endl;
for (long long i = 0; i < n; i++) cout << par[i] + 1 << " ";
cout << endl;
if (ans1 != -1) {
swap(par[ans1], par[ans2]);
for (long long i = 0; i < n; i++) cout << par[i] + 1 << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, af[N], l[N], r[N], a[N], pos[N];
vector<pair<int, int>> eve[N];
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
pq;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
eve[l[i]].push_back({r[i], i});
}
for (int i = 1; i <= n; i++) {
for (pair<int, int>& cur : eve[i]) {
pq.push(cur);
}
auto [r, ind] = pq.top();
pq.pop();
a[ind] = i;
pos[i] = ind;
if (!pq.empty()) {
af[ind] = pq.top().second;
}
}
for (int i = 1; i <= n; i++) {
int cur = i, nxt = af[i];
if (nxt != 0 && l[cur] <= a[nxt] && a[nxt] <= r[cur] && l[nxt] <= a[cur] &&
a[cur] <= r[nxt]) {
cout << "NO\n";
for (int i = 1; i <= n; i++) {
cout << a[i] << " \n"[i == n];
}
swap(a[cur], a[nxt]);
for (int i = 1; i <= n; i++) {
cout << a[i] << " \n"[i == n];
}
return 0;
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++) {
cout << a[i] << " \n"[i == n];
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct Node {
int l, r, id;
bool operator<(const Node &b) const { return l < b.l; }
} a[N], b[N];
priority_queue<pair<int, int> > q;
int ans[N], p[N], mi[N * 4], id[N * 4];
inline void update(int x) {
mi[x] = mi[x << 1 | (mi[x << 1] > mi[x << 1 | 1])],
id[x] = id[x << 1 | (mi[x << 1] > mi[x << 1 | 1])];
}
void build(int l, int r, int x) {
if (l == r) {
mi[x] = b[p[l]].l, id[x] = l;
return;
}
int mid = (l + r) >> 1;
build(l, mid, x << 1);
build(mid + 1, r, x << 1 | 1);
update(x);
}
pair<int, int> query(int x, int l, int r, int L, int R) {
if (L <= l && R >= r) return {mi[x], id[x]};
int mid = (l + r) >> 1;
pair<int, int> w1 = {1e9, 0}, w2 = {1e9, 0};
if (L <= mid) w1 = query(x << 1, l, mid, L, R);
if (R > mid) w2 = query(x << 1 | 1, mid + 1, r, L, R);
if (w1.first < w2.first) return w1;
return w2;
}
int main() {
int n, l = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d%d", &a[i].l, &a[i].r), a[i].id = i, b[i] = a[i];
sort(a, a + n);
for (int i = 1; i <= n; i++) {
while (l < n && a[l].l <= i) q.push({-a[l].r, a[l].id}), l++;
p[i] = q.top().second;
q.pop();
ans[p[i]] = i;
}
build(1, n, 1);
int u = -1, v;
for (int i = 1; i <= n; i++) {
if (b[p[i]].r == i) continue;
pair<int, int> w = query(1, 1, n, i + 1, b[p[i]].r);
if (w.first <= i) {
u = p[i], v = p[w.second];
break;
}
}
if (u == -1) {
puts("YES");
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
} else {
puts("NO");
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
swap(ans[u], ans[v]);
puts("");
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
const long long MOD2 = (long long)998244353 * (long long)998244353;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
int a[200135], b[200135], ans[200135], w[200135];
vector<int> pos[200135];
void ppt() {
for (int(i) = 1; (i) <= (int)(n); (i)++) printf("%d ", ans[i]);
puts("");
}
const int MN = (1 << 19) + 5;
struct mb {
int M, T[MN];
void init(int sz) {
for (M = 1; sz + 2 > M; M <<= 1)
;
}
void init(int sz, int val) {
for (M = 1; sz + 2 > M; M <<= 1)
;
for (int(i) = 0; (i) < (int)(MN); (i)++) T[i] = val;
}
void clear() { memset(T, 0, sizeof T); }
void upt(int l, int r, int val) {
for (l = l + M - 1, r = r + M + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (~l & 1) T[l ^ 1] = max(val, T[l ^ 1]);
if (r & 1) T[r ^ 1] = max(val, T[r ^ 1]);
}
}
int qy(int l) {
int ans = 0;
l += M;
while (l >= 1) {
ans = max(ans, T[l]);
l >>= 1;
}
return ans;
}
} T;
void fmain(int tid) {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d%d", a + i, b + i);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
pos[a[i]].push_back(i);
}
priority_queue<pair<int, int>, std::vector<pair<int, int>>,
std::greater<pair<int, int>>>
q;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int z : pos[i]) {
q.push({b[z], z});
}
assert(!q.empty());
auto pr = q.top();
q.pop();
ans[pr.second] = i;
w[i] = pr.second;
}
T.init(n, 0);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
int z = T.qy(i);
if (z >= a[w[i]]) {
puts("NO");
ppt();
swap(ans[w[i]], ans[w[z]]);
ppt();
return;
}
T.upt(i, b[w[i]], i);
}
puts("YES");
ppt();
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
const int N = 200005;
pair<ii, int> v[N];
int ans[N];
int rec[N];
int ans2[N];
struct SegTree {
vector<ii> st;
int n;
SegTree(int sz) {
st.resize(4 * (sz + 1), {0, 0});
n = sz;
}
void upd(int p, int l, int r, int x, int val) {
if (l == r && r == x) {
st[p] = {val, x};
return;
}
if (l > x || r < x) return;
int mid = (l + r) / 2;
upd(2 * p, l, mid, x, val);
upd(2 * p + 1, mid + 1, r, x, val);
st[p] = max(st[2 * p], st[2 * p + 1]);
}
ii qry(int p, int l, int r, int ql, int qr) {
if (l >= ql && r <= qr) {
return st[p];
}
if (l > qr || r < ql) return {0, 0};
int mid = (l + r) / 2;
return max(qry(2 * p, l, mid, ql, qr), qry(2 * p + 1, mid + 1, r, ql, qr));
}
void upd(int x, int val) { upd(1, 1, n, x, val); }
ii qry(int l, int r) { return qry(1, 1, n, l, r); }
};
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &v[i].first.first, &v[i].first.second);
v[i].second = i + 1;
}
sort(v, v + n);
int id = 0;
set<ii> s;
for (int i = 1; i <= n; i++) {
while (id < n && v[id].first.first <= i) {
s.insert({v[id].first.second, id});
id++;
}
assert(s.size());
ans[s.begin()->second] = i;
rec[i] = s.begin()->second;
s.erase(s.begin());
}
bool ok = 1;
int swp1, swp2;
SegTree st(n);
for (int i = 1; i <= n; i++) {
int l, r;
tie(l, r) = v[rec[i]].first;
ii x = st.qry(l, i);
if (x.first >= i) {
swp1 = x.second;
swp2 = i;
ok = 0;
break;
}
st.upd(i, r);
}
printf("%s\n", ok ? "YES" : "NO");
for (int i = 0; i < n; i++) {
ans2[v[i].second] = ans[i];
}
for (int i = 1; i <= n; i++) {
printf("%d ", ans2[i]);
}
printf("\n");
if (!ok) {
for (int i = 1; i <= n; i++) {
if (ans2[i] == swp1) {
printf("%d ", swp2);
} else if (ans2[i] == swp2) {
printf("%d ", swp1);
} else {
printf("%d ", ans2[i]);
}
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, af[N], l[N], r[N], a[N], pos[N];
vector<pair<int, int>> eve[N];
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
pq;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
eve[l[i]].push_back({r[i], i});
}
for (int i = 1; i <= n; i++) {
for (pair<int, int>& cur : eve[i]) {
pq.push(cur);
}
auto [r, ind] = pq.top();
pq.pop();
a[ind] = i;
pos[i] = ind;
if (!pq.empty()) {
af[ind] = pq.top().second;
}
}
for (int i = 1; i <= n; i++) {
int cur = i, nxt = af[i];
if (nxt != 0 && a[nxt] <= r[cur] && a[cur] <= r[nxt]) {
cout << "NO\n";
for (int i = 1; i <= n; i++) {
cout << a[i] << " \n"[i == n];
}
swap(a[cur], a[nxt]);
for (int i = 1; i <= n; i++) {
cout << a[i] << " \n"[i == n];
}
return 0;
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++) {
cout << a[i] << " \n"[i == n];
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, kezd[200002], veg[200002], pos[200002], inv[200002], x, csa, csb;
vector<pair<pair<int, int>, int> > sz;
vector<int> v;
priority_queue<pair<int, int> > q;
void p() {
for (int i = 1; i <= n; i++) inv[pos[i]] = i;
for (int i = 1; i <= n; i++) cout << inv[i] << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int a, b;
cin >> a >> b, kezd[i] = a, veg[i] = b;
sz.push_back({{a, b}, i});
}
sort(sz.begin(), sz.end());
for (int i = 1; i <= n; i++) {
while (x < n && sz[x].first.first == i)
q.push({-sz[x].first.second, sz[x].second}), x++;
pos[i] = q.top().second, q.pop();
}
for (int i = 1; i <= n; i++) {
while (v.size() > 0 && veg[pos[v.back()]] < i) {
v.pop_back();
}
int a = kezd[pos[i]], b = veg[pos[i]];
if (v.size() > 0 && a <= v.back()) {
csa = i, csb = v.back();
}
while (v.size() > 0 && b >= veg[pos[v.back()]]) v.pop_back();
v.push_back(i);
}
if (!csa) {
cout << "YES"
<< "\n";
p();
} else {
cout << "NO"
<< "\n";
p();
swap(pos[csa], pos[csb]);
p();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 5;
int sol[N];
struct ajutorab {
int a, b;
int id;
};
bool operator<(ajutorab x, ajutorab y) {
if (x.b == y.b) return x.id < y.id;
return x.b < y.b;
}
bool cmp(ajutorab a, ajutorab b) { return a.a < b.a; }
bool cmpid(ajutorab a, ajutorab b) { return a.id < b.id; }
ajutorab v[N];
set<ajutorab> pz;
int aint[4 * N];
void update(int node, int l, int r, int poz, int val) {
if (l > r || poz < l || poz > r) return;
if (l == r) {
aint[node] = val;
return;
}
int mid = (l + r) / 2;
update(2 * node, l, mid, poz, val);
update(2 * node + 1, mid + 1, r, poz, val);
aint[node] = max(aint[node * 2], aint[node * 2 + 1]);
}
int query(int node, int l, int r, int ql, int qr) {
if (l > r || qr < l || ql > r || ql > qr) return -1;
if (ql <= l && r <= qr) {
return aint[node];
}
int mid = (l + r) / 2;
int st = query(2 * node, l, mid, ql, qr);
int dr = query(2 * node + 1, mid + 1, r, ql, qr);
return max(st, dr);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i].a >> v[i].b;
v[i].id = i;
}
sort(v + 1, v + n + 1, cmp);
int poz = 1;
for (int i = 1; i <= n; i++) {
while (poz <= n && v[poz].a <= i) {
pz.insert(v[poz]);
poz++;
}
ajutorab x = (*pz.begin());
pz.erase(pz.begin());
sol[x.id] = i;
}
sort(v + 1, v + n + 1, cmpid);
for (int i = 1; i <= n; i++) {
update(1, 1, n, sol[i], v[i].b);
}
for (int i = 1; i <= n; i++) {
int q = query(1, 1, n, v[i].a, sol[i] - 1);
if (q >= sol[i]) {
cout << "No\n";
for (int j = 1; j <= n; j++) {
cout << sol[j] << " ";
}
cout << "\n";
for (int j = 1; j <= n; j++) {
if (j != i && v[i].a <= sol[j] && sol[j] <= sol[i] &&
sol[i] <= v[j].b) {
swap(sol[i], sol[j]);
break;
}
}
for (int j = 1; j <= n; j++) {
cout << sol[j] << " ";
}
return 0;
}
}
cout << "Yes\n";
for (int j = 1; j <= n; j++) {
cout << sol[j] << " ";
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.