solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
return a.first > b.first || a.first == b.first && a.second < b.second;
}
bool comp2(pair<long long, long long> a, pair<long long, long long> b) {
return a.second < b.second;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long a[n];
pair<long long, long long> s[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
s[i] = {a[i], i};
}
sort(s, s + n, comp);
vector<pair<long long, long long> > ans;
long long m;
cin >> m;
for (long long j = 0; j < m; j++) {
long long k, p;
cin >> k >> p;
ans.clear();
for (long long i = 0; i < k; i++) ans.push_back(s[i]);
sort(ans.begin(), ans.end(), comp2);
cout << ans[p - 1].first << endl;
}
return 0;
}
| 10 | CPP |
n = int(input())
s = list(map(int, input().split()))
for i in range(n):
s[i] = (s[i], i)
mx = sorted(s, key=lambda y: y[0], reverse=True)
m = int(input())
for i in range(m):
k, pos = map(int, input().split())
pos -= 1
a = 0
last = mx[0][0]
res = []
d = dict()
d2 = dict()
for x in range(k):
if mx[x][0] not in d:
d[mx[x][0]] = 1
else:
d[mx[x][0]] += 1
for x in range(n):
if mx[x][0] != last:
a += 1
last = mx[x][0]
if a == k:
break
if mx[x][0] not in d2:
d2[mx[x][0]] = [mx[x][1]]
else:
d2[mx[x][0]].append(mx[x][1])
for a in list(d.keys()):
d2[a].sort()
for j in range(d[a]):
res.append((a, d2[a][j]))
res = sorted(res, key=lambda y: y[1])
print(res[pos][0])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
void solve() {
int n, k, m, pos;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
cin >> m;
for (int _ = 0; _ < m; _++) {
cin >> k >> pos;
vector<int> ind;
set<int> s;
for (int i = 0; i < k; i++) {
int maxi = -1;
for (int j = 0; j < n; j++) {
if (s.find(j) != s.end()) continue;
if (maxi == -1)
maxi = j;
else if (a[maxi] < a[j]) {
maxi = j;
}
}
s.insert(maxi);
}
int h = 1;
for (auto i : s) {
if (h == pos) cout << a[i] << endl;
h++;
}
}
exit(0);
}
int main() {
int t = 1;
for (int i = 0; i < t; i++) solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first > b.first)
return true;
else if (a.first == b.first) {
if (a.second < b.second) return true;
return false;
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int i, j, k, l, m, n, p, x, t;
vector<pair<int, int> > v, c;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
v.push_back({x, i});
}
sort(v.begin(), v.end(), cmp);
cin >> m;
for (i = 1; i <= m; i++) {
cin >> k >> p;
for (j = 0; j < k; j++) c.push_back({v[j].second, v[j].first});
sort(c.begin(), c.end());
cout << c[p - 1].second << endl;
c.clear();
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const double pi = 3.141592653589793238;
const int MOD1 = 1e9 + 7;
const int MOD2 = 998244353;
const int N = 3e5 + 5;
using namespace std;
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first != b.first) return (a.first > b.first);
return (a.second < b.second);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n = 0;
cin >> n;
vector<pair<long long, long long>> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i + 1;
}
sort((a).begin(), (a).end(), cmp);
long long q = 0;
cin >> q;
while (q--) {
long long k, pos;
cin >> k >> pos;
set<pair<long long, long long>> s;
for (long long i = 0; i < k; i++) {
s.insert({a[i].second, a[i].first});
}
while (--pos) s.erase(s.begin());
auto m = *(s.begin());
cout << m.second << "\n";
}
}
| 10 | CPP |
n = int(input())
c = list(map(lambda x: (int(x[1]),-x[0]),enumerate(input().split())))
so = sorted(c)
for i in range(int(input())):
k,r = map(int,input().split())
now = so[-k:]
now.sort(key = lambda x: -x[1])
print(now[r-1][0]) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = (long long int)2e18 + 77;
void solve() {
int n;
cin >> n;
int a[n], i;
for (i = 0; i < n; i++) cin >> a[i];
map<int, int> N;
int M[n][n];
for (i = 0; i < n; i++) {
N[a[i]]++;
M[n - 1][i] = a[i];
}
for (i = n - 2; i >= 0; i--) {
int mn = (*N.begin()).first;
N[mn]--;
if (N[mn] == 0) N.erase(mn);
int j, k = i;
for (j = i + 1; j >= 0; j--) {
if (mn == M[i + 1][j])
mn = -1;
else
M[i][k--] = M[i + 1][j];
}
}
int m, len;
cin >> m;
while (m--) {
cin >> len >> i;
len--;
i--;
cout << M[len][i] << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int m;
cin >> m;
for (int e = 0; e < m; e++) {
int k, p;
cin >> k >> p;
vector<int> b;
for (int i = 0; i < k; i++) {
b.push_back(a[i]);
}
for (int i = k; i < n; i++) {
int MIN = 1000000007, pos = 0;
for (int j = 0; j < k; j++) {
if (b[j] <= MIN) {
MIN = b[j];
pos = j;
}
}
if (a[i] > MIN) {
b.erase(b.begin() + pos);
b.push_back(a[i]);
}
}
cout << b[p - 1] << endl;
}
}
| 10 | CPP |
n=int(input())
a=sorted(zip(list(map(int,input().split())),range(n)),key=lambda x:(x[0],-x[1]),reverse=True)
#print(a)
m=int(input())
for i in range(m):
k,pos=map(int,input().split())
b=sorted(a[:k],key=lambda x:x[1])
#print(b)
print(b[pos-1][0])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long pw(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 1)
return (a * pw((a * a) % 1000000007, b / 2)) % 1000000007;
else
return (1 * pw((a * a) % 1000000007, b / 2)) % 1000000007;
}
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
bool comp2(pair<long long, long long> a, pair<long long, long long> b) {
return a.second < b.second;
}
void solve() {
int n;
cin >> n;
vector<pair<long long, long long> > v;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back({x, i});
}
sort(v.begin(), v.end(), comp);
vector<vector<pair<long long, long long> > > ans;
for (int k = 0; k < n + 1; k++) {
vector<pair<long long, long long> > temp;
for (int j = 0; j < k; j++) temp.push_back(v[j]);
sort(temp.begin(), temp.end(), comp2);
ans.push_back(temp);
}
long long m;
cin >> m;
while (m--) {
long long k, p;
cin >> k >> p;
cout << ans[k][p - 1].first << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 10 | CPP |
from sys import stdin
n = int(stdin.readline())
alist = list(map(int, stdin.readline().split()))
aindlist = sorted([(elem, i) for i, elem in enumerate(alist)], key = lambda x: (-x[0], x[1]))
m = int(stdin.readline())
ans = []
for _ in range(m):
k, pos = map(int, stdin.readline().split())
temp = [x[1] for x in aindlist[:k]]
temp.sort()
ans.append(alist[temp[pos - 1]])
print(*ans, sep= '\n')
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6 + 1;
const int INF = 2e9 + 1;
const int MOD = (1e9 + 7);
void bye(string s = "") {
cout << s << '\n';
exit(0);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> arr(n);
set<pair<int, int> > kek;
for (int i = 0; i < n; i++) {
cin >> arr[i];
kek.emplace(-arr[i], i);
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int k, pos;
cin >> k >> pos;
auto e = kek.begin();
vector<pair<int, int> > mem;
for (int i = 0; i < k; i++) {
mem.emplace_back(e->second, e->first);
e++;
}
sort((mem).begin(), (mem).end());
cout << mem[pos - 1].second * -1 << '\n';
}
bye();
}
| 10 | CPP |
import itertools
import functools
from operator import itemgetter
def cmp(a, b):
# 0 - descending, 1 - ascending
# returns: -1, a before b; 1 b before a; 0 no difference
if a[0] > b[0]:
return -1
elif a[0] < b[0]:
return 1
else:
if a[1] < b[1]:
return -1
elif a[1] > b[1]:
return 1
else:
return 0
n = int(input())
a = list(map(int, input().split()))
c = a[:]
c = list(zip(a, itertools.count(0)))
c = sorted(c, key=functools.cmp_to_key(cmp))
h = c[:]
m = int(input())
for i in range(m):
k,pos = map(int, input().split())
h = sorted(c[:k], key=itemgetter(1))
print(h[pos-1][0])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
int main() {
ll t = 1;
while (t--) {
int n;
cin >> n;
vector<int> v(n), temp(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
temp[i] = v[i];
}
sort(temp.begin(), temp.end(), greater<int>());
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
map<int, int> mp;
for (int i = 0; i < k; i++) {
mp[temp[i]]++;
}
vector<int> v1(k);
int j = 0;
for (int i = 0; i < n && j < k; i++) {
if (mp[v[i]] > 0) {
mp[v[i]]--;
v1[j] = v[i];
j++;
}
}
cout << v1[pos - 1] << endl;
}
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n, x;
cin >> n;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) {
cin >> x;
a[i] = {-x, i};
}
sort(a.begin(), a.end());
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
vector<pair<int, int> > v;
for (int i = 0; i < k; i++) v.push_back({a[i].second, -a[i].first});
sort(v.begin(), v.end());
cout << v[pos - 1].second << "\n";
v.clear();
}
return 0;
}
}
| 10 | CPP |
n = int(input())
sequence = list(map(int, input().split()))
array = list(sequence)
array.sort(reverse=True)
m = int(input())
for i in range(m):
k, pos = map(int, input().split())
D = dict()
for elem in array[:k]:
if elem in D:
D[elem] += 1
else:
D[elem] = 1
for elem in sequence:
if elem in D and D[elem] != 0:
D[elem] -= 1
if pos == 1:
print(elem)
break
else:
pos -= 1
| 10 | PYTHON3 |
n = int(input())
p = list(map(int, input().split()))
p = sorted(list(enumerate(p)), key=lambda x: -x[1])
a = [[]]
for i in range(n):
a.append(sorted(a[-1] + [p[i]], key=lambda x: x[0]))
m = int(input())
for _ in range(m):
x, y = map(int, input().split())
print(a[x][y - 1][1])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long mo = 1e9 + 7;
long long sx, sy, ex, ey, dx[6] = {0, 1, 0, -1, 0, 0},
dy[6] = {1, 0, -1, 0, 0, 0}, m, n, k,
dz[6]{0, 0, 0, 0, -1, 1}, sg;
long long p, no, v, ans, w;
int par[550000];
long long a[500005], b[400005], c[500006], d1[400006], ma[500006], mi[500006];
int lg[200005], mi2[50], mn[25][200005];
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
set<int> se;
struct node {
long long u, v, w;
};
vector<node> eg;
long long qu(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = ans % m * a % m;
}
b >>= 1;
a = a % m * a % m;
}
return ans;
}
int su(int n) {
if (n == 1 || n == 0) return 0;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
int fi(int a) {
if (a == par[a])
return a;
else
return par[a] = fi(par[a]);
}
map<int, long long> mp, mp1;
map<pair<long long, int>, int> mp2;
priority_queue<pair<long long, int> > que;
pair<long long, int> a1[400000], a2[400000];
int vis[400055], vis1[400055], vis2[400055];
long long dp[55][1005];
char maze[505][505];
vector<int> g[400000], g1[400000];
vector<pair<long long, int> > ve, ve1, ve2;
int cmp1(pair<long long, int> a, pair<long long, int> b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
int cmp(pair<long long, int> a, pair<long long, int> b) {
return a.second < b.second;
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
string ans1;
int main() {
int t, p2, p3;
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, ss, sss;
long long l, r, n1, u, l1, r1;
int tot = 1;
char ch;
while (cin >> n) {
for (int i = 1; i <= n; i++) {
cin >> a[i];
a1[i] = pair<long long, int>{a[i], i};
}
sort(a1 + 1, a1 + n + 1, cmp1);
cin >> m;
vector<int> tmp;
while (m--) {
cin >> k >> p;
no = 0;
for (int i = 1; i <= k; i++) ve.push_back(a1[i]);
sort(ve.begin(), ve.end(), cmp);
cout << ve[p - 1].first << endl;
ve.clear();
}
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using mii = map<int, int>;
const double Eps = 1e-8;
const int Inf = 1e9 + 9;
const int Mod = 1e9 + 7;
const int N = 1e5 + 9;
const int dx4[4] = {0, 1, 0, -1};
const int dy4[4] = {-1, 0, 1, 0};
const int dx8[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dy8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
constexpr double pi = 3.141592653589793238462643383279502884L;
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
void prime_siever(long long p) {
bool prime[p + 9];
for (long long i = 2; i * i <= p; i++)
if (prime[i] == 0)
for (long long j = i * i; j <= p; j += i) prime[j] = 1;
}
int mul(int a, int b) { return (1LL * a * b) % Mod; }
int add(int a, int b) {
a += b;
if (a >= Mod) a -= Mod;
if (a < 0) a += Mod;
return a;
}
long long bin_power(long long a, long long n) {
if (a == 0) return 0;
long long res = 1;
while (n) {
if (n % 2) {
res = (res * a) % Mod;
n--;
} else {
a = (a * a) % Mod;
n /= 2;
}
}
return res;
}
vector<int> a;
vector<pair<int, int> > b, c;
priority_queue<int, vector<int>, greater<int> > qi;
map<pair<int, int>, int> mp;
void solve() {
int q, n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push_back(x);
qi.push(a[i]);
}
cin >> q;
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
b.push_back({x, y});
}
c = b;
sort(b.rbegin(), b.rend());
for (int i = 0; i < q; i++) {
int siz = b[i].first, idx = b[i].second - 1;
while (qi.size() != siz) {
reverse(a.begin(), a.end());
a.erase(find(a.begin(), a.end(), qi.top()));
reverse(a.begin(), a.end());
qi.pop();
}
mp[{siz, idx + 1}] = a[idx];
}
for (int i = 0; i < q; i++) {
cout << mp[c[i]] << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = LLONG_MAX - 100000;
void IO() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed);
}
long long pw(long long x, long long y, long long p = inf) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long invmod(long long a, long long m = mod) { return pw(a, m - 2, m); }
long long cl(long long a, long long x) {
return a % x == 0 ? a / x : a / x + 1;
}
void run_time_terror(long long case_no = 0) {
long long n, x;
cin >> n;
set<pair<long long, long long> > s;
for (long long i = 0; i < n; ++i) {
cin >> x;
s.insert({-x, i});
}
long long q;
cin >> q;
while (q--) {
long long sz, k;
cin >> sz >> k;
vector<pair<long long, long long> > seq;
for (auto &it : s) {
if (seq.size() >= sz) break;
seq.push_back({it.second, -it.first});
}
sort(seq.begin(), seq.end());
k--;
cout << seq[k].second << "\n";
}
}
int32_t main() {
cout << setprecision(0);
IO();
long long tt = 1;
for (long long case_no = 1; case_no <= tt; case_no++) {
run_time_terror(case_no);
}
return 0;
}
| 10 | CPP |
n = int(input())
A = list(map(int, input().split()))
L = A.copy()
L2 = L.copy()
A.sort()
c = int(input())
r = []
def S(x, L):
idx = L.index(x)
L[idx] = -1
return [idx, x]
for i in range(c):
k, pos = map(int, input().split())
B = A[:0-k-1:-1]
H = list(map(lambda x: S(x, L), B))
H.sort()
N = list(map(lambda x: x[1], H))
r += [N[pos - 1]]
L = L2.copy()
print('\n'.join(map(str, r))) | 10 | PYTHON3 |
def get_index(lt, vec):
max_el = 0
pos = None
for i in range(len(vec)):
if i not in lt:
if max_el < vec[i]:
max_el = vec[i]
pos = i
return pos
n = int(input())
vec = [int(x) for x in input().split()]
lst = [[vec.index(max(vec))]]
for i in range(n-1):
lt = list(lst[i])
ind = get_index(lt, vec)
lt.append(ind)
lst.append(lt)
for l in lst:
l.sort()
m = int(input())
for i in range(m):
k, pos = [int(x) for x in input().split()]
print(vec[lst[k-1][pos-1]])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cout.tie(0), cin.tie(0);
long long int n, m, k, i, j, a[101];
cin >> n;
vector<long long int> pr;
for (i = 0; i < n; i++) {
cin >> a[i];
pr.push_back(a[i]);
}
sort(pr.rbegin(), pr.rend());
cin >> m;
while (m--) {
long long int k, pos, last = -1;
cin >> k >> pos;
pos--;
for (i = k - 1; i >= 0; i--) {
if (pr[i] == pr[i - 1])
;
else
break;
}
int y = k - i, z = -1;
for (i = 0; i < n; i++) {
if (a[i] > pr[k - 1]) {
z++;
} else if (a[i] == pr[k - 1] && y) {
z++, y--;
}
if (z == pos) break;
}
cout << a[i] << endl;
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n, 0), b(n, 0);
for (int i = 0; i < n; ++i) {
cin >> a[i];
b[i] = a[i];
}
sort(b.begin(), b.end());
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int k, pos;
cin >> k >> pos;
int x = b[n - k];
vector<int> c;
for (int j = 0; j < n && c.size() < pos && k > 0; ++j) {
if (a[j] == x) {
--k;
if (k > 0) x = b[n - k];
c.push_back(a[j]);
} else if (a[j] > x) {
c.push_back(a[j]);
}
}
cout << c[pos - 1] << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
long long t = 1;
while (t--) {
long long n;
cin >> n;
vector<long long> ar(n), br(n);
for (long long i = 0; i < n; i++) {
cin >> ar[i];
br[i] = ar[i];
}
sort(br.begin(), br.end(), greater<long long>());
long long m;
cin >> m;
while (m--) {
long long k, pos;
cin >> k >> pos;
vector<long long> seq, arr;
arr = ar;
for (long long i = 0; i < k; i++) {
for (long long j = 0; j < n; j++) {
if (arr[j] == br[i]) {
seq.push_back(j);
arr[j] = -1;
break;
}
}
}
sort(seq.begin(), seq.end());
cout << ar[seq[pos - 1]] << "\n";
}
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e12;
long long a_s, b_s;
vector<long long> best(vector<long long> a, vector<long long> b) {
a_s = 0;
b_s = 0;
bool flaga = true;
bool flagb = true;
for (long long i = 0; i < a.size(); ++i)
if (a[i] < 0) flaga = false;
for (long long i = 0; i < b.size(); ++i)
if (b[i] < 0) flagb = false;
if ((!flaga) && flagb) return b;
if ((!flagb) && flaga) return a;
if ((!flaga) && (!flagb)) {
vector<long long> bad = {};
for (long long i = 0; i < a.size(); ++i) bad.push_back(-INF);
return bad;
}
for (long long i = 0; i < a.size(); ++i) a_s += a[i];
for (long long i = 0; i < a.size(); ++i) b_s += b[i];
if (a_s > b_s) return a;
if (b_s > a_s) return b;
for (long long i = 0; i < a.size(); ++i) {
if (a[i] < b[i]) return a;
if (b[i] < a[i]) return b;
}
return a;
}
signed main() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; ++i) cin >> a[i];
long long m;
cin >> m;
vector<long long> k(m);
vector<long long> pos(m);
for (long long j = 0; j < m; ++j) cin >> k[j] >> pos[j];
vector<vector<vector<long long>>> dp(
n + 1, vector<vector<long long>>(n + 1, vector<long long>()));
dp[0][0] = {};
for (long long i = 1; i <= n; ++i)
for (long long j = 0; j < i; ++j) dp[0][i].push_back(-INF);
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
vector<long long> dp11 = dp[i - 1][j - 1];
dp11.push_back(a[i - 1]);
dp[i][j] = best(dp[i - 1][j], dp11);
}
}
for (long long i = 0; i < m; ++i) cout << dp[n][k[i]][pos[i] - 1] << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[100];
int ind[100];
bool cmp(int i, int j) {
if (a[i].first == a[j].first) return a[i].second < a[j].second;
return a[i].first > a[j].first;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
a[i].second = i, ind[i] = i;
}
sort(ind, ind + n, cmp);
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
vector<int> chosen(k);
for (int i = 0; i < k; ++i) chosen[i] = a[ind[i]].second;
sort(chosen.begin(), chosen.end());
cout << a[chosen[pos - 1]].first << '\n';
}
}
| 10 | CPP |
from sys import stdin,stdout
from math import gcd,sqrt,factorial,pi
from collections import deque,defaultdict
input=stdin.readline
R=lambda:map(int,input().split())
I=lambda:int(input())
S=lambda:input().rstrip('\n')
L=lambda:list(R())
P=lambda x:stdout.write(x)
lcm=lambda x,y:(x*y)//gcd(x,y)
hg=lambda x,y:((y+x-1)//x)*x
pw=lambda x:1 if x==1 else 1+pw(x//2)
chk=lambda x:chk(x//2) if not x%2 else True if x==1 else False
sm=lambda x:(x**2+x)//2
N=10**9+7
n=I()
d={}
for i in sorted(enumerate(R()),reverse=True,key=lambda x:x[1]):
if i[1] not in d:
d[i[1]]=[]
d[i[1]]+=i,
d[i[1]].sort(key=lambda x:x[0])
a=[]
for i in d:
a.extend(d[i])
m=[]
x=[]
for i in range(n):
x+=a[i],
x.sort(key=lambda x:x[0])
m.append(x.copy())
for i in range(I()):
k,pos=R()
print(m[k-1][pos-1][1]) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, l, r, i, j, a[1000001], d[10000001], ans[1000001];
bool tt[1000001];
vector<pair<long long, long long> > v;
string s;
void build(long long h, long long l, long long r) {
if (l == r) {
d[h] = 0;
return;
}
long long w = (l + r) / 2;
build(h * 2, l, w);
build(h * 2 + 1, w + 1, r);
}
void update(long long h, long long l, long long r, long long x) {
if (l == r) {
d[h] = 1;
return;
}
long long w = (l + r) / 2;
if (x <= w)
update(h * 2, l, w, x);
else
update(h * 2 + 1, w + 1, r, x);
d[h] = d[h * 2] + d[h * 2 + 1];
}
long long get(long long h, long long l, long long r, long long x) {
if (l == r) return a[l];
long long w = (l + r) / 2;
if (x <= d[h * 2])
return get(h * 2, l, w, x);
else
return get(h * 2 + 1, w + 1, r, x - d[h * 2]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
v.push_back(make_pair(a[i], n - i));
}
build(1, 1, n);
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < n; i++) v[i].second = n - v[i].second;
vector<pair<pair<long long, long long>, long long> > z;
cin >> m;
for (int i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
z.push_back(make_pair(make_pair(x, y), i));
}
sort(z.begin(), z.end());
long long l = -1;
for (int i = 0; i < z.size(); i++) {
while (z[i].first.first - 1 > l) {
l++;
update(1, 1, n, v[l].second);
}
ans[z[i].second] = get(1, 1, n, z[i].first.second);
}
for (int i = 1; i <= m; i++) cout << ans[i] << "\n";
return 0;
}
| 10 | CPP |
m = int(input())
line = [int(i) for i in input().split()]
for i in range(int(input())):
false_line = list(line)
k, pos = map(int, input().split())
while len(false_line) > k:
x = min(false_line)
rang = iter(range(-1, -len(false_line)-1, -1))
j = next(rang)
while j > -len(false_line)-1:
if false_line[j] == x:
del false_line[j]
if len(false_line) == k:
break
else:
try:
j = next(rang)
except StopIteration:
break
print(false_line[pos-1])
| 10 | PYTHON3 |
import copy
b=[]
a=[]
rezult=''
n=int(input())
a=list(map(int,input().split()))
m=int(input())
for i in range(1,m+1):
k,pos=map(int,input().split())
b=copy.deepcopy(a)
b.reverse()
for j in range(1,n-k+1):
b.remove(min(b))
b.reverse()
rezult=rezult+'\n'+str(b[pos-1])
print(rezult)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
vector<long long int> a(n), v1(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
v1 = a;
sort(a.begin(), a.end(), greater<long long int>());
long long int q;
cin >> q;
while (q--) {
long long int k, p;
cin >> k >> p;
vector<long long int> v;
long long int sum = 0;
for (long long int i = 0; i < k; i++) sum += a[i];
long long int l1 = 0;
for (long long int i = 0; i < k; i++) {
if (a[i] == a[k - 1]) l1++;
}
for (long long int i = 0; i < n; i++) {
if (v1[i] >= a[k - 1]) v.push_back(v1[i]);
}
vector<long long int> v2, v3;
for (long long int i = 0; i < v.size(); i++) {
if (a[k - 1] == v[i] && l1 > 0)
v3.push_back(v[i]), l1--;
else if (v[i] > a[k - 1])
v3.push_back(v[i]);
}
v2 = v3;
cout << v2[p - 1] << endl;
v.clear();
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, A[111];
map<int, set<int>> idxs;
set<int> app;
int main(void) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &A[i]);
app.insert(A[i]);
idxs[A[i]].insert(i);
}
int q;
scanf("%d", &q);
while (q--) {
int k, pos;
scanf("%d%d", &k, &pos);
int cnt = 0;
set<int> ii;
for (auto it = app.rbegin(); it != app.rend(); ++it) {
int now = *it;
cnt += idxs[now].size();
if (cnt >= k) {
cnt -= idxs[now].size();
cnt = k - cnt;
auto it = idxs[now].begin();
while (cnt--) {
ii.insert(*it);
++it;
}
break;
}
for (int i : idxs[now]) ii.insert(i);
}
auto it = ii.begin();
while (--pos) ++it;
printf("%d\n", A[*it]);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios ::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
long long arr[n];
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
vector<long long> vrr(arr, arr + n);
sort(vrr.rbegin(), vrr.rend());
long long Q;
cin >> Q;
while (Q--) {
long long k, pos;
cin >> k >> pos;
long long d = 0;
mp = {};
for (long long i = 0; i < k; i++) {
mp[vrr[i]] += 1;
d = vrr[i];
}
vector<long long> ans;
for (long long i = 0; i < n; i++) {
if (arr[i] == d && mp[d] > 0) {
ans.push_back(arr[i]);
mp[d] = mp[d] - 1;
}
if (arr[i] > d) {
ans.push_back(arr[i]);
}
}
pos = pos - 1;
cout << ans[pos] << "\n";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1 << 62;
const long long MOD = 1e9 + 7;
const int iINF = 1 << 30;
const double PI = 3.14159265359;
int main() {
int n;
vector<pair<int, int> > a;
cin >> n;
a.assign(n, {0, 0});
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = -i;
}
sort(a.rbegin(), a.rend());
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int k, pos;
cin >> k >> pos;
vector<pair<int, int> > tmp;
for (int j = 0; j < k; j++) {
tmp.push_back({-a[j].second, a[j].first});
}
sort(tmp.begin(), tmp.end());
cout << tmp[pos - 1].second << "\n";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool mycomparator(pair<long long int, int> p1, pair<long long int, int> p2) {
if (p1.first == p2.first) {
if (p1.second > p2.second) {
return true;
} else {
return false;
}
}
if (p1.first < p2.first) {
return true;
} else {
return false;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<pair<long long int, int> > a;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push_back(make_pair(x, i));
}
sort(a.begin(), a.end(), mycomparator);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int k, pos;
cin >> k >> pos;
map<long long int, long long int> p;
vector<long long int> l;
for (int i = n - 1; i >= n - k; i--) {
p[a[i].second] = a[i].first;
l.push_back(a[i].second);
}
sort(l.begin(), l.end());
cout << p[l[pos - 1]] << "\n";
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void jakos() {
ios_base::sync_with_stdio(false);
cin.tie(0);
}
const int mod = 1e9 + 7;
const int base = 179;
const int INF = 1e9;
const int N = 1e5;
signed main() {
jakos();
int n;
cin >> n;
vector<pair<int, int>> a;
for (int i = 0; i < n; i++) {
int b;
cin >> b;
a.emplace_back(b, -i);
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
int q;
cin >> q;
while (q--) {
vector<pair<int, int>> ans;
int k, pos;
cin >> k >> pos;
for (int i = 0; i < k; i++) {
ans.emplace_back(-a[i].second, a[i].first);
}
sort(ans.begin(), ans.end());
cout << ans[pos - 1].second << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
constexpr int maxn = 105, inf = 0x3f3f3f3f;
int n;
int a[maxn], vis[maxn], b[maxn];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
int k, pos;
cin >> k >> pos;
int cnt = 0;
memset(vis, 0, sizeof vis);
for (int j = 1; j <= k; j++) {
int res = 0;
for (int d = 1; d <= n; d++) {
if (vis[d]) continue;
res = max(res, a[d]);
}
for (int d = 1; d <= n; d++) {
if (res == a[d] && !vis[d]) {
vis[d] = 1;
b[++cnt] = d;
break;
}
}
}
sort(b + 1, b + 1 + cnt);
printf("%d\n", a[b[pos]]);
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n;
long long x[n + 5];
for (long long i = 0; i < n; i++) {
cin >> x[i];
}
cin >> m;
long long ans = 1e+18;
deque<long long> y, z;
for (long long j = 0; j < m; j++) {
long long k, pos;
cin >> k >> pos;
y.clear();
z.clear();
for (long long i = 0; i < n; i++) {
if (i < k) {
y.push_back(x[i]);
z.push_back(x[i]);
} else {
sort(z.begin(), z.end());
if (x[i] > z[0]) {
for (long long r = k - 1; r >= 0; r--) {
if (y[r] == z[0]) {
y.erase(y.begin() + r);
break;
}
}
z.pop_front();
z.push_back(x[i]);
y.push_back(x[i]);
}
}
}
cout << y[pos - 1] << endl;
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<long long int, int> p, pair<long long int, int> q) {
if (p.first > q.first)
return 1;
else if (p.first < q.first)
return 0;
else {
if (p.second < q.second)
return 1;
else
return 0;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long int a[n];
vector<pair<long long int, int> > v;
for (int i = 0; i < n; i++) {
cin >> a[i];
v.push_back({a[i], i});
}
sort(v.begin(), v.end(), cmp);
int m;
cin >> m;
while (m--) {
int k, pos;
cin >> k >> pos;
vector<int> temp;
for (int i = 0; i < k; i++) temp.push_back(v[i].second);
sort(temp.begin(), temp.end());
cout << a[temp[pos - 1]] << "\n";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first < b.first) return true;
if (a.first > b.first) return false;
if (a.second < b.second) return false;
return true;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
vector<pair<long long, long long> > b;
for (long long i = 0; i < n; i++) {
cin >> a[i];
b.push_back({a[i], i});
}
sort(b.begin(), b.end(), comp);
long long t;
cin >> t;
while (t--) {
long long k, pos;
cin >> k >> pos;
vector<pair<long long, long long> > c;
long long cnt = 0;
for (long long i = n - 1; i >= 0; i--) {
c.push_back({b[i].second, b[i].first});
cnt++;
if (cnt == k) break;
}
sort(c.begin(), c.end());
cout << c[pos - 1].second << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
int head[N];
int dis[N], ecnt;
int fa[N];
int cat[2005][2005];
long long gcd(long long a, long long b) {
return a % b == 0 ? b : gcd(b, a % b);
}
long long qpow(long long base, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = (ans * base) % mod;
n >>= 1;
base = base * base % mod;
}
return ans;
}
struct Node {
long long x, y;
} nd[N];
long long m, n, x, k, y;
struct EDGE {
int u, v, nxt;
long long w;
} e[N];
bool cmp(EDGE a, EDGE b) { return a.w < b.w; }
void add_edge(int u, int v, long long w) {
e[ecnt].u = u;
e[ecnt].v = v;
e[ecnt].w = w;
e[ecnt].nxt = head[u];
head[u] = ecnt++;
}
int fd(int x) { return -1 == fa[x] ? x : fa[x] = fd(fa[x]); }
int c[N];
int lowbit(int x) { return x & (-x); }
void add(long long *c, int x, int y) {
while (x <= n) {
c[x] += y;
x += lowbit(x);
}
}
long long getsum(long long *c, int x) {
long long res = 0;
while (x > 0) {
res += c[x];
x -= lowbit(x);
}
return res;
}
int vis[N];
int p[N];
long long ans;
int C[55][55];
int dp[150][150];
long long posar[N], smar[N];
struct H {
int p, s;
friend bool operator<(H a, H b) { return a.p < b.p; }
} he[N];
bool cmp(int a, int b) { return a > b; }
priority_queue<int> q;
vector<int> v[30];
map<vector<int>, int> mp;
int ar[N];
int br[N];
vector<int> vv[10];
int main() {
{
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &ar[i]);
p[ar[i]] = i;
}
long long inv = 0;
for (int i = 1; i <= n; i++) {
inv += i - 1 - getsum(smar, p[i]);
add(smar, p[i], 1);
add(posar, p[i], p[i]);
int l = 1;
int r = n;
int mid;
while (l < r) {
mid = 1 + l + r >> 1;
if (getsum(smar, mid - 1) * 2 <= i)
l = mid;
else
r = mid - 1;
}
mid = l;
long long pre_cnt_sum = getsum(smar, mid),
pre_pos_sum = getsum(posar, mid);
long long mov =
pre_cnt_sum * mid - pre_pos_sum - pre_cnt_sum * (pre_cnt_sum - 1) / 2;
long long aft_cnt_sum = i - pre_cnt_sum;
mov += getsum(posar, n) - pre_pos_sum - aft_cnt_sum * mid -
aft_cnt_sum * (aft_cnt_sum + 1) / 2;
cout << inv + mov << " \n"[i == n];
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1 << 62;
const long long MOD = 1e9 + 7;
const int iINF = 1 << 30;
const double PI = 3.14159265359;
int LSOne(int n) { return n & (-n); }
class FenwickTree {
private:
vector<int> ft;
public:
FenwickTree(int n) { ft.assign(n + 1, 0); }
int rsq(int b) {
int sum = 0;
for (; b; b -= LSOne(b)) {
sum += ft[b];
}
return sum;
}
int rsq(int a, int b) { return rsq(b) - (a == 1 ? 0 : rsq(a - 1)); }
void adjust(int k, int v) {
for (; k < (int)ft.size(); k += LSOne(k)) {
ft[k] += v;
}
}
};
long long nsum(int x, int y) {
long long s = (long long)y * (y + 1) / 2;
s -= (long long)x * (x - 1) / 2;
return s;
}
void solve() {
int n;
cin >> n;
vector<int> a(n), pos(n + 1), less(n + 1);
for (int i = 0; i < n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
FenwickTree ft(n);
long long inv = 0;
set<int> mintree, maxtree;
long long minsum = 0, maxsum = 0;
cout << "0 ";
ft.adjust(pos[1] + 1, 1);
mintree.insert(pos[1]);
minsum += pos[1];
for (int i = 2; i <= n; i++) {
auto it1 = mintree.end();
it1--;
if (pos[i] < *it1) {
maxsum += *it1;
maxtree.insert(*it1);
minsum -= *it1;
mintree.erase(it1);
minsum += pos[i];
mintree.insert(pos[i]);
} else {
maxsum += pos[i];
maxtree.insert(pos[i]);
}
if (maxtree.size() > mintree.size()) {
int val = *maxtree.begin();
maxsum -= val;
maxtree.erase(maxtree.begin());
minsum += val;
mintree.insert(val);
}
inv += ft.rsq(pos[i] + 1, n);
it1 = mintree.end();
it1--;
int med = *it1;
int x = med - mintree.size() + 1;
int y = med + maxtree.size();
long long push = nsum(x, med) - minsum;
push += maxsum - nsum(med + 1, y);
cout << inv + push << " ";
ft.adjust(pos[i] + 1, 1);
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n;
long long a[N], id[N];
pair<long long, long long> G[N];
void Upd(int x, int y) {
while (x <= n) {
G[x].first++;
G[x].second += y;
x += (x & -x);
}
}
pair<long long, long long> Get(int x) {
pair<long long, long long> res;
res.first = res.second = 0;
while (x > 0) {
res.first += G[x].first;
res.second += G[x].second;
x -= (x & -x);
}
return res;
}
int main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
id[a[i]] = i;
}
long long inv = 0;
for (int i = 1; i <= n; i++) {
long long idx = id[i], ans = 0;
inv += Get(n).first - Get(idx).first;
ans = inv;
Upd(idx, idx);
long long l = 1, r = n, mid, res = -1;
while (l <= r) {
mid = (l + r) / 2;
if (Get(mid).first >= (i + 1) / 2) {
res = mid;
r = mid - 1;
} else
l = mid + 1;
}
long long totR = res + Get(n).first - Get(res).first;
ans += Get(n).second - Get(res).second -
(totR * (totR + 1) / 2 - res * (res + 1) / 2);
long long totL = res - Get(res - 1).first;
ans += (res - 1) * res / 2 - (totL - 1) * totL / 2 - Get(res - 1).second;
printf("%lld ", ans);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int N;
int position[maxn];
long long sum1[maxn << 2], sum2[maxn << 2];
void add(long long* bit, int pos, long long val) {
while (pos <= N) {
bit[pos] += val;
pos += pos & (-pos);
}
}
long long query(long long* bit, int pos) {
long long ret = 0;
while (pos) {
ret += bit[pos];
pos -= pos & (-pos);
}
return ret;
}
int search(long long* bit, int val) {
int i = 0;
for (int j = 20; j >= 0; --j) {
if ((i | (1 << j)) <= N && bit[i | (1 << j)] <= val) {
val -= bit[i |= (1 << j)];
}
}
return i;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N;
for (int i = 1; i <= N; ++i) {
int p;
cin >> p;
position[p] = i;
}
long long cnt = 0;
for (int i = 1; i <= N; ++i) {
int p = position[i];
add(sum1, p, 1);
cnt += i - query(sum1, p);
add(sum2, p, p);
long long pos = search(sum1, i / 2) + 1;
long long sum = 0;
long long a = i / 2, b = i - a - 1;
sum += pos * a - a * (a + 1) / 2 - query(sum2, pos - 1);
sum += (query(sum2, N) - query(sum2, pos)) - b * pos - b * (b + 1) / 2;
cout << cnt + sum << " ";
}
cout << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int a[maxn];
class BIT {
public:
long long a[maxn];
void add(int x, long long c) {
for (int i = x; i < maxn; i += i & -i) a[i] += c;
}
long long sum(int x) {
long long res = 0;
for (int i = x; i > 0; i -= i & -i) res += a[i];
return res;
}
} b1, b2;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, x;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
a[x] = i;
}
long long inv = 0;
for (int i = 1; i <= n; i++) {
b1.add(a[i], 1);
inv += i - b1.sum(a[i]);
b2.add(a[i], a[i]);
x = i / 2 + 1;
long long res = b2.sum(n);
int l = 1, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (b1.sum(mid) >= x)
r = mid;
else
l = mid + 1;
}
long long pos = l;
long long s = b2.sum(pos);
long long lans = pos * (pos + 1) / 2 - s - (pos - x) * (pos - x + 1) / 2;
long long rans = res - s - (i - x) * (pos + 1 + i - x + pos) / 2;
cout << lans + rans + inv << ' ';
}
cout << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int a[N], p[N], inv[N], n;
int f[N + 1];
int read(int idx) {
int sum = 0;
idx++;
while (idx > 0) {
sum += f[idx];
idx -= (idx & -idx);
}
return sum;
}
void update(int idx, int val) {
idx++;
while (idx <= n) {
f[idx] += val;
idx += (idx & -idx);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i], a[i]--;
for (int i = 0; i < n; i++) p[a[i]] = i;
for (int i = n - 1; i >= 0; i--) {
inv[a[i]] = read(a[i]);
update(a[i], 1);
}
long long ans = 0;
int l = p[0], r = l;
update(p[0], -1);
cout << ans << " ";
for (int i = 1; i < n; i++) {
int lc = p[i] + 1 - read(p[i]), rc = i - lc;
update(p[i], -1);
if (lc > rc) {
int lb = 0, rb = p[i] - 1;
while (lb <= rb) {
int m = (lb + rb) / 2;
int mc = m + 1 - read(m);
if (mc >= i + 1 - mc) {
rb = m - 1;
} else {
lb = m + 1;
}
}
ans += read(p[i]) - read(lb);
} else if (lc < rc) {
ans += rc - lc;
int lb = p[i] + 1, rb = n - 1;
while (lb <= rb) {
int m = (lb + rb) / 2;
int mc = m + 1 - read(m);
if (mc <= i + 1 - mc) {
lb = m + 1;
} else {
rb = m - 1;
}
}
ans += read(rb) - read(p[i]);
}
cout << ans << " ";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct fenwick {
int N;
vector<int> bit;
fenwick(int n = 1e5) {
N = n + 5;
bit.assign(N, 0);
}
void resize(int n) {
N = n + 5;
bit.assign(N, 0);
}
void update(int x, int val) {
while (x < N) {
bit[x] += val;
x += x & -x;
}
}
int sum(int x) {
int ret = 0;
while (x > 0) {
ret += bit[x];
x -= x & -x;
}
return ret;
}
};
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int n;
cin >> n;
vector<int> idx(n + 5);
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
idx[x] = i;
}
fenwick bit(n);
set<long long, greater<long long>> l;
set<long long> r;
long long lsum = 0, rsum = 0, ans = 0;
for (int i = 1; i <= n; ++i) {
bit.update(idx[i], 1);
ans += i - bit.sum(idx[i]);
if (l.size() == 0 || idx[i] < *l.begin())
l.insert(idx[i]), lsum += idx[i];
else
r.insert(idx[i]), rsum += idx[i];
if (l.size() > r.size() + 1) {
int x = *l.begin();
lsum -= x;
rsum += x;
l.erase(l.begin());
r.insert(x);
} else if (r.size() > l.size()) {
int x = *r.begin();
lsum += x;
rsum -= x;
l.insert(x);
r.erase(r.begin());
}
long long lcnt = (l.size() * (*l.begin())) - lsum -
(1ll * l.size() * (l.size() - 1)) / 2;
long long rcnt = (rsum - r.size() * (*l.begin())) -
(1ll * r.size() * (r.size() + 1)) / 2;
cout << ans + lcnt + rcnt << ' ';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 10;
long long sum1[maxn];
long long sum2[maxn];
long long n;
long long lowbit(long long x) { return x & -x; }
void add(long long *sum, long long x, long long v) {
while (x <= n) {
sum[x] += v;
x += lowbit(x);
}
}
long long query(long long *sum, long long x) {
long long res = 0;
while (x > 0) {
res += sum[x];
x -= lowbit(x);
}
return res;
}
long long a[maxn];
long long pos[maxn];
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
pos[a[i]] = i;
}
long long ans1 = 0;
for (long long i = 1; i <= n; i++) {
ans1 += i - 1 - query(sum1, pos[i]);
add(sum1, pos[i], 1);
add(sum2, pos[i], pos[i]);
long long mid, l = 1, r = n;
while (l <= r) {
mid = (l + r) >> 1;
if (query(sum1, mid) * 2 <= i) {
l = mid + 1;
} else {
r = mid - 1;
}
}
long long ans2 = 0;
long long cnt = query(sum1, mid), sum = query(sum2, mid);
ans2 += mid * cnt - sum - cnt * (cnt - 1) / 2;
cnt = i - cnt, sum = query(sum2, n) - sum;
ans2 += sum - cnt * (mid + 1) - cnt * (cnt - 1) / 2;
printf("%lld ", ans1 + ans2);
}
puts("");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 5;
long long c[maxn], d[maxn];
long long n;
long long lowbit(long long x) { return x & (-x); }
void update(long long i, long long k) {
while (i <= n) {
c[i] += k;
i += lowbit(i);
}
}
long long getsum(long long i) {
long long res = 0;
while (i > 0) {
res += c[i];
i -= lowbit(i);
}
return res;
}
void update2(long long i, long long k) {
while (i <= n) {
d[i] += k;
i += lowbit(i);
}
}
long long getsum2(long long i) {
long long res = 0;
while (i > 0) {
res += d[i];
i -= lowbit(i);
}
return res;
}
long long f[maxn], where[maxn];
long long bs(long long sum) {
long long l = 0, r = n;
while (l <= r) {
long long mid = (l + r) >> 1;
if (getsum2(mid) >= sum)
r = mid - 1;
else
l = mid + 1;
}
return l;
}
long long dc(long long x, long long y) {
long long len = y - x + 1;
return (x + y) * len / 2;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> f[i];
where[f[i]] = i;
}
long long cnt = 0;
for (long long i = 1; i <= n; ++i) {
long long pos = where[i];
update2(pos, 1);
cnt += i - getsum2(pos);
update(pos, pos);
long long base = bs(i / 2 + 1);
long long lmost = base - i / 2;
long long rmost = base + i / 2 - ((i + 1) % 2);
long long t = dc(lmost, base) - dc(base + 1, rmost);
long long sum = 0;
sum -= getsum(base);
sum += getsum(n) - getsum(base);
cout << sum + t + cnt << " ";
}
cout << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int oo = 1e9 + 7;
int a[maxn], c[maxn], n;
int pos[maxn];
long long ans[maxn];
void update(int x) {
for (int i = x; i <= n && i; i += i & (-i)) c[i]++;
}
long long query(int x) {
long long ans = 0;
while (x) ans = ans + 1ll * c[x], x -= x & (-x);
return ans;
}
priority_queue<int> q1, q2;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), pos[a[i]] = i;
long long a1 = 0, ln = 0, rn = 0;
for (long long i = 1; i <= n; i++) {
update(pos[i]);
a1 = a1 + i - query(pos[i]);
if (q1.size() && pos[i] < q1.top()) {
ln += pos[i];
q1.push(pos[i]);
} else {
rn += pos[i];
q2.push(-pos[i]);
}
while (q1.size() < q2.size()) {
long long c = -q2.top();
ln += c;
rn -= c;
q2.pop();
q1.push(c);
}
while (q1.size() > q2.size() + 1) {
long long c = q1.top();
ln -= c;
rn += c;
q1.pop();
q2.push(-c);
}
long long top = q1.top();
ans[i] = a1 + 1ll * top * q1.size() - ln -
1ll * q1.size() * (q1.size() - 1) / 2 + rn - top * q2.size() -
1ll * q2.size() * (q2.size() + 1) / 2;
;
;
}
for (int i = 1; i <= n; i++) {
if (i != 1) printf(" ");
printf("%lld", ans[i]);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Node {
Node *l, *r;
int count;
long long sum;
int ask(int k, int ll, int rr) {
if (ll == rr) {
return count;
}
int mid = (ll + rr) >> 1;
if (k <= mid) {
return l ? l->ask(k, ll, mid) : 0;
} else {
return (l ? l->count : 0) + (r ? r->ask(k, mid + 1, rr) : 0);
}
}
long long asksum(int k, int ll, int rr) {
if (ll == rr) {
return sum;
}
int mid = (ll + rr) >> 1;
if (k <= mid) {
return l ? l->asksum(k, ll, mid) : 0;
} else {
return (l ? l->sum : 0) + (r ? r->asksum(k, mid + 1, rr) : 0);
}
}
void add(int, int, int, int);
} node[200005 * 25];
int cnt;
Node *getNode() {
++cnt;
return node + cnt;
}
void Node::add(int k, int w, int ll, int rr) {
++count;
sum += w;
if (ll == rr) {
return;
}
int mid = (ll + rr) >> 1;
if (k <= mid) {
if (l) {
Node tmp = *l;
l = getNode();
(*l) = tmp;
} else {
l = getNode();
}
l->add(k, w, ll, mid);
} else {
if (r) {
Node tmp = *r;
r = getNode();
(*r) = tmp;
} else {
r = getNode();
}
r->add(k, w, mid + 1, rr);
}
}
int n;
Node root[200005];
int rf(int a, int b) {
int l = 0, r = n, mid;
while (l + 1 != r) {
mid = (l + r) >> 1;
if (root[mid].ask(a, 0, n) < b) {
l = mid;
} else {
r = mid;
}
}
return r;
}
int a[200005], b[200005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
b[a[i]] = i;
root[i] = root[i - 1];
root[i].add(a[i], i, 0, n);
}
long long sum = 0;
for (int i = 1; i <= n; ++i) {
int d = rf(i, (i >> 1) + (i & 1));
long long ans = 0;
ans += root[d].asksum(n, 0, n) - root[d].asksum(i, 0, n);
long long tmp = d - (i >> 1) - (i & 1);
ans -= tmp * (tmp + 1) / 2;
tmp = d + (i >> 1) + 1;
ans += (n + tmp) * (n - tmp + 1) / 2;
ans -= (root[n].asksum(n, 0, n) - root[n].asksum(i, 0, n)) -
(root[d].asksum(n, 0, n) - root[d].asksum(i, 0, n));
sum += i - root[b[i]].ask(i, 0, n);
ans += sum;
printf("%lld ", ans);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long const inf = 1e9;
long long const mod = 1e9 + 7;
long double const eps = 1e-9;
long long bit[200005];
long long bit2[200005];
long long sumbit[200005];
long long n;
void update(long long k) {
while (k <= 200000) {
bit[k] += 1;
k += k & -k;
}
}
long long sum(long long k) {
long long s = 0;
while (k > 0) {
s += bit[k];
k -= k & -k;
}
return s;
}
void update2(long long k) {
while (k <= 200000) {
bit2[k] += 1;
k += k & -k;
}
}
long long sum2(long long k) {
long long s = 0;
while (k > 0) {
s += bit2[k];
k -= k & -k;
}
return s;
}
void update3(long long k, long long val) {
while (k <= 200000) {
sumbit[k] += val;
k += k & -k;
}
}
long long sum3(long long k) {
long long s = 0;
while (k > 0) {
s += sumbit[k];
k -= k & -k;
}
return s;
}
long long cinv(long long pos, long long num) {
long long SUM = num - 1;
SUM -= sum2(pos);
update2(pos);
return SUM;
}
int main() {
cin >> n;
long long a[n];
long long pos[n + 1];
for (int i = (0); i < (n); i++) {
cin >> a[i];
pos[a[i]] = i + 1;
}
long long inversions = 0;
for (int i = (1); i < (n + 1); i++) {
inversions += cinv(pos[i], i);
update(pos[i]);
update3(pos[i], pos[i]);
long long k = 0;
for (long long b = n / 2; b >= 1; b /= 2) {
while (k + b <= n && sum(k + b) <= i / 2) k += b;
}
k++;
long long l = sum(k - 1);
long long r = sum(n) - sum(k);
long long suml = sum3(k - 1);
long long sumr = sum3(n) - sum3(k);
long long ans = inversions + (long long)l * k - suml + sumr -
(long long)r * k - (long long)(l * (l + 1)) / 2 -
(long long)(r * (r + 1)) / 2;
cout << ans << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
int a[MAX], p[MAX], n;
long long c1[MAX], c2[MAX];
set<int> st;
void add(long long *c, int x, int k) {
for (; x <= n; x += x & -x) c[x] += k;
}
long long query(long long *c, int x) {
long long sum = 0;
for (; x; x -= x & -x) sum += c[x];
return sum;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), p[a[i]] = i;
st.insert(p[1]);
auto it = st.begin();
printf("0 ");
add(c1, p[1], 1);
add(c2, p[1], p[1]);
long long res = 0;
for (int i = 2; i <= n; i++) {
st.insert(p[i]);
if (p[i] < (*it) && i % 2 == 0) it--;
if (p[i] > (*it) && i % 2 == 1) it++;
add(c1, p[i], 1);
res += (i * 1ll - query(c1, p[i]));
add(c2, p[i], p[i]);
int midpos = *it;
long long sum = 0, k = i / 2;
sum += i & 1 ? k * 1ll * (midpos - 1 + midpos - k) / 2
: (k - 1) * 1ll * (midpos + midpos - k) / 2;
sum -= k * 1ll * (midpos + 1 + midpos + k) / 2;
sum -= query(c2, midpos - 1);
sum += query(c2, n) - query(c2, midpos);
printf("%I64d ", res + sum);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
long long pos[N], s1[N], s2[N];
int a[N];
int n;
void add(long long s[], int pos, long long v) {
while (pos <= n) {
s[pos] += v;
pos += pos & (-pos);
}
}
long long query(long long s[], int pos) {
long long res = 0;
while (pos) {
res += s[pos];
pos -= pos & (-pos);
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += i - 1 - query(s1, pos[i]);
add(s1, pos[i], 1);
add(s2, pos[i], pos[i]);
int l = 1, r = n, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (query(s1, mid) * 2 <= i)
l = mid + 1;
else
r = mid - 1;
}
long long ans2 = 0;
long long cnt = query(s1, mid), sum = query(s2, mid);
ans2 += mid * cnt - sum - cnt * (cnt - 1) / 2;
cnt = i - cnt;
sum = query(s2, n) - sum;
ans2 += sum - cnt * (mid + 1) - cnt * (cnt - 1) / 2;
printf("%lld ", ans + ans2);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long sum1[maxn << 2], sum2[maxn << 2];
int N, pos[maxn], a[maxn];
void update(long long* tree, int pos, int l, int r, int id, long long val) {
if (l > r || pos < l || pos > r) return;
if (pos == l && pos == r) {
tree[id] += val;
} else {
int mid = (l + r) >> 1;
update(tree, pos, l, mid, id << 1, val);
update(tree, pos, mid + 1, r, id << 1 | 1, val);
tree[id] = tree[id << 1] + tree[id << 1 | 1];
}
}
long long query(long long* tree, int l, int r, int x, int y, int id) {
if (l > r || x > y || x > r || y < l) return 0;
if (l <= x && y <= r) {
return tree[id];
}
int mid = (x + y) >> 1;
if (mid < l) return query(tree, l, r, mid + 1, y, id << 1 | 1);
if (mid >= r) return query(tree, l, r, x, mid, id << 1);
return query(tree, l, r, x, mid, id << 1) +
query(tree, l, r, mid + 1, y, id << 1 | 1);
}
int search(long long* tree, long long val) {
int l = 1, r = N, ret = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (query(tree, 1, mid, 1, N, 1) < val) {
l = mid + 1;
} else {
ret = mid;
r = mid - 1;
}
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N;
for (int i = 1; i <= N; ++i) cin >> a[i], pos[a[i]] = i;
long long cnt = 0;
for (int i = 1; i <= N; ++i) {
int p = pos[i];
update(sum1, p, 1, N, 1, 1);
cnt += i - query(sum1, 1, p, 1, N, 1);
update(sum2, p, 1, N, 1, p);
long long a = i / 2, b = i - a - 1, pos = search(sum1, i / 2 + 1), sum = 0;
sum += -query(sum2, 1, pos - 1, 1, N, 1) + query(sum2, pos + 1, N, 1, N, 1);
sum += (a * pos - a * (a + 1) / 2) - (b * pos + b * (b + 1) / 2);
cout << cnt + sum << " ";
}
cout << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, fwk[2][200001], ps[200001] = {}, pv[200001] = {}, to1 = 0, to2 = 0;
set<long long> s;
set<long long>::iterator it;
void upd(int x, int t, long long v) {
for (; x <= n; x += x & (-x)) {
fwk[t][x] += v;
}
}
long long qry(int x, int t) {
long long to = 0;
for (; x; x -= x & (-x)) {
to += fwk[t][x];
}
return to;
}
long long sm(long long n) { return n * (n + 1) / 2; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
ps[x] = i;
}
for (int i = 1; i <= n; i++) {
if (i == 1) {
it = s.insert(ps[i]).first;
} else if (i % 2) {
s.insert(ps[i]);
if (ps[i] > *it) {
it = next(it);
}
} else {
s.insert(ps[i]);
if (ps[i] < *it) {
it = prev(it);
}
}
upd(ps[i] + 1, 0, 1);
upd(ps[i] + 1, 1, ps[i]);
to1 = (i % 2) * (*it) -
(2 * sm((i - 1) / 2) + ((i % 2 == 0) ? (i / 2) : 0)) -
2 * qry((*it) + 1, 1) + qry(n, 1);
to2 += (long long)(i - qry(ps[i] + 1, 0));
cout << to1 + to2;
if (i < n) {
cout << " ";
}
}
cout << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int a[N];
struct fenwick {
long long fen[N];
fenwick() { memset(fen, 0, sizeof fen); }
void add(int x, int d) {
for (int i = x + 1; i < N; i += i & -i) {
fen[i] += d;
}
}
long long sum(int x) {
long long ans = 0;
for (int i = x; i; i -= i & -i) {
ans += fen[i];
}
return ans;
}
long long sum(int l, int r) { return sum(r) - sum(l); }
int kth(int k) {
int x = 0;
for (int i = 17; ~i; i--) {
if ((x | 1 << i) < N && fen[x | 1 << i] <= k) {
x |= 1 << i;
k -= fen[x];
}
}
return x;
}
} t1, t2;
int solve() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[x] = i;
}
long long rev = 0;
for (int i = 1; i <= n; i++) {
t1.add(a[i], 1);
t2.add(a[i], a[i]);
rev += t1.sum(a[i] + 1, 2e5 + 1);
int t = i - 1 >> 1;
int m = t1.kth(t);
long long mv = 0;
++t;
mv += t2.sum(m + 1, 2e5 + 1) - 1ll * (m + 1) * (i - t) -
1ll * (i - t) * (i - t - 1) / 2;
mv += 1ll * m * t - t2.sum(m + 1) - 1ll * t * (t - 1) / 2;
printf("%lld ", mv + rev);
}
puts("");
return 0;
}
signed main() {
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 7;
const long long INF = 1LL << 60;
const long long mod = 1e9 + 7;
const long double eps = 1e-8;
const long double pi = acos(-1.0);
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class Abel>
struct BIT {
private:
vector<Abel> node;
long long n;
Abel UNITY_SUM = 0;
public:
BIT(long long n_) {
n = n_;
node.resize(n, UNITY_SUM);
}
void add(long long a, Abel w) {
for (long long i = a; i < n; i |= i + 1) node[i] += w;
}
Abel sum(long long a) {
Abel ret = UNITY_SUM;
for (long long i = a - 1; i >= 0; i = (i & (i + 1)) - 1) ret += node[i];
return ret;
}
Abel sum(long long a, long long b) { return sum(b) - sum(a); }
long long get(long long k) {
++k;
long long res = 0;
long long n = 1;
while (n < (long long)node.size()) n *= 2;
for (long long i = n / 2; i > 0; i /= 2) {
if (res + i < (long long)node.size() && node[res + i - 1] < k) {
k -= node[res + i - 1];
res += i;
}
}
return res;
}
void print() {
for (long long i = 0; i < n; ++i) cout << sum(i, i + 1) << ",";
cout << endl;
}
};
void solve() {
long long n;
cin >> n;
vector<long long> p(n);
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
cin >> p[i];
mp[p[i]] = i;
}
BIT<long long> bit(n + 1);
BIT<long long> bit2(n + 1);
long long now = 0;
for (long long i = 1; i <= n; ++i) {
long long ans = 0;
bit.add(mp[i], 1);
bit2.add(mp[i], mp[i]);
long long j1 = bit.get((i + 1) / 2 - 1);
long long j2 = j1 + 1;
if (i & 1) {
ans += j1 * bit.sum(0, j1) - bit2.sum(0, j1);
ans += bit2.sum(j1 + 1, n) - j1 * bit.sum(j1 + 1, n);
long long k = i / 2;
ans -= k * (k + 1);
} else {
ans += j1 * bit.sum(0, j1) - bit2.sum(0, j1);
ans += bit2.sum(j2 + 1, n) - j2 * bit.sum(j2 + 1, n);
long long k = (i - 2) / 2;
ans -= k * (k + 1);
}
now += bit.sum(mp[i] + 1, n);
ans += now;
cout << ans << " ";
}
cout << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 5;
const long long MAXN = 1e6 + 5;
long long n, m, t;
long long a[MAXN];
long long tree1[MAXN], tree2[MAXN];
long long pos[MAXN];
void add(long long *tree, long long x, long long xx) {
while (x <= n) tree[x] += xx, x += (x & (-x));
}
long long query(long long *tree, long long x) {
long long sum = 0;
while (x > 0) sum += tree[x], x -= (x & (-x));
return sum;
}
long long bs(long long x) {
long long l = 1, r = n;
long long ans;
while (l <= r) {
long long mid = l + r >> 1;
if (query(tree1, mid) > x / 2)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
return ans;
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) scanf("%d", &a[i]), pos[a[i]] = i;
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
long long ans = 0;
add(tree1, pos[i], 1);
add(tree2, pos[i], pos[i]);
cnt += query(tree1, n) - query(tree1, pos[i]);
long long tmp = bs(i);
long long a = i / 2, b = i - a - 1;
ans += a * tmp - query(tree2, tmp - 1) - (a + 1) * a / 2;
long long tmpp = query(tree2, n) - query(tree2, tmp);
ans += tmpp - b * tmp - (b + 1) * b / 2;
cout << ans + cnt << ' ';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, fwk[2][200001], ps[200001] = {}, pv[200001] = {}, to1 = 0, to2 = 0;
set<long long> s;
set<long long>::iterator it;
void upd(int x, int t, long long v) {
for (; x <= n; x += x & (-x)) {
fwk[t][x] += v;
}
}
long long qry(int x, int t) {
long long to = 0;
for (; x; x -= x & (-x)) {
to += fwk[t][x];
}
return to;
}
long long sm(long long n) { return n * (n + 1) / 2; }
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
ps[x] = i;
}
for (int i = 1; i <= n; i++) {
if (i == 1) {
it = s.insert(ps[i]).first;
} else if (i % 2) {
s.insert(ps[i]);
if (ps[i] > *it) {
it = next(it);
}
} else {
s.insert(ps[i]);
if (ps[i] < *it) {
it = prev(it);
}
}
upd(ps[i] + 1, 0, 1);
upd(ps[i] + 1, 1, ps[i]);
to1 = (i % 2) * (*it) -
(2 * sm((i - 1) / 2) + ((i % 2 == 0) ? (i / 2) : 0)) -
2 * qry((*it) + 1, 1) + qry(n, 1);
to2 += (long long)(i - qry(ps[i] + 1, 0));
cout << to1 + to2;
if (i < n) {
cout << " ";
}
}
cout << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int p[200005];
long long ret[200005];
long long inv[200005], sum[200005];
void update(long long *pen, int ind, int val) {
while (ind < 200005) {
pen[ind] += val;
ind += ind & (-ind);
}
}
long long query(long long *pen, int ind) {
long long ret = 0;
while (ind > 0) {
ret += pen[ind];
ind = ind & (ind - 1);
}
return ret;
}
int getIndex(int target, int n) {
int l = 0, r = n - 1, mid;
while (l < r) {
mid = (l + r + 1) / 2;
if (query(inv, mid) < target) {
l = mid;
} else {
r = mid - 1;
}
}
return l + 1;
}
long long getSum(int n) {
long long ret = (long long)n * (n + 1);
return ret / 2;
}
void solve() {
int n;
scanf("%d ", &n);
pair<int, int> in[200005];
int pos = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d ", &p[i]);
in[pos++] = make_pair(p[i], i);
}
sort(in, in + n);
int maxi = 0;
long long invSum = 0;
for (int i = 0; i < n; ++i) {
invSum = invSum + i - query(inv, in[i].second);
update(inv, in[i].second, 1);
update(sum, in[i].second, in[i].second);
int k = i + 1;
maxi = max(maxi, in[i].second);
int mInd = getIndex(k / 2, n);
long long R = 1e18;
if (k == 1) {
continue;
}
for (int j = 0; j < 2; ++j) {
int mid = getIndex(k / 2 + j, n);
long long prefix = getSum(mid) - getSum(mid - k / 2 - j);
long long suffix = getSum(mid + k - (k / 2 + j)) - getSum(mid);
long long tmp = prefix - query(sum, mid) * 2 - suffix + query(sum, n);
R = min(R, tmp);
}
ret[i + 1] = invSum + R;
}
for (int i = 1; i <= n; ++i) {
printf("%lld ", ret[i]);
}
putchar('\n');
}
int main() {
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int NN = (int)2e5 + 5;
int A[NN];
int pos[NN];
int n;
long long tree_cnt[NN];
long long tree_sum[NN];
long long read(long long* tree, int idx) {
idx++;
long long res = 0;
while (idx > 0) {
res += tree[idx];
idx -= (idx & (-idx));
}
return res;
}
void update(long long* tree, int idx, long long val) {
idx++;
while (idx < NN) {
tree[idx] += val;
idx += (idx & (-idx));
}
}
int find_median(int len) {
int lo = 0, hi = n;
int half = (len + 1) / 2;
while (lo < hi) {
int mid = (lo + hi) >> 1;
int r = read(tree_cnt, mid);
if (r < half)
lo = mid + 1;
else
hi = mid;
}
return lo;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
A[i]--;
pos[A[i]] = i;
}
memset(tree_cnt, 0, sizeof(tree_cnt));
memset(tree_sum, 0, sizeof(tree_sum));
long long tot = 0;
long long rev = 0;
for (int i = 0; i < n; i++) {
rev += i - read(tree_cnt, pos[i]);
update(tree_cnt, pos[i], +1);
update(tree_sum, pos[i], pos[i]);
int len = i + 1;
int med = find_median(len);
tot += pos[i];
long long sum_down = read(tree_sum, med);
long long sum_up = tot - sum_down;
long long down_cnt = (len + 1) / 2;
long long up_cnt = len - down_cnt;
long long res = 0;
res += sum_up - med * up_cnt - (up_cnt * (up_cnt + 1)) / 2;
res += med * down_cnt - sum_down - (down_cnt * (down_cnt - 1)) / 2;
res += rev;
if (i > 0) printf(" ");
printf("%lld", res);
}
printf("\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, a[200010], p[200010], c[200010];
long long inv[200010];
set<int> st;
set<int>::iterator it;
int Lowbit(int x) { return x & (-x); }
void Update(int x, int d) {
while (x <= n) {
c[x] += d;
x += Lowbit(x);
}
}
int Getsum(int x) {
int res = 0;
while (x) {
res += c[x];
x -= Lowbit(x);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
p[a[i]] = i;
}
cout << "0 ";
int center = p[1], lnum = 0, rnum = 0;
long long sum = 0;
st.insert(p[1]);
Update(p[1], 1);
for (int i = 2; i <= n; ++i) {
inv[i] = Getsum(n) - Getsum(p[i]);
Update(p[i], 1);
st.insert(p[i]);
long long nxt_sum =
sum + inv[i] + abs(p[i] - center) - abs(Getsum(center) - Getsum(p[i]));
if (center < p[i])
nxt_sum -= inv[i];
else
nxt_sum -= Getsum(p[i] - 1);
if (p[i] > center)
rnum++;
else
lnum++;
if (lnum == rnum + 1) {
it = st.find(center);
it--;
center = (*it);
lnum--;
rnum++;
}
if (rnum == lnum + 2) {
it = st.find(center);
it++;
nxt_sum -= ((*it) - center - 1);
center = (*it);
lnum++;
rnum--;
}
sum = nxt_sum;
cout << sum << " ";
}
cout << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const int maxn = 200000 + 10;
class BIT {
private:
int n;
int bit[maxn];
public:
BIT(int size) {
n = size;
std::fill(bit, bit + size + 1, 0);
}
void add(int x, int v) {
while (x <= this->n) {
bit[x] += v;
x += ((x) & (-x));
}
}
int query(int x) {
int ans = 0;
while (x) {
ans += bit[x];
x -= ((x) & (-x));
}
return ans;
}
int find_k(int k) {
int bits = 0;
int n = this->n;
while (n) {
n >>= 1;
bits++;
}
int mask = 0;
int cnt = 0;
for (int i = bits - 1; i >= 0; i--) {
mask += 1 << i;
if (mask > this->n || cnt + bit[mask] >= k)
mask -= (1 << i);
else
cnt += bit[mask];
}
return mask + 1;
}
};
int n, pos[maxn];
struct TreeNode {
int zeros, preadd, sufadd;
long long presum, sufsum;
};
TreeNode seg[maxn << 2];
void build_tree(int node, int L, int R) {
seg[node].zeros = R - L + 1;
if (L == R) return;
int M = L + (R - L) / 2;
build_tree(node << 1, L, M);
build_tree(node << 1 | 1, M + 1, R);
}
void push_down(int node, int L, int R) {
int lch = node << 1;
int rch = node << 1 | 1;
int M = L + (R - L) / 2;
if (seg[node].preadd) {
seg[lch].preadd += seg[node].preadd;
seg[rch].preadd += seg[node].preadd;
seg[lch].presum += 1LL * seg[lch].zeros * seg[node].preadd;
seg[rch].presum += 1LL * seg[rch].zeros * seg[node].preadd;
seg[node].preadd = 0;
}
if (seg[node].sufadd) {
seg[lch].sufadd += seg[node].sufadd;
seg[rch].sufadd += seg[node].sufadd;
seg[lch].sufsum += 1LL * seg[lch].zeros * seg[node].sufadd;
seg[rch].sufsum += 1LL * seg[rch].zeros * seg[node].sufadd;
seg[node].sufadd = 0;
}
}
int qL, qR;
void add(int node, int L, int R, int type) {
if (qL <= L && R <= qR) {
if (type == 0) {
seg[node].preadd += 1;
seg[node].presum += seg[node].zeros;
} else {
seg[node].sufadd += 1;
seg[node].sufsum += seg[node].zeros;
}
return;
}
push_down(node, L, R);
int M = L + (R - L) / 2;
if (qL <= M) add(node << 1, L, M, type);
if (qR > M) add(node << 1 | 1, M + 1, R, type);
int lch = node << 1;
int rch = node << 1 | 1;
seg[node].zeros = seg[lch].zeros + seg[rch].zeros;
seg[node].presum = seg[lch].presum + seg[rch].presum;
seg[node].sufsum = seg[lch].sufsum + seg[rch].sufsum;
}
void erase(int node, int L, int R, int p) {
if (L == R) {
memset(seg + node, 0, sizeof(TreeNode));
return;
}
int M = L + (R - L) / 2;
int lch = node << 1;
int rch = node << 1 | 1;
push_down(node, L, R);
if (p <= M)
erase(lch, L, M, p);
else
erase(rch, M + 1, R, p);
seg[node].zeros = seg[lch].zeros + seg[rch].zeros;
seg[node].presum = seg[lch].presum + seg[rch].presum;
seg[node].sufsum = seg[lch].sufsum + seg[rch].sufsum;
}
long long query(int node, int L, int R, int type) {
if (qL <= L && R <= qR) {
if (type == 0)
return seg[node].presum;
else
return seg[node].sufsum;
}
push_down(node, L, R);
long long ans = 0;
int M = L + (R - L) / 2;
if (qL <= M) ans += query(node << 1, L, M, type);
if (qR > M) ans += query(node << 1 | 1, M + 1, R, type);
return ans;
}
int main() {
scanf("%d", &n);
BIT bit(n);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
pos[a] = i;
}
build_tree(1, 1, n);
long long inversion = 0;
for (int i = 1; i <= n; i++) {
const int &p = pos[i];
inversion += i - 1 - bit.query(p);
bit.add(p, 1);
qL = p + 1;
qR = n;
if (qL <= qR) add(1, 1, n, 0);
qL = 1;
qR = p - 1;
if (qL <= qR) add(1, 1, n, 1);
erase(1, 1, n, p);
long long ans = 0;
int median = bit.find_k((i + 1) / 2);
qL = 1;
qR = median - 1;
if (qL <= qR) {
ans += query(1, 1, n, 0);
}
qL = median + 1;
qR = n;
if (qL <= qR) {
ans += query(1, 1, n, 1);
}
printf("%lld ", inversion + ans);
}
printf("\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos((long double)-1.0);
const double EPS = 1e-10;
const int MOD = 1e9 + 7;
template <typename T>
void cmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
void cmax(T &x, T y) {
if (y > x) x = y;
}
long long qpow(long long x, long long n, long long mod = MOD) {
if (n < 0) return 0;
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long sq(long long x) { return x * x; }
long long read() {
long long res = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
res = res * 10 + (c - '0');
c = getchar();
}
return res;
}
const int MAXN = 200000 + 10;
int n;
int a[MAXN];
int pos[MAXN];
struct SegmentTree {
int cnt[MAXN << 2];
long long sum[MAXN << 2];
int add[MAXN << 2];
void PushUp(int o) {
cnt[o] = cnt[(o << 1)] + cnt[(o << 1 | 1)];
sum[o] = sum[(o << 1)] + sum[(o << 1 | 1)];
}
void PushDown(int o, int l, int r) {
if (add[o]) {
int m = (l + r) >> 1;
sum[(o << 1)] += 1LL * cnt[(o << 1)] * add[o];
sum[(o << 1 | 1)] += 1LL * cnt[(o << 1 | 1)] * add[o];
add[(o << 1)] += add[o];
add[(o << 1 | 1)] += add[o];
add[o] = 0;
}
}
void Build(int o, int l, int r) {
add[o] = 0;
if (l == r) {
cnt[o] = 1;
sum[o] = 0;
return;
}
int m = (l + r) >> 1;
Build((o << 1), l, m);
Build((o << 1 | 1), m + 1, r);
PushUp(o);
}
void Add(int o, int l, int r, int ql, int qr, int v) {
if (ql <= l && r <= qr) {
sum[o] += 1LL * cnt[o] * v;
add[o] += v;
return;
}
PushDown(o, l, r);
int m = (l + r) >> 1;
if (ql <= m) Add((o << 1), l, m, ql, qr, v);
if (qr >= m + 1) Add((o << 1 | 1), m + 1, r, ql, qr, v);
PushUp(o);
}
void SetCnt0(int o, int l, int r, int p) {
if (l == r) {
cnt[o] = 0;
sum[o] = 0;
return;
}
PushDown(o, l, r);
int m = (l + r) >> 1;
if (p <= m) SetCnt0((o << 1), l, m, p);
if (p >= m + 1) SetCnt0((o << 1 | 1), m + 1, r, p);
PushUp(o);
}
int Cnt(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return cnt[o];
PushDown(o, l, r);
int m = (l + r) >> 1;
int res = 0;
if (ql <= m) res = res + Cnt((o << 1), l, m, ql, qr);
if (qr >= m + 1) res = res + Cnt((o << 1 | 1), m + 1, r, ql, qr);
return res;
}
long long Sum(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sum[o];
PushDown(o, l, r);
int m = (l + r) >> 1;
long long res = 0;
if (ql <= m) res = res + Sum((o << 1), l, m, ql, qr);
if (qr >= m + 1) res = res + Sum((o << 1 | 1), m + 1, r, ql, qr);
return res;
}
int Pos(int o, int l, int r, int k) {
if (l == r) return l;
PushDown(o, l, r);
int m = (l + r) >> 1;
int cnt0ls = (m - l + 1) - cnt[(o << 1)];
if (cnt0ls >= k) return Pos((o << 1), l, m, k);
return Pos((o << 1 | 1), m + 1, r, k - cnt0ls);
}
int Lmid() {
int cnt0 = n - cnt[1];
return Pos(1, 1, n, (cnt0 + 1) / 2);
}
int Rmid() {
int cnt0 = n - cnt[1];
return Pos(1, 1, n, cnt0 / 2 + 1);
}
} st;
namespace Solver {
void InitOnce() { int t; }
void Read() {
int res = scanf("%d", &n);
if (res == -1) exit(0);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
}
long long ans[200005];
void Solve() {
st.Build(1, 1, n);
long long cur = 0;
int Lmost = n, Rmost = 1;
for (int i = 1; i <= n; ++i) {
int p = pos[i];
cmin(Lmost, p);
cmax(Rmost, p);
cur += (n - p + 1) - st.Cnt(1, 1, n, p, n);
if (i >= 2) {
int Lmid = st.Lmid();
int Rmid = st.Rmid();
if (p < Lmid) st.Add(1, 1, n, p, Lmid, 1);
if (p > Rmid) st.Add(1, 1, n, Rmid, p, 1);
}
st.SetCnt0(1, 1, n, p);
ans[i] = cur + st.Sum(1, 1, n, Lmost, Rmost);
printf("%lld%c", ans[i], " \n"[i == n]);
}
}
} // namespace Solver
int main() {
Solver::InitOnce();
while (true) {
Solver::Read();
Solver::Solve();
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int T, n, m, p, k, a[200010], pos[200010], bit[200010], hd;
long long ans = 0;
int query(int a) {
int tmp = 0;
for (int i = a; i >= 1; i -= (i & -i)) tmp += bit[i];
return tmp;
}
void add(int a, int x) {
for (int i = a; i <= n; i += (i & -i)) bit[i] += x;
}
set<int> S;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), pos[a[i]] = i;
S.insert(INT_MIN);
S.insert(INT_MAX);
hd = pos[1];
for (int i = 1; i <= n; i++) {
ans += query(n) - query(pos[i]);
add(pos[i], 1);
if (pos[i] < hd)
ans += hd - pos[i] - 1 - query(hd - 1) + query(pos[i]),
ans -= query(pos[i] - 1);
if (pos[i] > hd)
ans += pos[i] - hd - 1 - query(pos[i] - 1) + query(hd),
ans -= query(n) - query(pos[i]);
S.insert(pos[i]);
set<int>::iterator now = S.find(hd), l = now, r;
l--;
if ((*l) > 0) {
if (query(n) - query(*l) <= i / 2 && query((*l) - 1) <= i / 2)
ans += (hd - (*l) - 1) * (query(n) - 2 * query(hd - 1)), hd = *l;
}
now = S.find(hd), r = now;
r++;
if ((*r) <= n) {
if (query(n) - query(*r) <= i / 2 && query((*r) - 1) <= i / 2)
ans += ((*r) - hd - 1) * (2 * query(hd) - query(n)), hd = *r;
}
printf("%lld ", ans);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxd = 4e5 + 10;
long long t1[maxd], t2[maxd], pos[maxd], a[maxd], n;
void add(long long* t, long long x, long long v) {
for (; x < maxd; x += (x & -x)) t[x] += v;
}
long long query(long long* t, long long x) {
long long ans = 0;
for (; x; x -= (x & -x)) ans += t[x];
return ans;
}
int solve(long long* t, int v) {
int i = 0;
for (int j = 19; j >= 0; j--)
if ((i | 1 << j) < maxd)
if (t[i | (1 << j)] <= v) v -= t[i |= (1 << j)];
return i;
}
int main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
pos[a[i]] = i;
}
long long ans = 0ll;
for (int i = 1; i <= n; i++) {
int p = pos[i];
add(t1, p, 1);
ans += i - query(t1, p);
add(t2, p, p);
int mid = solve(t1, i / 2) + 1;
long long sum = 0;
long long aa = i / 2;
long long bb = i - i / 2 - 1;
sum += (long long)aa * mid - aa * (aa + 1) / 2 - query(t2, mid - 1);
sum += (query(t2, maxd - 1) - query(t2, mid)) - (long long)bb * mid -
1ll * bb * (bb + 1) / 2;
printf("%lld ", sum + ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return (b == 0 ? a : gcd(b, a % b));
}
char vow[] = {'a', 'e', 'i', 'o', 'u'};
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
const int N = 4e5 + 30;
const long long int mod = -1e11;
int n;
int tx[N];
set<long long int> s;
long long int t1[4 * N], t2[4 * N], t3[4 * N];
long long int flag1[4 * N], flag2[4 * N], flag3[4 * N];
long long int inv;
void push(int nd) {
t1[nd] += flag1[nd];
flag1[nd * 2] += flag1[nd];
flag1[nd * 2 + 1] += flag1[nd];
flag1[nd] = 0;
t2[nd] += flag2[nd];
flag2[nd * 2] += flag2[nd];
flag2[nd * 2 + 1] += flag2[nd];
flag2[nd] = 0;
t3[nd] += flag3[nd];
flag3[nd * 2] += flag3[nd];
flag3[nd * 2 + 1] += flag3[nd];
flag3[nd] = 0;
}
void upd1(int ql, int qr, long long int v, int nl = 1, int nr = n, int nd = 1) {
push(nd);
if (ql > nr || qr < nl) return;
if (ql == nl && qr == nr) {
flag1[nd] += v;
push(nd);
return;
}
int mid = (nl + nr) / 2;
upd1(ql, min(mid, qr), v, nl, mid, nd * 2);
upd1(max(mid + 1, ql), qr, v, mid + 1, nr, nd * 2 + 1);
}
long long int qry1(int q, int nl = 1, int nr = n, int nd = 1) {
push(nd);
if (q > nr || q < nl) return 0;
if (nl == nr) {
return t1[nd];
}
int mid = (nl + nr) / 2;
return qry1(q, nl, mid, nd * 2) + qry1(q, mid + 1, nr, nd * 2 + 1);
}
void upd2(int ql, int qr, long long int v, int nl = 1, int nr = n, int nd = 1) {
push(nd);
if (ql > nr || qr < nl) return;
if (ql == nl && qr == nr) {
flag2[nd] += v;
push(nd);
return;
}
int mid = (nl + nr) / 2;
upd2(ql, min(mid, qr), v, nl, mid, nd * 2);
upd2(max(mid + 1, ql), qr, v, mid + 1, nr, nd * 2 + 1);
}
long long int qry2(int q, int nl = 1, int nr = n, int nd = 1) {
push(nd);
if (q > nr || q < nl) return 0;
if (nl == nr) {
return t2[nd];
}
int mid = (nl + nr) / 2;
return qry2(q, nl, mid, nd * 2) + qry2(q, mid + 1, nr, nd * 2 + 1);
}
void upd3(int ql, int qr, long long int v, int nl = 1, int nr = n, int nd = 1) {
push(nd);
if (ql > nr || qr < nl) return;
if (ql == nl && qr == nr) {
flag3[nd] += v;
push(nd);
return;
}
int mid = (nl + nr) / 2;
upd3(ql, min(mid, qr), v, nl, mid, nd * 2);
upd3(max(mid + 1, ql), qr, v, mid + 1, nr, nd * 2 + 1);
}
long long int qry3(int q, int nl = 1, int nr = n, int nd = 1) {
push(nd);
if (q > nr || q < nl) return 0;
if (nl == nr) {
return t3[nd];
}
int mid = (nl + nr) / 2;
return qry3(q, nl, mid, nd * 2) + qry3(q, mid + 1, nr, nd * 2 + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
tx[a] = i + 1;
}
for (int i = 1; i <= n; i++) {
upd2(tx[i], n, 1);
long long int l = 1, r = n, ind = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (qry2(mid) >= (i + 1) / 2) {
ind = mid;
r = mid - 1;
} else
l = mid + 1;
}
long long int s = (i + 1) / 2;
long long int sum = s * ind - ((s - 1LL) * s) / 2LL;
if (tx[i] == 1)
upd1(tx[i], n, -tx[i]);
else {
upd1(1, tx[i] - 1, tx[i]);
upd1(tx[i], n, -tx[i]);
}
inv += qry3(tx[i]);
upd3(1, tx[i], 1);
long long int ans = inv + sum + qry1(ind);
ind += i - (i + 1LL) / 2LL;
sum = i * ind - ((i - 1LL) * 1LL * i) / 2LL - sum;
ans -= sum;
cout << ans << " ";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 2e5 + 233;
int ch[maxn];
int a[maxn], n, p[maxn];
long long ans[maxn], sum[maxn];
void add(int x, int v) {
for (int i = x; i <= n; i += i & (-i)) ch[i] += v;
}
int query(int x) {
int sum = 0;
for (int i = x; i; i -= i & (-i)) sum += ch[i];
return sum;
}
void add_sum(int x, int v) {
for (int i = x; i <= n; i += i & (-i)) sum[i] += v;
}
long long query_sum(int x) {
long long res = 0;
for (int i = x; i; i -= i & (-i)) res += sum[i];
return res;
}
int cal(int n, int x) {
int t = query(x);
return min(t, n - t);
}
int find(int k) {
k--;
int x = 0;
for (int i = 20; i >= 0; i--)
if (x + (1 << i) <= n && ch[x + (1 << i)] <= k) {
x += 1 << i;
k -= ch[x];
}
return x + 1;
}
inline long long ari(int n) { return 1ll * n * (n + 1) / 2; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), p[a[i]] = i;
for (int i = 1; i <= n; i++) {
int x = p[i];
ans[i] = ans[i - 1] + (i - 1 - query(x));
add(x, 1);
}
memset(ch, 0, sizeof(ch));
long long sum = 0;
for (int i = 1; i <= n; i++) {
int x = p[i];
add(x, 1);
add_sum(x, x);
sum += x;
int k = (i + 1) / 2;
long long c = find(k);
long long tmp = query_sum(c);
long long a = k * c - tmp - ari(k - 1);
long long b = (sum - tmp) - (i - k) * c - ari(i - k);
ans[i] += a + b;
}
for (int i = 1; i <= n; i++) printf("%I64d ", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200000;
long long a[200005], pos[200005];
long long sum1[200005], sum2[200005];
void add(long long *sum1, long long x, long long val) {
while (x <= maxn) {
sum1[x] += val;
x += x & (-x);
}
}
long long sum(long long *sum1, long long pos) {
long long res = 0;
while (pos) {
res += sum1[pos];
pos -= pos & (-pos);
}
return res;
}
signed main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
long long ans1 = 0, ans2 = 0;
for (long long i = 1; i <= n; i++) {
ans1 += i - 1 - sum(sum1, pos[i]);
add(sum1, pos[i], 1);
add(sum2, pos[i], pos[i]);
long long l = 1, r = n;
while (l < r) {
long long mid = l + r + 1 >> 1;
if (sum(sum1, mid) * 2 <= i) {
l = mid;
} else
r = mid - 1;
}
long long cnt = sum(sum1, l);
long long sum3 = sum(sum2, l);
ans2 = 0;
ans2 += cnt * l - sum3 - cnt * (cnt - 1) / 2;
cnt = i - cnt;
sum3 = sum(sum2, n) - sum(sum2, l);
ans2 += sum3 - cnt * (l + 1) - cnt * (cnt - 1) / 2;
cout << ans1 + ans2 << " ";
}
cout << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using pii = pair<int, int>;
using vii = vector<pii>;
using ll = long long;
int solve();
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
struct Fenwick {
vector<int> b;
int n;
Fenwick(int n) : n(n) { b.resize(n + 1); }
void add(int i) {
while (i > 0 && i <= n) {
b[i]++;
i += i & (-i);
}
}
int rank(int i) const {
int res = 0;
for (; i > 0; i -= i & (-i)) res += b[i];
return res;
}
int at_rank(int k) const {
int l = 0, r = n + 1;
while (l < r) {
int m = (l + r) / 2;
if (k <= rank(m))
r = m;
else
l = m + 1;
}
return l;
}
};
int solve() {
int n;
cin >> n;
vector<int> pos(n);
Fenwick f(n + 1);
for (int i = 0; i < n; i++) {
int p;
cin >> p;
pos[p - 1] = i + 1;
}
long long a = 0;
for (int i = 0; i < n; i++) {
int p = pos[i];
f.add(p);
int r = f.rank(p);
int m = i / 2 + 1;
if (r <= m) {
m += i & 1;
a += f.at_rank(m) - p - m + i - r + 2;
} else {
a += p - f.at_rank(m) + m - r;
}
cout << a << ' ';
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int N;
int position[maxn];
long long sum1[maxn << 2], sum2[maxn << 2];
void add(long long* bit, int pos, long long val) {
while (pos <= N) {
bit[pos] += val;
pos += pos & (-pos);
}
}
long long query(long long* bit, int pos) {
long long ret = 0;
while (pos) {
ret += bit[pos];
pos -= pos & (-pos);
}
return ret;
}
int search(long long* bit, int val) {
int l = 1, r = N, ret = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (query(bit, mid) < val) {
l = mid + 1;
} else {
ret = mid;
r = mid - 1;
}
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N;
for (int i = 1; i <= N; ++i) {
int p;
cin >> p;
position[p] = i;
}
long long cnt = 0;
for (int i = 1; i <= N; ++i) {
int p = position[i];
add(sum1, p, 1);
cnt += i - query(sum1, p);
add(sum2, p, p);
long long pos = search(sum1, i / 2 + 1);
long long sum = 0;
long long a = i / 2, b = i - a - 1;
sum += pos * a - a * (a + 1) / 2 - query(sum2, pos - 1);
sum += (query(sum2, N) - query(sum2, pos)) - b * pos - b * (b + 1) / 2;
cout << cnt + sum << " ";
}
cout << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[300005], pos[300005];
int lowbit(int now) { return now & (-now); }
long long sum[5][300005];
void add(int flag, int now, int val) {
for (int i = now; i <= n; i += lowbit(i)) sum[flag][i] += val;
}
long long query(int flag, int now) {
long long ans = 0;
for (int i = now; i; i -= lowbit(i)) ans += sum[flag][i];
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), pos[a[i]] = i;
long long ans1 = 0;
for (int i = 1; i <= n; i++) {
ans1 += (i - 1 - query(1, pos[i]));
add(1, pos[i], 1);
add(2, pos[i], pos[i]);
int nl = 1, nr = n, ans = 1;
while (nl <= nr) {
if (query(1, ((nl + nr) >> 1)) * 2 <= i) {
ans = ((nl + nr) >> 1);
nl = ((nl + nr) >> 1) + 1;
} else
nr = ((nl + nr) >> 1) - 1;
}
long long cnt1 = query(1, ans), cnt2 = i - cnt1;
long long res1 =
ans * cnt1 - query(2, ans) - (1 + cnt1 - 1) * (cnt1 - 1) / 2;
long long res2 = (query(2, n) - query(2, ans)) - ((ans + 1) * cnt2) -
(cnt2) * (cnt2 - 1) / 2;
printf("%lld ", ans1 + res1 + res2);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos((long double)-1.0);
const double EPS = 1e-10;
const int MOD = 1e9 + 7;
template <typename T>
void cmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
void cmax(T &x, T y) {
if (y > x) x = y;
}
long long qpow(long long x, long long n, long long mod = MOD) {
if (n < 0) return 0;
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long sq(long long x) { return x * x; }
long long read() {
long long res = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
res = res * 10 + (c - '0');
c = getchar();
}
return res;
}
const int MAXN = 200000 + 10;
int n;
int a[MAXN];
int pos[MAXN];
struct SegmentTree {
int cnt[MAXN << 2];
long long sum[MAXN << 2];
int add[MAXN << 2];
void PushUp(int o) {
cnt[o] = cnt[(o << 1)] + cnt[(o << 1 | 1)];
sum[o] = sum[(o << 1)] + sum[(o << 1 | 1)];
}
void PushDown(int o, int l, int r) {
if (add[o]) {
int m = (l + r) >> 1;
sum[(o << 1)] += 1LL * cnt[(o << 1)] * add[o];
sum[(o << 1 | 1)] += 1LL * cnt[(o << 1 | 1)] * add[o];
add[(o << 1)] += add[o];
add[(o << 1 | 1)] += add[o];
add[o] = 0;
}
}
void Build(int o, int l, int r) {
add[o] = 0;
if (l == r) {
cnt[o] = 1;
sum[o] = 0;
return;
}
int m = (l + r) >> 1;
Build((o << 1), l, m);
Build((o << 1 | 1), m + 1, r);
PushUp(o);
}
void Add(int o, int l, int r, int ql, int qr, int v) {
if (ql <= l && r <= qr) {
sum[o] += 1LL * cnt[o] * v;
add[o] += v;
return;
}
PushDown(o, l, r);
int m = (l + r) >> 1;
if (ql <= m) Add((o << 1), l, m, ql, qr, v);
if (qr >= m + 1) Add((o << 1 | 1), m + 1, r, ql, qr, v);
PushUp(o);
}
void SetCnt0(int o, int l, int r, int p) {
if (l == r) {
cnt[o] = 0;
sum[o] = 0;
return;
}
PushDown(o, l, r);
int m = (l + r) >> 1;
if (p <= m) SetCnt0((o << 1), l, m, p);
if (p >= m + 1) SetCnt0((o << 1 | 1), m + 1, r, p);
PushUp(o);
}
int Cnt(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return cnt[o];
PushDown(o, l, r);
int m = (l + r) >> 1;
int res = 0;
if (ql <= m) res = res + Cnt((o << 1), l, m, ql, qr);
if (qr >= m + 1) res = res + Cnt((o << 1 | 1), m + 1, r, ql, qr);
return res;
}
long long Sum(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sum[o];
PushDown(o, l, r);
int m = (l + r) >> 1;
long long res = 0;
if (ql <= m) res = res + Sum((o << 1), l, m, ql, qr);
if (qr >= m + 1) res = res + Sum((o << 1 | 1), m + 1, r, ql, qr);
return res;
}
int Pos(int o, int l, int r, int k) {
if (l == r) return l;
PushDown(o, l, r);
int m = (l + r) >> 1;
int cnt0ls = (m - l + 1) - cnt[(o << 1)];
if (cnt0ls >= k) return Pos((o << 1), l, m, k);
return Pos((o << 1 | 1), m + 1, r, k - cnt0ls);
}
int Lmid() {
int cnt0 = n - cnt[1];
return Pos(1, 1, n, (cnt0 + 1) / 2);
}
int Rmid() {
int cnt0 = n - cnt[1];
return Pos(1, 1, n, cnt0 / 2 + 1);
}
} st;
namespace Solver {
void InitOnce() { int t; }
void Read() {
int res = scanf("%d", &n);
if (res == -1) exit(0);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
}
long long ans[200005];
void Solve() {
st.Build(1, 1, n);
long long cur = 0;
int Lmost = n, Rmost = 1;
for (int i = 1; i <= n; ++i) {
int p = pos[i];
cmin(Lmost, p);
cmax(Rmost, p);
cur += (n - p + 1) - st.Cnt(1, 1, n, p, n);
if (i >= 2) {
int Lmid = st.Lmid();
int Rmid = st.Rmid();
if (p < Lmid) st.Add(1, 1, n, p + 1, Lmid - 1, 1);
if (p > Rmid) st.Add(1, 1, n, Rmid + 1, p - 1, 1);
}
st.SetCnt0(1, 1, n, p);
ans[i] = cur + st.Sum(1, 1, n, Lmost, Rmost);
printf("%lld%c", ans[i], " \n"[i == n]);
}
}
} // namespace Solver
int main() {
Solver::InitOnce();
while (true) {
Solver::Read();
Solver::Solve();
}
return 0;
}
| 11 | CPP |
n = int(input())
a = [0] + list(map(int, input().split()))
pos, pb, ps = [[0] * (n + 1) for x in range(3)]
def add(bit, i, val):
while i <= n:
bit[i] += val
i += i & -i
def sum(bit, i):
res = 0
while i > 0:
res += bit[i]
i -= i & -i
return res
def find(bit, sum):
i, t = 0, 0
if sum == 0:
return 0
for k in range(17, -1, -1):
i += 1 << k
if i <= n and t + bit[i] < sum:
t += bit[i]
else:
i -= 1 << k
return i + 1
for i in range(1, n + 1):
pos[a[i]] = i
invSum = 0
totalSum = 0
for i in range(1, n + 1):
totalSum += pos[i]
invSum += i - sum(pb, pos[i]) - 1
add(pb, pos[i], 1)
add(ps, pos[i], pos[i])
mid = find(pb, i // 2)
if i % 2 == 1:
mid2 = find(pb, i // 2 + 1)
seqSum = (i + 1) * (i // 2) // 2
else:
mid2 = mid
seqSum = i * (i // 2) // 2
leftSum = sum(ps, mid)
rightSum = totalSum - sum(ps, mid2)
print(rightSum - leftSum - seqSum + invSum, end=" ")
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int n;
int a[MAXN];
int pos[MAXN];
struct BIT {
long long tree[MAXN];
BIT() {}
int LB(int x) { return x & -x; }
void Modify(int p, long long k) {
while (p <= n) {
tree[p] += k;
p += LB(p);
}
}
long long Query(int p) {
long long res = 0;
while (p >= 1) {
res += tree[p];
p -= LB(p);
}
return res;
}
int GetPos(long long sum) {
int l = 1, r = n, res = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (Query(mid) <= sum) {
res = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
return res;
}
} T1, T2;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
long long cnt = 0;
for (int i = 1; i <= n; i++) {
int p = pos[i];
T1.Modify(p, 1);
cnt += (long long)i - T1.Query(p);
T2.Modify(p, p);
int midp = T1.GetPos(i >> 1) + 1;
long long tot = 0;
long long l = i / 2, r = i - i / 2 - 1;
tot += l * midp - l * (l + 1) / 2 - T2.Query(midp - 1);
tot += (T2.Query(n) - T2.Query(midp)) - r * midp - r * (r + 1) / 2;
cout << tot + cnt << ' ';
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1061109567;
const long long LINF = 4557430888798830399ll;
const int MOD = 1000000007;
long long qpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
struct Treap {
static const int MAXN = 200000 + 5;
int ch[MAXN][2], dat[MAXN];
pair<int, int> val[MAXN];
int cnt[MAXN];
int siz[MAXN];
int tot, root;
inline void Init() {
tot = 0;
root = 0;
}
inline int NewNode(pair<int, int> v, int num) {
int id = ++tot;
ch[id][0] = ch[id][1] = 0;
dat[id] = rand();
val[id] = v;
cnt[id] = num;
siz[id] = num;
return id;
}
inline void PushUp(int id) {
siz[id] = siz[ch[id][0]] + siz[ch[id][1]] + cnt[id];
}
inline void Rotate(int &id, int d) {
int temp = ch[id][d ^ 1];
ch[id][d ^ 1] = ch[temp][d];
ch[temp][d] = id;
id = temp;
PushUp(ch[id][d]);
PushUp(id);
}
inline void Insert(int &id, pair<int, int> v, int num) {
if (!id)
id = NewNode(v, num);
else {
if (v == val[id])
cnt[id] += num;
else {
int d = val[id] > v ? 0 : 1;
Insert(ch[id][d], v, num);
if (dat[id] < dat[ch[id][d]]) Rotate(id, d ^ 1);
}
PushUp(id);
}
}
void Remove(int &id, pair<int, int> v, int num) {
if (!id)
return;
else {
if (v == val[id]) {
if (cnt[id] > num) {
cnt[id] -= num;
PushUp(id);
} else if (ch[id][0] || ch[id][1]) {
if (!ch[id][1] || dat[ch[id][0]] > dat[ch[id][1]])
Rotate(id, 1), Remove(ch[id][1], v, num);
else
Rotate(id, 0), Remove(ch[id][0], v, num);
PushUp(id);
} else
id = 0;
} else {
val[id] > v ? Remove(ch[id][0], v, num) : Remove(ch[id][1], v, num);
PushUp(id);
}
}
}
int GetRank(int id, pair<int, int> v) {
int res = 1;
while (id) {
if (val[id] > v)
id = ch[id][0];
else if (val[id] == v) {
res += siz[ch[id][0]];
break;
} else {
res += siz[ch[id][0]] + cnt[id];
id = ch[id][1];
}
}
return res;
}
pair<int, int> GetValue(int id, int rk) {
pair<int, int> res = {INF, INF};
while (id) {
if (siz[ch[id][0]] >= rk)
id = ch[id][0];
else if (siz[ch[id][0]] + cnt[id] >= rk) {
res = val[id];
break;
} else {
rk -= siz[ch[id][0]] + cnt[id];
id = ch[id][1];
}
}
return res;
}
} treap1, treap2;
int n;
int a[200005];
int p[200005];
long long ans[200005];
void test_case() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
p[a[i]] = i;
}
treap1.Init();
treap2.Init();
int Lmost = p[1], Rmost = p[1];
long long cnt1 = 0, cnt2 = 0;
treap1.Insert(treap1.root, {p[1], 1}, 1);
treap2.Insert(treap2.root, {p[1], 1}, 1);
pair<int, int> mid1, mid2;
mid1 = mid2 = {p[1], 1};
ans[1] = 0;
for (int i = 2; i <= n; ++i) {
treap1.Insert(treap1.root, {p[i], i}, 1);
if (i % 2 == 0) {
mid1 = treap1.GetValue(treap1.root, i / 2);
mid2 = treap1.GetValue(treap1.root, i / 2 + 1);
} else
mid1 = mid2 = treap1.GetValue(treap1.root, (i + 1) / 2);
int rk1 = treap1.GetRank(treap1.root, {p[i], i});
if (p[i] < Lmost) {
for (int j = Lmost - 1; j >= p[i]; --j)
treap2.Insert(treap2.root, {j, a[j]}, 1);
Lmost = p[i];
cnt2 += treap2.GetRank(treap2.root, mid2) - 1 - i / 2;
} else if (p[i] > Rmost) {
for (int j = Rmost + 1; j <= p[i]; ++j)
treap2.Insert(treap2.root, {j, a[j]}, 1);
Rmost = p[i];
cnt2 +=
treap2.siz[treap2.root] - treap2.GetRank(treap2.root, mid1) - i / 2;
} else {
if (p[i] >= mid2.first) {
cnt2 -= i - rk1;
cnt2 -= treap2.siz[treap2.root] -
treap2.GetRank(treap2.root, {p[i], i}) - (i - rk1);
cnt2 +=
treap2.siz[treap2.root] - treap2.GetRank(treap2.root, mid1) - i / 2;
} else if (p[i] <= mid1.first) {
cnt2 -= rk1 - 1;
cnt2 -= treap2.GetRank(treap2.root, {p[i], i}) - (rk1 - 1);
cnt2 += treap2.GetRank(treap2.root, mid2) - i / 2;
}
}
cnt1 += i - rk1;
ans[i] = cnt1 + cnt2;
}
for (int i = 1; i <= n; ++i) printf("%lld%c", ans[i], " \n"[i == n]);
}
int main() {
int t = 1;
for (int ti = 1; ti <= t; ++ti) {
test_case();
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1061109567;
const long long LINF = 4557430888798830399ll;
const int MOD = 1000000007;
long long qpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
struct TreapNode {
int val1, val2;
TreapNode() {}
TreapNode(int val1, int val2) : val1(val1), val2(val2) {}
bool operator<(const TreapNode& tn) const { return val1 < tn.val1; }
bool operator<=(const TreapNode& tn) const { return val1 <= tn.val1; }
bool operator==(const TreapNode& tn) const { return val1 == tn.val1; }
bool operator>=(const TreapNode& tn) const { return val1 >= tn.val1; }
bool operator>(const TreapNode& tn) const { return val1 > tn.val1; }
} TNINF(INF, INF);
struct Treap {
static const int MAXN = 200000;
int ch[MAXN + 5][2], dat[MAXN + 5];
TreapNode val[MAXN + 5];
int cnt[MAXN + 5];
int siz[MAXN + 5];
int tot, root;
void Init() {
tot = 0;
root = 0;
}
int NewNode(TreapNode v, int num) {
int id = ++tot;
ch[id][0] = ch[id][1] = 0;
dat[id] = rand();
val[id] = v;
cnt[id] = num;
siz[id] = num;
return id;
}
void PushUp(int id) { siz[id] = siz[ch[id][0]] + siz[ch[id][1]] + cnt[id]; }
void Rotate(int& id, int d) {
int temp = ch[id][d ^ 1];
ch[id][d ^ 1] = ch[temp][d];
ch[temp][d] = id;
id = temp;
PushUp(ch[id][d]);
PushUp(id);
}
void _Insert(int& id, TreapNode v, int num) {
if (!id)
id = NewNode(v, num);
else {
if (v == val[id])
cnt[id] += num;
else {
int d = val[id] > v ? 0 : 1;
_Insert(ch[id][d], v, num);
if (dat[id] < dat[ch[id][d]]) Rotate(id, d ^ 1);
}
PushUp(id);
}
}
void _Remove(int& id, TreapNode v, int num) {
if (!id)
return;
else {
if (v == val[id]) {
if (cnt[id] > num) {
cnt[id] -= num;
PushUp(id);
} else if (ch[id][0] || ch[id][1]) {
if (!ch[id][1] || dat[ch[id][0]] > dat[ch[id][1]])
Rotate(id, 1), _Remove(ch[id][1], v, num);
else
Rotate(id, 0), _Remove(ch[id][0], v, num);
PushUp(id);
} else
id = 0;
} else {
val[id] > v ? _Remove(ch[id][0], v, num) : _Remove(ch[id][1], v, num);
PushUp(id);
}
}
}
int _GetRank(int id, TreapNode v) {
int res = 1;
while (id) {
if (val[id] > v)
id = ch[id][0];
else if (val[id] == v) {
res += siz[ch[id][0]];
break;
} else {
res += siz[ch[id][0]] + cnt[id];
id = ch[id][1];
}
}
return res;
}
TreapNode _GetValue(int id, int rk) {
TreapNode res = TNINF;
while (id) {
if (siz[ch[id][0]] >= rk)
id = ch[id][0];
else if (siz[ch[id][0]] + cnt[id] >= rk) {
res = val[id];
break;
} else {
rk -= siz[ch[id][0]] + cnt[id];
id = ch[id][1];
}
}
return res;
}
int Size() { return siz[root]; }
void Insert(TreapNode v, int num = 1) { _Insert(root, v, num); }
void Remove(TreapNode v, int num = INF) { _Remove(root, v, num); }
int GetRank(TreapNode v) { return _GetRank(root, v); }
TreapNode GetValue(int rk) { return _GetValue(root, rk); }
} treap1, treap2;
int n;
int a[200005];
int p[200005];
long long ans[200005];
void test_case() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
p[a[i]] = i;
}
treap1.Init();
treap2.Init();
int Lmost = p[1], Rmost = p[1];
long long cnt1 = 0, cnt2 = 0;
TreapNode cur(p[1], 1);
treap1.Insert(cur);
treap2.Insert(cur);
TreapNode mid1, mid2;
mid1 = mid2 = cur;
ans[1] = 0;
for (int i = 2; i <= n; ++i) {
cur = TreapNode(p[i], i);
treap1.Insert(cur, 1);
mid1 = treap1.GetValue((i + 1) / 2);
mid2 = treap1.GetValue(i / 2 + 1);
if (p[i] < Lmost) {
for (int j = Lmost - 1; j >= p[i]; --j) treap2.Insert(TreapNode(j, a[j]));
Lmost = p[i];
} else if (p[i] > Rmost) {
for (int j = Rmost + 1; j <= p[i]; ++j) treap2.Insert(TreapNode(j, a[j]));
Rmost = p[i];
}
cnt1 += i - treap1.GetRank(cur);
if (p[i] >= mid2.val1) {
cnt2 -= treap2.Size() - treap2.GetRank(cur);
cnt2 += treap2.Size() - treap2.GetRank(mid1) - i / 2;
} else if (p[i] <= mid1.val1) {
cnt2 -= treap2.GetRank(cur);
cnt2 += treap2.GetRank(mid2) - i / 2;
}
ans[i] = cnt1 + cnt2;
}
for (int i = 1; i <= n; ++i) printf("%lld%c", ans[i], " \n"[i == n]);
}
int main() {
int t = 1;
for (int ti = 1; ti <= t; ++ti) {
test_case();
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const bool debug = true;
int p[200001];
int pos[200001];
class seg_tree {
int* st;
int n;
public:
seg_tree(int a) {
st = new int[2 * a];
for (int i = 0; i < 2 * a; i++) st[i] = 0;
n = a;
}
void set(int x) {
x += n;
st[x] = 1;
x /= 2;
while (x) {
st[x] = st[2 * x] + st[2 * x + 1];
x /= 2;
}
}
int query(int l, int r) {
l += n;
r += n;
int ans = 0;
while (l < r) {
if (l & 1) {
ans += st[l++];
}
if (r & 1) {
ans += st[--r];
}
l >>= 1;
r >>= 1;
}
return ans;
}
};
class median {
priority_queue<int, vector<int>, greater<int>> higher;
priority_queue<int> lower;
long long int suml, sumr;
public:
median() {
suml = 0;
sumr = 0;
}
void insert(int n) {
if ((lower.empty() && higher.empty()) || n < lower.top()) {
lower.push(n);
suml += n;
if (lower.size() > higher.size() + 1) {
higher.push(lower.top());
sumr += lower.top();
suml -= lower.top();
lower.pop();
}
} else {
higher.push(n);
sumr += n;
if (higher.size() > lower.size()) {
lower.push(higher.top());
suml += higher.top();
sumr -= higher.top();
higher.pop();
}
}
}
int get_median() { return lower.top(); }
long long get_swaps() {
long long int n = lower.size();
long long int l = lower.top() * n - suml - ((n) * (n - 1)) / 2;
n = higher.size();
long long r = sumr - lower.top() * n - ((n) * (n + 1)) / 2;
return l + r;
}
};
int main() {
int n;
cin >> n;
for (int z = 1; z < n + 1; z++) {
cin >> p[z];
pos[p[z]] = z;
}
seg_tree cind(n + 1);
median med;
long long inv = 0;
for (int z = 1; z < n + 1; z++) {
inv += cind.query(pos[z], n + 1);
cind.set(pos[z]);
med.insert(pos[z]);
cout << inv + med.get_swaps() << " ";
}
cout << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1, base = (1 << 19);
int n, p[N], inv_t[2 * base + 1], where[N], pref;
long long pos_t[2 * base + 1];
void add(int pos) {
pos += base;
while (pos) {
inv_t[pos]++;
pos /= 2;
}
}
int sum(int l, int r) {
l += base;
r += base;
int res = inv_t[l];
if (l != r) {
res += inv_t[r];
}
while (l / 2 != r / 2) {
if (l % 2 == 0) {
res += inv_t[l + 1];
}
if (r % 2 == 1) {
res += inv_t[r - 1];
}
l /= 2;
r /= 2;
}
return res;
}
int find_med(int id, int k) {
if (id >= base) {
return id - base;
}
if (inv_t[id * 2] + pref >= k) {
return find_med(id * 2, k);
}
pref += inv_t[id * 2];
return find_med(id * 2 + 1, k);
}
void ins(int pos, long long val) {
pos += base;
while (pos) {
pos_t[pos] += val;
pos /= 2;
}
}
long long pos_q(int l, int r) {
l += base;
r += base;
long long res = pos_t[l];
if (l != r) {
res += pos_t[r];
}
while (l / 2 != r / 2) {
if (l % 2 == 0) {
res += pos_t[l + 1];
}
if (r % 2 == 1) {
res += pos_t[r - 1];
}
l /= 2;
r /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> p[i];
where[p[i]] = i;
}
long long inv = 0;
for (int i = 1; i <= n; ++i) {
long long l = sum(0, where[i]);
long long r = sum(where[i], n - 1);
inv += r;
add(where[i]);
ins(where[i], where[i]);
int med = find_med(1, (i - 1) / 2 + 1);
pref = 0;
l = sum(0, med) - 1;
r = sum(med, n - 1) - 1;
long long cost = -pos_q(0, med) + pos_q(med, n - 1) +
(long long)med * (l - r) - r * (r + 1LL) / 2LL -
l * (l + 1LL) / 2LL;
cout << inv + cost << ' ';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 10;
int bit[MAX_N], n, pos[MAX_N], x;
long long ans = 0;
int lowbit(int x) { return x & (-x); }
int sum(int x) {
int res = 0;
while (x < MAX_N) {
res += bit[x];
x += lowbit(x);
}
return res;
}
void update(int x) {
while (x) {
bit[x] += 1;
x -= lowbit(x);
}
}
int get(int d) {
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) >> 1;
if (sum(mid) >= d) {
l = mid + 1;
} else {
r = mid - 1;
}
}
return r;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
pos[x] = i;
}
for (int i = 1; i <= n; i++) {
int mid = (i + 1) / 2;
if (i & 1) {
update(pos[i]);
int k = get(mid);
int dis = abs(pos[i] - k) - abs(sum(pos[i]) - sum(k));
if (pos[i] < k) {
ans += -(sum(1) - sum(pos[i]));
} else {
ans += -sum(pos[i] + 1);
}
ans += dis + sum(pos[i] + 1);
} else {
int k = get(mid);
int dis =
abs(pos[i] - k) - abs(sum(pos[i]) + (pos[i] < k ? 1 : 0) - sum(k));
if (pos[i] < k) {
ans += -(sum(1) - sum(pos[i]));
} else {
ans += -sum(pos[i] + 1);
}
ans += dis + sum(pos[i] + 1);
update(pos[i]);
}
printf("%I64d ", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
int a[MAX], p[MAX], n;
long long c1[MAX], c2[MAX];
set<int> st;
void add(long long *c, int x, int k) {
for (; x <= n; x += x & -x) c[x] += k;
}
long long query(long long *c, int x) {
long long sum = 0;
for (; x; x -= x & -x) sum += c[x];
return sum;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), p[a[i]] = i;
st.insert(p[1]);
auto it = st.begin();
printf("0 ");
add(c1, p[1], 1);
add(c2, p[1], p[1]);
long long res = 0;
for (int i = 2; i <= n; i++) {
st.insert(p[i]);
if (p[i] < (*it) && i % 2 == 0) it--;
if (p[i] > (*it) && i % 2 == 1) it++;
add(c1, p[i], 1);
res += (i * 1ll - query(c1, p[i]));
add(c2, p[i], p[i]);
int midpos = *it;
long long sum = 0, k = i / 2;
sum += i & 1 ? k * (midpos - 1 + midpos - k) / 2
: (k - 1) * (midpos + midpos - k) / 2;
sum -= k * (midpos + 1 + midpos + k) / 2;
sum -= query(c2, midpos - 1);
sum += query(c2, n) - query(c2, midpos);
printf("%I64d ", res + sum);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1061109567;
const int MAXN = 201010;
int n, median;
int v[MAXN];
int ind[MAXN];
long long st[4 * MAXN];
long long adjust[MAXN];
long long inversions[MAXN];
priority_queue<int> maxheap;
priority_queue<int, vector<int>, greater<int> > minheap;
void update(int nd, int l, int r, int pos, int x) {
if (l == r) {
st[nd] = x;
return;
}
if (pos < l || pos > r) return;
int mid = (l + r) >> 1;
int nxt = nd << 1;
if (pos <= mid) update(nxt, l, mid, pos, x);
if (pos > mid) update(nxt + 1, mid + 1, r, pos, x);
st[nd] = st[nxt] + st[nxt + 1];
}
long long query(int nd, int l, int r, int lq, int rq) {
if (r < lq || rq < l) return 0;
if (lq <= l && r <= rq) return st[nd];
int mid = (l + r) >> 1;
int nxt = nd << 1;
return query(nxt, l, mid, lq, rq) + query(nxt + 1, mid + 1, r, lq, rq);
}
long long gather(int k, int med_pos) {
long long rh = k - (k / 2);
long long lh = k - rh;
long long r_tar_sum = ((med_pos + (med_pos + rh - 1)) * rh) / 2;
long long l_tar_sum = ((med_pos - 1 + (med_pos - lh)) * lh) / 2;
long long r_pos_sum = query(1, 0, n, med_pos, n);
long long l_pos_sum = query(1, 0, n, 0, max(0, med_pos - 1));
long long ret_val = (l_tar_sum - l_pos_sum) + (r_pos_sum - r_tar_sum);
return ret_val;
}
void reset_seg_tree() {
for (int i = 1; i <= n; i++) update(1, 0, n, i, 0);
return;
}
void heap_insert(int x) {
if (maxheap.size() > minheap.size()) {
if (x < median) {
minheap.push(maxheap.top());
maxheap.pop();
maxheap.push(x);
} else {
minheap.push(x);
}
median = minheap.top();
} else if (maxheap.size() == minheap.size()) {
if (x < median) {
maxheap.push(x);
median = maxheap.top();
} else {
minheap.push(x);
median = minheap.top();
}
} else {
if (x > median) {
maxheap.push(minheap.top());
minheap.pop();
minheap.push(x);
} else {
maxheap.push(x);
}
median = minheap.top();
}
return;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> v[i];
ind[v[i]] = i;
}
for (int k = 1; k <= n; k++) {
heap_insert(ind[k]);
update(1, 0, n, ind[k], ind[k]);
adjust[k] = gather(k, median);
}
reset_seg_tree();
inversions[0] = 0;
for (int k = 1; k <= n; k++) {
inversions[k] = inversions[k - 1] + query(1, 0, n, ind[k] + 1, n - 1);
update(1, 0, n, ind[k], 1);
}
for (int i = 1; i <= n; i++)
cout << (inversions[i] + adjust[i]) << " \n"[i == n];
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long bit[N] = {};
int idx[N] = {};
int n;
priority_queue<int> A;
priority_queue<int, vector<int>, greater<int>> B;
inline long long __abs(int x) { return (x ^ (x >> 31)) - (x >> 31); }
long long sum(int x) {
int ret = 0;
while (x) {
ret += bit[x];
x -= (x & -x);
}
return ret;
}
void add(int x, int val) {
while (x <= n) {
bit[x] += val;
x += (x & -x);
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
long long x, now = 0, d = 0, t, f, p;
for (int i = 1; i <= n; i++) {
cin >> x;
idx[x] = i;
}
x = idx[1];
for (long long i = 1; i <= n; i++) {
B.emplace(idx[i]);
A.emplace(B.top());
B.pop();
while (A.size() > ((i + 1) >> 1)) {
B.emplace(A.top());
A.pop();
}
while (A.size() < B.size()) {
A.emplace(B.top());
B.pop();
}
f = A.top(), p = (i / 2) * (i / 2 + 1) - (i / 2) * ((i & 1) == 0),
t = A.size() - (f > x);
now += __abs(idx[i] - x) + (f - x) * (t + t - i);
x = f;
add(idx[i], 1);
d += i - sum(idx[i]);
cout << now - p + d << " \n"[i == n];
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const int inf = (1 << 29) - 1;
const int maxn = (int)2e5 + 10;
const int mod = (int)1e9 + 7;
using namespace std;
int n;
int p[maxn];
long long t[2][maxn];
int rp[maxn];
void upd(int id, int pos, int val) {
for (int i = pos; i <= n; i |= i + 1) t[id][i] += val;
}
long long get(int id, int pos) {
long long res = 0;
while (pos >= 0) {
res += t[id][pos];
pos = (pos & (pos + 1)) - 1;
}
return res;
}
set<int> s1, s2;
long long inv;
long long add(int p, int k) {
inv += get(0, n) - get(0, p);
upd(0, p, 1);
upd(1, p, p);
long long ans = inv;
s2.insert(p);
s1.insert(*s2.begin());
s2.erase(s2.begin());
if (s2.size() + 2 <= s1.size()) {
s2.insert(*(--s1.end()));
s1.erase(--s1.end());
}
long long m = *(--s1.end());
long long F = s1.size() - 1;
long long S = s2.size();
ans += F * m - get(1, m - 1) - F * (F + 1ll) / 2;
ans += get(1, n) - get(1, m) - m * S - S * (S + 1ll) / 2;
return ans;
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
rp[p[i]] = i;
}
for (int i = 1; i <= n; i++) {
int pos = rp[i];
cout << add(pos, i) << "\n";
}
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
long long mid[N], a[N], mark[N], k, f1[N][2], n, g[N], h[N], p, ct, cn,
tvn = 1, tedad[N * 4];
string s, s2;
long long saghf(long long x) { return (x / 2) + (x % 2); }
string binary(int m, int k) {
string g = "";
for (long long i = 0; i < k; i++) {
g += char((m % 2) + '0');
m = m / 2;
}
return g;
}
int main() {
cin >> n;
cn = n;
for (long long i = 1; i < n + 1; i++)
cin >> a[i], mark[a[i]] = i, f1[i][0] = i - 1, f1[i][1] = i + 1;
k = saghf(n);
for (long long i = n; i >= 1; i--) {
mid[i] = k;
if (i % 2 == 0) {
if (mark[i] <= k) k = f1[k][1];
} else {
if (mark[i] >= k) k = f1[k][0];
}
f1[f1[mark[i]][0]][1] = f1[mark[i]][1];
f1[f1[mark[i]][1]][0] = f1[mark[i]][0];
}
k = 0;
for (long long i = 2; i < n; i++) {
if (i % 2 == 0) {
if (mid[i] == mid[i - 1])
g[i] = g[i - 1] + (mark[i] - mid[i]) - (i / 2);
else
g[i] =
g[i - 1] + (mid[i - 1] - mid[i]) + (mid[i] - mark[i]) - ((i / 2));
} else {
if (mid[i] == mid[i - 1])
g[i] = g[i - 1] + (mid[i] - mark[i]) - (i / 2);
else
g[i] = g[i - 1] + (mark[i] - mid[i]) - (i / 2);
}
}
for (long long i = 1; i < (n + 3) / 2; i++) {
swap(a[i], a[n + 1 - i]);
a[i] = n + 1 - a[i];
a[n + 1 - i] = n + 1 - a[n + 1 - i];
}
if (n % 2 == 1) a[(n + 1) / 2] = n + 1 - a[(n + 1) / 2];
while (cn) {
k++;
cn /= 2;
tvn *= 2;
}
tvn /= 2;
for (long long i = 1; i < n + 1; i++) {
s = binary(a[i], k);
p = 0;
ct = tvn;
long long t = 0, m = tvn * 2 - a[i], p1 = tvn * 2;
s2 = binary(m, k);
for (long long j = k - 1; j >= 0; j--) {
if (s2[j] == '1') {
p1 -= ct;
t += tedad[p1];
}
ct /= 2;
}
h[n + 1 - a[i]] = t;
ct = tvn;
for (long long j = k - 1; j >= 0; j--) {
if (s[j] == '1') {
p += ct;
tedad[p]++;
}
ct /= 2;
}
}
for (long long i = 1; i < n + 1; i++) {
h[i] += h[i - 1];
cout << h[i] + g[i] << " ";
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long bit[N] = {};
int idx[N] = {};
int n;
priority_queue<int> A;
priority_queue<int, vector<int>, greater<int>> B;
long long sum(int x) {
int ret = 0;
while (x) {
ret += bit[x];
x -= (x & -x);
}
return ret;
}
void add(int x, int val) {
while (x <= n) {
bit[x] += val;
x += (x & -x);
}
}
int main() {
cin >> n;
long long x;
for (int i = 1; i <= n; i++) {
cin >> x;
idx[x] = i;
}
long long now = 0, d = 0, t;
x = idx[1];
for (int i = 1; i <= n; i++) {
B.emplace(idx[i]);
A.emplace(B.top());
B.pop();
while (A.size() > ((i + 1) >> 1)) {
B.emplace(A.top());
A.pop();
}
while (A.size() < B.size()) {
A.emplace(B.top());
B.pop();
}
long long f = A.top(),
p = (long long)(i / 2) * (i / 2 + 1) - (i / 2) * ((i & 1) == 0),
t = (long long)A.size() - (f >= x);
now += abs(idx[i] - x) + (f - x) * (t + t - i);
x = f;
add(idx[i], 1);
d += i - sum(idx[i]);
cout << now - p + d << " \n"[i == n];
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n;
int pos[maxn];
long long sum1[maxn], sum2[maxn];
int lowbit(int x) { return x & -x; }
void add(long long *sum, int x, long long v) {
while (x <= n) {
sum[x] += v;
x += lowbit(x);
}
}
long long query(long long *sum, int x) {
long long ans = 0;
while (x > 0) {
ans += sum[x];
x -= lowbit(x);
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int p;
scanf("%d", &p);
pos[p] = i;
}
long long rev = 0;
for (int i = 1; i <= n; i++) {
add(sum1, pos[i], 1);
add(sum2, pos[i], pos[i]);
rev += i - query(sum1, pos[i]);
int l = 1, r = n, mid = (l + r) >> 1;
while (l < r) {
if (query(sum1, mid) <= i / 2)
l = mid + 1;
else
r = mid;
mid = (l + r) >> 1;
}
long long cntl = query(sum1, mid) - 1, cntr = i - cntl - 1;
long long ans = 1LL * mid * (cntl - cntr + 1) + query(sum2, n) -
2 * query(sum2, mid) - (cntl + 1) * cntl / 2 -
(cntr + 1) * cntr / 2;
ans += rev;
printf("%lld ", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long ans, n, a[210000], x, sum1, sum2, las;
int rd[450000], siz[450000], son[450000][2], v[450000], root, num[450000], cnt;
priority_queue<int> q1;
priority_queue<int, vector<int>, greater<int> > q2;
inline void update(int x) {
if (!q2.size() || x > q2.top())
q2.push(x), sum2 += x;
else
q1.push(x), sum1 += x;
if (q1.size() > q2.size() + 1) {
sum1 -= q1.top(), sum2 += q1.top();
q2.push(q1.top());
q1.pop();
}
if (q2.size() > q1.size() + 1) {
sum2 -= q2.top(), sum1 += q2.top();
q1.push(q2.top());
q2.pop();
}
return;
}
inline int ask() {
if (q1.size() > q2.size()) return q1.top();
return q2.top();
}
int judge(int id) {
int ans = 1;
if (son[id][0]) ans++;
if (son[id][1]) ans += 2;
return ans;
}
void push_up(int id) {
siz[id] = siz[son[id][0]] + siz[son[id][1]] + num[id];
return;
}
void rotate(int &p, int d) {
int r = son[p][d ^ 1];
son[p][d ^ 1] = son[r][d];
son[r][d] = p;
push_up(p);
push_up(r);
p = r;
return;
}
void ins(int &p, int d) {
if (!p) {
p = ++cnt;
v[p] = d;
num[p] = siz[p] = 1;
rd[p] = rand();
return;
}
if (v[p] == d) {
num[p]++;
siz[p]++;
return;
}
int t = 0;
if (v[p] < d) t = 1;
ins(son[p][t], d);
if (rd[p] < rd[son[p][t]]) rotate(p, t ^ 1);
push_up(p);
return;
}
int rk(int p, int x) {
if (!p) return 0;
if (v[p] == x) return siz[son[p][0]] + 1;
if (v[p] < x) return siz[son[p][0]] + rk(son[p][1], x) + num[p];
if (v[p] > x) return rk(son[p][0], x);
}
int find(int p, int x) {
if (!p) return 0;
if (siz[son[p][0]] >= x) return find(son[p][0], x);
if (siz[son[p][0]] + num[p] >= x) return v[p];
return find(son[p][1], x - (siz[son[p][0]] + num[p]));
}
int main() {
srand((unsigned)time(NULL));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
a[x] = i;
}
for (int i = 1; i <= n; i++) {
update(a[i]);
int x = ask();
if (q2.size() >= q1.size()) {
ans =
sum2 - (1ll * q2.size() * x) - 1ll * (q2.size() - 1) * q2.size() / 2;
ans +=
(1ll * q1.size() * x) - sum1 - 1ll * (q1.size() + 1) * q1.size() / 2;
} else {
ans =
sum2 - (1ll * q2.size() * x) - 1ll * (q2.size() + 1) * q2.size() / 2;
ans +=
(1ll * q1.size() * x) - sum1 - 1ll * (q1.size() - 1) * q1.size() / 2;
}
ins(root, a[i]);
long long rr = rk(root, a[i]);
las += i - rr;
ans += las;
printf("%lld ", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const long long maxn = 200000 + 10;
class BIT {
private:
long long n;
long long bit[maxn];
public:
BIT(long long size) {
n = size;
std::fill(bit, bit + maxn, 0);
}
void add(long long x, long long v) {
while (x <= this->n) {
bit[x] += v;
x += ((x) & (-x));
}
}
long long query(long long x) {
long long ans = 0;
while (x) {
ans += bit[x];
x -= ((x) & (-x));
}
return ans;
}
long long find_k(long long k) {
long long bits = 0;
long long n = this->n;
while (n) {
n >>= 1;
bits++;
}
long long mask = 0;
long long cnt = 0;
for (long long i = bits; i >= 0; i--) {
mask += 1 << i;
if (mask > this->n || cnt + bit[mask] >= k)
mask -= (1 << i);
else
cnt += bit[mask];
}
return mask + 1;
}
};
long long n, pos[maxn];
struct TreeNode {
long long zeros, preadd, sufadd;
long long presum, sufsum;
};
TreeNode seg[1111111];
void build_tree(long long node, long long L, long long R) {
seg[node].zeros = R - L + 1;
if (L == R) return;
long long M = L + (R - L) / 2;
build_tree(node << 1, L, M);
build_tree(node << 1 | 1, M + 1, R);
}
void push_down(long long node, long long L, long long R) {
long long lch = node << 1;
long long rch = node << 1 | 1;
if (seg[node].preadd) {
seg[lch].preadd += seg[node].preadd;
seg[rch].preadd += seg[node].preadd;
seg[lch].presum += seg[lch].zeros * 1LL * seg[node].preadd;
seg[rch].presum += seg[rch].zeros * 1LL * seg[node].preadd;
seg[node].preadd = 0;
}
if (seg[node].sufadd) {
seg[lch].sufadd += seg[node].sufadd;
seg[rch].sufadd += seg[node].sufadd;
seg[lch].sufsum += seg[lch].zeros * 1LL * seg[node].sufadd;
seg[rch].sufsum += seg[rch].zeros * 1LL * seg[node].sufadd;
seg[node].sufadd = 0;
}
}
long long qL, qR;
void add(long long node, long long L, long long R, long long type) {
if (qL <= L && R <= qR) {
if (type == 0) {
seg[node].preadd += 1;
seg[node].presum += (long long)seg[node].zeros;
} else {
seg[node].sufadd += 1;
seg[node].sufsum += (long long)seg[node].zeros;
}
return;
}
push_down(node, L, R);
long long M = L + (R - L) / 2;
if (qL <= M) add(node << 1, L, M, type);
if (qR > M) add(node << 1 | 1, M + 1, R, type);
long long lch = node << 1;
long long rch = node << 1 | 1;
seg[node].zeros = seg[lch].zeros + seg[rch].zeros;
seg[node].presum = seg[lch].presum + seg[rch].presum;
seg[node].sufsum = seg[lch].sufsum + seg[rch].sufsum;
}
void erase(long long node, long long L, long long R, long long p) {
if (L == R) {
memset(seg + node, 0, sizeof(TreeNode));
return;
}
long long M = L + (R - L) / 2;
long long lch = node << 1;
long long rch = node << 1 | 1;
push_down(node, L, R);
if (p <= M)
erase(lch, L, M, p);
else
erase(rch, M + 1, R, p);
seg[node].zeros = seg[lch].zeros + seg[rch].zeros;
seg[node].presum = seg[lch].presum + seg[rch].presum;
seg[node].sufsum = seg[lch].sufsum + seg[rch].sufsum;
}
long long query(long long node, long long L, long long R, long long type) {
if (qL <= L && R <= qR) {
if (type == 0)
return seg[node].presum;
else
return seg[node].sufsum;
}
push_down(node, L, R);
long long ans = 0;
long long M = L + (R - L) / 2;
if (qL <= M) ans += query(node << 1, L, M, type);
if (qR > M) ans += query(node << 1 | 1, M + 1, R, type);
return ans;
}
int main() {
scanf("%lld", &n);
BIT bit(n);
for (long long i = 1; i <= n; i++) {
long long a;
scanf("%lld", &a);
pos[a] = i;
}
build_tree(1, 1, n);
long long inversion = 0;
for (long long i = 1; i <= n; i++) {
const long long &p = pos[i];
inversion += i - 1 - bit.query(p);
bit.add(p, 1);
qL = p + 1;
qR = n;
if (qL <= qR) add(1, 1, n, 0);
qL = 1;
qR = p - 1;
if (qL <= qR) add(1, 1, n, 1);
erase(1, 1, n, p);
long long sum = 0;
long long median = bit.find_k((i + 1) / 2);
qL = 1;
qR = median - 1;
if (qL <= qR) {
sum += query(1, 1, n, 0);
}
qL = median + 1;
qR = n;
if (qL <= qR) {
sum += query(1, 1, n, 1);
}
long long ans = inversion + sum;
printf("%lld ", ans);
}
printf("\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 200000 + 10;
long long BIT1[MAXN], BIT2[MAXN];
long long N;
void update(long long p, long long num, long long *BIT) {
for (; p <= N; p += p & -p) {
BIT[p] += num;
}
}
long long query(long long p, long long *BIT) {
long long sum = 0;
for (; p > 0; p -= p & -p) {
sum += BIT[p];
}
return sum;
}
long long arr_num[MAXN], arr_pos[MAXN];
signed main(void) {
cin >> N;
for (long long i = 1; i <= N; i++) {
cin >> arr_num[i];
arr_pos[arr_num[i]] = i;
}
long long ans = 0;
for (long long i = 1; i <= N; i++) {
ans += i - query(arr_pos[i], BIT1) - 1;
update(arr_pos[i], 1, BIT1);
update(arr_pos[i], arr_pos[i], BIT2);
long long lb = 1, ub = N;
while (ub > lb) {
long long mid = (lb + ub + 1) >> 1;
if (query(mid - 1, BIT1) > i / 2) {
ub = mid - 1;
} else {
lb = mid;
}
}
long long upper = query(N, BIT1) - query(ub, BIT1);
long long add1 =
query(N, BIT2) - query(ub, BIT2) - ub * upper - (1 + upper) * upper / 2;
long long lower = query(ub - 1, BIT1);
long long add2 = ub * lower - query(ub - 1, BIT2) - (1 + lower) * lower / 2;
cout << ans + add1 + add2 << " ";
}
cout << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
long long sum1[MAXN], sum2[MAXN], a[MAXN], pos[MAXN];
void add1(long long x, long long y) {
if (!x) return;
for (; x < MAXN; x += x & -x) {
sum1[x] += y;
}
}
long long query1(long long x) {
long long ans = 0;
for (; x; x -= x & -x) {
ans += sum1[x];
}
return ans;
}
void add2(long long x, long long y) {
if (!x) return;
for (; x < MAXN; x += x & -x) {
sum2[x] += y;
}
}
long long query2(long long x) {
long long ans = 0;
for (; x; x -= x & -x) {
ans += sum2[x];
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
while (cin >> n) {
memset(sum1, 0, sizeof(sum1));
memset(sum2, 0, sizeof(sum2));
long long ans = 0;
for (int i = 1; i <= n; i++) cin >> a[i], pos[a[i]] = i;
for (int i = 1; i <= n; i++) {
int p = pos[i];
add1(p, 1);
add2(p, p);
ans += i - query1(p);
long long pp = ans;
long long l = 1, r = n, temp;
while (l <= r) {
int mid = (l + r) >> 1;
if (query1(mid) * 2 > i) {
temp = mid;
r = mid - 1;
} else
l = mid + 1;
}
long long x = query1(temp);
pp += (temp - x + 1 + temp) * x / 2 - query2(temp);
x = i - x;
pp += query2(n) - query2(temp) - ((temp + 1 + temp + x) * x / 2);
cout << pp << " ";
}
cout << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double Pi = acos(-1);
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
double dpow(double a, long long b) {
double ans = 1.0;
while (b) {
if (b % 2) ans = ans * a;
a = a * a;
b /= 2;
}
return ans;
}
long long quick_pow(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) {
ans = ans * x % mod;
}
x = x * x % mod;
y >>= 1;
}
return ans;
}
int n;
int a[maxn], c[maxn];
int lowbit(int x) { return x & (-x); }
long long bit1[maxn], bit2[maxn];
void add(long long *bit, int pos, int val) {
while (pos < maxn) {
bit[pos] += val;
pos += lowbit(pos);
}
}
long long query(long long *bit, int pos) {
long long ans = 0;
while (pos) {
ans += bit[pos];
pos -= lowbit(pos);
}
return ans;
}
int bs(long long *bit, int val) {
int i = 0;
for (int j = 19; j >= 0; j--) {
if ((i | 1 << j) < maxn) {
if (bit[i | 1 << j] <= val) {
val -= bit[i |= 1 << j];
}
}
}
return i;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
c[a[i]] = i;
}
long long cnt = 0;
for (int i = 1; i <= n; i++) {
int p = c[i];
add(bit1, p, 1);
cnt += i - query(bit1, p);
add(bit2, p, p);
int pos = bs(bit1, i / 2) + 1;
long long sum = 0;
long long aa = i / 2, bb = i - i / 2 - 1;
sum += (long long)aa * pos - (long long)aa * (aa + 1) / 2 -
query(bit2, pos - 1);
sum += (query(bit2, maxn) - query(bit2, pos)) - (long long)bb * pos -
(long long)bb * (bb + 1) / 2;
printf("%lld\n", sum + cnt);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int s[200005], sum[200005], ara[200005], p[200005], seg[4 * 200005];
void add(int x, int n) {
while (x <= n) {
sum[x]++;
x += (x & -x);
}
return;
}
int query(int x) {
int ret = 0;
while (x) {
ret += sum[x];
x -= (x & -x);
}
return ret;
}
void update(int n, int s, int e, int indx) {
if (s == indx && e == indx) {
seg[n]++;
return;
}
if (s > indx || e < indx) return;
int mid = (s + e) / 2;
update(n * 2, s, mid, indx);
update(n * 2 + 1, mid + 1, e, indx);
seg[n] = seg[n * 2] + seg[n * 2 + 1];
return;
}
int query(int n, int s, int e, int k) {
if (s == e && k == 1) return s;
int mid = (s + e) / 2;
if (seg[n * 2] < k)
return query(n * 2 + 1, mid + 1, e, k - seg[n * 2]);
else
return query(n * 2, s, mid, k);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &ara[i]), p[ara[i]] = i;
for (int i = 1; i <= n; i++) s[i] = query(n) - query(p[i]), add(p[i], n);
printf("0");
long long res = 0;
memset(sum, 0, sizeof sum);
add(p[1], n);
update(1, 1, n, p[1]);
int mn = p[1], mx = p[1];
for (int i = 2; i <= n; i++) {
res += s[i];
update(1, 1, n, p[i]);
add(p[i], n);
if (p[i] < mn || p[i] > mx)
mn = min(mn, p[i]), mx = max(mx, p[i]);
else {
int x1 = query(p[i] - 1);
int x2 = query(n) - x1 - 1;
res -= min(x1, x2);
}
int l = p[i], r = query(1, 1, n, (i + 1) / 2);
if (!(i & 1) && p[i] <= r) r = query(1, 1, n, (i + 2) / 2);
if (l > r) swap(l, r);
if (l < r) res += (r - l + 1) - (query(r) - query(l - 1));
printf(" %lld", res);
}
puts("");
return 0;
}
| 11 | CPP |
from bisect import bisect_right, bisect_left
# instead of AVLTree
class BITbisect():
def __init__(self, InputProbNumbers):
# 座圧
self.ind_to_co = [-10**18]
self.co_to_ind = {}
for ind, num in enumerate(sorted(list(set(InputProbNumbers)))):
self.ind_to_co.append(num)
self.co_to_ind[num] = ind+1
self.max = len(self.co_to_ind)
self.data = [0]*(self.max+1)
def __str__(self):
retList = []
for i in range(1, self.max+1):
x = self.ind_to_co[i]
if self.count(x):
c = self.count(x)
for _ in range(c):
retList.append(x)
return "[" + ", ".join([str(a) for a in retList]) + "]"
def __getitem__(self, key):
key += 1
s = 0
ind = 0
l = self.max.bit_length()
for i in reversed(range(l)):
if ind + (1<<i) <= self.max:
if s + self.data[ind+(1<<i)] < key:
s += self.data[ind+(1<<i)]
ind += (1<<i)
if ind == self.max or key < 0:
raise IndexError("BIT index out of range")
return self.ind_to_co[ind+1]
def __len__(self):
return self._query_sum(self.max)
def __contains__(self, num):
if not num in self.co_to_ind:
return False
return self.count(num) > 0
# 0からiまでの区間和
# 左に進んでいく
def _query_sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
# i番目の要素にxを足す
# 上に登っていく
def _add(self, i, x):
while i <= self.max:
self.data[i] += x
i += i & -i
# 値xを挿入
def push(self, x):
if not x in self.co_to_ind:
raise KeyError("The pushing number didnt initialized")
self._add(self.co_to_ind[x], 1)
# 値xを削除
def delete(self, x):
if not x in self.co_to_ind:
raise KeyError("The deleting number didnt initialized")
if self.count(x) <= 0:
raise ValueError("The deleting number doesnt exist")
self._add(self.co_to_ind[x], -1)
# 要素xの個数
def count(self, x):
return self._query_sum(self.co_to_ind[x]) - self._query_sum(self.co_to_ind[x]-1)
# 値xを超える最低ind
def bisect_right(self, x):
if x in self.co_to_ind:
i = self.co_to_ind[x]
else:
i = bisect_right(self.ind_to_co, x) - 1
return self._query_sum(i)
# 値xを下回る最低ind
def bisect_left(self, x):
if x in self.co_to_ind:
i = self.co_to_ind[x]
else:
i = bisect_left(self.ind_to_co, x)
if i == 1:
return 0
return self._query_sum(i-1)
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
Ind = [0]*(N+1)
for i, a in enumerate(A):
Ind[a] = i+1
Bit = BITbisect(list(range(N+1)))
ans = [0]
Bit.push(Ind[1])
a = 0
for n in range(2, N+1):
ind = Ind[n]
f = Bit.bisect_left(ind)
#print(Bit)
l = len(Bit)
if l%2 == 0:
if f == l//2:
a += l//2-l//2
elif f < l//2:
p1 = Bit[l//2-1]
a += (p1-ind-1) - (l//2-1) + l-f
else:
p2 = Bit[l//2]
a += (ind-p2-1) - (l//2-1) + l-f
else:
p1 = Bit[l//2]
#print(f, p1, ind, l)
if f <= l//2:
a += (p1-ind-1) - l//2 + l-f
else:
a += (ind-p1-1) - l//2 + l-f
ans.append(a)
Bit.push(ind)
print(*ans, sep=" ") | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int n, sum[maxn], r[maxn];
void add(int i) {
while (i <= n) {
sum[i]++;
i += i & (-i);
}
}
int getsum(int i) {
int ans = 0;
while (i) {
ans += sum[i];
i -= i & (-i);
}
return ans;
}
int bs(int s, int e, int t) {
int mid = (s + e) / 2;
if (s >= e) return mid;
if (getsum(mid) >= t)
return bs(s, mid, t);
else
return bs(mid + 1, e, t);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
r[x] = i;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += i - 1 - getsum(r[i]);
int s, e;
s = bs(1, n, i / 2);
if (i % 2 == 1)
e = bs(1, n, i / 2 + 1);
else
e = s;
if (!(s <= r[i] && r[i] <= e)) {
if (r[i] < s)
ans += s - r[i] - 1 - getsum(s - 1);
else
ans += r[i] - e + getsum(e) - i;
} else
ans -= i / 2;
cout << ans << " ";
add(r[i]);
}
cout << '\n';
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using dd = double;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vdd = vector<dd>;
using vpll = vector<pll>;
using vtll = vector<tll>;
using vvll = vector<vll>;
using vvdd = vector<vdd>;
using vvpll = vector<vpll>;
using vvtll = vector<vtll>;
using vvvll = vector<vvll>;
using vvvdd = vector<vvdd>;
using vvvpll = vector<vvpll>;
using vvvtll = vector<vvtll>;
using vvvvll = vector<vvvll>;
using vvvvdd = vector<vvvdd>;
using vvvvpll = vector<vvvpll>;
using vvvvtll = vector<vvvtll>;
constexpr ll INF = 1LL << 60;
constexpr dd EPS = 1e-11;
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(std::numeric_limits<double>::max_digits10);
}
} fast;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline T MaxE(vector<T> &v, ll S, ll E) {
T m = v[S];
for (ll i = (S); i <= (E); i++) chmax(m, v[i]);
return m;
}
template <class T>
inline T MinE(vector<T> &v, ll S, ll E) {
T m = v[S];
for (ll i = (S); i <= (E); i++) chmin(m, v[i]);
return m;
}
template <class T>
inline T MaxE(vector<T> &v, ll N) {
return MaxE(v, 0, N - 1);
}
template <class T>
inline T MinE(vector<T> &v, ll N) {
return MinE(v, 0, N - 1);
}
template <class T>
inline T MaxE(vector<T> &v) {
return MaxE(v, (ll)v.size());
}
template <class T>
inline T MinE(vector<T> &v) {
return MinE(v, (ll)v.size());
}
template <class T>
inline ll MaxI(vector<T> &v, ll S, ll E) {
ll m = S;
for (ll i = (S); i <= (E); i++) {
if (v[i] > v[m]) m = i;
}
return m;
}
template <class T>
inline ll MinI(vector<T> &v, ll S, ll E) {
ll m = S;
for (ll i = (S); i <= (E); i++) {
if (v[i] < v[m]) m = i;
}
return m;
}
template <class T>
inline ll MaxI(vector<T> &v, ll N) {
return MaxI(v, 0, N - 1);
}
template <class T>
inline ll MinI(vector<T> &v, ll N) {
return MinI(v, 0, N - 1);
}
template <class T>
inline ll MaxI(vector<T> &v) {
return MaxI(v, (ll)v.size());
}
template <class T>
inline ll MinI(vector<T> &v) {
return MinI(v, (ll)v.size());
}
template <class T>
inline T Sum(vector<T> &v, ll S, ll E) {
T s = v[S];
for (ll i = (S + 1); i <= (E); i++) s += v[i];
return s;
}
template <class T>
inline T Sum(vector<T> &v, ll N) {
return Sum(v, 0, N - 1);
}
template <class T>
inline T Sum(vector<T> &v) {
return Sum(v, v.size());
}
template <class T>
inline ll Size(T &v) {
return (ll)v.size();
}
template <class T>
inline T POW(T a, ll n) {
T r = 1;
for (; n > 0; n >>= 1, a *= a) {
if (n & 1) r *= a;
}
return r;
}
inline ll POW(int a, ll n) { return POW((ll)a, n); }
inline ll MSB(ll a) {
for (ll o = 63, x = -1;;) {
ll m = (o + x) / 2;
if (a < (1LL << m))
o = m;
else
x = m;
if (o - x == 1) return x;
}
}
inline ll CEIL(ll a, ll b) { return (a + b - 1) / b; }
ll Gcd(ll a, ll b) { return (b == 0) ? a : Gcd(b, a % b); }
ll Lcm(ll a, ll b) { return a * b / Gcd(a, b); }
inline vll Bit2Idx(ll m) {
vll v;
for (ll i = 0; m; m >>= 1, i++)
if (m & 1) v.push_back(i);
return move(v);
}
inline ll BitNum(ll m) {
for (ll c = 0;; m >>= 1) {
c += m & 1;
if (!m) return c;
}
}
inline ll Bit(ll s, ll i) { return (s >> i) & 1; }
inline ll BitOn(ll s, ll i) { return s | (1LL << i); }
inline ll BitOff(ll s, ll i) { return s & ~(1LL << i); }
template <class T>
inline ll UnderNumOf(vector<T> &v, T x) {
return upper_bound(v.begin(), v.end(), x) - v.begin();
}
template <class T, class Pr>
inline ll UnderNumOf(vector<T> &v, T x, Pr pred) {
return upper_bound(v.begin(), v.end(), x, pred) - v.begin();
}
template <class T>
inline ll OverNumOf(vector<T> &v, T x) {
return (ll)v.size() - (lower_bound(v.begin(), v.end(), x) - v.begin());
}
template <class T, class Pr>
inline ll OverNumOf(vector<T> &v, T x, Pr pred) {
return (ll)v.size() - (lower_bound(v.begin(), v.end(), x, pred) - v.begin());
}
template <class T = ll>
inline vector<T> cinv(ll N) {
vector<T> v(N);
for (ll i = (0); i <= ((N)-1); i++) cin >> v[i];
return move(v);
}
template <class T = ll, class S = ll>
inline vector<pair<T, S>> cinv2(ll N) {
vector<pair<T, S>> v(N);
for (ll i = (0); i <= ((N)-1); i++) {
cin >> v[i].first >> v[i].second;
}
return move(v);
}
template <class T = ll, class S = ll, class R = ll>
inline vector<tuple<T, S, R>> cinv3(ll N) {
vector<tuple<T, S, R>> v(N);
for (ll i = (0); i <= ((N)-1); i++) {
cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]);
}
return move(v);
}
template <class T = ll, class S = ll, class R = ll, class Q = ll>
inline vector<tuple<T, S, R, Q>> cinv4(ll N) {
vector<tuple<T, S, R, Q>> v(N);
for (ll i = (0); i <= ((N)-1); i++) {
cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]) >> get<3>(v[i]);
}
return move(v);
}
template <class T = ll>
inline vector<vector<T>> cinvv(ll N, ll M) {
vector<vector<T>> vv(N);
for (ll i = (0); i <= ((N)-1); i++) vv[i] = cinv(M);
return move(vv);
}
template <class T>
inline void coutv(vector<T> &v, char deli = ' ') {
ll N = (ll)v.size();
for (ll i = (0); i <= ((N)-1); i++) {
cout << v[i] << ((i == N - 1) ? '\n' : deli);
}
}
template <class T>
void bye(T a) {
cout << a << '\n';
exit(0);
}
template <class T>
void Dump(vector<T> &v) {}
template <class T>
void Dump(vector<vector<T>> &v) {}
template <class T>
void Dump(vector<vector<vector<T>>> &v) {}
template <class T>
void Dump(vector<vector<vector<vector<T>>>> &v) {}
template <class T>
void Dump(vector<vector<vector<vector<vector<T>>>>> &v) {}
template <ll MOD>
struct mll_ {
ll val;
mll_(ll v = 0) : val(v % MOD) {
if (val < 0) val += MOD;
}
mll_ operator-() const { return -val; }
mll_ operator+(const mll_ &b) const { return val + b.val; }
mll_ operator-(const mll_ &b) const { return val - b.val; }
mll_ operator*(const mll_ &b) const { return val * b.val; }
mll_ operator/(const mll_ &b) const { return mll_(*this) /= b; }
mll_ operator+(ll b) const { return *this + mll_(b); }
mll_ operator-(ll b) const { return *this - mll_(b); }
mll_ operator*(ll b) const { return *this * mll_(b); }
friend mll_ operator+(ll a, const mll_ &b) { return b + a; }
friend mll_ operator-(ll a, const mll_ &b) { return -b + a; }
friend mll_ operator*(ll a, const mll_ &b) { return b * a; }
friend mll_ operator/(ll a, const mll_ &b) { return mll_(a) / b; }
mll_ &operator+=(const mll_ &b) {
val = (val + b.val) % MOD;
return *this;
}
mll_ &operator-=(const mll_ &b) {
val = (val + MOD - b.val) % MOD;
return *this;
}
mll_ &operator*=(const mll_ &b) {
val = (val * b.val) % MOD;
return *this;
}
mll_ &operator/=(const mll_ &b) {
ll c = b.val, d = MOD, u = 1, v = 0;
while (d) {
ll t = c / d;
c -= t * d;
swap(c, d);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0) val += MOD;
return *this;
}
mll_ &operator+=(ll b) { return *this += mll_(b); }
mll_ &operator-=(ll b) { return *this -= mll_(b); }
mll_ &operator*=(ll b) { return *this *= mll_(b); }
mll_ &operator/=(ll b) { return *this /= mll_(b); }
bool operator==(const mll_ &b) { return val == b.val; }
bool operator!=(const mll_ &b) { return val != b.val; }
bool operator==(ll b) { return *this == mll_(b); }
bool operator!=(ll b) { return *this != mll_(b); }
friend bool operator==(ll a, const mll_ &b) { return mll_(a) == b.val; }
friend bool operator!=(ll a, const mll_ &b) { return mll_(a) != b.val; }
friend ostream &operator<<(ostream &os, const mll_ &a) { return os << a.val; }
friend istream &operator>>(istream &is, mll_ &a) { return is >> a.val; }
static mll_ Combination(ll a, ll b) {
chmin(b, a - b);
if (b < 0) return mll_(0);
mll_ c = 1;
for (ll i = (0); i <= ((b)-1); i++) c *= a - i;
for (ll i = (0); i <= ((b)-1); i++) c /= i + 1;
return c;
}
};
using mll = mll_<1000000007LL>;
using vmll = std::vector<mll>;
using vvmll = std::vector<vmll>;
using vvvmll = std::vector<vvmll>;
using vvvvmll = std::vector<vvvmll>;
using vvvvvmll = std::vector<vvvvmll>;
template <class T>
struct SegmentTree {
using F = function<T(T, T)>;
vector<T> dat;
ll n;
F f;
T ti;
SegmentTree() {}
SegmentTree(vector<T> &v, F f, T ti) { Init(v, f, ti); }
void Init(vector<T> &v, F f, T ti) {
this->f = f;
this->ti = ti;
for (n = 1; n < (ll)v.size(); n *= 2)
;
dat.resize(2 * n - 1, ti);
for (ll i = (0); i <= (((ll)v.size()) - 1); i++) {
dat[i + n - 1] = v[i];
}
for (ll i = ((n - 1) - 1); i >= (0); i--) {
dat[i] = f(dat[2 * i + 1], dat[2 * i + 2]);
}
}
void Set(ll i, T x) {
i += n - 1;
dat[i] = x;
while (i > 0) {
i = (i - 1) / 2;
dat[i] = f(dat[2 * i + 1], dat[2 * i + 2]);
}
}
T Range(ll a, ll b) { return range(a, b, 0, 0, n); }
T operator[](ll i) { return dat[i + n - 1]; }
void Dump(ll w = 5) {
for (ll i = (0); i <= ((n)-1); i++)
for (ll k = i + n - 1, m = 1, p = 1; k >= 0;
p = m, m *= k % 2, k = (k == 0) ? -1 : (k - 1) / 2) {
if (m)
cerr << ((k < n - 1) ? " ┬ " : "") << setw(w) << dat[k];
else
cerr << ((p & ~m) ? " ┘ " : "");
if (k == 0) cerr << '\n';
}
cerr << '\n';
}
T range(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l) return ti;
if (a <= l && r <= b) return dat[k];
return f(range(a, b, k * 2 + 1, l, (l + r) / 2),
range(a, b, k * 2 + 2, (l + r) / 2, r));
}
};
void solve() {
ll n;
cin >> n;
vector<ll> P = cinv<ll>(n);
vll loc(n + 1);
for (ll i = (0); i <= (n - 1); i++) {
loc[P[i]] = i;
}
vll ans;
ans.push_back(0);
set<ll> buf;
buf.insert(loc[1]);
ll x = 0;
ll y = 0;
auto it = buf.begin();
vll ini(n, 0);
ini[loc[1]] = 1;
SegmentTree<ll> sgt(
ini, [](ll x, ll y) { return x + y; }, 0);
ll T = 0;
ll S = 0;
for (ll k = (1); k <= (n - 1); k++) {
ll p = loc[k + 1];
if (k % 2 == 0) {
auto iit = it;
iit++;
if (p < *it) {
ll inter = *it - p - 1;
inter -= sgt.Range(p + 1, (*it));
T += inter;
T -= sgt.Range(0, p);
} else if (*iit < p) {
ll inter = p - *iit - 1;
inter -= sgt.Range((*iit) + 1, p);
T += inter;
T -= sgt.Range(p + 1, n);
} else {
T -= sgt.Range(p + 1, n);
}
} else {
if (p < *it) {
ll inter = *it - p - 1;
inter -= sgt.Range(p + 1, (*it));
T += inter;
T -= sgt.Range(0, p);
} else {
ll inter = p - *it - 1;
inter -= sgt.Range((*it) + 1, p);
T += inter;
T -= sgt.Range(p + 1, n);
}
}
S += sgt.Range(p + 1, n);
ans.push_back(T + S);
if (p < *it)
x++;
else
y++;
buf.insert(p);
if (x - 1 == y) {
it--;
x--;
y++;
} else if (x + 2 == y) {
it++;
x++;
y--;
}
sgt.Set(p, 1);
}
coutv(ans);
}
int main() {
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 5, MXX = 23;
const long long mod = 1e9 + 7, inf = 1e18 + 6;
int n, a[MX], ind[MX], ver[MX];
void add(int l) {
for (int i = l + 1; i < MX; i += i & -i) ver[i]++;
}
int ask(int pn) {
int ans = 0;
for (pn++; pn; pn -= pn & -pn) ans += ver[pn];
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(9);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) ind[a[i]] = i;
set<int> nw;
long long ans = 0;
int md = ind[1];
for (int i = 1; i < n + 1; ++i) {
nw.insert(ind[i]);
auto v = nw.find(ind[i]);
add(ind[i]);
int ver = ask(ind[i]);
if (i & 1) {
if (ind[i] > md) md = *next(nw.find(md), 1);
} else {
if (ind[i] < md) md = *prev(nw.find(md), 1);
}
if (md != ind[i]) {
int ls = ((i % 2 == 0) && md > ind[i] ? *next(nw.find(md), 1) : md);
int dis = ls - ind[i];
dis = max(dis, -dis);
dis--;
int fr = ((i % 2 == 0) && md > ind[i] ? (i / 2) : ((i - 1) / 2));
fr++;
int bs = ver - fr;
bs = max(bs, -bs);
bs--;
ans += (long long)(dis - bs);
}
if (md == ind[i] && (i % 2 == 0)) {
ans += *next(nw.find(md), 1) - md - 1;
}
ans -= (min(i - ver, ver - 1));
ans += i - ver;
cout << ans << ' ';
}
cout << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
int size = 256 * 1024;
int Count(std::vector<int>& tree, int l, int r) {
l += size;
r += size;
int ans = 0;
while (l <= r) {
if (l % 2) {
ans += tree[l];
++l;
}
if (r % 2 == 0) {
ans += tree[r];
--r;
}
if (l > r) break;
r >>= 1;
l >>= 1;
}
return ans;
}
void Add(std::vector<int>& tree, int ind) {
ind += size;
while (ind) {
++tree[ind];
ind >>= 1;
}
}
int main() {
int64_t own = 0;
int n;
std::cin >> n;
std::vector<int> array(n);
std::vector<int> where(n);
std::vector<int> add(n);
for (int i = 0; i < n; ++i) {
std::cin >> array[i];
--array[i];
where[array[i]] = i;
}
{
std::vector<int> tree(size * 2, 0);
for (int i = 0; i < n; ++i) {
add[i] = Count(tree, where[i], n - 1);
Add(tree, where[i]);
}
}
std::cout << 0 << ' ';
std::set<int> pos;
pos.insert(where[0]);
int median = where[0];
int64_t dist = 0;
std::vector<int> tree(size * 2, 0);
Add(tree, where[0]);
for (int i = 1; i < n; ++i) {
own += add[i];
if (where[i] >= median) {
dist -= Count(tree, where[i], n - 1);
} else {
dist -= Count(tree, 0, where[i]);
}
pos.insert(where[i]);
if (where[i] > median && (i % 2 == 0)) {
median = *pos.upper_bound(median);
} else if (where[i] < median && (i % 2 == 1)) {
int n_median = *(--pos.lower_bound(median));
dist += (median - n_median - 1);
median = n_median;
}
if (where[i] > median) {
dist += (where[i] - median - Count(tree, median, where[i] - 1));
} else {
dist += (median - where[i] - Count(tree, where[i] + 1, median));
}
std::cout << own + dist << ' ';
Add(tree, where[i]);
}
return 0;
}
| 11 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.