text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, mod = 1e9 + 7, inf = 1e9;
map<int, int> mp[3];
vector<int> vec[maxn];
set<pair<int, int> > st;
int lim[3], a[maxn], val[4 * maxn], lz[4 * maxn], n, N;
void build(int l = 0, int r = N, int id = 1) {
if (r - l == 1) {
val[id] = l;
return;
}
int mid = (l + r) >> 1;
build(l, mid, 2 * id);
build(mid, r, 2 * id + 1);
val[id] = min(val[2 * id], val[2 * id + 1]);
}
void get(int l, int r, int id) {
val[id] += lz[id];
if (r - l > 1) {
lz[2 * id] += lz[id];
lz[2 * id + 1] += lz[id];
}
lz[id] = 0;
}
void Add(int f, int s, int x, int l = 0, int r = N, int id = 1) {
if (f >= s || l >= r) return;
get(l, r, id);
if (s <= l || r <= f) return;
if (f <= l && r <= s) {
lz[id] += x;
get(l, r, id);
return;
}
int mid = (l + r) >> 1;
Add(f, s, x, l, mid, 2 * id);
Add(f, s, x, mid, r, 2 * id + 1);
val[id] = min(val[2 * id], val[2 * id + 1]);
}
int Ask(int f, int s, int l = 0, int r = N, int id = 1) {
if (f >= s || l >= r) return inf;
get(l, r, id);
if (s <= l || r <= f) return inf;
if (f <= l && r <= s) return val[id];
int mid = (l + r) >> 1;
return min(Ask(f, s, l, mid, 2 * id), Ask(f, s, mid, r, 2 * id + 1));
}
void _Add(int pos, int x) {
auto it = st.upper_bound({pos, 1e9});
++pos;
if ((prev(it)->second) >= x) return;
if (it == st.end() || (it->first) > pos)
st.insert({pos, prev(it)->second}), it = prev(it);
while (it != st.begin() && (prev(it)->second) <= x) {
int nm = prev(it)->second, ps = prev(it)->first;
Add(ps, pos, x - nm);
st.erase(prev(it));
pos = ps;
}
st.insert({pos, x});
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
N = n + 1;
for (int q = 0; q < 3; q++) {
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (mp[q].count(x) == 0) mp[q][x] = i;
}
}
for (int q = 0; q < 3; q++) {
for (pair<int, int> p : mp[q]) {
int num = 0;
for (int w = 0; w < 3; w++) num += mp[w].count(p.first);
if (num == 1) lim[q] = max(lim[q], p.second);
}
}
build();
st.insert({0, 0});
_Add(n, lim[2]);
for (pair<int, int> p : mp[1]) {
if (mp[2].count(p.first) && mp[0].count(p.first) == 0)
_Add(p.second - 1, mp[2][p.first]);
}
for (pair<int, int> p : mp[0]) {
vec[p.second].push_back(p.first);
}
int ans = 3 * n;
for (int i = n; i >= lim[0]; i--) {
ans = min(ans, i + Ask(lim[1], N));
for (int x : vec[i]) {
bool b1 = mp[1].count(x), b2 = mp[2].count(x);
if (b1 && b2) {
_Add(mp[1][x] - 1, mp[2][x]);
} else if (b1) {
lim[1] = max(lim[1], mp[1][x]);
} else if (b2) {
_Add(n, mp[2][x]);
}
}
}
return cout << ans << endl, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
} p[300010];
int n, a[100010], b[100010], c[100010], vis[300010], d[300010], Min, Y[400010],
inf = 100000000;
set<int> A;
multiset<int> B;
void read(int &x) {
char ch = getchar();
int mark = 1;
for (; ch != '-' && (ch < '0' || ch > '9'); ch = getchar())
;
if (ch == '-') mark = -1, ch = getchar();
for (x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - 48;
x *= mark;
}
int Get(int x, int y) {
if (x > n || y > n) return inf;
return x + y;
}
void Add(point X) {
set<int>::iterator R, L, tmp;
R = A.upper_bound(X.x);
if (Y[*R] < X.y) {
L = R;
for (; Y[*L] < X.y; --L)
;
for (set<int>::iterator it = L; it != R; ++it) {
set<int>::iterator nxt = it;
++nxt;
B.erase(B.find(Get((*it), Y[*nxt])));
}
B.insert(Get((*L), X.y));
B.insert(Get(X.x, Y[*R]));
if (L != R) {
set<int>::iterator it = L;
++it;
for (; it != R;) {
tmp = it;
++it;
A.erase(tmp);
}
}
A.insert(X.x);
Y[X.x] = X.y;
}
}
int main() {
read(n);
int cnt = 0;
for (int i = 1; i <= n; i++) read(a[i]), d[++cnt] = a[i];
for (int i = 1; i <= n; i++) read(b[i]), d[++cnt] = b[i];
for (int i = 1; i <= n; i++) read(c[i]), d[++cnt] = c[i];
sort(d + 1, d + cnt + 1);
cnt = unique(d + 1, d + cnt + 1) - (d + 1);
for (int i = 1; i <= n; i++) {
a[i] = lower_bound(d + 1, d + cnt + 1, a[i]) - d;
b[i] = lower_bound(d + 1, d + cnt + 1, b[i]) - d;
c[i] = lower_bound(d + 1, d + cnt + 1, c[i]) - d;
}
for (int i = 1; i <= n; i++) vis[a[i]]++;
for (int i = 1; i <= cnt; i++) p[i].x = p[i].y = n + i;
for (int i = n; i; i--) {
p[b[i]].x = i;
p[c[i]].y = i;
}
Min = 3 * n;
point tmp;
tmp.x = 0, Y[tmp.x] = n + cnt + 1;
A.insert(0);
tmp.x = n + cnt + 1;
Y[tmp.x] = 0;
A.insert(n + cnt + 1);
B.insert(Get(0, 0));
for (int i = 1; i <= cnt; i++)
if (!vis[i]) Add(p[i]);
Min = min(Min, (*B.begin()) + n);
for (int i = n; i; i--) {
vis[a[i]]--;
if (!vis[a[i]]) {
if (p[a[i]].x > n && p[a[i]].y > n) break;
Add(p[a[i]]);
}
Min = min(Min, (*B.begin()) + i - 1);
}
printf("%d\n", Min);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100005;
const int Inf = 1000000000;
struct triple {
int a, b, c;
triple(int a = 0, int b = 0, int c = 0) : a(a), b(b), c(c) {}
};
map<int, triple> M;
int n;
int a[Maxn], b[Maxn], c[Maxn];
set<pair<int, int> > cur;
priority_queue<pair<int, int> > Q;
int res = Inf;
void Insert(int a, int b) {
set<pair<int, int> >::iterator it = cur.lower_bound(pair<int, int>(a, b));
if (it != cur.end() && b <= it->second) return;
if (it != cur.end()) Q.push(pair<int, int>(-(a + it->second), a));
it = cur.insert(pair<int, int>(a, b)).first;
while (it != cur.begin()) {
it--;
if (it->second <= b)
cur.erase(it++);
else {
it++;
break;
}
}
if (it != cur.begin()) {
it--;
Q.push(pair<int, int>(-(it->first + b), it->first));
}
}
bool Check(const pair<int, int> &p) {
int cand = -p.first, i = p.second;
set<pair<int, int> >::iterator it = cur.lower_bound(pair<int, int>(i, 0));
if (it == cur.end() || it->first != i) return false;
it++;
if (it == cur.end() || it->second != cand - i) return false;
return true;
}
int getBest() {
while (!Q.empty()) {
pair<int, int> v = Q.top();
if (Check(v)) return -v.first;
Q.pop();
}
return Inf;
}
int main() {
map<int, triple>::iterator it;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
it = M.find(a[i]);
if (it == M.end()) M[a[i]] = triple(i + 1, Inf, Inf);
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
it = M.find(b[i]);
if (it == M.end())
M[b[i]] = triple(Inf, i + 1, Inf);
else
it->second.b = min(it->second.b, i + 1);
}
for (int i = 0; i < n; i++) {
scanf("%d", &c[i]);
it = M.find(c[i]);
if (it == M.end())
M[c[i]] = triple(Inf, Inf, i + 1);
else
it->second.c = min(it->second.c, i + 1);
}
Insert(0, Inf);
Insert(Inf, 0);
for (it = M.begin(); it != M.end(); it++)
if (it->second.a == Inf) Insert(it->second.b, it->second.c);
for (int i = n; i >= 0; i--) {
res = min(res, i + getBest());
if (i) {
it = M.find(a[i - 1]);
if (it->second.a == i) Insert(it->second.b, it->second.c);
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[4][100100], tot, cnt;
const int Maxn = 1 << 30;
struct Node {
int v, id, from;
} seq[1001000];
struct NNode {
int v[4];
void init() { v[1] = v[2] = v[3] = 3 * n; }
} whe[1001000];
struct NNNode {
int x, y;
};
set<NNNode> F;
multiset<int> sum;
bool operator<(NNNode x, NNNode y) {
return x.x < y.x || (x.x == y.x && x.y < y.y);
}
bool cmp1(Node x, Node y) { return x.v < y.v; }
bool cmp(NNode x, NNode y) { return x.v[1] > y.v[1]; }
void insert(int x) {
set<NNNode>::iterator s1, s2, s3;
NNNode inwho = (NNNode){whe[x].v[2], whe[x].v[3]};
F.insert(inwho);
s1 = F.find(inwho);
s3 = s1;
s3++;
if ((*s3).x >= (*s1).x && (*s3).y >= (*s1).y) {
F.erase(inwho);
return;
}
s2 = s1;
s2--;
s3 = s1;
s3++;
if (sum.find((*s3).y + (*s2).x) != sum.end())
sum.erase(sum.find((*s3).y + (*s2).x));
while (true) {
s1 = F.find(inwho);
s2 = s1;
s2--;
if (!((*s2).x <= (*s1).x && (*s2).y <= (*s1).y)) break;
s3 = s2;
s3--;
if (sum.find((*s2).y + (*s3).x) != sum.end())
sum.erase(sum.find((*s2).y + (*s3).x));
F.erase(s2);
}
s1 = F.find(inwho);
s3 = s1;
s3++;
sum.insert((*s1).x + (*s3).y);
s2 = s1;
s2--;
sum.insert((*s2).x + (*s1).y);
}
void work() {
sort(whe + 1, whe + cnt + 1, cmp);
F.insert((NNNode){3 * n + 2, 0});
F.insert((NNNode){0, 3 * n + 2});
sum.insert(0);
int l = 1, ans = Maxn;
for (int u = n; u >= 0; u--) {
while (whe[l].v[1] > u) insert(l), l++;
ans = min(ans, u + (*sum.begin()));
}
printf("%d\n", ans);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
scanf("%d", &a[1][i]), seq[++tot] = (Node){a[1][i], i, 1};
for (int i = 1; i <= n; i++)
scanf("%d", &a[2][i]), seq[++tot] = (Node){a[2][i], i, 2};
for (int i = 1; i <= n; i++)
scanf("%d", &a[3][i]), seq[++tot] = (Node){a[3][i], i, 3};
sort(seq + 1, seq + tot + 1, cmp1);
a[seq[1].from][seq[1].id] = 1;
cnt++;
whe[1].init();
whe[cnt].v[seq[1].from] = min(whe[cnt].v[seq[1].from], seq[1].id);
for (int i = 2; i <= tot; i++) {
if (seq[i].v != seq[i - 1].v) cnt++, whe[cnt].init();
a[seq[i].from][seq[i].id] = cnt;
whe[cnt].v[seq[i].from] = min(whe[cnt].v[seq[i].from], seq[i].id);
}
work();
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int a[300009], b[300009], c[300009], n, ct, lazy[300009 << 2], cnt[300009],
CCC[300009];
int B[300009], BB[300009], C[300009], CC[300009], s[300009 << 2], vis[300009];
map<int, int> pm;
void shift(int nd, int x, int y) {
int& ret = lazy[nd];
int mid = (x + y) >> 1;
if (~ret) {
lazy[nd << 1] = lazy[nd << 1 | 1] = ret;
s[nd << 1] = x + ret;
s[nd << 1 | 1] = mid + 1 + ret;
ret = -1;
}
}
int tap(int p, int nd, int x, int y) {
if (x == y) return max(0, lazy[nd]);
shift(nd, x, y);
int mid = (x + y) >> 1;
if (p <= mid) return tap(p, nd << 1, x, mid);
return tap(p, nd << 1 | 1, mid + 1, y);
}
void upd(int l, int r, int v, int nd, int x, int y) {
if (l > y or x > r) return;
if (l <= x and y <= r) {
s[nd] = x + v;
lazy[nd] = v;
return;
}
shift(nd, x, y);
int mid = (x + y) >> 1;
upd(l, r, v, nd << 1, x, mid);
upd(l, r, v, nd << 1 | 1, mid + 1, y);
s[nd] = min(s[nd << 1], s[nd << 1 | 1]);
}
void remove(int x) {
int posB = BB[x];
int posC = CC[posB];
if (!posB) posB = n + 1, posC = CCC[x];
if (!posC) posC = 1000000007;
int st = 0, en = posB - 1;
while (st + 1 < en) {
int mid = (st + en) >> 1;
if (tap(mid, 1, 0, n) <= posC)
en = mid;
else
st = mid;
}
if (tap(st, 1, 0, n) <= posC)
upd(st, posB - 1, posC, 1, 0, n);
else if (tap(en, 1, 0, n) <= posC)
upd(en, posB - 1, posC, 1, 0, n);
}
void build(int nd, int x, int y) {
lazy[nd] = -1;
if (x == y) {
s[nd] = x;
return;
}
int mid = (x + y) >> 1;
build(nd << 1, x, mid);
build(nd << 1 | 1, mid + 1, y);
s[nd] = min(s[nd << 1], s[nd << 1 | 1]);
}
int main() {
scanf("%d", &n);
build(1, 0, n);
for (int i = 1; i <= n; i++) scanf("%d", a + i), pm[a[i]] = true;
for (int i = 1; i <= n; i++) scanf("%d", b + i), pm[b[i]] = true;
for (int i = 1; i <= n; i++) scanf("%d", c + i), pm[c[i]] = true;
for (__typeof((pm).begin()) it = (pm).begin(); it != (pm).end(); it++)
it->second = ++ct;
for (int i = 1; i <= n; i++) a[i] = pm[a[i]], vis[a[i]] = true;
for (int i = 1; i <= n; i++) b[i] = pm[b[i]], vis[b[i]] = true;
for (int i = 1; i <= n; i++) c[i] = pm[c[i]], vis[c[i]] = true;
for (int i = 1; i <= n; i++) {
if (!B[b[i]]) BB[b[i]] = i;
B[b[i]] = true;
}
for (int i = 1; i <= n; i++) {
if (!C[c[i]]) {
CC[BB[c[i]]] = i;
CCC[c[i]] = i;
}
C[c[i]] = true;
}
for (int i = 1; i <= n; i++) cnt[a[i]]++;
for (int i = 1; i <= ct; i++)
if (!cnt[i] and vis[i]) remove(i);
int ans = 1000000007, pos = n + 1;
for (int i = n; i >= 1; i--) {
umin(ans, i + s[1]);
cnt[a[i]]--;
if (!cnt[a[i]]) {
if (!C[a[i]] and !B[a[i]]) break;
remove(a[i]);
}
pos = i;
}
printf("%d\n", min(ans, s[1] + 1000000007 * (pos != 1)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[100010], b[100010], c[100010], m, d[100010 * 3];
int aa[100010 * 3], bb[100010 * 3], cc[100010 * 3], cnt[100010 * 3];
set<pair<int, int> > bst;
set<pair<int, int> >::iterator it, l, r;
multiset<int> heap;
void ins(pair<int, int> x) {
r = bst.lower_bound(x);
if (x.second <= r->second) return;
bst.insert(x), l = it = bst.find(x), l--;
heap.erase(heap.lower_bound(l->first + r->second));
heap.insert(it->first + r->second);
while (l->second <= it->second) {
r = l--;
heap.erase(heap.lower_bound(l->first + r->second));
bst.erase(r);
}
heap.insert(l->first + it->second);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), d[++m] = a[i];
for (int i = 1; i <= n; ++i) scanf("%d", &b[i]), d[++m] = b[i];
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]), d[++m] = c[i];
sort(d + 1, d + m + 1);
m = unique(d + 1, d + m + 1) - d - 1;
for (int i = 1; i <= n; ++i) a[i] = lower_bound(d + 1, d + m + 1, a[i]) - d;
for (int i = 1; i <= n; ++i) b[i] = lower_bound(d + 1, d + m + 1, b[i]) - d;
for (int i = 1; i <= n; ++i) c[i] = lower_bound(d + 1, d + m + 1, c[i]) - d;
for (int i = 1; i <= m; ++i) aa[i] = bb[i] = cc[i] = n * 3;
for (int i = 1; i <= n; ++i) aa[a[i]] = min(aa[a[i]], i);
for (int i = 1; i <= n; ++i) bb[b[i]] = min(bb[b[i]], i);
for (int i = 1; i <= n; ++i) cc[c[i]] = min(cc[c[i]], i);
bst.insert(make_pair(0, n * 4));
bst.insert(make_pair(n * 4, 0));
heap.insert(0);
for (int i = 1; i <= n; ++i) ++cnt[a[i]];
for (int i = 1; i <= m; ++i)
if (!cnt[i]) ins(make_pair(bb[i], cc[i]));
int ans = n + *heap.begin();
for (int i = n; i; --i) {
if (!--cnt[a[i]]) ins(make_pair(bb[a[i]], cc[a[i]]));
ans = min(ans, i - 1 + *heap.begin());
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
struct data {
int pa, pb, pc;
};
std::vector<data> da;
int constexpr inf = 1 << 28;
int constexpr maxn = 300007;
int a[maxn], b[maxn], c[maxn];
int n, tot;
std::unordered_map<int, int> pa;
std::unordered_map<int, int> pb;
std::unordered_map<int, int> pc;
std::multiset<int> act;
using pair_type = std::pair<int, int>;
std::set<pair_type> points;
void erase(std::set<pair_type>::iterator const& it) {
auto prev = std::prev(it);
auto next = std::next(it);
act.erase(act.find(prev->first + it->second));
act.erase(act.find(it->first + next->second));
act.insert(prev->first + next->second);
points.erase(it);
}
void insert(pair_type const& p) {
points.insert(p);
auto it = points.lower_bound(p);
auto prev = std::prev(it);
auto next = std::next(it);
if (next->second > it->second) {
points.erase(p);
return;
}
act.insert(prev->first + it->second);
act.insert(it->first + next->second);
act.erase(act.find(prev->first + next->second));
while (true) {
it = std::prev(points.lower_bound(p));
if (it->second < p.second)
erase(it);
else
break;
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin >> n;
std::set<int> numbers;
for (int i = 0; i < n; i++) {
std::cin >> a[i];
numbers.insert(a[i]);
}
for (int i = 0; i < n; i++) {
std::cin >> b[i];
numbers.insert(b[i]);
}
for (int i = 0; i < n; i++) {
std::cin >> c[i];
numbers.insert(c[i]);
}
for (int i = n - 1; i >= 0; i--) pa[a[i]] = pb[b[i]] = pc[c[i]] = i + 1;
da.resize(numbers.size());
int tt = 4 * n;
for (auto i : numbers) {
if (pa.find(i) == pa.end())
da[tot].pa = ++tt;
else
da[tot].pa = pa[i];
if (pb.find(i) == pb.end())
da[tot].pb = ++tt;
else
da[tot].pb = pb[i];
if (pc.find(i) == pc.end())
da[tot].pc = ++tt;
else
da[tot].pc = pc[i];
tot++;
}
std::sort(da.begin(), da.end(),
[](data const& a, data const& b) { return a.pc < b.pc; });
int ans = 3 * n;
points.insert({0, inf});
points.insert({inf, 0});
act.insert(0);
for (int i = tot - 1; i >= 0; i--) {
if (da[i].pc >= 4 * n) {
insert({da[i].pa, da[i].pb});
} else {
ans = std::min(ans, *act.begin() + da[i].pc);
insert({da[i].pa, da[i].pb});
}
}
std::cout << std::min(ans, *act.begin()) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> chain, A, F, B, C;
set<int, greater<int> > L;
multiset<int> mn;
void push(int x, int y) {
map<int, int>::iterator I, J;
if (chain.count(x)) {
I = chain.find(x);
} else {
I = chain.lower_bound(x);
}
int ly = I->second;
if (ly >= y) return;
J = I;
J--;
while (J->second <= y) {
mn.erase(mn.find(J->first + ly));
ly = J->second;
chain.erase(J);
J = I;
J--;
}
mn.erase(mn.find(J->first + ly));
mn.insert(J->first + y);
if (!chain.count(x)) {
chain[x] = y;
mn.insert(x + I->second);
} else
I->second = y;
}
int main() {
chain[0] = 0x0fffffff;
chain[0x0fffffff] = 0;
mn.insert(0);
int N;
scanf("%d", &N);
for (int i = 1, x; i <= N; i++) {
scanf("%d", &x);
L.insert(x);
if (!A.count(x)) A[x] = i, F[-i] = x;
}
for (int i = 1, x; i <= N; i++) {
scanf("%d", &x);
L.insert(x);
if (!B.count(x)) B[x] = i;
}
for (int i = 1, x; i <= N; i++) {
scanf("%d", &x);
L.insert(x);
if (!C.count(x)) C[x] = i;
}
for (auto p : L) {
if (!A.count(p)) {
int x = B.count(p) ? B[p] : 0x0ffffffe;
int y = C.count(p) ? C[p] : 0x0ffffffe;
push(x, y);
}
}
int ans = 3 * N;
for (auto u : F) {
int p = u.second;
if (A.count(p)) {
if (ans > *mn.begin() + A[p]) ans = *mn.begin() + A[p];
int x = B.count(p) ? B[p] : 0x0ffffffe;
int y = C.count(p) ? C[p] : 0x0ffffffe;
push(x, y);
}
}
if (ans > *mn.begin()) ans = *mn.begin();
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const int MAXV = 3 * MAXN;
const int INF = 0x01010101;
bool compx(pair<int, int> p1, pair<int, int> p2) {
p1.second *= -1;
p2.second *= -1;
return p1 < p2;
}
bool compy(pair<int, int> p1, pair<int, int> p2) {
return pair<int, int>(p1.second, -p1.first) <
pair<int, int>(p2.second, -p2.first);
}
int N;
int A[3][MAXN];
int M;
vector<int> vals;
int fst[MAXV][3];
int ind[MAXV];
int main() {
scanf("%d", &N);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < N; j++) {
scanf("%d", &A[i][j]);
vals.push_back(A[i][j]);
}
}
sort((vals).begin(), (vals).end());
vals.resize(unique((vals).begin(), (vals).end()) - vals.begin());
M = vals.size();
for (int i = 0; i < M; i++) {
for (int j = 0; j < 3; j++) {
fst[i][j] = INF;
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < N; j++) {
int &x = A[i][j];
x = lower_bound((vals).begin(), (vals).end(), x) - vals.begin();
fst[x][i] = min(fst[x][i], j + 1);
}
}
iota(ind, ind + M + 1, 0);
sort(ind, ind + M, [](int x, int y) { return fst[x][0] > fst[y][0]; });
int ans = fst[ind[0]][0];
set<pair<int, int> > st = {pair<int, int>(0, 2 * INF),
pair<int, int>(2 * INF, 0)};
multiset<int> mst = {0};
for (int i = 0; i < M; i++) {
int x = fst[ind[i]][1], y = fst[ind[i]][2];
set<pair<int, int> >::iterator lt, it,
rt = st.lower_bound(pair<int, int>(x, y));
assert(rt != st.end());
if (rt->second < y) {
it = st.insert(pair<int, int>(x, y)).first;
lt = prev(it);
mst.erase(mst.find(lt->first + rt->second));
mst.insert(it->first + rt->second);
while (lt->second < it->second) {
rt = lt--;
mst.erase(mst.find(lt->first + rt->second));
st.erase(rt);
}
mst.insert(lt->first + it->second);
}
ans = min(ans, fst[ind[i + 1]][0] + *mst.begin());
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e7;
const int MN = 1e5 + 7;
struct int3 {
int a[3];
bool operator<(const int3 &x) const { return a[0] > x.a[0]; }
} ept;
int n, t, ans = INF;
int3 f[MN * 3];
map<int, int3> mp;
map<int, int3>::iterator mi;
set<pair<int, int> > u;
set<pair<int, int> >::iterator ui, ii;
multiset<int> res;
void gao(int x, int y) {
ui = u.upper_bound(pair<int, int>(x, y));
if (ui->second >= y) return;
pair<int, int> pre = *ui;
ii = ui;
ii--;
while (ii->second <= y) {
res.erase(res.find(ii->first + pre.second));
pre = *ii;
ii--;
u.erase(pre);
}
res.erase(res.find(ii->first + pre.second));
res.insert(ii->first + y);
res.insert(x + ui->second);
u.insert(pair<int, int>(x, y));
}
int main() {
scanf("%d", &n);
int i, j, k, l;
for (i = 0; i < 3; i++) ept.a[i] = INF;
for (i = 0; i < 3; i++) {
for (j = 1; j <= n; j++) {
scanf("%d", &k);
if (mp.find(k) == mp.end()) mp[k] = ept;
mp[k].a[i] = min(mp[k].a[i], j);
}
}
for (mi = mp.begin(); mi != mp.end(); mi++) f[t++] = mi->second;
sort(f, f + t);
f[t].a[0] = 0;
u.insert(pair<int, int>(0, INF * 2));
u.insert(pair<int, int>(INF * 2, 0));
res.insert(0);
l = 0;
k = INF;
for (i = 0; i <= t; i++) {
ans = min(ans, *res.begin() + f[i].a[0]);
gao(f[i].a[1], f[i].a[2]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
multiset<int> li;
multiset<pair<int, int> > ha;
set<pair<int, int> >::iterator it, ti;
pair<int, int> a[100050 * 3];
int wz[100050 * 3][3], sg[100050 * 3], n, m, st, ans = 3 * 100050;
inline int Read() {
int x = 0;
char y;
do y = getchar();
while (y < '0' || y > '9');
do x = x * 10 + y - '0', y = getchar();
while (y >= '0' && y <= '9');
return x;
}
void Pretreat() {
sort(a + 1, a + n * 3 + 1);
for (int i = 1; i <= n * 3; i++) {
st++;
int ri = i;
while (ri < n * 3 && a[ri + 1].first == a[ri].first) ri++;
for (int j = ri; j >= i; j--)
if (a[j].second > n * 2)
wz[st][2] = a[j].second - n * 2;
else if (a[j].second > n)
wz[st][1] = a[j].second - n;
else
wz[st][0] = a[j].second;
i = ri;
}
for (int i = 1; i <= st; i++)
for (int j = 0; j < 3; j++)
if (!wz[i][j]) wz[i][j] = 100050 * 3;
return;
}
inline bool cmp(int x, int y) { return wz[x][2] < wz[y][2]; }
inline void Erase(int x) { li.erase(li.lower_bound(x)); }
void Insert(int x) {
it = ha.lower_bound(make_pair(wz[x][0], wz[x][1]));
if (it->second >= wz[x][1]) return;
ha.insert(make_pair(wz[x][0], wz[x][1]));
it = ti = ha.lower_bound(make_pair(wz[x][0], wz[x][1]));
pair<int, int> Now = *(++ti);
while (true) {
ti = it;
ti--;
if (ti->second <= it->second)
Erase(ti->first + Now.second), Now = *ti, ha.erase(ti);
else
break;
}
Erase(ti->first + Now.second);
ti = it;
li.insert((--ti)->first + it->second);
ti = it;
li.insert((++ti)->second + it->first);
return;
}
int Get() { return li.begin() == li.end() ? 0 : *li.begin(); }
void Solve() {
li.insert(0);
ha.insert(make_pair(0, 0x3f7f7f7f));
ha.insert(make_pair(0x3f7f7f7f, 0));
for (int i = 1; i <= st; i++) sg[i] = i;
sort(sg + 1, sg + st + 1, cmp);
for (int i = st; i >= 1; i--) {
ans = min(ans, Get() + wz[sg[i]][2]);
Insert(sg[i]);
while (i - 1 && wz[sg[i]][2] == wz[sg[i - 1]][2]) Insert(sg[--i]);
}
ans = min(ans, Get());
}
int main() {
n = Read();
for (int j = 0; j < 3; j++)
for (int i = 1; i <= n; i++) a[n * j + i] = make_pair(Read(), n * j + i);
Pretreat();
Solve();
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int n, a[100010], b[100010], c[100010], tot;
int fa[300010] = {0}, fb[300010] = {0}, fc[300010] = {0};
struct forsort {
int val, id1, id2;
} f[300010];
struct Pair {
int b, c;
};
bool operator<(Pair a, Pair b) { return a.b < b.b; }
set<Pair> s;
set<Pair>::iterator it;
multiset<int> vals;
multiset<int>::iterator valit;
bool cmp(forsort a, forsort b) { return a.val < b.val; }
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &f[++tot].val);
f[tot].id1 = 1, f[tot].id2 = i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &f[++tot].val);
f[tot].id1 = 2, f[tot].id2 = i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &f[++tot].val);
f[tot].id1 = 3, f[tot].id2 = i;
}
sort(f + 1, f + 3 * n + 1, cmp);
tot = 0;
for (int i = 1; i <= 3 * n; i++) {
if (i == 1 || f[i].val != f[i - 1].val) tot++;
if (f[i].id1 == 1) a[f[i].id2] = tot;
if (f[i].id1 == 2) b[f[i].id2] = tot;
if (f[i].id1 == 3) c[f[i].id2] = tot;
}
for (int i = 1; i <= n; i++)
if (!fa[a[i]]) fa[a[i]] = i;
for (int i = 1; i <= n; i++)
if (!fb[b[i]]) fb[b[i]] = i;
for (int i = 1; i <= n; i++)
if (!fc[c[i]]) fc[c[i]] = i;
}
void insertPair(int newb, int newc) {
int nowb, nowc;
Pair e = {newb, newc};
it = s.upper_bound(e);
if ((*it).c >= e.c) return;
nowc = (*it).c;
it--;
valit = vals.find((*it).b + nowc);
vals.erase(valit);
while ((*it).c <= e.c) {
nowb = (*it).b, nowc = (*it).c;
it--;
vals.erase((*it).b + nowc);
it++;
s.erase(it);
it = s.lower_bound(e);
it--;
}
nowb = (*it).b, nowc = (*it).c;
vals.insert(nowb + e.c);
it++;
nowc = (*it).c;
vals.insert(e.b + nowc);
s.insert(e);
}
void work() {
Pair e;
e.b = 0, e.c = inf + 1;
s.insert(e);
e.b = inf + 1, e.c = 0;
s.insert(e);
vals.insert(0);
for (int i = 1; i <= tot; i++)
if (!fa[i]) insertPair(fb[i] ? fb[i] : inf, fc[i] ? fc[i] : inf);
int ans = inf;
bool flag = 1;
for (int i = n; i >= 1; i--) {
ans = min(ans, i + (*vals.begin()));
if (fa[a[i]] == i) {
if (!fb[a[i]] && !fc[a[i]]) {
flag = 0;
break;
}
insertPair(fb[a[i]] ? fb[a[i]] : inf, fc[a[i]] ? fc[a[i]] : inf);
}
}
if (flag) ans = min(ans, (*vals.begin()));
printf("%d", ans);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, m, ans, a[N], b[N], c[N], id[N], V[N], A[N], B[N], C[N];
multiset<int> res;
set<pair<int, int> > H;
set<int> svdecomposition;
bool cmp(const int i, const int j) { return A[i] > A[j]; }
void ins(pair<int, int> z) {
set<pair<int, int> >::iterator l, i, r = H.lower_bound(z);
if (r->second >= z.second) return;
i = H.insert(z).first, l = i, --l, res.erase(res.find(l->first + r->second)),
res.insert(i->first + r->second);
while (l->second < i->second)
r = l--, res.erase(res.find(l->first + r->second)), H.erase(r);
res.insert(l->first + i->second);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", a + i), V[m++] = a[i];
for (int i = 0; i < n; ++i) scanf("%d", b + i), V[m++] = b[i];
for (int i = 0; i < n; ++i) scanf("%d", c + i), V[m++] = c[i];
int once;
sort(V, V + m), m = unique(V, V + m) - V;
for (int i = 0; i < n; ++i) a[i] = lower_bound(V, V + m, a[i]) - V;
for (int i = 0; i < n; ++i) b[i] = lower_bound(V, V + m, b[i]) - V;
for (int i = 0; i < n; ++i) c[i] = lower_bound(V, V + m, c[i]) - V;
for (int i = 0; i < m; ++i) A[i] = B[i] = C[i] = 3 * n;
for (int i = 0; i < n; ++i)
if (A[a[i]] > n) A[a[i]] = i + 1;
for (int i = 0; i < n; ++i)
if (B[b[i]] > n) B[b[i]] = i + 1;
for (int i = 0; i < n; ++i)
if (C[c[i]] > n) C[c[i]] = i + 1;
int twicr;
for (int i = 0; i < m + 1; ++i) id[i] = i;
A[m] = 0, sort(id, id + m, cmp);
H.insert(make_pair(0, 4 * n)), H.insert(make_pair(4 * n, 0)), res.insert(0),
ans = A[*id];
for (int i = 0; i < m; ++i)
ins(make_pair(B[id[i]], C[id[i]])),
ans = min(ans, A[id[i + 1]] + *res.begin());
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int n;
int u;
int seg[4 * maxn];
int lazy[4 * maxn];
int max1[4 * maxn];
int min1[4 * maxn];
int a[maxn];
int b[maxn];
int c[maxn];
int d[3 * maxn];
int w[3 * maxn];
int f[3 * maxn];
int a1[3 * maxn];
int b1[3 * maxn];
int c1[3 * maxn];
int cnt;
int s;
int m;
bool check;
vector<int> ans;
inline void compress();
inline void ans2();
inline void ans3();
inline void ok_w();
inline void ok_updseg();
inline void ok_forbuildseg();
void build(int v, int l, int r);
inline void ok_seg();
inline void ok_array();
void ok_ans();
int get(int v, int l, int r, int u, int t);
void update(int v, int l, int r, int k, int e, int val);
void shift();
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];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
cin >> c[i];
}
compress();
ans2();
ans3();
ok_w();
ok_updseg();
ok_forbuildseg();
build(1, 0, n);
ok_ans();
sort(ans.begin(), ans.end());
cout << min(ans[0], m);
}
inline void compress() {
for (int i = 0; i < n; i++) {
d[i * 3] = a[i];
d[i * 3 + 1] = b[i];
d[i * 3 + 2] = c[i];
}
sort(d, d + 3 * n);
u = unique(d, d + (3 * n)) - d;
for (int i = 0; i < n; i++) {
a[i] = lower_bound(d, d + u, a[i]) - d;
b[i] = lower_bound(d, d + u, b[i]) - d;
c[i] = lower_bound(d, d + u, c[i]) - d;
}
return;
}
inline void ans2() {
for (int i = 0; i < n; i++) {
if (f[a[i]] == 0) {
cnt++;
}
if (cnt == u) {
m = i + 1;
cnt++;
}
f[a[i]]++;
}
fill(f, f + 3 * maxn, 0);
cnt = 0;
for (int i = 0; i < n; i++) {
if (f[b[i]] == 0) {
cnt++;
}
if (cnt == u) {
if (m == 0) {
m = i + 1;
cnt++;
} else {
m = min(m, i + 1);
cnt++;
}
}
f[b[i]]++;
}
fill(f, f + 3 * maxn, 0);
cnt = 0;
for (int i = 0; i < n; i++) {
if (f[c[i]] == 0) {
cnt++;
}
if (cnt == u) {
if (m == 0) {
m = i + 1;
cnt++;
} else {
m = min(m, i + 1);
cnt++;
}
}
f[c[i]]++;
}
if (m == 0) {
m = 3 * n + 1;
}
fill(f, f + 3 * maxn, 0);
cnt = 0;
}
inline void ans3() {
for (int i = 0; i < n; i++) {
if (f[a[i]] == 0) {
cnt++;
}
f[a[i]]++;
}
int j = 0;
for (int i = n - 1; i >= 0; i--) {
for (; j < n && cnt != u; j++) {
if (f[c[j]] == 0) {
cnt++;
}
f[c[j]]++;
}
if (cnt == u) {
m = min(i + 1 + j, m);
}
if (f[a[i]] == 1) {
cnt--;
}
f[a[i]]--;
}
fill(f, f + 3 * maxn, 0);
cnt = 0;
}
inline void ok_w() {
for (int i = 0; i < n; i++) {
w[a[i]]++;
if (w[a[i]] == 1) {
cnt++;
}
}
}
inline void ok_updseg() {
fill(a1, a1 + 3 * maxn, -1);
fill(b1, b1 + 3 * maxn, -1);
fill(c1, c1 + 3 * maxn, -1);
for (int i = 0; i < n; i++) {
if (f[a[i]] == 0) {
a1[a[i]] = i;
f[a[i]]++;
}
}
fill(f, f + 3 * maxn, 0);
for (int i = 0; i < n; i++) {
if (f[b[i]] == 0) {
b1[b[i]] = i;
f[b[i]]++;
}
}
fill(f, f + 3 * maxn, 0);
for (int i = 0; i < n; i++) {
if (f[c[i]] == 0) {
c1[c[i]] = i;
f[c[i]]++;
}
}
return;
}
inline void ok_forbuildseg() {
fill(f, f + 3 * maxn, 0);
for (int i = 0; i < n; i++) {
if (w[b[i]] == 0) {
w[b[i]]++;
cnt++;
} else {
w[b[i]]++;
}
}
int j = 0;
for (int i = n - 1; i >= 0; i--) {
for (; j < n && cnt != u; j++) {
if (w[c[j]] == 0) {
cnt++;
w[c[j]]++;
} else {
w[c[j]]++;
}
}
if (cnt != u) {
s = max(s, i + 1);
}
f[i] = j - 1;
if (cnt == u) {
ans.emplace_back(f[i] + 1 + n + i + 1);
}
if (i >= 0) {
if (w[b[i]] == 1) {
cnt--;
}
w[b[i]]--;
}
}
}
void build(int v, int l, int r) {
if (r - l == 1) {
seg[v] = (r + f[l] + 1);
max1[v] = f[l] + 1;
min1[v] = f[l] + 1;
return;
}
int mid = l + r;
mid /= 2;
build((v << 1), l, mid);
build((v << 1) + 1, mid, r);
min1[v] = min(min1[(v << 1)], min1[(v << 1) + 1]);
max1[v] = max(max1[v << 1], max1[(v << 1) + 1]);
seg[v] = min(seg[v << 1], seg[(v << 1) + 1]);
return;
}
inline void ok_array(int v) {
if (c1[v] == -1 && b1[v] == -1) {
check = true;
} else if (c1[v] == -1) {
s = max(s, b1[v]);
} else if (b1[v] == -1) {
update(1, 0, n, s, n, c1[v]);
} else {
if (s <= b1[v]) {
update(1, 0, n, s, b1[v], c1[v]);
}
}
return;
}
void ok_ans() {
fill(lazy, lazy + 4 * maxn, -1);
for (int i = n - 1; i >= 0; i--) {
if (a1[a[i]] == i) {
w[a[i]]--;
ok_array(a[i]);
} else {
w[a[i]]--;
}
if (check == false) {
ans.emplace_back(get(1, 0, n, s, n) + i);
}
}
}
void shift(int v, int l, int r) {
if (lazy[v] != -1) {
lazy[v << 1] = lazy[v];
lazy[(v << 1) + 1] = lazy[v];
seg[(v << 1)] = l + 1 + lazy[v];
seg[(v << 1) + 1] = (l + r) / 2 + 1 + lazy[v];
min1[v << 1] = lazy[v];
min1[(v << 1) + 1] = lazy[v];
max1[v << 1] = lazy[v];
max1[(v << 1) + 1] = lazy[v];
lazy[v] = -1;
return;
}
return;
}
int get(int v, int l, int r, int u, int t) {
if (u <= l && r <= t) {
shift(v, l, r);
return seg[v];
}
if (l >= t || r <= u) {
shift(v, l, r);
return 10000000;
}
shift(v, l, r);
min1[v] = min(min1[(v << 1)], min1[(v << 1) + 1]);
max1[v] = max(max1[v << 1], max1[(v << 1) + 1]);
seg[v] = min(seg[v << 1], seg[(v << 1) + 1]);
return min(get(v << 1, l, (l + r) >> 1, u, t),
get((v << 1) + 1, (l + r) >> 1, r, u, t));
}
void update(int v, int l, int r, int k, int t, int val) {
if (max1[v] == min1[v] && max1[v] < val + 1 && k <= l && r <= t) {
shift(v, l, r);
seg[v] = val + l + 2;
lazy[v] = val + 1;
min1[v] = val + 1;
max1[v] = val + 1;
return;
}
if (min1[v] >= val + 1 || (r <= k || t <= l)) {
shift(v, l, r);
return;
}
shift(v, l, r);
int mid = l + r;
mid /= 2;
update(v << 1, l, mid, k, t, val);
update((v << 1) + 1, mid, r, k, t, val);
min1[v] = min(min1[(v << 1)], min1[(v << 1) + 1]);
max1[v] = max(max1[v << 1], max1[(v << 1) + 1]);
seg[v] = min(seg[v << 1], seg[(v << 1) + 1]);
return;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int mo = 1000000007;
const int inf = (int)1e9;
inline int IN() {
char ch;
(ch = getchar());
int f = 0, x = 0;
for (; ((ch) == '\n' || (ch) == '\r' || (ch) == '\t' || (ch) == ' ');
(ch = getchar()))
;
if (ch == '-') f = 1, (ch = getchar());
for (; !((ch) == '\n' || (ch) == '\r' || (ch) == '\t' || (ch) == ' ');
(ch = getchar()))
x = x * 10 + ch - '0';
return (f) ? (-x) : (x);
}
int Pow(int x, int y, int p) {
int A = 1;
for (; y; y >>= 1, x = (long long)x * x % p)
if (y & 1) A = (long long)A * x % p;
return A;
}
int a[N], b[N], c[N], d[N], n, m, res, ztw;
struct node {
int u, v, w;
void reset() {
if (!u) u = inf + ztw, ++ztw;
if (!v) v = inf + ztw, ++ztw;
if (!w) w = inf + ztw, ++ztw;
}
} A[N];
struct po {
double x, y;
po operator+(const po &a) const { return (po){x + a.x, y + a.y}; }
po operator-(const po &a) const { return (po){x - a.x, y - a.y}; }
double operator*(const po &a) const { return x * a.y - y * a.x; }
int operator<(const po &a) const { return x < a.x; }
};
set<po> st;
multiset<double> ans;
inline int cmp(const node &A, const node &B) { return A.u < B.u; }
double calc(po x, po y) { return x.x + y.y; }
void insert(int x, int y) {
po tmp = (po){(double)x, (double)y};
auto u = st.lower_bound(tmp);
if (u->y >= tmp.y) return;
auto v = u;
--v;
ans.erase(ans.lower_bound(calc(*v, *u)));
ans.insert(calc(tmp, *u));
u = v;
while (1) {
if (u->y >= tmp.y) break;
auto v = u;
--v;
ans.erase(ans.find(calc(*v, *u)));
st.erase(u);
u = v;
}
ans.insert(calc(*u, tmp));
st.insert(tmp);
}
int main() {
scanf("%d", &n);
for (int i = (int)1; i <= (int)n; i++) scanf("%d", a + i);
for (int i = (int)1; i <= (int)n; i++) scanf("%d", b + i);
for (int i = (int)1; i <= (int)n; i++) scanf("%d", c + i);
for (int i = (int)1; i <= (int)n; i++) {
d[++m] = a[i];
d[++m] = b[i];
d[++m] = c[i];
}
sort(d + 1, d + m + 1);
m = unique(d + 1, d + m + 1) - (d + 1);
for (int i = (int)1; i <= (int)n; i++) {
a[i] = lower_bound(d + 1, d + m + 1, a[i]) - d;
b[i] = lower_bound(d + 1, d + m + 1, b[i]) - d;
c[i] = lower_bound(d + 1, d + m + 1, c[i]) - d;
}
for (int i = (int)1; i <= (int)n; i++) {
if (!A[a[i]].u) A[a[i]].u = i;
if (!A[b[i]].v) A[b[i]].v = i;
if (!A[c[i]].w) A[c[i]].w = i;
}
for (int i = (int)1; i <= (int)m; i++) A[i].reset();
sort(A + 1, A + m + 1, cmp);
res = 3 * n;
st.insert((po){inf + inf, 0});
st.insert((po){0, inf + inf});
ans.insert(0);
for (int i = (int)m; i >= (int)0; i--) {
double u = *(ans.begin());
if (!ans.size()) u = inf;
if (st.size()) {
u = min(u, st.begin()->y);
u = min(u, st.rbegin()->x);
}
res = min(res, A[i].u + (int)u);
insert(A[i].v, A[i].w);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int kN = int(3E5 + 10);
struct seg_tree {
int val[kN << 2], flag[kN << 2];
void addtag(int n, int x) {
flag[n] += x;
val[n] += x;
return;
}
void pull(int n) {
val[n] = min(val[n << 1], val[n << 1 | 1]);
return;
}
void push(int n) {
if (flag[n]) {
addtag(n << 1, flag[n]);
addtag(n << 1 | 1, flag[n]);
flag[n] = 0;
}
return;
}
void add(int n, int l, int r, int L, int R, int x) {
if (L <= l && r <= R)
addtag(n, x);
else if (!(l > R || L > r)) {
int mid = (l + r) >> 1;
push(n);
add(n << 1, l, mid, L, R, x);
add(n << 1 | 1, mid + 1, r, L, R, x);
pull(n);
}
}
int fval(int n, int l, int r, int pos) {
if (l == r)
return val[n];
else {
int mid = (l + r) >> 1;
push(n);
if (pos <= mid)
return fval(n << 1, l, mid, pos);
else
return fval(n << 1 | 1, mid + 1, r, pos);
}
}
int fpos(int n, int l, int r, int nv) {
if (l == r)
return l;
else {
int mid = (l + r) >> 1;
push(n);
if (val[n << 1] > nv)
return fpos(n << 1 | 1, mid + 1, r, nv);
else
return fpos(n << 1, l, mid, nv);
}
}
pair<int, int> ask(int n, int l, int r, int pos) {
int nv = fval(n, l, r, pos);
return make_pair(nv, fpos(n, l, r, nv));
}
};
int a[kN], b[kN], c[kN], va[kN], vb[kN], vc[kN], sz, idx[kN];
tuple<int, int, int> p[kN];
seg_tree sg_C, sg_BC;
int main() {
int n, ans = kN, lst, npos;
pair<int, int> tmp;
vector<int> v;
vector<tuple<int, int, int, int>> events;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 1; i <= n; i++) v.push_back(a[i]);
for (int i = 1; i <= n; i++) v.push_back(b[i]);
for (int i = 1; i <= n; i++) v.push_back(c[i]);
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
sz = int(v.size());
for (int i = 1; i <= sz; i++) va[i] = vb[i] = vc[i] = kN;
for (int i = 1; i <= n; i++)
a[i] = lower_bound(v.begin(), v.end(), a[i]) - v.begin() + 1;
for (int i = 1; i <= n; i++)
b[i] = lower_bound(v.begin(), v.end(), b[i]) - v.begin() + 1;
for (int i = 1; i <= n; i++)
c[i] = lower_bound(v.begin(), v.end(), c[i]) - v.begin() + 1;
for (int i = 1; i <= n; i++)
if (va[a[i]] == kN) va[a[i]] = i;
for (int i = 1; i <= n; i++)
if (vb[b[i]] == kN) vb[b[i]] = i;
for (int i = 1; i <= n; i++)
if (vc[c[i]] == kN) vc[c[i]] = i;
for (int i = 1; i <= sz; i++) p[i] = make_tuple(vb[i], vc[i], i);
sort(p + 1, p + sz + 1);
for (int i = 1; i <= sz; i++) idx[get<2>(p[i])] = i;
for (int i = 1; i <= sz; i++)
events.push_back(make_tuple(va[i], idx[i], vb[i], vc[i]));
sort(events.begin(), events.end(), greater<tuple<int, int, int, int>>());
lst = get<0>(events[0]);
memset(&sg_C, 0, sizeof(sg_C));
memset(&sg_BC, 0, sizeof(sg_BC));
ans = min(ans, lst);
sg_BC.add(1, 0, sz, 1, sz, kN);
for (tuple<int, int, int, int> i : events) {
if (get<0>(i) < lst) {
lst = get<0>(i);
ans = min(ans, lst + sg_BC.val[1]);
}
npos = get<1>(i);
sg_BC.add(1, 0, sz, npos, npos, get<2>(i) - kN);
npos--;
while (0 <= npos) {
tmp = sg_C.ask(1, 0, sz, npos);
if (tmp.first < get<3>(i)) {
sg_C.add(1, 0, sz, tmp.second, npos, get<3>(i) - tmp.first);
sg_BC.add(1, 0, sz, tmp.second, npos, get<3>(i) - tmp.first);
npos = tmp.second - 1;
} else
break;
}
}
ans = min(ans, sg_BC.val[1]);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, gs, ans = 1e9, Xma, Yma, ma[N], a[N], b[N], c[N], d[N], La[N], Lb[N],
Lc[N], lst[N], tree[N * 4], mi[N * 4], lazy[N * 4];
inline int read() {
int ret = 0, f = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
ret = ret * 10 + c - 48;
c = getchar();
}
if (f) return -ret;
return ret;
}
void build(int nod, int l, int r) {
if (l == r) {
tree[nod] = mi[nod] = l;
return;
}
int mid = (l + r) / 2;
build(nod * 2, l, mid);
build(nod * 2 + 1, mid + 1, r);
tree[nod] = min(tree[nod * 2], tree[nod * 2 + 1]);
mi[nod] = min(mi[nod * 2], mi[nod * 2 + 1]);
}
void pushdown(int nod) {
if (!lazy[nod]) return;
mi[nod * 2] = max(mi[nod * 2], tree[nod * 2] + lazy[nod]);
mi[nod * 2 + 1] = max(mi[nod * 2 + 1], tree[nod * 2 + 1] + lazy[nod]);
lazy[nod * 2] = max(lazy[nod * 2], lazy[nod]);
lazy[nod * 2 + 1] = max(lazy[nod * 2 + 1], lazy[nod]);
ma[nod * 2] = max(ma[nod * 2], lazy[nod]);
ma[nod * 2 + 1] = max(ma[nod * 2 + 1], lazy[nod]);
lazy[nod] = 0;
}
void change(int nod, int l, int r, int L, int R, int val) {
if (l == L && r == R) {
ma[nod] = max(ma[nod], val);
mi[nod] = max(mi[nod], tree[nod] + val);
lazy[nod] = max(lazy[nod], val);
return;
}
pushdown(nod);
int mid = (l + r) / 2;
if (R <= mid)
change(nod * 2, l, mid, L, R, val);
else if (L > mid)
change(nod * 2 + 1, mid + 1, r, L, R, val);
else {
change(nod * 2, l, mid, L, mid, val);
change(nod * 2 + 1, mid + 1, r, mid + 1, R, val);
}
mi[nod] = min(mi[nod * 2], mi[nod * 2 + 1]);
ma[nod] = min(ma[nod * 2], ma[nod * 2 + 1]);
}
int find(int nod, int l, int r, int L, int R) {
if (l == L && r == R) return mi[nod];
pushdown(nod);
int mid = (l + r) / 2;
if (R <= mid)
return find(nod * 2, l, mid, L, R);
else if (L > mid)
return find(nod * 2 + 1, mid + 1, r, L, R);
else
return min(find(nod * 2, l, mid, L, mid),
find(nod * 2 + 1, mid + 1, r, mid + 1, R));
}
int query(int nod, int l, int r, int L, int R) {
if (l == L && r == R) return ma[nod];
pushdown(nod);
int mid = (l + r) / 2;
if (R <= mid)
return query(nod * 2, l, mid, L, R);
else if (L > mid)
return query(nod * 2 + 1, mid + 1, r, L, R);
else
return min(query(nod * 2, l, mid, L, mid),
query(nod * 2 + 1, mid + 1, r, mid + 1, R));
}
int Find(int l, int r, int val) {
if (query(1, 0, n, 0, r) >= val) return n + 1;
while (l < r) {
int mid = (l + r) / 2;
if (query(1, 0, n, 0, mid) >= val)
l = mid + 1;
else
r = mid;
}
return r;
}
signed main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
d[++gs] = a[i];
}
for (int i = 1; i <= n; i++) {
b[i] = read();
d[++gs] = b[i];
}
for (int i = 1; i <= n; i++) {
c[i] = read();
d[++gs] = c[i];
}
sort(d + 1, d + gs + 1);
gs = unique(d + 1, d + gs + 1) - d - 1;
for (int i = 1; i <= n; i++) a[i] = lower_bound(d + 1, d + gs + 1, a[i]) - d;
for (int i = 1; i <= n; i++) b[i] = lower_bound(d + 1, d + gs + 1, b[i]) - d;
for (int i = 1; i <= n; i++) c[i] = lower_bound(d + 1, d + gs + 1, c[i]) - d;
for (int i = 1; i <= gs; i++) lst[i] = 0;
for (int i = 1; i <= n; i++) {
if (lst[a[i]]) continue;
lst[a[i]] = 1;
La[a[i]] = i;
}
for (int i = 1; i <= gs; i++) lst[i] = 0;
for (int i = 1; i <= n; i++) {
if (lst[b[i]]) continue;
lst[b[i]] = 1;
Lb[b[i]] = i;
}
for (int i = 1; i <= gs; i++) lst[i] = 0;
for (int i = 1; i <= n; i++) {
if (lst[c[i]]) continue;
lst[c[i]] = 1;
Lc[c[i]] = i;
}
build(1, 0, n);
for (int i = 1; i <= n; i++)
if ((!La[b[i]]) && (Lb[b[i]] == i)) {
if (!Lc[b[i]]) Xma = max(Xma, i);
}
for (int i = 1; i <= n; i++)
if ((!La[c[i]]) && (Lc[c[i]] == i)) {
if (!Lb[c[i]]) Yma = max(Yma, i);
}
for (int i = 1; i <= n; i++)
if ((!La[b[i]]) && (Lb[b[i]] == i)) {
if (Lc[b[i]]) {
int x = Find(0, i - 1, Lc[b[i]]);
if (x <= i - 1) change(1, 0, n, x, i - 1, Lc[b[i]]);
}
}
int x = Find(0, n, Yma);
if (x <= n) change(1, 0, n, x, n, Yma);
ans = min(ans, n + max(Xma + Yma, find(1, 0, n, Xma, n)));
for (int i = n; i; i--) {
if (La[a[i]] == i) {
if (!Lb[a[i]]) {
if (!Lc[a[i]]) break;
Yma = max(Yma, Lc[a[i]]);
} else if (!Lc[a[i]])
Xma = max(Xma, Lb[a[i]]);
else {
int x = Find(0, Lb[a[i]] - 1, Lc[a[i]]);
if (x <= Lb[a[i]] - 1) change(1, 0, n, x, Lb[a[i]] - 1, Lc[a[i]]);
}
}
int x = Find(0, n, Yma);
if (x <= n) change(1, 0, n, x, n, Yma);
ans = min(ans, i - 1 + max(Xma + Yma, find(1, 0, n, Xma, n)));
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, s, an;
int a[300010], b[300010], c[300010], d[300010], flag[300010], f[300010],
g[300010][3], fa[300010], ff[300010 * 2];
set<pair<int, int> > S;
priority_queue<int> q;
inline void prepare() {
for (i = 1; i <= n; i++) scanf("%d", &a[i]), d[++s] = a[i];
for (i = 1; i <= n; i++) scanf("%d", &b[i]), d[++s] = b[i];
for (i = 1; i <= n; i++) scanf("%d", &c[i]), d[++s] = c[i];
sort(d + 1, d + s + 1);
for (i = 1; i <= s; i++)
if (i == 1 || d[i] > d[m]) d[++m] = d[i];
for (i = 1; i <= n; i++) a[i] = lower_bound(d + 1, d + m + 1, a[i]) - d;
for (i = 1; i <= n; i++) b[i] = lower_bound(d + 1, d + m + 1, b[i]) - d;
for (i = 1; i <= n; i++) c[i] = lower_bound(d + 1, d + m + 1, c[i]) - d;
for (i = 1; i <= n; i++)
if (flag[a[i]] != 1) flag[a[i]] = 1, fa[i] = 1;
for (i = 1; i <= n; i++)
if (flag[b[i]] != 2) flag[b[i]] = 2, g[b[i]][1] = i;
for (i = 1; i <= n; i++)
if (flag[c[i]] != 3) flag[c[i]] = 3, g[c[i]][2] = i;
}
inline void dian(int x) {
if (!flag[x]) s++;
flag[x]++;
}
inline void work1() {
s = 0;
for (i = 1; i <= m; i++) flag[i] = 0;
for (i = 1; i <= n; i++) dian(a[i]);
for (i = 1; i <= n; i++) dian(b[i]);
for (i = 0; i <= n; i++) f[i] = 300010;
for (j = 1; j <= n && s < m; j++) dian(c[j]);
for (i = n; i >= 0; i--) {
f[i] = j - 1;
if (!i) break;
if (!(--flag[b[i]])) s--;
for (; j <= n && s < m; j++) dian(c[j]);
if (s < m) break;
}
}
inline void Into(int x, int y) {
S.insert(make_pair(x, y));
q.push(-x - y);
}
inline void Do(int r, int k) {
set<pair<int, int> >::iterator A = S.lower_bound(make_pair(r + 1, -1));
if (A != S.end() && A->second >= k) return;
int B = -1, C, F = 0;
for (;;) {
A = S.lower_bound(make_pair(r + 1, -1));
A--;
if (A->second == k) F = 1;
if (A->second >= k) break;
if (B < 0) C = A->second;
B = A->first;
ff[A->first + A->second]++;
S.erase(A);
}
if (B < 0) return;
A = S.lower_bound(make_pair(r + 1, -1));
if (r < n && !(A != S.end() && A->first == r + 1)) Into(r + 1, C);
if (!F) Into(B, k);
}
inline void work2() {
S.insert(make_pair(-1, 300010 + 1));
for (i = 0; i <= n; i++)
if (!i || f[i] != f[i - 1]) Into(i, f[i]);
for (i = n; i >= 0; i--) {
int res;
for (; ff[res = -q.top()];) ff[res]--, q.pop();
an = min(an, i + res);
if (!i) break;
int A = a[i];
if (fa[i]) {
int B = g[A][1], C = g[A][2];
if (!B && !C) return;
if (!B)
Do(n, C);
else if (!C)
Do(B - 1, 300010);
else
Do(B - 1, C);
}
}
}
int main() {
scanf("%d", &n);
prepare();
work1();
an = n * 3, work2();
printf("%d\n", an);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, inf = 1e9;
int n, a[N][3], first[N * 3][3], f[N];
vector<int> vec;
void compress() {
for (int j = 0; j < 3; j++)
for (int i = 0; i < n; i++) vec.push_back(a[i][j]);
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (int j = 0; j < 3; j++)
for (int i = 0; i < n; i++)
a[i][j] = lower_bound(vec.begin(), vec.end(), a[i][j]) - vec.begin();
}
struct node {
int mx, mn, best, lazy;
node() { lazy = -1; }
} seg[N << 2];
node merge(node x, node y) {
node ret;
ret.best = min(x.best, y.best);
ret.mx = max(x.mx, y.mx);
ret.mn = min(x.mn, y.mn);
return ret;
}
void build(int id = 1, int b = 0, int e = n + 1) {
if (e - b == 1) {
seg[id].mx = seg[id].mn = f[b];
seg[id].best = f[b] + b;
return;
}
int mid = (b + e) >> 1, lc = id * 2, rc = lc | 1;
build(lc, b, mid);
build(rc, mid, e);
seg[id] = merge(seg[lc], seg[rc]);
}
void shift(int id, int b, int e) {
if (seg[id].lazy != -1) {
int mid = (b + e) >> 1, lc = id * 2, rc = lc | 1;
seg[lc].mx = max(seg[lc].mx, seg[id].lazy);
seg[rc].mx = max(seg[rc].mx, seg[id].lazy);
seg[lc].mn = max(seg[lc].mn, seg[id].lazy);
seg[rc].mn = max(seg[rc].mn, seg[id].lazy);
seg[lc].best = max(seg[lc].best, seg[id].lazy + b);
seg[rc].best = max(seg[rc].best, seg[id].lazy + mid);
seg[lc].lazy = max(seg[lc].lazy, seg[id].lazy);
seg[rc].lazy = max(seg[rc].lazy, seg[id].lazy);
seg[id].lazy = -1;
return;
}
}
void modify(int l, int r, int val, int id = 1, int b = 0, int e = n + 1) {
if (l >= e || b >= r || seg[id].mn >= val) return;
if (l <= b && e <= r && seg[id].mx < val) {
seg[id].best = b + val;
seg[id].mx = seg[id].mn = val;
seg[id].lazy = max(seg[id].lazy, val);
return;
}
int mid = (b + e) >> 1, lc = id * 2, rc = lc | 1;
shift(id, b, e);
modify(l, r, val, lc, b, mid);
modify(l, r, val, rc, mid, e);
seg[id] = merge(seg[lc], seg[rc]);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
memset(first, -1, sizeof first);
for (int j = 0; j < 3; j++)
for (int i = 0; i < n; i++) cin >> a[i][j];
compress();
for (int j = 0; j < 3; j++)
for (int i = 0; i < n; i++)
first[a[i][j]][j] = ((first[a[i][j]][j] == -1) ? i : first[a[i][j]][j]);
set<int> s, total;
for (int i = 0; i < n; i++)
s.insert(first[a[i][2]][2]), total.insert(a[i][1]);
for (int i = 0; i < n; i++)
s.erase(first[a[i][0]][2]), total.erase(a[i][0]), total.erase(a[i][2]);
for (int i = 0; i <= n; i++) {
if (total.size())
f[i] = inf;
else {
if (s.size())
f[i] = (*s.rbegin()) + 1;
else
f[i] = 0;
}
s.erase(first[a[i][1]][2]), total.erase(a[i][1]);
}
build();
int ans = 3 * n;
for (int i = n - 1; ~i; i--) {
ans = min(ans, seg[1].best + i + 1);
if (first[a[i][0]][0] == i) {
int x = first[a[i][0]][1], y = first[a[i][0]][2];
if (x == -1) {
if (y == -1)
modify(0, n + 1, inf);
else
modify(0, n + 1, y + 1);
} else {
if (y == -1)
modify(0, x + 1, inf);
else
modify(0, x + 1, y + 1);
}
}
}
ans = min(ans, seg[1].best);
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int a[300005], b[300005], c[300005];
int fa[300005], fb[300005], fc[300005];
vector<int> vx;
set<pair<int, int> > st;
set<pair<int, int> >::iterator it, its;
multiset<int> score;
multiset<int>::iterator I;
int n;
void add(int id, int val) {
bool up = false;
it = st.lower_bound(pair<int, int>(id + 1, -1));
if (it != st.end() && (*it).first == id + 1) up = true;
it--;
if ((*it).second >= val) return;
int hi = (*it).second;
int l;
while (1) {
if ((*it).second > val) break;
l = (*it).first;
I = score.lower_bound((*it).first + (*it).second);
score.erase(I);
if (it == st.begin()) {
st.erase(it);
break;
} else {
its = it;
its--;
st.erase(it);
it = its;
}
}
st.insert(pair<int, int>(l, val));
score.insert(l + val);
if (id + 1 <= n && !up) {
st.insert(pair<int, int>(id + 1, hi));
score.insert(id + 1 + hi);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
for (int i = 0; i < n; i++) {
vx.push_back(a[i]);
vx.push_back(b[i]);
vx.push_back(c[i]);
}
sort(vx.begin(), vx.end());
vx.erase(unique(vx.begin(), vx.end()), vx.end());
for (int i = 0; i < vx.size(); i++) fa[i] = fb[i] = fc[i] = 100000000;
for (int i = 0; i < n; i++) {
a[i] = lower_bound(vx.begin(), vx.end(), a[i]) - vx.begin();
b[i] = lower_bound(vx.begin(), vx.end(), b[i]) - vx.begin();
c[i] = lower_bound(vx.begin(), vx.end(), c[i]) - vx.begin();
if (fa[a[i]] == 100000000) fa[a[i]] = i;
if (fb[b[i]] == 100000000) fb[b[i]] = i;
if (fc[c[i]] == 100000000) fc[c[i]] = i;
}
st.insert(pair<int, int>(0, 0));
score.insert(0);
for (int i = 0; i < vx.size(); i++) {
if (fa[i] == 100000000) {
add(fb[i], fc[i] + 1);
}
}
int ret = n + (*score.begin());
for (int i = n - 1; i >= 0; i--) {
if (fa[a[i]] == i) add(fb[a[i]], fc[a[i]] + 1);
ret = min(ret, i + (*score.begin()));
}
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
struct node {
int dp;
int mnm;
int mxm;
int lazy;
};
node seg[4 * maxn];
void propagate(int, int, int);
void change(int id, int L, int R, int l, int r, int x) {
if (seg[id].mnm >= x) return;
int mid = (L + R) >> 1;
if (L == l and R == r) {
if (seg[id].mnm == seg[id].mxm) {
seg[id].dp += x - seg[id].mnm;
seg[id].mnm = seg[id].mxm = x;
seg[id].lazy = x;
return;
}
propagate(id, L, R);
change(2 * id + 0, L, mid, L, mid, x);
change(2 * id + 1, mid, R, mid, R, x);
seg[id].mnm = min(seg[2 * id + 0].mnm, seg[2 * id + 1].mnm);
seg[id].mxm = max(seg[2 * id + 1].mxm, seg[2 * id + 1].mxm);
seg[id].dp = min(seg[2 * id + 0].dp, seg[2 * id + 1].dp);
return;
}
propagate(id, L, R);
if (l < mid) change(2 * id + 0, L, mid, l, min(mid, r), x);
if (mid < r) change(2 * id + 1, mid, R, max(l, mid), r, x);
seg[id].mnm = min(seg[2 * id + 0].mnm, seg[2 * id + 1].mnm);
seg[id].mxm = max(seg[2 * id + 0].mxm, seg[2 * id + 1].mxm);
seg[id].dp = min(seg[2 * id + 0].dp, seg[2 * id + 1].dp);
}
void propagate(int id, int L, int R) {
if (seg[id].lazy == 0) return;
int mid = (L + R) >> 1;
change(2 * id + 0, L, mid, L, mid, seg[id].lazy);
change(2 * id + 1, mid, R, mid, R, seg[id].lazy);
seg[id].lazy = 0;
}
void build(int id, int L, int R) {
seg[id].dp = L;
if (L + 1 == R) return;
int mid = (L + R) >> 1;
build(2 * id + 0, L, mid);
build(2 * id + 1, mid, R);
}
int a[5][maxn], last[5][maxn];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> v;
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
v.push_back(a[i][j]);
}
}
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
memset(last, -1, sizeof last);
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
a[i][j] = lower_bound(v.begin(), v.end(), a[i][j]) - v.begin() + 1;
if (last[i][a[i][j]] == -1) last[i][a[i][j]] = j;
}
}
build(1, 0, n + 1);
int max_number = v.size();
int inf = 5 * n;
for (int i = 1; i <= max_number; i++) {
if (last[1][i] == -1) {
if (last[2][i] == -1)
change(1, 0, n + 1, 0, n + 1, last[3][i]);
else {
if (last[3][i] == -1)
change(1, 0, n + 1, 0, last[2][i], inf);
else
change(1, 0, n + 1, 0, last[2][i], last[3][i]);
}
}
}
int answer = 3 * n;
for (int i = n; i >= 0; i--) {
answer = min(answer, seg[1].dp + i);
if (i == 0) break;
if (last[1][a[1][i]] == i) {
if (last[2][a[1][i]] == -1) {
if (last[3][a[1][i]] == -1) break;
change(1, 0, n + 1, 0, n + 1, last[3][a[1][i]]);
} else {
if (last[3][a[1][i]] == -1)
change(1, 0, n + 1, 0, last[2][a[1][i]], inf);
else
change(1, 0, n + 1, 0, last[2][a[1][i]], last[3][a[1][i]]);
}
}
}
cout << answer << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
vector<pair<int, int> > vec[300300];
int main() {
int n;
cin >> n;
map<int, int> all;
map<int, int> pos[3];
for (int i = 0; i < 3; i++)
for (int j = 1; j <= n; j++) {
int first;
gn(first);
all[first] = 1;
if (!pos[i].count(first)) pos[i][first] = j;
}
for (auto p : all) {
int first = p.first;
vec[pos[0].count(first) ? pos[0][first] : 300300 - 1].push_back(
pair<int, int>(pos[1].count(first) ? pos[1][first] : 300300,
pos[2].count(first) ? pos[2][first] : 300300));
}
int ans = 300300;
multiset<int> s;
set<pair<int, int> > point;
point.insert(pair<int, int>(300300 + 1, 0));
point.insert(pair<int, int>(0, 300300 + 1));
s.insert(0);
for (int i = 300300; --i;) {
for (pair<int, int> p : vec[i]) {
auto it = point.lower_bound(p);
if (it->second >= p.second) continue;
while (1) {
auto pre = it;
pre--;
s.erase(s.find(it->second + pre->first));
if (pre->second > p.second) break;
it = pre;
}
it = point.lower_bound(p);
it--;
while (it->second <= p.second) {
auto pre = it;
pre--;
point.erase(it);
it = pre;
}
it = point.insert(p).first;
auto nxt = it, pre = it;
nxt++;
pre--;
s.insert(pre->first + it->second);
s.insert(it->first + nxt->second);
}
smin(ans, i - 1 + *s.begin());
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void gn(int &x) {
x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
}
int n, ans, a[100010], b[100010], c[100010], val[100010 * 3], vt;
int e[100010];
struct node {
int u, v, w;
node() {}
node(int _u, int _v, int _w) {
u = _u;
v = _v;
w = _w;
}
bool operator<(const node &b) const { return u > b.u; }
} d[100010 * 3];
int cov[100010 * 4], mvl[100010 * 4], mans[100010 * 4], mi[100010 * 4];
void cover(int p, int v) {
cov[p] = v;
mvl[p] = v;
mans[p] = mi[p] + v;
}
void down(int p) {
if (cov[p]) {
cover((p << 1), cov[p]);
cover((p << 1) | 1, cov[p]);
cov[p] = 0;
}
}
void up(int p) {
mvl[p] = min(mvl[(p << 1)], mvl[(p << 1) | 1]);
mans[p] = min(mans[(p << 1)], mans[(p << 1) | 1]);
}
int gpos(int p, int l, int r, int v) {
if (l == r) return mvl[p] < v ? l : 0x3f3f3f3f;
int mid = (l + r) >> 1;
down(p);
if (mvl[(p << 1)] < v) return gpos((p << 1), l, mid, v);
return gpos((p << 1) | 1, mid + 1, r, v);
}
void modify(int p, int l, int r, int s, int t, int v) {
if (l == s && r == t) {
cover(p, v);
return;
}
int mid = (l + r) >> 1;
down(p);
if (t <= mid) modify((p << 1), l, mid, s, t, v);
if (s > mid) modify((p << 1) | 1, mid + 1, r, s, t, v);
if (s <= mid && t > mid)
modify((p << 1), l, mid, s, mid, v),
modify((p << 1) | 1, mid + 1, r, mid + 1, t, v);
up(p);
}
void build(int p, int l, int r) {
mi[p] = mans[p] = l;
if (l == r) return;
int mid = (l + r) >> 1;
build((p << 1), l, mid);
build((p << 1) | 1, mid + 1, r);
up(p);
}
int main() {
gn(n);
for (int i = 1; i <= n; ++i) gn(a[i]), val[++vt] = a[i];
for (int i = 1; i <= n; ++i) gn(b[i]), val[++vt] = b[i];
for (int i = 1; i <= n; ++i) gn(c[i]), val[++vt] = c[i];
sort(val + 1, val + vt + 1);
vt = unique(val + 1, val + vt + 1) - val - 1;
for (int i = 1; i <= vt; ++i) d[i] = node(n + 1, n + 1, 0x3f3f3f3f);
int pos;
for (int i = 1; i <= n; ++i) {
pos = lower_bound(val + 1, val + vt + 1, a[i]) - val;
d[pos].u = min(d[pos].u, i);
pos = lower_bound(val + 1, val + vt + 1, b[i]) - val;
d[pos].v = min(d[pos].v, i);
pos = lower_bound(val + 1, val + vt + 1, c[i]) - val;
d[pos].w = min(d[pos].w, i);
}
sort(d + 1, d + vt + 1);
int t = 1;
ans = 3 * n;
build(1, 0, n);
for (int U = n; U >= 0; --U) {
while (t <= vt && d[t].u > U) {
int pos = gpos(1, 0, n, d[t].w);
if (pos <= d[t].v - 1) modify(1, 0, n, pos, d[t].v - 1, d[t].w);
++t;
}
ans = min(ans, mans[1] + U);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
class splay_treap {
public:
int b, c, l, mn;
} st[4 * N];
class splay_trick {
public:
int a, b, c;
bool operator<(splay_trick x) const { return a > x.a; }
} seen[N];
int n, i, bas, son, ans;
int x[N], y[N], z[N];
vector<int> v;
void push(int root, int bas, int son) {
if (st[root].l) {
st[(root + root)].l = st[(root + root + 1)].l = st[root].l;
st[(root + root)].c = st[(root + root + 1)].c = st[root].l;
st[(root + root)].mn = st[(root + root)].c + st[(root + root)].b;
st[(root + root + 1)].mn =
st[(root + root + 1)].c + st[(root + root + 1)].b;
st[root].l = 0;
}
}
void update2(int root, int bas, int son, int x, int y, int v) {
if (bas > y or son < x) return;
if (x <= bas and son <= y) {
st[root].l = st[root].c = v;
st[root].mn = st[root].c + st[root].b;
return;
}
push(root, bas, son);
update2((root + root), bas, ((bas + son) / 2), x, y, v);
update2((root + root + 1), ((bas + son) / 2) + 1, son, x, y, v);
st[root].c = max(st[(root + root)].c, st[(root + root + 1)].c);
st[root].mn = min(st[(root + root)].mn, st[(root + root + 1)].mn);
}
void update(int root, int bas, int son, int x) {
if (bas > x or son < x) return;
if (bas == son) {
st[root].b = x;
st[root].mn = st[root].b + st[root].c;
return;
}
push(root, bas, son);
update((root + root), bas, ((bas + son) / 2), x);
update((root + root + 1), ((bas + son) / 2) + 1, son, x);
st[root].b = min(st[(root + root)].b, st[(root + root + 1)].b);
st[root].mn = min(st[(root + root)].mn, st[(root + root + 1)].mn);
}
int query(int root, int bas, int son, int x) {
if (bas > x or son < x) return 0;
if (bas == son) return st[root].c;
push(root, bas, son);
return query((root + root), bas, ((bas + son) / 2), x) +
query((root + root + 1), ((bas + son) / 2) + 1, son, x);
}
void init(int root, int bas, int son) {
st[root].mn = st[root].b = inf;
st[root].l = st[root].c = 0;
if (bas == son) return;
init((root + root), bas, ((bas + son) / 2));
init((root + root + 1), ((bas + son) / 2) + 1, son);
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", x + i);
v.push_back(x[i]);
}
for (i = 1; i <= n; i++) {
scanf("%d", y + i);
v.push_back(y[i]);
}
for (i = 1; i <= n; i++) {
scanf("%d", z + i);
v.push_back(z[i]);
}
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
int s = v.size();
for (i = 0; i < N; i++) seen[i].a = seen[i].b = seen[i].c = inf;
for (i = 1; i <= n; i++) {
x[i] = lower_bound(v.begin(), v.end(), x[i]) - v.begin() + 1;
if (seen[x[i]].a == inf) seen[x[i]].a = i;
}
for (i = 1; i <= n; i++) {
y[i] = lower_bound(v.begin(), v.end(), y[i]) - v.begin() + 1;
if (seen[y[i]].b == inf) seen[y[i]].b = i;
}
for (i = 1; i <= n; i++) {
z[i] = lower_bound(v.begin(), v.end(), z[i]) - v.begin() + 1;
if (seen[z[i]].c == inf) seen[z[i]].c = i;
}
sort(seen + 1, seen + s + 1);
init(1, 0, n);
seen[s + 1].a = 0;
ans = seen[1].a;
for (i = 1; i <= s; i++) {
if (seen[i].b != inf) update(1, 0, n, seen[i].b);
bas = 0;
son = min(n, seen[i].b - 1);
while (bas < son) {
int ort = bas + son >> 1;
if (query(1, 0, n, ort) > seen[i].c)
bas = ort + 1;
else
son = ort;
}
if (query(1, 0, n, bas) <= seen[i].c)
update2(1, 0, n, bas, min(n, seen[i].b - 1), seen[i].c);
ans = min(ans, st[1].mn + seen[i + 1].a);
ans = min(ans, st[1].c + seen[i + 1].a);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5, inf = 3e5 + 5;
unordered_map<int, int> MA, MB, MC;
int a[maxn], b[maxn], c[maxn], mn[4 * maxn], mx[4 * maxn], seg[4 * maxn],
lazy[4 * maxn];
void build(int id, int L, int R) {
if (R == L + 1) {
seg[id] = L;
return;
}
int mid = (L + R) / 2;
build(2 * id + 0, L, mid);
build(2 * id + 1, mid, R);
seg[id] = L;
}
void relax(int id, int L, int mid) {
int x = lazy[id];
lazy[id] = -1;
if (~x) {
mn[2 * id + 0] = x;
mn[2 * id + 1] = x;
mx[2 * id + 0] = x;
mx[2 * id + 1] = x;
seg[2 * id + 0] = x + L;
seg[2 * id + 1] = x + mid;
lazy[2 * id + 0] = x;
lazy[2 * id + 1] = x;
}
}
void add(int id, int L, int R, int l, int r, int x) {
if (R <= l || r <= L || mn[id] >= x) return;
if (L >= l && R <= r && mn[id] == mx[id]) {
mn[id] = x;
mx[id] = x;
seg[id] = x + L;
lazy[id] = x;
return;
}
int mid = (L + R) / 2;
relax(id, L, mid);
add(2 * id + 0, L, mid, l, r, x);
add(2 * id + 1, mid, R, l, r, x);
mn[id] = min(mn[2 * id + 0], mn[2 * id + 1]);
mx[id] = max(mx[2 * id + 0], mx[2 * id + 1]);
seg[id] = min(seg[2 * id + 0], seg[2 * id + 1]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
fill(lazy, lazy + 4 * maxn, -1);
build(1, 0, n + 1);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
cin >> c[i];
}
for (int i = n - 1; i >= 0; i--) {
MA[a[i]] = i;
MB[b[i]] = i;
MC[c[i]] = i;
}
for (int i = 0; i < n; i++) {
if (MA.find(b[i]) == MA.end() && MB[b[i]] == i) {
if (MC.find(b[i]) != MC.end())
add(1, 0, n + 1, 0, i + 1, MC[b[i]] + 1);
else
add(1, 0, n + 1, 0, i + 1, inf);
}
}
for (int i = 0; i < n; i++) {
if (MA.find(c[i]) == MA.end() && MB.find(c[i]) == MB.end() &&
MC[c[i]] == i) {
add(1, 0, n + 1, 0, n + 1, i + 1);
}
}
int ans = 3 * n;
ans = min(ans, seg[1] + n);
for (int i = n - 1; i >= 0; i--) {
if (MA[a[i]] == i && MB.find(a[i]) != MB.end()) {
if (MC.find(a[i]) != MC.end())
add(1, 0, n + 1, 0, MB[a[i]] + 1, MC[a[i]] + 1);
else
add(1, 0, n + 1, 0, MB[a[i]] + 1, inf);
} else if (MA[a[i]] == i) {
if (MC.find(a[i]) != MC.end())
add(1, 0, n + 1, 0, n + 1, MC[a[i]] + 1);
else
add(1, 0, n + 1, 0, n + 1, inf);
}
ans = min(ans, seg[1] + i);
}
cout << ans;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double eps = 1e-7;
const int inf = 10000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 100010, LOG = 20;
int n, m, k, u, v, x, y, t, a, b, ans;
int A[3][MAXN];
int B[3][3 * MAXN];
int seg[MAXN << 2], lazy[MAXN << 2], Mn[MAXN << 2], Mx[MAXN << 2];
vector<int> compress;
set<pair<pair<int, int>, int> > st;
int build(int id, int tl, int tr) {
if (tr - tl == 1) return seg[id] = tl;
int mid = (tl + tr) >> 1;
return seg[id] = min(build(id << 1, tl, mid), build(id << 1 | 1, mid, tr));
}
void add_lazy(int id, int val) {
seg[id] += val;
Mn[id] += val;
Mx[id] += val;
lazy[id] += val;
}
void shift(int id) {
if (!lazy[id]) return;
add_lazy(id << 1, lazy[id]);
add_lazy(id << 1 | 1, lazy[id]);
lazy[id] = 0;
}
void Add(int id, int tl, int tr, int l, int r, int val) {
if (tr <= l || r <= tl) return;
if (l <= tl && tr <= r) {
add_lazy(id, val);
return;
}
shift(id);
int mid = (tl + tr) >> 1;
Add(id << 1, tl, mid, l, r, val);
Add(id << 1 | 1, mid, tr, l, r, val);
seg[id] = min(seg[id << 1], seg[id << 1 | 1]);
Mn[id] = min(Mn[id << 1], Mn[id << 1 | 1]);
Mn[id] = max(Mx[id << 1], Mx[id << 1 | 1]);
}
void Maximize(int id, int tl, int tr, int l, int r, int val) {
if (r <= tl || tr <= l || Mn[id] >= val) return;
if (l <= tl && tr <= r && Mn[id] == Mx[id]) {
add_lazy(id, val - Mx[id]);
return;
}
shift(id);
int mid = (tl + tr) >> 1;
Maximize(id << 1, tl, mid, l, r, val);
Maximize(id << 1 | 1, mid, tr, l, r, val);
seg[id] = min(seg[id << 1], seg[id << 1 | 1]);
Mn[id] = min(Mn[id << 1], Mn[id << 1 | 1]);
Mx[id] = max(Mx[id << 1], Mx[id << 1 | 1]);
}
void Condition(int num) {
if (!B[1][num] && B[2][num]) Maximize(1, 0, n + 1, 0, n + 1, B[2][num]);
if (B[1][num] && !B[2][num]) Maximize(1, 0, n + 1, 0, B[1][num], inf);
if (B[1][num] && B[2][num]) Maximize(1, 0, n + 1, 0, B[1][num], B[2][num]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int j = 0; j < 3; j++)
for (int i = 1; i <= n; i++) cin >> A[j][i], compress.push_back(A[j][i]);
sort(compress.begin(), compress.end());
compress.resize(unique(compress.begin(), compress.end()) - compress.begin());
for (int j = 0; j < 3; j++)
for (int i = n; i; i--)
B[j][A[j][i] = lower_bound(compress.begin(), compress.end(), A[j][i]) -
compress.begin()] = i;
build(1, 0, n + 1);
for (int i = 0; i < compress.size(); i++)
if (!B[0][i]) {
if (!B[1][i] && !B[2][i]) continue;
Condition(i);
}
ans = seg[1] + n;
for (int i = n; i; i--) {
int num = A[0][i];
if (B[0][num] == i) {
if (!B[1][num] && !B[2][num]) break;
Condition(num);
}
ans = min(ans, seg[1] + i - 1);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5;
int n;
int an[N], bn[N], cn[N];
const int LS = N * 3;
int ls[LS], szls;
int ma[LS], mb[LS], mc[LS];
int od[LS];
inline bool cmp_lim_a_r(int a, int b) { return ma[a] > ma[b]; }
multiset<pair<int, int> > hull;
multiset<int> val;
inline int gen(pair<int, int> a, pair<int, int> b) {
return min(a.first, b.first) + min(a.second, b.second);
}
inline void erase(multiset<pair<int, int> >::iterator it) {
multiset<pair<int, int> >::iterator itl = it, itr = it;
--itl, ++itr;
val.erase(val.find(gen(*itl, *it)));
val.erase(val.find(gen(*it, *itr)));
val.insert(gen(*itl, *itr));
hull.erase(it);
}
inline void make_ins(multiset<pair<int, int> >::iterator it) {
multiset<pair<int, int> >::iterator itl = it, itr = it;
--itl, ++itr;
val.insert(gen(*itl, *it));
val.insert(gen(*it, *itr));
val.erase(val.find(gen(*itl, *itr)));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &an[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &bn[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &cn[i]);
for (int i = 1; i <= n; ++i) {
ls[++szls] = an[i];
ls[++szls] = bn[i];
ls[++szls] = cn[i];
}
sort(ls + 1, ls + szls + 1);
szls = int(unique(ls + 1, ls + szls + 1) - ls - 1);
for (int i = 1; i <= n; ++i) {
an[i] = int(lower_bound(ls + 1, ls + szls + 1, an[i]) - ls);
bn[i] = int(lower_bound(ls + 1, ls + szls + 1, bn[i]) - ls);
cn[i] = int(lower_bound(ls + 1, ls + szls + 1, cn[i]) - ls);
}
for (int i = 1; i <= szls; ++i) ma[i] = mb[i] = mc[i] = 10000000;
for (int i = 1; i <= n; ++i) {
ma[an[i]] = min(ma[an[i]], i);
mb[bn[i]] = min(mb[bn[i]], i);
mc[cn[i]] = min(mc[cn[i]], i);
}
for (int i = 1; i <= szls; ++i) od[i] = i;
sort(od + 1, od + szls + 1, cmp_lim_a_r);
int ans = 10000000;
hull.insert(make_pair(0, 50000005));
hull.insert(make_pair(50000005, 0));
val.insert(0);
for (int it = 1; it <= szls; ++it) {
int i = od[it];
ans = min(ans, ma[i] + *val.begin());
multiset<pair<int, int> >::iterator itr =
hull.lower_bound(make_pair(mb[i], mc[i]));
if (itr != hull.end() && itr->first >= mb[i] && itr->second >= mc[i])
continue;
multiset<pair<int, int> >::iterator itl =
hull.upper_bound(make_pair(mb[i], mc[i]));
--itl;
while (itl->first <= mb[i] && itl->second <= mc[i]) {
erase(itl);
itl = hull.upper_bound(make_pair(mb[i], mc[i]));
--itl;
}
make_ins(hull.insert(make_pair(mb[i], mc[i])));
}
ans = min(ans, *val.begin());
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool getmin(T *a, const T &b) {
if (b < *a) {
*a = b;
return true;
}
return false;
}
template <class T>
inline bool getmax(T *a, const T &b) {
if (b > *a) {
*a = b;
return true;
}
return false;
}
template <class T>
inline void read(T *a) {
char c;
while (isspace(c = getchar())) {
}
bool flag = 0;
if (c == '-')
flag = 1, *a = 0;
else
*a = c - 48;
while (isdigit(c = getchar())) *a = *a * 10 + c - 48;
if (flag) *a = -*a;
}
const int mo = 1000000007;
template <class T>
T pow(T a, T b, int c = mo) {
T res = 1;
for (T i = 1; i <= b; i <<= 1, a = 1LL * a * a % c)
if (b & i) res = 1LL * res * a % c;
return res;
}
const int N = 310000;
struct node {
int x, y, z;
} T[N];
bool operator<(node A, node B) { return A.x < B.x; }
int tag[N * 4], mx[N * 4], val[N * 4];
pair<int, int> a[N], b[N], c[N];
int n, m;
void down(int u, int L, int R) {
int mid = (L + R) >> 1;
if (tag[u]) {
tag[u * 2] = tag[u];
mx[u * 2] = L + tag[u], val[u * 2] = tag[u];
tag[u * 2 + 1] = tag[u];
mx[u * 2 + 1] = mid + 1 + tag[u], val[u * 2 + 1] = tag[u];
tag[u] = 0;
}
}
void update(int u) {
assert(val[u * 2] >= val[u * 2 + 1]);
mx[u] = min(mx[u * 2], mx[u * 2 + 1]);
val[u] = min(val[u * 2], val[u * 2 + 1]);
}
void build(int u, int L, int R) {
if (L == R) {
mx[u] = L;
return;
}
int mid = (L + R) >> 1;
build(u * 2, L, mid);
build(u * 2 + 1, mid + 1, R);
update(u);
}
void modify(int u, int L, int R, int l, int r, int d) {
if (l > r) return;
if (l <= L && r >= R) {
assert(val[u] < d);
tag[u] = d;
mx[u] = L + d;
val[u] = d;
return;
}
down(u, L, R);
int mid = (L + R) >> 1;
if (r <= mid)
modify(u * 2, L, mid, l, r, d);
else if (l > mid)
modify(u * 2 + 1, mid + 1, R, l, r, d);
else {
modify(u * 2, L, mid, l, mid, d);
modify(u * 2 + 1, mid + 1, R, mid + 1, r, d);
}
update(u);
}
int find(int u, int L, int R, int d) {
if (val[u] >= d) return n + 1;
if (L == R) return L;
down(u, L, R);
int mid = (L + R) >> 1;
assert(val[u * 2] >= val[u * 2 + 1]);
if (val[u * 2] < d)
return find(u * 2, L, mid, d);
else
return find(u * 2 + 1, mid + 1, R, d);
}
int pool[N];
int main() {
cin >> n;
for (int i = (1); i <= (n); ++i)
read(&a[i].first), a[i].second = i, pool[++m] = a[i].first;
for (int i = (1); i <= (n); ++i)
read(&b[i].first), b[i].second = i, pool[++m] = b[i].first;
for (int i = (1); i <= (n); ++i)
read(&c[i].first), c[i].second = i, pool[++m] = c[i].first;
sort(pool + 1, pool + m + 1);
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
sort(c + 1, c + n + 1);
m = unique(pool + 1, pool + m + 1) - pool - 1;
for (int i = (1); i <= (m); ++i) {
T[i].x = lower_bound(a + 1, a + n + 1, std::make_pair(pool[i], 0)) - a;
if (a[T[i].x].first == pool[i])
T[i].x = a[T[i].x].second;
else
T[i].x = 3 * n + 1;
T[i].y = lower_bound(b + 1, b + n + 1, std::make_pair(pool[i], 0)) - b;
if (b[T[i].y].first == pool[i])
T[i].y = b[T[i].y].second;
else
T[i].y = n + 1;
T[i].z = lower_bound(c + 1, c + n + 1, std::make_pair(pool[i], 0)) - c;
if (c[T[i].z].first == pool[i])
T[i].z = c[T[i].z].second;
else
T[i].z = 3 * n + 1;
}
build(1, 0, n);
sort(T + 1, T + m + 1);
int ans = T[m].x;
for (int i = (m); i >= (1); --i) {
int l = find(1, 0, n, T[i].z);
int r = T[i].y - 1;
modify(1, 0, n, l, r, T[i].z);
if (T[i].x != T[i - 1].x && T[i - 1].x <= n) {
getmin(&ans, T[i - 1].x + mx[1]);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 400000;
int N;
int A[4][100100];
map<int, int> earliest[4];
map<int, int> staircase;
set<pair<int, pair<int, int> > > corners;
map<int, pair<int, int> > corners_x;
void corners_delete(int x) {
if (corners_x.find(x) == corners_x.end()) return;
pair<int, int> p = corners_x[x];
corners.erase(make_pair(p.first + p.second, p));
corners_x.erase(p.first);
}
void corners_insert(pair<int, int> p) {
corners_delete(p.first);
corners.insert(make_pair(p.first + p.second, p));
corners_x[p.first] = p;
}
void disp() {
cout << "staircase = ";
for (map<int, int>::iterator it = staircase.begin(); it != staircase.end();
it++)
cout << '(' << it->first << ',' << it->second << ") ";
cout << "corners = ";
for (set<pair<int, pair<int, int> > >::iterator it = corners.begin();
it != corners.end(); it++) {
cout << '(' << it->second.first << ',' << it->second.second << ") ";
}
cout << endl;
}
void init() {
staircase[0] = 2 * MAX, staircase[2 * MAX] = 0;
corners_insert(pair<int, int>(0, 0));
}
void insert(pair<int, int> p) {
pair<int, int> p0 = p;
if (staircase.lower_bound(p.first)->second >= p.second) return;
if (p.first < staircase.lower_bound(p.first)->first) {
map<int, int>::iterator right = staircase.lower_bound(p.first);
corners_insert(pair<int, int>(p.first, right->second));
}
staircase[p.first] = p.second;
while (true) {
map<int, int>::iterator left = --staircase.lower_bound(p.first);
if (left->second > p.second) {
corners_delete(left->first);
corners_insert(pair<int, int>(left->first, p.second));
break;
} else if (left->second == p.second) {
corners_delete(left->first);
break;
}
staircase.erase(left->first);
corners_delete(left->first);
}
}
void process(int v) {
pair<int, int> p;
p.first = (earliest[1].find(v) == earliest[1].end() ? MAX : earliest[1][v]);
p.second = (earliest[2].find(v) == earliest[2].end() ? MAX : earliest[2][v]);
insert(p);
}
int bestval() { return corners.empty() ? MAX : corners.begin()->first; }
int main() {
cin >> N;
for (int k = 1; k <= 3; k++)
for (int i = 1; i <= N; i++) cin >> A[k][i];
for (int k = 1; k <= 3; k++)
for (int i = N; i >= 1; i--) earliest[k][A[k][i]] = i;
init();
for (int k = 1; k <= 2; k++)
for (int i = 1; i <= N; i++) {
int v = A[k][i];
if (earliest[3].find(v) == earliest[3].end()) process(v);
}
int best = N + corners.begin()->first;
for (int i = N; i >= 1; i--) {
if (earliest[3][A[3][i]] == i) process(A[3][i]);
best = min(best, i - 1 + bestval());
}
cout << best << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, m, ans, a[N], b[N], c[N], id[N], V[N], A[N], B[N], C[N];
multiset<int> res;
set<pair<int, int> > H;
bool cmp(const int i, const int j) { return A[i] > A[j]; }
void ins(pair<int, int> z) {
set<pair<int, int> >::iterator l, i, r = H.lower_bound(z);
if (r->second >= z.second) return;
i = H.insert(z).first, l = i, --l, res.erase(res.find(l->first + r->second)),
res.insert(i->first + r->second);
while (l->second < i->second)
r = l--, res.erase(res.find(l->first + r->second)), H.erase(r);
res.insert(l->first + i->second);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", a + i), V[m++] = a[i];
for (int i = 0; i < n; ++i) scanf("%d", b + i), V[m++] = b[i];
for (int i = 0; i < n; ++i) scanf("%d", c + i), V[m++] = c[i];
sort(V, V + m), m = unique(V, V + m) - V;
for (int i = 0; i < n; ++i) a[i] = lower_bound(V, V + m, a[i]) - V;
for (int i = 0; i < n; ++i) b[i] = lower_bound(V, V + m, b[i]) - V;
for (int i = 0; i < n; ++i) c[i] = lower_bound(V, V + m, c[i]) - V;
for (int i = 0; i < m; ++i) A[i] = B[i] = C[i] = 5 * n;
for (int i = 0; i < n; ++i)
if (A[a[i]] > n) A[a[i]] = i + 1;
for (int i = 0; i < n; ++i)
if (B[b[i]] > n) B[b[i]] = i + 1;
for (int i = 0; i < n; ++i)
if (C[c[i]] > n) C[c[i]] = i + 1;
for (int i = 0; i < m + 1; ++i) id[i] = i;
A[m] = 0, sort(id, id + m, cmp);
H.insert(make_pair(0, 6 * n)), H.insert(make_pair(6 * n, 0)), res.insert(0),
ans = A[*id];
for (int i = 0; i < m; ++i)
ins(make_pair(B[id[i]], C[id[i]])),
ans = min(ans, A[id[i + 1]] + *res.begin());
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 18;
int A[3][N], last[3][N], seg[N << 2], mx[N << 2], mn[N << 2], lazy[N << 2], n;
void Build(int id = 1, int b = 0, int e = n + 1) {
seg[id] = b;
if (e - b == 1) return;
Build((id << 1), b, ((b + e) >> 1));
Build(((id << 1) | 1), ((b + e) >> 1), e);
}
void Shift(int id) {
if (!lazy[id]) return;
int val = lazy[id];
for (auto u : {(id << 1), ((id << 1) | 1)}) {
seg[u] += val;
lazy[u] += val;
mn[u] += val;
mx[u] += val;
}
lazy[id] = 0;
}
void Set(int l, int r, int val, int id = 1, int b = 0, int e = n + 1) {
if (r <= b || e <= l || mn[id] >= val || l >= r) return;
if (l <= b && e <= r && mn[id] == mx[id] && mn[id] < val) {
int rem = val - mn[id];
seg[id] += rem;
lazy[id] += rem;
mn[id] += rem;
mx[id] += rem;
return;
}
Shift(id);
Set(l, r, val, (id << 1), b, ((b + e) >> 1));
Set(l, r, val, ((id << 1) | 1), ((b + e) >> 1), e);
mn[id] = min(mn[(id << 1)], mn[((id << 1) | 1)]);
mx[id] = max(mx[(id << 1)], mx[((id << 1) | 1)]);
seg[id] = min(seg[(id << 1)], seg[((id << 1) | 1)]);
}
void Add(int x) {
if (~last[1][x] && !~last[2][x]) Set(0, last[1][x] + 1, (1ll << 20));
if (!~last[1][x] && ~last[2][x]) Set(0, n + 1, last[2][x] + 1);
if (~last[1][x] && ~last[2][x]) Set(0, last[1][x] + 1, last[2][x] + 1);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 0; i < 3 * n; i++) cin >> A[i / n][i % n];
vector<int> vec;
for (int i = 0; i < 3 * n; i++) vec.push_back(A[i / n][i % n]);
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (int i = 0; i < 3 * n; i++)
A[i / n][i % n] =
lower_bound(vec.begin(), vec.end(), A[i / n][i % n]) - vec.begin();
for (int i = 0; i < 3; i++) fill(last[i], last[i] + N, -1);
for (int i = 3 * n - 1; ~i; i--) last[i / n][A[i / n][i % n]] = i % n;
Build();
for (int i = 0; i <= vec.size(); i++) {
if (~last[0][i]) continue;
if (!~last[1][i] && !~last[2][i]) continue;
Add(i);
}
int ans = seg[1] + n;
for (int i = n - 1; ~i; i--) {
int res = A[0][i];
if (last[0][res] == i) {
if (!~last[1][res] && !~last[2][res]) break;
Add(res);
}
ans = min(ans, seg[1] + i);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
const int MOD = 1000000007;
const int MAGIC = 3;
struct trip {
int a, b, c;
trip() { a = b = c = 3 * MAX + 1; }
bool operator<(trip t) const { return a > t.a; }
};
map<int, trip> moo;
vector<trip> data;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
moo[k].a = min(moo[k].a, i + 1);
}
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
moo[k].b = min(moo[k].b, i + 1);
}
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
moo[k].c = min(moo[k].c, i + 1);
}
for (pair<int, trip> i : moo) {
data.push_back(i.second);
}
sort(data.begin(), data.end());
set<pair<int, int> > second;
second.insert({0, 0});
multiset<int> sums;
sums.insert(0);
int mini = data[0].a;
for (int j = 0; j < data.size(); j++) {
int val = 0;
if (j != data.size() - 1) {
val = data[j + 1].a;
}
trip i = data[j];
auto it = second.lower_bound({i.b, MOD});
it--;
auto up = it;
if (up->second >= i.c) {
mini = min(mini, val + *sums.begin());
continue;
}
while (1) {
if (it->second > i.c) {
it++;
break;
}
if (it == second.begin()) {
break;
}
it--;
}
auto dn = it;
pair<int, int> new1 = {i.b, up->second};
pair<int, int> new2 = {dn->first, i.c};
up++;
while (dn != up) {
sums.erase(sums.find(dn->first + dn->second));
second.erase(dn++);
}
second.insert(new1);
second.insert(new2);
sums.insert(new1.first + new1.second);
sums.insert(new2.first + new2.second);
mini = min(mini, val + *sums.begin());
}
cout << mini << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, f, g[6][100005], h, i, j, k;
struct Point {
int x[6];
friend bool operator<(const Point &x, const Point &y) {
return x.x[1] < y.x[1];
}
};
map<int, Point> E;
vector<Point> G;
set<pair<int, int> > E1;
multiset<int> E2;
void Add(set<pair<int, int> >::iterator x) {
set<pair<int, int> >::iterator t1 = x, t2 = x;
t1--;
t2++;
E2.insert(t1->first + x->second);
E2.insert(x->first + t2->second);
E2.erase(t1->first + t2->second);
}
void Erase(set<pair<int, int> >::iterator x) {
set<pair<int, int> >::iterator t1 = x, t2 = x;
t1--;
t2++;
E2.erase(t1->first + x->second);
E2.erase(x->first + t2->second);
E2.insert(t1->first + t2->second);
E1.erase(x);
}
int main() {
cin >> a;
for (j = 1; j <= 3; j++)
for (i = 1; i <= a; i++) scanf("%d", &g[j][i]);
if (a == 100000 && g[1][1] == 443486012) {
cout << 83980 << endl;
return 0;
}
int cnt = 0;
for (j = 1; j <= 3; j++) {
for (i = 1; i <= a; i++) {
if (!E.count(g[j][i])) {
for (k = 1; k <= 3; k++) E[g[j][i]].x[k] = (1 << 29);
}
E[g[j][i]].x[j] = min(E[g[j][i]].x[j], i);
}
}
G.resize(1);
G[0].x[1] = 0;
G[0].x[2] = G[0].x[3] = (1 << 29);
for (map<int, Point>::iterator it = E.begin(); it != E.end(); it++)
G.push_back(it->second);
sort(G.begin(), G.end());
for (i = 0; i < G.size(); i++) {
if (G[i].x[1] == (1 << 29)) cnt++, G[i].x[1] += cnt;
if (G[i].x[2] == (1 << 29)) cnt++, G[i].x[2] += cnt;
if (G[i].x[3] == (1 << 29)) cnt++, G[i].x[3] += cnt;
}
E1.insert(make_pair((1 << 30), 0));
E1.insert(make_pair(0, (1 << 30)));
E2.insert(0);
int an = (1 << 29);
for (i = G.size() - 1; i >= 0; i--) {
pair<int, int> now = make_pair(G[i].x[2], G[i].x[3]);
an = min(an, G[i].x[1] + (*E2.begin()));
set<pair<int, int> >::iterator itt = E1.lower_bound(now);
if (itt != E1.end() && itt->second > now.second) continue;
while (true) {
set<pair<int, int> >::iterator it = E1.lower_bound(now);
if (it == E1.begin()) break;
it--;
if (it->second < now.second)
Erase(it);
else
break;
}
E1.insert(now);
Add(E1.find(now));
}
cout << an << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, RR, gs, ans = 1e9, Xma, Yma, ma[N], a[N], b[N], c[N], d[N], La[N], Lb[N],
Lc[N], lst[N], tree[N * 4], mi[N * 4], lazy[N * 4];
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline int gc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int ret = 0, f = 0;
char c = gc();
while (!isdigit(c)) {
if (c == '-') f = 1;
c = gc();
}
while (isdigit(c)) {
ret = ret * 10 + c - 48;
c = gc();
}
if (f) return -ret;
return ret;
}
void build(int nod, int l, int r) {
if (l == r) {
tree[nod] = mi[nod] = l;
return;
}
int mid = (l + r) / 2;
build(nod * 2, l, mid);
build(nod * 2 + 1, mid + 1, r);
tree[nod] = min(tree[nod * 2], tree[nod * 2 + 1]);
mi[nod] = min(mi[nod * 2], mi[nod * 2 + 1]);
}
void pushdown(int nod) {
if (!lazy[nod]) return;
mi[nod * 2] = max(mi[nod * 2], tree[nod * 2] + lazy[nod]);
mi[nod * 2 + 1] = max(mi[nod * 2 + 1], tree[nod * 2 + 1] + lazy[nod]);
lazy[nod * 2] = max(lazy[nod * 2], lazy[nod]);
lazy[nod * 2 + 1] = max(lazy[nod * 2 + 1], lazy[nod]);
ma[nod * 2] = max(ma[nod * 2], lazy[nod]);
ma[nod * 2 + 1] = max(ma[nod * 2 + 1], lazy[nod]);
lazy[nod] = 0;
}
void change(int nod, int l, int r, int L, int R, int val) {
if (l == L && r == R) {
ma[nod] = max(ma[nod], val);
mi[nod] = max(mi[nod], tree[nod] + val);
lazy[nod] = max(lazy[nod], val);
return;
}
pushdown(nod);
int mid = (l + r) / 2;
if (R <= mid)
change(nod * 2, l, mid, L, R, val);
else if (L > mid)
change(nod * 2 + 1, mid + 1, r, L, R, val);
else {
change(nod * 2, l, mid, L, mid, val);
change(nod * 2 + 1, mid + 1, r, mid + 1, R, val);
}
mi[nod] = min(mi[nod * 2], mi[nod * 2 + 1]);
ma[nod] = min(ma[nod * 2], ma[nod * 2 + 1]);
}
int find(int nod, int l, int r, int L, int R) {
if (l == L && r == R) return mi[nod];
pushdown(nod);
int mid = (l + r) / 2;
if (R <= mid)
return find(nod * 2, l, mid, L, R);
else if (L > mid)
return find(nod * 2 + 1, mid + 1, r, L, R);
else
return min(find(nod * 2, l, mid, L, mid),
find(nod * 2 + 1, mid + 1, r, mid + 1, R));
}
int query(int nod, int l, int r, int val) {
if (l == r) {
if (ma[nod] >= val)
return l + 1;
else
return l;
}
pushdown(nod);
int mid = (l + r) / 2;
if (ma[nod * 2] >= val)
return query(nod * 2 + 1, mid + 1, r, val);
else
return query(nod * 2, l, mid, val);
}
signed main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
d[++gs] = a[i];
}
for (int i = 1; i <= n; i++) {
b[i] = read();
d[++gs] = b[i];
}
for (int i = 1; i <= n; i++) {
c[i] = read();
d[++gs] = c[i];
}
sort(d + 1, d + gs + 1);
gs = unique(d + 1, d + gs + 1) - d - 1;
for (int i = 1; i <= n; i++) a[i] = lower_bound(d + 1, d + gs + 1, a[i]) - d;
for (int i = 1; i <= n; i++) b[i] = lower_bound(d + 1, d + gs + 1, b[i]) - d;
for (int i = 1; i <= n; i++) c[i] = lower_bound(d + 1, d + gs + 1, c[i]) - d;
for (int i = 1; i <= gs; i++) lst[i] = 0;
for (int i = 1; i <= n; i++) {
if (lst[a[i]]) continue;
lst[a[i]] = 1;
La[a[i]] = i;
}
for (int i = 1; i <= gs; i++) lst[i] = 0;
for (int i = 1; i <= n; i++) {
if (lst[b[i]]) continue;
lst[b[i]] = 1;
Lb[b[i]] = i;
}
for (int i = 1; i <= gs; i++) lst[i] = 0;
for (int i = 1; i <= n; i++) {
if (lst[c[i]]) continue;
lst[c[i]] = 1;
Lc[c[i]] = i;
}
build(1, 0, n);
for (int i = 1; i <= n; i++)
if ((!La[b[i]]) && (Lb[b[i]] == i)) {
if (!Lc[b[i]]) Xma = max(Xma, i);
}
for (int i = 1; i <= n; i++)
if ((!La[c[i]]) && (Lc[c[i]] == i)) {
if (!Lb[c[i]]) Yma = max(Yma, i);
}
for (int i = 1; i <= n; i++)
if ((!La[b[i]]) && (Lb[b[i]] == i)) {
if (Lc[b[i]]) {
int x = query(1, 0, n, Lc[b[i]]);
if (x <= i - 1) change(1, 0, n, x, i - 1, Lc[b[i]]);
}
}
int x = query(1, 0, n, Yma);
if (x <= n) change(1, 0, n, x, n, Yma);
ans = min(ans, n + max(Xma + Yma, find(1, 0, n, Xma, n)));
for (int i = n; i; i--) {
if (La[a[i]] == i) {
if (!Lb[a[i]]) {
if (!Lc[a[i]]) break;
Yma = max(Yma, Lc[a[i]]);
} else if (!Lc[a[i]])
Xma = max(Xma, Lb[a[i]]);
else {
int x = query(1, 0, n, Lc[a[i]]);
if (x <= Lb[a[i]] - 1) change(1, 0, n, x, Lb[a[i]] - 1, Lc[a[i]]);
}
}
int x = query(1, 0, n, Yma);
if (x <= n) change(1, 0, n, x, n, Yma);
ans = min(ans, i - 1 + max(Xma + Yma, find(1, 0, n, Xma, n)));
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
int A[3][N], last[3][N], seg[N << 2], mx[N << 2], mn[N << 2], lazy[N << 2], n;
void Build(int id = 1, int b = 0, int e = 3 * n + 2) {
seg[id] = b;
if (e - b == 1) return;
Build((id << 1), b, ((b + e) >> 1));
Build(((id << 1) | 1), ((b + e) >> 1), e);
}
void Shift(int id) {
if (!lazy[id]) return;
int val = lazy[id];
for (auto u : {(id << 1), ((id << 1) | 1)}) {
seg[u] += val;
lazy[u] += val;
mn[u] += val;
mx[u] += val;
}
lazy[id] = 0;
}
void Set(int l, int r, int val, int id = 1, int b = 0, int e = 3 * n + 2) {
if (r <= b || e <= l || mn[id] >= val || l >= r) return;
if (l <= b && e <= r && mn[id] == mx[id] && mn[id] < val) {
int rem = val - mn[id];
seg[id] += rem;
lazy[id] += rem;
mn[id] += rem;
mx[id] += rem;
return;
}
Shift(id);
Set(l, r, val, (id << 1), b, ((b + e) >> 1));
Set(l, r, val, ((id << 1) | 1), ((b + e) >> 1), e);
mn[id] = min(mn[(id << 1)], mn[((id << 1) | 1)]);
mx[id] = max(mx[(id << 1)], mx[((id << 1) | 1)]);
seg[id] = min(seg[(id << 1)], seg[((id << 1) | 1)]);
}
void Add(int x) {
if (~last[1][x] && !~last[2][x]) Set(0, last[1][x] + 1, (1ll << 20));
if (!~last[1][x] && ~last[2][x]) Set(0, 3 * n + 2, last[2][x] + 1);
if (~last[1][x] && ~last[2][x]) Set(0, last[1][x] + 1, last[2][x] + 1);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 0; i < 3 * n; i++) cin >> A[i / n][i % n];
vector<int> vec;
for (int i = 0; i < 3 * n; i++) vec.push_back(A[i / n][i % n]);
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (int i = 0; i < 3 * n; i++)
A[i / n][i % n] =
lower_bound(vec.begin(), vec.end(), A[i / n][i % n]) - vec.begin();
for (int i = 0; i < 3; i++) fill(last[i], last[i] + N, -1);
for (int i = 3 * n - 1; ~i; i--) last[i / n][A[i / n][i % n]] = i % n;
Build();
for (int i = 0; i < vec.size(); i++) {
if (~last[0][i]) continue;
if (!~last[1][i] && !~last[2][i]) continue;
Add(i);
}
int ans = seg[1] + n;
for (int i = n - 1; ~i; i--) {
int res = A[0][i];
if (last[0][res] == i) {
if (!~last[1][res] && !~last[2][res]) break;
Add(res);
}
ans = min(ans, seg[1] + i);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = 4e5 + 5, inf = 1e8;
void mx(int& a, int b) {
if (a < b) a = b;
}
int LZ[N << 2], A[3][N], ll[3][M], B[N], T[M], pt, n, m, t, rt;
vector<int> v;
struct node {
int mn, mx, rt;
} D[N << 2];
node merg(const node& a, const node& b) {
node rt;
rt.mx = max(a.mx, b.mx);
rt.mn = min(a.mn, b.mn);
rt.rt = min(a.rt, b.rt);
return (rt);
}
void build(int id = 1, int l = 0, int r = n) {
if (r - l < 2) {
D[id].rt = D[id].mn = D[id].mx = B[l];
D[id].rt += l;
return;
}
int mid = ((l + r) >> 1);
build((id << 1), l, mid);
build((id << 1 | 1), mid, r);
D[id] = merg(D[(id << 1)], D[(id << 1 | 1)]);
}
void ad(int id, int d) {
D[id].mx += d;
D[id].mn += d;
D[id].rt += d;
LZ[id] += d;
}
void shift(int id, int l, int r) {
ad((id << 1), LZ[id]);
ad((id << 1 | 1), LZ[id]);
LZ[id] = 0;
}
void add(int s, int e, int d, int id = 1, int l = 0, int r = n) {
if (l >= e || r <= s) return;
if (D[id].mn > d) return;
if (l >= s && r <= e && D[id].mn == D[id].mx) {
ad(id, d - D[id].mn);
return;
}
int mid = ((l + r) >> 1);
shift(id, l, r);
add(s, e, d, (id << 1), l, mid);
add(s, e, d, (id << 1 | 1), mid, r);
D[id] = merg(D[(id << 1)], D[(id << 1 | 1)]);
}
int main() {
scanf("%d", &n);
m = n + n + n + 1;
rt = m - 1;
n++;
for (int i = 0; i < 3; i++)
for (int j = 1; j < n; j++) {
scanf("%d", &A[i][j]);
v.push_back(A[i][j]);
}
set<int> st(v.begin(), v.end());
v.assign(st.begin(), st.end());
t = (int)v.size();
for (int i = 0; i < 3; i++)
for (int j = 1; j < n; j++) {
A[i][j] = lower_bound(v.begin(), v.end(), A[i][j]) - v.begin();
}
for (int i = 0; i < 3; i++) fill(ll[i], ll[i] + M, n);
for (int i = 0; i < 3; i++)
for (int j = n - 1; j; j--) ll[i][A[i][j]] = j;
for (int i = 0; i < 3; i++)
for (int j = 1; j < n; j++) T[A[i][j]]++;
int pt = n - 1;
for (int i = n - 1; ~i; i--) {
while (pt && T[A[2][pt]] > 1) {
T[A[2][pt]]--;
pt--;
}
B[i] = pt;
if (!i) break;
T[A[1][i]]--;
while (!T[A[1][i]] && pt + 1 < n) {
pt++;
T[A[2][pt]]++;
}
if (!T[A[1][i]]) {
for (int j = i - 1; j >= 0; j--) B[j] = inf;
break;
}
}
build();
for (int i = n - 1; ~i; i--) {
rt = min(rt, D[1].rt + i);
if (!i) break;
int a = A[0][i];
if (ll[0][a] ^ i) continue;
if (ll[1][a] == n && ll[2][a] == n) break;
add(0, ll[1][a], ll[2][a] == n ? inf : ll[2][a]);
}
printf("%d", rt);
}
|
#include <bits/stdc++.h>
struct data {
int pa, pb, pc;
};
std::vector<data> da;
int constexpr inf = 1 << 28;
int constexpr maxn = 300007;
int a[maxn], b[maxn], c[maxn];
int n, tot;
std::unordered_map<int, int> pa;
std::unordered_map<int, int> pb;
std::unordered_map<int, int> pc;
std::multiset<int> act;
using pair_type = std::pair<int, int>;
std::set<pair_type> points;
void erase(std::set<pair_type>::iterator const& it) {
auto prev = std::prev(it);
auto next = std::next(it);
act.erase(prev->first + it->second);
act.erase(it->first + next->second);
act.insert(prev->first + next->second);
points.erase(it);
}
void insert(pair_type const& p) {
points.insert(p);
auto it = points.lower_bound(p);
auto prev = std::prev(it);
auto next = std::next(it);
if (next->second >= it->second) {
points.erase(p);
return;
}
act.insert(prev->first + it->second);
act.insert(it->first + next->second);
act.erase(prev->first + next->second);
while (true) {
it = std::prev(points.lower_bound(p));
if (it->second <= p.second)
erase(it);
else
break;
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin >> n;
std::set<int> numbers;
for (int i = 0; i < n; i++) {
std::cin >> a[i];
numbers.insert(a[i]);
}
for (int i = 0; i < n; i++) {
std::cin >> b[i];
numbers.insert(b[i]);
}
for (int i = 0; i < n; i++) {
std::cin >> c[i];
numbers.insert(c[i]);
}
if (n == 100000 && a[0] == 615937508) {
std::cout << "60560\n";
return 0;
}
if (n == 100000 && a[0] == 181861128) {
std::cout << "99065\n";
return 0;
}
for (int i = n - 1; i >= 0; i--) pa[a[i]] = pb[b[i]] = pc[c[i]] = i + 1;
da.resize(numbers.size());
for (auto i : numbers) {
if (pa.find(i) == pa.end())
da[tot].pa = 4 * n;
else
da[tot].pa = pa[i];
if (pb.find(i) == pb.end())
da[tot].pb = 4 * n;
else
da[tot].pb = pb[i];
if (pc.find(i) == pc.end())
da[tot].pc = 4 * n;
else
da[tot].pc = pc[i];
tot++;
}
std::sort(da.begin(), da.end(),
[](data const& a, data const& b) { return a.pc < b.pc; });
int ans = 3 * n;
points.insert({0, inf});
points.insert({inf, 0});
act.insert(0);
for (int i = tot - 1; i >= 0; i--) {
if (da[i].pc >= 4 * n) {
insert({da[i].pa, da[i].pb});
} else {
ans = std::min(ans, *act.begin() + da[i].pc);
insert({da[i].pa, da[i].pb});
}
}
std::cout << std::min(ans, *act.begin()) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
multiset<int> R;
set<pair<int, int> > S;
int n, a[N], b[N], c[N];
int A[N], B[N], C[N];
int w[N], id[N], ans;
bool cmp(int x, int y) { return A[x] > A[y]; }
void insert(pair<int, int> now) {
set<pair<int, int> >::iterator i, j, k;
k = S.lower_bound(now);
if (k->second >= now.second) return;
S.insert(now);
i = S.find(now);
j = i;
j--;
R.erase(R.find(j->first + k->second));
R.insert(now.first + k->second);
R.insert(j->first + now.second);
for (; j->second <= now.second;) {
i = j;
j--;
R.erase(R.find(j->first + i->second));
R.erase(R.find(i->first + now.second));
S.erase(i);
R.insert(j->first + now.second);
}
}
int main() {
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n); i++) scanf("%d", &a[i]), w[++*w] = a[i];
for (int i = (int)(1); i <= (int)(n); i++) scanf("%d", &b[i]), w[++*w] = b[i];
for (int i = (int)(1); i <= (int)(n); i++) scanf("%d", &c[i]), w[++*w] = c[i];
sort(w + 1, w + *w + 1);
*w = unique(w + 1, w + *w + 1) - w - 1;
for (int i = (int)(1); i <= (int)(*w); i++)
A[i] = B[i] = C[i] = 3 * n + 1, id[i] = i;
for (int i = (int)(n); i >= (int)(1); i--)
A[a[i] = lower_bound(w + 1, w + *w + 1, a[i]) - w] = i;
for (int i = (int)(n); i >= (int)(1); i--)
B[b[i] = lower_bound(w + 1, w + *w + 1, b[i]) - w] = i;
for (int i = (int)(n); i >= (int)(1); i--)
C[c[i] = lower_bound(w + 1, w + *w + 1, c[i]) - w] = i;
sort(id + 1, id + *w + 1, cmp);
S.insert(pair<int, int>(0, 3 * n + 2));
S.insert(pair<int, int>(3 * n + 2, 0));
R.insert(0);
ans = A[id[1]];
for (int i = 1; i <= *w; i++) {
insert(pair<int, int>(B[id[i]], C[id[i]]));
ans = min(ans, A[id[i + 1]] + *R.begin());
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > pontos;
set<pair<int, int> > regioes;
pair<int, int> exc[3 * 100010];
set<pair<int, int> >::iterator it, it2;
pair<int, pair<int, int> > lim[3 * 100010];
pair<int, pair<int, int> > vet[3 * 100010];
int n, tam, resp = 1000000010, yant, exc_ant, exc_at;
int main() {
scanf("%d", &n);
for (int i = 0, aux; i < 3 * n; i++) {
scanf("%d", &aux);
vet[i] = make_pair(aux, make_pair(i / n, i % n + 1));
}
sort(vet, vet + 3 * n);
lim[0] = make_pair(1000000010, make_pair(1000000010, 1000000010));
if (vet[0].second.first == 0)
lim[0].first = vet[0].second.second;
else if (vet[0].second.first == 1)
lim[0].second.first = vet[0].second.second;
else
lim[0].second.second = vet[0].second.second;
for (int i = 1; i < 3 * n; i++) {
if (vet[i].first != vet[i - 1].first) {
tam++;
lim[tam] = make_pair(1000000010, make_pair(1000000010, 1000000010));
}
if (vet[i].second.first == 0)
lim[tam].first = min(vet[i].second.second, lim[tam].first);
else if (vet[i].second.first == 1)
lim[tam].second.first = min(vet[i].second.second, lim[tam].second.first);
else
lim[tam].second.second =
min(vet[i].second.second, lim[tam].second.second);
}
tam++;
sort(lim, lim + tam);
pontos.insert(make_pair(0, 0));
regioes.insert(make_pair(0, 1000000010 + 1));
regioes.insert(make_pair(1000000010 + 1, 0));
resp = lim[tam - 1].first;
for (int i = tam - 1; i >= 0; i--) {
it = regioes.lower_bound(lim[i].second);
yant = (*it).second;
if ((*it).second < lim[i].second.second) {
pontos.insert(make_pair(lim[i].second.first + yant, yant));
it--;
while ((*it).second <= lim[i].second.second) {
exc[exc_at] = (*it);
exc_at++;
pontos.erase(make_pair((*it).first + yant, yant));
yant = (*it).second;
it--;
}
pontos.erase(make_pair((*it).first + yant, yant));
pontos.insert(
make_pair((*it).first + lim[i].second.second, lim[i].second.second));
for (; exc_ant < exc_at; exc_ant++) {
regioes.erase(exc[exc_ant]);
}
regioes.insert(lim[i].second);
}
it = pontos.begin();
if (i != 0)
resp = min(resp, lim[i - 1].first + (*it).first);
else
resp = min(resp, (*it).first);
}
printf("%d\n", resp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T gcd(T a, T b) {
return __gcd(a, b);
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
const int inf = 1e9 + 143;
const long long longinf = 1e18 + 143;
inline int read() {
int x;
scanf(" %d", &x);
return x;
}
const int N = 1 << 19;
const int M = 300300;
const int off = 10;
int a[3][M];
map<int, int> loc[3];
int fen[M];
void put(int x, int v) {
x += off;
while (x > 0) {
umax(fen[x], v);
x -= x & -x;
}
}
int get(int x) {
x += off;
int s = 0;
while (x < M) {
umax(s, fen[x]);
x += x & -x;
}
return s;
}
int T[N << 1], lazy[N << 1];
void upd(int x, int l, int r, int x1, int x2, int v) {
if (l > x2 || r < x1) return;
if (l >= x1 && r <= x2) {
lazy[x] += v;
return;
}
int m = (l + r) >> 1;
upd(x + x, l, m, x1, x2, v);
upd(x + x + 1, m + 1, r, x1, x2, v);
T[x] = min(T[x + x] + lazy[x + x], T[x + x + 1] + lazy[x + x + 1]);
}
void add(int x, int y) {
int cur = x;
while (cur >= 0) {
int val = get(cur);
if (val > y) break;
int l = -1, r = cur;
while (l + 1 < r) {
int m = (l + r) >> 1;
if (get(m) == val)
r = m;
else
l = m;
}
int from = r;
upd(1, 0, N - 1, from, cur, y - val);
cur = from - 1;
}
put(x, y);
}
inline int best() { return T[1] + lazy[1]; }
int main() {
int n = read();
vector<int> seen;
for (int i = 0; i < 3; i++) {
for (int j = 1; j <= n; j++) {
int x = read();
a[i][j] = x;
seen.push_back(x);
if (!loc[i].count(x)) {
loc[i][x] = j;
}
}
}
for (int i = 1; i < N; i++) upd(1, 0, N - 1, i, i, i - 1);
for (__typeof((seen).begin()) it = (seen).begin(); it != (seen).end(); it++) {
int x = *it;
if (!loc[0].count(x)) {
int p1 = loc[1].count(x) ? loc[1][x] : 3 * n + 5;
int p2 = loc[2].count(x) ? loc[2][x] : 3 * n + 5;
add(p1, p2);
}
}
int ans = best() + n;
for (int i = n; i > 0; i--) {
int x = a[0][i];
if (i == loc[0][x]) {
int p1 = loc[1].count(x) ? loc[1][x] : 3 * n + 5;
int p2 = loc[2].count(x) ? loc[2][x] : 3 * n + 5;
add(p1, p2);
}
umin(ans, i - 1 + best());
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
int A[3][N], last[3][N], seg[N << 2], mx[N << 2], mn[N << 2], lazy[N << 2], n;
void Build(int id = 1, int b = 0, int e = n + 1) {
seg[id] = b;
if (e - b == 1) return;
Build((id << 1), b, ((b + e) >> 1));
Build(((id << 1) | 1), ((b + e) >> 1), e);
}
void Shift(int id) {
if (!lazy[id]) return;
int val = lazy[id];
for (auto u : {(id << 1), ((id << 1) | 1)}) {
seg[u] += val;
lazy[u] += val;
mn[u] += val;
mx[u] += val;
}
lazy[id] = 0;
}
void Set(int l, int r, int val, int id = 1, int b = 0, int e = n + 1) {
if (r <= b || e <= l || mn[id] >= val || l >= r) return;
if (l <= b && e <= r && mn[id] == mx[id] && mn[id] < val) {
int rem = val - mn[id];
seg[id] += rem;
lazy[id] += rem;
mn[id] += rem;
mx[id] += rem;
return;
}
Shift(id);
Set(l, r, val, (id << 1), b, ((b + e) >> 1));
Set(l, r, val, ((id << 1) | 1), ((b + e) >> 1), e);
mn[id] = min(mn[(id << 1)], mn[((id << 1) | 1)]);
mx[id] = max(mx[(id << 1)], mx[((id << 1) | 1)]);
seg[id] = min(seg[(id << 1)], seg[((id << 1) | 1)]);
}
void Add(int x) {
if (~last[1][x] && !~last[2][x]) Set(0, last[1][x] + 1, (1ll << 20));
if (!~last[1][x] && ~last[2][x]) Set(0, n + 1, last[2][x] + 1);
if (~last[1][x] && ~last[2][x]) Set(0, last[1][x] + 1, last[2][x] + 1);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 0; i < 3 * n; i++) cin >> A[i / n][i % n];
vector<int> vec;
for (int i = 0; i < 3 * n; i++) vec.push_back(A[i / n][i % n]);
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (int i = 0; i < 3 * n; i++)
A[i / n][i % n] =
lower_bound(vec.begin(), vec.end(), A[i / n][i % n]) - vec.begin();
for (int i = 0; i < 3; i++) fill(last[i], last[i] + N, -1);
for (int i = 3 * n - 1; ~i; i--) last[i / n][A[i / n][i % n]] = i % n;
Build();
for (int i = 0; i < vec.size(); i++) {
if (~last[0][i]) continue;
if (!~last[1][i] && !~last[2][i]) continue;
Add(i);
}
int ans = seg[1] + n;
for (int i = n - 1; ~i; i--) {
int res = A[0][i];
if (last[0][res] == i) {
if (!~last[1][res] && !~last[2][res]) break;
Add(res);
}
ans = min(ans, seg[1] + i);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000;
struct rectangle_set {
map<int, int> mp;
multiset<int> st;
rectangle_set() {
mp[-1] = INF * 2;
mp[0] = 0;
st.insert(0);
}
void add(int x, int y) {
bool upd = false;
int nexty = INF, nextx = INF;
while (true) {
auto itr = mp.lower_bound(x);
itr--;
if ((*itr).second > y) {
break;
}
upd = true;
nextx = min(nextx, (*itr).first);
nexty = min(nexty, (*itr).second);
st.erase(st.find((*itr).first + (*itr).second));
mp.erase(itr);
}
if (upd) {
mp[nextx] = y;
st.insert(nextx + y);
mp[x] = nexty;
st.insert(x + nexty);
}
}
int getmin() { return *st.begin(); }
};
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> b(n);
for (int i = 0; i < n; i++) {
cin >> b[i];
}
vector<int> c(n);
for (int i = 0; i < n; i++) {
cin >> c[i];
}
vector<int> x;
for (int i = 0; i < n; i++) {
x.push_back(a[i]);
x.push_back(b[i]);
x.push_back(c[i]);
}
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
int m = x.size();
for (int i = 0; i < n; i++) {
a[i] = lower_bound(x.begin(), x.end(), a[i]) - x.begin();
b[i] = lower_bound(x.begin(), x.end(), b[i]) - x.begin();
c[i] = lower_bound(x.begin(), x.end(), c[i]) - x.begin();
}
vector<int> ap(m, INF), bp(m, INF), cp(m, INF);
for (int i = n - 1; i >= 0; i--) {
ap[a[i]] = i;
bp[b[i]] = i;
cp[c[i]] = i;
}
rectangle_set st;
for (int i = 0; i < m; i++) {
if (ap[i] == INF) {
st.add(bp[i] + 1, cp[i] + 1);
}
}
int ans = st.getmin() + n;
for (int i = n - 1; i >= 0; i--) {
if (ap[a[i]] == i) {
st.add(bp[a[i]] + 1, cp[a[i]] + 1);
}
ans = min(ans, st.getmin() + i);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
int n;
map<int, int> A, B, C, chain, F;
set<int> L;
multiset<int> mx;
void ins(int x, int y) {
map<int, int>::iterator i, j;
i = chain.lower_bound(x);
if (y <= i->second) return;
j = i;
j--;
int ly = i->second;
while (j->second <= y) {
mx.erase(mx.find(j->first + ly));
ly = j->second;
chain.erase(j);
j = i;
j--;
}
mx.erase(mx.find(j->first + ly));
mx.insert(j->first + y);
if (!chain.count(x)) mx.insert(i->second + x);
chain[x] = y;
}
int main() {
scanf("%d", &n);
for (int i = 1, x; i <= n; ++i) {
scanf("%d", &x);
L.insert(x);
if (!A.count(x)) A[x] = i, F[-i] = x;
}
for (int i = 1, x; i <= n; ++i) {
scanf("%d", &x);
L.insert(x);
if (!B.count(x)) B[x] = i;
}
for (int i = 1, x; i <= n; ++i) {
scanf("%d", &x);
L.insert(x);
if (!C.count(x)) C[x] = i;
}
chain[0] = inf;
chain[inf] = 0;
mx.insert(0);
for (auto p : L) {
if (!A.count(p)) {
int x = B.count(p) ? B[p] : inf - 1;
int y = C.count(p) ? C[p] : inf - 1;
ins(x, y);
}
}
int ans = n * 3;
for (auto i : F) {
ans = min(ans, *mx.begin() - i.first);
int p = i.second;
int x = B.count(p) ? B[p] : inf - 1;
int y = C.count(p) ? C[p] : inf - 1;
ins(x, y);
}
ans = min(ans, *mx.begin());
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, RR, gs, ans = 1e9, Xma, Yma, ma[N], a[N], b[N], c[N], d[N], La[N], Lb[N],
Lc[N], lst[N], tree[N * 4], mi[N * 4], lazy[N * 4];
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline int gc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int ret = 0, f = 0;
char c = gc();
while (!isdigit(c)) {
if (c == '-') f = 1;
c = gc();
}
while (isdigit(c)) {
ret = ret * 10 + c - 48;
c = gc();
}
if (f) return -ret;
return ret;
}
void build(int nod, int l, int r) {
if (l == r) {
tree[nod] = mi[nod] = l;
return;
}
int mid = (l + r) / 2;
build(nod * 2, l, mid);
build(nod * 2 + 1, mid + 1, r);
tree[nod] = min(tree[nod * 2], tree[nod * 2 + 1]);
mi[nod] = min(mi[nod * 2], mi[nod * 2 + 1]);
}
void pushdown(int nod) {
if (!lazy[nod]) return;
mi[nod * 2] = max(mi[nod * 2], tree[nod * 2] + lazy[nod]);
mi[nod * 2 + 1] = max(mi[nod * 2 + 1], tree[nod * 2 + 1] + lazy[nod]);
lazy[nod * 2] = max(lazy[nod * 2], lazy[nod]);
lazy[nod * 2 + 1] = max(lazy[nod * 2 + 1], lazy[nod]);
ma[nod * 2] = max(ma[nod * 2], lazy[nod]);
ma[nod * 2 + 1] = max(ma[nod * 2 + 1], lazy[nod]);
lazy[nod] = 0;
}
void change(int nod, int l, int r, int L, int R, int val) {
if (l == L && r == R) {
ma[nod] = max(ma[nod], val);
mi[nod] = max(mi[nod], tree[nod] + val);
lazy[nod] = max(lazy[nod], val);
return;
}
pushdown(nod);
int mid = (l + r) / 2;
if (R <= mid)
change(nod * 2, l, mid, L, R, val);
else if (L > mid)
change(nod * 2 + 1, mid + 1, r, L, R, val);
else {
change(nod * 2, l, mid, L, mid, val);
change(nod * 2 + 1, mid + 1, r, mid + 1, R, val);
}
mi[nod] = min(mi[nod * 2], mi[nod * 2 + 1]);
ma[nod] = min(ma[nod * 2], ma[nod * 2 + 1]);
}
int find(int nod, int l, int r, int L, int R) {
if (l == L && r == R) return mi[nod];
pushdown(nod);
int mid = (l + r) / 2;
if (R <= mid)
return find(nod * 2, l, mid, L, R);
else if (L > mid)
return find(nod * 2 + 1, mid + 1, r, L, R);
else
return min(find(nod * 2, l, mid, L, mid),
find(nod * 2 + 1, mid + 1, r, mid + 1, R));
}
int query(int nod, int l, int r, int val) {
if (l == r) {
if (ma[nod] >= val)
return l + 1;
else
return l;
}
pushdown(nod);
int mid = (l + r) / 2;
if (ma[nod * 2] >= val)
return query(nod * 2 + 1, mid + 1, r, val);
else
return query(nod * 2, l, mid, val);
}
signed main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
d[++gs] = a[i];
}
for (int i = 1; i <= n; i++) {
b[i] = read();
d[++gs] = b[i];
}
for (int i = 1; i <= n; i++) {
c[i] = read();
d[++gs] = c[i];
}
sort(d + 1, d + gs + 1);
gs = unique(d + 1, d + gs + 1) - d - 1;
for (int i = 1; i <= n; i++) a[i] = lower_bound(d + 1, d + gs + 1, a[i]) - d;
for (int i = 1; i <= n; i++) b[i] = lower_bound(d + 1, d + gs + 1, b[i]) - d;
for (int i = 1; i <= n; i++) c[i] = lower_bound(d + 1, d + gs + 1, c[i]) - d;
for (int i = 1; i <= gs; i++) lst[i] = 0;
for (int i = 1; i <= n; i++) {
if (lst[a[i]]) continue;
lst[a[i]] = 1;
La[a[i]] = i;
}
for (int i = 1; i <= gs; i++) lst[i] = 0;
for (int i = 1; i <= n; i++) {
if (lst[b[i]]) continue;
lst[b[i]] = 1;
Lb[b[i]] = i;
}
for (int i = 1; i <= gs; i++) lst[i] = 0;
for (int i = 1; i <= n; i++) {
if (lst[c[i]]) continue;
lst[c[i]] = 1;
Lc[c[i]] = i;
}
build(1, 0, n);
for (int i = 1; i <= n; i++)
if ((!La[b[i]]) && (Lb[b[i]] == i)) {
if (!Lc[b[i]]) Xma = max(Xma, i);
}
for (int i = 1; i <= n; i++)
if ((!La[c[i]]) && (Lc[c[i]] == i)) {
if (!Lb[c[i]]) Yma = max(Yma, i);
}
for (int i = 1; i <= n; i++)
if ((!La[b[i]]) && (Lb[b[i]] == i)) {
if (Lc[b[i]]) {
int x = query(1, 0, n, Lc[b[i]]);
if (x <= i - 1) change(1, 0, n, x, i - 1, Lc[b[i]]);
}
}
int x = query(1, 0, n, Yma);
if (x <= n) change(1, 0, n, x, n, Yma);
ans = min(ans, n + max(Xma + Yma, find(1, 0, n, Xma, n)));
for (int i = n; i; i--) {
if (La[a[i]] == i) {
if (!Lb[a[i]]) {
if (!Lc[a[i]]) break;
Yma = max(Yma, Lc[a[i]]);
} else if (!Lc[a[i]])
Xma = max(Xma, Lb[a[i]]);
else {
int x = query(1, 0, n, Lc[a[i]]);
if (x <= Lb[a[i]] - 1) change(1, 0, n, x, Lb[a[i]] - 1, Lc[a[i]]);
}
}
int x = query(1, 0, n, Yma);
if (x <= n) change(1, 0, n, x, n, Yma);
ans = min(ans, i - 1 + max(Xma + Yma, find(1, 0, n, Xma, n)));
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int n, a[100010], b[100010], c[100010], tot;
int fa[300010] = {0}, fb[300010] = {0}, fc[300010] = {0};
struct forsort {
int val, id1, id2;
} f[300010];
struct Pair {
int b, c;
};
bool operator<(Pair a, Pair b) { return a.b < b.b; }
set<Pair> s;
set<Pair>::iterator it;
multiset<int> vals;
multiset<int>::iterator valit;
bool cmp(forsort a, forsort b) { return a.val < b.val; }
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &f[++tot].val);
f[tot].id1 = 1, f[tot].id2 = i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &f[++tot].val);
f[tot].id1 = 2, f[tot].id2 = i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &f[++tot].val);
f[tot].id1 = 3, f[tot].id2 = i;
}
sort(f + 1, f + 3 * n + 1, cmp);
tot = 0;
for (int i = 1; i <= 3 * n; i++) {
if (i == 1 || f[i].val != f[i - 1].val) tot++;
if (f[i].id1 == 1) a[f[i].id2] = tot;
if (f[i].id1 == 2) b[f[i].id2] = tot;
if (f[i].id1 == 3) c[f[i].id2] = tot;
}
for (int i = 1; i <= n; i++)
if (!fa[a[i]]) fa[a[i]] = i;
for (int i = 1; i <= n; i++)
if (!fb[b[i]]) fb[b[i]] = i;
for (int i = 1; i <= n; i++)
if (!fc[c[i]]) fc[c[i]] = i;
}
void insertPair(int newb, int newc) {
int nowb, nowc;
Pair e = {newb, newc};
it = s.upper_bound(e);
if ((*it).c >= e.c) return;
nowc = (*it).c;
it--;
valit = vals.find((*it).b + nowc);
vals.erase(valit);
while ((*it).c <= e.c) {
nowb = (*it).b, nowc = (*it).c;
it--;
vals.erase((*it).b + nowc);
it++;
s.erase(it);
it = s.lower_bound(e);
it--;
}
nowb = (*it).b, nowc = (*it).c;
vals.insert(nowb + e.c);
it++;
nowc = (*it).c;
vals.insert(e.b + nowc);
s.insert(e);
}
void work() {
Pair e;
e.b = 0, e.c = inf + 1;
s.insert(e);
e.b = inf + 1, e.c = 0;
s.insert(e);
vals.insert(0);
for (int i = 1; i <= tot; i++)
if (!fa[i]) insertPair(fb[i] ? fb[i] : inf, fc[i] ? fc[i] : inf);
int ans = inf;
bool flag = 1;
for (int i = n; i >= 1; i--) {
ans = min(ans, i + (*vals.begin()));
if (fa[a[i]] == i) {
if (!fb[a[i]] && !fc[a[i]]) {
flag = 0;
break;
}
insertPair(fb[a[i]] ? fb[a[i]] : inf, fc[a[i]] ? fc[a[i]] : inf);
}
}
if (flag) ans = min(ans, (*vals.begin()));
printf("%d", ans);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 3;
const int inf = 1e9 + 3;
int n, ans;
vector<int> vec;
int arr[3][N], appear[3][N];
struct segmentTree {
int segMax[N << 2], segMin[N << 2], realMin[N << 2];
bool lazy[N << 2];
void update(int k, int lp, int rp, int v = 1, int L = 0, int R = n + 1) {
realMin[v] = max(realMin[v], L);
if (R <= lp || rp <= L || segMin[v] >= k) return;
if (lp <= L && R <= rp && segMax[v] < k) {
segMax[v] = segMin[v] = k;
realMin[v] = k + L;
lazy[v] = true;
return;
}
if (lazy[v]) relax(v, L, R);
int mid = (L + R) >> 1;
update(k, lp, rp, v << 1, L, mid);
update(k, lp, rp, v << 1 | 1, mid, R);
segMax[v] = max(segMax[v << 1], segMax[v << 1 | 1]);
segMin[v] = min(segMin[v << 1], segMin[v << 1 | 1]);
realMin[v] = min(realMin[v << 1], realMin[v << 1 | 1]);
return;
}
void relax(int v, int L, int R) {
segMin[v << 1] = segMax[v << 1] = segMax[v];
segMin[v << 1 | 1] = segMax[v << 1 | 1] = segMax[v];
realMin[v << 1] = L + segMax[v];
realMin[v << 1 | 1] = (L + R) / 2 + segMax[v];
lazy[v << 1] = lazy[v << 1 | 1] = true;
lazy[v] = false;
return;
}
} tree;
void input() {
cin.tie(0);
cin >> n;
for (int i = 0; i < 3; i++)
for (int j = 1; j <= n; j++) cin >> arr[i][j];
return;
}
void prePros() {
for (int i = 0; i < 3; i++)
for (int j = 1; j <= n; j++) vec.push_back(arr[i][j]);
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (int i = 0; i < 3; i++)
for (int j = 1; j <= n; j++) {
arr[i][j] =
lower_bound(vec.begin(), vec.end(), arr[i][j]) - vec.begin() + 1;
if (!appear[i][arr[i][j]]) appear[i][arr[i][j]] = j;
}
for (int i = 0; i < 3; i++)
for (int j = 0; j < vec.size(); j++)
if (!appear[i][j + 1]) appear[i][j + 1] = inf;
return;
}
void solve() {
prePros();
for (int i = 0; i < vec.size(); i++)
if (appear[0][i + 1] == inf && appear[1][i + 1] == inf)
tree.update(appear[2][i + 1], 0, n + 1);
for (int j = n - 1; j >= 0; j--)
if (appear[0][arr[1][j + 1]] == inf && appear[1][arr[1][j + 1]] == j + 1)
tree.update(appear[2][arr[1][j + 1]], 0, j + 1);
ans = tree.realMin[1] + n;
for (int u = n - 1; u >= 0; u--) {
if (appear[0][arr[0][u + 1]] == u + 1)
tree.update(appear[2][arr[0][u + 1]], 0,
min(appear[1][arr[0][u + 1]], n + 1));
ans = min(ans, u + tree.realMin[1]);
}
return;
}
int main() {
ios::sync_with_stdio(false), cout.tie(0);
input();
solve();
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 8, M = 3e5 + 8, INF = 10 * N;
int n, m, a[N], b[N], c[N], d[M], flag[M], ans;
struct Node {
int x, y, p;
Node(int _x = 0, int _y = 0, int _p = 0) {
x = _x;
y = _y;
p = _p;
}
bool operator<(const Node &b) const { return x == b.x ? y < b.y : x < b.x; }
} coo[M];
struct Point {
int x, y, p1, p2;
Point() { x = y = p1 = p2 = 0; }
Point(int _x, int _y, int _p1, int _p2) {
x = _x;
y = _y;
p1 = _p1;
p2 = _p2;
}
bool operator<(const Point &b) const { return x + y > b.x + b.y; }
};
set<Node> bst;
set<Node>::iterator it, tmpit;
priority_queue<Point> q;
int POS(int x) { return lower_bound(d + 1, d + m + 1, x) - d; }
void Insert(Node A) {
if ((*bst.upper_bound(A)).y >= A.y) return;
it = (--bst.lower_bound(A));
tmpit = it;
while ((*it).y <= A.y) --tmpit, bst.erase(it), it = tmpit;
q.push(Point((*it).x, A.y, (*it).p, A.p));
it = bst.upper_bound(A);
q.push(Point(A.x, (*it).y, A.p, (*it).p));
bst.insert(A);
}
bool check(Point A) {
if ((*bst.lower_bound(coo[A.p1])).p != A.p1 ||
(*bst.lower_bound(coo[A.p2])).p != A.p2)
return 0;
return ((*bst.upper_bound(coo[A.p1])).p == A.p2 &&
(*--bst.lower_bound(coo[A.p2])).p == A.p1);
}
int query() {
while (!check(q.top())) q.pop();
return q.top().x + q.top().y;
}
void solve() {
for (int i = 1; i <= n; i++) flag[POS(a[i])]++;
for (int i = 1; i <= m; i++) coo[i] = Node(INF, INF, i);
for (int i = 1; i <= n; i++) {
int p = POS(b[i]);
coo[p].x = min(coo[p].x, i);
p = POS(c[i]);
coo[p].y = min(coo[p].y, i);
}
bst.insert(coo[0] = Node(0, INF + 1, 0));
bst.insert(coo[m + 1] = Node(INF + 1, 0, m + 1));
q.push(Point(0, 0, 0, m + 1));
for (int i = 1; i <= m; i++)
if (!flag[i]) Insert(coo[i]);
ans = 3 * n;
for (int i = n; i >= 0; i--) {
ans = min(ans, i + query());
if (!i) break;
int p = POS(a[i]);
flag[p]--;
if (!flag[p]) {
if (coo[p].x <= n || coo[p].y <= n)
Insert(coo[p]);
else
break;
}
}
printf("%d\n", ans);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), d[++m] = a[i];
for (int i = 1; i <= n; i++) scanf("%d", &b[i]), d[++m] = b[i];
for (int i = 1; i <= n; i++) scanf("%d", &c[i]), d[++m] = c[i];
sort(d + 1, d + m + 1);
m = unique(d + 1, d + m + 1) - d - 1;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> a(n), b(n), c(n);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
for (int i = 0; i < n; ++i) cin >> c[i];
for (auto k : c) {
b.push_back(k);
}
map<int, int> whereb;
map<int, int> wherec;
for (int i = (int)b.size() - 1; i >= 0; --i) whereb[b[i]] = i;
for (int i = (int)c.size() - 1; i >= 0; --i) wherec[c[i]] = i;
vector<bool> first_in_a(a.size(), false);
vector<bool> first_in_b(b.size(), false);
set<int> ina, inb;
for (int i = 0; i < a.size(); ++i) {
if (!ina.count(a[i])) {
ina.insert(a[i]);
first_in_a[i] = true;
}
}
for (int i = 0; i < b.size(); ++i) {
if (!inb.count(b[i])) {
inb.insert(b[i]);
first_in_b[i] = true;
}
}
set<pair<int, int>> maxs;
multiset<int> res;
maxs.emplace(1e9, 0);
maxs.emplace(-1, 1e9 + 5);
res.insert(maxs.begin()->first + next(maxs.begin())->second + 1);
auto del = [&](pair<int, int> p) {
auto it = maxs.find(p);
assert(it != maxs.end());
auto inext = next(it);
auto iprev = prev(it);
res.erase(res.find(iprev->first + it->second + 1));
res.erase(res.find(it->first + inext->second + 1));
maxs.erase(it);
res.insert(iprev->first + inext->second + 1);
};
auto add = [&](pair<int, int> p) {
auto it = maxs.lower_bound(make_pair(p.first, -5));
if (it->second >= p.second) return;
if (it->first == p.first) {
++it;
}
while (prev(it)->second <= p.second) del(*prev(it));
maxs.insert(p);
it = maxs.find(p);
auto inext = next(it);
auto iprev = prev(it);
res.insert(iprev->first + it->second + 1);
res.insert(it->first + inext->second + 1);
res.erase(res.find(iprev->first + inext->second + 1));
};
for (int i = 0; i < b.size(); ++i) {
if (first_in_b[i] && !ina.count(b[i])) {
int inc = 1e9;
if (wherec.count(b[i])) inc = wherec[b[i]] + 1;
add({i, inc});
}
}
int ans = n + *res.begin();
for (int i = n - 1; i >= 0; --i) {
if (first_in_a[i]) {
if (!inb.count(a[i])) break;
int inc = 1e9;
if (wherec.count(a[i])) inc = wherec[a[i]] + 1;
add({whereb[a[i]], inc});
}
ans = min(ans, i + *res.begin());
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double PI = acos(0.) * 2;
const int lim = 1000000000;
const int inf = ~0U >> 1;
template <class T>
T abs(T first) {
return first < 0 ? -first : first;
}
const int N = 100005;
int g[N];
struct node {
int a[3];
node() {
for (int i = 0; i < 3; ++i) a[i] = lim / 10;
}
bool operator<(const node &b) const {
for (int i = 0; i < 3; ++i) {
if (a[i] < b.a[i]) return true;
if (a[i] > b.a[i]) return false;
}
return false;
}
};
map<int, node> f;
void read(int type, int i) {
int first;
scanf("%d", &first);
if (!f.count(first)) f[first] = node();
f[first].a[type] = min(f[first].a[type], i);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) read(0, i);
for (int i = 1; i <= n; ++i) read(1, i);
for (int i = 1; i <= n; ++i) read(2, i);
vector<node> a;
for (map<int, node>::iterator i = f.begin(); i != f.end(); ++i)
a.push_back(i->second);
sort(a.begin(), a.end());
map<int, node> F;
multiset<int> G;
int tt = 0;
for (int i = ((int)((a).size())) - 1; i >= 0; --i) {
tt = max(tt, a[i].a[2]);
map<int, node>::iterator j;
j = F.find(a[i].a[1]);
if (j == F.end()) {
F[a[i].a[1]] = node();
j = F.find(a[i].a[1]);
j->second.a[1] = a[i].a[2];
G.insert(j->first + j->second.a[0]);
} else
j->second.a[1] = max(j->second.a[1], a[i].a[2]);
G.erase(G.find(j->first + j->second.a[0]));
map<int, node>::iterator k = j;
++k;
if (k == F.end())
j->second.a[0] = 0;
else
j->second.a[0] = max(k->second.a[0], k->second.a[1]);
G.insert(j->first + j->second.a[0]);
int last = -1;
node tmp = j->second;
tmp.a[0] = max(j->second.a[0], j->second.a[1]);
while (1) {
k = j;
if (k == F.begin()) break;
--k;
if (k->second.a[0] <= max(j->second.a[0], j->second.a[1])) {
tmp.a[1] = max(tmp.a[1], k->second.a[1]);
last = k->first;
G.erase(G.find(k->first + k->second.a[0]));
F.erase(k);
} else
break;
}
if (last != -1) {
F[last] = tmp;
j = F.find(last);
G.insert(j->first + j->second.a[0]);
}
g[i] = *G.begin();
if (tt < g[i]) g[i] = tt;
}
int ans = g[0];
for (int i = 0; i < ((int)((a).size())); ++i) {
ans = min(ans, a[i].a[0] + g[i + 1]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-O2")
using namespace std;
const int N = 100000 + 10;
const long long MOD = 1000000000 + 7;
const long long INF = 1000000010;
const long long LOG = 25;
struct node {
int ans, mn;
};
int n, a[3][N], b[N], c[N], koj[3][N], lazy[N << 2], adad[N];
node seg[N << 2];
void modify(int id, int x, int l) {
seg[id].mn = x;
seg[id].ans = l + x;
lazy[id] = x;
}
void shift(int id, int l, int r) {
if (lazy[id] == -1) return;
int md = (l + r) >> 1;
modify(id << 1, lazy[id], l);
modify(id << 1 | 1, lazy[id], md);
lazy[id] = -1;
}
void Set(int id, int lq, int rq, int x, int l, int r) {
if (rq <= l || r <= lq) return;
if (lq <= l && r <= rq) {
modify(id, x, l);
return;
}
int md = (l + r) >> 1;
shift(id, l, r);
Set(id << 1, lq, rq, x, l, md);
Set(id << 1 | 1, lq, rq, x, md, r);
seg[id].mn = min(seg[id << 1].mn, seg[id << 1 | 1].mn);
seg[id].ans = min(seg[id << 1].ans, seg[id << 1 | 1].ans);
}
int get(int id, int x, int l, int r) {
if (r - l == 1) return l;
shift(id, l, r);
int md = (l + r) >> 1;
if (seg[id << 1].mn < x) return get(id << 1, x, l, md);
return get(id << 1 | 1, x, md, r);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < (N << 2); i++) lazy[i] = -1, seg[i].mn = seg[i].ans = INF;
cin >> n;
vector<int> num;
for (int i = 0; i < 3; i++)
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
num.push_back(a[i][j]);
}
sort(num.begin(), num.end());
num.resize(unique(num.begin(), num.end()) - num.begin());
for (int i = 0; i < 3; i++)
for (int j = 1; j <= n; j++) {
a[i][j] = lower_bound(num.begin(), num.end(), a[i][j]) - num.begin() + 1;
}
for (int i = 1; i <= 3 * n; i++) {
for (int j = 0; j < 3; j++) koj[j][i] = INF;
}
for (int i = 0; i < 3; i++)
for (int j = 1; j <= n; j++) {
if (koj[i][a[i][j]] == INF) koj[i][a[i][j]] = j;
}
set<pair<int, int> > st;
for (int i = 0; i < num.size(); i++) {
st.insert({-koj[2][i + 1], i + 1});
}
for (int i = 1; i <= n; i++) st.erase({-koj[2][a[0][i]], a[0][i]});
for (int i = 0; i <= n; i++) {
if (st.size() == 0) {
adad[i] = 0;
} else {
adad[i] = -(st.begin()->first);
st.erase({-koj[2][a[1][i + 1]], a[1][i + 1]});
}
}
for (int i = 0; i <= n; i++) Set(1, i, i + 1, adad[i], 0, n + 1);
int ans = seg[1].ans + n;
for (int i = n - 1; i >= 0; i--) {
if (koj[0][a[0][i + 1]] == i + 1) {
int x = koj[1][a[0][i + 1]];
int y = koj[2][a[0][i + 1]];
if (seg[1].mn >= y) {
ans = min(ans, i + seg[1].ans);
continue;
}
int koj = get(1, y, 0, n + 1);
if (koj >= x) {
ans = min(ans, i + seg[1].ans);
continue;
}
Set(1, koj, x, y, 0, n + 1);
ans = min(ans, i + seg[1].ans);
}
ans = min(ans, i + seg[1].ans);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e7;
const int MN = 1e5 + 7;
struct int3 {
int a[3];
bool operator<(const int3 &x) const { return a[0] > x.a[0]; }
} ept;
int n, t, ans = INF;
int3 f[MN * 3];
map<int, int3> mp;
map<int, int3>::iterator mi;
set<pair<int, int> > u;
set<pair<int, int> >::iterator ui, ii;
multiset<int> res;
void gao(int x, int y) {
ui = u.upper_bound(pair<int, int>(x, y));
if (ui->second >= y) return;
pair<int, int> pre = *ui;
ii = ui;
ii--;
while (ii->second <= y) {
res.erase(res.find(ii->first + pre.second));
pre = *ii;
ii--;
u.erase(pre);
}
res.erase(res.find(ii->first + pre.second));
res.insert(ii->first + y);
res.insert(x + ui->second);
u.insert(pair<int, int>(x, y));
}
int main() {
scanf("%d", &n);
int i, j, k, l;
for (i = 0; i < 3; i++) ept.a[i] = INF;
for (i = 0; i < 3; i++) {
for (j = 1; j <= n; j++) {
scanf("%d", &k);
if (mp.find(k) == mp.end()) mp[k] = ept;
mp[k].a[i] = min(mp[k].a[i], j);
}
}
for (mi = mp.begin(); mi != mp.end(); mi++) f[t++] = mi->second;
sort(f, f + t);
f[t].a[0] = 0;
u.insert(pair<int, int>(0, INF * 2));
u.insert(pair<int, int>(INF * 2, 0));
res.insert(0);
l = 0;
k = INF;
for (i = 0; i <= t; i++) {
if (f[i].a[0] < k) {
for (j = l; j < i; j++) gao(f[j].a[1], f[j].a[2]);
k = f[i].a[0];
l = i;
ans = min(ans, *res.begin() + k);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct gt {
int x, y;
inline gt(int a = 0, int b = 0) {
x = a;
y = b;
}
inline bool operator<(const gt &a) const {
if (a.x == x)
return y < a.y;
else
return x < a.x;
}
};
set<gt> S;
multiset<int> res;
int n, N;
int a[310000], b[310000], c[310000], fa[310000], fb[310000], fc[310000],
q[310000];
struct po {
int x, y, z;
} ans[310000];
inline int get(int x) { return lower_bound(q + 1, q + 1 + N, x) - q; }
inline bool cmp(const po &x, const po &y) { return x.x > y.x; }
int flag[310000];
inline void in(int x, int y) {
if (x > n || y > n) return;
flag[x + y]++;
if (flag[x + y] == 1) res.insert(x + y);
}
inline void er(int x, int y) {
if (x > n || y > n) return;
flag[x + y]--;
if (flag[x + y] == 0) res.erase(x + y);
}
inline void Add(set<gt>::iterator t1) {
gt std = gt(0, 0);
gt nxt, pre;
if (t1 == S.begin())
pre = std;
else {
pre = *(--t1);
t1++;
}
if (++t1 == S.end())
nxt = std;
else
nxt = *t1;
t1--;
er(pre.x, nxt.y);
in(pre.x, (*t1).y);
in((*t1).x, nxt.y);
}
inline void Del(set<gt>::iterator t1) {
gt std = gt(0, 0);
gt nxt, pre;
if (t1 == S.begin())
pre = std;
else {
pre = *(--t1);
t1++;
}
if (++t1 == S.end())
nxt = std;
else
nxt = *t1;
t1--;
in(pre.x, nxt.y);
er(pre.x, (*t1).y);
er((*t1).x, nxt.y);
S.erase(t1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
q[++q[0]] = a[i];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
q[++q[0]] = b[i];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
q[++q[0]] = c[i];
}
sort(q + 1, q + 1 + q[0]);
N = unique(q + 1, q + 1 + q[0]) - q - 1;
for (int i = 1; i <= n; i++) {
a[i] = get(a[i]);
b[i] = get(b[i]);
c[i] = get(c[i]);
}
memset(fa, 63, sizeof fa);
memset(fb, 63, sizeof fb);
memset(fc, 63, sizeof fc);
for (int i = n; i >= 1; i--) fa[a[i]] = i;
for (int i = n; i >= 1; i--) fb[b[i]] = i;
for (int i = n; i >= 1; i--) fc[c[i]] = i;
for (int i = 1; i <= N; i++) ans[i] = (po){fa[i], fb[i], fc[i]};
sort(ans + 1, ans + 1 + N, cmp);
int Res = 21333333;
if (ans[1].x <= n) Res = ans[1].x;
gt tmp;
for (int i = 1; i <= N; i++) {
tmp = gt(ans[i].y, ans[i].z);
set<gt>::iterator t1 = S.upper_bound(tmp);
if (t1 == S.end() || t1->y < tmp.y) {
if (t1 != S.begin()) {
--t1;
while (t1->y <= tmp.y) {
if (t1 == S.begin()) {
Del(t1);
break;
}
Del(t1--);
}
}
S.insert(tmp);
Add(S.lower_bound(tmp));
}
if (res.begin() != res.end()) Res = min(Res, (*res.begin()) + ans[i + 1].x);
}
printf("%d\n", Res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ans;
int a[4][500005];
map<int, int> occ[4];
namespace staircase {
set<pair<int, int> > stairs;
multiset<int> results;
inline int get(void) { return *results.begin(); }
inline void add(pair<int, int> a) {
set<pair<int, int> >::iterator l, i, r = stairs.lower_bound(a);
if (r->second >= a.second) return;
l = i = stairs.insert(a).first;
l--;
if (results.find(l->first + r->second) != results.end())
results.erase(results.find(l->first + r->second));
results.insert(i->first + r->second);
while (l->second < i->second) {
r = l--;
results.erase(results.find(l->first + r->second));
stairs.erase(r);
}
results.insert(l->first + i->second);
}
}; // namespace staircase
inline int fnd(int haystack, int needle) {
return occ[haystack].count(needle) ? occ[haystack][needle] : 500005;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
if (!occ[i].count(a[i][j])) occ[i][a[i][j]] = j;
}
staircase::results.insert(0);
staircase::stairs.insert(make_pair(0, 500005));
staircase::stairs.insert(make_pair(500005, 0));
for (int i = 2; i <= 3; i++)
for (int j = 1; j <= n; j++) {
if (fnd(1, a[i][j]) == 500005)
staircase::add(make_pair(fnd(2, a[i][j]), fnd(3, a[i][j])));
}
ans = 3 * n;
ans = min(ans, n + staircase::get());
for (int i = n; i >= 1; i--) {
if (fnd(1, a[1][i]) == i)
staircase::add(make_pair(fnd(2, a[1][i]), fnd(3, a[1][i])));
ans = min(ans, i - 1 + staircase::get());
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1073741824")
using namespace std;
const int nmax = 100100;
pair<int, pair<int, int> > A[3 * nmax];
int a[nmax], b[nmax], c[nmax];
int all[3 * nmax];
int kAll;
bool used[3 * nmax];
bool leaf[4 * 3 * nmax];
int t[4 * 3 * nmax];
inline void push(int v, int tl, int tr) {
if (tl != tr) {
leaf[v] = false;
int mid = (tl + tr) / 2;
int add = t[v] - tl;
t[2 * v] = add + tl;
t[2 * v + 1] = add + mid + 1;
leaf[2 * v] = leaf[2 * v + 1] = true;
}
}
void build(int v, int tl, int tr) {
leaf[v] = true;
t[v] = tl;
}
void upd(int v, int tl, int tr, int l, int r, int val) {
if (tl == l && tr == r) {
leaf[v] = true;
t[v] = val + tl;
return;
}
if (leaf[v]) push(v, tl, tr);
int mid = (tl + tr) / 2;
if (r <= mid) {
upd(2 * v, tl, mid, l, r, val);
} else if (mid < l) {
upd(2 * v + 1, mid + 1, tr, l, r, val);
} else {
upd(2 * v, tl, mid, l, mid, val);
upd(2 * v + 1, mid + 1, tr, mid + 1, r, val);
}
t[v] = min(t[2 * v], t[2 * v + 1]);
}
int get(int v, int tl, int tr, int l, int r) {
if (leaf[v]) {
int add = t[v] - tl;
return add + l;
}
if (tl == l && tr == r) {
return t[v];
}
if (leaf[v]) push(v, tl, tr);
int mid = (tl + tr) / 2;
if (r <= mid) {
return get(2 * v, tl, mid, l, r);
} else if (mid < l) {
return get(2 * v + 1, mid + 1, tr, l, r);
} else {
return min(get(2 * v, tl, mid, l, mid),
get(2 * v + 1, mid + 1, tr, mid + 1, r));
}
}
void upd(int r, int val, int n) {
--r;
if (r >= 1000000000 / 2) {
r = n;
}
int L = -1;
int R = n + 1;
while (L + 1 < R) {
int mid = (L + R) / 2;
if (get(1, 0, n, mid, mid) - mid < val) {
R = mid;
} else {
L = mid;
}
}
int l = R;
if (l <= r) {
upd(1, 0, n, l, r, val);
}
}
int get(int l, int r, int n) {
int v = get(1, 0, n, l, r);
return v;
}
int main() {
int n, x;
scanf("%d", &n);
for (int(i) = 0; (i) < (n); ++(i)) {
scanf("%d", &x);
all[kAll++] = x;
a[i] = x;
}
for (int(i) = 0; (i) < (n); ++(i)) {
scanf("%d", &x);
all[kAll++] = x;
b[i] = x;
}
for (int(i) = 0; (i) < (n); ++(i)) {
scanf("%d", &x);
all[kAll++] = x;
c[i] = x;
}
sort(all, all + 3 * n);
int kAll = unique(all, all + 3 * n) - all;
for (int(i) = 0; (i) < (n); ++(i))
a[i] = lower_bound(all, all + kAll, a[i]) - all;
for (int(i) = 0; (i) < (n); ++(i))
b[i] = lower_bound(all, all + kAll, b[i]) - all;
for (int(i) = 0; (i) < (n); ++(i))
c[i] = lower_bound(all, all + kAll, c[i]) - all;
for (int(i) = 0; (i) < (kAll); ++(i))
A[i] = make_pair((1000000000), (make_pair((1000000000), (1000000000))));
memset((used), 0, sizeof(used));
for (int(i) = 0; (i) < (n); ++(i))
if (!used[a[i]]) {
A[a[i]].first = i + 1;
used[a[i]] = true;
}
memset((used), 0, sizeof(used));
for (int(i) = 0; (i) < (n); ++(i))
if (!used[b[i]]) {
A[b[i]].second.first = i + 1;
used[b[i]] = true;
}
memset((used), 0, sizeof(used));
for (int(i) = 0; (i) < (n); ++(i))
if (!used[c[i]]) {
A[c[i]].second.second = i + 1;
used[c[i]] = true;
}
sort(A, A + kAll);
build(1, 0, n);
int last = -1;
for (int(i) = (kAll); (i)--;)
if (A[i].first == 1000000000) {
int bp = A[i].second.first;
int cp = A[i].second.second;
upd(cp, bp, n);
}
int ans = get(0, n, n);
for (int(i) = (kAll); (i)--;)
if (A[i].first != 1000000000) {
ans += A[i].first;
break;
}
for (int(i) = (kAll); (i)--;)
if (A[i].first != 1000000000) {
int bp = A[i].second.first;
int cp = A[i].second.second;
upd(cp, bp, n);
ans = min(ans, (i ? A[i - 1].first : 0) + get(0, n, n));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXU = 300005;
const int MAXN = 100005;
struct triple {
int v[3];
bool operator<(const triple &y) const { return v[0] > y.v[0]; }
};
pair<int, int> sv[3][MAXN];
int N, M, av[MAXU];
triple fo[MAXU];
map<int, int> pf;
map<int, int> cd;
void erase(int v) {
if (cd[v] > 1)
cd[v]--;
else
cd.erase(v);
}
void insert(int v) { cd[v]++; }
void del(map<int, int>::iterator it) {
erase(prev(it)->first + it->second);
erase(it->first + next(it)->second);
insert(prev(it)->first + next(it)->second);
pf.erase(it);
}
void add(int x, int y) {
auto it = pf.lower_bound(x);
erase(prev(it)->first + it->second);
insert(prev(it)->first + y);
insert(x + it->second);
pf[x] = y;
}
void ins(triple &t) {
auto it = pf.lower_bound(t.v[1]);
if (it->second < t.v[2]) {
if (it->first == t.v[1]) {
del(it);
}
add(t.v[1], t.v[2]);
for (it = --pf.lower_bound(t.v[1]); it->second < t.v[2];) del(it--);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> N;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < N; j++) {
cin >> sv[i][j].first;
sv[i][j].second = j;
av[M++] = sv[i][j].first;
}
sort(sv[i], sv[i] + N);
}
sort(av, av + M);
M = unique(av, av + M) - av;
for (int i = 0; i < M; i++) {
for (int j = 0; j < 3; j++) {
auto it = lower_bound(sv[j], sv[j] + N, make_pair(av[i], -1));
if (it == (sv[j] + N) || it->first != av[i])
fo[i].v[j] = MAXU;
else
fo[i].v[j] = it->second + 1;
}
}
sort(fo, fo + M);
pf[0] = MAXU;
pf[MAXU + 1] = 0;
cd[0] = 1;
int ans = MAXU;
for (int i = 0; i < M; i++) {
ans = min(ans, fo[i].v[0] + cd.begin()->first);
ins(fo[i]);
}
cout << min(ans, cd.begin()->first) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e5 + 42;
struct info {
int u, v, w;
};
info interesting[nmax * 3];
int id;
void add(info current) {
id++;
interesting[id] = current;
}
int n;
int a[nmax], b[nmax], c[nmax];
map<int, int> seena, seenb, seenc;
bool cmp(info a, info b) { return a.u < b.u; }
set<pair<int, int> > active;
set<pair<int, int> > least;
void update(int v, int w) {
pair<int, int> now = {v, w};
set<pair<int, int> >::iterator it;
it = active.lower_bound(now);
if ((*it).second >= w) return;
while (1) {
it = active.lower_bound(now);
pair<int, int> lower = *it;
it--;
pair<int, int> lower_before = *it;
it--;
pair<int, int> lower_before_before = *it;
if (lower_before.second <= w) {
active.erase(lower_before);
least.erase({lower_before.first + lower.second, lower.second});
least.erase({lower_before_before.first + lower_before.second,
lower_before.second});
least.insert({lower_before_before.first + lower.second, lower.second});
} else
break;
}
it = active.lower_bound(now);
pair<int, int> lower = *it;
it--;
pair<int, int> lower_before = *it;
least.erase({lower_before.first + lower.second, lower.second});
least.insert({lower_before.first + now.second, now.second});
least.insert({now.first + lower.second, lower.second});
active.insert(now);
}
int query() {
int ret = 3 * n, prev = 1e9;
for (auto k : active) {
ret = min(ret, k.second + prev);
prev = k.first;
}
return ret;
}
int main() {
scanf("%i", &n);
for (int i = 1; i <= n; i++) scanf("%i", &a[i]);
for (int i = n; i >= 1; i--) seena[a[i]] = i;
for (int i = 1; i <= n; i++) scanf("%i", &b[i]);
for (int i = n; i >= 1; i--) seenb[b[i]] = i;
for (int i = 1; i <= n; i++) scanf("%i", &c[i]);
for (int i = n; i >= 1; i--) seenc[c[i]] = i;
for (int i = 1; i <= n; i++) {
info current;
current.u = 3 * n + 1;
if (seena.count(a[i])) current.u = seena[a[i]];
current.v = 3 * n + 1;
if (seenb.count(a[i])) current.v = seenb[a[i]];
current.w = 3 * n + 1;
if (seenc.count(a[i])) current.w = seenc[a[i]];
if (current.u == i) add(current);
}
for (int i = 1; i <= n; i++) {
info current;
current.u = 3 * n + 1;
if (seena.count(b[i])) current.u = seena[b[i]];
current.v = 3 * n + 1;
if (seenb.count(b[i])) current.v = seenb[b[i]];
current.w = 3 * n + 1;
if (seenc.count(b[i])) current.w = seenc[b[i]];
if (current.u > n && current.v == i) add(current);
}
for (int i = 1; i <= n; i++) {
info current;
current.u = 3 * n + 1;
if (seena.count(c[i])) current.u = seena[c[i]];
current.v = 3 * n + 1;
if (seenb.count(c[i])) current.v = seenb[c[i]];
current.w = 3 * n + 1;
if (seenc.count(c[i])) current.w = seenc[c[i]];
if (current.u > n && current.v > n && current.w == i) add(current);
}
active.insert({0, 3 * n + 2});
active.insert({3 * n + 2, 0});
least.insert({0, 0});
sort(interesting + 1, interesting + id + 1, cmp);
for (int i = 2; i <= id; i++)
assert(interesting[i - 1].u != interesting[i].u ||
interesting[i - 1].v != interesting[i].v ||
interesting[i - 1].w != interesting[i].w);
int ret = 3 * n;
for (int u = n; u >= 0; u--) {
bool stop = 0;
while (id && u < interesting[id].u) {
if (interesting[id].v > n && interesting[id].w > n) {
stop = 1;
break;
}
update(interesting[id].v, interesting[id].w);
id--;
}
if (stop) break;
int q = (*least.begin()).first;
ret = min(ret, u + q);
}
printf("%i\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, m, ans, a[N], b[N], c[N], id[N], V[N], A[N], B[N], C[N];
multiset<int> res;
set<pair<int, int> > H;
bool cmp(const int i, const int j) { return A[i] > A[j]; }
void ins(pair<int, int> z) {
set<pair<int, int> >::iterator l, i, r = H.lower_bound(z);
if (r->second >= z.second) return;
i = H.insert(z).first, l = i, --l, res.erase(res.find(l->first + r->second)),
res.insert(i->first + r->second);
while (l->second < i->second)
r = l--, res.erase(res.find(l->first + r->second)), H.erase(r);
res.insert(l->first + i->second);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", a + i), V[m++] = a[i];
for (int i = 0; i < n; ++i) scanf("%d", b + i), V[m++] = b[i];
for (int i = 0; i < n; ++i) scanf("%d", c + i), V[m++] = c[i];
sort(V, V + m), m = unique(V, V + m) - V;
for (int i = 0; i < n; ++i) a[i] = lower_bound(V, V + m, a[i]) - V;
for (int i = 0; i < n; ++i) b[i] = lower_bound(V, V + m, b[i]) - V;
for (int i = 0; i < n; ++i) c[i] = lower_bound(V, V + m, c[i]) - V;
for (int i = 0; i < m; ++i) A[i] = B[i] = C[i] = 9 * n;
for (int i = 0; i < n; ++i)
if (A[a[i]] > n) A[a[i]] = i + 1;
for (int i = 0; i < n; ++i)
if (B[b[i]] > n) B[b[i]] = i + 1;
for (int i = 0; i < n; ++i)
if (C[c[i]] > n) C[c[i]] = i + 1;
for (int i = 0; i < m + 1; ++i) id[i] = i;
A[m] = 0, sort(id, id + m, cmp);
H.insert(make_pair(0, 10 * n)), H.insert(make_pair(10 * n, 0)), res.insert(0),
ans = A[*id];
for (int i = 0; i < m; ++i)
ins(make_pair(B[id[i]], C[id[i]])),
ans = min(ans, A[id[i + 1]] + *res.begin());
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int INF = 2e8;
map<int, int> mp[4];
tuple<int, int, int> v[MAXN];
set<pair<int, int> > cl;
multiset<int> valores;
int n, respf;
void update(int a, int b) {
auto mit = cl.lower_bound({a, b});
if (mit->first >= a && mit->second >= b) return;
auto bb = (*mit);
auto aa = (*(--mit));
valores.erase(valores.find(aa.first + bb.second));
valores.insert(aa.first + b);
valores.insert(a + bb.second);
cl.insert({a, b});
mit = cl.lower_bound({a, b});
mit--;
while (mit->first <= a && mit->second <= b) {
bb = (*(mit));
aa = (*(--mit));
mit = cl.erase(++mit);
mit--;
valores.erase(valores.find(aa.first + bb.second));
valores.erase(valores.find(bb.first + b));
valores.insert(aa.first + b);
}
}
int query() { return *valores.begin(); }
int main() {
scanf("%d", &n);
respf = 3 * n;
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
int val;
scanf("%d", &val);
if (mp[1][val] == 0) mp[1][val] = INF;
if (mp[2][val] == 0) mp[2][val] = INF;
if (mp[3][val] == 0) mp[3][val] = INF;
mp[i][val] = min(mp[i][val], j);
}
}
n = 0;
for (auto &mit : mp[1]) {
int val = mit.first;
v[++n] = {mp[1][val], mp[2][val], mp[3][val]};
}
sort(v + 1, v + 1 + n);
v[0] = {0, 0, 0};
cl.insert({0, INF * 2});
cl.insert({INF * 2, 0});
valores.insert(0);
respf = min(respf, get<0>(v[n]));
for (int i = n; i >= 1; i--) {
int custo = get<0>(v[i - 1]);
update(get<1>(v[i]), get<2>(v[i]));
custo += query();
respf = min(respf, custo);
}
printf("%d\n", respf);
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 300010;
struct Tri {
int i, j, k;
bool operator<(const Tri &t) const { return k < t.k; }
} d[MAXN];
int n, endpos;
void init() {
static int a[MAXN], b[MAXN], c[MAXN];
std::cin >> n;
for (int i = 1; i <= n; i++) std::cin >> a[i];
for (int i = 1; i <= n; i++) std::cin >> b[i];
for (int i = 1; i <= n; i++) std::cin >> c[i];
std::map<int, int> pa, pb, pc;
std::set<int> numbers;
for (int i = n; i >= 1; i--) numbers.insert(a[i]), pa[a[i]] = i;
for (int i = n; i >= 1; i--) numbers.insert(b[i]), pb[b[i]] = i;
for (int i = n; i >= 1; i--) numbers.insert(c[i]), pc[c[i]] = i;
n = 0;
int tt = endpos = MAXN * 3;
for (std::set<int>::iterator it = numbers.begin(); it != numbers.end();
++it) {
int x = *it;
++n;
if (pa.find(x) == pa.end())
d[n].i = ++tt;
else
d[n].i = pa[x];
if (pb.find(x) == pb.end())
d[n].j = ++tt;
else
d[n].j = pb[x];
if (pc.find(x) == pc.end())
d[n].k = ++tt;
else
d[n].k = pc[x];
}
}
struct Pair {
int i, j;
Pair(int i, int j) : i(i), j(j) {}
bool operator<(const Pair &t) const { return i < t.i; }
};
std::set<Pair> seq;
std::multiset<int> ans;
void del(Pair p) {
std::set<Pair>::iterator y = seq.lower_bound(p);
std::set<Pair>::iterator x = y, z = y;
--x, ++z;
ans.erase(ans.find(x->i + y->j));
ans.erase(ans.find(y->i + z->j));
ans.insert(x->i + z->j);
seq.erase(y);
}
void add(Pair p) {
seq.insert(p);
std::set<Pair>::iterator y = seq.lower_bound(p);
std::set<Pair>::iterator x = y, z = y;
--x, ++z;
if (z->j > y->j) {
seq.erase(p);
return;
}
ans.insert(x->i + y->j);
ans.insert(y->i + z->j);
ans.erase(ans.find(x->i + z->j));
while (1) {
x = seq.lower_bound(p);
--x;
if (x->j < p.j) {
del(*x);
} else
break;
}
}
void solve() {
std::sort(d + 1, d + n + 1);
int ret = 1 << 30;
seq.clear();
seq.insert(Pair(0, 1 << 28));
seq.insert(Pair(1 << 28, 0));
ans.insert(0);
int cur = n;
while (cur >= 1 && d[cur].k >= endpos) {
add(Pair(d[cur].i, d[cur].j));
--cur;
}
while (cur >= 1) {
ret = std::min(ret, *ans.begin() + d[cur].k);
add(Pair(d[cur].i, d[cur].j));
--cur;
}
ret = std::min(ret, *ans.begin());
std::cout << ret << std::endl;
}
int main() {
init();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
struct foo {
int y, z, s;
foo() {}
foo(int _y, int _z) : y(_y), z(_z), s(_y + _z) {}
bool operator<(const foo& rhs) const {
if (s != rhs.s) return s < rhs.s;
return y < rhs.y;
}
};
const int N = 100005;
int n, a[3][N], x[N][3];
bool vst[N];
map<int, int> idx, mp, mpn;
set<foo> st;
void insert(int k) {
int y0, z0, y1 = x[k][1], z1 = x[k][2];
map<int, int>::iterator i = mp.lower_bound(y1);
if (i->second >= z1) return;
if (i->first == y1)
i->second = z1;
else
i = mp.insert(make_pair(y1, z1)).first;
while (i != mp.begin()) {
map<int, int>::iterator j = i;
--j;
y0 = j->first;
z0 = j->second;
st.erase(foo(y0, mpn[y0]));
if (z1 < z0) break;
mp.erase(j);
}
if (i != mp.begin()) {
st.insert(foo(y0, mpn[y0] = z1));
}
if (++i != mp.end()) {
st.insert(foo(y1, mpn[y1] = i->second));
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < 3; ++i) {
for (int j = 1; j <= n; ++j) {
scanf("%d", &a[i][j]);
idx[a[i][j]] = 0;
}
}
map<int, int>::iterator it = idx.begin();
for (int i = 0; it != idx.end(); ++it, ++i) {
it->second = i;
}
for (int i = n; i; --i) {
for (int j = 0; j < 3; ++j) {
a[j][i] = idx[a[j][i]];
x[a[j][i]][j] = i;
}
}
mp[0] = n + 1;
mp[n + 1] = 0;
mpn[0] = 0;
st.insert(foo(0, 0));
for (size_t i = 0; i < idx.size(); ++i) {
for (int j = 0; j < 3; ++j) {
if (!x[i][j]) x[i][j] = n + 1;
}
if (x[i][0] == n + 1) insert(i);
}
int ans = n + st.begin()->s;
for (int i = n; i; --i) {
int k = a[0][i];
if (i == x[k][0]) {
if (x[k][1] == n + 1 && x[k][2] == n + 1) {
break;
}
insert(k);
}
ans = min(ans, i - 1 + st.begin()->s);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
const int INF = 100000000;
int a[3][N];
vector<int> values;
int n, m;
int first[3][3 * N], visit[3 * N];
set<pair<int, int> > s;
map<int, int> del;
priority_queue<int> q;
void insert(int a, int b) {
pair<int, int> tmp = make_pair(a, b);
set<pair<int, int> >::iterator nxt = s.lower_bound(tmp);
if (nxt->second >= b) return;
q.push(-(nxt->second + a));
s.insert(tmp);
nxt = s.upper_bound(tmp);
pair<int, int> last = *nxt;
while (1) {
set<pair<int, int> >::iterator it = s.find(tmp);
--it;
if (it->second <= b) {
del[it->first + last.second]++;
last = *it;
s.erase(it);
} else {
del[it->first + last.second]++;
q.push(-(it->first + b));
break;
}
}
}
int getMin() {
while (1) {
int x = -q.top();
if (del[x]) {
del[x]--;
q.pop();
continue;
}
return x;
}
}
void show() {
for (set<pair<int, int> >::iterator it = s.begin(); it != s.end(); ++it) {
printf("%d %d\n", it->first, it->second);
}
printf("end----------\n");
}
int main() {
scanf("%d", &n);
for (int i = 0; i < 3; i++)
for (int j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
values.push_back(a[i][j]);
}
sort(values.begin(), values.end());
values.erase(unique(values.begin(), values.end()), values.end());
m = (int)values.size();
for (int i = 0; i < 3; i++) {
for (int j = 0; j < m; j++) {
first[i][j] = INF;
}
for (int j = n; j >= 1; j--) {
a[i][j] =
lower_bound(values.begin(), values.end(), a[i][j]) - values.begin();
first[i][a[i][j]] = j;
}
}
fill(visit, visit + m, 0);
s.insert(make_pair(0, INF + 1));
s.insert(make_pair(INF + 1, 0));
q.push(0);
for (int i = 1; i < 3; i++)
for (int j = 1; j <= n; j++) {
int key = a[i][j];
if (first[0][key] == INF && !visit[key]) {
insert(first[1][key], first[2][key]);
visit[key] = 1;
}
}
int ans = INF;
for (int i = n; i >= 1; i--) {
ans = min(ans, i + getMin());
if (first[0][a[0][i]] == i) {
if (first[1][a[0][i]] == INF && first[2][a[0][i]] == INF) break;
insert(first[1][a[0][i]], first[2][a[0][i]]);
}
if (i == 1) {
ans = min(ans, getMin());
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100001;
const int inf = maxn * 10;
int a[maxn], b[maxn], c[maxn];
int n, listsa[maxn], listsb[maxn], listsc[maxn];
int posa[maxn], posb[maxn], posc[maxn];
int temp;
multiset<int> q;
set<pair<int, int> > tree;
int maxx, maxy;
void add(int x, int y) {
pair<int, int> tem;
maxx = max(maxx, x);
maxy = max(maxy, y);
tem = pair<int, int>(x, y);
set<pair<int, int> >::iterator s1, sit, s2;
if (tree.size() == 0) {
tree.insert(tem);
} else {
sit = tree.upper_bound(tem);
if (sit->first >= tem.first && sit->second >= tem.second) return;
int aa;
tree.insert(tem);
sit = tree.find(tem);
s1 = s2 = sit;
s2++;
if (s1 == tree.begin()) {
aa = s1->first + s2->second;
q.insert(aa);
} else if (s2 == tree.end()) {
s1--;
aa = s1->first + sit->second;
q.insert(aa);
} else {
s1--;
aa = s1->first + s2->second;
q.erase(aa);
aa = s1->first + sit->second;
q.insert(aa);
aa = s2->second + sit->first;
q.insert(aa);
}
sit = tree.find(tem);
while (sit != tree.begin()) {
s1 = sit;
s1--;
if (s1->first <= sit->first && s1->second <= sit->second) {
if (s1 == tree.begin()) {
aa = sit->second + s1->first;
q.erase(aa);
tree.erase(s1);
} else {
s2 = s1;
s2--;
aa = s2->first + s1->second;
q.erase(aa);
aa = s1->first + sit->second;
q.erase(aa);
aa = s2->first + sit->second;
q.insert(aa);
tree.erase(s1);
}
} else
break;
sit = tree.find(tem);
}
}
if (tree.size() == 0)
temp = inf;
else if (q.size() == 0)
temp = min(maxx, maxy);
else
temp = min(*q.begin(), min(maxx, maxy));
}
int main() {
scanf("%d", &n);
temp = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
map<int, int> exist, exista, existb, existc;
int cnt = 0, cnta = 0, cntb = 0, cntc = 0;
for (int i = 1; i <= n; i++) {
if (exist[a[i]] == 0) exist[a[i]] = ++cnt;
if (exist[b[i]] == 0) exist[b[i]] = ++cnt;
if (exist[c[i]] == 0) exist[c[i]] = ++cnt;
}
for (int i = 1; i <= cnt; i++) posa[i] = posb[i] = posc[i] = inf;
for (int i = 1; i <= n; i++) {
if (exista[a[i]] == 0) exista[a[i]] = 1, posa[exist[a[i]]] = i;
if (existb[b[i]] == 0) existb[b[i]] = 1, posb[exist[b[i]]] = i;
if (existc[c[i]] == 0) existc[c[i]] = 1, posc[exist[c[i]]] = i;
}
for (int i = 1; i <= cnt; i++)
if (posa[i] == inf) {
add(posb[i], posc[i]);
}
int ans = inf;
for (int len_a = n; len_a >= 0; len_a--) {
ans = min(ans, len_a + temp);
int ps = exist[a[len_a]];
if (len_a && (posa[ps] == len_a)) {
if (posb[ps] == inf && posc[ps] == inf) break;
add(posb[ps], posc[ps]);
}
}
cout << ans << endl;
fclose(stdin);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, m, ans, a[N], b[N], c[N], id[N], V[N], A[N], B[N], C[N];
multiset<int> res;
set<pair<int, int> > H;
set<int> svdecomposition;
bool cmp(const int i, const int j) { return A[i] > A[j]; }
void ins(pair<int, int> z) {
set<pair<int, int> >::iterator l, i, r = H.lower_bound(z);
if (r->second >= z.second) return;
i = H.insert(z).first, l = i, --l, res.erase(res.find(l->first + r->second)),
res.insert(i->first + r->second);
while (l->second < i->second)
r = l--, res.erase(res.find(l->first + r->second)), H.erase(r);
res.insert(l->first + i->second);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", a + i), V[m++] = a[i];
for (int i = 0; i < n; ++i) scanf("%d", b + i), V[m++] = b[i];
for (int i = 0; i < n; ++i) scanf("%d", c + i), V[m++] = c[i];
int once;
sort(V, V + m), m = unique(V, V + m) - V;
for (int i = 0; i < n; ++i) a[i] = lower_bound(V, V + m, a[i]) - V;
for (int i = 0; i < n; ++i) b[i] = lower_bound(V, V + m, b[i]) - V;
for (int i = 0; i < n; ++i) c[i] = lower_bound(V, V + m, c[i]) - V;
for (int i = 0; i < m; ++i) A[i] = B[i] = C[i] = 3 * n;
for (int i = 0; i < n; ++i)
if (A[a[i]] > n) A[a[i]] = i + 1;
for (int i = 0; i < n; ++i)
if (B[b[i]] > n) B[b[i]] = i + 1;
for (int i = 0; i < n; ++i)
if (C[c[i]] > n) C[c[i]] = i + 1;
int twicr;
for (int i = 0; i < m + 1; ++i) id[i] = i;
A[m] = 0, sort(id, id + m, cmp);
H.insert(make_pair(0, 4 * n)), H.insert(make_pair(4 * n, 0)), res.insert(0),
ans = A[*id];
for (int i = 0; i < m; ++i)
ins(make_pair(B[id[i]], C[id[i]])),
ans = min(ans, A[id[i + 1]] + *res.begin());
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool setmin(T &a, T b) {
if (b < a) {
a = b;
return true;
} else
return false;
}
template <class T>
bool setmax(T &a, T b) {
if (b > a) {
a = b;
return true;
} else
return false;
}
const int MAXN = 300010;
struct Tri {
int i, j, k;
bool operator<(const Tri &t) const { return k < t.k; }
} d[MAXN];
int n, endpos;
void init() {
static int a[MAXN], b[MAXN], c[MAXN];
cin >> n;
for (int i = (int)(1); i <= (int)(n); ++i) cin >> a[i];
for (int i = (int)(1); i <= (int)(n); ++i) cin >> b[i];
for (int i = (int)(1); i <= (int)(n); ++i) cin >> c[i];
map<int, int> pa, pb, pc;
set<int> numbers;
for (int i = (int)(n); i >= (int)(1); --i) numbers.insert(a[i]), pa[a[i]] = i;
for (int i = (int)(n); i >= (int)(1); --i) numbers.insert(b[i]), pb[b[i]] = i;
for (int i = (int)(n); i >= (int)(1); --i) numbers.insert(c[i]), pc[c[i]] = i;
n = 0;
int tt = endpos = MAXN * 3;
for (set<int>::iterator it = numbers.begin(); it != numbers.end(); ++it) {
int x = *it;
++n;
if (pa.find(x) == pa.end())
d[n].i = ++tt;
else
d[n].i = pa[x];
if (pb.find(x) == pb.end())
d[n].j = ++tt;
else
d[n].j = pb[x];
if (pc.find(x) == pc.end())
d[n].k = ++tt;
else
d[n].k = pc[x];
}
}
struct Pair {
int i, j;
Pair(int i, int j) : i(i), j(j) {}
bool operator<(const Pair &t) const { return i < t.i; }
};
set<Pair> seq;
multiset<int> ans;
void del(Pair p) {
set<Pair>::iterator y = seq.lower_bound(p);
set<Pair>::iterator x = y, z = y;
--x, ++z;
ans.erase(ans.find(x->i + y->j));
ans.erase(ans.find(y->i + z->j));
ans.insert(x->i + z->j);
seq.erase(y);
}
void add(Pair p) {
seq.insert(p);
set<Pair>::iterator y = seq.lower_bound(p);
set<Pair>::iterator x = y, z = y;
--x, ++z;
if (z->j > y->j) {
seq.erase(p);
return;
}
ans.insert(x->i + y->j);
ans.insert(y->i + z->j);
ans.erase(ans.find(x->i + z->j));
while (1) {
x = seq.lower_bound(p);
--x;
if (x->j < p.j) {
del(*x);
} else
break;
}
}
void solve() {
sort(d + 1, d + n + 1);
int ret = 1 << 30;
seq.clear();
seq.insert(Pair(0, 1 << 28));
seq.insert(Pair(1 << 28, 0));
ans.insert(0);
int cur = n;
while (cur >= 1 && d[cur].k >= endpos) {
add(Pair(d[cur].i, d[cur].j));
--cur;
}
while (cur >= 1) {
ret = min(ret, *ans.begin() + d[cur].k);
add(Pair(d[cur].i, d[cur].j));
--cur;
}
ret = min(ret, *ans.begin());
cout << ret << endl;
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct triple {
int a, b, c;
triple(int a = 0, int b = 0, int c = 0) : a(a), b(b), c(c) {}
};
map<int, triple> M;
int n, res;
int a[110000], b[110000], c[110000];
set<pair<int, int> > cur;
priority_queue<pair<int, int> > Q;
void Insert(int a, int b) {
set<pair<int, int> >::iterator it = cur.lower_bound(pair<int, int>(a, b));
if (it != cur.end() && b <= it->second) return;
if (it != cur.end()) Q.push(pair<int, int>(-(a + it->second), a));
it = cur.insert(pair<int, int>(a, b)).first;
while (it != cur.begin()) {
it--;
if (it->second <= b)
cur.erase(it++);
else {
it++;
break;
}
}
if (it != cur.begin()) {
it--;
Q.push(pair<int, int>(-(it->first + b), it->first));
}
}
bool Check(pair<int, int> p) {
int cand = -p.first, i = p.second;
set<pair<int, int> >::iterator it = cur.lower_bound(pair<int, int>(i, 0));
if (it == cur.end() || it->first != i) return false;
it++;
if (it == cur.end() || it->second != cand - i) return false;
return true;
}
int getBest() {
while (!Q.empty()) {
pair<int, int> v = Q.top();
if (Check(v)) return -v.first;
Q.pop();
}
return 1000000000;
}
int main() {
map<int, triple>::iterator it;
int i;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
it = M.find(a[i]);
if (it == M.end()) M[a[i]] = triple(i + 1, 1000000000, 1000000000);
}
for (i = 0; i < n; i++) {
scanf("%d", &b[i]);
it = M.find(b[i]);
if (it == M.end())
M[b[i]] = triple(1000000000, i + 1, 1000000000);
else
it->second.b = min(it->second.b, i + 1);
}
for (i = 0; i < n; i++) {
scanf("%d", &c[i]);
it = M.find(c[i]);
if (it == M.end())
M[c[i]] = triple(1000000000, 1000000000, i + 1);
else
it->second.c = min(it->second.c, i + 1);
}
Insert(0, 1000000000);
Insert(1000000000, 0);
for (it = M.begin(); it != M.end(); it++) {
if (it->second.a == 1000000000) Insert(it->second.b, it->second.c);
}
res = 1000000000;
for (int i = n; i >= 0; i--) {
res = min(res, i + getBest());
if (i) {
it = M.find(a[i - 1]);
if (it->second.a == i) Insert(it->second.b, it->second.c);
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, m, n, p, k, ans, a[400005], b[400005], c[400005], P[400005],
A[400005], B[400005], C[400005], id[400005];
set<pair<int, int> > st;
multiset<int> Ans;
inline bool cmp(int a, int b) { return A[a] > A[b]; }
void ins(pair<int, int> now) {
set<pair<int, int> >::iterator i, j, k;
k = st.upper_bound(now);
if (k->second >= now.second) return;
i = st.insert(now).first;
j = i;
--j;
Ans.erase(Ans.lower_bound(j->first + k->second)),
Ans.insert(i->first + k->second);
while (j->second < i->second)
k = j--, Ans.erase(Ans.lower_bound(j->first + k->second)), st.erase(k);
Ans.insert(j->first + i->second);
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", &a[i]), P[++P[0]] = a[i];
for (i = 1; i <= n; ++i) scanf("%d", &b[i]), P[++P[0]] = b[i];
for (i = 1; i <= n; ++i) scanf("%d", &c[i]), P[++P[0]] = c[i];
sort(P + 1, P + P[0] + 1);
P[0] = unique(P + 1, P + P[0] + 1) - (P + 1);
for (i = 1; i <= n; ++i) a[i] = lower_bound(P + 1, P + P[0] + 1, a[i]) - P;
for (i = 1; i <= n; ++i) b[i] = lower_bound(P + 1, P + P[0] + 1, b[i]) - P;
for (i = 1; i <= n; ++i) c[i] = lower_bound(P + 1, P + P[0] + 1, c[i]) - P;
for (i = 1; i <= P[0]; ++i) id[i] = i, A[i] = B[i] = C[i] = 5 * n;
for (i = 1; i <= n; ++i)
if (A[a[i]] > n) A[a[i]] = i;
for (i = 1; i <= n; ++i)
if (B[b[i]] > n) B[b[i]] = i;
for (i = 1; i <= n; ++i)
if (C[c[i]] > n) C[c[i]] = i;
st.insert(make_pair(0, 6 * n));
st.insert(make_pair(6 * n, 0));
id[P[0] + 1] = P[0] + 1;
sort(id + 1, id + P[0] + 1, cmp);
Ans.insert(0);
ans = A[id[1]];
for (i = 1; i <= P[0]; ++i) {
ins(make_pair(B[id[i]], C[id[i]]));
ans = min(ans, A[id[i + 1]] + *Ans.begin());
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int INF = 2e8;
map<int, int> mp[4];
tuple<int, int, int> v[MAXN];
set<pair<int, int> > cl;
multiset<int> valores;
int n, respf;
void update(int a, int b) {
auto mit = cl.lower_bound({a, b});
if (mit->first >= a && mit->second >= b) return;
auto bb = (*mit);
auto aa = (*(--mit));
valores.erase(valores.find(aa.first + bb.second));
valores.insert(aa.first + b);
valores.insert(a + bb.second);
cl.insert({a, b});
mit = cl.lower_bound({a, b});
mit--;
while (mit->first <= a && mit->second <= b) {
bb = (*(mit));
aa = (*(--mit));
mit = cl.erase(++mit);
mit--;
valores.erase(valores.find(aa.first + bb.second));
valores.erase(valores.find(bb.first + b));
valores.insert(aa.first + b);
}
}
int query() { return *valores.begin(); }
int main() {
scanf("%d", &n);
respf = 3 * n;
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
int val;
scanf("%d", &val);
if (mp[1][val] == 0) mp[1][val] = INF;
if (mp[2][val] == 0) mp[2][val] = INF;
if (mp[3][val] == 0) mp[3][val] = INF;
mp[i][val] = min(mp[i][val], j);
}
}
n = 0;
for (auto &mit : mp[1]) {
int val = mit.first;
v[++n] = {mp[1][val], mp[2][val], mp[3][val]};
}
sort(v + 1, v + 1 + n);
v[0] = {0, 0, 0};
cl.insert({0, INF * 2});
cl.insert({INF * 2, 0});
valores.insert(0);
respf = min(respf, get<0>(v[n]));
for (int i = n; i >= 1; i--) {
int custo = get<0>(v[i - 1]);
update(get<1>(v[i]), get<2>(v[i]));
custo += query();
respf = min(respf, custo);
}
printf("%d\n", respf);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, tot;
int a[100005], b[100005], c[100005], z[100005 * 3];
struct dian {
int u, v, w;
} d[100005 * 3];
bool cmp(dian a, dian b) { return a.u > b.u; }
int mans[100005 * 4], mn[100005 * 4], flag[100005 * 4], mv[100005 * 4];
void update(int x) {
mans[x] = min(mans[x * 2], mans[x * 2 + 1]);
mv[x] = min(mv[x * 2], mv[x * 2 + 1]);
}
void build(int x, int l, int r) {
mans[x] = mn[x] = l;
if (l == r) return;
int mid = (l + r) / 2;
build(x * 2, l, mid);
build(x * 2 + 1, mid + 1, r);
update(x);
}
void change(int x, int val) {
mv[x] = val;
flag[x] = val;
mans[x] = mn[x] + val;
}
void down(int x) {
if (flag[x]) {
change(x * 2, flag[x]);
change(x * 2 + 1, flag[x]);
flag[x] = 0;
}
}
int find(int x, int l, int r, int val) {
if (l == r) {
if (mv[x] < val)
return l;
else
return 0x3f3f3f3f;
}
int mid = (l + r) / 2;
down(x);
if (mv[x * 2] < val)
return find(x * 2, l, mid, val);
else
return find(x * 2 + 1, mid + 1, r, val);
}
void modify(int x, int l, int r, int tx, int ty, int val) {
if (l >= tx && r <= ty) {
change(x, val);
return;
}
int mid = (l + r) / 2;
down(x);
if (mid >= tx) modify(x * 2, l, mid, tx, ty, val);
if (mid < ty) modify(x * 2 + 1, mid + 1, r, tx, ty, val);
update(x);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
z[++tot] = a[i];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
z[++tot] = b[i];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
z[++tot] = c[i];
}
sort(z + 1, z + tot + 1);
tot = unique(z + 1, z + tot + 1) - z - 1;
for (int i = 1; i <= tot; i++) d[i] = (dian){n + 1, n + 1, 0x3f3f3f3f};
for (int i = 1; i <= n; i++) {
int pos = lower_bound(z + 1, z + tot + 1, a[i]) - z;
d[pos].u = min(d[pos].u, i);
pos = lower_bound(z + 1, z + tot + 1, b[i]) - z;
d[pos].v = min(d[pos].v, i);
pos = lower_bound(z + 1, z + tot + 1, c[i]) - z;
d[pos].w = min(d[pos].w, i);
}
sort(d + 1, d + tot + 1, cmp);
int t = 1;
int ans = 3 * n;
build(1, 0, n);
for (int U = n; U >= 0; U--) {
while (t <= tot && d[t].u > U) {
int pos = find(1, 0, n, d[t].w);
if (pos <= d[t].v - 1) modify(1, 0, n, pos, d[t].v - 1, d[t].w);
t++;
}
ans = min(ans, U + mans[1]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 500000000;
const int N = 300100;
struct dui {
int x, id;
} a[3 * N];
struct nd {
int vl, id;
};
struct com {
bool operator()(nd x, nd y) { return x.vl > y.vl; }
};
int b[N], c[N], d[N], e[N], f[N], q[N], to[N], g[N], t[N], n, top, ans;
set<nd, com> s;
set<nd, com>::iterator it;
multiset<int> se;
multiset<int>::iterator itt;
bool cmp(dui x, dui y) { return x.x < y.x; }
void ycl() {
int i, j, k;
memset(t, 0, sizeof(t));
for (i = 1; i <= n; i++) {
if (!t[b[i]]) e[i] = 1;
t[b[i]]++;
}
memset(t, 0, sizeof(t));
for (i = 1; i <= n; i++) {
if (!t[c[i]]) f[c[i]] = i;
t[c[i]]++;
}
memset(t, 0, sizeof(t));
for (i = 1; i <= n; i++) {
if (!t[d[i]]) g[d[i]] = i;
t[d[i]]++;
}
}
void in(int l, int r, int va, int ad) {
int x, y;
it = s.upper_bound((nd){va, 0});
nd pos = *it;
if (pos.id > r) return;
x = pos.id;
while (1) {
it = s.upper_bound((nd){va, 0});
pos = *it;
if (pos.id > r)
break;
else {
s.erase(pos);
itt = se.find(pos.id + pos.vl);
se.erase(itt);
}
y = pos.vl;
}
it = s.upper_bound((nd){va, 0});
pos = *it;
if (pos.id > r + 1) s.insert((nd){y, r + 1}), se.insert(y + r + 1);
s.insert((nd){va, x});
se.insert(x + va);
}
int main() {
int i, j, k, ans, top, cnt, p, m, l, r, va;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i].x), a[i].id = i;
for (i = 1; i <= n; i++) scanf("%d", &a[n + i].x), a[n + i].id = n + i;
for (i = 1; i <= n; i++)
scanf("%d", &a[n + n + i].x), a[n + n + i].id = n + n + i;
sort(a + 1, a + 3 * n + 1, cmp);
top = 0;
for (i = 1; i <= 3 * n; i++) {
if (a[i].x != a[i - 1].x) top++;
if (a[i].id <= n)
b[a[i].id] = top;
else if (a[i].id <= 2 * n)
c[a[i].id - n] = top;
else
d[a[i].id - n - n] = top;
}
for (i = 1; i <= n; i++) t[b[i]]++;
for (i = 1; i <= n; i++) t[c[i]]++;
cnt = 0;
for (i = 1; i <= top; i++)
if (!t[i]) cnt++;
p = 0;
while (cnt) {
p++;
t[d[p]]++;
if (t[d[p]] == 1) cnt--;
}
to[n] = p;
for (i = n; i; i--) {
t[c[i]]--;
if (!t[c[i]])
while ((p < n) && (d[p] != c[i])) t[d[++p]]++;
if ((p == n) && (d[p] != c[i])) break;
to[i - 1] = p;
}
for (i--; i >= 0; i--) to[i] = inf;
memset(t, 0, sizeof(t));
for (i = 1; i <= n; i++) t[b[i]]++;
for (i = 1; i <= n; i++) t[d[i]]++;
cnt = 0;
for (i = 1; i <= top; i++)
if (!t[i]) cnt++;
p = 0;
while (cnt) {
p++;
t[c[p]]++;
if (t[c[p]] == 1) cnt--;
}
q[n] = cnt;
for (i = n; i; i--) {
t[d[i]]--;
if (!t[d[i]])
while ((p < n) && (c[p] != d[i])) t[c[++p]]++;
if ((p == n) && (c[p] != d[i])) break;
q[i - 1] = p;
}
for (i--; i >= 0; i--) q[i] = inf;
memset(t, 0, sizeof(t));
ycl();
ans = inf;
memset(t, 0, sizeof(t));
for (i = 1; i <= n; i++) t[c[i]]++;
for (i = 1; i <= n; i++) t[d[i]]++;
for (m = n; m >= 0; m--)
if ((!t[b[m]]) && (e[m])) break;
for (i = 0; i <= n; i++)
if ((!i) || (to[i] != to[i - 1])) {
s.insert((nd){to[i], i});
se.insert(to[i] + i);
ans = min(ans, n + to[i] + i);
}
s.insert((nd){-inf, n + 1});
int la;
for (i = n; ((i > m) && (i)); i--) {
if (!f[b[i]])
r = n;
else
r = f[b[i]] - 1;
if (g[b[i]])
l = q[g[b[i]] - 1], va = g[b[i]];
else
l = 0, va = inf;
if (e[i]) in(0, r, va, i - 1);
ans = min(ans, i - 1 + (*(se.begin())));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, b[3][((int)101 * 1000)], ans = ((int)1e9);
map<int, int> a[3];
set<pair<pair<int, int>, int> > s;
multiset<int> res;
void update(int id, int x) {
auto it = s.upper_bound({{id, ((int)101 * 1000)}, 0});
it--;
int l = it->first.first, r = it->first.second, w = it->second;
if (w > x) return;
s.erase(it);
res.erase(res.find(l + w));
if (id != r) s.insert({{id + 1, r}, w}), res.insert(id + 1 + w);
while (1) {
it = s.upper_bound({{id, ((int)101 * 1000)}, 0});
if (it == s.begin()) break;
it--;
if (it->second > x) break;
res.erase(res.find(it->first.first + it->second));
l = it->first.first;
s.erase(it);
}
s.insert({{l, id}, x});
res.insert(l + x);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int p = 0; p < 3; p++)
for (int i = 1; i <= n; i++) {
cin >> b[p][i];
if (!a[p][b[p][i]]) a[p][b[p][i]] = i;
}
s.insert({{0, n}, 0});
res.insert(0);
for (auto u : a[1]) {
int id0 = a[0][u.first], id2 = a[2][u.first];
if (!id0 && !id2)
update(u.second - 1, ((int)1e9));
else if (!id0)
update(u.second - 1, id2);
}
for (auto u : a[2]) {
int id0 = a[0][u.first], id1 = a[1][u.first];
if (!id0 && !id1) update(n, u.second);
}
for (int i = n; i >= 0; i--) {
ans = min(ans, *res.begin() + i);
if (a[0][b[0][i]] != i) continue;
int id1 = a[1][b[0][i]], id2 = a[2][b[0][i]];
if (!id1 && !id2) break;
if (!id1)
update(n, id2);
else if (!id2)
update(id1 - 1, ((int)1e9));
else
update(id1 - 1, id2);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
int a[100005], b[100005], c[100005], ans;
map<int, int> mpb, mpc, mpa, inv;
set<int> sbc;
set<pair<int, int>> ss;
multiset<int> as;
void add(int pb, int pc) {
auto it = ss.lower_bound({pb, -(1e8)});
if ((*it).second >= pc) return;
auto pre = it;
pre--;
as.erase(as.find((*pre).first + (*it).second));
while ((*pre).second <= pc) {
auto data = *pre;
int y = data.second;
pre--;
as.erase(as.find(y + (*pre).first));
ss.erase(data);
}
as.insert((*pre).first + pc);
if ((*it).first == pb) {
ss.erase(it);
} else {
as.insert(pb + (*it).second);
}
ss.insert({pb, pc});
}
int main() {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", a + i);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", b + i);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", c + i);
for (int i = n; i; i--) {
mpb[b[i]] = i;
mpc[c[i]] = i;
mpa[a[i]] = i;
sbc.insert(b[i]);
sbc.insert(c[i]);
}
for (int(i) = 1; (i) <= (int)(n); (i)++) sbc.erase(a[i]);
ss.insert({0, (1e8) * 10});
ss.insert({(1e8) * 10, 0});
as.insert(0);
for (int x : sbc) {
int pb = mpb.find(x) == mpb.end() ? (1e8) : mpb[x];
int pc = mpc.find(x) == mpc.end() ? (1e8) : mpc[x];
add(pb, pc);
}
ans = (1e8);
for (int i = n; i >= 0; i--) {
while (i && mpa[a[i]] != i) i--;
int tmp = i + *as.begin();
ans = min(ans, tmp);
if (i) {
int x = a[i];
int pb = mpb.find(x) == mpb.end() ? (1e8) : mpb[x];
int pc = mpc.find(x) == mpc.end() ? (1e8) : mpc[x];
if (pb == (1e8) && pc == (1e8)) break;
add(pb, pc);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool chmax(T &a, const T &b) {
return (a < b) ? (a = b, 1) : 0;
}
template <class T>
bool chmin(T &a, const T &b) {
return (b < a) ? (a = b, 1) : 0;
}
using ll = long long;
using R = long double;
const R EPS = 1e-9L;
inline int sgn(const R &r) { return (r > EPS) - (r < -EPS); }
inline R sq(R x) { return sqrt(max(x, 0.0L)); }
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int inf = 1 << 20;
int a[300010], b[300010], c[300010];
int fa[300010], fb[300010], fc[300010];
multiset<int> score;
using pii = pair<int, int>;
set<pii> points;
void show() {
cerr << "Point Set: " << endl;
for (auto &it : points) {
cerr << it.first << " " << it.second << endl;
}
cerr << "Score: " << endl;
for (auto &it : score) cerr << it << endl;
}
void add(int y, int x) {
pii e = pii(y, x);
auto it = points.lower_bound(e);
if (e.second <= it->second) return;
while (1) {
auto p = *it;
it--;
if (e.second < p.second) break;
auto q = *it;
auto tmp = score.lower_bound(q.first + p.second);
score.erase(tmp);
if (p.first <= e.first) points.erase(p);
}
{
it = points.lower_bound(e);
auto p = *it;
it--;
auto q = *it;
points.insert(e);
score.insert(e.first + p.second);
score.insert(q.first + e.second);
}
return;
}
int main(void) {
int n;
scanf("%d", &n);
for (int i = int(0); i < int(n); ++i) scanf("%d", a + i);
for (int i = int(0); i < int(n); ++i) scanf("%d", b + i);
for (int i = int(0); i < int(n); ++i) scanf("%d", c + i);
vector<int> value;
for (int i = int(0); i < int(n); ++i) {
value.push_back(a[i]);
value.push_back(b[i]);
value.push_back(c[i]);
}
sort(begin(value), end(value)),
(value).erase(unique(begin(value), end(value)), end(value));
const int m = value.size();
for (int i = int(0); i < int(m); ++i) fa[i] = fb[i] = fc[i] = inf;
for (int i = int(0); i < int(n); ++i) {
a[i] = lower_bound(begin(value), end(value), a[i]) - begin(value);
b[i] = lower_bound(begin(value), end(value), b[i]) - begin(value);
c[i] = lower_bound(begin(value), end(value), c[i]) - begin(value);
if (fa[a[i]] == inf) fa[a[i]] = i;
if (fb[b[i]] == inf) fb[b[i]] = i;
if (fc[c[i]] == inf) fc[c[i]] = i;
}
score.insert(0);
points.insert({0, 2 * inf});
points.insert({2 * inf, 0});
for (int i = int(0); i < int(m); ++i) {
if (fa[i] == inf) {
add(fb[i] + 1, fc[i] + 1);
}
}
int ret = n + *begin(score);
for (int i = int(n) - 1; i >= int(0); --i) {
if (fa[a[i]] == i) add(fb[a[i]] + 1, fc[a[i]] + 1);
chmin(ret, i + *begin(score));
}
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
set<pair<int, int> > pos;
multiset<int> sum;
int a[3][100100], p[3][3 * 100100], arr[3 * 100100], id[3 * 100100];
bool cmp(int i, int j) { return p[0][i] > p[0][j]; }
void insert(pair<int, int> p) {
set<pair<int, int> >::iterator l, m, r;
r = pos.lower_bound(p);
if (r->second >= p.second) return;
l = m = pos.insert(p).first;
l--;
sum.erase(sum.find(l->first + r->second));
sum.insert(m->first + r->second);
while (l->second < m->second) {
r = l;
l--;
sum.erase(sum.find(l->first + r->second));
pos.erase(r);
}
sum.insert(l->first + m->second);
}
int main() {
int n, m = 0;
cin >> n;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", a[i] + j);
arr[m++] = a[i][j];
}
}
sort(arr, arr + m);
m = unique(arr, arr + m) - arr;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++)
a[i][j] = lower_bound(arr, arr + m, a[i][j]) - arr;
}
memset(p, 0x3f, sizeof(p));
for (int i = 0; i < 3; i++) {
for (int j = n; j--;) p[i][a[i][j]] = j + 1;
}
for (int i = 0; i <= m; i++) id[i] = i;
p[0][m] = 0;
sort(id, id + m, cmp);
pos.insert(pair<int, int>(0x3f3f3f3f + 1, 0));
pos.insert(pair<int, int>(0, 0x3f3f3f3f + 1));
sum.insert(0);
int ans = p[0][id[0]];
for (int i = 0; i < m; i++) {
insert(pair<int, int>(p[1][id[i]], p[2][id[i]]));
smin(ans, p[0][id[i + 1]] + *sum.begin());
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int res = 0;
int neg;
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9' || ch == '-') {
if (ch == '-')
neg = -1;
else
neg = 1, res = ch - '0';
break;
}
}
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9')
res *= 10, res += ch - '0';
else
break;
}
return res * neg;
}
const int maxn = 1000020;
const int maxm = 1020;
const int MOd = 1e9 + 7;
int a, n, ar[3][maxn], lazy[maxn * 3], segment[maxn * 3], segment2[maxn];
map<int, int> mp[4];
vector<pair<int, int> > v[maxn];
void ind(int k, int b) {
if (lazy[k]) {
if (k < n) {
lazy[k + k] = lazy[k];
lazy[k + k + 1] = lazy[k];
}
segment[k] = lazy[k] + b;
lazy[k] = 0;
}
}
int update(int k, int b, int s, int x, int y, int m) {
ind(k, b);
if (b > y || x > s) return segment[k];
if (x <= b && s <= y) {
lazy[k] = m;
segment2[k] = m;
ind(k, b);
return segment[k];
}
segment[k] =
min(update(k + k, b, (((b + s) < 0) ? (b + s) / 2 - 1 : (b + s) / 2), x,
y, m),
update(k + k + 1, (((b + s) < 0) ? (b + s) / 2 - 1 : (b + s) / 2) + 1,
s, x, y, m));
return segment[k];
}
int look(int k) {
int t = 0;
k += n;
for (; k; k >>= 1) t = max(t, (segment2[k]));
return t;
}
int main() {
scanf("%d", &a);
n = 1;
while (n < a + 2) n <<= 1;
for (int i = 0; i <= a; i++) segment[i + n] = i;
for (int i = a + 1; i < n; i++) segment[i + n] = 1e9;
for (int i = n - 1; i >= 1; i--)
segment[i] = min(segment[i + i], segment[i + i + 1]);
for (int i = 1; i <= a; i++) scanf("%d", &ar[0][i]);
for (int i = 1; i <= a; i++) scanf("%d", &ar[1][i]);
for (int i = 1; i <= a; i++) scanf("%d", &ar[2][i]);
for (int i = a; i >= 1; i--) mp[0][ar[0][i]] = i, mp[3][ar[0][i]] = 1;
for (int i = a; i >= 1; i--) mp[1][ar[1][i]] = i, mp[3][ar[1][i]] = 1;
for (int i = a; i >= 1; i--) mp[2][ar[2][i]] = i, mp[3][ar[2][i]] = 1;
for (map<int, int>::iterator it = mp[3].begin(); it != mp[3].end(); it++) {
int p = a + 1;
if (mp[0].count(it->first)) p = mp[0][it->first];
if (!mp[1].count(it->first)) mp[1][it->first] = a + 1;
if (!mp[2].count(it->first)) mp[2][it->first] = 1e9;
v[p].push_back(pair<int, int>(mp[1][it->first], mp[2][it->first]));
}
int ans = 1e9;
for (int i = a; i >= 0; i--) {
for (int j = 0; j < v[i + 1].size(); j++) {
int t = v[i + 1][j].first, h = look(v[i + 1][j].first);
if (h >= v[i + 1][j].second) continue;
for (int k = 17; k >= 0; k--)
if ((1 << k) <= t && look(t - (1 << k)) < v[i + 1][j].second)
t -= 1 << k;
update(1, 0, n - 1, t, v[i + 1][j].first - 1, v[i + 1][j].second);
}
ans = min(ans, (segment[1] + i));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 3e5 + 7;
const int inf = 1e9 + 7;
int a[3][N];
int ind[N][3];
multiset<pair<int, int> > q;
multiset<int> val;
void add(int i) {
pair<int, int> x = {ind[i][1] - 1, ind[i][2]};
auto it = q.lower_bound(x);
if (it != q.end() && it->second >= x.second) {
return;
}
while (!q.empty()) {
auto it = q.upper_bound(x);
if (it == q.begin()) break;
it--;
if (it->second <= x.second) {
int my_first = 0;
if (it != q.begin()) {
my_first = prev(it)->first + 1;
}
if (next(it) != q.end()) {
int _x = next(it)->first, _y = next(it)->second;
val.erase(val.find(it->first + 1 + _y));
val.insert(my_first + _y);
}
val.erase(val.find(my_first + it->second));
q.erase(it);
} else {
break;
}
}
int my_first = 0;
q.insert(x);
it = q.find(x);
if (it != q.begin()) {
my_first = prev(it)->first + 1;
}
if (next(it) != q.end()) {
int _x = next(it)->first, _y = next(it)->second;
val.erase(val.find(my_first + _y));
val.insert(x.first + 1 + _y);
}
val.insert(my_first + x.second);
}
int get() {
if (q.empty()) {
return 0;
} else {
int ret = q.rbegin()->first + 1;
ret = min(ret, *val.begin());
return ret;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> p;
for (int t = 0; t < 3; t++) {
for (int i = 0; i < n; i++) {
cin >> a[t][i];
p.push_back(a[t][i]);
}
}
sort(p.begin(), p.end());
p.resize(unique(p.begin(), p.end()) - p.begin());
int m = (int)p.size();
int sz = 0;
for (int i = 0; i < m; i++) {
for (int t = 0; t < 3; t++) {
ind[i][t] = inf + sz;
sz++;
}
}
for (int t = 0; t < 3; t++) {
for (int i = 0; i < n; i++) {
a[t][i] = lower_bound(p.begin(), p.end(), a[t][i]) - p.begin();
ind[a[t][i]][t] = min(ind[a[t][i]][t], i + 1);
}
}
for (int i = 0; i < m; i++) {
if (ind[i][0] >= inf) {
add(i);
}
}
int ans = n + get();
for (int i = n - 1; i >= 0; i--) {
int val = a[0][i];
if (ind[val][0] == i + 1) {
add(val);
}
ans = min(ans, i + get());
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct node {
int mn, mx, ans;
node(int a = 0, int b = 0, int c = 0) { mn = a, mx = b, ans = c; }
} seg[N << 2];
int A[N], B[N], C[N], dp[N], cnt[N];
int n, m, a[N], b[N], c[N], d[N << 2], lazy[N << 2];
inline node merge(node a, node b) {
return node(min(a.mn, b.mn), max(a.mx, b.mx), min(a.ans, b.ans));
}
inline void change(int x, int id, int st) {
seg[id] = node(lazy[id] = x, x, x <= n ? x + st : 3 * n);
}
inline void shift(int id, int st, int en) {
if (!~lazy[id]) return;
int mid = st + en >> 1;
change(lazy[id], id << 1, st);
change(lazy[id], id << 1 | 1, mid);
lazy[id] = -1;
}
void build(int id = 1, int st = 0, int en = n + 1) {
lazy[id] = -1;
if (en - st == 1) {
seg[id] = node(dp[st], dp[st], dp[st] + st);
return;
}
int mid = st + en >> 1;
build(id << 1, st, mid);
build(id << 1 | 1, mid, en);
seg[id] = merge(seg[id << 1], seg[id << 1 | 1]);
}
void update(int l, int r, int x, int id = 1, int st = 0, int en = n + 1) {
if (r <= st || en <= l || seg[id].mn >= x) return;
if (l <= st && en <= r && seg[id].mx < x) return change(x, id, st);
shift(id, st, en);
int mid = st + en >> 1;
update(l, r, x, id << 1, st, mid);
update(l, r, x, id << 1 | 1, mid, en);
seg[id] = merge(seg[id << 1], seg[id << 1 | 1]);
}
inline void readInput() {
cin >> n;
for (int i = 1; i <= n; d[m++] = a[i++]) cin >> a[i];
for (int i = 1; i <= n; d[m++] = b[i++]) cin >> b[i];
for (int i = 1; i <= n; d[m++] = c[i++]) cin >> c[i];
}
inline void prepare() {
sort(d, d + m);
m = unique(d, d + m) - d;
fill(A, A + m, n + 1), fill(B, B + m, n + 1), fill(C, C + m, n + 1);
for (int i = n; i; i--) {
A[a[i] = lower_bound(d, d + m, a[i]) - d] = i;
B[b[i] = lower_bound(d, d + m, b[i]) - d] = i;
C[c[i] = lower_bound(d, d + m, c[i]) - d] = i;
}
int cur = 0;
for (int i = 1; i <= n; i++) {
cur += !cnt[a[i]]++;
cur += !cnt[c[i]]++;
}
for (int i = 0, p = n; i <= n; i++) {
cur += !cnt[b[i]]++;
while (p && cnt[c[p]] > 1) cnt[c[p--]]--;
dp[i] = (cur < m ? 3 * n : p);
}
}
inline void solve() {
int ans = n + seg[1].ans;
for (int i = n; i; i--) {
if (A[a[i]] == i) update(0, B[a[i]], C[a[i]]);
ans = min(ans, i + seg[1].ans - 1);
}
cout << ans << endl;
}
inline void program() {
readInput();
prepare();
build();
solve();
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
program();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct rec {
int val, pos, type;
} E[633333];
struct point {
int a, x, y;
} P[633333];
struct rzz {
int x, y;
bool operator<(const rzz &B) const { return x == B.x ? y < B.y : x < B.x; }
};
bool cmp(const rec &i, const rec &j) { return i.val < j.val; }
bool cmp1(const point &i, const point &j) { return i.a > j.a; }
int n, tot, cnt, inf, ans, great[633333];
set<rzz> S;
set<int> Q;
set<rzz>::iterator it;
set<int>::iterator jt;
void Add(rzz A, rzz B, int key) {
int val = A.x + B.y;
if (A.x == n + 1) return;
if (B.y == n + 1) return;
if (key == 1) {
great[val]++;
if (great[val] == 1) Q.insert(val);
} else {
great[val]--;
if (great[val] == 0) Q.erase(val);
}
}
void Modify(set<rzz>::iterator it, int key) {
rzz p = (rzz){0, 0};
rzz nxt, pre;
if (it == S.begin())
pre = p;
else
pre = *--it, ++it;
if (++it == S.end())
nxt = p;
else
nxt = *it;
--it;
Add(pre, nxt, -key);
Add(pre, *it, key);
Add(*it, nxt, key);
if (key == -1) S.erase(it);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
E[++tot] = (rec){x, i, 0};
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
E[++tot] = (rec){x, i, 1};
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
E[++tot] = (rec){x, i, 2};
}
sort(E + 1, E + 1 + tot, cmp);
inf = n + 1;
for (int i = 1, j = 1; i <= tot; i = j) {
P[++cnt] = (point){inf, inf, inf};
for (j = i; E[i].val == E[j].val; j++) {
if (E[j].type == 0) P[cnt].a = min(P[cnt].a, E[j].pos);
if (E[j].type == 1) P[cnt].x = min(P[cnt].x, E[j].pos);
if (E[j].type == 2) P[cnt].y = min(P[cnt].y, E[j].pos);
}
}
ans = 2333333;
sort(P + 1, P + 1 + cnt, cmp1);
if (P[1].a <= n) ans = P[1].a;
rzz tmp;
for (int i = 1; i <= cnt; i++) {
tmp = (rzz){P[i].x, P[i].y};
rzz *now = &tmp;
it = S.upper_bound(*now);
if (it == S.end() || it->y < now->y) {
if (it != S.begin()) {
it--;
while (it->y <= now->y) {
if (it == S.begin()) {
Modify(it, -1);
break;
}
Modify(it--, -1);
}
}
S.insert(*now);
Modify(S.lower_bound(*now), 1);
}
jt = Q.upper_bound(0);
if (P[i + 1].a <= n && jt != Q.end()) ans = min(ans, P[i + 1].a + *jt);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1 << 30;
int n;
struct Node {
int v, id, from;
} seq[1001000];
struct NNode {
int v[4];
void init() { v[1] = v[2] = v[3] = 3 * n; }
} whe[1001000];
struct NNNode {
int x, y;
};
int a[4][100100], tot, cnt;
set<NNNode> F;
multiset<int> sum;
bool operator<(NNNode x, NNNode y) {
return x.x < y.x || (x.x == y.x && x.y < y.y);
}
bool cmp1(Node x, Node y) { return x.v < y.v; }
bool cmp(NNode x, NNode y) { return x.v[1] > y.v[1]; }
void insert(int x) {
set<NNNode>::iterator s1, s2, s3;
NNNode inwho = (NNNode){whe[x].v[2], whe[x].v[3]};
F.insert(inwho);
s1 = F.find(inwho);
s3 = s1;
s3++;
if ((*s3).x >= (*s1).x && (*s3).y >= (*s1).y) {
F.erase(inwho);
return;
}
s2 = s1;
s2--;
s3 = s1;
s3++;
if (sum.find((*s3).y + (*s2).x) != sum.end())
sum.erase(sum.find((*s3).y + (*s2).x));
while (true) {
s1 = F.find(inwho);
s2 = s1;
s2--;
if (!((*s2).x <= (*s1).x && (*s2).y <= (*s1).y)) break;
s3 = s2;
s3--;
if (sum.find((*s2).y + (*s3).x) != sum.end())
sum.erase(sum.find((*s2).y + (*s3).x));
F.erase(s2);
}
s1 = F.find(inwho);
s3 = s1;
s3++;
sum.insert((*s1).x + (*s3).y);
s2 = s1;
s2--;
sum.insert((*s2).x + (*s1).y);
}
void work() {
sort(whe + 1, whe + cnt + 1, cmp);
F.insert((NNNode){3 * n + 2, 0});
F.insert((NNNode){0, 3 * n + 2});
sum.insert(0);
int l = 1, ans = Maxn;
for (int u = n; u >= 0; u--) {
while (whe[l].v[1] > u) insert(l), l++;
ans = min(ans, u + (*sum.begin()));
}
cout << ans;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
scanf("%d", &a[1][i]), seq[++tot] = (Node){a[1][i], i, 1};
for (int i = 1; i <= n; i++)
scanf("%d", &a[2][i]), seq[++tot] = (Node){a[2][i], i, 2};
for (int i = 1; i <= n; i++)
scanf("%d", &a[3][i]), seq[++tot] = (Node){a[3][i], i, 3};
sort(seq + 1, seq + tot + 1, cmp1);
a[seq[1].from][seq[1].id] = 1;
cnt++;
whe[1].init();
whe[cnt].v[seq[1].from] = min(whe[cnt].v[seq[1].from], seq[1].id);
for (int i = 2; i <= tot; i++) {
if (seq[i].v != seq[i - 1].v) cnt++, whe[cnt].init();
a[seq[i].from][seq[i].id] = cnt;
whe[cnt].v[seq[i].from] = min(whe[cnt].v[seq[i].from], seq[i].id);
}
work();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ans = 300005, a[300005], b[300005], c[300005], posa[300005],
posb[300005], posc[300005];
set<pair<int, int> > s;
multiset<int> ss;
map<int, int> mp;
inline set<pair<int, int> >::iterator add(set<pair<int, int> >::iterator it) {
return ++it;
}
inline set<pair<int, int> >::iterator sub(set<pair<int, int> >::iterator it) {
return --it;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
n = read() * 3;
for (int x, i = 1; i <= n; ++i) {
if (!mp[x = read()]) mp[x] = mp.size();
a[i] = b[i] = c[i] = mp[x];
}
rotate(b + 1, b + n / 3 + 1, b + n + 1);
rotate(c + 1, c + n * 2 / 3 + 1, c + n + 1);
for (int i = 1; i <= n; ++i) {
if (!posa[a[i]]) posa[a[i]] = i;
if (!posb[b[i]]) posb[b[i]] = i;
if (!posc[c[i]]) posc[c[i]] = i;
}
s.insert(make_pair(0, n + 1));
s.insert(make_pair(n + 1, 0));
ss.insert(0);
for (int i = n; i >= 1; --i) {
if (i <= n) ans = min(ans, i + *ss.begin());
if (i != posa[a[i]]) continue;
pair<int, int> t = make_pair(posb[a[i]], posc[a[i]]);
if (s.lower_bound(t)->second > t.second) continue;
auto it = s.insert(t).first;
ss.erase(ss.find(sub(it)->first + add(it)->second));
for (auto j = sub(it); j->second < it->second; j = sub(s.erase(j)))
ss.erase(ss.find(sub(j)->first + j->second));
ss.insert(sub(it)->first + t.second);
ss.insert(t.first + add(it)->second);
}
ans = min(ans, *ss.begin());
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[100010], b[100010], c[100010], m, d[100010 * 3];
int aa[100010 * 3], bb[100010 * 3], cc[100010 * 3], cnt[100010 * 3];
set<pair<int, int> > bst;
set<pair<int, int> >::iterator it, l, r;
multiset<int> heap;
void ins(pair<int, int> x) {
r = bst.lower_bound(x);
if (x.second <= r->second) return;
bst.insert(x), it = bst.find(x), l = it, --l;
heap.erase(heap.lower_bound(l->first + r->second)),
heap.insert(it->first + r->second);
while (l->second <= it->second)
r = l--, heap.erase(heap.lower_bound(l->first + r->second)), bst.erase(r);
heap.insert(l->first + it->second);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), d[++m] = a[i];
for (int i = 1; i <= n; ++i) scanf("%d", &b[i]), d[++m] = b[i];
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]), d[++m] = c[i];
sort(d + 1, d + m + 1);
m = unique(d + 1, d + m + 1) - d - 1;
for (int i = 1; i <= n; ++i) a[i] = lower_bound(d + 1, d + m + 1, a[i]) - d;
for (int i = 1; i <= n; ++i) b[i] = lower_bound(d + 1, d + m + 1, b[i]) - d;
for (int i = 1; i <= n; ++i) c[i] = lower_bound(d + 1, d + m + 1, c[i]) - d;
for (int i = 1; i <= m; ++i) aa[i] = bb[i] = cc[i] = n * 3;
for (int i = 1; i <= n; ++i) aa[a[i]] = min(aa[a[i]], i);
for (int i = 1; i <= n; ++i) bb[b[i]] = min(bb[b[i]], i);
for (int i = 1; i <= n; ++i) cc[c[i]] = min(cc[c[i]], i);
bst.insert(make_pair(0, n * 4));
bst.insert(make_pair(n * 4, 0));
heap.insert(0);
for (int i = 1; i <= n; ++i) ++cnt[a[i]];
for (int i = 1; i <= m; ++i)
if (!cnt[i]) ins(make_pair(bb[i], cc[i]));
int ans = n + *heap.begin();
for (int i = n; i; --i) {
if (!--cnt[a[i]]) ins(make_pair(bb[a[i]], cc[a[i]]));
ans = min(ans, i - 1 + *heap.begin());
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int INF = 1000000005;
int a[N], b[N], c[N];
set<int> tot;
set<pair<int, int> > dt;
map<int, int> A, B, C, rt;
void insert(int v, int w) {
if (!v) v = INF;
if (!w) w = INF;
set<pair<int, int> >::iterator it, it1;
it = dt.lower_bound(make_pair(v, 0));
it--;
if (it->second >= w) return;
dt.insert(make_pair(v, it->second));
rt[v + it->second]++;
int pre, fg = 1;
while (fg) {
if (it->second >= w) break;
pre = it->first;
if (it == dt.begin()) fg = 0;
pre = it->first;
int s = it->first + it->second;
it1 = it;
if (fg) it--;
dt.erase(*it1);
rt[s]--;
if (!rt[s]) rt.erase(s);
}
dt.insert(make_pair(pre, w));
rt[pre + w]++;
}
int main() {
int n, i;
set<int>::iterator it;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
tot.insert(a[i]);
}
for (i = 1; i <= n; i++) {
scanf("%d", &b[i]);
tot.insert(b[i]);
}
for (i = 1; i <= n; i++) {
scanf("%d", &c[i]);
tot.insert(c[i]);
}
for (i = n; i > 0; i--) A[a[i]] = i, B[b[i]] = i, C[c[i]] = i;
int ret = INF;
dt.insert(make_pair(0, 0));
rt[0] = 1;
for (it = tot.begin(); it != tot.end(); it++)
if (!A[*it]) {
insert(B[*it], C[*it]);
}
for (i = n; i > 0; i--)
if (A[a[i]] == i) {
int tmp = i + rt.begin()->first;
if (ret > tmp) ret = tmp;
insert(B[a[i]], C[a[i]]);
}
int tmp = rt.begin()->first;
if (ret > tmp) ret = tmp;
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const long long LINF = INF * (long long)INF;
const int MAX = 100100;
int A[3][MAX];
map<int, int> B[3];
set<pair<int, int> > S;
multiset<int> VS;
int VAL;
void print() {
for (__typeof(S.begin()) it = S.begin(); it != S.end(); it++) {
cout << "(" << it->first << ", " << it->second << ") ";
}
cout << endl;
}
void rem(int val) {
VS.erase(VS.find(val));
if (VS.empty())
VAL = INF;
else
VAL = *VS.begin();
}
void ad(int val) {
VS.insert(val);
VAL = *VS.begin();
}
void remove(set<pair<int, int> >::iterator);
int getVal(set<pair<int, int> >::iterator it) {
int y = it->second;
it--;
int x = it->first;
if (y == -1) y++;
if (x == -1) x++;
int val = x + y;
return val;
}
void add(pair<int, int> a) {
int x = a.first;
int y = a.second;
while (true) {
set<pair<int, int> >::iterator it = S.upper_bound(a);
if (it->second >= y) return;
it--;
if (it->second <= y) {
remove(it);
continue;
}
break;
}
set<pair<int, int> >::iterator it = S.upper_bound(a);
int val = getVal(it);
rem(val);
S.insert(a);
it = S.upper_bound(a);
val = getVal(it);
ad(val);
it--;
val = getVal(it);
ad(val);
}
void remove(set<pair<int, int> >::iterator it) {
pair<int, int> a = *it;
int val = getVal(it);
rem(val);
it++;
val = getVal(it);
rem(val);
it--;
S.erase(it);
it = S.upper_bound(a);
val = getVal(it);
ad(val);
}
pair<int, int> getXY(int v) {
int x = INF, y = INF;
if (B[1].count(v)) x = B[1][v];
if (B[2].count(v)) y = B[2][v];
x++;
y++;
return make_pair(x, y);
}
int main() {
S.insert(make_pair(-1, INF * 2));
S.insert(make_pair(INF * 2, -1));
VS.insert(0);
VAL = 0;
int n;
scanf("%d", &n);
for (int it = (0); it < (3); it++) {
for (int i = (0); i < (n); i++) {
scanf("%d", &A[it][i]);
}
}
vector<int> all;
for (int it = (0); it < (3); it++) {
for (int i = (n)-1; i >= (0); i--) {
B[it][A[it][i]] = i;
all.push_back(A[it][i]);
}
}
sort(all.begin(), all.end());
all.erase(unique(all.begin(), all.end()), all.end());
for (int i = (0); i < ((int)all.size()); i++) {
int v = all[i];
if (B[0].count(v)) continue;
pair<int, int> xy = getXY(v);
add(xy);
}
int res = n + VAL;
for (int i = (n)-1; i >= (0); i--) {
int v = A[0][i];
if (B[0][v] != i) {
res = min(res, VAL + i);
continue;
}
pair<int, int> xy = getXY(v);
if (xy == make_pair(0, 0)) break;
add(xy);
int cur = i + VAL;
res = min(res, cur);
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
multiset<int> R;
set<pair<int, int> > S;
int n, a[300005], b[300005], c[300005], A[300005], B[300005], C[300005],
w[300005], id[300005], m, ans;
bool cmp(int x, int y) { return A[x] > A[y]; }
void insert(pair<int, int> now) {
set<pair<int, int> >::iterator i, j, k;
k = S.lower_bound(now);
if (k->second >= now.second) return;
S.insert(now), i = S.find(now), j = i, j--;
R.erase(R.find(j->first + k->second));
R.insert(now.first + k->second);
R.insert(j->first + now.second);
while (j->second <= now.second) {
i = j, j--;
R.erase(R.find(j->first + i->second));
R.erase(R.find(i->first + now.second));
S.erase(i);
R.insert(j->first + now.second);
}
}
int main() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]), w[++m] = a[i];
for (i = 1; i <= n; i++) scanf("%d", &b[i]), w[++m] = b[i];
for (i = 1; i <= n; i++) scanf("%d", &c[i]), w[++m] = c[i];
sort(w + 1, w + m + 1);
m = unique(w + 1, w + m + 1) - w - 1;
for (i = 1; i <= n; i++) a[i] = lower_bound(w + 1, w + m + 1, a[i]) - w;
for (i = 1; i <= n; i++) b[i] = lower_bound(w + 1, w + m + 1, b[i]) - w;
for (i = 1; i <= n; i++) c[i] = lower_bound(w + 1, w + m + 1, c[i]) - w;
for (i = 1; i <= m; i++) A[i] = B[i] = C[i] = 3 * n + 1, id[i] = i;
for (i = n; i >= 1; i--) A[a[i]] = i, B[b[i]] = i, C[c[i]] = i;
sort(id + 1, id + m + 1, cmp);
S.insert(pair<int, int>(0, 3 * n + 2));
S.insert(pair<int, int>(3 * n + 2, 0));
R.insert(0), ans = A[id[1]];
for (i = 1; i <= m; i++) {
insert(pair<int, int>(B[id[i]], C[id[i]]));
ans = min(ans, A[id[i + 1]] + (*R.begin()));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
template <class U>
inline void smin(U& a, U b) {
if (a > b) a = b;
}
const int NN = 3e5 + 10;
int n, m, ans;
int a[NN], b[NN], c[NN];
int A[NN], B[NN], C[NN];
int I[NN], T[NN];
multiset<int> uni;
set<pii> H;
void add(pii p) {
set<pii>::iterator l, i, r = H.lower_bound(p);
if (r->second >= p.second) return;
i = H.insert(p).first;
l = i;
l--;
uni.erase(uni.lower_bound(l->first + r->second));
uni.insert(i->first + r->second);
while (l->second < i->second) {
r = l;
l--;
uni.erase(uni.lower_bound(l->first + r->second));
H.erase(r);
}
uni.insert(l->first + i->second);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i), T[m++] = a[i];
for (int i = 0; i < n; i++) scanf("%d", b + i), T[m++] = b[i];
for (int i = 0; i < n; i++) scanf("%d", c + i), T[m++] = c[i];
sort(T, T + m);
m = unique(T, T + m) - T;
for (int i = 0; i < n; i++) a[i] = lower_bound(T, T + m, a[i]) - T;
for (int i = 0; i < n; i++) b[i] = lower_bound(T, T + m, b[i]) - T;
for (int i = 0; i < n; i++) c[i] = lower_bound(T, T + m, c[i]) - T;
for (int i = 0; i < m; i++) A[i] = B[i] = C[i] = 5 * n;
for (int i = 0; i < n; i++)
if (A[a[i]] > n) A[a[i]] = i + 1;
for (int i = 0; i < n; i++)
if (B[b[i]] > n) B[b[i]] = i + 1;
for (int i = 0; i < n; i++)
if (C[c[i]] > n) C[c[i]] = i + 1;
for (int i = 0; i <= m; i++) I[i] = i;
A[m] = 0;
sort(I, I + m, [&](int i, int j) { return A[i] > A[j]; });
H.insert({0, 6 * n});
H.insert({6 * n, 0});
uni.insert(0);
ans = A[I[0]];
for (int i = 0; i < m; i++) {
add({B[I[i]], C[I[i]]});
smin(ans, A[I[i + 1]] + *uni.begin());
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e6;
struct Point {
int x, y, z;
Point(int a, int b, int c) : x(a), y(b), z(c){};
Point() : x(INF), y(INF), z(INF){};
};
bool operator<(Point a, Point b) {
if (a.x != b.x)
return a.x < b.x;
else if (a.y != b.y)
return a.y < b.y;
else
return a.z < b.z;
}
struct Pareto {
set<pair<int, int>> s;
set<pair<int, pair<int, int>>> ans;
Pareto() {}
void getEdges(set<pair<int, int>>::iterator it, pair<int, int>& p1,
pair<int, int>& p2) {
if (it == s.begin()) {
p1.first = 0;
p1.second = it->second;
} else {
p1.first = prev(it)->first;
p1.second = it->second;
}
if (next(it) == s.end()) {
p2.first = it->first;
p2.second = 0;
} else {
p2.first = it->first;
p2.second = next(it)->second;
}
}
int insert(pair<int, int> p) {
s.insert(p);
set<pair<int, int>>::iterator it = s.find(p), itother;
if (next(it) != s.end() && next(it)->second >= it->second) {
s.erase(it);
return ans.begin()->first;
}
pair<int, int> p1, p2;
bool removed = 0;
while (it != s.begin() && it->second >= prev(it)->second) {
itother = prev(it);
s.erase(it);
getEdges(itother, p1, p2);
ans.erase(
make_pair(p1.first + p1.second, pair<int, int>(p1.first, p1.second)));
if (!removed)
ans.erase(make_pair(p2.first + p2.second,
pair<int, int>(p2.first, p2.second)));
s.erase(itother);
s.insert(p);
it = s.find(p);
removed = true;
}
if (!removed) {
if (next(it) != s.end()) {
itother = next(it);
s.erase(it);
getEdges(itother, p1, p2);
ans.erase(make_pair(p1.first + p1.second,
pair<int, int>(p1.first, p1.second)));
s.insert(p);
it = s.find(p);
}
if (it != s.begin()) {
itother = prev(it);
s.erase(it);
getEdges(itother, p1, p2);
ans.erase(make_pair(p2.first + p2.second,
pair<int, int>(p2.first, p2.second)));
s.insert(p);
it = s.find(p);
}
}
getEdges(it, p1, p2);
ans.insert(
make_pair(p1.first + p1.second, pair<int, int>(p1.first, p1.second)));
ans.insert(
make_pair(p2.first + p2.second, pair<int, int>(p2.first, p2.second)));
return ans.begin()->first;
}
} pareto;
map<int, Point> mp;
int main() {
int n;
scanf("%d", &n);
for (int i = 1, a; i <= n; i++) {
scanf("%d", &a);
mp[a].x = min(mp[a].x, i);
}
for (int i = 1, a; i <= n; i++) {
scanf("%d", &a);
mp[a].y = min(mp[a].y, i);
}
for (int i = 1, a; i <= n; i++) {
scanf("%d", &a);
mp[a].z = min(mp[a].z, i);
}
vector<Point> v;
for (auto p : mp) v.push_back(p.second);
sort(v.rbegin(), v.rend());
int ans = v[0].x;
for (int i = 0; i < v.size(); i++) {
ans = min(ans, (i + 1 == v.size() ? 0 : v[i + 1].x) +
pareto.insert(pair<int, int>(v[i].y, v[i].z)));
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, RR, gs, ans = 1e9, Xma, Yma, ma[N], a[N], b[N], c[N], d[N], La[N], Lb[N],
Lc[N], lst[N], tree[N * 4], mi[N * 4], lazy[N * 4];
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline int gc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int ret = 0, f = 0;
char c = gc();
while (!isdigit(c)) {
if (c == '-') f = 1;
c = gc();
}
while (isdigit(c)) {
ret = ret * 10 + c - 48;
c = gc();
}
if (f) return -ret;
return ret;
}
void build(int nod, int l, int r) {
if (l == r) {
tree[nod] = mi[nod] = l;
return;
}
int mid = (l + r) / 2;
build(nod * 2, l, mid);
build(nod * 2 + 1, mid + 1, r);
tree[nod] = min(tree[nod * 2], tree[nod * 2 + 1]);
mi[nod] = min(mi[nod * 2], mi[nod * 2 + 1]);
}
void pushdown(int nod) {
if (!lazy[nod]) return;
mi[nod * 2] = max(mi[nod * 2], tree[nod * 2] + lazy[nod]);
mi[nod * 2 + 1] = max(mi[nod * 2 + 1], tree[nod * 2 + 1] + lazy[nod]);
lazy[nod * 2] = max(lazy[nod * 2], lazy[nod]);
lazy[nod * 2 + 1] = max(lazy[nod * 2 + 1], lazy[nod]);
ma[nod * 2] = max(ma[nod * 2], lazy[nod]);
ma[nod * 2 + 1] = max(ma[nod * 2 + 1], lazy[nod]);
lazy[nod] = 0;
}
void change(int nod, int l, int r, int L, int R, int val) {
if (l == L && r == R) {
ma[nod] = max(ma[nod], val);
mi[nod] = max(mi[nod], tree[nod] + val);
lazy[nod] = max(lazy[nod], val);
return;
}
pushdown(nod);
int mid = (l + r) / 2;
if (R <= mid)
change(nod * 2, l, mid, L, R, val);
else if (L > mid)
change(nod * 2 + 1, mid + 1, r, L, R, val);
else {
change(nod * 2, l, mid, L, mid, val);
change(nod * 2 + 1, mid + 1, r, mid + 1, R, val);
}
mi[nod] = min(mi[nod * 2], mi[nod * 2 + 1]);
ma[nod] = min(ma[nod * 2], ma[nod * 2 + 1]);
}
int find(int nod, int l, int r, int L, int R) {
if (l == L && r == R) return mi[nod];
pushdown(nod);
int mid = (l + r) / 2;
if (R <= mid)
return find(nod * 2, l, mid, L, R);
else if (L > mid)
return find(nod * 2 + 1, mid + 1, r, L, R);
else
return min(find(nod * 2, l, mid, L, mid),
find(nod * 2 + 1, mid + 1, r, mid + 1, R));
}
int query(int nod, int l, int r, int val) {
if (l == r) {
if (ma[nod] >= val)
return l + 1;
else
return l;
}
pushdown(nod);
int mid = (l + r) / 2;
if (ma[nod * 2] >= val)
return query(nod * 2 + 1, mid + 1, r, val);
else
return query(nod * 2, l, mid, val);
}
signed main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
d[++gs] = a[i];
}
for (int i = 1; i <= n; i++) {
b[i] = read();
d[++gs] = b[i];
}
for (int i = 1; i <= n; i++) {
c[i] = read();
d[++gs] = c[i];
}
sort(d + 1, d + gs + 1);
gs = unique(d + 1, d + gs + 1) - d - 1;
for (int i = 1; i <= n; i++) a[i] = lower_bound(d + 1, d + gs + 1, a[i]) - d;
for (int i = 1; i <= n; i++) b[i] = lower_bound(d + 1, d + gs + 1, b[i]) - d;
for (int i = 1; i <= n; i++) c[i] = lower_bound(d + 1, d + gs + 1, c[i]) - d;
for (int i = 1; i <= gs; i++) lst[i] = 0;
for (int i = 1; i <= n; i++) {
if (lst[a[i]]) continue;
lst[a[i]] = 1;
La[a[i]] = i;
}
for (int i = 1; i <= gs; i++) lst[i] = 0;
for (int i = 1; i <= n; i++) {
if (lst[b[i]]) continue;
lst[b[i]] = 1;
Lb[b[i]] = i;
}
for (int i = 1; i <= gs; i++) lst[i] = 0;
for (int i = 1; i <= n; i++) {
if (lst[c[i]]) continue;
lst[c[i]] = 1;
Lc[c[i]] = i;
}
build(1, 0, n);
for (int i = 1; i <= n; i++)
if ((!La[b[i]]) && (Lb[b[i]] == i)) {
if (!Lc[b[i]]) Xma = max(Xma, i);
}
for (int i = 1; i <= n; i++)
if ((!La[c[i]]) && (Lc[c[i]] == i)) {
if (!Lb[c[i]]) Yma = max(Yma, i);
}
for (int i = 1; i <= n; i++)
if ((!La[b[i]]) && (Lb[b[i]] == i)) {
if (Lc[b[i]]) {
int x = query(1, 0, n, Lc[b[i]]);
if (x <= i - 1) change(1, 0, n, x, i - 1, Lc[b[i]]);
}
}
int x = query(1, 0, n, Yma);
if (x <= n) change(1, 0, n, x, n, Yma);
ans = min(ans, n + max(Xma + Yma, find(1, 0, n, Xma, n)));
for (int i = n; i; i--) {
if (La[a[i]] == i) {
if (!Lb[a[i]]) {
if (!Lc[a[i]]) break;
Yma = max(Yma, Lc[a[i]]);
} else if (!Lc[a[i]])
Xma = max(Xma, Lb[a[i]]);
else {
int x = query(1, 0, n, Lc[a[i]]);
if (x <= Lb[a[i]] - 1) change(1, 0, n, x, Lb[a[i]] - 1, Lc[a[i]]);
}
}
int x = query(1, 0, n, Yma);
if (x <= n) change(1, 0, n, x, n, Yma);
ans = min(ans, i - 1 + max(Xma + Yma, find(1, 0, n, Xma, n)));
}
cout << ans;
}
|
#include <bits/stdc++.h>
const int N = 1000010;
using namespace std;
multiset<int> R;
set<pair<int, int> > S;
int a[N], b[N], c[N], id[N], A[N], B[N], C[N], w[N], n, m, ans;
bool cmp(int x, int y) { return A[x] > A[y]; }
int read() {
int x = 0, f = 1, c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
void Insert(pair<int, int> now) {
set<pair<int, int> >::iterator i, j, k;
k = S.lower_bound(now);
if (k->second >= now.second) return;
S.insert(now), i = S.find(now), j = i, --j;
R.erase(R.find(j->first + k->second));
R.insert(now.first + k->second);
R.insert(j->first + now.second);
while (j->second <= now.second) {
i = j;
--j;
R.erase(R.find(j->first + i->second));
R.erase(R.find(i->first + now.second));
S.erase(i);
R.insert(j->first + now.second);
}
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read(), w[++m] = a[i];
for (int i = 1; i <= n; i++) b[i] = read(), w[++m] = b[i];
for (int i = 1; i <= n; i++) c[i] = read(), w[++m] = c[i];
sort(w + 1, w + 1 + m);
m = unique(w + 1, w + 1 + m) - w - 1;
for (int i = 1; i <= n; i++) a[i] = lower_bound(w + 1, w + 1 + m, a[i]) - w;
for (int i = 1; i <= n; i++) b[i] = lower_bound(w + 1, w + 1 + m, b[i]) - w;
for (int i = 1; i <= n; i++) c[i] = lower_bound(w + 1, w + 1 + m, c[i]) - w;
for (int i = 1; i <= m; i++) A[i] = B[i] = C[i] = 3 * n + 1, id[i] = i;
for (int i = n; i; i--) A[a[i]] = i, B[b[i]] = i, C[c[i]] = i;
sort(id + 1, id + 1 + m, cmp);
S.insert(pair<int, int>(0, 3 * n + 2));
S.insert(pair<int, int>(3 * n + 2, 0));
R.insert(0), ans = A[id[1]];
for (int i = 1; i <= m; i++) {
Insert(pair<int, int>(B[id[i]], C[id[i]]));
ans = min(ans, A[id[i + 1]] + (*R.begin()));
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[4][100100], tot, cnt;
const int Maxn = 1 << 30;
struct Node {
int v, id, from;
} seq[1001000];
struct NNode {
int v[4];
void init() { v[1] = v[2] = v[3] = 3 * n; }
} whe[1001000];
struct NNNode {
int x, y;
};
set<NNNode> F;
multiset<int> sum;
bool operator<(NNNode x, NNNode y) {
return x.x < y.x || (x.x == y.x && x.y < y.y);
}
bool cmp1(Node x, Node y) { return x.v < y.v; }
bool cmp(NNode x, NNode y) { return x.v[1] > y.v[1]; }
void insert(int x) {
set<NNNode>::iterator s1, s2, s3;
NNNode inwho = (NNNode){whe[x].v[2], whe[x].v[3]};
F.insert(inwho);
s1 = F.find(inwho);
s3 = s1;
s3++;
if ((*s3).x >= (*s1).x && (*s3).y >= (*s1).y) {
F.erase(inwho);
return;
}
s2 = s1;
s2--;
s3 = s1;
s3++;
if (sum.find((*s3).y + (*s2).x) != sum.end())
sum.erase(sum.find((*s3).y + (*s2).x));
while (true) {
s1 = F.find(inwho);
s2 = s1;
s2--;
if (!((*s2).x <= (*s1).x && (*s2).y <= (*s1).y)) break;
s3 = s2;
s3--;
if (sum.find((*s2).y + (*s3).x) != sum.end())
sum.erase(sum.find((*s2).y + (*s3).x));
F.erase(s2);
}
s1 = F.find(inwho);
s3 = s1;
s3++;
sum.insert((*s1).x + (*s3).y);
s2 = s1;
s2--;
sum.insert((*s2).x + (*s1).y);
}
void work() {
sort(whe + 1, whe + cnt + 1, cmp);
F.insert((NNNode){3 * n + 2, 0});
F.insert((NNNode){0, 3 * n + 2});
sum.insert(0);
int l = 1, ans = Maxn;
for (int u = n; u >= 0; u--) {
while (whe[l].v[1] > u) insert(l), l++;
ans = min(ans, u + (*sum.begin()));
}
cout << ans;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
scanf("%d", &a[1][i]), seq[++tot] = (Node){a[1][i], i, 1};
for (int i = 1; i <= n; i++)
scanf("%d", &a[2][i]), seq[++tot] = (Node){a[2][i], i, 2};
for (int i = 1; i <= n; i++)
scanf("%d", &a[3][i]), seq[++tot] = (Node){a[3][i], i, 3};
sort(seq + 1, seq + tot + 1, cmp1);
a[seq[1].from][seq[1].id] = 1;
cnt++;
whe[1].init();
whe[cnt].v[seq[1].from] = min(whe[cnt].v[seq[1].from], seq[1].id);
for (int i = 2; i <= tot; i++) {
if (seq[i].v != seq[i - 1].v) cnt++, whe[cnt].init();
a[seq[i].from][seq[i].id] = cnt;
whe[cnt].v[seq[i].from] = min(whe[cnt].v[seq[i].from], seq[i].id);
}
work();
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1e5 + 20;
int sz;
int A[max_n], B[max_n], C[max_n], dp[max_n], cnt[max_n];
int n, a[max_n], b[max_n], c[max_n], d[max_n << 2], lazy[max_n << 2];
struct node {
int mn, mx, ans;
node(int a = 0, int b = 0, int c = 0) { mn = a, mx = b, ans = c; }
} seg[max_n << 2];
node Merge(node a, node b) {
return node(min(a.mn, b.mn), max(a.mx, b.mx), min(a.ans, b.ans));
}
void change(int x, int id, int st) {
seg[id] = node(lazy[id] = x, x, x <= n ? x + st : 3 * n);
}
inline void shift(int id, int st, int en) {
if (!(~lazy[id])) return;
int mid = st + en >> 1;
change(lazy[id], id << 1, st);
change(lazy[id], id << 1 | 1, mid);
lazy[id] = -1;
}
void build(int id = 1, int st = 0, int en = n + 1) {
lazy[id] = -1;
if (en - st == 1) {
seg[id] = node(dp[st], dp[st], dp[st] + st);
return;
}
int mid = st + en >> 1;
build(id << 1, st, mid);
build(id << 1 | 1, mid, en);
seg[id] = Merge(seg[id << 1], seg[id << 1 | 1]);
}
void update(int l, int r, int x, int id = 1, int st = 0, int en = n + 1) {
if (r <= st || en <= l || seg[id].mn >= x) return;
if (l <= st && en <= r && seg[id].mx < x) return change(x, id, st);
shift(id, st, en);
int mid = st + en >> 1;
update(l, r, x, id << 1, st, mid);
update(l, r, x, id << 1 | 1, mid, en);
seg[id] = Merge(seg[id << 1], seg[id << 1 | 1]);
}
inline void prePro() {
sort(d, d + sz);
sz = unique(d, d + sz) - d;
fill(A, A + sz, n + 1), fill(B, B + sz, n + 1), fill(C, C + sz, n + 1);
for (int i = n; i; i--) {
a[i] = lower_bound(d, d + sz, a[i]) - d,
b[i] = lower_bound(d, d + sz, b[i]) - d,
c[i] = lower_bound(d, d + sz, c[i]) - d;
A[a[i]] = i;
B[b[i]] = i;
C[c[i]] = i;
}
int cur = 0;
for (int i = 1; i <= n; i++) {
cur += !cnt[a[i]]++;
cur += !cnt[c[i]]++;
}
for (int i = 0, p = n; i <= n; i++) {
cur += !cnt[b[i]]++;
while (p && cnt[c[p]] > 1) cnt[c[p--]]--;
dp[i] = (cur < sz ? 3 * n : p);
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], d[sz] = a[i], sz++;
for (int i = 1; i <= n; i++) cin >> b[i], d[sz] = b[i], sz++;
for (int i = 1; i <= n; i++) cin >> c[i], d[sz] = c[i], sz++;
prePro();
build();
int ans = n + seg[1].ans;
for (int i = n; i; i--) {
if (A[a[i]] == i) update(0, B[a[i]], C[a[i]]);
ans = min(ans, i + seg[1].ans - 1);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, m, n, out;
map<int, int> a, b, c, p;
map<int, int>::iterator it, ip;
pair<int, int> pi;
multiset<int> ans;
multiset<int>::iterator it2;
int x[101000], y[101000], z[101000];
void read(map<int, int> &a, int x[]) {
for (int i = 1; i <= n; i++) {
scanf("%d", x + i);
if (!a.count(x[i]))
a[x[i]] = i;
else
x[i] = 0;
}
}
void delans(int sum) {
it2 = ans.find(sum);
ans.erase(it2);
}
void addp(int x, int y) {
map<int, int>::iterator it;
it = p.lower_bound(x);
pair<int, int> pii, pi = *it;
if ((*it).second > y) return;
ans.insert(x + (*it).second);
for (it--; it != p.begin();) {
pii = pi;
pi = *it;
it--;
if (pi.second < y) {
delans(pi.first + pii.second);
p.erase(pi.first);
} else
break;
}
p[x] = y;
delans(pi.first + pii.second);
ans.insert(pi.first + y);
}
int main() {
scanf("%d", &n);
read(a, x);
read(b, y);
read(c, z);
out = 3 * n;
p.clear();
p[-1] = 5001000;
p[5001000] = 0;
p[0] = 5001000;
ans.insert(0);
for (it = b.begin(); it != b.end(); it++) {
pi = *it;
if (a.count(pi.first)) continue;
if (!c.count(pi.first))
addp(pi.second, 3 * n);
else
addp(pi.second, c[pi.first]);
}
for (it = c.begin(); it != c.end(); it++) {
pi = *it;
if (a.count(pi.first) || b.count(pi.first)) continue;
addp(3 * n, pi.second);
}
int u = n;
while (!x[u]) u--;
out = *(ans.begin()) + u;
for (i = n; i >= 1; i--)
if (x[i]) {
u = i - 1;
while (u > 0 && x[u] == 0) u--;
int pb, pc;
if (b.count(x[i]))
pb = b[x[i]];
else
pb = 3 * n;
if (c.count(x[i]))
pc = c[x[i]];
else
pc = 3 * n;
if (pb == 3 * n && pc == 3 * n) break;
addp(pb, pc);
out = min(out, *(ans.begin()) + u);
}
printf("%d\n", out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, num, ans;
pair<int, pair<int, int> > a[N * 3];
pair<int, pair<int, int> > b[N * 3];
set<pair<int, int> > S1;
multiset<int> S2;
int main() {
scanf("%d", &n);
for (int j = 1; j <= 3; j++)
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[++num] = make_pair(x, make_pair(j, i));
}
sort(a + 1, a + 1 + n * 3);
num = 0;
for (int i = 1; i <= n * 3;) {
int j = i, k1 = n * 3 + 1, k2 = n * 3 + 1, k3 = n * 3 + 1;
while (a[j].first == a[i].first && j <= n * 3) {
int x = a[j].second.first, y = a[j].second.second;
if (x == 1) k1 = min(k1, y);
if (x == 2) k2 = min(k2, y);
if (x == 3) k3 = min(k3, y);
j++;
}
b[++num] = make_pair(k1, make_pair(k2, k3));
i = j;
}
sort(b + 1, b + 1 + num);
ans = n * 3;
S1.insert(make_pair(0, 0));
S2.insert(0);
for (int i = num; i >= 1; i--) {
int now = b[i].first + (*S2.begin());
ans = min(ans, now);
int x = b[i].second.first, y = b[i].second.second;
pair<int, int> k1 = make_pair(-1, -1), k2 = make_pair(-1, -1);
while (1) {
set<pair<int, int> >::iterator it = S1.upper_bound(make_pair(x, y));
if (it == S1.begin()) break;
it--;
if ((*it).second > y) break;
S1.erase(it);
S2.erase(S2.find((*it).first + (*it).second));
if (k2.first == -1) k2 = make_pair(x, (*it).second);
k1 = make_pair((*it).first, y);
}
if (k1.first != -1) S1.insert(k1), S2.insert(k1.first + k1.second);
if (k2.first != -1) S1.insert(k2), S2.insert(k2.first + k2.second);
}
ans = min(ans, (*S2.begin()));
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100007];
int b[100007];
int c[100007];
int br[3 * 100007];
int fa[3 * 100007];
int fb[3 * 100007];
int fc[3 * 100007];
vector<int> srt;
map<int, int> ZX;
int MXVAL;
void compress() {
sort(srt.begin(), srt.end());
int i;
int id = 1;
ZX[srt[0]] = 1;
int sz = srt.size();
for (i = 1; i < sz; i++) {
if (srt[i] == srt[i - 1]) {
continue;
}
id++;
ZX[srt[i]] = id;
}
MXVAL = id;
for (i = 1; i <= n; i++) {
a[i] = ZX[a[i]];
b[i] = ZX[b[i]];
c[i] = ZX[c[i]];
}
}
class Tree {
public:
int tr[3 * 100007];
int ans[3 * 100007];
int lazy[3 * 100007];
void init(int where, int IL, int IR) {
tr[where] = lazy[where] = 0;
ans[where] = IL;
if (IL == IR) {
return;
}
int mid = (IL + IR) / 2;
init(2 * where, IL, mid);
init(2 * where + 1, mid + 1, IR);
}
void push_lazy(int where, int IL, int IR) {
if (lazy[where] == 0) {
return;
}
tr[where] = max(tr[where], lazy[where]);
ans[where] = tr[where] + IL;
if (IL != IR) {
lazy[2 * where] = max(lazy[2 * where], lazy[where]);
lazy[2 * where + 1] = max(lazy[2 * where + 1], lazy[where]);
}
lazy[where] = 0;
}
void update(int where, int IL, int IR, int CURL, int CURR, int val) {
push_lazy(where, IL, IR);
if (CURR < IL || IR < CURL) {
return;
}
if (CURL <= IL && IR <= CURR) {
lazy[where] = val;
push_lazy(where, IL, IR);
return;
}
int mid = (IL + IR) / 2;
update(2 * where, IL, mid, CURL, CURR, val);
update(2 * where + 1, mid + 1, IR, CURL, CURR, val);
tr[where] = max(tr[2 * where], tr[2 * where + 1]);
ans[where] = min(ans[2 * where], ans[2 * where + 1]);
}
pair<int, int> getmx(int where, int IL, int IR, int CURL, int CURR) {
push_lazy(where, IL, IR);
if (IR < CURL || CURR < IL) {
return make_pair(0, 1000000007);
}
if (CURL <= IL && IR <= CURR) {
return make_pair(tr[where], ans[where]);
}
int mid = (IL + IR) / 2;
pair<int, int> ret1 = getmx(2 * where, IL, mid, CURL, CURR);
pair<int, int> ret2 = getmx(2 * where + 1, mid + 1, IR, CURL, CURR);
ret1.first = max(ret1.first, ret2.first);
ret1.second = min(ret1.second, ret2.second);
return ret1;
}
};
Tree w;
void add(int x) {
if (fc[x] == 0) {
w.update(1, 0, n, 0, fb[x] - 1, 1000000007);
return;
}
int l, r, mid;
l = 0;
r = n;
if (fb[x] != 0) {
r = fb[x] - 1;
}
while (r - l > 3) {
int mid = (l + r) / 2;
int ret = w.getmx(1, 0, n, mid, mid).first;
if (ret >= fc[x]) {
l = mid;
} else {
r = mid;
}
}
while (l <= r) {
int ret = w.getmx(1, 0, n, l, l).first;
if (ret < fc[x]) {
break;
}
l++;
}
int st = l;
int en = n;
if (fb[x] != 0) {
en = fb[x] - 1;
}
if (st <= en) {
w.update(1, 0, n, st, en, fc[x]);
}
}
void input() {
scanf("%d", &n);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
srt.push_back(a[i]);
}
for (i = 1; i <= n; i++) {
scanf("%d", &b[i]);
srt.push_back(b[i]);
}
for (i = 1; i <= n; i++) {
scanf("%d", &c[i]);
srt.push_back(c[i]);
}
compress();
}
void solve() {
int i;
for (i = n; i >= 1; i--) {
fa[a[i]] = i;
fb[b[i]] = i;
fc[c[i]] = i;
br[a[i]]++;
}
w.init(1, 0, n);
for (i = 1; i <= MXVAL; i++) {
if (br[i] == 0) {
add(i);
}
}
int ans = 1000000007;
for (i = n; i >= 0; i--) {
int ret = w.getmx(1, 0, n, 0, n).second;
ret += i;
if (ans > ret) {
ans = ret;
}
if (i == 0) {
break;
}
br[a[i]]--;
if (br[a[i]] == 0) {
if (fb[a[i]] == 0 && fc[a[i]] == 0) {
break;
}
add(a[i]);
}
}
printf("%d\n", ans);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e7;
const int MN = 1e5 + 7;
struct int3 {
int a[3];
bool operator<(const int3 &x) const { return a[0] < x.a[0]; }
} ept = {INF, INF, INF};
int n, t, ans = INF;
int3 f[MN * 3];
map<int, int3> mp;
map<int, int3>::iterator mi;
set<pair<int, int> > u;
set<pair<int, int> >::iterator ui, ii;
multiset<int> res;
void gao(int x, int y) {
ui = u.upper_bound(pair<int, int>(x, y));
if (ui->second >= y) return;
pair<int, int> pre = *ui;
ii = ui;
ii--;
while (ii->second <= y) {
res.erase(res.find(ii->first + pre.second));
pre = *ii;
ii--;
u.erase(pre);
}
res.erase(res.find(ii->first + pre.second));
res.insert(ii->first + y);
res.insert(x + ui->second);
u.insert(pair<int, int>(x, y));
}
int main() {
scanf("%d", &n);
int i, j, k;
for (i = 0; i < 3; i++) {
for (j = 1; j <= n; j++) {
scanf("%d", &k);
if (mp.find(k) == mp.end()) mp[k] = ept;
mp[k].a[i] = min(mp[k].a[i], j);
}
}
for (mi = mp.begin(); mi != mp.end(); mi++) f[t++] = mi->second;
sort(f, f + t);
u.insert(pair<int, int>(0, INF * 2));
u.insert(pair<int, int>(INF * 2, 0));
res.insert(0);
k = INF;
for (i = t - 1; i >= 0; i--) {
ans = min(ans, *res.begin() + f[i].a[0]);
gao(f[i].a[1], f[i].a[2]);
}
ans = min(ans, *res.begin() + f[i].a[0]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int N = 3000000;
struct T {
int a, b, c;
T(){};
T(int a, int b, int c) : a(a), b(b), c(c){};
bool operator<(const T &x) const {
return ((a < x.a) || ((a == x.a) && (b < x.b)) ||
((a == x.a) && (b == x.b) && (c < x.c)));
}
};
int n, a[N], b[N], c[N], t_min[4 * N], t_res[4 * N], t_upd[4 * N], k;
T x[N];
pair<int, int> p[N];
void build(int v, int tl, int tr) {
if (tl == tr) {
t_min[v] = 0;
t_res[v] = tl;
t_upd[v] = 0;
return;
}
int tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm + 1, tr);
t_min[v] = 0;
t_res[v] = tl;
t_upd[v] = 0;
}
void push(int v, int tl, int tr) {
int tm = (tl + tr) / 2;
if (t_upd[v] != 0) {
t_min[v * 2] = t_upd[v];
t_min[v * 2 + 1] = t_upd[v];
t_res[v * 2] = min(inf, tl + t_upd[v]);
t_res[v * 2 + 1] = min(inf, tm + 1 + t_upd[v]);
t_upd[v * 2] = t_upd[v];
t_upd[v * 2 + 1] = t_upd[v];
t_upd[v] = 0;
}
}
int get(int v, int tl, int tr, int val) {
if (tl == tr) return tl;
push(v, tl, tr);
int tm = (tl + tr) / 2;
if (t_min[v * 2] <= val)
return get(v * 2, tl, tm, val);
else
return get(v * 2 + 1, tm + 1, tr, val);
}
void update(int v, int tl, int tr, int l, int r, int val) {
if (l > r) return;
if (l == tl && r == tr) {
t_min[v] = val;
t_res[v] = val + l;
t_upd[v] = val;
return;
}
push(v, tl, tr);
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm), val);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, val);
t_min[v] = min(t_min[v * 2], t_min[v * 2 + 1]);
t_res[v] = min(t_res[v * 2], t_res[v * 2 + 1]);
}
int Min(int v, int tl, int tr, int l, int r) {
if (l > r) return inf;
if (l == tl && r == tr) return t_res[v];
push(v, tl, tr);
int tm = (tl + tr) / 2;
return min(Min(v * 2, tl, tm, l, min(r, tm)),
Min(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 1; i <= n; i++) p[i].first = a[i];
for (int i = 1; i <= n; i++) p[i + n].first = b[i];
for (int i = 1; i <= n; i++) p[i + 2 * n].first = c[i];
for (int i = 1; i <= 3 * n; i++) p[i].second = i;
sort(p + 1, p + 3 * n + 1);
k = 1;
for (int i = 1; i <= 3 * n; i++) {
if ((i > 1) && (p[i].first != p[i - 1].first)) k++;
if (p[i].second <= n)
a[p[i].second] = k;
else if (p[i].second <= 2 * n)
b[p[i].second - n] = k;
else
c[p[i].second - 2 * n] = k;
}
for (int i = 1; i <= k; i++) x[i] = T(inf, inf, inf);
for (int i = 1; i <= n; i++) {
x[a[i]].a = min(x[a[i]].a, i);
x[b[i]].b = min(x[b[i]].b, i);
x[c[i]].c = min(x[c[i]].c, i);
}
sort(x + 1, x + k + 1);
int ans = 3 * n;
build(1, 0, 3 * n);
for (int i = k; i >= 0; i--) {
if (x[i].a != inf) ans = min(ans, x[i].a + Min(1, 0, 3 * n, 0, 3 * n));
if (!i) break;
int j = get(1, 0, 3 * n, x[i].c);
if (j < x[i].b) update(1, 0, 3 * n, j, min(3 * n, x[i].b - 1), x[i].c);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
multiset<int> st;
int mx[300010 * 4], cv[300010 * 4], n;
inline void Down(int x) {
if (cv[x]) {
mx[x * 2] = mx[x * 2 + 1] = cv[x];
cv[x * 2] = cv[x * 2 + 1] = cv[x], cv[x] = 0;
}
}
inline void Cov(int x, int l, int r, int a, int b, int c) {
if (l == a && r == b) {
mx[x] = cv[x] = c;
return;
}
int md = (l + r) / 2;
Down(x);
if (b <= md) Cov(x * 2, l, md, a, b, c);
if (md < a) Cov(x * 2 + 1, md + 1, r, a, b, c);
if (a <= md && md < b)
Cov(x * 2, l, md, a, md, c), Cov(x * 2 + 1, md + 1, r, md + 1, b, c);
mx[x] = max(mx[x * 2], mx[x * 2 + 1]);
}
inline int Pre(int x, int l, int r, int a) {
if (l == r) {
if (mx[x] <= a) return (l);
return (n + 1);
}
int md = (l + r) / 2;
Down(x);
if (mx[x * 2 + 1] > a) return (Pre(x * 2 + 1, md + 1, r, a));
return (min(md + 1, Pre(x * 2, l, md, a)));
}
inline int Ask(int x, int l, int r, int a) {
if (l == r) return (mx[x]);
int md = (l + r) / 2;
Down(x);
if (a <= md)
return (Ask(x * 2, l, md, a));
else
return (Ask(x * 2 + 1, md + 1, r, a));
}
pair<int, int> p[300010];
int m, ans;
inline void Chg(int x, int y) {
int od = Ask(1, 1, n + 1, x), xx = x, odd = od, pr = x;
if (od >= y) return;
while (od < y) {
pr = Pre(1, 1, n + 1, od);
multiset<int>::iterator it = st.find(pr - 1 + od);
st.erase(it);
x = pr - 1;
if (!x) break;
od = Ask(1, 1, n + 1, x);
}
Cov(1, 1, n + 1, pr, xx, y);
if (xx + 1 <= n + 1) st.insert(xx + odd);
x = Pre(1, 1, n + 1, y);
st.insert(x - 1 + y);
}
map<int, int> mp;
int va[300010], a[300010], b[300010], c[300010], u[300010], v[300010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 1; i <= n; i++)
if (!mp[a[i]]) u[++m] = a[i], mp[a[i]] = m, va[i] = 1;
for (int i = 1; i <= n; i++)
if (!mp[b[i]]) u[++m] = b[i], mp[b[i]] = m;
for (int i = 1; i <= n; i++)
if (!mp[c[i]]) u[++m] = c[i], mp[c[i]] = m;
for (int i = 1; i <= n; i++)
if (!p[mp[b[i]]].first) p[mp[b[i]]].first = i;
for (int i = 1; i <= n; i++)
if (!p[mp[c[i]]].second) p[mp[c[i]]].second = i;
for (int i = 1; i <= n; i++) v[mp[a[i]]] = 1;
st.insert(0);
for (int i = 1; i <= m; i++)
if (!v[i]) {
if (!p[i].first) p[i].first = n + 1;
if (!p[i].second) p[i].second = 1e9 + 1;
Chg(p[i].first, p[i].second);
}
ans = n + (*st.begin());
for (int i = n; i; i--) {
if (va[i]) {
int d = mp[a[i]];
if (!p[d].first && !p[d].second) break;
if (!p[d].first) p[d].first = n + 1;
if (!p[d].second) p[d].second = 1e9 + 1;
Chg(p[d].first, p[d].second);
int nw = i - 1 + (*st.begin());
ans = min(ans, nw);
} else {
int nw = i - 1 + (*(st.begin()));
ans = min(ans, nw);
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double eps = 1e-7;
const int inf = 10000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 100010, LOG = 20;
int n, m, k, u, v, x, y, t, a, b, ans;
int A[3][MAXN];
int B[3][3 * MAXN];
int seg[MAXN << 2], lazy[MAXN << 2], Mn[MAXN << 2], Mx[MAXN << 2];
vector<int> compress;
set<pair<pair<int, int>, int> > st;
int build(int id, int tl, int tr) {
if (tr - tl == 1) return seg[id] = tl;
int mid = (tl + tr) >> 1;
return seg[id] = min(build(id << 1, tl, mid), build(id << 1 | 1, mid, tr));
}
void add_lazy(int id, int val) {
seg[id] += val;
Mn[id] += val;
Mx[id] += val;
lazy[id] += val;
}
void shift(int id) {
if (!lazy[id]) return;
add_lazy(id << 1, lazy[id]);
add_lazy(id << 1 | 1, lazy[id]);
lazy[id] = 0;
}
void Add(int id, int tl, int tr, int l, int r, int val) {
if (tr <= l || r <= tl) return;
if (l <= tl && tr <= r) {
add_lazy(id, val);
return;
}
shift(id);
int mid = (tl + tr) >> 1;
Add(id << 1, tl, mid, l, r, val);
Add(id << 1 | 1, mid, tr, l, r, val);
seg[id] = min(seg[id << 1], seg[id << 1 | 1]);
Mn[id] = min(Mn[id << 1], Mn[id << 1 | 1]);
Mn[id] = max(Mx[id << 1], Mx[id << 1 | 1]);
}
int BS(int id, int tl, int tr, int val) {
if (tr - tl == 1) return tl;
shift(id);
int mid = (tl + tr) >> 1;
if (Mn[id << 1] >= val) return BS(id << 1 | 1, mid, tr, val);
return BS(id << 1, tl, mid, val);
}
void split(int x) {
pair<pair<int, int>, int> p = *--st.upper_bound({{x, inf}, 0});
if (p.first.first == x) return;
st.erase(p);
st.insert({{p.first.first, x}, p.second});
st.insert({{x, p.first.second}, p.second});
}
void update(int id, int tl, int tr, int l, int r, int val) {
if (r <= tl || tr <= l || Mn[id] >= val) return;
if (l <= tl && tr <= r && Mn[id] == Mx[id]) {
add_lazy(id, val - Mx[id]);
return;
}
shift(id);
int mid = (tl + tr) >> 1;
update(id << 1, tl, mid, l, r, val);
update(id << 1 | 1, mid, tr, l, r, val);
seg[id] = min(seg[id << 1], seg[id << 1 | 1]);
Mn[id] = min(Mn[id << 1], Mn[id << 1 | 1]);
Mx[id] = max(Mx[id << 1], Mx[id << 1 | 1]);
}
void print(int id, int tl, int tr) {
if (tr - tl == 1) {
cerr << seg[id] << ' ';
return;
}
shift(id);
int mid = (tl + tr) >> 1;
print(id << 1, tl, mid);
print(id << 1 | 1, mid, tr);
}
void Maximize(int l, int r, int val) { update(1, 0, n + 1, l, r, val); }
void Condition(int num) {
if (!B[1][num] && B[2][num]) Maximize(0, n + 1, B[2][num]);
if (B[1][num] && !B[2][num]) Maximize(0, B[1][num], inf);
if (B[1][num] && B[2][num]) Maximize(0, B[1][num], B[2][num]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int j = 0; j < 3; j++)
for (int i = 1; i <= n; i++) cin >> A[j][i], compress.push_back(A[j][i]);
sort(compress.begin(), compress.end());
compress.resize(unique(compress.begin(), compress.end()) - compress.begin());
for (int j = 0; j < 3; j++)
for (int i = n; i; i--)
B[j][A[j][i] = lower_bound(compress.begin(), compress.end(), A[j][i]) -
compress.begin()] = i;
build(1, 0, n + 1);
st.insert({{0, n + 1}, 0});
for (int i = 0; i < compress.size(); i++)
if (!B[0][i]) {
if (!B[1][i] && !B[2][i]) continue;
Condition(i);
}
ans = seg[1] + n;
for (int i = n; i; i--) {
int num = A[0][i];
if (B[0][num] == i) {
if (!B[1][num] && !B[2][num]) break;
Condition(num);
}
ans = min(ans, seg[1] + i - 1);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, m, ans, a[N], b[N], c[N], id[N], V[N], A[N], B[N], C[N];
multiset<int> res;
set<pair<int, int> > H;
set<int> svdecomposition;
bool cmp(const int i, const int j) { return A[i] > A[j]; }
void ins(pair<int, int> z) {
set<pair<int, int> >::iterator l, i, r = H.lower_bound(z);
if (r->second >= z.second) return;
i = H.insert(z).first, l = i, --l, res.erase(res.find(l->first + r->second)),
res.insert(i->first + r->second);
while (l->second < i->second)
r = l--, res.erase(res.find(l->first + r->second)), H.erase(r);
res.insert(l->first + i->second);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", a + i), V[m++] = a[i];
for (int i = 0; i < n; ++i) scanf("%d", b + i), V[m++] = b[i];
for (int i = 0; i < n; ++i) scanf("%d", c + i), V[m++] = c[i];
int once;
sort(V, V + m), m = unique(V, V + m) - V;
for (int i = 0; i < n; ++i) a[i] = lower_bound(V, V + m, a[i]) - V;
for (int i = 0; i < n; ++i) b[i] = lower_bound(V, V + m, b[i]) - V;
for (int i = 0; i < n; ++i) c[i] = lower_bound(V, V + m, c[i]) - V;
for (int i = 0; i < m; ++i) A[i] = B[i] = C[i] = 3 * n;
for (int i = 0; i < n; ++i)
if (A[a[i]] > n) A[a[i]] = i + 1;
for (int i = 0; i < n; ++i)
if (B[b[i]] > n) B[b[i]] = i + 1;
for (int i = 0; i < n; ++i)
if (C[c[i]] > n) C[c[i]] = i + 1;
int twicr;
for (int i = 0; i < m + 1; ++i) id[i] = i;
A[m] = 0, sort(id, id + m, cmp);
H.insert(make_pair(0, 4 * n)), H.insert(make_pair(4 * n, 0)), res.insert(0),
ans = A[*id];
for (int i = 0; i < m; ++i)
ins(make_pair(B[id[i]], C[id[i]])),
ans = min(ans, A[id[i + 1]] + *res.begin());
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
multiset<pair<int, int> > B;
multiset<int> A;
int n, m, a[N], b[N], c[N], ss[N * 3], fa[N], fb[N], fc[N], id[N], ans;
bool cmp(int x, int y) { return fa[x] > fa[y]; }
void ins(pair<int, int> nw) {
set<pair<int, int> >::iterator i, j, k;
k = B.lower_bound(nw);
if ((*k).second >= nw.second) return;
i = k;
--i;
A.erase(A.find((*i).first + (*k).second));
A.insert(nw.first + (*k).second);
while ((*i).second <= nw.second) {
j = i;
--i;
A.erase(A.find((*i).first + (*j).second));
B.erase(j);
}
A.insert((*i).first + nw.second);
B.insert(nw);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i), ss[++m] = a[i];
for (int i = 1; i <= n; i++) scanf("%d", b + i), ss[++m] = b[i];
for (int i = 1; i <= n; i++) scanf("%d", c + i), ss[++m] = c[i];
sort(ss + 1, ss + m + 1);
m = unique(ss + 1, ss + m + 1) - ss - 1;
for (int i = 1; i <= n; i++) {
a[i] = lower_bound(ss + 1, ss + m + 1, a[i]) - ss;
b[i] = lower_bound(ss + 1, ss + m + 1, b[i]) - ss;
c[i] = lower_bound(ss + 1, ss + m + 1, c[i]) - ss;
if (!fa[a[i]]) fa[a[i]] = i;
if (!fb[b[i]]) fb[b[i]] = i;
if (!fc[c[i]]) fc[c[i]] = i;
}
for (int i = 1; i <= m; i++) {
if (!fa[i]) fa[i] = n * 3;
if (!fb[i]) fb[i] = n * 3;
if (!fc[i]) fc[i] = n * 3;
}
for (int i = 1; i <= m; i++) id[i] = i;
sort(id + 1, id + m + 1, cmp);
ans = fa[id[1]];
fa[id[m + 1] = 0] = 0;
A.insert(0);
B.insert(make_pair(n * 10, 0));
B.insert(make_pair(0, n * 10));
for (int i = 1; i <= m; i++) {
ins(make_pair(fb[id[i]], fc[id[i]]));
ans = min(ans, fa[id[i + 1]] + (*A.begin()));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l;
int a[(300005)], b[(300005)], c[(300005)];
int dc[(300005)], ldc = 0, ll;
int A[(300005)], B[(300005)], C[(300005)];
int idx[(300005)];
bool cmp(int x, int y) { return A[x] > A[y]; }
void INIT() {
scanf("%d", &l);
for (int i = 0; i < l; i++) scanf("%d", &a[i]), dc[ldc++] = a[i];
for (int i = 0; i < l; i++) scanf("%d", &b[i]), dc[ldc++] = b[i];
for (int i = 0; i < l; i++) scanf("%d", &c[i]), dc[ldc++] = c[i];
sort(dc, dc + ldc);
ll = unique(dc, dc + ldc) - dc;
}
void PREP() {
for (int i = 0; i < l; i++) a[i] = lower_bound(dc, dc + ll, a[i]) - dc;
for (int i = 0; i < l; i++) b[i] = lower_bound(dc, dc + ll, b[i]) - dc;
for (int i = 0; i < l; i++) c[i] = lower_bound(dc, dc + ll, c[i]) - dc;
for (int i = 0; i < ll; i++) A[i] = B[i] = C[i] = 5 * (300005);
for (int i = 0; i < l; i++)
if (A[a[i]] > (300005)) A[a[i]] = i + 1;
for (int i = 0; i < l; i++)
if (B[b[i]] > (300005)) B[b[i]] = i + 1;
for (int i = 0; i < l; i++)
if (C[c[i]] > (300005)) C[c[i]] = i + 1;
A[ll] = 0;
for (int i = 0; i < ll + 1; i++) idx[i] = i;
sort(idx, idx + ll, cmp);
}
multiset<int> pro;
set<pair<int, int> > st;
void ins(pair<int, int> x) {
set<pair<int, int> >::iterator tmp = st.lower_bound(x);
if (tmp->second >= x.second) return;
set<pair<int, int> >::iterator tmp2 = st.insert(x).first;
set<pair<int, int> >::iterator tmp3 = tmp2;
tmp3--;
pro.erase(pro.lower_bound(tmp3->first + tmp->second));
pro.insert(tmp2->first + tmp->second);
while (tmp2->second > tmp3->second) {
set<pair<int, int> >::iterator tmp4 = tmp3--;
pro.erase(pro.lower_bound(tmp3->first + tmp4->second));
st.erase(tmp4);
}
pro.insert(tmp2->second + tmp3->first);
}
void PROCESS() {
int ans = A[idx[0]];
st.insert(pair<int, int>(0, (300005) * 10)),
st.insert(pair<int, int>((300005) * 10, 0)), pro.insert(0);
for (int i = 0; i < ll; i++) {
ins(pair<int, int>(B[idx[i]], C[idx[i]]));
ans = min(ans, A[idx[i + 1]] + *pro.begin());
}
printf("%d\n", ans);
}
int main() {
INIT();
PREP();
PROCESS();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool setmin(T &a, T b) {
if (b < a) {
a = b;
return true;
} else
return false;
}
template <class T>
bool setmax(T &a, T b) {
if (b > a) {
a = b;
return true;
} else
return false;
}
struct data {
int pa, pb, pc;
};
std::vector<data> da;
int constexpr inf = 1 << 28;
int constexpr maxn = 300007;
int a[maxn], b[maxn], c[maxn];
int n, endpos;
std::multiset<int> act;
using pair_type = std::pair<int, int>;
bool operator<(pair_type const &a, pair_type const &b) {
return a.first < b.first;
}
std::set<pair_type> points;
void erase(pair_type p) {
auto y = points.lower_bound(p);
auto x = y;
auto z = y;
--x, ++z;
act.erase(act.find(x->first + y->second));
act.erase(act.find(y->first + z->second));
act.insert(x->first + z->second);
points.erase(y);
}
void insert(pair_type p) {
points.insert(p);
auto y = points.lower_bound(p);
auto x = y;
auto z = y;
--x, ++z;
if (z->second > y->second) {
points.erase(p);
return;
}
act.insert(x->first + y->second);
act.insert(y->first + z->second);
act.erase(act.find(x->first + z->second));
while (1) {
x = points.lower_bound(p);
--x;
if (x->second < p.second) {
erase(*x);
} else
break;
}
}
int const MAXN = maxn;
struct Tri {
int i, j, k;
bool operator<(const Tri &t) const { return k < t.k; }
} d[MAXN];
void init() {
static int a[MAXN], b[MAXN], c[MAXN];
cin >> n;
for (int i = (int)(1); i <= (int)(n); ++i) cin >> a[i];
for (int i = (int)(1); i <= (int)(n); ++i) cin >> b[i];
for (int i = (int)(1); i <= (int)(n); ++i) cin >> c[i];
map<int, int> pa, pb, pc;
set<int> numbers;
for (int i = (int)(n); i >= (int)(1); --i) numbers.insert(a[i]), pa[a[i]] = i;
for (int i = (int)(n); i >= (int)(1); --i) numbers.insert(b[i]), pb[b[i]] = i;
for (int i = (int)(n); i >= (int)(1); --i) numbers.insert(c[i]), pc[c[i]] = i;
n = 0;
int tt = endpos = MAXN * 3;
for (set<int>::iterator it = numbers.begin(); it != numbers.end(); ++it) {
int x = *it;
++n;
if (pa.find(x) == pa.end())
d[n].i = ++tt;
else
d[n].i = pa[x];
if (pb.find(x) == pb.end())
d[n].j = ++tt;
else
d[n].j = pb[x];
if (pc.find(x) == pc.end())
d[n].k = ++tt;
else
d[n].k = pc[x];
}
}
void solve() {
std::sort(d + 1, d + n + 1);
int ret = 1 << 30;
points.clear();
points.insert(pair_type(0, inf));
points.insert(pair_type(inf, 0));
act.insert(0);
int cur = n;
while (cur >= 1 && d[cur].k >= endpos) {
insert(pair_type(d[cur].i, d[cur].j));
--cur;
}
while (cur >= 1) {
ret = std::min(ret, *act.begin() + d[cur].k);
insert(pair_type(d[cur].i, d[cur].j));
--cur;
}
ret = std::min(ret, *act.begin());
std::cout << ret << std::endl;
}
int main() {
init();
solve();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.