text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long long BIG = 1446803456761533460;
const int Big = 336860180;
stringstream sss;
const long long int maxn = 100010;
long long int n;
long long int A[maxn], B[maxn], C[maxn];
map<long long int, long long int> cnt_in_A, fst_in_B, fst_in_C;
set<pair<long long int, long long int> > hist;
long long int seg[maxn * 4];
long long int lazy[maxn * 4];
void build(long long int x = 1, long long int l = 0, long long int r = n + 1) {
seg[x] = l;
if (r - l > 1) {
long long int mid = (l + r) / 2;
build(x * 2, l, mid);
build(x * 2 + 1, mid, r);
}
}
void push(long long int x) {
seg[x * 2] += lazy[x];
lazy[x * 2] += lazy[x];
seg[x * 2 + 1] += lazy[x];
lazy[x * 2 + 1] += lazy[x];
lazy[x] = 0;
}
void update(long long int li, long long int ri, long long int v,
long long int x = 1, long long int l = 0, long long int r = n + 1) {
if (seg[x] >= BIG) return;
if (li >= r || l >= ri) {
} else if (li <= l && r <= ri) {
seg[x] += v;
lazy[x] += v;
} else {
if (lazy[x]) push(x);
long long int mid = (l + r) / 2;
update(li, ri, v, x * 2, l, mid);
update(li, ri, v, x * 2 + 1, mid, r);
seg[x] = min(seg[x * 2], seg[x * 2 + 1]);
}
}
void set_max(long long int i, long long int v) {
auto rt = hist.upper_bound({i, BIG});
if (rt->second >= v) return;
auto lt = rt;
--lt;
if (lt->first == i && lt->second >= v) return;
while (lt->second <= v) {
long long int b = lt->first, hb = lt->second;
--lt;
long long int a = lt->first;
update(a + 1, b + 1, -(hb - rt->second));
}
update(lt->first + 1, i + 1, v - rt->second);
++lt;
hist.erase(lt, rt);
hist.insert({i, v});
}
void MAIN() {
cin >> n;
for (long long int i = (0); i < (n); ++i) cin >> A[i];
for (long long int i = (0); i < (n); ++i) cin >> B[i];
for (long long int i = (0); i < (n); ++i) cin >> C[i];
for (long long int i = (0); i < (n); ++i) cnt_in_A[A[i]]++;
for (long long int i = (n)-1; i >= (0); --i) {
fst_in_B[B[i]] = i;
fst_in_C[C[i]] = i;
}
build();
hist.insert({-1, BIG + 1});
hist.insert({BIG, 0});
long long int s = 0;
for (long long int i = (0); i < (n); ++i) {
if (cnt_in_A.count(C[i]) + fst_in_B.count(C[i]) == 0 && fst_in_C[C[i]] == i)
s = i + 1;
}
set_max(n, s);
for (long long int i = (n)-1; i >= (0); --i) {
if (cnt_in_A[B[i]] == 0 && fst_in_B[B[i]] == i) {
long long int s = fst_in_C.count(B[i]) ? fst_in_C[B[i]] + 1 : BIG;
set_max(i, s);
}
}
long long int ans = n + seg[1];
for (long long int i = (n)-1; i >= (0); --i) {
if (--cnt_in_A[A[i]] == 0) {
long long int f = fst_in_B.count(A[i]) ? fst_in_B[A[i]] : n;
long long int s = fst_in_C.count(A[i]) ? fst_in_C[A[i]] + 1 : BIG;
set_max(f, s);
}
ans = min(ans, (i + seg[1]));
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
10
3 2 2 1 3 4 1 10 5 10
2 10 8 9 9 10 3 1 3 4
1 4 6 8 8 3 4 5 8 10
10
2 5 10 6 4 3 1 1 9 5
5 10 5 2 4 1 1 4 7 4
5 1 4 9 2 6 10 9 8 3
10
2 10 2 1 8 8 3 1 7 10
2 10 5 7 8 8 2 6 1 6
1 5 6 6 7 8 4 9 4 4
5
1 1 2 2 3
2 2 4 3 3
3 3 1 1 1
)";
MAIN();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, tot = 0, fa[3 * 100005], fb[3 * 100005], fc[3 * 100005], a[100005],
b[100005], c[100005];
int ans = INF, flag = 1;
struct node {
int val, id1, id2;
friend bool operator<(node a, node b) { return a.val < b.val; }
} f[3 * 100005];
struct Pair {
int b, c;
friend bool operator<(Pair a, Pair b) { return a.b < b.b; }
} p;
set<Pair> s;
set<Pair>::iterator it;
multiset<int> mul_s;
multiset<int>::iterator mul_it;
inline int read() {
register int x = 0, f = 1;
register char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
inline 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--;
mul_it = mul_s.find((*it).b + nowc);
mul_s.erase(mul_it);
while ((*it).c <= e.c) {
nowb = (*it).b, nowc = (*it).c;
it--;
mul_s.erase((*it).b + nowc);
it++;
s.erase(it);
it = s.lower_bound(e);
it--;
}
nowb = (*it).b, nowc = (*it).c;
mul_s.insert(nowb + e.c);
it++;
nowc = (*it).c;
mul_s.insert(e.b + nowc);
s.insert(e);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
f[++tot].val = read();
f[tot].id1 = 1, f[tot].id2 = i;
}
for (int i = 1; i <= n; i++) {
f[++tot].val = read();
f[tot].id1 = 2, f[tot].id2 = i;
}
for (int i = 1; i <= n; i++) {
f[++tot].val = read();
f[tot].id1 = 3, f[tot].id2 = i;
}
sort(f + 1, f + 3 * n + 1);
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;
p.b = 0, p.c = INF + 1;
s.insert(p);
p.b = INF + 1, p.c = 0;
s.insert(p);
mul_s.insert(0);
for (int i = 1; i <= tot; i++)
if (!fa[i]) {
if (fb[i]) {
if (fc[i])
insertPair(fb[i], fc[i]);
else
insertPair(fb[i], INF);
} else {
if (fc[i])
insertPair(INF, fc[i]);
else
insertPair(INF, INF);
}
}
for (int i = n; i >= 1; i--) {
ans = min(ans, i + (*mul_s.begin()));
if (fa[a[i]] == i) {
if (!fb[a[i]] && !fc[a[i]]) {
flag = 0;
break;
}
if (fb[a[i]]) {
if (fc[a[i]])
insertPair(fb[a[i]], fc[a[i]]);
else
insertPair(fb[a[i]], INF);
} else {
if (fc[a[i]])
insertPair(INF, fc[a[i]]);
else
insertPair(INF, INF);
}
}
}
if (flag) ans = min(ans, (*mul_s.begin()));
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int getint() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x *= 10, x += (c - '0'), c = getchar();
return x;
}
map<int, int> M;
int n, a[100010], b[100010], c[100010], idx;
int A[100010 * 3], B[100010 * 3], C[100010 * 3], no[100010 * 3];
bool cmp(int a, int b) { return A[a] > A[b]; }
void init() {
n = getint();
for (int i = 1; i <= n; i++) {
a[i] = getint();
M[a[i]] = 1;
}
for (int i = 1; i <= n; i++) {
b[i] = getint();
M[b[i]] = 1;
}
for (int i = 1; i <= n; i++) {
c[i] = getint();
M[c[i]] = 1;
}
for (map<int, int>::iterator it = M.begin(); it != M.end(); it++)
it->second = ++idx;
}
void pre_build() {
for (int i = 1; i <= idx; i++) {
A[i] = B[i] = C[i] = 1000010;
no[i] = i;
}
for (int i = 1; i <= n; i++)
if (A[M[a[i]]] == 1000010) A[M[a[i]]] = i;
for (int i = 1; i <= n; i++)
if (B[M[b[i]]] == 1000010) B[M[b[i]]] = i;
for (int i = 1; i <= n; i++)
if (C[M[c[i]]] == 1000010) C[M[c[i]]] = i;
}
multiset<int> aS;
set<pair<int, int> > S;
void insert(int tb, int tc) {
pair<int, int> tmp = make_pair(tb, tc);
set<pair<int, int> >::iterator l, now, r = S.lower_bound(tmp);
if (r->second >= tmp.second) return;
l = now = S.insert(tmp).first;
l--;
aS.erase(aS.lower_bound(l->first + r->second));
aS.insert(now->first + r->second);
while (l->second < now->second) {
r = l--;
aS.erase(aS.lower_bound(l->first + r->second));
S.erase(r);
}
aS.insert(l->first + now->second);
}
void process() {
sort(no + 1, no + idx + 1, cmp);
S.insert(make_pair(0, 1000010 * 2));
S.insert(make_pair(1000010 * 2, 0));
aS.insert(0);
int ans = A[no[1]];
A[idx + 1] = 0;
for (int i = 1; i <= idx; i++) {
insert(B[no[i]], C[no[i]]);
if (A[no[i + 1]] + *aS.begin() < ans) ans = A[no[i + 1]] + *aS.begin();
}
printf("%d\n", ans);
}
int main() {
init();
pre_build();
process();
S.clear();
aS.clear();
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
constexpr long long mod = 100000008;
const long long INF = mod * mod;
const long double eps = 1e-12;
const long double pi = acosl(-1.0);
long long mod_pow(long long x, long long n, long long m = mod) {
if (n < 0) {
long long res = mod_pow(x, -n, m);
return mod_pow(res, m - 2, m);
}
if (abs(x) >= m) x %= m;
if (x < 0) x += m;
long long res = 1;
while (n) {
if (n & 1) res = res * x % m;
x = x * x % m;
n >>= 1;
}
return res;
}
struct modint {
long long n;
modint() : n(0) { ; }
modint(long long m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint& a, modint b) {
a.n += b.n;
if (a.n >= mod) a.n -= mod;
return a;
}
modint operator-=(modint& a, modint b) {
a.n -= b.n;
if (a.n < 0) a.n += mod;
return a;
}
modint operator*=(modint& a, modint b) {
a.n = ((long long)a.n * b.n) % mod;
return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, long long n) {
if (n == 0) return modint(1);
modint res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
long long inv(long long a, long long p) {
return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
modint operator/=(modint& a, modint b) {
a = a / b;
return a;
}
const int max_n = 100;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
modint combP(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return fact[a] * factinv[a - b];
}
void solve() {
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];
vector<int> v;
for (int val : a) v.push_back(val);
for (int val : b) v.push_back(val);
for (int val : c) v.push_back(val);
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
vector<int> la(v.size(), mod);
vector<int> lb(v.size(), mod);
vector<int> lc(v.size(), mod);
for (int i = 0; i < a.size(); i++) {
int id = lower_bound((v).begin(), (v).end(), a[i]) - v.begin();
la[id] = min(la[id], i + 1);
}
for (int i = 0; i < b.size(); i++) {
int id = lower_bound((v).begin(), (v).end(), b[i]) - v.begin();
lb[id] = min(lb[id], i + 1);
}
for (int i = 0; i < c.size(); i++) {
int id = lower_bound((v).begin(), (v).end(), c[i]) - v.begin();
lc[id] = min(lc[id], i + 1);
}
int ra = 0, rb = 0, rc = 0;
for (int i = 0; i < v.size(); i++) {
if (lb[i] == mod && lc[i] == mod) {
ra = max(ra, la[i]);
}
if (la[i] == mod && lc[i] == mod) {
rb = max(rb, lb[i]);
}
if (la[i] == mod && lb[i] == mod) {
rc = max(rc, lc[i]);
}
}
set<pair<int, int>> st;
multiset<int> stval;
st.insert({0, 2 * mod});
st.insert({2 * mod, 0});
stval.insert(0);
auto add = [&](int x, int y) {
pair<int, int> p = {x, -1};
st.insert(p);
auto itr = st.find(p);
itr++;
pair<int, int> nex = *itr;
st.erase(p);
if (nex.first == x) {
if (nex.second >= y)
return;
else {
st.insert({x, y});
itr = st.find({x, y});
st.erase(nex);
itr--;
int val = (*itr).first + nex.second;
stval.erase(stval.find(val));
while (true) {
if ((*itr).second <= y) {
pair<int, int> mem = *itr;
itr--;
st.erase(mem);
int val = (*itr).first + mem.second;
stval.erase(stval.find(val));
} else
break;
}
val = (*itr).first + y;
stval.insert(val);
}
} else {
if (nex.second >= y) return;
itr--;
int val = (*itr).first + nex.second;
stval.erase(stval.find(val));
st.insert({x, y});
val = x + nex.second;
stval.insert(val);
while (true) {
if ((*itr).second <= y) {
pair<int, int> mem = *itr;
itr--;
st.erase(mem);
int val = (*itr).first + mem.second;
stval.erase(stval.find(val));
} else
break;
}
val = (*itr).first + y;
stval.insert(val);
}
};
vector<vector<pair<int, int>>> adbc(n - ra + 1);
vector<vector<int>> adb(n - ra + 1);
vector<vector<int>> adc(n - ra + 1);
for (int i = 0; i < v.size(); i++) {
if (la[i] <= ra || lb[i] <= rb || lc[i] <= rc) continue;
if (lc[i] == mod) {
adb[la[i] - ra].push_back(lb[i] - rb);
} else if (lb[i] == mod) {
adc[la[i] - ra].push_back(lc[i] - rc);
} else if (la[i] == mod) {
add(lb[i] - rb, lc[i] - rc);
} else {
adbc[la[i] - ra].push_back({lb[i] - rb, lc[i] - rc});
}
}
int ans = 3 * n;
for (int i = n - ra; i >= 0; i--) {
int cost = ra + rb + rc + i + *stval.begin();
ans = min(ans, cost);
for (pair<int, int> p : adbc[i]) {
add(p.first, p.second);
}
for (int valb : adb[i]) {
add(valb, mod);
}
for (int valc : adc[i]) {
add(mod, valc);
}
}
cout << ans << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int nmax = 511222;
void read(int a[nmax], int n, int all[]) {
for (int(i) = 0; (i) < (n); ++(i)) {
scanf("%d", &a[i]);
all[i] = a[i];
}
}
void make_small(int a[nmax], int n, int all[nmax], int sz) {
for (int(i) = 0; (i) < (n); ++(i)) {
a[i] = lower_bound(all, all + sz, a[i]) - all;
}
}
int a[nmax], b[nmax], c[nmax], all[nmax];
int pa[nmax], pb[nmax], pc[nmax];
int n, sz;
struct element {
int a, b, c;
};
bool comp(element e1, element e2) { return e1.a < e2.a; }
element mas[nmax];
struct node {
bool end;
int val;
int ans;
};
node T[nmax * 4];
int getval(int pos) {
int v = 1;
int l = 0;
int r = n;
while (T[v].end != true) {
int mid = (l + r) / 2;
if (pos <= mid) {
r = mid;
v = v * 2;
} else {
l = mid + 1;
v = v * 2 + 1;
}
}
return T[v].val;
}
void update(int v, int l, int r, int kl, int kr, int val) {
if (l == kl && r == kr) {
T[v].end = true;
assert(val >= T[v].val);
T[v].val = val;
T[v].ans = val + l;
return;
} else {
int mid = (l + r) / 2;
if (T[v].end) {
T[v * 2].val = T[v].val;
T[v * 2].end = true;
T[v * 2].ans = T[v].ans;
T[v * 2 + 1].val = T[v].val;
T[v * 2 + 1].end = true;
T[v * 2 + 1].ans = T[v].val + mid + 1;
T[v].end = false;
}
if (kr <= mid) update(v * 2, l, mid, kl, kr, val);
if (kl > mid) update(v * 2 + 1, mid + 1, r, kl, kr, val);
if (kl <= mid && kr > mid) {
update(v * 2, l, mid, kl, mid, val);
update(v * 2 + 1, mid + 1, r, mid + 1, kr, val);
}
T[v].ans = min(T[v * 2].ans, T[v * 2 + 1].ans);
}
}
int main() {
scanf("%d", &n);
read(a, n, all);
read(b, n, all + n);
read(c, n, all + n + n);
sort(all, all + 3 * n);
int sall = 1;
for (int(i) = (1); (i) <= (3 * n - 1); ++(i)) {
if (all[i] != all[i - 1]) all[sall++] = all[i];
}
make_small(a, n, all, sall);
make_small(b, n, all, sall);
make_small(c, n, all, sall);
sz = sall;
for (int(i) = 0; (i) < (sz); ++(i)) pa[i] = pb[i] = pc[i] = 1000000000;
for (int(i) = (n); (i)--;) {
pa[a[i]] = i;
pb[b[i]] = i;
pc[c[i]] = i;
}
for (int(i) = 0; (i) < (sz); ++(i)) {
mas[i].a = pa[i];
mas[i].b = pb[i];
mas[i].c = pc[i];
}
sort(mas, mas + sz, comp);
int ans = n + n + n;
if (mas[sz - 1].a != 1000000000) ans = mas[sz - 1].a + 1;
T[1].end = true;
for (int(i) = (sz); (i)--;) {
element cur = mas[i];
if (cur.b == 1000000000) cur.b = n;
if (getval(cur.b) < cur.c + 1) {
int l = -1, r = cur.b;
while (l < r - 1) {
int mid = (l + r) / 2;
if (getval(mid) < cur.c + 1)
r = mid;
else
l = mid;
}
update(1, 0, n, r, cur.b, cur.c + 1);
}
ans = min(ans, (i == 0 ? 0 : mas[i - 1].a + 1) + T[1].ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int a[N], b[N], c[N], d[N * 3], n, m, ans;
int fr1[N * 3], fr2[N * 3], fr3[N * 3];
struct node {
int l, r, dl, dr, ans, tag;
} t[N * 4];
multiset<int> s;
multiset<int>::iterator ii;
void push_down(int k) {
if (t[k].tag == -1) return;
t[k * 2].tag = t[k * 2].dl = t[k * 2].dr = t[k].tag;
t[k * 2].ans = t[k].tag + t[k * 2].l;
t[k * 2 + 1].tag = t[k * 2 + 1].dl = t[k * 2 + 1].dr = t[k].tag;
t[k * 2 + 1].ans = t[k].tag + t[k * 2 + 1].l;
t[k].tag = -1;
}
void built(int k, int l, int r) {
t[k].l = l;
t[k].r = r;
t[k].tag = -1;
if (l == r) {
t[k].dl = t[k].dr = d[l];
t[k].ans = d[l] + l;
return;
}
int mid = (l + r) >> 1;
built(k * 2, l, mid);
built(k * 2 + 1, mid + 1, r);
t[k].dl = t[k * 2].dl;
t[k].dr = t[k * 2 + 1].dr;
t[k].ans = min(t[k * 2].ans, t[k * 2 + 1].ans);
}
void modify(int k, int l, int r, int x) {
if (t[k].l == l && t[k].r == r && t[k].dl <= x) {
t[k].dl = t[k].dr = t[k].tag = x;
t[k].ans = x + t[k].l;
return;
}
if (t[k].l == t[k].r) return;
push_down(k);
int mid = (t[k].l + t[k].r) >> 1;
if (t[k * 2].dr < x && l <= mid) modify(k * 2, l, min(mid, r), x);
if (t[k * 2 + 1].dr < x && r > mid) modify(k * 2 + 1, max(l, mid + 1), r, x);
t[k].dl = t[k * 2].dl;
t[k].dr = t[k * 2 + 1].dr;
t[k].ans = min(t[k * 2].ans, t[k * 2 + 1].ans);
}
int find(int x) {
int l = 0, r = m, mid;
while (r - l > 1) {
mid = (r + l) >> 1;
if (d[mid] >= x)
r = mid;
else
l = mid;
}
return r;
}
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 + 1 + m);
m = unique(d + 1, d + 1 + m) - d - 1;
for (int i = 1; i <= n; i++) a[i] = find(a[i]);
for (int i = 1; i <= n; i++) b[i] = find(b[i]);
for (int i = 1; i <= n; i++) c[i] = find(c[i]);
for (int i = 1; i <= m; i++) fr1[i] = fr2[i] = fr3[i] = n * 3;
for (int i = 1; i <= n; i++)
if (fr1[a[i]] == n * 3) fr1[a[i]] = i;
for (int i = 1; i <= n; i++)
if (fr2[b[i]] == n * 3) fr2[b[i]] = i;
for (int i = 1; i <= n; i++)
if (fr3[c[i]] == n * 3) fr3[c[i]] = i;
for (int i = 1; i <= m; i++)
if (fr1[i] == 3 * n) s.insert(fr3[i]);
s.insert(0);
for (int i = 0; i <= n; i++) {
if (i && fr2[b[i]] == i && fr1[b[i]] == 3 * n) {
ii = s.find(fr3[b[i]]);
if (ii != s.end()) s.erase(ii);
}
ii = s.end();
ii--;
d[i] = *ii;
}
built(1, 0, n);
ans = t[1].ans + n;
for (int i = n; i; i--) {
if (fr1[a[i]] == i) modify(1, 0, min(n, fr2[a[i]] - 1), fr3[a[i]]);
ans = min(ans, i - 1 + t[1].ans);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
int n;
set<pair<int, int> > wyk;
multiset<int> M;
void Dodaj(int x, int wys) {
set<pair<int, int> >::iterator it = wyk.lower_bound(make_pair(x, -1));
int ost;
if (it == wyk.end())
ost = 2 * n - 1;
else {
if (it->first > x)
ost = it->first - 1;
else {
if (++it == wyk.end())
ost = 2 * n - 1;
else
ost = it->first - 1;
--it;
}
}
if (it == wyk.end() || it->first > x) --it;
if (wys <= it->second) return;
vector<pair<int, int> > usu;
while (it->second <= wys) {
usu.push_back(*it);
if (it == wyk.begin()) break;
--it;
}
for (int i = 0; i < usu.size(); ++i) {
wyk.erase(usu[i]);
M.erase(M.find(usu[i].first + usu[i].second));
}
wyk.insert(make_pair(usu.back().first, wys));
M.insert(usu.back().first + wys);
if (ost > x) {
wyk.insert(make_pair(x + 1, usu[0].second));
M.insert(x + 1 + usu[0].second);
}
}
int main() {
ios_base::sync_with_stdio(0);
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 (int i = 0; i < n; ++i) b.push_back(c[i]);
map<int, int> gdzieA, gdzieB, gdzieC;
for (int i = n - 1; i >= 0; --i) gdzieA[a[i]] = i;
for (int i = 2 * n - 1; i >= 0; --i) gdzieB[b[i]] = i;
for (int i = n - 1; i >= 0; --i) gdzieC[c[i]] = i;
vector<int> pos(2 * n - 1);
for (int i = 0; i < 2 * n; ++i) {
if (gdzieB[b[i]] != i)
pos[i] = 0;
else {
if (gdzieC.find(b[i]) == gdzieC.end())
pos[i] = INF;
else
pos[i] = gdzieC[b[i]] + 1;
}
}
wyk.insert(make_pair(0, 0));
M.insert(0);
for (int i = 0; i < 2 * n; ++i)
if (gdzieA.find(b[i]) == gdzieA.end() && gdzieB[b[i]] == i)
Dodaj(i, pos[i]);
int odp = n + *M.begin();
for (int i = n - 1; i >= 0; --i) {
if (gdzieA[a[i]] == i) {
if (gdzieB.find(a[i]) != gdzieB.end())
Dodaj(gdzieB[a[i]], pos[gdzieB[a[i]]]);
else
break;
}
odp = min(odp, i + *M.begin());
}
cout << odp;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l;
int a[(100005)], b[(100005)], c[(100005)];
int dc[(100005) * 3], ldc = 0, ll;
int A[(100005) * 3], B[(100005) * 3], C[(100005) * 3];
int idx[(100005) * 3];
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 * (100005);
for (int i = 0; i < l; i++)
if (A[a[i]] > (100005)) A[a[i]] = i + 1;
for (int i = 0; i < l; i++)
if (B[b[i]] > (100005)) B[b[i]] = i + 1;
for (int i = 0; i < l; i++)
if (C[c[i]] > (100005)) 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, (100005) * 10)),
st.insert(pair<int, int>((100005) * 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;
const int maxn = 300005;
struct pi {
int lazy;
int mi;
int mm;
int le, ri;
int ma = 0;
} pp[maxn << 2];
void build(int tot, int l, int r) {
pp[tot].le = l;
pp[tot].ri = r;
pp[tot].ma = 0;
pp[tot].mm = 0;
pp[tot].lazy = -1;
if (l == r) {
pp[tot].lazy = 0;
pp[tot].mi = l;
return;
}
int mid = (l + r) / 2;
build(2 * tot, l, mid);
build(2 * tot + 1, mid + 1, r);
pp[tot].mi = min(pp[2 * tot].mi, pp[2 * tot + 1].mi);
}
void update(int tot) { pp[tot].mi = pp[tot].lazy + pp[tot].le; }
void merg(int tot, int l, int r, int p) {
if (pp[tot].lazy >= p) return;
if (pp[tot].mm >= p) return;
if (l <= pp[tot].le && r >= pp[tot].ri) {
if (pp[tot].ma <= p) {
pp[tot].ma = p;
pp[tot].lazy = p;
pp[tot].mm = p;
pp[tot].mi = p + pp[tot].le;
return;
} else {
merg(2 * tot, l, r, p);
merg(2 * tot + 1, l, r, p);
}
} else {
if (pp[tot].lazy != -1) {
pp[2 * tot].lazy = pp[tot].lazy;
update(2 * tot);
pp[2 * tot + 1].lazy = pp[tot].lazy;
update(2 * tot + 1);
pp[tot].lazy = -1;
}
int mid = (pp[tot].le + pp[tot].ri) / 2;
if (l <= mid) merg(2 * tot, l, r, p);
if (r > mid) merg(2 * tot + 1, l, r, p);
}
pp[tot].mi = min(pp[2 * tot].mi, pp[2 * tot + 1].mi);
pp[tot].ma = max(pp[tot].ma, p);
pp[tot].mm = min(pp[2 * tot].mm, pp[2 * tot + 1].mm);
}
int a[maxn], b[maxn], c[maxn], d[maxn];
int ne[3][maxn];
set<int> ss;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
d[i] = a[i];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
d[n + i] = b[i];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
d[2 * n + i] = c[i];
}
sort(d + 1, d + 1 + 3 * n);
for (int i = 1; i <= n; i++) {
a[i] = lower_bound(d + 1, d + 3 * n + 1, a[i]) - d;
ss.insert(a[i]);
}
for (int i = 1; i <= n; i++) {
b[i] = lower_bound(d + 1, d + 3 * n + 1, b[i]) - d;
ss.insert(b[i]);
}
for (int i = 1; i <= n; i++) {
c[i] = lower_bound(d + 1, d + 3 * n + 1, c[i]) - d;
ss.insert(c[i]);
}
for (int i = 0; i < 3; i++) {
for (int j = 1; j <= 3 * n; j++) ne[i][j] = 3 * n + 1;
}
for (int i = n; i >= 1; i--) ne[0][a[i]] = i;
for (int i = n; i >= 1; i--) ne[1][b[i]] = i;
for (int i = n; i >= 1; i--) ne[2][c[i]] = i;
int ans = 3 * n;
build(1, 0, 3 * n + 1);
for (int i = 1; i <= 3 * n; i++) {
if (ss.find(i) == ss.end()) continue;
if (ne[0][i] > n) {
merg(1, 0, ne[1][i] - 1, ne[2][i]);
}
}
for (int i = n; i >= 1; i--) {
ans = min(ans, i + pp[1].mi);
if (ne[0][a[i]] == i) {
merg(1, 0, ne[1][a[i]] - 1, ne[2][a[i]]);
}
}
ans = min(ans, pp[1].mi);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T x) {
return x > 0 ? x : -x;
}
const int maxn = 100005;
const int inf = 1e9;
int n;
multiset<int> v;
set<pair<pair<int, int>, int> > s;
void add(int x, int val) { v.insert(n - min(n, x) + val); }
void remove(int x, int val) { v.erase(v.find(n - min(n, x) + val)); }
void addS(int l, int val) {
auto it = s.upper_bound(make_pair(make_pair(l, inf), -1));
if (it != s.begin()) {
it--;
if (it->second >= val)
return;
else {
if (it->first.first == l) {
remove(it->first.first, it->second);
remove(it->first.second, it->second);
s.erase(it);
add(l, val);
} else {
remove(it->first.second, it->second);
add(l - 1, it->second);
auto t = make_pair(make_pair(it->first.first, l - 1), it->second);
s.erase(it);
s.insert(t);
add(l, val);
}
}
} else
add(l, val);
int r = l;
while (true) {
auto it = s.upper_bound(make_pair(make_pair(l, -1), -1));
if (it == s.end()) {
r = n + 1;
break;
}
if (it->second >= val) {
r = it->first.first - 1;
break;
}
remove(it->first.first, it->second);
remove(it->first.second, it->second);
r = it->first.second;
s.erase(it);
}
add(r, val);
s.insert(make_pair(make_pair(l, r), val));
}
int a[3][maxn];
map<int, int> rev[3];
void print() {
cerr << endl;
for (auto x : s) {
cerr << x.first.first << " " << x.first.second << " " << x.second << endl;
}
cerr << endl;
}
int main(int argc, char *argv[]) {
scanf("%d", &n);
set<int> e;
for (int i = 0; i < 3; i++)
for (int j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
if (rev[i].find(a[i][j]) == rev[i].end()) rev[i][a[i][j]] = j;
e.insert(a[i][j]);
}
v.insert(0);
v.insert(n);
s.insert(make_pair(make_pair(0, n + 1), 0));
for (int x : e) {
if (rev[0].find(x) != rev[0].end()) continue;
if (rev[1].find(x) == rev[1].end()) {
addS(0, rev[2][x]);
} else {
int y;
if (rev[2].find(x) == rev[2].end())
y = inf;
else
y = rev[2][x];
addS(n + 1 - rev[1][x], y);
}
}
int ans = n + (*v.begin());
for (int i = n; i >= 1; i--) {
if (rev[0][a[0][i]] < i) {
ans = min(ans, i - 1 + (*v.begin()));
continue;
}
int x = a[0][i];
if (rev[1].find(x) == rev[1].end() && rev[2].find(x) == rev[2].end()) break;
if (rev[1].find(x) == rev[1].end()) {
addS(0, rev[2][x]);
} else {
int y;
if (rev[2].find(x) == rev[2].end())
y = inf;
else
y = rev[2][x];
addS(n + 1 - rev[1][x], y);
}
ans = min(ans, i - 1 + (*v.begin()));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 300010, inf = ~0U >> 2;
int N;
int A[3][MXN];
int sa[MXN], n = 0;
struct tri {
int c[3];
};
bool cmp(const tri& a, const tri& b) { return a.c[0] > b.c[0]; }
tri th[MXN];
void init() {
scanf("%d", &N);
for (int k = 0; k < 3; k++)
for (int i = 1; i <= N; i++) scanf("%d", &A[k][i]), sa[++n] = A[k][i];
sort(sa + 1, sa + n + 1);
n = unique(sa + 1, sa + n + 1) - sa - 1;
for (int i = 1; i <= n; i++)
for (int k = 0; k < 3; k++) th[i].c[k] = N * 3;
for (int k = 0; k < 3; k++)
for (int i = 1; i <= N; i++) {
static int x;
A[k][i] = x = lower_bound(sa + 1, sa + n + 1, A[k][i]) - sa;
th[x].c[k] = min(th[x].c[k], i);
}
}
namespace solve {
set<pair<int, int> > S;
multiset<int> Q;
int answer = inf;
void hi(int x, int y) { Q.insert(x + y); }
void bye(int x, int y) { Q.erase(Q.find(x + y)); }
void ins(int x, int y) {
set<pair<int, int> >::iterator s = S.lower_bound(pair<int, int>(x, y));
if (s->second >= y) return;
set<pair<int, int> >::iterator p = s, q = p--;
bye(p->first, q->second);
while (p->second <= y) {
if (p == S.begin()) {
cout << "ERROR" << endl;
return;
}
q = p--;
bye(p->first, q->second);
S.erase(q);
}
S.insert(pair<int, int>(x, y));
hi(p->first, y);
hi(x, s->second);
}
void solve() {
sort(th + 1, th + n + 1, cmp);
S.insert(pair<int, int>(0, inf));
S.insert(pair<int, int>(inf, 0));
hi(0, 0);
for (int i = 1; i <= n; i++) {
answer = min(answer, th[i].c[0] + *Q.begin());
int j = i;
while (j < n && th[j].c[0] == th[j + 1].c[0]) j++;
for (int k = i; k <= j; k++) ins(th[k].c[1], th[k].c[2]);
i = j;
}
answer = min(answer, *Q.begin());
printf("%d\n", answer);
}
} // namespace solve
int main() {
init();
solve::solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 100000000;
struct Point {
int x, y, z;
Point() { x = y = z = INF; }
} P[100005];
bool cmp(Point a, Point b) { return a.x < b.x; }
map<int, Point> MP;
set<pair<int, int> > S;
multiset<int> costs;
void insert(pair<int, int> a) {
S.insert(a);
costs.insert(a.first + a.second);
}
void remove(set<pair<int, int> >::iterator it) {
costs.erase(costs.find(it->first + it->second));
S.erase(it);
}
int main() {
int N, a, n = 0, ans = INF, minf = INF;
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%d", &a);
MP[a].x = min(MP[a].x, i);
}
for (int i = 1; i <= N; ++i) {
scanf("%d", &a);
MP[a].y = min(MP[a].y, i);
}
for (int i = 1; i <= N; ++i) {
scanf("%d", &a);
MP[a].z = min(MP[a].z, i);
}
for (auto i = MP.begin(); i != MP.end(); ++i) P[n++] = i->second;
sort(P, P + n, cmp);
insert(make_pair(0, 0));
for (int i = n - 1; i >= 0; --i) {
ans = min(ans, P[i].x + *costs.begin());
auto it = S.lower_bound(make_pair(P[i].y, 0));
--it;
int maxv = it->second, start = -1;
while (it->second <= P[i].z) {
start = it->first;
if (it == S.begin()) {
remove(it);
break;
}
remove(it--);
}
if (start != -1) {
insert(make_pair(start, P[i].z));
if (P[i].y != INF) {
insert(make_pair(P[i].y, maxv));
}
}
}
ans = min(ans, *costs.begin());
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > tr;
multiset<int> an;
int a[300005], b[300005], c[300005], fira[300005], firb[300005], firc[300005],
n, bin[300005], id[300005], m = 0;
int cmp(int x, int y) { return fira[x] > fira[y]; }
void ins(pair<int, int> u) {
set<pair<int, int> >::iterator l, i, r = tr.lower_bound(u);
if (r->second >= u.second) return;
i = tr.insert(u).first;
l = i;
l--;
an.erase(an.lower_bound(l->first + r->second));
an.insert(i->first + r->second);
while (l->second < i->second) {
r = l--;
an.erase(an.lower_bound(l->first + r->second));
tr.erase(r);
}
an.insert(l->first + i->second);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]), bin[m++] = a[i];
for (int i = 0; i < n; i++) scanf("%d", &b[i]), bin[m++] = b[i];
for (int i = 0; i < n; i++) scanf("%d", &c[i]), bin[m++] = c[i];
sort(bin, bin + m);
m = unique(bin, bin + m) - bin;
for (int i = 0; i < n; i++) {
a[i] = lower_bound(bin, bin + m, a[i]) - bin;
b[i] = lower_bound(bin, bin + m, b[i]) - bin;
c[i] = lower_bound(bin, bin + m, c[i]) - bin;
if (!fira[a[i]]) fira[a[i]] = i + 1;
if (!firb[b[i]]) firb[b[i]] = i + 1;
if (!firc[c[i]]) firc[c[i]] = i + 1;
}
for (int i = 0; i < m; i++) {
if (!fira[i]) fira[i] = 5 * n;
if (!firb[i]) firb[i] = 5 * n;
if (!firc[i]) firc[i] = 5 * n;
}
for (int i = 0; i <= m; i++) id[i] = i;
fira[m] = 0;
sort(id, id + m, cmp);
an.insert(0);
int ans = fira[*id];
tr.insert(make_pair(7 * n, 0));
tr.insert(make_pair(0, 7 * n));
for (int i = 0; i < m; i++) {
ins(make_pair(firb[id[i]], firc[id[i]]));
ans = min(ans, fira[id[i + 1]] + *an.begin());
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int type;
struct bg {
int l, k, id;
friend bool operator<(const bg& a, const bg& b) {
return a.k > b.k || a.k == b.k && a.l < b.l;
}
};
set<bg> S;
priority_queue<pair<int, int> > Q;
int pos[3][110000 * 3], p[110000 * 3], a[110000], b[110000], c[110000], cnt,
ans, tot, i, j, n;
bool flag[110000 * 24];
bg mk(int l, int k, int id) {
bg res = {l, k, id};
return res;
}
int Find(int x) { return lower_bound(p + 1, p + tot + 1, x) - p; }
void add(int x, int y) {
set<bg>::iterator t = S.lower_bound(mk(-1, y, -1)), t1, t2;
if (t == S.end() || x < t->l) return;
int l = t->l, tmp;
t1 = t;
for (;;) {
t2 = t1;
t2++;
if (t2 == S.end())
tmp = 1e9;
else
tmp = (t2->l) - 1;
if (x >= tmp) {
flag[t1->id] = 1;
S.erase(t1);
t1 = t2;
} else {
flag[t1->id] = 1;
bg res1 = {l, y, ++cnt}, res2 = {x + 1, t1->k, ++cnt};
S.erase(t1);
S.insert(res1);
S.insert(res2);
Q.push(make_pair(-res1.l - res1.k, res1.id));
Q.push(make_pair(-res2.l - res2.k, res2.id));
return;
}
}
}
void init() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", &a[i]), p[++tot] = a[i];
for (i = 1; i <= n; ++i) scanf("%d", &b[i]), p[++tot] = b[i];
for (i = 1; i <= n; ++i) scanf("%d", &c[i]), p[++tot] = c[i];
sort(p + 1, p + tot + 1);
tot = unique(p + 1, p + tot + 1) - p - 1;
for (i = 1; i <= n; ++i) {
a[i] = Find(a[i]);
b[i] = Find(b[i]);
c[i] = Find(c[i]);
}
memset(pos, 3, sizeof(pos));
for (i = n; i >= 1; --i) {
pos[0][a[i]] = i;
pos[1][b[i]] = i;
pos[2][c[i]] = i;
}
}
int main() {
init();
S.insert(mk(0, 0, ++cnt));
Q.push(make_pair(0, cnt));
for (i = 1; i <= tot; ++i)
if (pos[0][i] > 1e6) add(pos[1][i] - 1, pos[2][i]);
while (flag[Q.top().second]) Q.pop();
ans = -Q.top().first + n;
for (i = n; i >= 1; --i) {
if (pos[0][a[i]] == i) {
add(pos[1][a[i]] - 1, pos[2][a[i]]);
}
while (flag[Q.top().second]) Q.pop();
ans = min(ans, i - 1 - Q.top().first);
}
printf("%d\n", ans);
}
|
#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.lower_bound(l->first + r->second)),
res.insert(i->first + r->second);
while (l->second < i->second)
r = l--, res.erase(res.lower_bound(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;
template <class T, class T2>
inline void chkmax(T &x, const T2 &y) {
if (x < y) x = y;
}
template <class T, class T2>
inline void chkmin(T &x, const T2 &y) {
if (x > y) x = y;
}
const int MAXN = (1 << 20);
const int inf = (int)1e9 + 17;
struct node {
int lazy, mx, ans;
node() {
ans = inf;
mx = 0;
lazy = 0;
}
node(int val, int _ans) {
mx = val;
ans = _ans;
lazy = 0;
}
};
node temp, broken;
node merge(node l, node r) {
temp.mx = max(l.mx, r.mx);
temp.ans = min(l.ans, r.ans);
temp.lazy = 0;
return temp;
}
struct segment_tree {
node tr[4 * MAXN];
void push(int l, int r, int idx) {
if (tr[idx].lazy) {
tr[idx].mx = max(tr[idx].mx, tr[idx].lazy);
tr[idx].ans = tr[idx].mx + l;
if (l != r) {
chkmax(tr[2 * idx + 1].lazy, tr[idx].lazy);
chkmax(tr[2 * idx + 2].lazy, tr[idx].lazy);
}
tr[idx].lazy = 0;
}
}
void init(int l, int r, int idx) {
if (l == r) {
tr[idx] = node(0, l);
return;
}
int mid = (l + r) >> 1;
init(l, mid, 2 * idx + 1);
init(mid + 1, r, 2 * idx + 2);
tr[idx] = merge(tr[2 * idx + 1], tr[2 * idx + 2]);
}
void update(int qL, int qR, int val, int l, int r, int idx) {
push(l, r, idx);
if (qL > r || l > qR) return;
if (qL <= l && r <= qR) {
tr[idx].lazy = val;
push(l, r, idx);
return;
}
int mid = (l + r) >> 1;
update(qL, qR, val, l, mid, 2 * idx + 1);
update(qL, qR, val, mid + 1, r, 2 * idx + 2);
tr[idx] = merge(tr[2 * idx + 1], tr[2 * idx + 2]);
}
node query(int qL, int qR, int l, int r, int idx) {
push(l, r, idx);
if (l > qR || r < qL) return broken;
if (qL <= l && r <= qR) return tr[idx];
int mid = (l + r) >> 1;
return merge(query(qL, qR, l, mid, 2 * idx + 1),
query(qL, qR, mid + 1, r, 2 * idx + 2));
}
};
int n;
int a[MAXN];
int b[MAXN];
int c[MAXN];
void read() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int j = 0; j < n; j++) cin >> b[j];
for (int k = 0; k < n; k++) cin >> c[k];
}
segment_tree t;
int fa[MAXN], fb[MAXN], fc[MAXN];
int cnt[MAXN];
void add(int x) {
if (fc[x] == 0) {
t.update(0, fb[x] - 1, inf, 0, n, 0);
return;
}
int low = 0, high = -1 + ((fb[x] == 0) ? n + 1 : fb[x]), mid, ret = -1;
while (low <= high) {
mid = (low + high) >> 1;
if (t.query(mid, mid, 0, n, 0).mx < fc[x])
ret = mid, high = mid - 1;
else
low = mid + 1;
}
if (ret == -1) return;
int up = -1 + ((fb[x] == 0) ? n + 1 : fb[x]);
if (ret <= up) t.update(ret, up, fc[x], 0, n, 0);
}
int query() { return t.query(0, n, 0, n, 0).ans; }
void solve() {
vector<int> li_all;
for (int i = 0; i < n; i++) li_all.push_back(a[i]);
for (int i = 0; i < n; i++) li_all.push_back(b[i]);
for (int i = 0; i < n; i++) li_all.push_back(c[i]);
sort(li_all.begin(), li_all.end());
li_all.erase(unique(li_all.begin(), li_all.end()), li_all.end());
for (int i = 0; i < n; i++)
a[i] = lower_bound(li_all.begin(), li_all.end(), a[i]) - li_all.begin();
for (int i = 0; i < n; i++)
b[i] = lower_bound(li_all.begin(), li_all.end(), b[i]) - li_all.begin();
for (int i = 0; i < n; i++)
c[i] = lower_bound(li_all.begin(), li_all.end(), c[i]) - li_all.begin();
for (int i = n - 1; i >= 0; i--) a[i + 1] = a[i];
for (int i = n - 1; i >= 0; i--) b[i + 1] = b[i];
for (int i = n - 1; i >= 0; i--) c[i + 1] = c[i];
for (int i = n; i >= 1; i--) fa[a[i]] = i, fb[b[i]] = i, fc[c[i]] = i;
for (int i = 1; i <= n; i++) cnt[a[i]]++;
t.init(0, n, 0);
for (int l = 0; l < (int)li_all.size(); l++)
if (cnt[l] == 0) add(l);
int answer = query() + n;
for (int i = n; i >= 1; i--) {
cnt[a[i]]--;
if (cnt[a[i]] == 0 && fb[a[i]] == 0 && fc[a[i]] == 0) break;
if (cnt[a[i]] == 0) add(a[i]);
chkmin(answer, i + query() - 1);
}
cout << answer << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10, INF = N * 3 + 1;
int a[N], b[N], c[N], id[N * 3], L = 0;
int find(int x) {
int l = 0, r = L;
while (l + 1 < r) {
int mid = (l + r) >> 1;
if (id[mid] >= x)
r = mid;
else
l = mid;
}
return r;
}
int n;
pair<int, int> poi[N * 3];
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), id[++L] = a[i];
for (int i = 1; i <= n; i++) scanf("%d", &b[i]), id[++L] = b[i];
for (int i = 1; i <= n; i++) scanf("%d", &c[i]), id[++L] = c[i];
sort(id + 1, id + L + 1);
L = unique(id + 1, id + L + 1) - (id + 1);
for (int i = 1; i <= n; i++) a[i] = find(a[i]);
for (int i = 1; i <= n; i++) b[i] = find(b[i]);
for (int i = 1; i <= n; i++) c[i] = find(c[i]);
for (int i = 1; i <= L; i++) poi[i] = make_pair(INF, INF);
for (int i = 1; i <= n; i++)
if (poi[b[i]].first == INF) poi[b[i]].first = i;
for (int i = 1; i <= n; i++)
if (poi[c[i]].second == INF) poi[c[i]].second = i;
}
int vis[N * 3], ans = INF * 3;
set<pair<int, int> > s;
priority_queue<pair<int, int> > ds;
int lf[N], rg[N], del[N * 7], L1 = 0;
void print() {
for (set<pair<int, int> >::iterator it = s.begin(); it != s.end(); it++)
cout << (*it).first << ' ' << (*it).second << endl;
cout << endl;
}
void add(pair<int, int> a) {
set<pair<int, int> >::iterator it = s.insert(a).first, r = it, l = it;
r++, l--;
if ((*r).second >= a.second) {
s.erase(a);
return;
}
while ((*l).second <= a.second) {
del[rg[(*l).first]] = 1, del[lf[(*l).first]] = 1;
s.erase(l);
l = it, l--;
}
del[rg[(*l).first]] = 1;
rg[(*l).first] = lf[a.first] = ++L1;
ds.push(make_pair(-((*l).first + a.second), L1));
del[lf[(*r).first]] = 1;
rg[a.first] = lf[(*r).first] = ++L1;
ds.push(make_pair(-(a.first + (*r).second), L1));
}
void calc(int i) {
while ((!ds.empty()) && del[(ds.top()).second]) ds.pop();
if (ds.empty()) {
ans = ((ans) < (i) ? (ans) : (i));
return;
}
pair<int, int> t = ds.top();
ans = ((ans) < (-t.first + i) ? (ans) : (-t.first + i));
}
void work() {
for (int i = 1; i <= L; i++) vis[i] = 0;
for (int i = 1; i <= n; i++) vis[a[i]] = 1;
s.clear();
s.insert(make_pair(0, INF + 1)), s.insert(make_pair(INF + 1, 0));
for (int i = 1; i <= L; i++)
if (!vis[i]) add(poi[i]);
for (int i = 1; i <= L; i++) vis[i] = 0;
for (int i = 1; i <= n; i++)
if (!vis[a[i]]) vis[a[i]] = i;
for (int i = n; i >= 1; i--)
if (vis[a[i]] == i) {
calc(i);
add(poi[a[i]]);
}
calc(0);
}
int main() {
init();
work();
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAXN = (int)1e5 + 3;
const int MAXK = (int)3e5 + 3;
const int infint = (int)1e9 + 3;
const long long inf = (long long)1e12;
int a[MAXN], b[MAXN], c[MAXN], n, fir[MAXK], sec[MAXK], thir[MAXK], sz,
mn[MAXN << 2], mx[MAXN << 2], ans[MAXN << 2], lazy[MAXN << 2];
int rev(int idx) {
if (idx == n + 1) return 3 * n + 1;
return idx;
}
int f(int idx) {
if (idx == 3 * n + 1) return n + 1;
return idx;
}
void build(int node, int st, int en) {
ans[node] = rev(st);
if (en - st < 2) return;
int mid = (st + en) >> 1;
build(node << 1, st, mid);
build(node << 1 | 1, mid, en);
}
void upd(int node, int st, int en, int x) {
mn[node] = mx[node] = x;
ans[node] = x + rev(st);
lazy[node] = x;
return;
}
void shift(int node, int st, int en) {
int mid = (st + en) >> 1;
if (lazy[node] == 0) return;
upd(node << 1, st, mid, lazy[node]);
upd(node << 1 | 1, mid, en, lazy[node]);
lazy[node] = 0;
}
void update(int node, int st, int en, int l, int r, int x) {
if (l >= en || st >= r || mn[node] >= x) return;
if (l <= st && en <= r && mx[node] <= x) {
upd(node, st, en, x);
return;
}
int mid = (st + en) >> 1;
shift(node, st, en);
update(node << 1, st, mid, l, r, x);
update(node << 1 | 1, mid, en, l, r, x);
mn[node] = min(mn[node << 1], mn[node << 1 | 1]);
mx[node] = max(mx[node << 1], mx[node << 1 | 1]);
ans[node] = min(ans[node << 1], ans[node << 1 | 1]);
}
bool cmp(int u, int v) { return fir[u] < fir[v]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) cin >> c[i];
vector<int> v;
for (int i = 1; i <= n; i++)
v.push_back(a[i]), v.push_back(b[i]), v.push_back(c[i]);
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
sz = v.size();
for (int i = 1; i <= n; i++)
a[i] = lower_bound(v.begin(), v.end(), a[i]) - v.begin();
for (int i = 1; i <= n; i++)
b[i] = lower_bound(v.begin(), v.end(), b[i]) - v.begin();
for (int i = 1; i <= n; i++)
c[i] = lower_bound(v.begin(), v.end(), c[i]) - v.begin();
for (int i = 0; i < sz; i++)
fir[i] = 3 * n + 1, sec[i] = 3 * n + 1, thir[i] = 3 * n + 1;
for (int i = n; i >= 1; i--) fir[a[i]] = i;
for (int i = n; i >= 1; i--) sec[b[i]] = i;
for (int i = n; i >= 1; i--) thir[c[i]] = i;
v.clear();
for (int i = 0; i < sz; i++) v.push_back(i);
sort(v.begin(), v.end(), cmp);
build(1, 0, n + 2);
int cnt = fir[v.back()];
for (int i = sz - 1; i >= 0; i--) {
int idx = v[i], cur = 0;
update(1, 0, n + 2, 0, f(sec[idx]), thir[idx]);
if (i) cur = fir[v[i - 1]];
cnt = min(cnt, ans[1] + cur);
}
cout << cnt;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
vector<T>& operator--(vector<T>& v) {
for (auto& i : v) --i;
return v;
}
template <typename T>
vector<T>& operator++(vector<T>& v) {
for (auto& i : v) ++i;
return v;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& i : v) is >> i;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (auto& i : v) os << i << ' ';
return os;
}
template <typename T, typename U>
istream& operator>>(istream& is, pair<T, U>& p) {
is >> p.first >> p.second;
return is;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, pair<T, U>& p) {
os << p.first << ' ' << p.second;
return os;
}
template <typename T, typename U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return make_pair(a.first - b.first, a.second - b.second);
}
template <typename T, typename U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return make_pair(a.first + b.first, a.second + b.second);
}
template <typename T, typename U>
void umin(T& a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
void umax(T& a, U b) {
if (a < b) a = b;
}
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);
cin >> a >> b >> c;
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) {
42;
;
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();
42;
;
42;
;
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});
}
42;
;
42;
;
ans = min(ans, i + *res.begin());
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, A1[200005], A2[200005], A3[200005], tot, B[3 * 200005];
;
void _read(int &x) {
x = 0;
char ch = getchar();
bool flag = false;
while (ch < '0' || ch > '9') {
if (ch == '-') flag = true;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
if (flag) x = -x;
return;
}
struct data {
int x, y, z;
} A[3 * 200005];
bool cmp1(data a, data b) { return a.z > b.z; }
int LAST[3 * 200005];
void Init() {
_read(N);
tot = 0;
for (int i = 1; i <= N; i++) _read(A1[i]), B[++tot] = A1[i];
for (int i = 1; i <= N; i++) _read(A2[i]), B[++tot] = A2[i];
for (int i = 1; i <= N; i++) _read(A3[i]), B[++tot] = A3[i];
sort(B + 1, B + 1 + tot);
tot = unique(B + 1, B + 1 + tot) - B - 1;
for (int i = 1; i <= N; i++) {
A1[i] = lower_bound(B + 1, B + 1 + tot, A1[i]) - B;
A2[i] = lower_bound(B + 1, B + 1 + tot, A2[i]) - B;
A3[i] = lower_bound(B + 1, B + 1 + tot, A3[i]) - B;
}
for (int i = 1; i <= tot; i++) A[i].x = A[i].y = A[i].z = 3 * N + 1;
for (int i = N; i >= 1; i--) {
A[A1[i]].x = i;
A[A2[i]].y = i;
A[A3[i]].z = i;
}
sort(A + 1, A + 1 + tot, cmp1);
return;
}
struct sta {
int x, y;
} miny[200005 * 10], maxy[200005 * 10];
int chi_1[200005 * 20][2], np1, rt1;
void pushup_1(int now) {
int lc = chi_1[now][0], rc = chi_1[now][1];
miny[now] = (miny[lc].y < miny[rc].y) ? miny[lc] : miny[rc];
maxy[now] = (maxy[lc].y > maxy[rc].y) ? maxy[lc] : maxy[rc];
return;
}
void build_1(int &now, int L, int R) {
now = ++np1;
if (L == R) {
miny[now] = (sta){L, 2000000001};
maxy[now] = (sta){L, -2000000001};
return;
}
int mid = (L + R) >> 1;
build_1(chi_1[now][0], L, mid);
build_1(chi_1[now][1], mid + 1, R);
pushup_1(now);
return;
}
void update_1(int now, int L, int R, int x, int y) {
if (L == R) {
if (y != -1)
miny[now] = maxy[now] = (sta){x, y};
else {
miny[now] = (sta){x, 2000000001};
maxy[now] = (sta){x, -2000000001};
}
return;
}
int mid = (L + R) >> 1;
if (x <= mid)
update_1(chi_1[now][0], L, mid, x, y);
else
update_1(chi_1[now][1], mid + 1, R, x, y);
pushup_1(now);
return;
}
sta Findmin(int now, int L, int R, int x, int y) {
if (x <= L && R <= y) {
return miny[now];
}
int mid = (L + R) >> 1;
if (y <= mid)
return Findmin(chi_1[now][0], L, mid, x, y);
else if (x > mid)
return Findmin(chi_1[now][1], mid + 1, R, x, y);
else {
sta t1 = Findmin(chi_1[now][0], L, mid, x, y),
t2 = Findmin(chi_1[now][1], mid + 1, R, x, y);
if (t1.y >= t2.y)
return t2;
else
return t1;
}
}
sta Findmax(int now, int L, int R, int x, int y) {
if (x <= L && R <= y) {
return maxy[now];
}
int mid = (L + R) >> 1;
if (y <= mid)
return Findmax(chi_1[now][0], L, mid, x, y);
else if (x > mid)
return Findmax(chi_1[now][1], mid + 1, R, x, y);
else {
sta t1 = Findmax(chi_1[now][0], L, mid, x, y),
t2 = Findmax(chi_1[now][1], mid + 1, R, x, y);
if (t1.y <= t2.y)
return t2;
else
return t1;
}
}
int np2, rt2, chi_2[200005 * 10][2], minsum[200005 * 10];
void build_2(int &now, int L, int R) {
now = ++np2;
if (L == R) {
minsum[now] = 2000000001;
return;
}
int mid = (L + R) >> 1;
build_2(chi_2[now][0], L, mid);
build_2(chi_2[now][1], mid + 1, R);
minsum[now] = min(minsum[chi_2[now][0]], minsum[chi_2[now][1]]);
return;
}
void update_2(int now, int L, int R, int x, int y) {
if (L == R) {
minsum[now] = x + y;
return;
}
int mid = (L + R) >> 1;
if (x <= mid)
update_2(chi_2[now][0], L, mid, x, y);
else
update_2(chi_2[now][1], mid + 1, R, x, y);
minsum[now] = min(minsum[chi_2[now][0]], minsum[chi_2[now][1]]);
return;
}
void _ready() {
np1 = np2 = 0;
build_1(rt1, 0, 3 * N + 2);
update_1(rt1, 0, 3 * N + 2, 0, 3 * N + 2);
update_1(rt1, 0, 3 * N + 2, 3 * N + 2, 0);
build_2(rt2, 0, 3 * N + 2);
update_2(rt2, 0, 3 * N + 2, 0, 0);
return;
}
void In(int x, int y) {
sta tmp1, tmp2, tmp3;
tmp1 = Findmax(rt1, 0, 3 * N + 2, x, 3 * N + 2);
if (tmp1.y >= y) return;
tmp1 = Findmin(rt1, 0, 3 * N + 2, 0, x);
while (tmp1.y <= y && tmp1.y < 2000000001) {
update_1(rt1, 0, 3 * N + 2, tmp1.x, -1);
tmp2.y = 2000000001;
tmp2 = Findmin(rt1, 0, 3 * N + 2, 0, tmp1.x - 1);
update_2(rt2, 0, 3 * N + 2, tmp2.x, 2000000001);
tmp3.y = -2000000001;
tmp3 = Findmax(rt1, 0, 3 * N + 2, tmp1.x + 1, 3 * N + 2);
update_2(rt2, 0, 3 * N + 2, tmp1.x, 2000000001);
tmp1 = Findmin(rt1, 0, 3 * N + 2, 0, x);
}
tmp2 = Findmin(rt1, 0, 3 * N + 2, 0, x - 1);
tmp3 = Findmax(rt1, 0, 3 * N + 2, x + 1, 3 * N + 2);
update_2(rt2, 0, 3 * N + 2, tmp2.x, y);
update_2(rt2, 0, 3 * N + 2, x, tmp3.y);
update_1(rt1, 0, 3 * N + 2, x, y);
return;
}
void work() {
_ready();
int ni = 1, ans = 3 * N;
for (int i = N + 1; i >= 0; i--) {
while (A[ni].z > i && ni <= tot) {
In(A[ni].x, A[ni].y);
ni++;
}
ans = min(ans, i + minsum[rt2]);
}
printf("%d\n", ans);
return;
}
int main() {
Init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 6e5 + 21, inf = 1e7 + 21;
int n, sz;
int A[MAXN], B[MAXN], C[MAXN], a[MAXN], b[MAXN], c[MAXN];
int dp[MAXN], cnt[MAXN];
int bw[MAXN << 2], lazy[MAXN << 2];
struct node {
int ans, mn, mx;
node(int a = 0, int b = 0, int c = 0) { mn = a, mx = b, ans = c; }
} seg[MAXN << 2];
inline node MRG(node a, node b) {
return node(min(a.mn, b.mn), max(a.mx, b.mx), min(a.ans, b.ans));
}
inline void relax(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;
relax(lazy[id], id << 1, st);
relax(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] = MRG(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 relax(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] = MRG(seg[id << 1], seg[id << 1 | 1]);
}
inline void pre() {
int cur = 0;
sort(bw, bw + sz);
sz = unique(bw, bw + sz) - bw;
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(bw, bw + sz, a[i]) - bw;
b[i] = lower_bound(bw, bw + sz, b[i]) - bw;
c[i] = lower_bound(bw, bw + sz, c[i]) - bw;
A[a[i]] = i;
B[b[i]] = i;
C[c[i]] = i;
}
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--]]--;
if (cur < sz)
dp[i] = 3 * n;
else
dp[i] = p;
}
build();
return;
}
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];
bw[sz++] = a[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
bw[sz++] = b[i];
}
for (int i = 1; i <= n; i++) {
cin >> c[i];
bw[sz++] = c[i];
}
pre();
int ans = n + seg[1].ans;
for (int i = n; i > 0; i--) {
if (A[a[i]] == i) {
update(0, B[a[i]], C[a[i]]);
}
ans = min(ans, i + seg[1].ans - 1);
}
cout << ans;
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] = 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;
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;
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 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n;
long long a[3][200000];
set<int> w[3];
long long f[3][200000];
map<int, int> inv[3];
set<pair<int, int> > gset;
multiset<int> sum;
int graph[200000];
pair<int, int> q[200000];
int qi;
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 0; i < 3; i++) {
for (j = 0; j < n; j++) scanf("%I64d", &a[i][j]);
}
for (i = 0; i < 3; i++) {
for (j = 0; j < n; j++) {
if (!w[i].count(a[i][j])) {
w[i].insert(a[i][j]);
f[i][j] = 1;
inv[i][a[i][j]] = j;
}
}
}
int start = 0;
for (i = n - 1; i >= 0; i--) {
if (f[2][i] == 0) continue;
if (w[0].count(a[2][i]) || w[1].count(a[2][i])) continue;
start = i + 1;
break;
}
graph[n] = start;
for (i = n - 1; i >= 0; i--) {
start = graph[i + 1];
if (graph[i + 1] == 1000000) {
graph[i] = graph[i + 1];
continue;
}
if (f[1][i] == 0 || inv[0].count(a[1][i])) {
graph[i] = graph[i + 1];
} else {
if (!inv[2].count(a[1][i])) {
graph[i] = 1000000;
} else {
if (inv[2][a[1][i]] <= start - 1) {
graph[i] = graph[i + 1];
} else
graph[i] = inv[2][a[1][i]] + 1;
}
}
}
for (i = 0; i <= n; i++) {
if (graph[i] != graph[i + 1] || i == n) {
gset.insert(pair<int, int>(i, graph[i]));
}
}
gset.insert(pair<int, int>(-1, 1000000));
for (auto it : gset) {
set<pair<int, int> >::iterator z =
gset.upper_bound(pair<int, int>(it.first, 1000000));
if (z == gset.end()) break;
sum.insert(it.first + 1 + z->second);
}
int minn = *sum.begin() + n;
for (i = n - 1; i >= 0; i--) {
if (f[0][i] == 0) {
if (minn > *sum.begin() + i) {
minn = *sum.begin() + i;
}
continue;
}
int x, y;
if (!inv[1].count(a[0][i]))
x = n + 1;
else
x = inv[1][a[0][i]] + 1;
if (!inv[2].count(a[0][i]))
y = 1000000;
else
y = inv[2][a[0][i]] + 1;
x--;
set<pair<int, int> >::iterator z = gset.lower_bound(pair<int, int>(x, -1));
if (z != gset.end() && z->second >= y) {
if (minn > *sum.begin() + i) {
minn = *sum.begin() + i;
}
continue;
}
z = gset.lower_bound(pair<int, int>(x + 1, -1));
z--;
qi = 0;
while (1) {
set<pair<int, int> >::iterator u =
gset.upper_bound(pair<int, int>(z->first, 1000000));
if (u != gset.end()) sum.erase(sum.find(z->first + 1 + u->second));
if (z->second >= y) break;
q[qi++] = *z;
if (z == gset.begin()) break;
z--;
}
for (j = 0; j < qi; j++) gset.erase(q[j]);
set<pair<int, int> >::iterator u;
gset.insert(pair<int, int>(x, y));
z = gset.find(pair<int, int>(x, y));
u = gset.upper_bound(pair<int, int>(z->first, 1000000));
if (u != gset.end()) sum.insert(z->first + 1 + u->second);
z = gset.lower_bound(pair<int, int>(x, -1));
if (z != gset.begin()) {
z--;
u = gset.upper_bound(pair<int, int>(z->first, 1000000));
if (u != gset.end()) sum.insert(z->first + 1 + u->second);
}
if (x == 1000000 && y == 1000000) break;
if (minn > *sum.begin() + i) {
minn = *sum.begin() + i;
}
}
printf("%d", minn);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int xx[4] = {0, 0, 1, -1};
int yy[4] = {1, -1, 0, 0};
int n, m;
int a[int(1048576 + 2000)], b[int(1048576 + 2000)];
long long f[30][2];
long long res = 0;
void build(int l, int r, int h) {
if (l == r) return;
int mid = (l + r) / 2;
build(l, mid, h + 1);
build(mid + 1, r, h + 1);
int i = l;
int j = mid + 1;
int k = l;
while (i <= mid && j <= r) {
if (a[i] <= a[j]) {
b[k] = a[i];
i++;
f[h][1] += j - (mid + 1);
} else {
b[k] = a[j];
j++;
f[h][0] += (i - l);
}
k++;
}
while (i <= mid) {
b[k] = a[i];
i++;
k++;
f[h][1] += r - mid;
}
while (j <= r) {
b[k] = a[j];
j++;
k++;
f[h][0] += (mid - l + 1);
}
j = mid;
int d = 0;
for (int i = (l), _b = (mid); i <= _b; i++) {
if (i == l || a[i] != a[i - 1]) d = 0;
while (j + 1 <= r && a[j + 1] <= a[i]) {
j++;
if (a[j] == a[i]) d++;
}
f[h][0] -= d;
}
for (int i = (l), _b = (r); i <= _b; i++) a[i] = b[i];
}
void solve(int x) {
for (int i = (x), _b = (n); i <= _b; i++) {
res -= f[i][1];
swap(f[i][1], f[i][0]);
res += f[i][1];
}
printf("%I64d\n", res);
}
int main() {
scanf("%d", &n);
m = (1 << n);
for (int i = (1), _b = (m); i <= _b; i++) scanf("%d", &a[i]);
build(1, m, 0);
for (int i = (0), _b = (n); i <= _b; i++) res += f[i][1];
int q;
scanf("%d", &q);
for (int i = (1), _b = (q); i <= _b; i++) {
int x;
scanf("%d", &x);
solve(n - x);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long lrinv[21];
long long rlinv[21];
int n;
int a[1 << 20];
int b[1 << 20];
void mergesort() {
for (int k = 1; k <= n; k++) {
int len = 1 << (k - 1);
for (int j = 0; j < (1 << n); j += 2 * len) {
int l = 0, r = 0;
int sl = j, sr = j + len;
for (int i = 0; i < 2 * len; i++) {
if (r == len || (l != len && a[sl + l] <= a[sr + r])) {
b[i] = a[sl + (l++)];
lrinv[k] += r;
} else {
b[i] = a[sr + (r++)];
}
}
l = r = 0;
for (int i = 0; i < 2 * len; i++) {
if (l == len || (r != len && a[sr + r] <= a[sl + l])) {
r++;
rlinv[k] += l;
} else {
l++;
}
}
memcpy(a + j, b, sizeof(int) * (2 * len));
}
}
}
bool status[21];
long long cans = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
scanf("%d", &n);
for (int i = 0; i < (int)(1 << n); i++) scanf("%d", a + i);
mergesort();
for (int i = 0; i < (int)(n + 1); i++) cans += lrinv[i];
int m;
scanf("%d", &m);
for (int _ = 0; _ < (int)(m); _++) {
int q;
scanf("%d", &q);
for (int i = 0; i <= q; i++) {
if (!status[i]) {
cans -= lrinv[i];
cans += rlinv[i];
} else {
cans -= rlinv[i];
cans += lrinv[i];
}
status[i] = !status[i];
}
printf("%lld\n", cans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 21;
int a[N];
long long cont[22][2];
void merge_sort(int l, int r, int dep) {
if (l >= r) return;
int m = (l + r) >> 1;
merge_sort(l, m, dep - 1);
merge_sort(m + 1, r, dep - 1);
for (int i = l; i <= m; i++) {
cont[dep][0] += (lower_bound(a + m + 1, a + r + 1, a[i]) - (a + m + 1));
cont[dep][1] +=
r - m - (upper_bound(a + m + 1, a + r + 1, a[i]) - (a + m + 1));
}
sort(a + l, a + r + 1);
}
int main() {
int n;
while (cin >> n) {
for (int i = 1; i <= (1 << n); i++) cin >> a[i];
memset(cont, 0, sizeof(cont));
merge_sort(1, (1 << n), n);
int m;
cin >> m;
while (m--) {
int q;
cin >> q;
for (int i = 1; i <= q; i++) swap(cont[i][0], cont[i][1]);
long long res = 0;
for (int i = 1; i <= n; i++) res += cont[i][0];
cout << res << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[1 << 20], temp[1 << 20];
pair<long long, long long> p[21];
int c;
long long tt;
void mergesort(int a[], int first, int last, int ind) {
if (first >= last) return;
int middle = (first + last) / 2;
mergesort(a, first, middle, ind - 1);
mergesort(a, middle + 1, last, ind - 1);
c = 0;
int i, j, k;
tt = 1 << (ind - 1);
tt = tt * tt;
p[ind].first = p[ind].first + tt;
for (i = first, j = first, k = middle + 1; i <= last; i++) {
if (j == middle + 1) {
temp[i] = a[k++];
p[ind].first -= c;
if (k <= last && a[k] != a[k - 1]) {
c = 0;
}
} else if (k == last + 1) {
temp[i] = a[j++];
} else if (a[j] > a[k]) {
temp[i] = a[k++];
p[ind].first = p[ind].first - c;
p[ind].second = p[ind].second + (middle - j + 1);
if (k <= last && a[k] != a[k - 1]) {
c = 0;
}
} else {
if (a[j] == a[k]) c++;
temp[i] = a[j++];
}
}
for (i = first; i <= last; i++) {
a[i] = temp[i];
}
}
long long inversions(int current, int n) {
long long ans = 0;
int i;
for (i = 0; i <= n; i++) {
if (i <= current) p[i].second = p[i].first - p[i].second;
ans = ans + p[i].second;
}
return ans;
}
int main() {
int n, N, i, q, m;
long long ans;
scanf("%d", &n);
N = 1 << n;
for (i = 0; i < N; i++) {
scanf("%d", &arr[i]);
}
mergesort(arr, 0, N - 1, n);
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d", &q);
ans = inversions(q, n);
printf("%I64d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int bfsz = 1 << 16;
char bf[bfsz + 5];
int rsz = 0;
int ptr = 0;
char gc() {
if (rsz <= 0) {
ptr = 0;
rsz = fread(bf, 1, bfsz, stdin);
if (rsz <= 0) return EOF;
}
--rsz;
return bf[ptr++];
}
void ga(char &c) {
c = EOF;
while (!isalpha(c)) c = gc();
}
int gs(char s[]) {
int l = 0;
char c = gc();
while (isspace(c)) c = gc();
while (c != EOF && !isspace(c)) {
s[l++] = c;
c = gc();
}
s[l] = '\0';
return l;
}
template <class T>
bool gi(T &v) {
v = 0;
char c = gc();
while (c != EOF && c != '-' && !isdigit(c)) c = gc();
if (c == EOF) return false;
bool neg = c == '-';
if (neg) c = gc();
while (isdigit(c)) {
v = v * 10 + c - '0';
c = gc();
}
if (neg) v = -v;
return true;
}
bool exitInput = false;
int ntest = 1, itest = 1;
const int dx[4] = {-1, +0, +1, -0};
const int dy[4] = {+0, +1, +0, -1};
const long long Mod = 1e9 + 7;
const int maxn = (1 << 20) + 5;
const int maxv = 20 + 5;
const int maxe = 4 * (1 << 20) + 5;
int Logn, a[maxn], b[maxn], arr[maxv][maxn];
long long n, res, inversion_node[maxe], inversion_level[maxv],
equal_pair_node[maxe], equal_pair_level[maxv];
long long totalChange;
void build(int node, int L, int R, int level) {
if (L == R) {
inversion_node[node] = equal_pair_node[node] = 0;
arr[level][L] = a[L];
return;
}
int mid = (L + R) >> 1;
build((node << 1), L, mid, level - 1);
build(((node << 1) | 1), mid + 1, R, level - 1);
inversion_node[node] =
inversion_node[(node << 1)] + inversion_node[((node << 1) | 1)];
equal_pair_node[node] =
equal_pair_node[(node << 1)] + equal_pair_node[((node << 1) | 1)];
int i, j, k, cnt_smaller, cnt_equal;
cnt_smaller = cnt_equal = 0;
for (i = L, j = mid + 1, k = 0; i <= mid; ++i) {
if (i == L || arr[level - 1][i] > arr[level - 1][i - 1]) {
cnt_smaller += cnt_equal;
for (; j <= R && arr[level - 1][j] < arr[level - 1][i];
++j, ++cnt_smaller) {
b[k++] = arr[level - 1][j];
}
cnt_equal = 0;
for (; j <= R && arr[level - 1][j] == arr[level - 1][i];
++j, ++cnt_equal) {
b[k++] = arr[level - 1][j];
}
}
inversion_node[node] += cnt_smaller;
equal_pair_node[node] += cnt_equal;
b[k++] = arr[level - 1][i];
}
for (; j <= R; ++j) b[k++] = arr[level - 1][j];
inversion_level[level] += inversion_node[node];
equal_pair_level[level] += equal_pair_node[node];
for (i = 0; i <= R - L; ++i) {
arr[level][L + i] = b[i];
}
}
void pre() {}
void read() {
gi(Logn);
n = 1 << Logn;
for (int i = 1; i <= n; ++i) {
gi(a[i]);
}
}
void solve() {
build(1, 1, n, Logn);
res = inversion_level[Logn];
int Q, q, len, i;
gi(Q);
while (Q--) {
gi(q);
if (q > 0) {
len = 1 << q;
totalChange =
n * (len - 1) / 2 - inversion_level[q] * 2 - equal_pair_level[q];
res = res + totalChange;
for (i = q; i >= 0; --i) {
len = 1 << i;
inversion_level[i] =
n * (len - 1LL) / 2 - inversion_level[i] - equal_pair_level[i];
}
for (i = q + 1; i <= Logn; ++i) {
inversion_level[i] += totalChange;
}
}
printf("%lld\n", res);
}
}
int main() {
pre();
for (itest = 1; itest <= ntest; ++itest) {
read();
if (exitInput) {
break;
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1 << 21;
const long long big = 1e9 + 1;
const long long block = 800;
const long long mod = 1e6;
long long n, q;
long long a[N];
long long S[2][22];
void merge(long long l = 0, long long r = (1 << n) - 1, long long st = n) {
if (l == r) return;
long long m = (l + r) / 2;
merge(l, m, st - 1);
merge(m + 1, r, st - 1);
long long ptr[2] = {l, m + 1};
for (int i = m + 1; i <= r; i++) {
while (ptr[0] <= m && a[ptr[0]] <= a[i]) ptr[0]++;
S[0][st] += (m + 1) - ptr[0];
}
for (int i = l; i <= m; i++) {
while (ptr[1] <= r && a[ptr[1]] <= a[i]) ptr[1]++;
S[1][st] += r + 1 - ptr[1];
}
ptr[0] = l, ptr[1] = m + 1;
vector<long long> z;
for (int i = l; i <= r; i++) {
if (ptr[0] > m)
z.push_back(a[ptr[1]++]);
else if (ptr[1] > r)
z.push_back(a[ptr[0]++]);
else
z.push_back(a[ptr[0]] > a[ptr[1]] ? a[ptr[1]++] : a[ptr[0]++]);
}
for (int i = l; i <= r; i++) a[i] = z[i - l];
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < (1 << n); i++) cin >> a[i];
merge();
cin >> q;
while (q--) {
long long h = 0;
cin >> h;
for (int i = 0; i <= min(n, h); i++) swap(S[0][i], S[1][i]);
long long sub = 0;
for (int i = 0; i < 21; i++) sub += S[0][i];
cout << sub << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = (1 << 21) + 5;
int n, m;
int a[MAX];
long long tree[22][2];
void f(int l, int r, int lev) {
if (l >= r) return;
int mid = (l + r) >> 1;
f(l, mid, lev + 1);
f(mid + 1, r, lev + 1);
for (int i = l; i <= mid; ++i) {
tree[lev][0] += lower_bound(a + mid + 1, a + r + 1, a[i]) - (a + mid + 1);
}
for (int i = mid + 1; i <= r; ++i) {
tree[lev][1] += lower_bound(a + l, a + mid + 1, a[i]) - (a + l);
}
sort(a + l, a + r + 1);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (1 << n); ++i) {
scanf("%d", a + i);
}
f(0, (1 << n) - 1, 1);
long long ans = 0ll;
for (int i = 1; i <= n + 1; ++i) ans += tree[i][0];
scanf("%d", &m);
while (m--) {
int q;
scanf("%d", &q);
for (int i = n - q + 1; i <= n + 1; ++i) {
ans += (tree[i][1] - tree[i][0]);
swap(tree[i][1], tree[i][0]);
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, m, n, p, k, a[2000001], Q;
long long f[41][2], ans;
void dfs(int l, int r, int dep) {
if (l == r) return;
dfs(l, ((l + r) >> 1), dep - 1);
dfs(((l + r) >> 1) + 1, r, dep - 1);
int i;
for (i = l; i <= ((l + r) >> 1); i++) {
f[dep][0] += lower_bound(a + ((l + r) >> 1) + 1, a + r + 1, a[i]) -
(a + ((l + r) >> 1) + 1),
f[dep][1] += r - ((l + r) >> 1) -
(upper_bound(a + ((l + r) >> 1) + 1, a + r + 1, a[i]) -
(a + ((l + r) >> 1) + 1));
}
sort(a + l, a + r + 1);
}
int main() {
scanf("%d", &n);
int Maxn = 1 << n;
for (i = 1; i <= Maxn; i++) scanf("%d", &a[i]);
dfs(1, Maxn, n);
scanf("%d", &Q);
for (; Q--;) {
scanf("%d", &k);
ans = 0;
for (i = 1; i <= k; i++) swap(f[i][0], f[i][1]);
for (i = 0; i <= 20; i++) ans += f[i][0];
printf("%I64d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[2000000];
int b[2000000];
int tmp[2000000];
int q;
long long layer[25];
long long layer2[25];
void merge(int s, int mid, int e, int level) {
int i, j;
int p = s;
i = s;
j = mid + 1;
while (i <= mid && j <= e) {
if (a[i] <= a[j]) {
tmp[p] = a[i];
i++;
p++;
} else {
layer[level] += mid + 1 - i;
tmp[p] = a[j];
j++;
p++;
}
}
while (i <= mid) {
tmp[p] = a[i];
i++;
p++;
}
while (j <= e) {
tmp[p] = a[j];
p++;
j++;
}
for (i = s; i <= e; i++) a[i] = tmp[i];
}
void merge_sort(int s, int e, int level) {
if (e == s) return;
int mid = (s + e) / 2;
merge_sort(s, mid, level - 1);
merge_sort(mid + 1, e, level - 1);
merge(s, mid, e, level);
}
void merge2(int s, int mid, int e, int level) {
int i, j;
int p = s;
i = s;
j = mid + 1;
while (i <= mid && j <= e) {
if (a[i] < a[j]) {
layer2[level] += e + 1 - j;
tmp[p] = a[i];
i++;
p++;
} else {
tmp[p] = a[j];
j++;
p++;
}
}
while (i <= mid) {
tmp[p] = a[i];
i++;
p++;
}
while (j <= e) {
tmp[p] = a[j];
p++;
j++;
}
for (i = s; i <= e; i++) a[i] = tmp[i];
}
void merge_sort2(int s, int e, int level) {
if (e == s) return;
int mid = (s + e) / 2;
merge_sort2(s, mid, level - 1);
merge_sort2(mid + 1, e, level - 1);
merge2(s, mid, e, level);
}
int main() {
scanf("%d", &n);
int i;
for (i = 1; i <= 1 << n; i++) scanf("%d", &a[i]);
memcpy(b, a, sizeof(int) * 1100000);
merge_sort(1, 1 << n, n + 1);
memcpy(a, b, sizeof(int) * 1100000);
merge_sort2(1, 1 << n, n + 1);
scanf("%d", &q);
long long ans = 0;
for (i = 1; i <= n + 1; i++) {
ans += layer[i];
}
for (i = 1; i <= q; i++) {
int tmp;
scanf("%d", &tmp);
tmp++;
for (int j = tmp; j >= 1; j--) {
ans -= layer[j];
ans += layer2[j];
swap(layer[j], layer2[j]);
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1050010;
struct P {
int b, v, c;
} p[maxn];
int a[maxn];
int d[maxn];
int temp[23];
long long g[23][2];
int n;
bool cmp1(P b1, P b2) { return b1.b < b2.b; }
bool cmp2(P b1, P b2) { return b1.v < b2.v; }
int lowbit(int x) { return x & (-x); }
void change(int x, int y) {
while (x <= (1 << n)) {
d[x] += y;
x += lowbit(x);
}
return;
}
int sum(int k) {
int ans = 0;
while (k > 0) {
ans += d[k];
k -= lowbit(k);
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (1 << n); i++) {
scanf("%d", &a[i]);
p[i].b = a[i];
p[i].v = i;
}
sort(p, p + (1 << n), cmp1);
for (int i = 0; i < (1 << n); i++) {
p[i].c = i + 1;
if (i == 0) continue;
if (p[i].b == p[i - 1].b) p[i].c = p[i - 1].c;
}
sort(p, p + (1 << n), cmp2);
for (int i = 0; i < (1 << n); i++) a[i] = p[i].c;
for (int i = 1; i <= n; i++) {
int k = 0;
for (int j = 0; j < (1 << n); j++) {
g[i][0] += (k - sum(a[j]));
g[i][1] += (sum(a[j] - 1));
k++;
if (k == (1 << i)) {
for (int l = j - 1;; l--) {
change(a[l], -1);
if ((l % (1 << i)) == 0) break;
}
k = 0;
} else
change(a[j], 1);
}
}
for (int i = n; i > 1; i--) {
g[i][1] = g[i][1] - g[i - 1][1];
g[i][0] = g[i][0] - g[i - 1][0];
}
memset(temp, 0, sizeof(temp));
int m, q;
long long ans;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &q);
for (int j = q; j > 0; j--) {
temp[j] = 1 - temp[j];
}
ans = 0;
for (int j = 1; j <= n; j++) ans += g[j][temp[j]];
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = (1 << 20) + 5;
int n, q, a[MX], b, r;
vector<int> c;
long long res = 0;
int ft[MX];
void update(int i, int k) {
while (i < MX) {
ft[i] += k;
i += i & -i;
}
}
int query(int i) {
int sum = 0;
while (i) {
sum += ft[i];
i -= i & -i;
}
return sum;
}
long long cn[MX], par[22], inv[22];
void obtInv(int i, int j, int k) {
if (!k) return;
int l = i - 1, r = j - 1, m = (i + j) / 2 - 1;
for (int o = m + 1; o <= r; o++) update(a[o], 1);
for (int o = l; o <= m; o++) {
int d = query(a[o] - 1);
inv[k] += d;
par[k] += (m - l + 1) - query(a[o]) + d;
}
for (int o = m + 1; o <= r; o++) update(a[o], -1);
obtInv(i, m + 1, k - 1);
obtInv(m + 2, j, k - 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
scanf("%d", &r);
n = (1 << r);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
c.push_back(a[i]);
}
sort(c.begin(), c.end());
c.erase(unique(c.begin(), c.end()), c.end());
for (int i = 0; i < n; i++)
a[i] = (lower_bound(c.begin(), c.end(), a[i]) - c.begin() + 1);
;
obtInv(1, n, r);
scanf("%d", &q);
while (q--) {
scanf("%d", &b);
for (int i = 1; i <= b; i++) inv[i] = par[i] - inv[i];
res = 0;
for (int i = 1; i <= r; i++) res += inv[i];
cout << res << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, v[1058576];
long long sum[30], inv[30], ans, m, I[4 * 1058576];
void build(int nod = 1, int a = 1, int b = (1 << n), int deep = n) {
if (a == b) return;
build((2 * nod), a, ((a + b) / 2), deep - 1),
build((2 * nod + 1), ((a + b) / 2) + 1, b, deep - 1);
long long aux = 0, eq = 0;
for (int i = a; i <= ((a + b) / 2); i++) {
int x = v[i];
long long p = (lower_bound(v + ((a + b) / 2) + 1, v + b + 1, x) -
(v + ((a + b) / 2) + 1));
aux += (long long)p;
}
sort(v + a, v + b + 1);
for (int i = a; i <= b; i++) {
int x = v[i];
if (v[i] == v[i - 1] and i != a) continue;
long long p = (lower_bound(v + a, v + b + 1, x) - (v + a + 1));
long long pp = (upper_bound(v + a, v + b + 1, x) - (v + a + 1));
eq += (pp - p) * (pp - p - 1) / 2;
}
I[nod] = I[(2 * nod)] + I[(2 * nod + 1)] + aux;
inv[deep] += I[nod];
sum[deep] += (((long long)b - (long long)a + 1LL) *
((long long)b - (long long)a) / 2) -
eq;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= (1 << n); i++) cin >> v[i];
build();
cin >> m;
ans = I[1];
for (int i = 1; i <= m; i++) {
cin >> q;
ans = ans + sum[q] - 2LL * inv[q];
for (int j = n; j >= q; j--) inv[j] += sum[q] - 2LL * inv[q];
for (int j = 0; j < q; j++) inv[j] += sum[j] - 2LL * inv[j];
cout << inv[n] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long x[20];
long long y[20];
int a[1 << 20];
void cal(int ind, int l, int r) {
if (ind == 0) return;
int mid = ((l + r) >> 1);
cal(ind - 1, l, mid);
cal(ind - 1, mid + 1, r);
for (int i = l; i <= mid; i++) {
x[ind] += lower_bound(a + mid + 1, a + r + 1, a[i]) - (a + mid + 1);
y[ind] +=
(r - mid - (upper_bound(a + mid + 1, a + r + 1, a[i]) - (a + mid + 1)));
}
int p1 = l, p2 = mid + 1;
vector<int> b;
while (1) {
if (p1 > mid) {
while (p2 <= r) b.push_back(a[p2++]);
break;
}
if (p2 > r) {
while (p1 <= mid) b.push_back(a[p1++]);
break;
}
if (a[p1] <= a[p2]) {
b.push_back(a[p1++]);
} else {
b.push_back(a[p2++]);
}
}
int len = b.size();
for (int i = 0; i < len; i++) {
a[l + i] = b[i];
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (1 << n); i++) {
scanf("%d", &a[i]);
}
cal(n, 0, (1 << n) - 1);
for (int i = 1; i <= n; i++) y[i] += x[i];
int q;
scanf("%d", &q);
while (q--) {
int idx;
scanf("%d", &idx);
for (int i = 1; i <= idx; i++) {
x[i] = y[i] - x[i];
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += x[i];
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
if (x < 0)
return -x;
else
return x;
}
int N, tot, A[(1 << (20)) + 33];
long long smaller[23], bigger[23];
void Divide(int L, int R, int dep) {
if (L == R) return;
int M((L + R) >> 1);
Divide(L, M, dep + 1);
Divide(M + 1, R, dep + 1);
for (int i(M + 1); i <= (R); ++i) {
smaller[dep] += lower_bound(A + L, A + M + 1, A[i]) - 1 - (A + L - 1);
bigger[dep] += A + M - (upper_bound(A + L, A + M + 1, A[i]) - 1);
}
sort(A + L, A + R + 1);
}
void solve() {
scanf("%d", &N);
tot = (1 << (N));
for (int i(1); i <= (tot); ++i) scanf("%d", A + i);
memset(smaller, 0, sizeof(smaller));
memset(bigger, 0, sizeof(bigger));
Divide(1, tot, 1);
int M;
scanf("%d", &M);
long long ans = 0;
for (int i(1); i <= (N); ++i) ans += bigger[i];
while (M--) {
int q;
scanf("%d", &q);
q = N - q + 1;
for (int i(q); i <= (N); ++i) {
ans -= bigger[i];
swap(bigger[i], smaller[i]);
ans += bigger[i];
}
printf("%I64d\n", ans);
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const double eps = 1e-10;
const int maxn = 1111111;
long long s[2][30];
int now[30];
long long pow2[30];
int A[maxn], T[maxn];
int n, m;
void merge_sort(int *A, int x, int y, int *T, int level) {
if (y <= x) return;
int m = x + (y - x) / 2;
int p = x, q = m + 1, i = x;
merge_sort(A, x, m, T, level + 1);
merge_sort(A, m + 1, y, T, level + 1);
while (p <= m || q <= y) {
if (q > y || (p <= m && A[p] <= A[q]))
T[i++] = A[p++];
else {
s[0][level] += m - p + 1;
T[i++] = A[q++];
}
}
p = m, q = y, i = y;
while (p >= x && q > m) {
if (q <= m || (p >= x && A[p] >= A[q]))
T[i--] = A[p--];
else {
s[1][level] += p - x + 1;
T[i--] = A[q--];
}
}
for (int i = x; i <= y; i++) A[i] = T[i];
}
int main() {
pow2[0] = 1;
for (int i = 1; i <= 22; i++) pow2[i] = pow2[i - 1] * 2;
scanf("%d", &n);
for (int i = 0; i < (pow2[n]); ++i) scanf("%d", &A[i]);
merge_sort(A, 0, pow2[n] - 1, T, 0);
scanf("%d", &m);
while (m--) {
int x;
scanf("%d", &x);
for (int i = x; i >= 1; i--) {
int y = n - i;
now[y] ^= 1;
}
long long ans = 0;
for (int i = 0; i <= n; i++) ans += s[now[i]][i];
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
int A[1048577], TEMP[1048577];
long long ANS[3][21];
void f(int n, int* Ar) {
if (n == 0) {
ANS[0][n] = ANS[1][n] = 0;
return;
}
int sz = (1 << n), s = (sz >> 1);
f(n - 1, Ar);
f(n - 1, Ar + s);
int j = 0;
for (int i = s; i < sz; ++i) {
while (Ar[j] < Ar[i] && j < s) j++;
ANS[1][n] += j;
}
j = s;
for (int i = 0; i < s; ++i) {
while (Ar[j] < Ar[i] && j < sz) j++;
ANS[0][n] += (j - s);
}
j = s;
int k = 0;
for (int i = 0; i < s; ++i) {
while (Ar[j] <= Ar[i] && j < sz) TEMP[k++] = Ar[j++];
TEMP[k++] = Ar[i];
}
while (j < sz) TEMP[k++] = Ar[j++];
for (int i = 0; i < sz; ++i) Ar[i] = TEMP[i];
return;
}
int main() {
int N;
memset(ANS, false, sizeof ANS);
scanf("%d", &N);
for (int i = 0; i < (1 << N); ++i) scanf("%d", A + i);
f(N, A);
int M, x;
scanf("%d", &M);
while (M--) {
scanf("%d", &x);
ANS[2][x] = 1 - ANS[2][x];
long long ans = 0;
int sum = 0;
for (int i = N; i >= 0; --i) {
sum += ANS[2][i];
ans += ANS[sum % 2][i];
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[(1 << 20) + 10];
int b[(1 << 20) + 10];
int temp[(1 << 20) + 10];
int pos[30] = {0};
long long shun[30] = {0};
long long ni[30] = {0};
void merge(int s, int t, int l) {
if (s != t) {
merge(s, (s + t) / 2, l + 1);
merge((s + t) / 2 + 1, t, l + 1);
}
int i = s, j = (s + t) / 2 + 1;
int tot = 0;
while (i <= (s + t) / 2 || j <= t) {
if (i > (s + t) / 2) {
j++;
} else if (j > t) {
i++;
} else {
if (b[i] <= b[j])
i++;
else {
ni[l] += ((s + t) / 2 - i + 1);
j++;
}
}
}
i = s, j = (s + t) / 2 + 1;
tot = 0;
while (i <= (s + t) / 2 || j <= t) {
if (i > (s + t) / 2) {
temp[tot++] = b[j];
j++;
} else if (j > t) {
temp[tot++] = b[i];
i++;
} else {
if (b[j] <= b[i]) {
temp[tot++] = b[j];
j++;
} else {
temp[tot++] = b[i];
shun[l] += (t - j + 1);
i++;
}
}
}
for (int i = s; i <= t; i++) {
b[i] = temp[i - s];
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (1 << n); i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
int N = (1 << n);
merge(0, N - 1, 1);
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int q;
scanf("%d", &q);
for (int j = n - q + 1; j <= n; j++) pos[j] = 1 - pos[j];
long long res = 0;
for (int j = 1; j <= n; j++) {
if (pos[j] == 1)
res += shun[j];
else
res += ni[j];
}
cout << res << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int rei() {
int x;
cin >> x;
return x;
}
inline long long rel() {
long long x;
cin >> x;
return x;
}
inline string res() {
string x;
cin >> x;
return x;
}
long long Olr[20];
long long Orl[20];
long long state[1 << 20];
void Calc() {
int N = rei();
vector<int> A(1 << N);
vector<int> oA(1 << N);
for (int i = 0; i < 1 << N; i++) {
A[i] = rei();
}
for (int i = 0; i < N; i++) {
int Block = 1 << (i + 1);
for (int j = 0; j < 1 << N; j += Block) {
{
int p = j;
int pl = p;
int pr = p + Block / 2;
int lf = p;
int rf = pr;
int lt = pr;
int rt = p + Block;
while (pl < lt && pr < rt) {
if (A[pl] <= A[pr]) {
oA[p] = A[pl];
p++;
pl++;
Orl[i] += pr - rf;
} else {
oA[p] = A[pr];
p++;
pr++;
}
}
while (pl < lt) {
oA[p] = A[pl];
p++;
pl++;
Orl[i] += pr - rf;
}
while (pr < rt) {
oA[p] = A[pr];
p++;
pr++;
}
}
{
int p = j;
int pl = p;
int pr = p + Block / 2;
int lf = p;
int rf = pr;
int lt = pr;
int rt = p + Block;
while (pl < lt && pr < rt) {
if (A[pr] <= A[pl]) {
p++;
pr++;
Olr[i] += pl - lf;
} else {
p++;
pl++;
}
}
while (pr < rt) {
p++;
pr++;
Olr[i] += pl - lf;
}
}
}
swap(A, oA);
}
for (int i = 0; i < 1 << N; i++) {
long long sum = 0;
for (int j = 0; j < N; j++) {
if (i & (1 << j)) {
sum += Olr[j];
} else {
sum += Orl[j];
}
}
state[i] = sum;
}
int Q = rei();
int curstate = 0;
for (int i = 0; i < Q; i++) {
int x = rei();
curstate = curstate ^ ((1 << x) - 1);
cout << state[curstate] << "\n";
}
}
int main(int argc, char** argv) {
ios::sync_with_stdio(false), cin.tie(0);
cout.tie(0);
Calc();
return 0;
}
|
#include <bits/stdc++.h>
inline int get_ui();
int get_ui() {
char c;
for (; (c = getchar()) < '0' || c > '9';)
;
for (int a = c ^ '0';; a = (a * 10) + (c ^ '0'))
if ((c = getchar()) < '0' || c > '9') return a;
}
inline void put_ull(long long x);
void put_ull(long long x) {
char buf[24], *p = buf;
do {
*p++ = '0' + x % 10;
x /= 10;
} while (x);
do {
putchar(*--p);
} while (p > buf);
putchar('\n');
}
int data_fwd[1 << 20], data_rev[1 << 20], data_buf[1 << 20], xlat[20 + 1], n,
n2;
long long acc_fwd[20 + 1], acc_rev[20 + 1], base_sum;
void helper(int *data, long long *acc) {
{
long long inv = 0;
for (int i = 0; i < n2; i += 2) {
int a = data[i];
if (a > data[i + 1]) {
data[i] = data[i + 1];
data[i + 1] = a;
inv++;
}
}
acc[0] = inv;
}
int width = 2;
int *bufhead = data_buf;
for (int level = 1; level < n; level++) {
long long inv = 0;
int *le = data, *ri = data + width, step = width * 2;
for (int *buf = bufhead; buf < bufhead + n2;) {
int i = 0, j = 0;
for (;;) {
if (le[i] > ri[j]) {
*buf++ = ri[j++];
if (j == width) {
inv += (long long)j * (width - i);
for (; i < width;) *buf++ = le[i++];
break;
};
} else {
inv += j;
*buf++ = le[i++];
if (i == width) {
for (; j < width;) *buf++ = ri[j++];
break;
}
}
}
le += step;
ri += step;
}
width <<= 1;
acc[level] = inv;
le = bufhead;
bufhead = data;
data = le;
}
}
int main() {
n = get_ui();
n2 = 1 << n;
for (int i = 0, j = n2 - 1; i < n2; i++, j--)
data_fwd[i] = data_rev[j] = get_ui();
if (n) {
helper(data_fwd, acc_fwd);
helper(data_rev, acc_rev);
for (int i = 0; i < n; i++) {
if (acc_fwd[i] < acc_rev[i]) {
base_sum += acc_fwd[i];
acc_fwd[i] = acc_rev[i] - acc_fwd[i];
} else {
base_sum += acc_rev[i];
acc_fwd[i] -= acc_rev[i];
xlat[i] = 1;
}
}
}
for (int qwerycnt = get_ui(); qwerycnt > 0; qwerycnt--) {
for (int i = get_ui(); i > 0;) xlat[--i] ^= 1;
long long res = base_sum;
for (int i = 0; i < n; i++)
if (xlat[i]) res += acc_fwd[i];
put_ull(res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
int v[1 << N], n, q;
long long dp[1 << N];
int t[1 << N];
void merge(int v[], int a, int b, int c) {
int k = 0, i, j;
for (i = a, j = b; i <= b - 1 && j <= c;) {
if (v[i] <= v[j])
t[k++] = v[i++];
else
t[k++] = v[j++];
}
while (i <= b - 1) t[k++] = v[i++];
while (j <= c) t[k++] = v[j++];
for (i = 0; i < k; ++i) v[a + i] = t[i];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= (1 << n); ++i) scanf("%d", &v[i]);
dp[0] = dp[1] = 0;
for (int i = 1; i <= n; ++i) {
long long sum = 0, sumtp = 0;
for (int j = 1; j <= (1 << n); j += (1 << i)) {
int a = j, b = j + (1 << (i - 1)), c = j + (1 << i) - 1;
for (int ta = b - 1, tb = c; tb >= b;) {
if (ta >= a && v[ta] > v[tb])
ta--;
else
sumtp += (b - 1) - ta, tb--;
}
merge(v, a, b, c);
int p = c + 1;
for (int k = c - 1; k >= a; --k) {
if (v[k] < v[k + 1]) p = k + 1;
sum += c - p + 1;
}
}
for (int j = 0; j < (1 << (i)); ++j) {
dp[j | (1 << i)] = sum - sumtp - dp[j];
dp[j] += sumtp;
}
}
scanf("%d", &q);
int cnt = 0;
while (q--) {
int x;
scanf("%d", &x);
cnt ^= (1 << x);
printf("%I64d\n", dp[cnt]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int x[1 << 20];
int y[1 << 20];
long long res[20];
long long all[20];
int q;
int build(int i, int l, int r) {
if (l == r) return 0;
int s = (l + r) / 2;
build(i + 1, l, s);
build(i + 1, s + 1, r);
int a = l, b = s + 1, c = l;
while (a <= s || b <= r) {
int A = a, B = b;
int cur;
if (a <= s && (b > r || x[a] <= x[b]))
cur = x[a];
else
cur = x[b];
while (A <= s && x[A] == cur) A++;
while (B <= r && x[B] == cur) B++;
res[i] += (long long)(s - A + 1) * (B - b);
all[i] += (long long)(s - A + 1) * (B - b);
all[i] += (long long)(A - a) * (r - B + 1);
while (a < A) {
y[c++] = cur;
a++;
}
while (b < B) {
y[c++] = cur;
b++;
}
}
for (int i = l; i <= r; i++) x[i] = y[i];
return 0;
}
int main() {
scanf("%d", &n);
m = 1 << n;
for (int i = 0; i < m; i++) scanf("%d", &x[i]);
build(0, 0, m - 1);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int x;
scanf("%d", &x);
for (int j = n - x; j < n; j++) res[j] = all[j] - res[j];
long long ans = 0;
for (int j = 0; j < n; j++) ans += res[j];
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
int num[1050000];
int num2[1050000];
long long inv[22][2] = {{0}};
int po[22];
long long cc[22] = {0};
void merge(int l, int r, int len) {
int i1, i2, j1, j2;
int m;
if (l != r) {
merge(l, (l + r) / 2, len - 1);
merge((l + r) / 2 + 1, r, len - 1);
j1 = l;
j2 = (l + r) / 2 + 1;
i1 = l;
while (j1 <= (l + r) / 2 && j2 <= r) {
if (num[j1] < num[j2]) {
num2[i1] = num[j1];
j1++;
i1++;
} else if (num[j1] == num[j2]) {
for (i2 = j2; i2 <= r && num[j1] == num[i2]; i1++, i2++) {
num2[i1] = num[j2];
}
m = i2 - j2;
j2 += m;
i1--;
j2--;
for (; j1 <= (l + r) / 2 && num[j1] == num[j2]; i1++) {
num2[i1] = num[j1];
inv[len][1] += m;
j1++;
}
} else {
num2[i1] = num[j2];
inv[len][0] += (l + r) / 2 - j1 + 1;
j2++;
i1++;
}
}
for (; j1 <= (l + r) / 2; i1++, j1++) {
num2[i1] = num[j1];
}
for (; j2 <= r; i1++, j2++) {
num2[i1] = num[j2];
}
for (i1 = l; i1 <= r; i1++) {
num[i1] = num2[i1];
}
}
}
int main() {
int i1, i2;
int n, m, q;
long long sum;
po[0] = 1;
for (i1 = 1; i1 < 21; i1++) {
po[i1] = po[i1 - 1] * 2;
cc[i1] = (long long)po[i1 - 1] * po[i1 - 1];
}
scanf("%d", &n);
for (i1 = 0; i1 < po[n]; i1++) {
scanf("%d", &num[i1]);
}
merge(0, po[n] - 1, n);
scanf("%d", &m);
for (i1 = 0; i1 < m; i1++) {
scanf("%d", &q);
sum = 0;
for (i2 = 1; i2 <= q; i2++) {
inv[i2][0] = cc[i2] * po[n - i2] - inv[i2][1] - inv[i2][0];
sum += inv[i2][0];
}
for (; i2 <= n; i2++) {
sum += inv[i2][0];
}
printf("%I64d\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int bfsz = 1 << 16;
char bf[bfsz + 5];
int rsz = 0;
int ptr = 0;
char gc() {
if (rsz <= 0) {
ptr = 0;
rsz = fread(bf, 1, bfsz, stdin);
if (rsz <= 0) return EOF;
}
--rsz;
return bf[ptr++];
}
void ga(char &c) {
c = EOF;
while (!isalpha(c)) c = gc();
}
int gs(char s[]) {
int l = 0;
char c = gc();
while (isspace(c)) c = gc();
while (c != EOF && !isspace(c)) {
s[l++] = c;
c = gc();
}
s[l] = '\0';
return l;
}
template <class T>
bool gi(T &v) {
v = 0;
char c = gc();
while (c != EOF && c != '-' && !isdigit(c)) c = gc();
if (c == EOF) return false;
bool neg = c == '-';
if (neg) c = gc();
while (isdigit(c)) {
v = v * 10 + c - '0';
c = gc();
}
if (neg) v = -v;
return true;
}
bool exitInput = false;
int ntest = 1, itest = 1;
const int dx[4] = {-1, +0, +1, -0};
const int dy[4] = {+0, +1, +0, -1};
const long long Mod = 1e9 + 7;
const int maxn = (1 << 20) + 5;
const int maxv = 20 + 5;
const int maxe = 4 * (1 << 20) + 5;
int Logn, a[maxn], b[maxn], arr[maxv][maxn];
long long n, res, inversion_node[maxe], inversion_level[maxv],
equal_pair_node[maxe], equal_pair_level[maxv];
long long totalChange;
void build(int node, int L, int R, int level) {
if (L == R) {
inversion_node[node] = equal_pair_node[node] = 0;
arr[level][L] = a[L];
return;
}
int mid = (L + R) >> 1;
build((node << 1), L, mid, level - 1);
build(((node << 1) | 1), mid + 1, R, level - 1);
inversion_node[node] =
inversion_node[(node << 1)] + inversion_node[((node << 1) | 1)];
equal_pair_node[node] =
equal_pair_node[(node << 1)] + equal_pair_node[((node << 1) | 1)];
int i, j, k, cnt_smaller, cnt_equal;
cnt_smaller = cnt_equal = 0;
for (i = L, j = mid + 1, k = 0; i <= mid; ++i) {
if (i == L || arr[level - 1][i] > arr[level - 1][i - 1]) {
cnt_smaller += cnt_equal;
for (; j <= R && arr[level - 1][j] < arr[level - 1][i];
++j, ++cnt_smaller) {
b[k++] = arr[level - 1][j];
}
cnt_equal = 0;
for (; j <= R && arr[level - 1][j] == arr[level - 1][i];
++j, ++cnt_equal) {
b[k++] = arr[level - 1][j];
}
}
inversion_node[node] += cnt_smaller;
equal_pair_node[node] += cnt_equal;
b[k++] = arr[level - 1][i];
}
for (; j <= R; ++j) b[k++] = arr[level - 1][j];
inversion_level[level] += inversion_node[node];
equal_pair_level[level] += equal_pair_node[node];
for (i = 0; i <= R - L; ++i) {
arr[level][L + i] = b[i];
}
}
void pre() {}
void read() {
gi(Logn);
n = 1 << Logn;
for (int i = 1; i <= n; ++i) {
gi(a[i]);
}
}
void solve() {
build(1, 1, n, Logn);
res = inversion_level[Logn];
int Q, q, len, i;
gi(Q);
while (Q--) {
gi(q);
if (q > 0) {
len = 1 << q;
totalChange =
n * (len - 1) / 2 - inversion_level[q] * 2 - equal_pair_level[q];
res = res + totalChange;
for (i = q; i >= 0; --i) {
len = 1 << i;
inversion_level[i] =
n * (len - 1LL) / 2 - inversion_level[i] - equal_pair_level[i];
}
for (i = q + 1; i <= Logn; ++i) {
inversion_level[i] += totalChange;
}
}
printf("%lld\n", res);
}
}
int main() {
pre();
for (itest = 1; itest <= ntest; ++itest) {
read();
if (exitInput) {
break;
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 21);
int n, a[N], m;
long long val[N][3], sum[21][3];
vector<int> node[4 * N];
template <typename T>
inline void Cin(T& x) {
char c = getchar();
x = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
}
template <typename T, typename... Args>
inline void Cin(T& a, Args&... args) {
Cin(a);
Cin(args...);
}
void build(int id, int l, int r) {
if (l == r) {
node[id].push_back(a[l]);
val[id][1] = 0;
val[id][2] = 0;
return;
}
int mid = (l + r) / 2;
build(id * 2, l, mid);
build(id * 2 + 1, mid + 1, r);
node[id].resize(node[id * 2].size() + node[id * 2 + 1].size());
merge(node[id * 2].begin(), node[id * 2].end(), node[id * 2 + 1].begin(),
node[id * 2 + 1].end(), node[id].begin());
int j = 0;
for (int i = 0; i < node[id * 2 + 1].size(); i++) {
int cur = node[id * 2 + 1][i];
while (j < node[id * 2].size() && node[id * 2][j] < cur) j++;
val[id][2] += 1ll * j;
}
j = 0;
for (int i = 0; i < node[id * 2].size(); i++) {
int cur = node[id * 2][i];
while (j < node[id * 2 + 1].size() && node[id * 2 + 1][j] < cur) j++;
val[id][1] += 1ll * j;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
Cin(n);
for (int i = 1; i <= (1 << n); i++) Cin(a[i]);
build(1, 1, (1 << n));
for (int i = 0; i <= n; i++) {
for (int l = (1 << i); l < (1 << (i + 1)); l++) {
sum[i][1] += val[l][1];
sum[i][2] += val[l][2];
}
}
Cin(m);
while (m--) {
int h;
Cin(h);
long long res = 0;
for (int i = n - h; i <= n; i++) swap(sum[i][1], sum[i][2]);
for (int i = 0; i <= n; i++) res = res + sum[i][1];
cout << res << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int inf = 1e9 / 2;
vector<int> a;
int n, q, m;
struct Bucket {
long long inversions;
long long exclude;
int depth;
Bucket() { inversions = exclude = depth = 0; }
long long flip() {
long long all = 1 << (n - depth);
long long buckets = (1 << n) / all;
long long new_val = all * buckets * (all - 1) / 2 - inversions - exclude;
long long res = new_val - inversions;
inversions = new_val;
return res;
}
};
long long merge(vector<int>& v, int s, int mid, int e) {
vector<int> aux(e - s + 1);
int p1 = s, p2 = mid + 1, cntr = 0;
long long invs = 0;
while (p1 <= mid && p2 <= e) {
if (v[p1] <= v[p2])
aux[cntr++] = v[p1++];
else {
aux[cntr++] = v[p2++];
invs += mid - p1 + 1;
}
}
while (p1 <= mid) {
aux[cntr++] = v[p1++];
}
while (p2 <= e) {
aux[cntr++] = v[p2++];
}
for (int i = 0; i < aux.size(); i++) v[s++] = aux[i];
return invs;
}
Bucket buck[25];
long long _count_inversions(vector<int>& v, int s, int e, int depth = 0) {
buck[depth].depth = depth;
if (s == e) return 0;
int mid = (s + e) / 2;
long long res = 0;
res += _count_inversions(v, s, mid, depth + 1);
res += _count_inversions(v, mid + 1, e, depth + 1);
res += merge(v, s, mid, e);
map<int, int> make_pair;
for (int i = s; i <= e; i++) make_pair[v[i]]++;
for (map<int, int>::iterator it = make_pair.begin(); it != make_pair.end();
it++) {
int cnta = it->second;
if (cnta > 1) buck[depth].exclude += cnta * 1ll * (cnta - 1) / 2;
}
buck[depth].inversions += res;
return res;
}
long long count_inversions(vector<int> v) {
return _count_inversions(v, 0, v.size() - 1);
}
int main() {
ios_base::sync_with_stdio(false);
scanf("%d", &n);
a.resize(1 << n);
for (int i = 0; i < 1 << n; i++) scanf("%d", &a[i]);
long long inversions = count_inversions(a);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int q;
scanf("%d", &q);
q = n - q;
long long difference = buck[q].flip();
inversions += difference;
for (int j = q + 1; j < n; j++) buck[j].flip();
for (int j = q - 1; j >= 0; j--) buck[j].inversions += difference;
printf("%lld\n", inversions);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const int MAXN = 2e6 + 105;
const int N = 5000 + 15;
const double EPS = 1e-9;
int dx[] = {1, 0, 0, -1};
int dy[] = {0, 1, -1, 0};
long long i, j, k, n, m;
long long a[MAXN];
long long lvl[50], reverseLvl[50];
void calc(long long left, long long right, long long level) {
if (left == right) return;
long long mid = (left + right) / 2;
calc(left, mid, level - 1);
calc(mid + 1, right, level - 1);
for (int i = left; i <= mid; i++) {
long long greaterThan =
lower_bound(a + mid + 1, a + right + 1, a[i]) - (a + mid + 1);
lvl[level] += greaterThan;
long long tmp =
upper_bound(a + mid + 1, a + right + 1, a[i]) - (a + mid + 1);
reverseLvl[level] += right - mid - tmp;
}
sort(a + left, a + right + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
long long len = 1 << n;
for (int i = 1; i <= len; i++) cin >> a[i];
calc(1, len, n);
int t;
cin >> t;
while (t--) {
int q;
cin >> q;
long long ans = 0;
for (int i = 1; i <= q; i++) {
swap(lvl[i], reverseLvl[i]);
}
for (int i = 1; i <= n; i++) ans += lvl[i];
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
int n, m, a[1 << maxn];
long long ans[maxn][2];
pair<long long, const int *> Solve(const int *a, const int *b, int len) {
static int c[1 << maxn];
int i = 0, j = 0, k = 0;
long long ans = 0;
while (i < len || j < len) {
if (i < len && (j == len || a[i] <= b[j])) {
c[k++] = a[i++];
} else {
ans += len - i;
c[k++] = b[j++];
}
}
return make_pair(ans, c);
}
void Sort(int *a, int n) {
if (n == 0) {
return;
}
Sort(a, n - 1);
Sort(a + (1 << n - 1), n - 1);
auto t = Solve(a + (1 << n - 1), a, 1 << n - 1);
ans[n - 1][1] += t.first;
t = Solve(a, a + (1 << n - 1), 1 << n - 1);
ans[n - 1][0] += t.first;
memcpy(a, t.second, (1 << n) * sizeof(int));
}
int main(void) {
scanf("%d", &n);
for (int i = 0; i < 1 << n; ++i) {
scanf("%d", a + i);
}
Sort(a, n);
int m;
scanf("%d", &m);
while (m--) {
int q;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
swap(ans[i][0], ans[i][1]);
}
long long sum = 0;
for (int i = 0; i < n; ++i) {
sum += ans[i][0];
}
printf("%lld\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, Len;
long long dp[25][2], A[2000005];
inline long long read() {
char ch;
long long a = 0;
while ((ch = getchar()) < '0' || ch > '9')
;
while ((ch >= '0') && (ch <= '9')) a = a * 10 + ch - '0', ch = getchar();
return a;
}
inline void read(int &a) {
char ch;
a = 0;
while ((ch = getchar()) < '0' || ch > '9')
;
while ((ch >= '0') && (ch <= '9')) a = a * 10 + ch - '0', ch = getchar();
}
void write(long long a) {
if (a >= 10) write(a / 10);
putchar(a % 10 + '0');
}
inline void Merge(int l, int r, int dep) {
if (!dep) return;
int m = (l + r) / 2;
Merge(l, m, dep - 1);
Merge(m + 1, r, dep - 1);
for (int i = l; i <= m; i++) {
dp[dep][0] += lower_bound(A + m + 1, A + r + 1, A[i]) - (A + m + 1);
dp[dep][1] +=
r - m - (upper_bound(A + m + 1, A + r + 1, A[i]) - (A + m + 1));
}
sort(A + l, A + r + 1);
}
int main() {
read(N);
Len = 1 << N;
for (int i = 1; i <= Len; i++) A[i] = read();
memset(dp, 0, sizeof(dp));
Merge(1, Len, N);
read(M);
for (int i = 1, x; i <= M; i++) {
read(x);
long long Ans = 0;
for (int i = 1; i <= x; i++) swap(dp[i][0], dp[i][1]);
for (int i = 1; i <= N; i++) Ans += dp[i][0];
write(Ans);
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, q;
long long ar[2000005], hsl[25], rev[25];
long long ar2[20000005];
void hitung(long long node, long long x, long long y) {
if (x != y) {
hitung(node + 1, x, (x + y) / 2);
hitung(node + 1, (x + y) / 2 + 1, y);
} else
return;
long long mid = (x + y) / 2;
long long temp = 0, temp2 = 0;
long long i, j;
sort(ar + x, ar + mid + 1);
sort(ar + mid + 1, ar + y + 1);
j = mid + 1;
for (i = x; i <= mid; i++) {
while (j <= y && ar[j] < ar[i]) j++;
temp += j - mid - 1;
}
j = x;
for (i = mid + 1; i <= y; i++) {
while (j <= mid && ar[j] < ar[i]) j++;
temp2 += j - x;
}
hsl[node] += temp;
rev[node] += temp2;
}
int main() {
memset(hsl, 0, sizeof(hsl));
memset(rev, 0, sizeof(rev));
scanf("%I64d", &n);
for (int i = 1; i <= (1 << n); i++) scanf("%I64d", &ar[i]);
hitung(1, 1, (1 << n));
scanf("%I64d", &m);
for (int i = 1; i <= m; i++) {
scanf("%I64d", &q);
long long ans = 0;
for (int j = 1; j <= n - q; j++) {
ans += hsl[j];
}
for (int j = 1; j <= q; j++) {
ans += rev[n - j + 1];
swap(rev[n - j + 1], hsl[n - j + 1]);
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[1 << 21];
long long int dp[21][2];
void merge_sort(int l, int r, int dep) {
if (l >= r) return;
int m = (l + r) / 2;
merge_sort(l, m, dep - 1);
merge_sort(m + 1, r, dep - 1);
for (int i = l; i <= m; i++) {
dp[dep][0] += lower_bound(a + m + 1, a + r + 1, a[i]) - (a + m + 1);
dp[dep][1] +=
r - m - (upper_bound(a + m + 1, a + r + 1, a[i]) - (a + m + 1));
}
sort(a + l, a + r + 1);
}
int main() {
scanf("%d", &n);
for (int i = 1, sz = (1 << n); i <= sz; i++) scanf("%d", a + i);
merge_sort(1, (1 << n), n);
scanf("%d", &m);
while (m--) {
int q;
long long int ans = 0;
scanf("%d", &q);
for (int i = 1; i <= q; i++) swap(dp[i][0], dp[i][1]);
for (int i = 1; i <= n; i++) ans += dp[i][0];
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> A, B;
long long c1[25], c2[25];
int n;
long long merge1(vector<int>& a, int lev) {
int n = a.size();
if (lev == 0) return 0;
long long cnt = 0;
vector<int> b(a.begin(), a.begin() + n / 2);
vector<int> c(a.begin() + n / 2, a.end());
cnt += merge1(b, lev - 1);
cnt += merge1(c, lev - 1);
int ai = 0, bi = 0, ci = 0;
long long sum = 0;
while (ai < n) {
if (bi < b.size() && (ci == c.size() || b[bi] <= c[ci]))
a[ai++] = b[bi++];
else {
cnt += n / 2 - bi;
sum += n / 2 - bi;
a[ai++] = c[ci++];
}
}
c1[lev] += sum;
return cnt;
}
long long merge2(vector<int>& a, int lev) {
int n = a.size();
if (lev == 0) return 0;
long long cnt = 0;
vector<int> b(a.begin(), a.begin() + n / 2);
vector<int> c(a.begin() + n / 2, a.end());
cnt += merge2(b, lev - 1);
cnt += merge2(c, lev - 1);
int ai = 0, bi = 0, ci = 0;
long long sum = 0;
while (ai < n) {
if (bi < b.size() && (ci == c.size() || b[bi] >= c[ci]))
a[ai++] = b[bi++];
else {
cnt += n / 2 - bi;
sum += n / 2 - bi;
a[ai++] = c[ci++];
}
}
c2[lev] += sum;
return cnt;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (1 << n); i++) {
int temp;
scanf("%d", &temp);
A.push_back(temp);
}
B = A;
merge1(A, n);
merge2(B, n);
int q;
scanf("%d", &q);
while (q--) {
int pos;
scanf("%d", &pos);
for (int i = 0; i <= pos; i++) swap(c1[i], c2[i]);
long long ans = 0;
for (int i = 0; i <= n; i++) ans += c1[i];
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int lg = 21;
long long a[(1 << lg) + 9], ans[1 << lg], ans2[1 << lg], tmp[(1 << lg) + 9], n,
q, x, t;
void ms(int s = 0, int e = (1 << n), int h = 0) {
if (e - s == 1) return;
long long mid = s + e >> 1, ret = 0, ret2 = 0;
ms(s, mid, h + 1), ms(mid, e, h + 1);
for (int i = s; i < mid; i++) {
ret2 += e - mid - (upper_bound(a + mid, a + e, a[i]) - a - mid);
ret += lower_bound(a + mid, a + e, a[i]) - a - mid;
}
sort(a + s, a + e);
ans[h] += ret, ans2[h] += ret2;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < (1 << n); i++) cin >> a[i];
ms(), cin >> q;
while (q--) {
long long ret = 0;
cin >> x;
for (int i = n - x; i <= n; i++) swap(ans[i], ans2[i]);
for (int i = 0; i <= n; i++) ret += ans[i];
cout << ret << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int tmp[1048576];
long long sum[30];
int pos(int n) {
int c = 0;
while (n) {
c++;
n /= 2;
}
return c - 1;
}
long long mergesort(int *p, int l, int r) {
if (l + 1 >= r) return 0;
int m = (l + r) / 2;
long long ans = 0;
ans += mergesort(p, l, m);
ans += mergesort(p, m, r);
int i = l, j = m, k = 0;
long long x = 0;
while (i != m || j != r) {
if (i == m || (j != r && p[i] > p[j])) {
tmp[k++] = p[j++];
ans += m - i;
x += m - i;
} else
tmp[k++] = p[i++];
}
memcpy(p + l, tmp, (r - l) * sizeof(int));
sum[pos(r - l)] += x;
return ans;
}
int a[1048576];
int b[1048576];
long long r[30];
long long s1[30], s2[30];
int main() {
ios::sync_with_stdio(false);
int k, n, m, q, stat[30] = {0};
while (cin >> k) {
memset(stat, 0, sizeof(stat));
n = 1 << k;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[n - i - 1] = a[i];
}
memset(sum, 0, sizeof(sum));
long long rev = mergesort(a, 0, n);
memcpy(s1, sum, sizeof(sum));
memset(sum, 0, sizeof(sum));
mergesort(b, 0, n);
memcpy(s2, sum, sizeof(sum));
cin >> m;
for (int i = 1; i <= k; i++) r[i] = s1[i] - s2[i];
for (int i = 0; i < m; i++) {
cin >> q;
for (int i = 1; i <= q; i++) {
if (stat[i]) {
rev += r[i];
} else {
rev -= r[i];
}
stat[i] = !stat[i];
}
cout << rev << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, lis[1 << 20], rec[22], val;
int q;
long long inv[22], neutral[22];
vector<int> v;
int main() {
scanf("%d", &n);
for (int i = (0); i <= ((int)((1 << n)) - 1); i++) scanf("%d", &lis[i]);
scanf("%d", &q);
long long ans = 0;
int half = 1;
for (int ii = (1); ii <= (n); ii++) {
for (int st = 0; st < (1 << n); st += half + half) {
int p1 = st;
int p2 = st + half;
int lat = -1;
int cnt = 0;
while (p1 < st + half && p2 < st + half + half) {
if (lis[p1] <= lis[p2]) {
if (lis[p1] == lat)
cnt++;
else {
lat = lis[p1];
cnt = 1;
}
v.push_back(lis[p1++]);
} else {
if (lis[p2] == lat) neutral[ii] += cnt;
v.push_back(lis[p2++]);
inv[ii] += st + half - p1;
}
}
for (int i = (p1); i <= (st + half - 1); i++) v.push_back(lis[i]);
for (int i = (p2); i <= (st + half + half - 1); i++) {
v.push_back(lis[i]);
if (lis[i] == lat) neutral[ii] += cnt;
}
for (int i = (0); i <= ((int)(half + half) - 1); i++) lis[st + i] = v[i];
v.clear();
}
ans += inv[ii];
half *= 2;
}
while (q--) {
scanf("%d", &val);
for (int i = (val); i >= (1); i--) {
rec[i]++;
if (rec[i] & 1)
ans += (1ll << (n + i - 2)) - 2 * inv[i] - neutral[i];
else
ans -= (1ll << (n + i - 2)) - 2 * inv[i] - neutral[i];
}
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long n, input[1200000];
vector<long> v;
map<long, long> mapp;
long calc;
long long span, tinv[200], linv[200];
long long p;
vector<pair<long, long> > ad;
long tests;
long lvl;
long long answ;
long vars[1200000];
class Fenwick {
long *m, *mt, N;
public:
Fenwick(long n);
Fenwick(long a[], long n);
void add_range(long l, long d);
void add_range(long l, long r, long d);
long sum(long r);
long sum(long l, long r);
};
Fenwick::Fenwick(long n) {
N = n;
m = new long[N];
mt = new long[N];
for (int i = 0; i < n; i++) m[i] = mt[i] = 0;
}
void Fenwick::add_range(long r, long d) {
if (r < 0) return;
for (int i = r; i >= 0; i = (i & (i + 1)) - 1) mt[i] += d;
for (int i = r | (r + 1); i < N; i |= i + 1)
m[i] += d * (r - (i & (i + 1)) + 1);
}
void Fenwick::add_range(long l, long r, long d) {
add_range(r, d);
add_range(l - 1, -d);
}
long Fenwick::sum(long r) {
if (r < 0) return 0;
long long res = 0;
for (int i = r; i >= 0; i = (i & (i + 1)) - 1)
res += m[i] + mt[i] * (i - (i & (i + 1)) + 1);
for (int i = r | (r + 1); i < N; i |= i + 1)
res += mt[i] * (r - (i & (i + 1)) + 1);
return res;
}
long Fenwick::sum(long l, long r) { return sum(r) - sum(l - 1); }
int main() {
cin >> n;
for (int i = 0; i < (1 << n); i++) {
scanf("%d", &input[i]);
vars[i] = input[i];
v.push_back(input[i]);
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (i == 0 || v[i] != v[i - 1]) {
mapp[v[i]] = calc + 1;
calc++;
}
}
for (int i = 0; i < (1 << n); i++) {
input[i] = mapp[input[i]];
ad.push_back(make_pair(input[i], -i));
}
sort(ad.begin(), ad.end());
Fenwick inv(1100100);
for (int pp = 0; pp < (1 << n); pp++) {
long i = -ad[pp].second;
for (int lev = 1; lev <= n; lev++) {
span = i % (1 << lev);
p = i - span;
if (span < (1 << (lev - 1))) continue;
linv[lev] += inv.sum(p, p + (1 << (lev - 1)) - 1);
}
inv.add_range(-ad[pp].second, -ad[pp].second, 1);
}
for (int lev = 1; lev <= n; lev++) tinv[lev] = linv[lev];
Fenwick inv1(1100100);
ad.clear();
for (int i = 0; i < (1 << n); i++) {
input[i] = calc - input[i] + 1;
ad.push_back(make_pair(-input[i], i));
}
sort(ad.begin(), ad.end());
for (int pp = 0; pp < (1 << n); pp++) {
long i = ad[pp].second;
for (int lev = 1; lev <= n; lev++) {
span = i % (1 << lev);
p = i - span + (1 << (lev - 1));
if (span >= (1 << (lev - 1))) continue;
tinv[lev] += inv1.sum(p, p + (1 << (lev - 1)) - 1);
}
inv1.add_range(ad[pp].second, ad[pp].second, 1);
}
cin >> tests;
for (; tests; --tests) {
scanf("%d", &lvl);
for (int i = lvl; i > 0; --i) linv[i] = tinv[i] - linv[i];
answ = 0;
for (int i = 1; i <= n; i++) answ += linv[i];
printf("%I64d\n", answ);
}
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1 << 21], temp[1 << 21];
int mp[1 << 21];
long long ans[22][2];
int mask[22];
void solve(int L, int R) {
if (L == R) return;
int M = (L + R) / 2;
solve(L, M);
solve(M + 1, R);
int l = L, r = M + 1;
int now = mp[R - L + 1];
int i = L;
while (l <= M && r <= R) {
if (a[l] > a[r]) {
ans[now][0] += M - l + 1;
temp[i++] = a[r++];
continue;
}
temp[i++] = a[l++];
}
i = L;
l = L;
r = M + 1;
while (l <= M && r <= R) {
if (a[l] < a[r]) {
ans[now][1] += R - r + 1;
temp[i++] = a[l++];
continue;
}
temp[i++] = a[r++];
}
while (l <= M) temp[i++] = a[l++];
while (r <= R) temp[i++] = a[r++];
for (int i = L; i <= R; i++) a[i] = temp[i];
}
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++) mp[1 << i] = i;
for (int i = 1; i <= (1 << n); i++) scanf("%d", &a[i]);
solve(1, 1 << n);
long long res = 0;
for (int i = 0; i <= n; i++) res += ans[i][0];
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int p;
scanf("%d", &p);
for (int j = p; j >= 0; j--) {
res += ans[j][mask[j] ^ 1] - ans[j][mask[j]];
mask[j] ^= 1;
}
printf("%I64d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int rel_inv[25][2];
int arr[(1 << 20) + 5];
void merge_sort(int ss, int second, int d) {
if (ss >= second) return;
int mid = (ss + second) >> 1;
merge_sort(ss, mid, d - 1);
merge_sort(mid + 1, second, d - 1);
int aux[second - ss + 1];
int l = ss, r = mid + 1, i, j = 0;
for (i = ss; i <= second; i++) {
if (l > mid)
aux[j++] = arr[r++];
else if (r > second)
aux[j++] = arr[l++];
else if (arr[l] <= arr[r]) {
aux[j++] = arr[l++];
} else {
rel_inv[d][0] += 1LL * (mid - l + 1);
aux[j++] = arr[r++];
}
}
l = ss, r = mid + 1, i, j = 0;
for (i = ss; i <= second; i++) {
if (l > mid)
aux[j++] = arr[r++];
else if (r > second)
aux[j++] = arr[l++];
else if (arr[l] >= arr[r]) {
aux[j++] = arr[r++];
} else {
rel_inv[d][1] += 1LL * (second - r + 1);
aux[j++] = arr[l++];
}
}
for (int i = ss, j = 0; i <= second; i++) arr[i] = aux[j++];
}
int main() {
int n, m, x;
scanf("%d", &n);
int size = 1 << n;
for (int i = 1; i <= size; i++) scanf("%d", &arr[i]);
merge_sort(1, size, n);
scanf("%d", &m);
while (m--) {
scanf("%d", &x);
long long int ans = 0;
for (int i = 0; i <= x; i++) swap(rel_inv[i][0], rel_inv[i][1]);
for (int i = 0; i <= n; i++) {
ans += rel_inv[i][0];
}
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[(1 << 21) + 20];
vector<long long> tree[4 * (1 << 21)];
long long normal[25];
long long rev[25];
bool check[25];
void merge_sort(long long node, long long a, long long b, long long lev) {
if (a == b) {
tree[node].push_back(arr[a]);
return;
}
long long mid = (a + b) / 2, left, right;
left = node * 2;
right = left + 1;
merge_sort(left, a, mid, lev + 1);
merge_sort(right, mid + 1, b, lev + 1);
long long i = 0, j = 0;
while (1) {
if (i == tree[left].size()) {
for (long long ind = j; ind < tree[right].size(); ind++) {
tree[node].push_back(tree[right][ind]);
}
break;
}
if (j == tree[right].size()) {
for (long long ind = i; ind < tree[left].size(); ind++) {
tree[node].push_back(tree[left][ind]);
}
break;
}
if (tree[left][i] > tree[right][j]) {
normal[lev] += tree[left].size() - i;
tree[node].push_back(tree[right][j]);
j++;
} else {
tree[node].push_back(tree[left][i]);
i++;
}
}
i = j = 0;
while (1) {
if (i == tree[left].size()) break;
if (j == tree[right].size()) break;
if (tree[left][i] < tree[right][j]) {
rev[lev] += tree[right].size() - j;
i++;
} else {
j++;
}
}
}
int main() {
long long i, j, k, l, m, n, o;
long long testcase;
long long input, flag, tag, ans;
scanf("%lld", &n);
long long sz = (1 << n);
for (i = 1; i <= sz; i++) scanf("%lld", &arr[i]);
merge_sort(1, 1, sz, 0);
scanf("%lld", &m);
for (i = 0; i < 24; i++) check[i] = 1;
long long x;
for (long long y = 1; y <= m; y++) {
scanf("%lld", &x);
long long lev = n - x;
for (i = lev; i <= n; i++) {
if (check[i])
check[i] = 0;
else
check[i] = 1;
}
ans = 0;
for (i = 0; i <= n; i++) {
if (check[i])
ans += normal[i];
else
ans += rev[i];
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long expo(long long a, long long b, long long mod) {
if (b == 0) return 1;
if (b == 1) return a % mod;
long long ret = expo(a, b / 2, mod);
ret *= ret;
ret %= mod;
if (b & 1) {
ret *= a;
ret %= mod;
}
return ret;
}
long long inv(long long v, long long mod) { return expo(v, mod - 2, mod); }
int n, a[1100000], q, x, sz, p2[25];
int temp[1100000];
int arr[1100000];
long long cost[2][25];
void reset() {}
void input() {
scanf("%d", &n);
sz = (1 << n);
for (long long(i) = (1); (i) <= (sz); (i)++) {
scanf("%d", &a[i]);
}
}
void solve() {
long long bit = 0, ans = 0;
for (long long(i) = (0); (i) < (n); (i)++) ans += cost[0][i];
scanf("%d", &q);
while (q--) {
scanf("%d", &x);
for (long long(i) = (x - 1); (i) >= (0); (i)--) {
if ((bit & (1 << i)))
ans += cost[0][i] - cost[1][i];
else
ans += cost[1][i] - cost[0][i];
bit ^= 1 << i;
}
printf("%lld\n", ans);
}
}
void merge(int type, int x, int l, int r) {
int m = l + r >> 1;
int i = m, j = r;
while (i >= l) {
while (j >= m + 1 && temp[i] > temp[j]) j--;
cost[type][x] += r - j;
i--;
}
i = l;
j = m + 1;
int k = l;
while (i <= m && j <= r) {
if (temp[i] > temp[j])
arr[k++] = temp[i++];
else
arr[k++] = temp[j++];
}
while (i <= m) arr[k++] = temp[i++];
while (j <= r) arr[k++] = temp[j++];
for (long long(i) = (l); (i) <= (r); (i)++) temp[i] = arr[i];
}
void divide(int type, int x, int l, int r) {
if (l == r) return;
int m = l + r >> 1;
divide(type, x - 1, l, m);
divide(type, x - 1, m + 1, r);
merge(type, x, l, r);
}
void LetsRock() {
for (long long(i) = (1); (i) <= (sz); (i)++) temp[i] = a[i];
divide(0, n - 1, 1, sz);
for (long long(i) = (1); (i) <= (sz); (i)++) temp[i] = a[i];
reverse(temp + 1, temp + 1 + sz);
divide(1, n - 1, 1, sz);
solve();
}
int main() {
p2[0] = 1;
for (long long(i) = (1); (i) <= (20); (i)++) p2[i] = p2[i - 1] * 2;
input();
LetsRock();
reset();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int rel_inv[25][2];
int arr[(1 << 20) + 5];
void merge_sort(int ss, int mid, int second, int d) {
if (ss >= second) return;
merge_sort(ss, (ss + mid) / 2, mid, d - 1);
merge_sort(mid + 1, (mid + 1 + second) / 2, second, d - 1);
int aux[second - ss + 1];
int l = ss, r = mid + 1, i, j = 0;
for (i = ss; i <= second; i++) {
if (l > mid)
aux[j++] = arr[r++];
else if (r > second)
aux[j++] = arr[l++];
else if (arr[l] <= arr[r]) {
aux[j++] = arr[l++];
} else {
rel_inv[d][0] += 1LL * (mid - l + 1);
aux[j++] = arr[r++];
}
}
l = ss, r = mid + 1, i, j = 0;
for (i = ss; i <= second; i++) {
if (l > mid)
aux[j++] = arr[r++];
else if (r > second)
aux[j++] = arr[l++];
else if (arr[l] >= arr[r]) {
aux[j++] = arr[r++];
} else {
rel_inv[d][1] += 1LL * (second - r + 1);
aux[j++] = arr[l++];
}
}
for (int i = ss, j = 0; i <= second; i++) arr[i] = aux[j++];
}
int main() {
int n, m, x;
scanf("%d", &n);
int size = 1 << n;
for (int i = 1; i <= size; i++) scanf("%d", &arr[i]);
merge_sort(1, (size + 1) / 2, size, n);
scanf("%d", &m);
while (m--) {
scanf("%d", &x);
long long int ans = 0;
for (int i = 0; i <= x; i++) swap(rel_inv[i][0], rel_inv[i][1]);
for (int i = 0; i <= n; i++) {
ans += rel_inv[i][0];
}
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1100005], n, i, nn, Q, x;
long long f[21][2], ans;
void dfs(int l, int r, int deep) {
if (l == r) return;
int mid = (l + r) / 2;
dfs(l, mid, deep - 1);
dfs(mid + 1, r, deep - 1);
for (int i = l; i <= mid; i++) {
f[deep][0] += lower_bound(a + mid + 1, a + r + 1, a[i]) - (a + mid + 1);
f[deep][1] +=
r - mid - (upper_bound(a + mid + 1, a + r + 1, a[i]) - (a + mid + 1));
}
sort(a + l, a + r + 1);
}
int main() {
scanf("%d", &nn);
n = 1 << nn;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
dfs(1, n, nn);
scanf("%d", &Q);
while (Q--) {
scanf("%d", &x);
ans = 0;
for (i = 1; i <= x; i++) swap(f[i][0], f[i][1]);
for (i = 0; i <= 20; i++) ans += f[i][0];
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using std::map;
const int N = 22;
const int M = 1000010;
const int INF = 0x3f3f3f3f;
int n, m;
int a[1 << N], q[M];
long long sum_in[N], sum_out[N], minus[N];
int left[1 << N], right[1 << N];
long long two[N];
void init() {
for (int i = 0; i < N; i++) two[i] = 1ll << i;
}
long long dfs(int l, int r, int dep) {
if (l < r) {
int m = (l + r) >> 1;
long long lv = dfs(l, m, dep + 1);
long long rv = dfs(m + 1, r, dep + 1);
sum_in[dep] += lv + rv;
memcpy(left, a + l, (m - l + 1) * sizeof(int));
memcpy(right, a + m + 1, (r - m) * sizeof(int));
left[m - l + 1] = INF;
right[r - m] = INF;
long long cur = 0;
map<int, int> cnt;
for (int i = l, j = 0, k = 0; i <= r; i++) {
if (left[j] <= right[k]) {
a[i] = left[j++];
cur += k;
} else {
a[i] = right[k++];
}
cnt[a[i]]++;
}
sum_in[dep] += cur;
sum_out[dep + 1] += cur;
for (auto &u : cnt) {
minus[dep] += 1ll * u.second * (u.second - 1) / 2;
}
return lv + rv + cur;
}
return 0;
}
inline long long cal(int level) { return two[n - 1] * (two[n - level] - 1); }
int main() {
std::ios::sync_with_stdio(0);
init();
scanf("%d", &n);
for (int i = 0; i < 1 << n; i++) {
scanf("%d", a + i);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", q + i);
}
dfs(0, (1 << n) - 1, 0);
for (int i = 0; i < m; i++) {
int level = n - q[i];
sum_in[level] = cal(level) - sum_in[level] - minus[level];
for (int j = level - 1; j >= 0; j--) {
sum_in[j] = sum_in[j + 1] + sum_out[j + 1];
}
for (int j = level + 1; j <= n; j++) {
sum_in[j] = cal(j) - sum_in[j] - minus[j];
sum_out[j] = sum_in[j - 1] - sum_in[j];
}
printf("%I64d\n", sum_in[0]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 4e18;
const int inf = 2e9;
const int N = (1 << 20) + 10;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int a[N], b[N], tmp[N];
bool stat[22];
long long inv[22], des[22];
void merge(int l, int r, int lv) {
if (lv == 0) return;
int mid = (l + r) >> 1, i = l, j = mid + 1, cur = 0, t;
merge(l, mid, lv - 1);
merge(mid + 1, r, lv - 1);
while (i <= mid && j <= r) {
if (a[i] > a[j]) {
inv[lv - 1] += mid - i + 1;
tmp[cur++] = a[j++];
} else
tmp[cur++] = a[i++];
}
while (i <= mid) tmp[cur++] = a[i++];
while (j <= r) tmp[cur++] = a[j++];
for (t = r; t >= l; --t) a[t] = tmp[--cur];
}
void mergedes(int l, int r, int lv) {
if (lv == 0) return;
int mid = (l + r) >> 1, i = l, j = mid + 1, cur = 0, t;
mergedes(l, mid, lv - 1);
mergedes(mid + 1, r, lv - 1);
while (i <= mid && j <= r) {
if (b[i] < b[j]) {
des[lv - 1] += mid - i + 1;
tmp[cur++] = b[j++];
} else
tmp[cur++] = b[i++];
}
while (i <= mid) tmp[cur++] = b[i++];
while (j <= r) tmp[cur++] = b[j++];
for (t = r; t >= l; --t) b[t] = tmp[--cur];
}
int main(void) {
int n, i, j, p, q, m;
scanf("%d", &n);
p = (1 << n);
for (i = 0; i < p; ++i) {
scanf("%d", &a[i]);
b[i] = a[i];
}
merge(0, p - 1, n);
mergedes(0, p - 1, n);
scanf("%d", &m);
while (m--) {
scanf("%d", &q);
for (i = 0; i < q; ++i) stat[i] ^= 1;
long long ans = 0;
for (i = 0; i < n; ++i) ans += (stat[i] ? des[i] : inv[i]);
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int kkaass = 1;
struct data {
int level, u, v;
};
int n;
int ar[(1 << 20)];
pair<long long, long long> ans[25];
void ini(int left, int right, int lvl) {
if (left == right) return;
int mid = (left + right) / 2;
ini(left, mid, lvl + 1);
ini(mid + 1, right, lvl + 1);
vector<int> L, R;
for (int i = left; i <= mid; i++) L.push_back(ar[i]);
for (int i = mid + 1; i <= right; i++) R.push_back(ar[i]);
sort(L.begin(), L.end());
sort(R.begin(), R.end());
for (int i = 0; i < (int)L.size(); i++) {
ans[lvl].first += (R.end() - upper_bound(R.begin(), R.end(), L[i]));
ans[lvl].second += (lower_bound(R.begin(), R.end(), L[i]) - R.begin());
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
int i, j, k;
while (cin >> n) {
memset(ans, 0, sizeof(ans));
for (i = 0; i < ((1 << n)); i++) cin >> ar[i];
ini(0, (1 << n) - 1, 0);
int q;
cin >> q;
while (q--) {
int v;
cin >> v;
long long ret = 0;
for (int i = n - v; i <= n; i++) swap(ans[i].first, ans[i].second);
for (int i = 0; i <= n; i++) ret += ans[i].second;
cout << ret << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20 + 5;
int board[2][N], n, est[22];
long long solver[22][2];
inline void merged() {
int num = 1 << n;
for (int lvl = int(1); lvl < int(n + 1); ++lvl) {
int ato = 1 << lvl;
int ito = ato >> 1;
int sig = (lvl - 1) & 1;
for (int i = 0; i < num; i += ato) {
int c1 = 0, c2 = 0;
while (c1 < ito && c2 < ito) {
int p1 = i + c1;
int p2 = i + ito + c2;
if (board[sig][p1] > board[sig][p2])
board[lvl & 1][i + c1 + c2] = board[sig][p2], c2++,
solver[lvl][0] += ito - c1;
else
board[lvl & 1][i + c1 + c2] = board[sig][p1], c1++;
}
while (c1 < ito) board[lvl & 1][i + c1 + c2] = board[sig][i + c1], c1++;
while (c2 < ito)
board[lvl & 1][i + c1 + c2] = board[sig][i + ito + c2], c2++;
}
}
}
inline void mergei() {
int num = 1 << n;
for (int lvl = int(1); lvl < int(n + 1); ++lvl) {
int ato = 1 << lvl;
int ito = ato >> 1;
int sig = (lvl - 1) & 1;
for (int i = 0; i < num; i += ato) {
int c1 = 0, c2 = 0;
while (c1 < ito && c2 < ito) {
int p1 = i + c1;
int p2 = i + ito + c2;
if (board[sig][p1] > board[sig][p2])
board[lvl & 1][i + c1 + c2] = board[sig][p2], c2++,
solver[lvl][1] += ito - c1;
else
board[lvl & 1][i + c1 + c2] = board[sig][p1], c1++;
}
while (c1 < ito) board[lvl & 1][i + c1 + c2] = board[sig][i + c1], c1++;
while (c2 < ito)
board[lvl & 1][i + c1 + c2] = board[sig][i + ito + c2], c2++;
}
}
}
inline long long query(int k) {
est[k] = 1 - est[k];
long long ret = 0;
int e = 0;
for (int i = int(n); i >= int(0); i--) {
e ^= est[i];
ret += solver[i][e];
}
return ret;
}
int main() {
scanf("%d", &n);
vector<int> v((1 << n));
for (int i = int(0); i < int(1 << n); ++i) scanf("%d", &v[i]);
for (int i = int(0); i < int(1 << n); ++i) board[0][i] = v[i];
merged();
reverse((v).begin(), (v).end());
for (int i = int(0); i < int(1 << n); ++i) board[0][i] = v[i];
mergei();
int q;
scanf("%d", &q);
while (q--) {
int k;
scanf("%d", &k);
printf("%lld\n", query(k));
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const double EPS = 1e-9;
const int N = 2e6 + 9;
int n, a[N];
long long ans[2][N];
void go(int p) {
for (int i = 1; i <= (1 << n); i += (1 << p)) {
vector<int> x, y;
for (int j = i; j < i + (1 << (p - 1)); j++) x.push_back(a[j]);
for (int j = i + (1 << (p - 1)); j < i + (1 << p); j++) y.push_back(a[j]);
sort(x.begin(), x.end());
sort(y.begin(), y.end());
for (auto r : x) {
ans[0][p] += lower_bound(y.begin(), y.end(), r) - y.begin();
}
for (auto r : y) {
ans[1][p] += lower_bound(x.begin(), x.end(), r) - x.begin();
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= 1 << n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) go(i);
int m, q;
scanf("%d", &m);
while (m--) {
scanf("%d", &q);
long long t = 0;
for (int i = q; i > -1; i--) swap(ans[0][i], ans[1][i]);
for (int i = 0; i <= n; i++) t += ans[0][i];
printf("%lld\n", t);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long temp[4000000];
long long v[4000000];
long long vr[4000000];
long long cur[4000000];
long long a[2000000];
long long ttemp[4000000];
void mrg(int l, int r, int numb, int qq) {
if (r == l) {
v[numb] = 0;
vr[numb] = 0;
return;
}
long long ans = 0;
mrg(l, (l + r) / 2, 2 * numb, qq);
mrg((l + r) / 2 + 1, r, 2 * numb + 1, qq);
int uk1 = l;
int uk2 = (l + r) / 2 + 1;
int uk = l;
while (uk1 <= (l + r) / 2 && uk2 <= r) {
if (temp[uk1] <= temp[uk2]) {
ttemp[uk] = temp[uk1];
uk++;
uk1++;
} else {
ttemp[uk] = temp[uk2];
uk++;
uk2++;
ans += (l + r) / 2 - uk1 + 1;
}
}
while (uk1 <= (l + r) / 2) {
ttemp[uk] = temp[uk1];
uk++;
uk1++;
}
while (uk2 <= r) {
ttemp[uk] = temp[uk2];
uk++;
uk2++;
}
for (int i = l; i <= r; i++) temp[i] = ttemp[i];
if (qq)
v[numb] += ans;
else
vr[numb] += ans;
return;
}
int n;
void getans(int vv, int lvl, int need) {
if (lvl < 0) return;
temp[lvl] += v[vv];
ttemp[lvl] += vr[vv];
getans(2 * vv, lvl - 1, need);
getans(2 * vv + 1, lvl - 1, need);
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= (1 << n); i++) scanf("%d", &a[i]);
for (int i = 1; i <= (1 << (n + 1)); i++) {
cur[i] = 1;
}
for (int i = 1; i <= (1 << n); i++) temp[i] = a[i];
mrg(1, (1 << n), 1, 1);
for (int i = 1; i <= (1 << n); i++) temp[i] = a[(1 << n) - i + 1];
mrg(1, (1 << n), 1, 0);
for (int i = 1; i <= (1 << n); i++) {
temp[i] = 0;
ttemp[i] = 0;
}
getans(1, n, 0);
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int z;
long long sum = 0;
scanf("%d", &z);
for (int j = 0; j <= n; j++) {
if (j <= z) cur[j] = 1 - cur[j];
if (cur[j])
sum += temp[j];
else
sum += ttemp[j];
}
printf("%I64d\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
long long inv[25][2], res;
vector<int> merge(const vector<int>& a, const vector<int>& b) {
int i = 0, j = 0;
vector<int> v;
while (i < a.size() && j < b.size()) {
if (a[i] <= b[j])
v.push_back(a[i++]);
else
v.push_back(b[j++]), res += a.size() - i;
}
while (i < a.size()) v.push_back(a[i++]);
while (j < b.size()) v.push_back(b[j++]);
return v;
}
vector<int> merge_sort(const vector<int>& a, int low, int high, int depth,
int w) {
if (low == high) {
vector<int> v;
v.push_back(a[low]);
return v;
}
int middle = (low + high) / 2;
vector<int> v1 = merge_sort(a, low, middle, depth + 1, w);
vector<int> v2 = merge_sort(a, middle + 1, high, depth + 1, w);
vector<int> m = merge(v1, v2);
inv[depth][w] += res;
res = 0;
return m;
}
int main() {
int N;
scanf("%d", &N);
vector<int> a(1 << N);
for (int i = 0; i < (1 << N); i++) scanf("%d", &a[i]);
merge_sort(a, 0, a.size() - 1, 0, 0);
reverse(begin(a), end(a));
merge_sort(a, 0, a.size() - 1, 0, 1);
int Q, state = 0;
scanf("%d", &Q);
while (Q--) {
int x;
scanf("%d", &x);
for (int i = N; i >= N - x; i--) state ^= (1 << i);
long long answer = 0;
for (int i = 0; i <= N; i++) {
answer += inv[i][(bool)(state & (1 << i))];
}
printf("%I64d\n", answer);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long x) { return x * x; }
long double sqrd(long double x) { return x * x; }
mt19937 Random((int)time(0));
long long rnd(long long x) { return Random() % x; }
const long long INF = (long long)1e9 + 282;
const long long MOD = (long long)1e9 + 7;
const long double PI = acosl(-1.0);
const int L = 22;
const int N = (1ll << (L)) + 10;
int arr[N];
long long cnt[N][2], sum[L][2];
void calc(int v, int l, int r, vector<int>& arr, int d) {
if (l == r) {
return;
}
int m = (l + r) / 2;
vector<int> a, b;
for (int i = 0; i < (int)(arr).size() / 2; i++) {
a.push_back(arr[i]);
}
for (int i = (int)(arr).size() / 2; i < (int)(arr).size(); i++) {
b.push_back(arr[i]);
}
calc(v * 2, l, m, a, d + 1);
calc(v * 2 + 1, m + 1, r, b, d + 1);
arr.clear();
int x = 0, y = 0;
while (x < (int)(a).size() && y < (int)(b).size()) {
if (a[x] == b[y]) {
arr.push_back(a[x++]);
arr.push_back(b[y++]);
continue;
}
if (a[x] < b[y]) {
arr.push_back(a[x++]);
} else {
arr.push_back(b[y++]);
}
}
while (x < (int)(a).size()) {
arr.push_back(a[x++]);
}
while (y < (int)(b).size()) {
arr.push_back(b[y++]);
}
int p = 0;
for (int i = 0; i < (int)(a).size(); i++) {
while (p < (int)(b).size() && b[p] <= a[i]) {
p++;
}
cnt[v][1] += (int)(b).size() - p;
}
p = 0;
for (int i = 0; i < (int)(b).size(); i++) {
while (p < (int)(a).size() && a[p] <= b[i]) {
p++;
}
cnt[v][0] += (int)(a).size() - p;
}
sum[d][0] += cnt[v][0];
sum[d][1] += cnt[v][1];
}
void mane() {
int n;
cin >> n;
int l = n;
n = (1ll << (n));
vector<int> res;
res.reserve(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
res.push_back(arr[i]);
}
calc(1, 0, n - 1, res, 0);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int h;
cin >> h;
h = l - h;
for (int j = h; j <= l; j++) {
swap(sum[j][0], sum[j][1]);
}
long long ans = 0;
for (int j = 0; j <= l; j++) {
ans += sum[j][0];
}
cout << ans << "\n";
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios_base::fixed, ios_base::floatfield);
cout.precision(12);
mane();
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2000005];
int b[2000005];
long long dp[25][2];
void ms(int lev, int l, int r) {
if (lev == 0) {
dp[0][0] = dp[0][1] = 0;
return;
}
int mid = (l + r) / 2;
ms(lev - 1, l, mid), ms(lev - 1, mid + 1, r);
for (int i = l; i <= mid; i++) {
dp[lev][0] += (lower_bound(a + mid + 1, a + r + 1, a[i]) - (a + mid + 1));
dp[lev][1] +=
(r - mid - (upper_bound(a + mid + 1, a + r + 1, a[i]) - (a + mid + 1)));
}
sort(a + l, a + r + 1);
}
int main() {
int n;
while (~scanf("%d", &n)) {
int len = (1 << n);
for (int i = 1; i <= len; i++) scanf("%d", &a[i]);
memset(dp, 0, sizeof(dp));
ms(n, 1, len);
int m;
scanf("%d", &m);
while (m--) {
int q;
scanf("%d", &q);
for (int i = q; i >= 0; i--) swap(dp[i][0], dp[i][1]);
long long ans = 0;
for (int i = 0; i <= n; i++) ans += dp[i][0];
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 0.0000001;
const double PI = acos(-1);
const int INF = 0x7FFFFFFF;
template <typename T>
inline void next(T &num) {
char c;
num = 0;
do {
c = getchar_unlocked();
} while (c != EOF && c == ' ' && c == '\n' && c == '\t');
int sign = (c == '-' ? -1 : 1);
if (c != '-') num += (c - '0');
while ((c = getchar_unlocked()) != EOF && c != '\n' && c != '\t' &&
c != ' ') {
num *= 10;
num += (c - '0');
}
num *= sign;
}
inline string getstr() {
string str;
char k;
while ((k = getchar_unlocked()) == ' ' || k == '\n') {
k = getchar_unlocked();
if (k == ' ' || k == '\n')
continue;
else
break;
}
str.push_back(k);
while ((k = getchar_unlocked()) != EOF && k != '\n' && k != '\t' &&
k != '\v' && k != '\0' && k != ' ')
str.push_back(k);
return str;
}
const int N = 1050000;
long long inv1[21], inv2[21];
int a[N], b[N], tmp[N], p, n, m;
bool stat[22];
void mergesort1(int l, int r, int lv) {
if (lv == 0) return;
int mid = (l + r) >> 1, i = l, j = mid + 1, cur = 0;
mergesort1(l, mid, lv - 1);
mergesort1(mid + 1, r, lv - 1);
while (i <= mid && j <= r) {
if (a[j] < a[i]) {
inv1[lv - 1] += mid - i + 1;
tmp[cur++] = a[j++];
} else
tmp[cur++] = a[i++];
}
while (i <= mid) tmp[cur++] = a[i++];
while (j <= r) tmp[cur++] = a[j++];
for (int t = int(r), _b = int(l); t >= _b; t--) a[t] = tmp[--cur];
}
void mergesort2(int l, int r, int lv) {
if (lv == 0) return;
int mid = (l + r) >> 1, i = l, j = mid + 1, cur = 0;
mergesort2(l, mid, lv - 1);
mergesort2(mid + 1, r, lv - 1);
while (i <= mid && j <= r) {
if (b[j] > b[i]) {
inv2[lv - 1] += mid - i + 1;
tmp[cur++] = b[j++];
} else
tmp[cur++] = b[i++];
}
while (i <= mid) tmp[cur++] = b[i++];
while (j <= r) tmp[cur++] = b[j++];
for (int t = int(r), _b = int(l); t >= _b; t--) b[t] = tmp[--cur];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> p;
n = 1 << p;
for (int i = int(0), _b = int(n - 1); i <= _b; i++) {
cin >> a[i];
b[i] = a[i];
}
mergesort1(0, n - 1, p);
mergesort2(0, n - 1, p);
inv1[p] = inv1[p - 1];
inv2[p] = inv2[p - 1];
cin >> m;
while (m--) {
int q;
cin >> q;
for (int i = int(0), _b = int(q - 1); i <= _b; i++) stat[i] ^= 1;
long long res = 0;
for (int i = int(0), _b = int(p - 1); i <= _b; i++)
res += stat[i] ? inv2[i] : inv1[i];
cout << res << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 20) + 5;
int A[maxn], tmp[maxn], cur, p[maxn];
long long s[2][25];
bool flip[25];
void mgsort(int l, int r, int h) {
if (l == r) return;
int m = (l + r) >> 1;
mgsort(l, m, h - 1), mgsort(m + 1, r, h - 1);
long long res = 0;
int i = l, j = m + 1, k = l;
for (; i <= m && j <= r;) {
if (p[i] < p[j])
res += r + 1 - j, tmp[k++] = p[i++];
else
tmp[k++] = p[j++];
}
while (i <= m) tmp[k++] = p[i++];
while (j <= r) tmp[k++] = p[j++];
for (int(i) = (int)(l); (i) <= (int)(r); ++(i)) p[i] = tmp[i];
s[cur][h] += res;
}
int main(int argc, char const *argv[]) {
int n;
scanf("%d", &n);
for (int(i) = (int)(1); (i) <= (int)(1 << n); ++(i))
scanf("%d", A + i), p[i] = A[i];
mgsort(1, 1 << n, n);
for (int(i) = (int)(1); (i) <= (int)(1 << n); ++(i)) p[i] = -A[i];
cur ^= 1;
mgsort(1, 1 << n, n);
int Q;
scanf("%d", &Q);
for (int(i) = (int)(0); (i) <= (int)(n); ++(i)) flip[i] = true;
while (Q--) {
int q;
scanf("%d", &q);
for (int(i) = (int)(1); (i) <= (int)(q); ++(i)) flip[i] ^= 1;
long long res = 0;
for (int(i) = (int)(1); (i) <= (int)(n); ++(i)) res += s[flip[i]][i];
printf("%I64d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
int n, s, m, a[2000000], at[2000000], q[1000000];
long long sum[21], same[21];
long long V(int x) { return (long long)x * (x - 1) / 2; }
long long Merge(int l, int r, int t) {
if (l == r) return 0;
int mid = (l + r) / 2;
long long ret = Merge(l, mid, t - 1) + Merge(mid + 1, r, t - 1);
for (int i = l, j = mid + 1, k = l; i <= mid || j <= r; k++) {
if (i > mid)
at[k] = a[j++];
else if (j > r)
at[k] = a[i++];
else if (a[i] <= a[j])
at[k] = a[i++];
else
at[k] = a[j++], ret += mid - i + 1;
}
for (int i = l; i <= r; i++) a[i] = at[i];
for (int i = l, j = l + 1; i <= r; i = j++) {
while (j <= r && a[j] == a[i]) j++;
same[t] += V(j - i);
}
sum[t] += ret;
return ret;
}
int main() {
scanf("%d", &n), s = 1 << n;
for (int i = 0; i < s; i++) scanf("%d", &a[i]);
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", &q[i]);
Merge(0, s - 1, n);
for (int i = 0; i <= n; i++) same[i] = V(1 << i) * (1 << (n - i)) - same[i];
for (int i = 0; i < m; i++) {
long long tmp = sum[q[i]];
for (int j = q[i]; j <= n; j++) sum[j] += same[q[i]] - tmp * 2;
for (int j = 0; j < q[i]; j++) sum[j] = same[j] - sum[j];
printf("%I64d\n", sum[n]);
}
getchar();
getchar();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 20) + 10, MAXNN = 20 + 5;
int N, n, c[MAXN], a[MAXN], zz[MAXN], M, tot;
long long sum[MAXNN], inv[MAXNN], ans, eqqual[MAXNN];
void add(int x, int y) {
for (; x <= n; x += x & -x) c[x] += y;
}
int query(int x) {
int res = 0;
for (; x; x -= x & -x) res += c[x];
return res;
}
void make(int l, int r, int depth) {
if (l < r) {
int mid = (l + r) >> 1;
make(l, mid, depth + 1);
make(mid + 1, r, depth + 1);
int len = mid - l + 1;
sum[depth] += (long long)len * (r - mid);
for (int i = mid + 1; i <= r; ++i) add(a[i], 1);
for (int i = l; i <= mid; ++i) {
inv[depth] += query(a[i] - 1);
eqqual[depth] += query(a[i]) - query(a[i] - 1);
}
for (int i = mid + 1; i <= r; ++i) add(a[i], -1);
}
}
int main() {
scanf("%d", &N);
n = 1 << N;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
zz[i] = a[i];
}
sort(zz + 1, zz + n + 1);
tot = unique(zz + 1, zz + n + 1) - zz - 1;
for (int i = 1; i <= n; ++i)
a[i] = lower_bound(zz + 1, zz + tot + 1, a[i]) - zz;
make(1, n, 0);
for (int i = 0; i <= N; ++i) ans += inv[i];
scanf("%d", &M);
for (int i = 1; i <= M; ++i) {
int tmp;
scanf("%d", &tmp);
tmp = N - tmp;
for (int j = tmp; j <= N; ++j) {
ans -= inv[j];
inv[j] = (sum[j] - eqqual[j]) - inv[j];
ans += inv[j];
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 20;
long long invCnt[MaxN + 1][2];
void build(int dep, int *a, int n) {
if (n == 1) return;
int m = n / 2;
build(dep + 1, a, m);
build(dep + 1, a + m, m);
int out_n = 0;
static int type[1 << MaxN];
static int out[1 << MaxN];
int i = 0, j = m;
while (i < m || j < n) {
if (i < m && (j == n || a[i] < a[j]))
type[out_n] = 0, out[out_n++] = a[i++];
else
type[out_n] = 1, out[out_n++] = a[j++];
}
for (int i = 0, j = 0, r = 0; i < out_n; i++) {
while (j < out_n && out[j] < out[i]) {
if (type[j] == 1) r++;
j++;
}
if (type[i] == 0) invCnt[dep][0] += r;
}
for (int i = 0, j = 0, r = 0; i < out_n; i++) {
while (j < out_n && out[j] < out[i]) {
if (type[j] == 0) r++;
j++;
}
if (type[i] == 1) invCnt[dep][1] += r;
}
copy(out, out + out_n, a);
}
int main() {
int n;
static int a[1 << MaxN];
cin >> n;
for (int i = 0; i < (1 << n); i++) scanf("%d", &a[i]);
build(0, a, 1 << n);
static bool revB[MaxN + 1];
int m;
cin >> m;
while (m--) {
int q;
scanf("%d", &q);
q = n - q;
revB[q] = !revB[q];
long long res = 0;
bool b = false;
for (int i = 0; i < n; i++) {
b ^= revB[i];
res += invCnt[i][b];
}
printf("%I64d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1300000;
int n, m, p, q;
int a[maxn];
int b[maxn];
long long inv[maxn];
long long sum[maxn];
long long eq[maxn];
struct BIT {
long long dt[maxn];
void init() { memset(dt, 0, sizeof dt); }
int lowbit(int x) { return x & -x; }
void modify(int x, long long c = 1) {
for (int i = x; i < maxn; i += lowbit(i)) {
dt[i] += c;
}
}
long long query(int x) {
long long res = 0;
for (int i = x; i > 0; i -= lowbit(i)) {
res += dt[i];
}
return res;
}
} bit;
void slove(int l, int r, int d) {
if (l == r) return;
int m = (l + r) >> 1;
slove(l, m, d + 1);
slove(m + 1, r, d + 1);
long long len = (long long)(m - l + 1) * (long long)(r - m);
sum[d] += len;
for (int i = m + 1; i <= r; i++) bit.modify(a[i]);
for (int i = l; i <= m; i++) {
inv[d] += bit.query(a[i] - 1);
eq[d] += bit.query(a[i]) - bit.query(a[i] - 1);
}
for (int i = m + 1; i <= r; i++) bit.modify(a[i], -1);
}
int main() {
while (~scanf("%d", &n)) {
int nn = n;
n = 1 << n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memcpy(b, a, sizeof a);
sort(b + 1, b + n + 1);
int size = unique(b + 1, b + 1 + n) - (b + 1);
for (int i = 1; i <= n; i++)
a[i] = lower_bound(b + 1, b + 1 + size, a[i]) - (b + 1) + 1;
bit.init();
memset(sum, 0, sizeof sum);
memset(inv, 0, sizeof inv);
memset(eq, 0, sizeof eq);
slove(1, n, 0);
scanf("%d", &m);
long long ans = 0;
for (int i = 0; i < nn; i++) ans += inv[i];
while (m--) {
int k;
scanf("%d", &k);
k = nn - k;
for (int i = k; i <= nn; i++) {
ans -= inv[i];
inv[i] = sum[i] - eq[i] - inv[i];
ans += inv[i];
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000010, D = 25;
int n, q, a[N], te[N], b[D];
long long x[D], y[D];
void calc(int l, int r, int d) {
if (!d) return;
int m = l + r >> 1, p = r - l + 1 >> 1;
calc(l, m, d - 1);
calc(m + 1, r, d - 1);
for (int i = 1, j = 1; i <= p; i++) {
while (j <= p && a[l + i - 1] > a[m + j]) j++;
x[d] += j - 1;
}
for (int i = 1, j = 1; i <= p; i++) {
while (j <= p && a[l + i - 1] >= a[m + j]) j++;
y[d] += p + 1 - j;
}
merge(a + l, a + m + 1, a + m + 1, a + r + 1, te);
for (int i = l; i <= r; i++) a[i] = te[i - l];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= 1 << n; i++) scanf("%d", &a[i]);
calc(1, 1 << n, n);
scanf("%d", &q);
while (q--) {
int t;
long long s = 0;
scanf("%d", &t);
for (int i = 0; i <= t; i++) b[i] ^= 1;
for (int i = 0; i <= n; i++)
if (!b[i])
s += x[i];
else
s += y[i];
printf("%lld\n", s);
}
return 0;
}
|
#include <bits/stdc++.h>
const long long M = 1 << 21;
using namespace std;
long long sum[30][2], a[M], b[M], x, ans, Q, n, N;
long long read() {
long long 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 work(long long l, long long r, long long deep) {
if (deep == 0) {
sum[deep][0] = sum[deep][1] = 0;
return;
}
long long mid = (l + r) >> 1;
work(l, mid, deep - 1);
work(mid + 1, r, deep - 1);
for (int i = l; i <= mid; i++)
sum[deep][0] += lower_bound(a + mid + 1, a + r + 1, a[i]) - (a + mid + 1);
for (int i = mid + 1; i <= r; i++)
sum[deep][1] += lower_bound(a + l, a + mid + 1, a[i]) - (a + l);
sort(a + l, a + r + 1);
}
int main() {
n = read();
N = 1 << n;
for (long long i = 1; i <= N; i++) a[i] = read();
work(1, N, n);
Q = read();
for (long long I = 1; I <= Q; I++) {
x = read();
ans = 0;
for (long long i = x; i >= 0; i--) swap(sum[i][0], sum[i][1]);
for (long long i = 0; i <= n; i++) ans += sum[i][0];
printf("%I64d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const double eps = 1e-10;
const int maxn = 1111111;
long long s[2][30];
int now[30];
long long pow2[30];
int A[maxn], AA[maxn], T[maxn];
int n, m;
void merge_sort(int *A, int x, int y, int *T, int level) {
if (y <= x) return;
int m = x + (y - x) / 2;
int p = x, q = m + 1, i = x;
merge_sort(A, x, m, T, level + 1);
merge_sort(A, m + 1, y, T, level + 1);
while (p <= m || q <= y) {
if (q > y || (p <= m && A[p] <= A[q]))
T[i++] = A[p++];
else {
s[0][level] += m - p + 1;
T[i++] = A[q++];
}
}
for (int i = x; i <= y; i++) A[i] = T[i];
}
void merge_sort2(int *A, int x, int y, int *T, int level) {
if (y <= x) return;
int m = x + (y - x) / 2;
int p = x, q = m + 1, i = x;
merge_sort2(A, x, m, T, level + 1);
merge_sort2(A, m + 1, y, T, level + 1);
while (p <= m || q <= y) {
if (q > y || (p <= m && A[p] >= A[q]))
T[i++] = A[p++];
else {
s[1][level] += m - p + 1;
T[i++] = A[q++];
}
}
for (int i = x; i <= y; i++) A[i] = T[i];
}
int main() {
pow2[0] = 1;
for (int i = 1; i <= 22; i++) pow2[i] = pow2[i - 1] * 2;
scanf("%d", &n);
for (int i = 0; i < (pow2[n]); ++i) scanf("%d", &A[i]), AA[i] = A[i];
merge_sort(A, 0, pow2[n] - 1, T, 0);
merge_sort2(AA, 0, pow2[n] - 1, T, 0);
scanf("%d", &m);
while (m--) {
int x;
scanf("%d", &x);
for (int i = x; i >= 1; i--) {
int y = n - i;
now[y] ^= 1;
}
long long ans = 0;
for (int i = 0; i <= n; i++) ans += s[now[i]][i];
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21, M = 1 << 20 + 1;
int n, mm, a[M];
long long inv[N], inv2[N];
void build(int h, int l, int r) {
if (h == 0) return;
int m = (l + r) / 2;
build(h - 1, l, m);
build(h - 1, m + 1, r);
vector<int> v;
int i = l, j = m + 1, k, c;
while (i <= m && j <= r) {
if (a[i] < a[j]) {
inv2[h] += (long long)(r - j + 1);
v.push_back(a[i++]);
} else if (a[j] < a[i]) {
inv[h] += (long long)(m - i + 1);
v.push_back(a[j++]);
} else {
k = i, c = a[i];
while (k <= m && a[k] == c) k++;
if (k <= r) inv[h] += (long long)(m - k + 1);
v.push_back(a[j++]);
}
}
while (i <= m) v.push_back(a[i++]);
while (j <= r) v.push_back(a[j++]);
for (int i = l, j = 0; i <= r; i++, j++) a[i] = v[j];
}
int main() {
std::ios::sync_with_stdio(false);
scanf("%d", &n);
int m = 1 << n;
mm = m;
for (int i = 0; i < m; i++) scanf("%d", a + i);
build(n, 0, m - 1);
int q, h;
scanf("%d", &q);
while (q--) {
scanf("%d", &h);
for (int i = 0; i <= h; i++) swap(inv[i], inv2[i]);
long long ans = 0;
for (int i = 0; i <= n; i++) ans += inv[i];
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long leftAns[21], rightAns[21];
int n, m, query, k, a[2000000], b[2000000];
int get_inver(int l1, int r1, int value) {
int res = 0;
int end = r1;
while (r1 - l1 > 1) {
int m = (l1 + r1) >> 1;
if (b[m] > value)
r1 = m;
else
l1 = m;
}
res = end - r1;
if (b[r1] > value) res++;
return res;
}
void my_m(int l1, int r1, int l2, int r2) {
int st = l1;
static int c[2000000];
int d = 0;
int v = r2 - l1 + 1;
for (int j = 1; j < v; j <<= 1, d++)
;
int cnt = -1;
while (l1 <= r1 || l2 <= r2) {
cnt++;
if (l1 <= r1 && (l2 > r2 || b[l1] <= b[l2])) {
rightAns[d] += get_inver(l2 - 1, r2, b[l1]);
c[cnt] = b[l1++];
} else {
leftAns[d] += get_inver(l1 - 1, r1, b[l2]);
c[cnt] = b[l2++];
}
}
for (int i = 0; i <= cnt; i++) {
b[st + i] = c[i];
}
}
void getValues(int l, int r) {
if (r - l <= 1) {
if (a[l] > a[r])
leftAns[1]++;
else if (a[l] < a[r])
rightAns[1]++;
b[l] = min(a[l], a[r]);
b[r] = max(a[l], a[r]);
} else {
int tm = (l + r) >> 1;
getValues(l, tm);
getValues(tm + 1, r);
my_m(l, tm, tm + 1, r);
}
}
int main() {
scanf("%d", &n);
int nD = n;
n = pow(2, n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
getValues(0, n - 1);
for (int i = 2; i <= nD; i++) {
leftAns[i] += leftAns[i - 1];
rightAns[i] += rightAns[i - 1];
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
long long addValue = 0;
scanf("%d", &query);
for (int j = 1; j <= query; j++) {
if (j == query) {
addValue = rightAns[j] - leftAns[j];
break;
}
long long sw = leftAns[j];
leftAns[j] = rightAns[j];
rightAns[j] = sw;
}
for (int j = query; j <= nD; j++) {
leftAns[j] += addValue;
rightAns[j] -= addValue;
}
printf("%I64d\n", leftAns[nD]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char IO_MODE = 3;
inline long long ReadInt() {
long long 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;
}
inline void WriteInt(long long x) {
char CH[20];
if (x < 0) {
putchar('-');
x = -x;
}
int Num = 0;
if (!x) {
putchar('0');
return;
}
while (x > 0) CH[++Num] = x % 10, x /= 10;
while (Num) putchar(CH[Num--] + 48);
}
inline void out(int x) {
if (IO_MODE & 1)
WriteInt(x);
else
printf("%i", x);
}
template <typename... Args>
inline void out(int x, Args... args) {
out(x);
putc(' ', stdout);
out(args...);
}
inline void in(int &x) {
if (IO_MODE & 2)
x = ReadInt();
else
scanf("%i", &x);
}
template <typename... Args>
inline void in(int &x, Args &...args) {
in(x);
in(args...);
}
inline void outll(long long x) {
if (IO_MODE & 1)
WriteInt(x);
else
printf("%I64d", x);
}
template <typename... Args>
inline void outll(long long x, Args... args) {
outll(x);
putc(' ', stdout);
outll(args...);
}
inline void inll(long long &x) {
if (IO_MODE & 2)
x = ReadInt();
else
scanf("%I64d", &x);
}
template <typename... Args>
inline void inll(long long &x, Args &...args) {
inll(x);
inll(args...);
}
int aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, mm, nn, oo, pp, qq, rr, ss, tt,
uu, vv, ww, xx, yy, zz;
int tc;
int n, q, p, mask;
int A[1 << 22];
long long Ans[22];
long long More[2][22];
inline long long build(int l, int r, int lev) {
if (l == r) return 0;
long long L_ans = build(l, l + r >> 1, lev - 1);
long long R_ans = build((l + r >> 1) + 1, r, lev - 1);
long long ans = 0, L_more = 0, R_more = 0;
int tmp[r - l + 1];
int i = 0, j = 0, k = 0;
int *L = &A[l];
int *R = &A[(l + r >> 1) + 1];
int N = r - l + 1 >> 1;
while (k < N << 1) {
if (i == N)
while (j < N) tmp[k++] = R[j++], R_more += i;
else if (j == N)
while (i < N) tmp[k++] = L[i++], L_more += j;
else if (L[i] < R[j])
while (i < N && L[i] < R[j]) tmp[k++] = L[i++], L_more += j;
else if (L[i] > R[j])
while (j < N && L[i] > R[j]) tmp[k++] = R[j++], R_more += i;
else {
int pre_i = i;
int pre_j = j;
int pre_k = k;
int val = L[i];
while (i < N && L[i] == val) tmp[k++] = L[i++], L_more += pre_j;
while (j < N && R[j] == val) tmp[k++] = R[j++], R_more += pre_i;
}
}
N <<= 1;
for (int i = 0; i < N; i++) L[i] = tmp[i];
ans += L_ans + R_ans + L_more;
Ans[lev] += ans;
More[0][lev] += L_more;
More[1][lev] += R_more;
return ans;
}
int main() {
in(n);
for (int i = 0; i < 1 << n; i++) in(A[i]);
build(0, (1 << n) - 1, n);
in(q);
while (q--) {
in(p);
mask ^= (1 << p + 1) - 1;
for (int i = 1; i <= n; i++)
Ans[i] = Ans[i - 1] + More[!!(mask & 1 << i)][i];
outll(Ans[n]);
putc('\n', stdout);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1050010;
struct P {
int b, v, c;
} p[maxn];
int a[maxn];
int d[maxn];
int temp[23];
long long g[23][2];
int n;
bool cmp1(P b1, P b2) { return b1.b < b2.b; }
bool cmp2(P b1, P b2) { return b1.v < b2.v; }
int lowbit(int x) { return x & (-x); }
void change(int x, int y) {
while (x <= (1 << n)) {
d[x] += y;
x += lowbit(x);
}
return;
}
int sum(int k) {
int ans = 0;
while (k > 0) {
ans += d[k];
k -= lowbit(k);
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (1 << n); i++) {
scanf("%d", &a[i]);
p[i].b = a[i];
p[i].v = i;
}
sort(p, p + (1 << n), cmp1);
for (int i = 0; i < (1 << n); i++) {
p[i].c = i + 1;
if (i == 0) continue;
if (p[i].b == p[i - 1].b) p[i].c = p[i - 1].c;
}
sort(p, p + (1 << n), cmp2);
for (int i = 0; i < (1 << n); i++) a[i] = p[i].c;
for (int j = 0; j < (1 << n); j += 2)
if (a[j + 1] > a[j])
g[1][1]++;
else if (a[j + 1] < a[j])
g[1][0]++;
for (int i = 2; i <= n; i++) {
int k = 0;
for (int j = 0; j < (1 << n); j++) {
g[i][0] += (k - sum(a[j]));
g[i][1] += (sum(a[j] - 1));
k++;
if (k == (1 << i)) {
if (i >= 10)
memset(d, 0, sizeof(d));
else
for (int l = j - 1;; l--) {
change(a[l], -1);
if ((l % (1 << i)) == 0) break;
}
k = 0;
} else
change(a[j], 1);
}
}
for (int i = n; i > 1; i--) {
g[i][1] = g[i][1] - g[i - 1][1];
g[i][0] = g[i][0] - g[i - 1][0];
}
memset(temp, 0, sizeof(temp));
int m, q;
long long ans;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &q);
for (int j = q; j > 0; j--) {
temp[j] = 1 - temp[j];
}
ans = 0;
for (int j = 1; j <= n; j++) ans += g[j][temp[j]];
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int md = 1000000007;
const double esp = 0.000000000001;
int bit[5555555];
int a[11111111];
int n, q;
vector<int> seg[2222222];
long long larger[2222222], smaller[2222222];
long long largerh[22], smallerh[22], sumnode[22];
int query[2222222];
int stt[22];
int read() {
scanf("%d", &n);
for (int i = 1; i <= (1 << n); i++) scanf("%d", a + i);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d", query + i);
query[i] = n - query[i];
}
return 0;
}
int buildSEG(int i, int l, int r, int h) {
if (l == r) {
seg[i].push_back(a[l]);
return 0;
}
int mid = (l + r) / 2;
buildSEG(2 * i, l, mid, h + 1);
buildSEG(2 * i + 1, mid + 1, r, h + 1);
int y = 0;
for (int x = 0; x < seg[2 * i].size(); x++) {
while (y < seg[2 * i + 1].size() && seg[2 * i + 1][y] < seg[2 * i][x]) {
seg[i].push_back(seg[2 * i + 1][y]);
y++;
}
larger[i] += y;
seg[i].push_back(seg[2 * i][x]);
}
for (int j = y; j < seg[2 * i + 1].size(); j++)
seg[i].push_back(seg[2 * i + 1][j]);
y = seg[2 * i + 1].size() - 1;
for (int x = seg[2 * i].size() - 1; x >= 0; x--) {
while (y >= 0 && seg[2 * i + 1][y] > seg[2 * i][x]) y--;
smaller[i] += seg[2 * i + 1].size() - y - 1;
}
largerh[h + 1] += larger[i];
smallerh[h + 1] += smaller[i];
return 0;
}
int init() {
buildSEG(1, 1, (1 << n), 0);
for (int i = n - 1; i >= 0; i--) sumnode[i] = sumnode[i + 1] + largerh[i + 1];
return 0;
}
int process() {
for (int i = 1; i <= q; i++) {
if (query[i] == n) {
printf("%I64d\n", sumnode[0]);
continue;
}
for (int j = query[i] + 1; j <= n; j++) {
stt[j]++;
stt[j] %= 2;
}
for (int j = n; j >= 0; j--) {
long long between;
if (stt[j + 1] == 0)
between = largerh[j + 1];
else
between = smallerh[j + 1];
sumnode[j] = sumnode[j + 1] + between;
}
printf("%I64d\n", sumnode[0]);
}
return 0;
}
int main() {
read();
init();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 20) + 50;
int n, a[maxn], N, b[maxn];
long long same[30], inv[30], all[30];
struct ar_tree {
long long c[maxn];
void add(int x, int k) {
for (; x <= N; x += x & -x) c[x] += k;
}
long long query(int x) {
long long res(0);
for (; x; x -= x & -x) res += c[x];
return res;
}
} T;
void solve(int l, int r, int dep) {
if (l == r) return;
int mid = (l + r) >> 1;
solve(l, mid, dep + 1);
solve(mid + 1, r, dep + 1);
for (int i = mid + 1; i <= r; ++i) T.add(a[i], 1);
all[dep] += (long long)(mid - l + 1) * (r - mid);
for (int i = l; i <= mid; ++i)
inv[dep] += T.query(a[i] - 1),
same[dep] += T.query(a[i]) - T.query(a[i] - 1);
for (int i = mid + 1; i <= r; ++i) T.add(a[i], -1);
}
int main() {
scanf("%d", &n);
N = 1 << n;
for (int i = 1; i <= N; ++i) scanf("%d", &a[i]), b[i] = a[i];
sort(b + 1, b + 1 + N);
int m = unique(b + 1, b + 1 + N) - (b + 1);
for (int i = 1; i <= N; ++i) a[i] = lower_bound(b + 1, b + 1 + m, a[i]) - b;
solve(1, N, 0);
int Q;
for (scanf("%d", &Q); Q--;) {
int t;
scanf("%d", &t);
t = n - t;
for (int i = t; i <= n; ++i) inv[i] = all[i] - inv[i] - same[i];
long long res(0);
for (int i = 0; i <= n; ++i) res += inv[i];
printf("%I64d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long LLMAX = 9223372036854775807LL;
const int MOD = 1000000007;
const int maxn = 100000 + 10;
long long gt[111], lt[111];
int n, m;
int a[1 << 21];
void solve(int d, int s, int t) {
if (t - s == 1) return;
int u = (s + t) / 2;
solve(d - 1, s, u);
solve(d - 1, u, t);
int lb = u, ub = u;
for (int i = s; i < u; ++i) {
for (; lb < t; ++lb)
if (a[lb] >= a[i]) break;
for (; ub < t; ++ub)
if (a[ub] > a[i]) break;
lt[d] += lb - u;
gt[d] += t - ub;
}
inplace_merge(a + s, a + u, a + t);
}
int main() {
scanf("%d", &(n));
for (int i = 0; i < (1 << n); ++i) scanf("%d", &(a[i]));
solve(n - 1, 0, 1 << n);
scanf("%d", &(m));
int q;
long long now = 0;
for (int i = 0; i < n; ++i) now += lt[i];
while (m--) {
scanf("%d", &(q));
for (int i = 0; i < q; ++i) {
now = now - lt[i] + gt[i];
swap(lt[i], gt[i]);
}
printf("%I64d\n", now);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxm = 1e3 + 5;
const int mod = 1e9 + 7;
long long f[21][2];
int a[(1 << 20) + 5];
void dfs(int l, int r, int deep) {
if (deep == 0) return;
int m = (l + r) / 2;
dfs(l, m, deep - 1);
dfs(m, r, deep - 1);
for (int i = l; i < m; i++) {
f[deep][0] += lower_bound(a + m, a + r, a[i]) - (a + m);
f[deep][1] += (a + r) - upper_bound(a + m, a + r, a[i]);
}
sort(a + l, a + r);
}
inline void solve() {
int n, m;
scanf("%d", &n);
int up = 1 << n;
for (int i = 0; i < up; i++) scanf("%d", &a[i]);
dfs(0, up, n);
scanf("%d", &m);
while (m--) {
int q;
scanf("%d", &q);
for (int i = 1; i < q + 1; i++) swap(f[i][0], f[i][1]);
long long ans = 0;
for (int i = 1; i < n + 1; i++) ans += f[i][0];
printf("%lld\n", ans);
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
int a[1 << 20];
int b[1 << 20];
int left[(1 << 19) + 1];
int right[(1 << 19) + 1];
int n, m;
struct pair {
int64_t a, b;
};
pair inversions[20];
int state;
int64_t merge(int a[], int l, int m, int r, bool dir) {
int left_size = m - l + 1;
int right_size = r - m;
memcpy(left, &a[l], left_size * sizeof(int));
memcpy(right, &a[m + 1], right_size * sizeof(int));
if (dir) {
left[left_size] = INT_MAX;
right[right_size] = INT_MAX;
} else {
left[left_size] = INT_MIN;
right[right_size] = INT_MIN;
}
int lp = 0;
int rp = 0;
int64_t n = 0;
for (int i = l; i <= r; ++i) {
if (dir) {
if (left[lp] <= right[rp]) {
a[i] = left[lp++];
} else {
a[i] = right[rp++];
n += left_size - lp;
}
} else {
if (left[lp] >= right[rp]) {
a[i] = left[lp++];
} else {
a[i] = right[rp++];
n += left_size - lp;
}
}
}
return n;
}
int64_t merge_sort(int a[], int l, int r, int depth, bool dir) {
int64_t inv = 0;
if (l < r) {
int mid = (l + r) / 2;
merge_sort(a, l, mid, depth + 1, dir);
merge_sort(a, mid + 1, r, depth + 1, dir);
inv += merge(a, l, mid, r, dir);
}
if (dir) {
inversions[depth].a += inv;
} else {
inversions[depth].b += inv;
}
return inv;
}
void print_inv() {
int64_t inv = 0;
for (int i = 0; i < n; ++i) {
inv += (state & 1 << i) ? inversions[i].b : inversions[i].a;
}
printf("%" PRId64 "\n", inv);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (1 << n); ++i) scanf("%d", &a[i]);
memcpy(b, a, (1 << n) * sizeof(int));
merge_sort(a, 0, (1 << n) - 1, 0, true);
merge_sort(b, 0, (1 << n) - 1, 0, false);
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
int q;
scanf("%d", &q);
for (int j = n - q; j < n; ++j) {
state ^= 1 << j;
}
print_inv();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1500005];
long long f[55], g[55];
inline void merge(int l, int r, int x) {
if (l >= r) return;
int mid = (l + r) >> 1;
merge(l, mid, x - 1), merge(mid + 1, r, x - 1);
for (int i = l; i <= mid; i++) {
f[x] += lower_bound(a + mid + 1, a + r + 1, a[i]) - (a + mid + 1);
g[x] +=
r - mid - (upper_bound(a + mid + 1, a + r + 1, a[i]) - (a + mid + 1));
}
sort(a + l, a + r + 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= (1 << n); i++) scanf("%d", &a[i]);
merge(1, (1 << n), n);
int query;
scanf("%d", &query);
while (query--) {
int x;
long long ans = 0;
scanf("%d", &x);
for (int i = 1; i <= x; i++) swap(f[i], g[i]);
for (int i = 1; i <= n; i++) ans += f[i];
printf("%I64d\n", ans);
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class T>
inline void RST(T &A) {
memset(A, 0, sizeof(A));
}
template <class T>
inline void FLC(T &A, int x) {
memset(A, x, sizeof(A));
}
template <class T>
inline void CLR(T &A) {
A.clear();
}
const int dx4[] = {-1, 0, 1, 0};
const int dy4[] = {0, 1, 0, -1};
const int dx8[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy8[] = {0, 1, 0, -1, -1, 1, -1, 1};
const int dxhorse[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const int dyhorse[] = {1, -1, 2, -2, 2, -2, 1, -1};
const int mod = 1000000007;
const int inf = 0x3f3f3f3f;
const long long inff = 1LL << 60;
const double eps = 1e-9;
const double oo = 1e25;
const double pi = acos(-1.0);
template <class T>
inline void checkMin(T &a, const T b) {
if (b < a) a = b;
}
template <class T>
inline void checkMax(T &a, const T b) {
if (a < b) a = b;
}
template <class T>
inline void checkMin(T &a, T &b, const T x) {
checkMin(a, x), checkMin(b, x);
}
template <class T>
inline void checkMax(T &a, T &b, const T x) {
checkMax(a, x), checkMax(b, x);
}
template <class T, class C>
inline void checkMin(T &a, const T b, C c) {
if (c(b, a)) a = b;
}
template <class T, class C>
inline void checkMax(T &a, const T b, C c) {
if (c(a, b)) a = b;
}
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
template <class T>
inline T sqr(T a) {
return a * a;
}
template <class T>
inline T cub(T a) {
return a * a * a;
}
template <class T>
inline T ceil(T x, T y) {
return (x - 1) / y + 1;
}
inline int sgn(double x) { return x < -eps ? -1 : x > eps; }
inline int sgn(double x, double y) { return sgn(x - y); }
inline double cot(double x) { return 1. / tan(x); };
inline double sec(double x) { return 1. / cos(x); };
inline double csc(double x) { return 1. / sin(x); };
namespace BO {
inline bool _1(int x, int i) { return bool(x & 1 << i); }
inline bool _1(long long x, int i) { return bool(x & 1LL << i); }
inline long long _1(int i) { return 1LL << i; }
inline long long _U(int i) { return _1(i) - 1; };
inline int reverse_bits(int x) {
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa);
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc);
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0);
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00);
x = ((x >> 16) & 0x0000ffff) | ((x << 16) & 0xffff0000);
return x;
}
inline long long reverse_bits(long long x) {
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL);
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL);
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL);
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL);
x = ((x >> 16) & 0x0000ffff0000ffffLL) | ((x << 16) & 0xffff0000ffff0000LL);
x = ((x >> 32) & 0x00000000ffffffffLL) | ((x << 32) & 0xffffffff00000000LL);
return x;
}
template <class T>
inline bool odd(T x) {
return x & 1;
}
template <class T>
inline bool even(T x) {
return !odd(x);
}
template <class T>
inline T low_bit(T x) {
return x & -x;
}
template <class T>
inline T high_bit(T x) {
T p = low_bit(x);
while (p != x) x -= p, p = low_bit(x);
return p;
}
template <class T>
inline T cover_bit(T x) {
T p = 1;
while (p < x) p <<= 1;
return p;
}
template <class T>
inline int cover_idx(T x) {
int p = 0;
while (_1(p) < x) ++p;
return p;
}
inline int clz(int x) { return __builtin_clz(x); }
inline int clz(long long x) { return __builtin_clzll(x); }
inline int ctz(int x) { return __builtin_ctz(x); }
inline int ctz(long long x) { return __builtin_ctzll(x); }
inline int lg2(int x) { return !x ? -1 : 31 - clz(x); }
inline int lg2(long long x) { return !x ? -1 : 63 - clz(x); }
inline int low_idx(int x) { return !x ? -1 : ctz(x); }
inline int low_idx(long long x) { return !x ? -1 : ctz(x); }
inline int high_idx(int x) { return lg2(x); }
inline int high_idx(long long x) { return lg2(x); }
inline int parity(int x) { return __builtin_parity(x); }
inline int parity(long long x) { return __builtin_parityll(x); }
inline int count_bits(int x) { return __builtin_popcount(x); }
inline int count_bits(long long x) { return __builtin_popcountll(x); }
} // namespace BO
using namespace BO;
namespace NT {
template <class T>
inline T lowbit(T x) {
return x & -x;
}
template <class T>
inline T GCD(T A, T B) {
T C;
while (B != 0) C = B, B = A % B, A = C;
return A;
}
template <class T>
inline T LCM(T A, T B) {
return A * (B / GCD(A, B));
}
template <class T>
inline T Mod(T a, T b) {
a %= b;
return a < 0 ? a + b : a;
}
template <class T>
inline T MulMod(T a, T b, T c) {
if (c == 1) return 0;
if (c <= 0) return -1;
T ret = 0, tmp;
tmp = a = Mod(a, c);
b = Mod(b, c);
while (b) {
if (b & 0x1)
if ((ret += tmp) >= c) ret -= c;
if ((tmp <<= 1) >= c) tmp -= c;
b >>= 1;
}
return ret;
}
template <class T, class Tb>
inline T PowMod(Tb a, T b, T c) {
if (c == 1) return 0;
if (c <= 0) return -1;
a = Mod(a, (Tb)c);
Tb ret(1L % c);
while (b) {
if (b & 0x1) ret = ret * a % c;
a = a * a % c;
b >>= 1;
}
return (T)ret;
}
template <class T>
inline T HPowMod(T a, T b, T c) {
if (c == 1) return 0;
if (c <= 0) return -1;
a = Mod(a, c);
T ret(1L % c);
while (b) {
if (b & 0x1) ret = MulMod(ret, a, c);
a = MulMod(a, a, c);
b >>= 1;
}
return ret;
}
template <class T, class Tb>
inline T Pow(T a, Tb b) {
T c(1);
while (b) {
if (b & 1) c *= a;
a *= a, b >>= 1;
}
return c;
}
template <class T>
inline T EXT_GCD(T a, T b, T &x, T &y) {
T t, ret;
if (!b) {
x = 1, y = 0;
return a;
}
ret = EXT_GCD(b, a % b, x, y);
t = x, x = y, y = t - a / b * y;
return ret;
}
template <class T>
inline T Inv(T a, T n) {
if (n <= 0) return -1;
T d, x, y;
d = EXT_GCD(a, n, x, y);
if (d != 1) return -1;
return Mod(x, n);
}
template <class T, int MAXN, T MOD = -1>
class Matrix {
public:
T m[MAXN][MAXN];
Matrix() {}
void init(T num[MAXN][MAXN]) {
for (int i = 0; i < MAXN; i++) {
for (int j = 0; j < MAXN; j++) {
m[i][j] = num[i][j];
if (MOD != -1) m[i][j] %= MOD;
}
}
}
friend Matrix operator*(const Matrix &m1, const Matrix &m2) {
int i, j, k;
Matrix ret;
memset(ret.m, 0, sizeof(ret.m));
for (i = 0; i < MAXN; i++) {
for (j = 0; j < MAXN; j++)
if (m1.m[i][j]) {
for (k = 0; k < MAXN; k++) {
ret.m[i][k] += m1.m[i][j] * m2.m[j][k];
if (MOD != -1) ret.m[i][k] %= MOD;
}
}
}
return ret;
}
friend Matrix operator+(const Matrix &m1, const Matrix &m2) {
int i, j;
Matrix ret;
for (i = 0; i < MAXN; i++) {
for (j = 0; j < MAXN; j++) {
ret.m[i][j] = 0;
ret.m[i][j] = m1.m[i][j] + m2.m[i][j];
if (MOD != -1) ret.m[i][j] %= MOD;
}
}
return ret;
}
friend Matrix operator^(const Matrix &_M, long long nx) {
Matrix ret, M(_M);
for (int i = 0; i < MAXN; i++) {
for (int j = 0; j < MAXN; j++) {
if (i == j)
ret.m[i][j] = 1;
else
ret.m[i][j] = 0;
}
}
while (nx) {
if (nx & 1) ret = ret * M;
nx = nx >> 1;
M = M * M;
}
return ret;
}
};
} // namespace NT
using namespace NT;
namespace Date {
int days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
struct date {
int year, month, day;
};
inline int leap(int year) {
return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
}
inline int legal(date a) {
if (a.month < 0 || a.month > 12) return 0;
if (a.month == 2) return a.day > 0 && a.day <= 28 + leap(a.year);
return a.day > 0 && a.day <= days[a.month - 1];
}
inline int datecmp(date a, date b) {
if (a.year != b.year) return a.year - b.year;
if (a.month != b.month) return a.month - b.month;
return a.day - b.day;
}
int weekday(date a) {
int tm = a.month >= 3 ? (a.month - 2) : (a.month + 10);
int ty = a.month >= 3 ? a.year : (a.year - 1);
return (ty + ty / 4 - ty / 100 + ty / 400 + (int)(2.6 * tm - 0.2) + a.day) %
7;
}
int date2int(date a) {
int ret = a.year * 365 + (a.year - 1) / 4 - (a.year - 1) / 100 +
(a.year - 1) / 400,
i;
days[1] += leap(a.year);
for (i = 0; i < a.month - 1; ret += days[i++])
;
days[1] = 28;
return ret + a.day;
}
date int2date(int a) {
date ret;
ret.year = a / 146097 * 400;
for (a %= 146097; a >= 365 + leap(ret.year);
a -= 365 + leap(ret.year), ret.year++)
;
days[1] += leap(ret.year);
for (ret.month = 1; a >= days[ret.month - 1];
a -= days[ret.month - 1], ret.month++)
;
days[1] = 28;
ret.day = a + 1;
return ret;
}
} // namespace Date
namespace IO {
template <class T>
inline T RD(T &x) {
char c;
for (c = getchar(); c < '-'; c = getchar())
;
if (c == '-') {
x = '0' - getchar();
for (c = getchar(); '0' <= c && c <= '9'; c = getchar())
x = x * 10 + '0' - c;
} else {
x = c - '0';
for (c = getchar(); '0' <= c && c <= '9'; c = getchar())
x = x * 10 + c - '0';
}
return x;
}
inline long long RD() {
long long x;
return RD(x);
}
} // namespace IO
using namespace IO;
const int NN = (1 << 20) + 10;
int n, m, k;
long long x[25], y[25];
long long a[NN];
void build(int l, int r, int dep) {
if (l == r) {
return;
} else {
int mid = (l + r) / 2;
build(l, mid, dep - 1);
build(mid + 1, r, dep - 1);
for (int i = l; i <= mid; i++) {
x[dep] += upper_bound(a + mid + 1, a + r + 1, a[i] - 1) - (a + mid + 1);
y[dep] += a + r + 1 - lower_bound(a + mid + 1, a + r + 1, a[i] + 1);
}
sort(a + l, a + r + 1);
}
}
int main() {
k = RD();
n = 1 << k;
for (int i = 1; i <= n; i++) {
a[i] = RD();
}
build(1, n, k);
m = RD();
for (int i = 0; i < m; i++) {
int t = RD();
for (int i = 0; i <= t; i++) swap(x[i], y[i]);
long long sum = 0;
for (int i = 0; i < 25; i++) sum += x[i];
printf("%I64d\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 10;
int a[N];
long long ans[N], rans[N];
void merge_sort(int s, int e, int t) {
if (e - s < 2) return;
int mid = (s + e) / 2;
merge_sort(s, mid, t + 1);
merge_sort(mid, e, t + 1);
for (int i = s; i <= mid - 1; i++) {
ans[t] += lower_bound(a + mid, a + e, a[i]) - (a + mid);
long long x = e - mid;
x -= upper_bound(a + mid, a + e, a[i]) - (a + mid);
rans[t] += x;
}
sort(a + s, a + e);
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i <= (1 << n) - 1; i++) cin >> a[i];
merge_sort(0, (1 << n), 0);
int m;
cin >> m;
while (m--) {
int q;
cin >> q;
for (int i = n - q; i <= n; i++) swap(ans[i], rans[i]);
long long x = 0;
for (int i = 0; i <= n; i++) x += ans[i];
cout << x << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int n, m, a[1 << 21];
long long dp[21][2];
void merge_sort(int l, int r, int dep) {
if (l >= r) return;
int m = (l + r) / 2;
merge_sort(l, m, dep - 1);
merge_sort(m + 1, r, dep - 1);
for (int i = l; i <= m; i++) {
dp[dep][0] += lower_bound(a + m + 1, a + r + 1, a[i]) - (a + m + 1);
dp[dep][1] +=
r - m - (upper_bound(a + m + 1, a + r + 1, a[i]) - (a + m + 1));
}
sort(a + l, a + r + 1);
}
int main() {
scanf("%d", &n);
for (int i = 1, sz = (1 << n); i <= sz; i++) scanf("%d", a + i);
merge_sort(1, (1 << n), n);
scanf("%d", &m);
while (m--) {
int q;
long long ans = 0;
scanf("%d", &q);
for (int i = 1; i <= q; i++) swap(dp[i][0], dp[i][1]);
for (int i = 1; i <= n; i++) ans += dp[i][0];
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[(1 << 20) + 4], n;
long long store[21][2], INV = 0;
long long query(int l, int r, int no) {
return (A + r + 1 - upper_bound(A + l, A + r + 1, no));
}
void gen(int de, int l, int r) {
if (!de) return;
gen(de - 1, l, (l + r) / 2);
gen(de - 1, (l + r) / 2 + 1, r);
int a = l, b = (l + r) / 2, c = r;
for (int i = a; i <= b; i++) {
long long nos = query(b + 1, c, A[i]);
store[de][1] += nos;
}
for (int i = b + 1; i <= c; i++) {
long long nos = query(a, b, A[i]);
store[de][0] += nos;
}
sort(A + l, A + r + 1);
}
int main() {
cin >> n;
for (int i = 1; i <= (1 << n); i++) cin >> A[i];
gen(n, 1, (1 << n));
for (int de = n; de > 0; de--) INV += store[de][0];
int m;
cin >> m;
while (m--) {
int de;
cin >> de;
while (de != 0) {
INV -= store[de][0];
INV += store[de][1];
swap(store[de][0], store[de][1]);
de--;
}
printf("%lld\n", INV);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long Scal(vector<int>& a, vector<int>& b) {
int n = a.size();
long long odp = 0;
int i = 0, j = 0;
while (i < n && j < n) {
if (a[i] <= b[j])
++i;
else {
odp += n - i;
++j;
}
}
return odp;
}
int main() {
int n;
scanf("%d", &n);
int wlk = 1 << n;
vector<int> a(wlk);
for (int i = 0; i < wlk; ++i) scanf("%d", &a[i]);
vector<vector<long long> > inw(2, vector<long long>(n + 1, 0));
for (int wyk = 1; wyk <= n; ++wyk) {
int blok = 1 << wyk;
for (int p1 = 0; p1 < wlk; p1 += blok) {
int k1 = p1 + blok / 2 - 1;
int p2 = k1 + 1;
int k2 = p2 + blok / 2 - 1;
vector<int> L, P;
for (int i = p1; i <= k1; ++i) L.push_back(a[i]);
for (int i = p2; i <= k2; ++i) P.push_back(a[i]);
inw[0][wyk] += Scal(L, P);
inw[1][wyk] += Scal(P, L);
for (int i = 0; i < blok / 2; ++i) L.push_back(P[i]);
sort(L.begin(), L.end());
for (int i = 0; i < blok; ++i) a[p1 + i] = L[i];
}
}
int m;
scanf("%d", &m);
vector<int> stan(n + 1, 0);
long long odp = 0;
for (int i = 0; i <= n; ++i) odp += inw[0][i];
for (int i = 0; i < m; ++i) {
int q;
scanf("%d", &q);
for (int j = 0; j <= q; ++j) {
odp -= inw[stan[j]][j];
stan[j] ^= 1;
odp += inw[stan[j]][j];
}
printf("%I64d\n", odp);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char IO_MODE = 3;
inline long long ReadInt() {
long long 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;
}
inline void WriteInt(long long x) {
char CH[20];
if (x < 0) {
putchar('-');
x = -x;
}
int Num = 0;
if (!x) {
putchar('0');
return;
}
while (x > 0) CH[++Num] = x % 10, x /= 10;
while (Num) putchar(CH[Num--] + 48);
}
inline void out(int x) {
if (IO_MODE & 1)
WriteInt(x);
else
printf("%i", x);
}
template <typename... Args>
inline void out(int x, Args... args) {
out(x);
putc(' ', stdout);
out(args...);
}
inline void in(int &x) {
if (IO_MODE & 2)
x = ReadInt();
else
scanf("%i", &x);
}
template <typename... Args>
inline void in(int &x, Args &...args) {
in(x);
in(args...);
}
inline void outll(long long x) {
if (IO_MODE & 1)
WriteInt(x);
else
printf("%I64d", x);
}
template <typename... Args>
inline void outll(long long x, Args... args) {
outll(x);
putc(' ', stdout);
outll(args...);
}
inline void inll(long long &x) {
if (IO_MODE & 2)
x = ReadInt();
else
scanf("%I64d", &x);
}
template <typename... Args>
inline void inll(long long &x, Args &...args) {
inll(x);
inll(args...);
}
int aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, mm, nn, oo, pp, qq, rr, ss, tt,
uu, vv, ww, xx, yy, zz;
int tc;
int n, q, p, mask;
int A[1 << 22];
long long Ans[22];
long long More[2][22];
inline long long build(int l, int r, int lev) {
if (l == r) return 0;
long long L_ans = build(l, l + r >> 1, lev - 1);
long long R_ans = build((l + r >> 1) + 1, r, lev - 1);
long long ans = 0, L_more = 0, R_more = 0;
int tmp[r - l + 1];
int i = 0, j = 0, k = 0;
int *L = &A[l];
int *R = &A[(l + r >> 1) + 1];
int N = r - l + 1 >> 1;
while (k < N << 1) {
if (i == N)
while (j < N) tmp[k++] = R[j++], R_more += i;
else if (j == N)
while (i < N) tmp[k++] = L[i++], L_more += j;
else if (L[i] < R[j])
while (i < N && L[i] < R[j]) tmp[k++] = L[i++], L_more += j;
else if (L[i] > R[j])
while (j < N && L[i] > R[j]) tmp[k++] = R[j++], R_more += i;
else {
int pre_i = i;
int pre_j = j;
int pre_k = k;
int val = L[i];
while (i < N && L[i] == val) tmp[k++] = L[i++], L_more += pre_j;
while (j < N && R[j] == val) tmp[k++] = R[j++], R_more += pre_i;
}
}
N <<= 1;
for (int i = 0; i < N; i++) L[i] = tmp[i];
ans += L_ans + R_ans + L_more;
Ans[lev] += ans;
More[0][lev] += L_more;
More[1][lev] += R_more;
return ans;
}
int main() {
in(n);
for (int i = 0; i < 1 << n; i++) in(A[i]);
build(0, (1 << n) - 1, n);
in(q);
while (q--) {
in(p);
mask ^= (1 << p + 1) - 1;
for (int i = 1; i <= n; i++)
Ans[i] = Ans[i - 1] + More[!!(mask & 1 << i)][i];
outll(Ans[n]);
putc('\n', stdout);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long Scal(vector<int>& a, vector<int>& b) {
int n = a.size();
long long odp = 0;
int i = 0, j = 0;
while (i < n && j < n) {
if (a[i] <= b[j])
++i;
else {
odp += n - i;
++j;
}
}
return odp;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int wlk = 1 << n;
vector<int> a(wlk);
for (int i = 0; i < wlk; ++i) cin >> a[i];
vector<vector<long long> > inw(2, vector<long long>(n + 1, 0));
for (int wyk = 1; wyk <= n; ++wyk) {
int blok = 1 << wyk;
for (int p1 = 0; p1 < wlk; p1 += blok) {
int k1 = p1 + blok / 2 - 1;
int p2 = k1 + 1;
int k2 = p2 + blok / 2 - 1;
vector<int> L, P;
for (int i = p1; i <= k1; ++i) L.push_back(a[i]);
for (int i = p2; i <= k2; ++i) P.push_back(a[i]);
inw[0][wyk] += Scal(L, P);
inw[1][wyk] += Scal(P, L);
for (int i = 0; i < blok / 2; ++i) L.push_back(P[i]);
sort(L.begin(), L.end());
for (int i = 0; i < blok; ++i) a[p1 + i] = L[i];
}
}
int m;
cin >> m;
vector<int> stan(n + 1, 0);
long long odp = 0;
for (int i = 0; i <= n; ++i) odp += inw[0][i];
for (int i = 0; i < m; ++i) {
int q;
cin >> q;
for (int j = 0; j <= q; ++j) {
odp -= inw[stan[j]][j];
stan[j] ^= 1;
odp += inw[stan[j]][j];
}
cout << odp << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.