solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const int INF = 1e9 + 7;
struct node {
int l, r;
node(int _l = 0, int _r = 0) : l(_l), r(_r){};
void operator+=(node x) {
l = min(l + x.l, INF);
r = min(r + x.r, INF);
}
int get() { return min(l, r); }
} val[N];
int root[N], rev[N];
pair<int, int> getRoot(int u) {
if (u == root[u]) {
return make_pair(u, 0);
} else {
pair<int, int> tmp = getRoot(root[u]);
root[u] = tmp.first;
rev[u] ^= tmp.second;
return make_pair(root[u], rev[u]);
}
}
int n, k;
vector<int> adj[N];
string s;
int main() {
cin >> n >> k;
cin >> s;
for (int i = 1; i <= k; i++) {
val[i] = node(1, 0);
root[i] = i;
rev[i] = 0;
int c;
cin >> c;
while (c--) {
int x;
cin >> x;
adj[x].push_back(i);
}
}
int curAns = 0;
for (int i = 1; i <= n; i++) {
int t = (s[i - 1] - '0') ^ 1;
if (adj[i].size() == 1) {
pair<int, int> u = getRoot(adj[i][0]);
curAns -= val[u.first].get();
val[u.first] += node((u.second == t) * INF, (u.second != t) * INF);
curAns += val[u.first].get();
}
if (adj[i].size() == 2) {
pair<int, int> u = getRoot(adj[i][0]);
pair<int, int> v = getRoot(adj[i][1]);
if (u.first != v.first) {
curAns -= val[u.first].get();
curAns -= val[v.first].get();
if (u.first > v.first) swap(u, v);
if (u.second ^ v.second ^ t) {
rev[v.first] = 1;
swap(val[v.first].l, val[v.first].r);
}
root[v.first] = u.first;
val[u.first] += val[v.first];
curAns += val[u.first].get();
}
}
cout << curAns << endl;
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] ? fa[u] = find(fa[u]) : u; }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0], kk + kk + 1);
ans += mix(k[i][0]);
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1] + kk), uni(k[i][0] + kk, k[i][1]);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0] + kk, kk + kk + 1);
ans += mix(k[i][0]);
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
template <class V>
int get_p(V& p, int j) {
if (p[j] == j) return j;
if (p[j] < 0) return p[j] = -get_p(p, -p[j]);
return p[j] = get_p(p, p[j]);
}
int get_min(bool a_j, int S_j, bool coa_j, int coS_j) {
if (!coa_j) return S_j;
if (!a_j) return coS_j;
return std::min(S_j, coS_j);
}
void proc() {
int n, k;
std::cin >> n >> k;
std::vector<bool> x(n);
for (int i = 0; i < n; i++) {
char c;
std::cin >> c;
x[i] = c % 2;
}
std::vector<std::vector<int> > J(n);
std::vector<int> p(k + 1);
for (int j = 1; j <= k; j++) {
p[j] = j;
int c;
std::cin >> c;
while (c--) {
int i;
std::cin >> i;
J[i - 1].push_back(j);
}
}
std::vector<int> S(k + 1, 1);
std::vector<int> coS(k + 1, 0);
std::vector<bool> a(k + 1, true);
std::vector<bool> coa(k + 1, true);
int R = 0;
for (int i = 0; i < n; i++) {
if (J[i].size() == 0) {
std::cout << R << std::endl;
continue;
}
int j = J[i][0];
int p_j = get_p(p, j);
int abs_p_j = std::abs(p_j);
bool a_j = a[abs_p_j];
bool coa_j = coa[abs_p_j];
int S_j = S[abs_p_j];
int coS_j = coS[abs_p_j];
if (J[i].size() == 1) {
a[abs_p_j] = a_j & (x[i] ^ (p_j > 0));
coa[abs_p_j] = coa_j & (x[i] ^ (p_j < 0));
int m_0 = get_min(a_j, S_j, coa_j, coS_j);
int m_1 = get_min(a[abs_p_j], S_j, coa[abs_p_j], coS_j);
R += m_1 - m_0;
std::cout << R << std::endl;
continue;
}
int l = J[i][1];
int p_l = get_p(p, l);
int abs_p_l = std::abs(p_l);
bool a_l = a[abs_p_l];
bool coa_l = coa[abs_p_l];
int S_l = S[abs_p_l];
int coS_l = coS[abs_p_l];
if (abs_p_j < abs_p_l) {
std::swap(p_j, p_l);
std::swap(abs_p_j, abs_p_l);
std::swap(a_j, a_l);
std::swap(coa_j, coa_l);
std::swap(S_j, S_l);
std::swap(coS_j, coS_l);
}
a[abs_p_j] = a_j & coa_l ^
(a_j & coa_l ^ a_j & a_l) & (x[i] ^ (p_j > 0) ^ (p_l > 0));
coa[abs_p_j] = coa_j & a_l ^ (coa_j & a_l ^ coa_j & coa_l) &
(x[i] ^ (p_j > 0) ^ (p_l > 0));
int m_0 = get_min(a_j, S_j, coa_j, coS_j);
if (abs_p_j != abs_p_l) {
m_0 += get_min(a_l, S_l, coa_l, coS_l);
bool t = x[i] ^ (p_j > 0) ^ (p_l > 0);
p[abs_p_l] = t ? abs_p_j : -abs_p_j;
S[abs_p_j] += t ? S_l : coS_l;
coS[abs_p_j] += t ? coS_l : S_l;
}
int m_1 = get_min(a[abs_p_j], S[abs_p_j], coa[abs_p_j], coS[abs_p_j]);
R += m_1 - m_0;
std::cout << R << std::endl;
}
}
int main() {
std::cin.tie(0);
std::cin.sync_with_stdio(false);
int t = 1;
while (t--) proc();
return 0;
}
| 11 | CPP |
import bisect
def getsum(tree , i):
s = 0
i += 1
while i>0:
s += tree[i]
i -= i & (-i)
return s
def updatebit(tree , n , i , v):
i+= 1
while i <= n:
tree[i] += v
i += i & (-i)
n = int(input())
x = list(map(int , input().split()))
v = list(map(int , input().split()))
p = [[x[i] , v[i]] for i in range(len(x))]
vs = sorted(list(set(v)))
p = sorted(p , key = lambda i : i[0])
l = len(vs)
cnt = [0]*(l+1)
xs = [0]*(l+1)
ans = 0
for pnt in p:
pos = bisect.bisect_left(vs , pnt[1])
ans += getsum(cnt , pos) * pnt[0] - getsum(xs , pos)
updatebit(cnt , l , pos , 1)
updatebit(xs , l , pos , pnt[0])
print(ans)
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct FenwickTree {
int n;
vector<long long> num;
FenwickTree() : n(0) {}
FenwickTree(int _n) {
n = _n;
num.assign(n, 0);
}
void add(int i, int val) {
for (; i < n; i |= i + 1) num[i] += val;
}
long long sum(int i) {
long long ret = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) ret += num[i];
return ret;
}
};
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int>> point(n);
vector<int> speed;
for (int i = 0; i < n; i++) scanf("%d", &point[i].first);
for (int i = 0; i < n; i++) {
scanf("%d", &point[i].second);
speed.push_back(point[i].second);
}
sort(speed.begin(), speed.end());
speed.erase(unique(speed.begin(), speed.end()), speed.end());
sort(point.begin(), point.end());
long long ans = 0;
FenwickTree cnt(n), sumx(n);
for (auto i : point) {
i.second =
lower_bound(speed.begin(), speed.end(), i.second) - speed.begin();
ans += cnt.sum(i.second) * i.first - sumx.sum(i.second);
cnt.add(i.second, 1);
sumx.add(i.second, i.first);
}
printf("%lld\n", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
int v[n];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) cin >> v[i];
map<int, int> mp;
vector<pair<int, int> > vi;
vector<pair<int, int> > vf;
for (int i = 0; i < n; i++) {
vi.push_back({arr[i], v[i]});
vf.push_back({v[i], arr[i]});
}
sort(vi.begin(), vi.end());
sort(vf.begin(), vf.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
int val = vi[i].first;
mp[val] = i;
ans += (2 * i - n + 1) * ((long long)val);
}
for (int i = 0; i < n; i++) {
int val = vf[i].second;
if (mp[val] == i) continue;
ans += (i - mp[val]) * (long long)val;
}
cout << ans << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, T;
pair<int, int> a[200010];
long long getval(vector<long long> &f, int pos) {
pos++;
long long ans = 0;
for (int i = pos; i > 0; i -= (i & -i)) ans += f[i];
return ans;
}
void upd(vector<long long> &f, int pos, int val) {
pos++;
for (int i = pos; i < int(f.size()); i += (i & -i)) f[i] += val;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].first;
for (int i = 0; i < n; i++) cin >> a[i].second;
sort(a, a + n);
vector<int> compress_v;
for (int i = 0; i < n; i++) compress_v.push_back(a[i].second);
sort(compress_v.begin(), compress_v.end());
compress_v.resize(unique(compress_v.begin(), compress_v.end()) -
compress_v.begin());
vector<long long> cnt(compress_v.size() + 1), sum(compress_v.size() + 1);
long long ans = 0;
for (int i = 0; i < n; i++) {
int pos = lower_bound(compress_v.begin(), compress_v.end(), a[i].second) -
compress_v.begin();
ans += getval(cnt, pos) * 1ll * a[i].first - getval(sum, pos);
upd(cnt, pos, 1);
upd(sum, pos, a[i].first);
}
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
class st {
int size;
vector<int> c;
vector<long long> a;
public:
st(int n) {
size = 1;
while (size < n) size *= 2;
c.assign(2 * size, 0);
a.assign(2 * size, 0);
}
void set(int i, long long v, int x, int lx, int rx) {
if (lx + 1 == rx) {
if (v == 0) {
c[x] = 0;
a[x] = 0;
} else {
c[x] = 1;
a[x] = v;
}
return;
}
int m = (lx + rx) / 2;
if (i < m)
set(i, v, 2 * x + 1, lx, m);
else
set(i, v, 2 * x + 2, m, rx);
c[x] = c[2 * x + 1] + c[2 * x + 2];
a[x] = a[2 * x + 1] + a[2 * x + 2];
}
void set(int i, long long v) { set(i, v, 0, 0, size); }
long long g1(int l, int r, int x, int lx, int rx) {
if (l >= rx || r <= lx) return 0;
if (l <= lx && r >= rx) return a[x];
int m = (lx + rx) / 2;
long long s1 = g1(l, r, 2 * x + 1, lx, m);
long long s2 = g1(l, r, 2 * x + 2, m, rx);
return s1 + s2;
}
long long g1(int l, int r) { return g1(l, r, 0, 0, size); }
long long g2(int l, int r, int x, int lx, int rx) {
if (l >= rx || r <= lx) return 0;
if (l <= lx && r >= rx) return c[x];
int m = (lx + rx) / 2;
long long s1 = g2(l, r, 2 * x + 1, lx, m);
long long s2 = g2(l, r, 2 * x + 2, m, rx);
return s1 + s2;
}
long long g2(int l, int r) { return g2(l, r, 0, 0, size); }
};
void solve() {
int n;
cin >> n;
vector<pair<long long, long long>> pts(n);
vector<pair<long long, long long>> pts2(n);
vector<long long> p2v(n);
for (int i = 0; i < n; i++) cin >> pts[i].first;
for (int i = 0; i < n; i++) cin >> pts[i].second;
for (int i = 0; i < n; i++) {
pts2[i].first = pts[i].second;
pts2[i].second = pts[i].first;
}
sort(pts.begin(), pts.end());
sort(pts2.begin(), pts2.end());
for (int i = 0; i < n; i++) p2v[i] = pts2[i].first;
st s(n);
for (int i = 0; i < n; i++) {
s.set(i, pts2[i].second);
}
long long total = 0;
for (int i = 0; i < n; i++) {
int ind = lower_bound(pts2.begin(), pts2.end(),
make_pair(pts[i].second, pts[i].first)) -
pts2.begin();
int ind2 = lower_bound(p2v.begin(), p2v.end(), pts[i].second) - p2v.begin();
s.set(ind, 0);
total += (s.g1(ind2, n) - s.g2(ind2, n) * pts[i].first);
}
cout << total << "\n";
}
int main() {
auto start = high_resolution_clock::now();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
long long t = 1;
for (long long i = 0; i < t; i++) {
solve();
}
auto stop = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(stop - start);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long MOD = 1e+9 + 7;
const long long INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const long long MAXN = 2e+5 + 8;
vector<long long> adj[MAXN];
long long visit[MAXN] = {};
int dx8[] = {0, 1, 1, 1, 0, -1, -1, -1}, dy8[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dx4[] = {0, 1, 0, -1}, dy4[] = {1, 0, -1, 0};
int t = 1;
long long n;
pair<long long, long long> seg[4 * MAXN + 8];
vector<pair<long long, long long> > arr;
vector<long long> v;
void build(long long n, long long st, long long en) {
if (st == en) {
seg[n] = arr[st];
return;
}
long long mid = (st + en) / 2;
build(2 * n, st, mid);
build(2 * n + 1, mid + 1, en);
seg[n].first = seg[2 * n].first + seg[2 * n + 1].first;
seg[n].second = seg[2 * n].second + seg[2 * n + 1].second;
}
void update(long long n, long long st, long long en, long long pos,
long long val1, long long val2) {
if (st == en) {
seg[n].first += val1;
seg[n].second += val2;
return;
}
long long mid = (st + en) / 2;
if (pos <= mid)
update(2 * n, st, mid, pos, val1, val2);
else
update(2 * n + 1, mid + 1, en, pos, val1, val2);
seg[n].first = seg[2 * n].first + seg[2 * n + 1].first;
seg[n].second = seg[2 * n].second + seg[2 * n + 1].second;
}
pair<long long, long long> query(long long n, long long st, long long en,
long long l, long long r) {
if (l <= st && en <= r) return seg[n];
if (st > r || en < l) return {0, 0};
long long mid = (st + en) / 2;
pair<long long, long long> lq = query(2 * n, st, mid, l, r);
pair<long long, long long> rq = query(2 * n + 1, mid + 1, en, l, r);
pair<long long, long long> res;
res.first = lq.first + rq.first;
res.second = lq.second + rq.second;
return res;
}
long long ans = 0;
void MAIN() {
cin >> n;
arr = vector<pair<long long, long long> >(n + 1, {0, 0});
v = vector<long long>(n + 1, 0);
for (long long i = (1); i <= n; i++) cin >> arr[i].first;
for (long long i = (1); i <= n; i++) cin >> arr[i].second;
for (long long i = (1); i <= n; i++) v[i] = arr[i].second;
sort(1 + (arr).begin(), (arr).end());
sort(1 + (v).begin(), (v).end());
for (auto [x, sp] : arr) {
if (x == 0) continue;
long long pos = lower_bound(1 + (v).begin(), (v).end(), sp) - v.begin();
ans += (query(1, 1, n, 1, pos).first * x) - (query(1, 1, n, 1, pos).second);
update(1, 1, n, pos, 1, x);
}
cout << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout << setprecision(10);
;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
;
while (t--) {
MAIN();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mxn = 1e6 + 7;
const long long mod = 1e9 + 7;
const long long inf = 1e18 + 7;
int dx[] = {+1, -1, 0, 0};
int dy[] = {0, 0, -1, +1};
pair<int, int> p[mxn];
map<long long, long long> f, s;
int n;
int a[mxn], ls[mxn];
long long ans;
void upd1(int x, int val) {
while (x <= (int)1e8) {
f[x] += val;
x = (x | (x + 1));
}
}
void upd2(int x) {
while (x <= (int)1e8) {
s[x]++;
x = (x | (x + 1));
}
}
long long sum1(int x) {
long long res = 0;
while (x > 0) {
res += f[x];
x = (x & (x + 1)) - 1;
}
return res;
}
int sum2(int x) {
int res = 0;
while (x > 0) {
res += s[x];
x = (x & (x + 1)) - 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> p[i].second;
ls[i] = p[i].second;
}
sort(p + 1, p + n + 1);
sort(ls + 1, ls + n + 1);
for (int i = 1; i <= n; i++) {
p[i].second = lower_bound(ls + 1, ls + n + 1, p[i].second) - ls;
}
for (int i = 1; i <= n; i++) {
ans += (1LL * p[i].first * sum2(p[i].second)) - sum1(p[i].second);
upd1(p[i].second, p[i].first);
upd2(p[i].second);
}
cout << ans;
return 0;
}
| 12 | CPP |
import io
import os
from collections import Counter, defaultdict, deque, namedtuple
# From: https://github.com/cheran-senthil/PyRival/blob/master/pyrival/data_structures/SegmentTree.py
class SegmentTree:
def __init__(self, data, default=0, func=max):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size : _size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
"""func of data[start, stop)"""
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
def solve(N, X, V):
# Sort by x coordinate first
indices = sorted(range(N), key=lambda i: X[i])
X = [X[i] for i in indices]
V = [V[i] for i in indices]
# Calculate where each index should be mapped to if sorted by velocity instead
BIL = 10 ** 9
vIndices = sorted(range(N), key=lambda i: V[i] * BIL + X[i])
indicesByV = {
originalIndex: sortedIndex for sortedIndex, originalIndex in enumerate(vIndices)
}
# Create a segment tree with placeholders for where the velocities should be set
segTreeTotal = SegmentTree([0 for i in range(N)], 0, lambda a, b: a + b)
segTreeCount = SegmentTree([0 for i in range(N)], 0, lambda a, b: a + b)
ans = 0
for j in range(N):
# Calculate sum X[j]-X[i] such that V[i] <= V[j], i < j
index = indicesByV[j]
count = segTreeCount.query(0, index)
totalXi = segTreeTotal.query(0, index)
# print(j, X[j], count, totalXi)
ans += X[j] * count - totalXi
segTreeCount[index] = 1
segTreeTotal[index] = X[j]
return ans
def solveBrute(N, X, V):
# Sort by x coordinate first (x is distinct)
indices = sorted(range(N), key=lambda i: X[i])
X = [X[i] for i in indices]
V = [V[i] for i in indices]
ans = 0
for j in range(N):
xj = X[j]
vj = V[j]
total = 0
totalXi = 0
count = 0
for i in range(j):
xi = X[i]
vi = V[i]
assert xi <= xj
if vi <= vj:
total += xj - xi
totalXi += xi
count += 1
print(j, X[j], count, totalXi)
assert total == X[j] * count - totalXi
ans += total
return ans
if False:
import random
random.seed(0)
N = 200000
for i in range(1):
X = [random.randint(0, 10) for i in range(N)]
V = [random.randint(0, 10) for i in range(N)]
ans = solve(N, X, V)
# assert solveBrute(N, X, V) == ans
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
(N,) = [int(x) for x in input().split()]
X = [int(x) for x in input().split()]
V = [int(x) for x in input().split()]
ans = solve(N, X, V)
print(ans)
| 12 | PYTHON3 |
import sys,math,itertools
from collections import Counter,deque,defaultdict
from bisect import bisect_left,bisect_right
from heapq import heappop,heappush,heapify, nlargest
from copy import deepcopy
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_1(): return list(map(lambda x:int(x)-1, sys.stdin.readline().split()))
def inps(): return sys.stdin.readline()
def inpsl(x): tmp = sys.stdin.readline(); return list(tmp[:x])
def err(x): print(x); exit()
class BIT:
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
self.el = [0]*(n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
# 1_indexed
# n = 6
# a = [1,2,3,4,5,6]
# bit = BIT(n)
# for i,e in enumerate(a):
# bit.add(i+1,e)
# print(bit.get(2,5)) #12 (3+4+5)
n = inp()
X = inpl()
V = inpl()
d = {}; dd={}
for i,x in enumerate(sorted(X)):
d[x] = i; dd[i]=x
for i,x in enumerate(X):
X[i] = d[x]
xv = [(x,v) for x,v in zip(X,V)]
xv.sort(key=lambda x:x[0] ,reverse=True)
xv.sort(key=lambda x:x[1], reverse=True)
cnt_bit = BIT(n+10)
sum_bit = BIT(n+10)
res = 0
for x,_ in xv:
res += sum_bit.get(x,n+5) - cnt_bit.get(x,n+5)*dd[x]
sum_bit.add(x+1,dd[x])
cnt_bit.add(x+1,1)
print(res)
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
bool prime[10000001];
long long P = 1000000007 - 2;
long long factorial[10000001] = {0};
long long powerFunction(long long x, long long y) {
long long res = 1;
long long p = 1000000007;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void sieveFunction(long long maxLimit) {
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (long long i = 2; maxLimit >= i; i++) {
if (prime[i]) {
for (long long j = 2 * i; maxLimit >= j; j += i) prime[j] = false;
}
}
}
void factorialFunction(long long maxLimit) {
factorial[0] = 1;
for (long long i = 1; i <= maxLimit; i++)
factorial[i] = (factorial[i - 1] * i) % 1000000007;
return;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<pair<long long, long long>> tree[800001];
vector<long long> treesum[800001];
vector<pair<long long, long long>> v;
void build(long long node, long long start, long long end) {
if (start == end) {
vector<pair<long long, long long>> temp;
temp.push_back({v[start].second, v[start].first});
tree[node] = temp;
vector<long long> sum;
long long s = 0;
for (long long i = 0; tree[node].size() > i; i++) {
s += tree[node][i].second;
treesum[node].push_back(s);
}
return;
}
long long mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
long long i = 0, j = 0;
while (i < tree[2 * node].size() && j < tree[2 * node + 1].size()) {
if (tree[2 * node][i] <= tree[2 * node + 1][j]) {
tree[node].push_back(tree[2 * node][i]);
i++;
} else {
tree[node].push_back(tree[2 * node + 1][j]);
j++;
}
}
for (long long k = i; k < tree[2 * node].size(); k++)
tree[node].push_back(tree[2 * node][k]);
for (long long k = j; k < tree[2 * node + 1].size(); k++)
tree[node].push_back(tree[2 * node + 1][k]);
long long s = 0;
for (long long k = 0; tree[node].size() > k; k++) {
s += tree[node][k].second;
treesum[node].push_back(s);
}
}
long long n;
pair<long long, long long> query(long long node, long long start, long long end,
long long x) {
if (start > x && end <= n) {
pair<long long, long long> tem = {v[x].second, INT64_MIN};
long long id = lower_bound(tree[node].begin(), tree[node].end(), tem) -
tree[node].begin();
if (id) {
return {treesum[node].back() - treesum[node][id - 1],
(long long)tree[node].size() - id};
}
return {treesum[node].back(), tree[node].size()};
}
if (end <= x || start > n) {
return {0, 0};
}
long long mid = (start + end) / 2;
pair<long long, long long> t1 = query(2 * node, start, mid, x),
t2 = query(2 * node + 1, mid + 1, end, x);
return {t1.first + t2.first, t1.second + t2.second};
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
long long x[n + 1], s[n + 1];
for (long long i = 1; n >= i; i++) {
cin >> x[i];
}
for (long long i = 1; n >= i; i++) {
cin >> s[i];
}
v.push_back({INT64_MIN, INT64_MIN});
for (long long i = 1; n >= i; i++) {
v.push_back({x[i], s[i]});
}
sort(v.begin(), v.end());
build(1, 1, n);
long long ans = 0;
for (long long i = 1; n >= i; i++) {
long long xx = v[i].first;
pair<long long, long long> temp = query(1, 1, n, i);
temp.first -= xx * temp.second;
ans += temp.first;
}
cout << ans << "\n";
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = int(1e9) + 7;
const long long int MOD64 = (long long int)(1e18) + 7;
const int INF = 0x7fffffff;
const long long int INF64 = 0x7fffffffffffffff;
using namespace std;
const int maxn = 1e+5;
struct abc {
long long pos;
long long sp;
} ver[maxn * 2 + 5];
int n;
long long speed[maxn * 2 + 5];
long long tree[maxn * 2 + 5][2];
long long lowbit(long long x);
long long _get(long long x, long long which);
void updata(long long x, long long val);
long long lowbit(long long x) { return x & (-x); }
bool cmp(abc a, abc b) { return a.pos < b.pos; }
long long _get(long long x, long long which) {
long long res = 0;
while (x) {
res += tree[x][which];
x -= lowbit(x);
}
return res;
}
void updata(long long x, long long val) {
while (x <= n) {
tree[x][0]++;
tree[x][1] += val;
x += lowbit(x);
}
}
int main() {
memset(tree, 0, sizeof(tree));
memset(speed, 0, sizeof(speed));
cin >> n;
for (int i = 1; i <= n; i++) cin >> ver[i].pos;
for (int i = 1; i <= n; i++) {
cin >> ver[i].sp;
speed[i] = ver[i].sp;
}
sort(ver + 1, ver + 1 + n, cmp);
sort(speed + 1, speed + 1 + n);
long long m = unique(speed + 1, speed + 1 + n) - speed - 1;
long long res = 0;
for (int i = 1; i <= n; i++) {
int x = lower_bound(speed + 1, speed + 1 + m, ver[i].sp) - speed;
res += ver[i].pos * _get(x, 0) - _get(x, 1);
updata(x, ver[i].pos);
}
cout << res;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, c[200005];
long long ans;
struct t {
long long x, y;
int z;
} a[200005];
int lowbit(int x) { return x & (-x); }
void update(int x) {
for (int i = x; i <= n; i += lowbit(i)) c[i]++;
}
int query(int x) {
int s = 0;
for (int i = x; i >= 1; i -= lowbit(i)) s += c[i];
return s;
}
bool cmp(t x, t y) { return x.y < y.y || x.y == y.y && x.x < y.x; }
bool cmp1(t x, t y) { return x.x < y.x; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i].x);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i].y);
sort(a + 1, a + 1 + n, cmp1);
for (int i = 1; i <= n; i++) a[i].z = i;
sort(a + 1, a + 1 + n, cmp);
memset(c, 0, sizeof(c));
ans = 0;
for (int i = 1; i <= n; i++) {
long long x;
x = query(a[i].z - 1);
ans += a[i].x * x;
update(a[i].z);
}
memset(c, 0, sizeof(c));
for (int i = n; i >= 1; i--) {
long long x = query(n) - query(a[i].z);
ans -= a[i].x * x;
update(a[i].z);
}
printf("%lld\n", ans);
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
using namespace std;
const long long N = 1e6 + 5;
const long long M = 1e8;
const long long mod = 1e9 + 7;
const long long INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
long long test = 1, n, a[N], v[N], ct = 1;
vector<long long> sp;
vector<pair<long long, long long> > x;
map<long long, long long> ind;
long long tree[N][2] = {};
void update(int idx, int val, int first) {
idx++;
while (idx <= n + 1) {
tree[idx][first] += val;
idx += idx & (-idx);
}
}
long long query(int idx, int first) {
idx++;
long long sum = 0;
while (idx > 0) {
sum += tree[idx][first];
idx -= idx & (-idx);
}
return sum;
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> v[i], sp.push_back(v[i]);
sort(sp.begin(), sp.end());
for (auto it : sp)
if (ind[it] == 0) ind[it] = ct++;
for (int i = 1; i <= n; i++) v[i] = ind[v[i]], x.push_back({a[i], v[i]});
sort(x.begin(), x.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += query(x[i].second, 0) * x[i].first - query(x[i].second, 1);
update(x[i].second, 1, 0);
update(x[i].second, x[i].first, 1);
}
cout << ans << " "
<< "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout << setprecision(10);
;
for (int i = 1; i <= test; i++) {
solve();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[200005];
vector<int> g;
struct node {
long long w, num;
} tree[1000005];
void update(int x, long long val, int l, int r, int k = 1) {
if (l == r and l == x) {
tree[k].w++;
tree[k].num += val;
return;
}
int mid = l + r >> 1;
if (x <= mid)
update(x, val, l, mid, k << 1);
else
update(x, val, mid + 1, r, k << 1 | 1);
tree[k].w = tree[k << 1].w + tree[k << 1 | 1].w;
tree[k].num = tree[k << 1].num + tree[k << 1 | 1].num;
}
long long cnt, sum;
void query(int x, int y, int l, int r, int k = 1) {
if (x <= l and y >= r) {
if (tree[k].w) sum += tree[k].num, cnt += tree[k].w;
return;
}
int mid = l + r >> 1;
if (x <= mid) query(x, y, l, mid, k << 1);
if (y > mid) query(x, y, mid + 1, r, k << 1 | 1);
}
map<int, int> id;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
}
for (int i = 1; i <= n; ++i) {
cin >> a[i].second;
g.push_back(a[i].second);
}
sort(a + 1, a + 1 + n);
sort(g.begin(), g.end());
g.erase(unique(g.begin(), g.end()), g.end());
for (int i = 0; i < g.size(); i++) {
id[g[i]] = i;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
sum = cnt = 0;
query(0, id[a[i].second], 0, g.size() - 1);
ans += abs(sum - cnt * a[i].first);
update(id[a[i].second], a[i].first, 0, g.size() - 1);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
void dout() { cerr << '\n'; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << " " << H;
dout(T...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 7;
int n, m, cnt[N];
long long sum[N];
pair<int, int> p[N];
void upd(int x, int y) {
for (; x <= m; x |= (x + 1)) {
cnt[x]++;
sum[x] += y;
}
}
int getnum(int x) {
int res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += cnt[x];
}
return res;
}
long long getsum(int x) {
long long res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += sum[x];
}
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
cin >> n;
vector<int> vec, v;
for (int i = 1; i <= n; i++) {
cin >> p[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> p[i].second;
vec.push_back(p[i].second);
}
sort((vec).begin(), (vec).end());
map<int, int> ind;
for (int i = 1; i <= n; i++) {
if (!ind.count(vec[i - 1])) {
ind[vec[i - 1]] = ++m;
}
}
for (int i = 1; i <= n; i++) {
p[i].second = ind[p[i].second];
}
sort(p + 1, p + n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += (long long)getnum(p[i].second) * p[i].first - getsum(p[i].second);
upd(p[i].second, p[i].first);
}
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5, MOD = 1e9 + 7;
pair<long long, long long> a[N];
pair<long long, long long> tree[4 * N];
bool compare(pair<long long, long long> p1, pair<long long, long long> p2) {
return p1.first < p2.first;
}
void update(long long node, long long st, long long en, long long ccidx,
long long val, long long cnt) {
if (st == en) {
tree[node].first += val;
tree[node].second += cnt;
return;
}
long long mid = (st + en) / 2;
if (ccidx <= mid)
update(2 * node, st, mid, ccidx, val, cnt);
else
update(2 * node + 1, mid + 1, en, ccidx, val, cnt);
tree[node].first = tree[2 * node].first + tree[2 * node + 1].first;
tree[node].second = tree[2 * node].second + tree[2 * node + 1].second;
}
pair<long long, long long> query(long long node, long long st, long long en,
long long l, long long r) {
if (l > en || r < st) return {0, 0};
if (l <= st && en <= r) return tree[node];
long long mid = (st + en) / 2;
pair<long long, long long> p1 = query(2 * node, st, mid, l, r);
pair<long long, long long> p2 = query(2 * node + 1, mid + 1, en, l, r);
return {p1.first + p2.first, p1.second + p2.second};
}
void solve() {
long long n;
cin >> n;
set<long long> s;
for (long long i = 0; i < n; i++) cin >> a[i].first;
for (long long i = 0; i < n; i++) {
cin >> a[i].second;
s.insert(a[i].second);
}
map<long long, long long> cc;
long long j = 1;
for (auto x : s) {
cc[x] = j;
j++;
}
sort(a, a + n, compare);
pair<long long, long long> tem = {0ll, 0ll};
for (long long i = 0; i < 4 * N; i++) tree[i] = tem;
for (long long i = 0; i < n; i++) {
update(1, 1, j - 1, cc[a[i].second], a[i].first, 1);
}
long long ans = 0;
for (long long i = n - 1; i >= 0; i--) {
update(1, 1, j - 1, cc[a[i].second], -a[i].first, -1);
pair<long long, long long> x = query(1, 1, j - 1, 1, cc[a[i].second]);
ans += abs(x.second * a[i].first - x.first);
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
struct Point {
LL x, v;
bool operator<(const Point &rhs) const {
if (v == rhs.v)
return x < rhs.x;
else
return v < rhs.v;
}
};
Point p[200010];
LL n, x2[200010], idx[200010], c[200010], s[200010];
void update(LL *arr, LL pos, LL val) {
for (LL i = pos; i <= n; i += i & (-i)) arr[i] += val;
}
LL query(LL *arr, LL pos) {
LL res = 0;
for (LL i = pos; i; i -= i & (-i)) res += arr[i];
return res;
}
int main() {
scanf("%lld", &n);
for (LL i = 1; i <= n; i++) scanf("%lld", &p[i].x);
for (LL i = 1; i <= n; i++) scanf("%lld", &p[i].v);
for (LL i = 1; i <= n; i++) idx[i] = i;
sort(p + 1, p + n + 1);
sort(idx + 1, idx + n + 1, [](LL i, LL j) { return p[i].x < p[j].x; });
for (LL i = 1; i <= n;) {
LL j;
for (j = i; j <= n; j++)
if (p[idx[j]].x != p[idx[i]].x)
break;
else
x2[idx[j]] = i;
i = j;
}
LL ans = 0;
for (LL i = 1; i <= n; i++) {
ans += p[i].x * query(c, x2[i]) - query(s, x2[i]);
update(c, x2[i], 1);
update(s, x2[i], p[i].x);
}
printf("%lld\n", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, tot, cnt, v[200001];
long long ans, c1[200001], c2[200001];
struct node {
int x, v;
inline bool operator<(const node &a) const { return x < a.x; }
} s[200001];
inline int read() {
int k = 0, f = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') f = -1;
while (c >= '0' && c <= '9')
k = (k << 1) + (k << 3) + (c ^ 48), c = getchar();
return k * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x / 10) write(x / 10);
putchar(x % 10 + '0');
return;
}
inline void add(int pos, int num, bool op) {
for (; pos <= n; pos += pos & -pos)
if (op)
c1[pos] += num;
else
++c2[pos];
}
inline long long sum(int pos, bool op) {
long long res = 0;
for (; pos; pos -= pos & -pos)
if (op)
res += c1[pos];
else
res += c2[pos];
return res;
}
int main() {
n = read();
for (register int i = 1; i <= n; ++i) s[i].x = read();
for (register int i = 1; i <= n; ++i) s[i].v = read(), v[i] = s[i].v;
sort(v + 1, v + n + 1);
cnt = unique(v + 1, v + n + 1) - v - 1;
for (register int i = 1; i <= n; ++i)
s[i].v = lower_bound(v + 1, v + cnt + 1, s[i].v) - v;
sort(s + 1, s + n + 1);
for (register int i = 1; i <= n; ++i) {
long long sum1 = sum(s[i].v, 1), sum2 = sum(s[i].v, 0);
ans += sum2 * s[i].x - sum1;
add(s[i].v, s[i].x, 1);
add(s[i].v, 1, 0);
}
write(ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5;
pair<long long, long long> p[N], a[N];
long long n;
long long fwt[N], cntf[N];
long long len;
void add(long long *b, long long x, long long v) {
while (x <= len) {
b[x] += v;
x += x & -x;
}
}
long long get(long long *b, long long x) {
long long res = 0;
while (x) {
res += b[x];
x -= x & -x;
}
return res;
}
signed main() {
ios::sync_with_stdio(false);
cin >> n;
vector<long long> velo_neg, velo_pos;
for (long long i = 0; i < n; i++) {
cin >> p[i].first;
}
for (long long i = 0; i < n; i++) {
cin >> p[i].second;
}
sort(p, p + n);
vector<long long> velo;
for (long long i = 0; i < n; i++) {
velo.push_back(p[i].second);
}
sort(velo.begin(), velo.end());
velo.erase(unique(velo.begin(), velo.end()), velo.end());
len = velo.size();
long long ans = 0;
long long sumx = 0;
for (long long i = 0; i < n; i++) {
a[i] = p[i];
a[i].second =
lower_bound(velo.begin(), velo.end(), p[i].second) - velo.begin() + 1;
ans += i * p[i].first - sumx;
sumx += p[i].first;
}
for (long long i = 0; i < n; i++) {
if (p[i].second < 0) {
ans -= (get(cntf, len) - get(cntf, a[i].second)) * p[i].first -
(get(fwt, len) - get(fwt, a[i].second));
}
add(fwt, a[i].second, p[i].first);
add(cntf, a[i].second, 1);
}
memset(cntf, 0, sizeof cntf);
memset(fwt, 0, sizeof fwt);
for (long long i = n - 1; i >= 0; i--) {
if (p[i].second > 0) {
ans -=
get(fwt, a[i].second - 1) - get(cntf, a[i].second - 1) * p[i].first;
}
if (p[i].second >= 0) {
add(fwt, a[i].second, p[i].first);
add(cntf, a[i].second, 1);
}
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
long long f[200005], ans, bit[200005], s[200005];
map<long long, long long> m;
long long t, n;
pair<long long, long long> a[200005];
long long get(long long first, long long second) {
long long re = 0, cnt = 0;
for (long long i = second; i > 0; i -= (i & (-i))) {
cnt += bit[i];
re += s[i];
}
return first * cnt - re;
}
void update(long long first, long long second) {
for (long long i = second; i <= n; i += (i & (-i))) {
bit[i]++;
s[i] += first;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i].first;
for (long long i = 1; i <= n; i++) cin >> a[i].second, m[a[i].second] = 0;
long long k = 1;
for (map<long long, long long>::iterator it = m.begin(); it != m.end();
it++, k++)
it->second = k;
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) a[i].second = m[a[i].second];
for (long long i = 1; i <= n; i++) {
ans += get(a[i].first, a[i].second);
update(a[i].first, a[i].second);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
struct dd {
int gt;
int x;
int v;
};
vector<dd> a;
struct Data {
long long sum;
int sl;
};
Data it[200009 * 8];
Data ans;
long long res;
void update(int i, int l, int r, int pos, int data) {
if (l > pos || r < pos) return;
if (l == r) {
it[i].sum = data;
it[i].sl = 1;
return;
}
int mid = (l + r) / 2;
update(i * 2, l, mid, pos, data);
update(i * 2 + 1, mid + 1, r, pos, data);
it[i].sum = it[i * 2].sum + it[i * 2 + 1].sum;
it[i].sl = it[i * 2].sl + it[i * 2 + 1].sl;
}
void find(int i, int l, int r, int u, int v) {
if (l > r) return;
if (r < u || l > v) return;
if (u <= l && r <= v) {
ans.sum = ans.sum + it[i].sum;
ans.sl = ans.sl + it[i].sl;
return;
}
int mid = (l + r) / 2;
find(i * 2, l, mid, u, v);
find(i * 2 + 1, mid + 1, r, u, v);
}
bool cmp(const dd& a, const dd& b) {
if (a.v == b.v) {
return a.x < b.x;
}
return a.v < b.v;
}
bool cmp1(const dd& a, const dd& b) { return a.x < b.x; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
dd tmp;
cin >> tmp.x;
a.push_back(tmp);
}
for (int i = 0; i < n; i++) {
cin >> a[i].v;
}
sort(a.begin(), a.end(), cmp1);
for (int i = 0; i < n; i++) {
a[i].gt = i + 1;
}
sort(a.begin(), a.end(), cmp);
update(1, 1, n, a[n - 1].gt, a[n - 1].x);
for (int i = n - 2; i >= 0; i--) {
long long tmp = a[i].x;
ans.sl = 0;
ans.sum = 0;
find(1, 1, n, a[i].gt + 1, n);
res = res + ans.sum - (tmp * ans.sl);
update(1, 1, n, a[i].gt, a[i].x);
}
cout << res << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000010;
const long long mod = 998244353;
const long long inf = 1e9;
const long double eps = 1e-16;
const long double pi = acos(-1);
inline long long rd() {
long long p = 0;
long long f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f *= -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
p = p * 10 + ch - '0';
ch = getchar();
}
return p * f;
}
struct node {
long long x, v;
} a[N];
vector<long long> v;
bool cmp(const node &x, const node &y) { return x.x < y.x; }
long long tr[2][N], n;
void add(long long id, long long x, long long c) {
while (x <= n) {
tr[id][x] += c;
x += ((x) & (-(x)));
}
}
long long qry(long long id, long long x) {
long long s = 0;
while (x >= 1) {
s += tr[id][x];
x -= ((x) & (-(x)));
}
return s;
}
signed main() {
n = rd();
for (long long i = (1); i <= (n); i++) a[i].x = rd();
for (long long i = (1); i <= (n); i++) a[i].v = rd(), v.push_back(a[i].v);
sort(a + 1, a + n + 1, cmp);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (long long i = (1); i <= (n); i++)
a[i].v = lower_bound(v.begin(), v.end(), a[i].v) - v.begin() + 1;
long long ans = 0;
for (long long i = (1); i <= (n); i++) {
ans += qry(0, a[i].v) * a[i].x - qry(1, a[i].v);
add(0, a[i].v, 1);
add(1, a[i].v, a[i].x);
}
return printf("%lld\n", ans), 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n;
pair<long long, long long> pos[200005];
struct FenwickTree {
vector<long long> bit;
long long n;
FenwickTree(long long n) {
this->n = n;
bit.assign(n, 0);
}
FenwickTree(vector<long long> a) : FenwickTree(a.size()) {
for (size_t i = 0; i < a.size(); i++) add(i, a[i]);
}
long long sum(long long r) {
long long ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
return ret;
}
long long sum(long long l, long long r) { return sum(r) - sum(l - 1); }
void add(long long idx, long long delta) {
for (; idx < n; idx = idx | (idx + 1)) bit[idx] += delta;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
pos[i].first = a;
}
pair<long long, long long> temp[n];
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
temp[i] = {a, i};
}
sort(temp, temp + n);
long long prev = -100000005;
long long cur = -1;
for (long long i = 0; i < n; i++) {
if (temp[i].first != prev) cur++;
pos[temp[i].second].second = cur;
prev = temp[i].first;
}
sort(pos, pos + n);
FenwickTree f1(200005);
FenwickTree f2(200005);
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans -= f1.sum(0, pos[i].second);
ans += f2.sum(0, pos[i].second) * pos[i].first;
f1.add(pos[i].second, pos[i].first);
f2.add(pos[i].second, 1);
}
cout << ans << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long> inverse(vector<long>& perm) {
long n = perm.size();
vector<long> ret(n);
for (long i = 0; i < n; ++i) {
ret[perm[i]] = i;
}
return ret;
}
vector<long> assignPermutation(const vector<long>& uniqs) {
long n = uniqs.size();
vector<pair<long, long>> withIndices(n);
for (long i = 0; i < n; ++i) {
withIndices[i] = {uniqs[i], i};
}
sort(withIndices.begin(), withIndices.end());
vector<long> temp(n);
for (long i = 0; i < n; ++i) {
temp[i] = withIndices[i].second;
}
return inverse(temp);
}
int main() {
long n;
cin >> n;
cin.ignore();
vector<long> x(n);
vector<long> v(n);
vector<pair<long, long>> data(n);
for (long i = 0; i < n; ++i) {
cin >> x[i];
}
cin.ignore();
for (long i = 0; i < n; ++i) {
cin >> v[i];
data[i] = {v[i], x[i]};
}
cin.ignore();
sort(data.begin(), data.end());
vector<long> xtemp(n);
for (long i = 0; i < n; ++i) xtemp[i] = data[i].second;
auto xranks = assignPermutation(xtemp);
sort(x.begin(), x.end());
long long totsum = 0;
for (long i = 0; i < n; ++i) {
totsum += (long long)(i)*x[i];
totsum -= (long long)(n - 1 - i) * x[i];
}
for (long i = 0; i < n; ++i) {
long netleftjumps = i - xranks[i];
totsum += (long long)(netleftjumps)*xtemp[i];
}
cout << totsum << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int lowbit(int x) { return x & (-x); }
long long get(vector<long long>& f, int pos) {
long long res = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) res += f[pos];
return res;
}
void upd(vector<long long>& f, int pos, int val) {
for (; pos < int(f.size()); pos |= pos + 1) {
f[pos] += val;
}
}
int main() {
int n;
cin >> n;
vector<pair<int, int>> p(n);
for (auto& pnt : p) cin >> pnt.first;
for (auto& pnt : p) cin >> pnt.second;
sort(p.begin(), p.end());
vector<int> vs;
for (auto& pnt : p) vs.push_back(pnt.second);
sort(vs.begin(), vs.end());
vs.resize(unique(vs.begin(), vs.end()) - vs.begin());
long long ans = 0;
vector<long long> cnt(vs.size()), xs(vs.size());
for (auto& pnt : p) {
int pos = lower_bound(vs.begin(), vs.end(), pnt.second) - vs.begin();
ans += get(cnt, pos) * 1ll * pnt.first - get(xs, pos);
upd(cnt, pos, 1);
upd(xs, pos, pnt.first);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, ans, tree[800002], tree1[800002];
map<long long, long long> mp, mp1;
pair<long long, long long> a[300005];
vector<long long> v;
void inc1(int idx, int val) {
for (int i = idx; i <= n; i += i & (-i)) {
tree[i] += val;
}
}
void inc2(int idx, int val) {
for (int i = idx; i <= n; i += (i & (-i))) {
tree1[i] += val;
}
}
long long sum1(int idx) {
long long pas = 0;
for (int i = idx; i > 0; i -= i & (-i)) {
pas += tree[i];
}
return pas;
}
long long sum2(int idx) {
long long pas = 0;
for (int i = idx; i > 0; i -= i & (-i)) {
pas += tree1[i];
}
return pas;
}
int main() {
std::ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> a[i].second;
if (!mp[a[i].second]) {
v.push_back(a[i].second);
}
mp[a[i].second] = 1;
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
mp1[v[i]] = i + 1;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
ans += sum1(mp1[a[i].second]) * a[i].first - sum2(mp1[a[i].second]);
inc1(mp1[a[i].second], 1);
inc2(mp1[a[i].second], a[i].first);
}
cout << ans << endl;
}
| 12 | CPP |
import sys
input = sys.stdin.readline
from heapq import heappush, heappop, heapify
def query(f, i):
ret = 0
while i:
ret += f[i]
i -= (i & -i)
return ret
def update(f, i, d):
n = len(f)
while i < n:
f[i] += d
i += (i & -i)
n = int(input())
x = list(map(int, input().split()))
v = list(map(int, input().split()))
a = [()] * (n+1)
for i in range(1, n+1):
a[i] = (x[i-1], v[i-1])
a.sort()
f = [0] * (n+1)
f2 = [0] * (n+1)
for i in range(1, n+1):
update(f, i, a[i][0])
update(f2, i, 1)
b = []
for i in range(1, n+1):
b.append((-a[i][1], -i))
heapify(b)
ans = 0
while b:
v, i = heappop(b)
v, i = -v, -i
x = a[i][0]
if i > 1:
sum = query(f, i-1)
cnt = query(f2, i-1)
ans += x * cnt - sum
update(f, i, -x)
update(f2, i, -1)
print(ans) | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int l, r;
int cnt = 0;
long long sum = 0;
int left = -1;
int right = -1;
} NIL;
vector<Node> st;
Node merge(Node x, Node y) {
Node z;
z.cnt = x.cnt + y.cnt;
z.sum = x.sum + y.sum;
return z;
}
void add(int u, int x, int v) {
if (not(st[u].l <= v and v <= st[u].r)) return;
if (st[u].l == v and v == st[u].r) {
st[u].cnt += 1;
st[u].sum += x;
return;
}
int m = (st[u].l + st[u].r) >> 1;
if (st[u].left == -1) {
Node x;
x.l = st[u].l, x.r = m;
st[u].left = int(st.size());
st.push_back(x);
}
if (st[u].right == -1) {
Node x;
x.l = m + 1, x.r = st[u].r;
st[u].right = int(st.size());
st.push_back(x);
}
add(st[u].left, x, v);
add(st[u].right, x, v);
Node s = merge(st[st[u].left], st[st[u].right]);
st[u].sum = s.sum;
st[u].cnt = s.cnt;
};
Node gteq(int u, int L, int R) {
if (u == -1 or st[u].r < L or R < st[u].l) return NIL;
if (L <= st[u].l and st[u].r <= R) return st[u];
return merge(gteq(st[u].left, L, R), gteq(st[u].right, L, R));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, int> > p(n);
for (int i = 0; i < n; i++) cin >> p[i].first;
for (int i = 0; i < n; i++) cin >> p[i].second;
sort(begin(p), end(p));
Node root;
root.l = -1e8;
root.r = 1e8;
st.emplace_back(root);
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
Node s = gteq(0, p[i].second, 1e8);
ans += s.sum - 1LL * s.cnt * p[i].first;
add(0, p[i].first, p[i].second);
}
cout << ans << '\n';
return (0);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
long long f1[200005], f2[200005], kc;
pair<long long, long long> a[200005];
bool cmp1(pair<long long, long long> x, pair<long long, long long> y) {
return x.first < y.first;
}
bool cmp2(pair<long long, long long> x, pair<long long, long long> y) {
return x.second < y.second;
}
void update(int id, long long value, long long f[]) {
while (id < 200005) {
f[id] = f[id] + value;
id = id + (id & -id);
};
}
long long rsumq(int x, long long f[]) {
long long sum = 0;
while (x != 0) {
sum += f[x];
x -= (x & -x);
};
return sum;
}
long long rsumq(int x, int y, long long f[]) {
return rsumq(y, f) - (x == 1 ? 0 : rsumq(x - 1, f));
}
void nhap() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].first;
for (int i = 1; i <= n; i++) cin >> a[i].second;
sort(a + 1, a + 1 + n, cmp2);
int cnt = 1;
for (int i = 1; i < n; i++) {
int tmp = a[i].second;
a[i].second = cnt;
if (tmp != a[i + 1].second) cnt++;
}
a[n].second = cnt;
}
void xuly() {
sort(a + 1, a + 1 + n, cmp1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += (rsumq(1, a[i].second, f1) * a[i].first - rsumq(1, a[i].second, f2));
update(a[i].second, 1, f1);
update(a[i].second, a[i].first, f2);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
nhap();
xuly();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
static int MAX_N = 200000, n;
vector<ll> bitx(MAX_N + 1), bit1(MAX_N + 1);
ll sum(int i, vector<ll> &bit) {
ll res = 0;
while (i > 0) {
res += bit.at(i);
i -= i & -i;
}
return res;
}
void add(int i, int x, vector<ll> &bit) {
while (i <= n) {
bit.at(i) += x;
i += i & -i;
}
}
int main() {
cin >> n;
vi x(n);
for (int i = 0; i < (int)(n); i++) cin >> x.at(i);
vi v(n);
for (int i = 0; i < (int)(n); i++) cin >> v.at(i);
vector<pii> p;
for (int i = 0; i < (int)(n); i++) {
pii pi(x.at(i), v.at(i));
p.push_back(pi);
}
sort(p.begin(), p.end());
map<int, int> x2i;
for (int i = 0; i < (int)(n); i++) x2i[p.at(i).first] = i + 1;
sort(p.begin(), p.end(), [](pii p1, pii p2) {
if (p1.second == p2.second)
return p1.first < p2.first;
else
return p1.second < p2.second;
});
ll ans = 0;
for (int j = 0; j < (int)(n); j++) {
int x = p.at(j).first;
int i = x2i.at(x);
ans += x * sum(i - 1, bit1) - sum(i - 1, bitx);
add(i, x, bitx);
add(i, 1, bit1);
}
cout << ans << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
void fio() {}
void pti() {
double timeuse = clock() * 1000.0 / CLOCKS_PER_SEC;
cerr << "Timeuse " << timeuse << "ms" << endl;
}
void end() { exit(0); }
namespace io {
const int SIZ = 55;
int que[SIZ], op, qr;
char ch;
template <class I>
inline void gi(I& w) {
ch = getchar(), op = 1, w = 0;
while (!isdigit(ch)) {
if (ch == '-') op = -1;
ch = getchar();
}
while (isdigit(ch)) {
w = w * 10 + ch - '0';
ch = getchar();
}
w *= op;
}
template <typename T, typename... Args>
inline void gi(T& t, Args&... args) {
gi(t);
gi(args...);
}
template <class I>
inline void print(I w) {
qr = 0;
if (!w) putchar('0');
if (w < 0) putchar('-'), w = -w;
while (w) que[++qr] = w % 10 + '0', w /= 10;
while (qr) putchar(que[qr--]);
}
} // namespace io
using io::gi;
using io::print;
const int N = 2e5 + 5;
int n, num;
struct node {
long long a, b;
};
node e[N];
long long c[N], t[N], sum[N];
map<long long, int> g;
int lowbit(int x) { return x & -x; }
void modify(int x, long long z) {
while (x <= n) ++t[x], sum[x] += z, x += lowbit(x);
}
long long query_t(int x) {
long long res = 0;
while (x) res += t[x], x -= lowbit(x);
return res;
}
long long query_sum(int x) {
long long res = 0;
while (x) res += sum[x], x -= lowbit(x);
return res;
}
int main() {
fio();
gi(n);
for (int i = 1; i <= n; ++i) gi(e[i].a);
for (int i = 1; i <= n; ++i) gi(e[i].b), c[i] = e[i].b;
sort(c + 1, c + n + 1);
for (int i = 1; i <= n; ++i)
if (!g[c[i]]) g[c[i]] = ++num;
sort(e + 1, e + n + 1,
[](node x, node y) { return x.a == y.a ? x.b < y.b : x.a < y.a; });
long long ans = 0;
for (int i = 1, j = 1; i <= n; ++i) {
ans += e[i].a * query_t(g[e[i].b]) - query_sum(g[e[i].b]);
while (j <= n && e[j].b == e[i].b && e[j].a == e[i].a)
modify(g[e[j].b], e[j].a), ++j;
}
print(ans);
end();
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma optimize("O3")
using namespace std;
const long long MOD = 1e9 + 9;
const long long INF = 1e9 + 7;
const int base = 2e5 + 1;
const long long MAX = 1e15 + 1;
const double EPS = 1e-9;
const double PI = acos(-1.);
const int MAXN = 2 * 1e5 + 47;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
pair<long long, long long> t[MAXN];
map<int, int> ind, vx;
void add(int x, long long val) {
for (int j = x; j < MAXN; j = j | (j + 1)) {
t[j].first += val;
t[j].second++;
}
}
long long get(int x) {
long long res = 0;
for (int j = x; j >= 0; j = (j & (j + 1)) - 1) {
res += t[j].first;
}
return res;
}
long long cnt(int x) {
long long res = 0;
for (int j = x; j >= 0; j = (j & (j + 1)) - 1) {
res += t[j].second;
}
return res;
}
int main() {
int n;
cin >> n;
vector<long long> x(n), v(n);
for (long long i = (0); i < (n); ++i) scanf("%lld", &x[i]);
for (long long i = (0); i < (n); ++i) {
scanf("%lld", &v[i]);
vx[x[i]] = v[i];
}
sort(v.begin(), v.end());
sort(x.begin(), x.end());
long long res = 0;
for (long long i = (0); i < (n); ++i) ind[v[i]] = i;
for (long long i = (0); i < (n); ++i) {
int cur = ind[vx[x[i]]];
res += x[i] * cnt(cur) - get(cur);
add(cur, x[i]);
}
cout << res;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> final[200001];
void up(long long int i, long long int x, long long int j) {
while (i < 200001) {
j == 0 ? final[i].first += x : final[i].second += x;
i += (i & (-i));
}
}
long long int q(long long int i, long long int j) {
long long int ans = 0;
while (i) {
ans += (j == 0 ? final[i].first : final[i].second);
i -= (i & (-i));
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int a[n];
pair<long long int, long long int> b[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
for (long long int i = 0; i < n; i++) {
cin >> b[i].first;
b[i].second = a[i];
}
sort(b, b + n);
map<long long int, long long int> mapper;
sort(a, a + n);
for (long long int i = 0; i < n; i++) {
mapper[a[i]] = i + 1;
}
long long int ans = 0;
for (auto e : b) {
long long int sp = e.first, pos = e.second;
long long int ind = mapper[pos];
long long int sum = q(ind - 1, 1);
long long int points = q(ind - 1, 0);
ans += pos * points - sum;
up(ind, 1, 0);
up(ind, pos, 1);
}
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int inf = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double eps = 1e-4;
const double pi = acos(-1.0);
void debug() { cerr << '\n'; }
template <typename T, typename... Ts>
void debug(T x, Ts... y) {
cerr << "\033[31m" << x << "\033[0m";
if (sizeof...(y) > 0) cerr << ' ';
debug(y...);
}
template <typename T>
void debug(const T &a, int l, int r, char c) {
for (int i = l; i <= r; ++i)
cerr << "\033[31m" << a[i] << "\033[0m" << (i == r ? '\n' : c);
}
template <typename T>
void debug(vector<T> a) {
for (int i = 0; i < (int)a.size(); ++i)
cerr << "\033[31m" << a[i] << "\033[31m"
<< " \n"[i == ((int)a.size() - 1)];
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long qpow(long long x, long long y) {
long long ans = 1;
for (; y > 0; y >>= 1) {
if (y & 1) ans *= x;
x *= x;
}
return ans;
}
long long qpow(long long x, long long y, int MOD) {
long long ans = 1;
for (; y > 0; y >>= 1) {
if (y & 1) ans = ans * x % MOD;
x = x * x % MOD;
}
return ans;
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, x, y);
long long X = x;
x = y;
y = X - a / b * y;
}
long long inv(long long x, int mod = MOD) { return qpow(x, mod - 2, mod); }
long long m_m(long long a, int mod = MOD) { return (a % mod + mod) % mod; }
const int N = 2e5 + 5;
vector<pair<long long, int>> tr(N + 1);
int tot;
int lsh[N];
void add(int x, int v) {
for (; x <= tot; x += -x & x) tr[x].first += v, ++tr[x].second;
}
pair<long long, int> qy(int x) {
pair<long long, int> ans;
for (; x > 0; x -= -x & x)
ans.first += tr[x].first, ans.second += tr[x].second;
return ans;
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<pair<int, int>> a(n + 1);
for (int i = (1); i < (n + 1); ++i) cin >> a[i].first;
for (int i = (1); i < (n + 1); ++i) {
cin >> a[i].second;
lsh[i] = a[i].second;
}
sort(a.begin(), a.end());
sort(lsh + 1, lsh + n + 1);
tot = unique(lsh + 1, lsh + n + 1) - lsh;
long long ans = 0;
for (int i = (1); i < (n + 1); ++i) {
int j = lower_bound(lsh + 1, lsh + tot, a[i].second) - lsh;
pair<long long, int> t = qy(j);
ans += 1ll * a[i].first * t.second - t.first;
add(j, a[i].first);
}
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int lowbit(int x) { return x & (-x); }
long long getsum(vector<long long> &V, int pos) {
long long ret = 0;
for (; pos; pos -= lowbit(pos)) ret += V[pos];
return ret;
}
void add(vector<long long> &V, int pos, int k) {
for (; pos < (int)V.size(); pos += lowbit(pos)) V[pos] += k;
}
int main() {
int n;
cin >> n;
vector<pair<int, int>> p(n);
for (auto &pnt : p) {
int x;
scanf("%d", &x);
pnt.first = x;
}
for (auto &pnt : p) {
int v;
scanf("%d", &v);
pnt.second = v;
}
sort(p.begin(), p.end());
vector<int> vs{(int)(-1e9)};
for (auto pnt : p) vs.push_back(pnt.second);
sort(vs.begin(), vs.end());
vs.resize(unique(vs.begin(), vs.end()) - vs.begin());
long long ans = 0;
vector<long long> cnt(vs.size()), xs(vs.size());
for (auto pnt : p) {
int pos = lower_bound(vs.begin(), vs.end(), pnt.second) - vs.begin();
ans += getsum(cnt, pos) * pnt.first - getsum(xs, pos);
add(cnt, pos, 1), add(xs, pos, pnt.first);
}
printf("%lld\n", ans);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int x[N];
long long ans;
pair<int, int> a[N];
int main(void) {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].second, x[i] = a[i].second;
for (int i = 0; i < n; i++) cin >> a[i].first;
sort(a, a + n), sort(x, x + n);
for (int i = 0; i < n; i++)
ans += (long long)(lower_bound(x, x + n, a[i].second) - x - n + 1 + i) *
a[i].second;
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int b[200005], m;
long long tr[800005][2];
struct node {
int x, v;
bool operator<(const node t) const { return x < t.x; }
} a[200005];
int lsh(long long x) { return lower_bound(b + 1, b + 1 + m, x) - b; }
long long query(int l, int r, int x, int y, int k, int p) {
if (l == x && r == y) return tr[p][k];
int mid = l + r >> 1;
if (y <= mid)
return query(l, mid, x, y, k, p << 1);
else if (x > mid)
return query(mid + 1, r, x, y, k, p << 1 | 1);
else
return query(l, mid, x, mid, k, p << 1) +
query(mid + 1, r, mid + 1, y, k, p << 1 | 1);
}
void update(int l, int r, int x, int y, int p) {
if (l == r) {
tr[p][0]++;
tr[p][1] += y;
return;
}
int mid = l + r >> 1;
if (x <= mid)
update(l, mid, x, y, p << 1);
else
update(mid + 1, r, x, y, p << 1 | 1);
tr[p][0] = tr[p << 1][0] + tr[p << 1 | 1][0];
tr[p][1] = tr[p << 1][1] + tr[p << 1 | 1][1];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
b[i] = a[i].v;
}
sort(b + 1, b + 1 + n);
m = unique(b + 1, b + 1 + n) - b - 1;
sort(a + 1, a + 1 + n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int t = lsh(a[i].v);
ans += query(1, m, 1, t, 0, 1) * a[i].x - query(1, m, 1, t, 1, 1);
update(1, m, t, a[i].x, 1);
}
printf("%lld", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int infinity = 9e18;
pair<long long int, long long int> t1[4 * 200005] = {};
pair<long long int, long long int> t2[4 * 200005] = {};
struct SegmentTree {
void update(pair<long long int, long long int> t[], int v, int tl, int tr,
int pos, int x) {
if (tl == tr) {
t[v].first += x;
t[v].second += 1;
} else {
int tm = (tl + tr) / 2;
if (pos <= tm)
update(t, 2 * v, tl, tm, pos, x);
else
update(t, 2 * v + 1, tm + 1, tr, pos, x);
t[v].first = (t[2 * v].first + t[2 * v + 1].first);
t[v].second = (t[2 * v].second + t[2 * v + 1].second);
}
}
pair<long long int, long long int> query(
pair<long long int, long long int> t[], int v, int tl, int tr, int l,
int r) {
if (l > r) return {0, 0};
if (tl == l && tr == r) {
return t[v];
} else {
int tm = (tl + tr) / 2;
pair<long long int, long long int> left =
query(t, 2 * v, tl, tm, l, min(tm, r));
pair<long long int, long long int> right =
query(t, 2 * v + 1, tm + 1, tr, max(tm + 1, l), r);
pair<long long int, long long int> p;
p.first = left.first + right.first;
p.second = left.second + right.second;
return p;
}
}
};
long long int func(vector<pair<long long int, long long int> > &vp,
pair<long long int, long long int> t[]) {
long long int n = vp.size();
set<long long int> s;
for (auto i : vp) {
s.insert(i.second);
}
long long int speed = 0;
map<long long int, long long int> m;
for (auto i : s) {
m[i] = speed++;
}
for (int i = 0; i < n; i++) {
vp[i].second = m[vp[i].second];
}
SegmentTree st;
long long int total = 0;
for (int i = 0; i < n; i++) {
pair<long long int, long long int> p =
st.query(t, 1, 0, n - 1, 0, vp[i].second);
total = total + (vp[i].first) * p.second - p.first;
st.update(t, 1, 0, n - 1, vp[i].second, vp[i].first);
}
return total;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
vector<pair<long long int, long long int> > vp(n);
for (int i = 0; i < n; i++) {
cin >> vp[i].first;
}
for (int i = 0; i < n; i++) {
cin >> vp[i].second;
}
sort(vp.begin(), vp.end());
vector<pair<long long int, long long int> > pos, neg;
long long int sum = 0;
long long int total = 0;
long long int count = 0;
for (int i = n - 1; i >= 0; i--) {
if (vp[i].second >= 0) {
sum += vp[i].first;
count++;
pos.push_back({vp[i].first, vp[i].second});
} else {
total = total + sum - vp[i].first * count;
neg.push_back({vp[i].first, vp[i].second});
}
}
sort(pos.begin(), pos.end());
sort(neg.begin(), neg.end());
total = total + func(pos, t1) + func(neg, t2);
cout << total;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n;
int b[maxn];
struct node {
int x, v;
} a[maxn];
bool cmp(node q1, node q2) { return q1.v == q2.v ? q1.x < q2.x : q1.v < q2.v; }
struct BIT {
long long c[maxn][2];
void init() { memset(c, 0, sizeof(c)); }
int lowbit(int x) { return x & (-x); }
void update(int k, int x, int y) {
for (int i = k; i <= n; i += lowbit(i)) {
c[i][0] += x;
c[i][1] += y;
}
}
pair<long long, long long> query(int k) {
long long ans1 = 0, ans2 = 0;
for (int i = k; i; i -= lowbit(i)) {
ans1 += c[i][0];
ans2 += c[i][1];
}
return make_pair(ans1, ans2);
}
pair<long long, long long> ask(int l, int r) {
pair<long long, long long> tmp1 = query(r);
pair<long long, long long> tmp2 = query(l - 1);
pair<long long, long long> tmp =
make_pair(tmp1.first - tmp2.first, tmp1.second - tmp2.second);
return tmp;
}
} T[2];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x);
int cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
b[++cnt] = a[i].x;
}
sort(b + 1, b + cnt + 1);
sort(a + 1, a + n + 1, cmp);
cnt = unique(b + 1, b + cnt + 1) - b - 1;
for (int i = 1; i <= n; i++) {
a[i].x = lower_bound(b + 1, b + cnt + 1, a[i].x) - b;
T[1].update(a[i].x, 1, b[a[i].x]);
}
long long ans = 0;
pair<long long, long long> tmp;
for (int i = 1; i <= n; i++) {
T[0].update(a[i].x, 1, b[a[i].x]);
T[1].update(a[i].x, -1, -b[a[i].x]);
tmp = T[0].ask(1, a[i].x);
ans += tmp.first * b[a[i].x] - tmp.second;
tmp = T[1].ask(a[i].x, n);
ans += tmp.second - tmp.first * b[a[i].x];
}
printf("%lld\n", ans / 2);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
pair<int, int> p[maxn];
int n;
long long d[maxn];
long long e[maxn];
void add(long long *c, int i, int k) {
while (i <= n) {
c[i] += k;
i += i & (-i);
}
}
long long sum(long long *c, int i) {
long long res = 0;
while (i > 0) {
res += c[i];
i -= i & (-i);
}
return res;
}
int main() {
cin >> n;
for (int i = 0; i <= n - 1; i++) cin >> p[i].first;
for (int i = 0; i <= n - 1; i++) cin >> p[i].second;
sort(p, p + n);
vector<int> es(n);
for (int i = 0; i <= n - 1; i++) es[i] = p[i].second;
sort(es.begin(), es.end());
long long res = 0;
for (int i = 0; i <= n - 1; i++) {
int pp1 = lower_bound(es.begin(), es.end(), p[i].second) - es.begin() + 1;
int pp2 = upper_bound(es.begin(), es.end(), p[i].second) - es.begin() + 1;
res += sum(d, pp2 - 1) * p[i].first - sum(e, pp2 - 1);
add(d, pp1, 1);
add(e, pp1, p[i].first);
}
cout << res;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int II() {
int q;
scanf("%d", &q);
return q;
}
long long LII() {
long long q;
scanf("%lld", &q);
return q;
}
const long long Mx = 200005;
long long N;
vector<long long> tree[Mx * 4], cum[Mx * 4];
vector<pair<long long, long long> > v(Mx + 1);
void update(long long node, long long b, long long e) {
if (b == e) {
tree[node].push_back(v[b].first);
cum[node].push_back(v[b].first);
return;
}
update((node * 2), b, (b + e) / 2);
update((node * 2) + 1, (b + e) / 2 + 1, e);
for (auto it : tree[(node * 2)]) tree[node].push_back(it);
for (auto it : tree[(node * 2) + 1]) tree[node].push_back(it);
sort(tree[node].begin(), tree[node].end());
cum[node] = tree[node];
for (long long i = cum[node].size() - 2; i >= 0; i--) {
cum[node][i] += cum[node][i + 1];
}
}
long long query(long long node, long long b, long long e, long long l,
long long r, long long val) {
if (r < l) return 0;
if (b > r or e < l) return 0;
if (b >= l and e <= r) {
long long up = upper_bound(tree[node].begin(), tree[node].end(), val) -
tree[node].begin();
if (up == tree[node].size()) return 0;
long long q = tree[node].size() - up;
return cum[node][up] - ((q * val));
}
return query((node * 2), b, (b + e) / 2, l, r, val) +
query((node * 2) + 1, (b + e) / 2 + 1, e, l, r, val);
}
void solve() {
cin >> N;
for (long long i = 1; i <= N; i++) cin >> v[i].first;
for (long long i = 1; i <= N; i++) cin >> v[i].second;
sort(v.begin() + 1, v.begin() + 1 + N,
[](pair<long long, long long> a, pair<long long, long long> b) {
if (a.second == b.second) return a.first < b.first;
return a.second < b.second;
});
update(1, 1, N);
long long ans = 0;
for (long long i = 1; i <= N; i++) {
ans += query(1, 1, N, i + 1, N, v[i].first);
}
cout << ans << endl;
}
int32_t main() {
long long tt;
tt = 1;
long long cas = 1;
while (tt--) {
solve();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using db = double;
using vi = vector<int>;
const int inf = 0x3f3f3f3f;
const db eps = 1e-8;
const int mod = 1e9 + 7;
ll qpow(ll a, ll b) {
ll ret = 1;
while (a) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
int n, m, k;
vector<pii> a;
const int maxn = 2e5 + 7;
struct node {
ll b[maxn];
void update(int i, ll v) {
for (; i < maxn; i += (i & -i)) b[i] += v;
}
ll query(int i) {
ll ret = 0;
for (; i > 0; i -= (i & -i)) ret += b[i];
return ret;
}
} bit1, bit2;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
a.resize(n);
vector<ll> co(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
}
for (int i = 0; i < n; i++) {
cin >> a[i].second;
co[i] = a[i].second;
}
sort(co.begin(), co.end());
sort(a.begin(), a.end());
co.erase(unique(co.begin(), co.end()), co.end());
for (int i = 0; i < n; i++)
a[i].second =
lower_bound(co.begin(), co.end(), a[i].second) - co.begin() + 1;
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += bit2.query(a[i].second) * a[i].first - bit1.query(a[i].second);
bit1.update(a[i].second, a[i].first);
bit2.update(a[i].second, 1);
}
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200010;
const long long N = 200000;
long long n;
struct Node {
long long v, x;
bool operator<(const Node& b) const { return x < b.x; }
} p[maxn];
struct BIT {
long long b[maxn];
inline long long lowbit(long long x) { return x & (-x); }
void update(long long x, long long v) {
for (long long i = x; i <= N; i += lowbit(i)) b[i] += v;
}
long long query(long long x) {
long long ans = 0;
for (long long i = x; i > 0; i -= lowbit(i)) ans += b[i];
return ans;
}
} a, b;
long long tot[maxn], len[maxn];
long long c[maxn], l[maxn];
map<long long, long long> mm;
long long ans;
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> p[i].x;
for (long long i = 1; i <= n; i++) cin >> p[i].v, mm[p[i].v]++;
long long id = 0;
for (map<long long, long long>::iterator it = mm.begin(); it != mm.end();
it++)
it->second = ++id;
for (long long i = 1; i <= n; i++) p[i].v = mm[p[i].v];
sort(p + 1, p + n + 1);
for (long long i = 1; i <= n; i++) {
ans += a.query(p[i].v) * p[i].x - b.query(p[i].v);
a.update(p[i].v, 1);
b.update(p[i].v, p[i].x);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int N = 2e5 + 2;
const int inf = 2e9;
const long long linf = 4e18;
long long val[N], cnt[N];
void upd(int x, long long v) {
int z = 0;
if (v < 0)
z--;
else
z++;
for (; x < N; x += x & (-x)) {
cnt[x] += z;
val[x] += v;
}
}
array<long long, 2> get(int x) {
array<long long, 2> data;
data = {0, 0};
for (; x > 0; x -= x & (-x)) {
data[0] += cnt[x];
data[1] += val[x];
}
return data;
}
array<long long, 2> get2(int x) {
array<long long, 2> a = get(N - 1);
array<long long, 2> b = get(x - 1);
return {a[0] - b[0], a[1] - b[1]};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
int n;
cin >> n;
vector<array<long long, 2>> data(n), v(n);
for (int i = 0; i < n; i++) cin >> data[i][0];
for (int i = 0; i < n; i++) {
cin >> data[i][1];
v[i] = {data[i][1], i};
}
sort(v.begin(), v.end());
int h = 0;
data[v[0][1]][1] = ++h;
for (int i = 1; i < n; i++) {
data[v[i][1]][1] = h;
if (v[i][0] != v[i - 1][0]) data[v[i][1]][1] = ++h;
}
sort(data.begin(), data.end());
for (int i = 0; i < n; i++) {
upd(data[i][1], data[i][0]);
}
long long ans = 0;
for (int i = 0; i < n; i++) {
upd(data[i][1], -data[i][0]);
array<long long, 2> d = get2(data[i][1]);
ans += d[1] - (d[0] * data[i][0]);
}
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct fen {
vector<T> fenwick;
long long size;
fen(long long sz) {
size = sz;
fenwick.resize(size);
for (long long i = 0; i < size; i++) fenwick[i] = 0;
}
fen(vector<T> arr) {
size = arr.size();
fenwick.resize(size);
for (long long i = 0; i < size; i++) fenwick[i](0);
for (long long i = 0; i < size; i++) update(i, arr[i]);
}
void add(long long index, T add) {
for (long long k = index; k < size; k |= (~k & -~k)) {
fenwick[k] = fenwick[k] + add;
}
}
void update(long long index, T nval) {
add(index, nval - rangeQuery(index, index));
}
T query(long long to) {
if (to < 0) return 0;
T sum = 0;
for (long long curr = to + 1; curr > 0; curr ^= (curr & -curr)) {
sum = sum + fenwick[curr - 1];
}
return sum;
}
T rangeQuery(long long from, long long to) {
if (from > to) return 0;
if (!from) return query(to);
return query(to) - query(from - 1);
}
void prll() {
for (long long i = 0; i < size; i++) cout << query(i) << " ";
cout << endl;
}
};
const long long sz = 2e5 + 5;
long long n;
pair<long long, long long> xv[sz];
vector<int> tmp;
map<int, int> rkspeed;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) cin >> xv[i].first;
for (long long i = 0; i < n; i++) cin >> xv[i].second;
sort(xv, xv + n);
for (long long i = 0; i < n; i++) tmp.push_back(xv[i].second);
sort(tmp.begin(), tmp.end());
vector<int> t2{tmp[0]};
for (long long i = 1; i < n; i++) {
if (tmp[i] != t2.back()) t2.push_back(tmp[i]);
}
for (long long i = 0; i < t2.size(); i++) rkspeed[t2[i]] = i;
fen<int> fcnt(n);
fen<long long> sums(n);
long long tot = 0;
for (long long i = 0; i < n; i++) {
int mrk = rkspeed[xv[i].second];
long long bamt = fcnt.query(mrk);
tot += bamt * xv[i].first - sums.query(mrk);
fcnt.add(mrk, 1);
sums.add(mrk, xv[i].first);
}
cout << tot;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int get(vector<long long int> &arr, long long int ind,
long long int n) {
long long int ans = 0;
for (; ind > 0; ind -= (ind & (-ind))) ans += arr[ind];
return ans;
}
void upd(vector<long long int> &arr, long long int ind, long long int x,
long long int n) {
for (; ind <= n; ind += (ind & (-ind))) arr[ind] += x;
}
int main() {
long long int n;
cin >> n;
pair<long long int, long long int> arr[n];
for (long long int i = 0; i < n; i++) cin >> arr[i].first;
for (long long int i = 0; i < n; i++) cin >> arr[i].second;
vector<int> vec(n);
for (long long int i = 0; i < n; i++) vec.push_back(arr[i].second);
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
vector<long long int> cnt(vec.size() + 1), cs(vec.size() + 1);
sort(arr, arr + n);
long long int ans = 0;
long long int n1 = vec.size();
for (long long int i = 0; i < n; i++) {
long long int pos =
lower_bound(vec.begin(), vec.end(), arr[i].second) - vec.begin();
ans += get(cnt, pos + 1, n1) * arr[i].first - get(cs, pos + 1, n1);
upd(cnt, pos + 1, 1, n1);
upd(cs, pos + 1, arr[i].first, n1);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
long double pi = acos(-1.0);
const int mod = 1e9 + 7;
using namespace std;
const int N = 2e5 + 5;
vector<long long> F(N), F2(N);
long long sum(int r, vector<long long> &t) {
long long result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
void inc(int i, long long delta, vector<long long> &t) {
for (; i < N; i = (i | (i + 1))) t[i] += delta;
}
long long sum(int l, int r, vector<long long> &t) {
return sum(r, t) - sum(l - 1, t);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(20);
cout.setf(ios::fixed);
int n;
cin >> n;
vector<pair<int, int> > pts(n);
for (int(i) = 0; (i) < n; (i)++) {
cin >> pts[i].first;
}
vector<int> vv;
for (int(i) = 0; (i) < n; (i)++) {
cin >> pts[i].second;
vv.push_back(pts[i].second);
}
sort((vv).begin(), (vv).end());
vv.resize(unique((vv).begin(), (vv).end()) - vv.begin());
for (int(i) = 0; (i) < n; (i)++) {
pts[i].second =
lower_bound((vv).begin(), (vv).end(), pts[i].second) - vv.begin();
}
sort((pts).begin(), (pts).end());
for (int(i) = 0; (i) < n; (i)++) {
inc(pts[i].second, pts[i].first, F);
inc(pts[i].second, 1, F2);
}
long long ans = 0;
for (int(i) = 0; (i) < n; (i)++) {
int v = pts[i].second;
inc(v, -pts[i].first, F);
inc(v, -1, F2);
long long sum1 = sum(v, N - 1, F);
long long cnt = sum(v, N - 1, F2);
ans += sum1 - cnt * (long long)pts[i].first;
}
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
using namespace chrono;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long int advceil(long long int num, long long int den) {
return (num % den == 0 ? num / den : num / den + 1);
}
long long int lstbt(long long int val) {
long long int msk = val & (val - 1);
return log2(val ^ msk);
}
long long int modmul(long long int a, long long int b) {
a %= 1000000007;
b %= 1000000007;
long long int res = 0;
while (b > 0) {
if (b & 1) res = (res + a) % 1000000007;
a = (a * 2) % 1000000007;
b /= 2;
}
return res;
}
long long int modexpo(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = modmul(res, a);
a = modmul(a, a);
b /= 2;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return a == 0 ? b : gcd(b % a, a);
}
vector<long long int> CALCfactor(long long int n) {
vector<long long int> factor(n + 2, 0);
for (long long int i = 4; i <= n; i += 2) factor[i] = 2;
for (long long int j = 3; j <= n; j += 2) {
if (factor[j]) continue;
for (long long int i = 2 * j; i <= n; i += j) factor[i] = j;
}
return factor;
}
vector<long long int> CALCprimeNUM(long long int n) {
vector<long long int> factor = CALCfactor(n);
vector<long long int> primeNUM;
primeNUM.reserve(n + 2);
for (long long int i = 2; i <= n; i++)
if (!factor[i]) primeNUM.push_back(i);
return primeNUM;
}
vector<long long int> CALCprimeFACTOR(long long int n) {
vector<long long int> factor = CALCfactor(n);
vector<long long int> ans;
while (factor[n] != 0) {
ans.push_back(factor[n]);
n /= factor[n];
}
if (n > 1) ans.push_back(n);
return ans;
}
vector<long long int> unique(vector<long long int> x) {
sort(x.begin(), x.end());
set<long long int> s;
vector<long long int> ans;
ans.reserve(x.size());
for (auto elem : x) s.insert(elem);
for (auto elem : s) ans.push_back(elem);
return ans;
}
pair<vector<long long int>, vector<long long int> > getFact(long long int n) {
vector<long long int> fact(n + 1, 1), invfact(n + 1, 1);
for (long long int i = 1; i <= n; i++)
fact[i] = (i * (fact[i - 1])) % 1000000007;
for (long long int i = 1; i <= n; i++)
invfact[i] = (modexpo(i, 1000000007 - 2) * invfact[i - 1]) % 1000000007;
return {fact, invfact};
}
long long int BIT[300001][2] = {};
long long int N;
void update(long long int idx, long long int val, long long int typ) {
for (long long int i = idx; i <= N; i += (i & (-i))) BIT[i][typ] += val;
}
long long int query(long long int idx, long long int typ) {
long long int res = 0;
for (long long int i = idx; i > 0; i -= (i & (-i))) res += BIT[i][typ];
return res;
}
long long int sum(long long int l, long long int r, long long int typ) {
return query(r, typ) - query(l - 1, typ);
}
map<long long int, long long int> fmap;
void solve() {
long long int n;
cin >> n;
vector<pair<long long int, long long int> > arr;
arr.resize(n);
for (long long int i = 0; i < n; i++) cin >> arr[i].first;
for (long long int i = 0; i < n; i++) cin >> arr[i].second;
sort(arr.begin(), arr.end());
vector<long long int> temp;
temp.reserve(n);
for (auto elem : arr) temp.push_back(elem.second);
long long int cnt = 1;
sort(temp.begin(), temp.end());
for (auto elem : temp) {
fmap[elem] = cnt;
cnt++;
}
N = cnt;
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
long long int c1 = sum(1, fmap[arr[i].second], 0);
c1 = (arr[i].first * sum(1, fmap[arr[i].second], 1) - c1);
ans += (c1);
update(fmap[arr[i].second], arr[i].first, 0);
update(fmap[arr[i].second], 1, 1);
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
auto start1 = high_resolution_clock::now();
solve();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Point {
long long x;
long long v;
};
vector<Point> points;
long long SUM;
void add_pairwise_dist(long long start, long long end) {
int m, i, j;
if (start == end) return;
m = start + (end - start) / 2;
add_pairwise_dist(start, m);
add_pairwise_dist(m + 1, end);
vector<long long> rcumsum(end - start + 2);
for (i = end; i >= start; i--) {
rcumsum[i - start] = rcumsum[i - start + 1] + points[i].x;
}
j = m + 1;
for (i = start; i <= m; i++) {
while (j <= end && points[i].v > points[j].v) j++;
if (j > end) break;
SUM += rcumsum[j - start] - points[i].x * (end - j + 1);
}
vector<Point> temp(end - start + 1);
i = start;
j = m + 1;
for (int k = 0; k < end - start + 1; k++) {
if (i > m) {
temp[k] = points[j++];
} else if (j > end) {
temp[k] = points[i++];
} else if (points[i].v < points[j].v) {
temp[k] = points[i++];
} else {
temp[k] = points[j++];
}
}
for (int k = 0; k < end - start + 1; k++) {
points[start + k] = temp[k];
}
}
int main() {
int n;
cin >> n;
points.resize(n);
for (int i = 0; i < n; i++) cin >> points[i].x;
for (int i = 0; i < n; i++) cin >> points[i].v;
sort(points.begin(), points.end(),
[](const Point &a, Point const &b) { return a.x < b.x; });
add_pairwise_dist(0, n - 1);
cout << SUM << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
int x[N + 5], v[N + 5], _v[N + 5];
pair<int, int> point[N + 5];
template <typename T, int N>
struct Binary_Indexed_Tree {
int n;
T sumv[N + 5];
void init(int _n) {
n = _n;
memset(sumv, 0, (n + 4) * sizeof(T));
}
void build(T A[], int _n) {
init(_n);
for (int i = 1; i <= n; ++i) {
sumv[i] += A[i];
int j = i + (i & -i);
if (j <= n) sumv[j] += sumv[i];
}
}
void add(int p, T k) {
while (p <= n) {
sumv[p] += k;
p += p & -p;
}
}
T sum(int p) {
T res = 0;
while (p) {
res += sumv[p];
p -= p & -p;
}
return res;
}
};
Binary_Indexed_Tree<long long, N> bit, bitr, cbit, cbitr;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", x + i);
for (int i = 1; i <= n; ++i) scanf("%d", v + i);
memcpy(_v, v, sizeof(v));
sort(_v + 1, _v + n + 1);
auto ed = unique(_v + 1, _v + n + 1);
for (int i = 1; i <= n; ++i) {
v[i] = lower_bound(_v + 1, ed, v[i]) - _v;
point[i] = {x[i], v[i]};
}
sort(point + 1, point + n + 1);
bit.init(n);
bitr.init(n);
cbit.init(n);
cbitr.init(n);
for (int i = 1; i <= n; ++i) {
int xi = point[i].first, vi = point[i].second;
bitr.add(vi, xi);
cbitr.add(vi, 1);
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int xi = point[i].first, vi = point[i].second;
bitr.add(vi, -xi);
cbitr.add(vi, -1);
ans += xi * cbit.sum(vi) - bit.sum(vi) + bitr.sum(n) - bitr.sum(vi - 1) -
(cbitr.sum(n) - cbitr.sum(vi - 1)) * xi;
bit.add(vi, xi);
cbit.add(vi, 1);
}
printf("%lld\n", ans / 2);
return 0;
}
| 12 | CPP |
import sys
input = sys.stdin.readline
from heapq import heappush, heappop, heapify
def query(f, i):
ret = 0
while i:
ret += f[i]
i -= (i & -i)
return ret
def update(f, i, d):
n = len(f)
while i < n:
f[i] += d
i += (i & -i)
n = int(input())
X = list(map(int, input().split()))
V = list(map(int, input().split()))
r = list(range(n))
r.sort(key=lambda i: X[i])
f = [0] * (n+1)
f2 = [0] * (n+1)
b = []
for i, k in enumerate(r):
b.append((V[k], i))
heapify(b)
ans = 0
while b:
v, i = heappop(b)
x = X[r[i]]
sum = query(f, i)
cnt = query(f2, i)
ans += x * cnt - sum
update(f, i+1, x)
update(f2, i+1, 1)
print(ans) | 12 | PYTHON3 |
#include <bits/stdc++.h>
template <class C>
inline void log_c(const C& c) {}
template <class C>
inline int sz(const C& c) {
return static_cast<int>(c.size());
}
using namespace std;
using pii = pair<int, int>;
using num = int64_t;
using pll = pair<num, num>;
const std::string eol = "\n";
using Ft = map<int, pair<int, int64_t>>;
const int max_x = 100000000;
void ft_inc(Ft& ft, int x, const pair<int, int64_t>& p) {
for (; x <= max_x; x |= x + 1) {
ft[x].first += p.first;
ft[x].second += p.second;
}
}
pair<int, int64_t> ft_sum(Ft& ft, int x) {
pair<int, int64_t> res;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res.first += ft[x].first;
res.second += ft[x].second;
}
return res;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<pii> data(n);
for (int k = 0; k < (n); ++k) cin >> data[k].second;
for (int k = 0; k < (n); ++k) cin >> data[k].first;
sort(begin(data), end(data));
Ft ft_slow;
int64_t ans = 0;
for (int k = 0; k < (sz(data)); ++k) {
const auto [v, x] = data[k];
const auto [c_slow, s_slow] = ft_sum(ft_slow, x);
ans += static_cast<int64_t>(x) * c_slow - s_slow;
ft_inc(ft_slow, x, {1, x});
}
cout << ans << eol;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, x[N], v[N];
vector<pair<int, int>> p;
long long bit1[N], bit2[N], ans;
void add(int p, int v, long long *bit) {
for (p += 2; p < N; p += p & -p) bit[p] += v;
}
long long query(int p, long long *bit) {
long long r = 0;
for (p += 2; p; p -= p & -p) r += bit[p];
return r;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++) p.push_back({x[i], v[i]});
sort(p.begin(), p.end());
sort(v, v + n);
for (auto &x : p) {
x.second = lower_bound(v, v + n, x.second) - v + 1;
ans += 1ll * x.first * query(x.second, bit1) - query(x.second, bit2);
add(x.second, 1, bit1);
add(x.second, x.first, bit2);
}
cout << ans << "\n";
}
| 12 | CPP |
import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
#from bisect import bisect_left as bl, bisect_right as br, insort
#from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
#from decimal import Decimal
#from fractions import Fraction
#sys.setrecursionlimit(100000)
#INF = float('inf')
mod = int(1e9)+7
def update(BIT,v, w):
while v <= n:
BIT[v] += w
v += (v & (-v))
def getvalue(BIT,v):
ANS = 0
while v != 0:
ANS += BIT[v]
v -= (v & (-v))
return ANS
def bisect_on_BIT(BIT,x):
if x <= 0:
return 0
ANS = 0
h = 1 << (n - 1)
while h > 0:
if ANS + h <= n and BIT[ANS + h] < x:
x -= BIT[ANS + h]
ANS += h
h //= 2
return ANS + 1
n=int(data())
x=mdata()
v=mdata()
a=[[v[i],x[i]] for i in range(n)]
a.sort()
s=[0]*(n+1)
cnt=[0]*(n+1)
pos=dd(int)
for i in range(n):
pos[a[i][1]]=i+1
for i in range(n):
update(s,i+1,a[i][1])
update(cnt,i+1,1)
ans=0
x.sort()
for i in range(n):
ind=pos[x[i]]
ans+=getvalue(s,n)-getvalue(s,ind)-(getvalue(cnt,n)-getvalue(cnt,ind))*x[i]
update(s,ind,-x[i])
update(cnt,ind,-1)
out(ans) | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void dout() { cerr << '\n'; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << " " << H;
dout(T...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 7;
int n, m, cnt[N];
long long sum[N];
pair<int, int> p[N];
void upd(int x, int y) {
for (; x <= m; x |= (x + 1)) {
cnt[x]++;
sum[x] += y;
}
}
int getnum(int x) {
int res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += cnt[x];
}
return res;
}
long long getsum(int x) {
long long res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += sum[x];
}
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
cin >> n;
vector<int> vec;
for (int i = 1; i <= n; i++) {
cin >> p[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> p[i].second;
vec.push_back(p[i].second);
}
sort((vec).begin(), (vec).end());
map<int, int> ind;
for (int i = 1; i <= n; i++) {
if (!ind.count(vec[i - 1])) {
ind[vec[i - 1]] = ++m;
}
}
for (int i = 1; i <= n; i++) {
p[i].second = ind[p[i].second];
}
sort(p + 1, p + n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += (long long)getnum(p[i].second) * p[i].first - getsum(p[i].second);
upd(p[i].second, p[i].first);
}
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, inf = 1e9;
const long long mod = (long long)1e9 + 7;
set<int> setV;
map<int, int> idV;
pair<int, int> p[N];
int n;
int treenum[N], num;
long long treesum[N], sum;
long long qry(long long tree[], int id) {
long long ans = 0LL;
for (; id; id -= (id & (-id))) ans += tree[id];
return ans;
}
int qry(int tree[], int id) {
int ans = 0LL;
for (; id; id -= (id & (-id))) ans += tree[id];
return ans;
}
int GetNum(int v) { return num - qry(treenum, idV[v] - 1); }
long long GetSum(int v) { return sum - qry(treesum, idV[v] - 1); }
void upd(int tree[], int id, int val) {
for (; id < N; id += (id & -id)) tree[id] += val;
}
void upd(long long tree[], int id, int val) {
for (; id < N; id += (id & -id)) tree[id] += val;
}
void Update(int v, int x) {
upd(treenum, idV[v], +1);
upd(treesum, idV[v], +x);
num++;
sum += x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> p[i].first;
}
for (int i = 1; i <= n; ++i) {
cin >> p[i].second;
setV.insert(p[i].second);
}
sort(p + 1, p + n + 1);
int k = 0;
for (int x : setV) idV[x] = ++k;
num = 0;
sum = 0LL;
long long ans = 0LL;
for (int i = n; i >= 1; --i) {
int m = GetNum(p[i].second);
long long y = GetSum(p[i].second);
ans += y - 1LL * m * p[i].first;
Update(p[i].second, p[i].first);
}
cout << ans << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long mod) {
if (b == 0 || a == 1) {
if (mod == 1)
return 0;
else
return 1;
}
if (b % 2 == 0) {
long long k = powmod(a, b / 2, mod);
return (k * k) % mod;
} else {
long long k = powmod(a, b / 2, mod);
return ((k * k) % mod * a) % mod;
}
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
if (a > b)
return gcd(a % b, b);
else
return gcd(b % a, a);
}
long long prime(long long p) {
for (long long i = 2; i * i <= p; i++) {
if (p % i == 0 && i < p) return i;
}
return 1;
}
long long inv(long long a, long long mod) { return powmod(a, mod - 2, mod); }
long long tree[1000000];
long long sum1(long long v, long long tl, long long tr, long long l,
long long r) {
if (l > r) return 0;
if (l == tl && r == tr) return tree[v];
long long tm = (tl + tr) / 2;
return sum1(2 * v, tl, tm, l, min(r, tm)) +
sum1(2 * v + 1, tm + 1, tr, max(l, tm + 1), r);
}
void update(long long v, long long tl, long long tr, long long pos,
long long new_val) {
if (tl == tr)
tree[v] += new_val;
else {
long long tm = (tl + tr) / 2;
if (pos <= tm)
update(v * 2, tl, tm, pos, new_val);
else
update(v * 2 + 1, tm + 1, tr, pos, new_val);
tree[v] = tree[v * 2] + tree[v * 2 + 1];
}
}
long long tree2[1000000];
long long sum2(long long v, long long tl, long long tr, long long l,
long long r) {
if (l > r) return 0;
if (l == tl && r == tr) return tree2[v];
long long tm = (tl + tr) / 2;
return sum2(2 * v, tl, tm, l, min(r, tm)) +
sum2(2 * v + 1, tm + 1, tr, max(l, tm + 1), r);
}
void update2(long long v, long long tl, long long tr, long long pos,
long long new_val) {
if (tl == tr)
tree2[v] += new_val;
else {
long long tm = (tl + tr) / 2;
if (pos <= tm)
update2(v * 2, tl, tm, pos, new_val);
else
update2(v * 2 + 1, tm + 1, tr, pos, new_val);
tree2[v] = tree2[v * 2] + tree2[v * 2 + 1];
}
}
void solve() {
long long a;
cin >> a;
vector<pair<long long, long long>> m(a);
for (long long i = 0; i < a; i++) cin >> m[i].first;
for (long long i = 0; i < a; i++) cin >> m[i].second;
sort(m.begin(), m.end());
long long ans = 0;
long long sum = 0;
long long col = 0;
vector<long long> copy(a);
for (long long i = 0; i < a; i++) copy[i] = m[i].second;
sort(copy.begin(), copy.end());
map<long long, long long> zamena;
for (long long i = 0; i < a; i++) zamena[copy[i]] = i;
for (long long i = 0; i < a; i++) m[i].second = zamena[m[i].second];
long long cur = 0;
for (long long i = 0; i < a; i++)
if (m[i].second > cur) {
update2(1, 1, 200000, m[i].second, m[i].first);
update(1, 1, 200000, m[i].second, 1);
}
for (long long i = 0; i < a; i++) {
if (m[i].second > cur) {
ans += m[i].first * col - sum;
ans += sum2(1LL, 1LL, 200000LL, m[i].second, 200000LL) -
sum1(1LL, 1LL, 200000LL, m[i].second, 200000LL) * m[i].first;
update(1, 1, 200000, m[i].second, -1);
update2(1, 1, 200000, m[i].second, -m[i].first);
} else {
col++;
sum += m[i].first;
}
}
cout << ans << " ";
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tututu;
tututu = 1;
for (long long qwerty = 0; qwerty < tututu; qwerty++) solve();
return 0;
}
| 12 | 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)
# 足す時はi番目に足し、返すのは累積和
class sumBIT():
def __init__(self, N):
self.N = N
self.bit = [0 for _ in range(self.N+1)]
def __str__(self):
ret = []
for i in range(1, self.N+1):
ret.append(self.__getitem__(i))
return "[" + ", ".join([str(a) for a in ret]) + "]"
def __getitem__(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.N:
self.bit[i] += x
i += i & -i
import sys
input = sys.stdin.buffer.readline
from operator import itemgetter
def main():
N = int(input())
X = list(map(int, input().split()))
V = list(map(int, input().split()))
XV = [(x, v) for x, v in zip(X, V)]
XV.sort()
XV.sort(key=itemgetter(1))
co_to_ind1 = {}
#co_to_ind2 = {}
for i, (x, v) in enumerate(XV):
co_to_ind1[x] = i+1
XV.sort()
sumbit = sumBIT(N+1)
bit = sumBIT(N+1)
ans = 0
for x, v in XV:
ind1 = co_to_ind1[x]
#ind2 = co_to_ind2[v]
count = bit[ind1]
s = sumbit[ind1]
ans += count*x - s
bit.add(ind1, 1)
sumbit.add(ind1, x)
print(ans)
if __name__ == "__main__":
main() | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int max(long long int a, long long int b) {
if (a > b)
return a;
else
return b;
}
long long int min(long long int a, long long int b) {
if (a < b)
return a;
else
return b;
}
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
int XX[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int YY[] = {-1, 0, 1, -1, 1, -1, 0, 1};
long long int fen1[200005] = {0};
long long int maxi = 200003;
void update1(long long int ind, long long int val) {
for (long long int i = ind; i <= maxi; i += i & -i) fen1[i] += val;
}
long long int sum1(long long int ind) {
long long int s = 0;
for (long long int i = ind; i; i -= i & -i) s += fen1[i];
return s;
}
long long int fen2[200005] = {0};
void update2(long long int ind, long long int val) {
for (long long int i = ind; i <= maxi; i += i & -i) fen2[i] += val;
}
long long int sum2(long long int ind) {
long long int s = 0;
for (long long int i = ind; i; i -= i & -i) s += fen2[i];
return s;
}
void convert(long long int arr[], long long int n) {
long long int temp[n];
memcpy(temp, arr, n * sizeof(long long int));
sort(temp, temp + n);
unordered_map<long long int, long long int> umap;
long long int val = 1;
for (long long int i = 0; i < n; i++) umap[temp[i]] = val++;
for (long long int i = 0; i < n; i++) arr[i] = umap[arr[i]];
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int i, j, n, k, x, v;
cin >> n;
long long int arr1[n];
for (i = 0; i < n; i++) {
cin >> arr1[i];
}
long long int arr2[n];
for (i = 0; i < n; i++) {
cin >> arr2[i];
}
convert(arr2, n);
vector<pair<long long int, long long int> > vec;
for (i = 0; i < n; i++) {
vec.push_back(make_pair(arr1[i], arr2[i]));
}
sort(vec.begin(), vec.end());
long long int ans = 0;
for (i = 0; i < vec.size(); i++) {
x = vec[i].first;
v = vec[i].second;
update1(v, 1);
update2(v, x);
}
for (i = vec.size() - 1; i >= 0; i--) {
x = vec[i].first;
v = vec[i].second;
update1(v, -1);
update2(v, -x);
long long int z = sum2(v);
long long int count = sum1(v);
ans += (x * count - z);
}
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T lcm(T a, T b) {
return a / __gcd(a, b) * b;
}
const long long mod = 1e9 + 7, oo = 1e12, N = 2e5 + 5;
using namespace std;
long long n, b[N], res, bit1[N], bit2[N];
pair<long long, long long> a[N];
inline long long lowbit(long long x) { return x & -x; }
void update(long long pos, long long val, long long *arr) {
while (pos <= n) {
arr[pos] += val;
pos += lowbit(pos);
}
}
long long get(long long pos, long long *arr) {
long long ret = 0;
while (pos > 0) {
ret += arr[pos];
pos -= lowbit(pos);
}
return ret;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n;
for (__typeof(n - 1) i = (0); i <= (n - 1); ++i) cin >> a[i].first;
for (__typeof(n - 1) i = (0); i <= (n - 1); ++i) {
cin >> a[i].second;
b[i] = a[i].second;
}
sort(b, b + n);
for (__typeof(n - 1) i = (0); i <= (n - 1); ++i)
a[i].second = lower_bound(b, b + n, a[i].second) - b + 1;
sort(a, a + n);
for (__typeof(n - 1) i = (0); i <= (n - 1); ++i) {
long long tmp1 = get(a[i].second, bit1);
long long tmp2 = get(a[i].second, bit2);
res += a[i].first * tmp1 - tmp2;
update(a[i].second, 1, bit1);
update(a[i].second, a[i].first, bit2);
}
cout << res;
return 0;
}
| 12 | CPP |
import sys
input = sys.stdin.readline
import bisect
def query(f, i):
ret = 0
while i:
ret += f[i]
i -= (i & -i)
return ret
def update(f, i, d):
n = len(f)
while i < n:
f[i] += d
i += (i & -i)
n = int(input())
X = list(map(int, input().split()))
V = list(map(int, input().split()))
a = [(X[i], V[i]) for i in range(n)]
a.sort()
# r = list(range(n))
# r.sort(key=lambda i: X[i])
vlist = sorted(set(V))
f = [0] * (len(vlist) + 1)
f2 = [0] * (len(vlist) + 1)
ans = 0
for x, v in a:
# x, v = X[i], V[i]
ii = bisect.bisect_left(vlist, v)
sm = query(f, ii + 1)
cnt = query(f2, ii + 1)
ans += x * cnt - sm
update(f, ii+1, x)
update(f2, ii+1, 1)
print(ans) | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
struct FenwickTree {
vector<long long> bit;
long long n;
vector<long long> cnt;
FenwickTree(long long n) {
this->n = n;
bit.assign(n, 0);
cnt.assign(n, 0);
}
FenwickTree(vector<long long> a) : FenwickTree(a.size()) {
for (size_t i = 0; i < a.size(); i++) add(i, a[i]);
}
pair<long long, long long> sum(long long r) {
long long ret = 0;
long long t = r;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
long long ret2 = 0;
r = t;
for (; r >= 0; r = (r & (r + 1)) - 1) ret2 += cnt[r];
return {ret, ret2};
}
pair<long long, long long> sum(long long l, long long r) {
auto j = sum(r);
auto j2 = sum(l - 1);
return {j.first - j2.first, j.second - j2.second};
}
void add(long long idx, long long delta) {
long long t = idx;
for (; idx < n; idx = idx | (idx + 1)) bit[idx] += delta;
idx = t;
for (; idx < n; idx = idx | (idx + 1)) cnt[idx] += 1;
}
};
FenwickTree ft(1000005);
map<long long, long long> compress;
signed main() {
ios_base::sync_with_stdio(0);
long long TESTS = 1;
while (TESTS--) {
long long n;
cin >> n;
long long x[n];
for (long long i = 0; i < n; i++) cin >> x[i];
long long v[n];
for (long long i = 0; i < n; i++) cin >> v[i];
set<long long> vv;
for (long long i = 0; i < n; i++) {
vv.insert(abs(v[i]));
}
long long i = 0;
for (auto j : vv) {
if (j == 0)
compress[j] = 0;
else {
compress[j] = i + 1;
i++;
}
}
for (long long i = 0; i < n; i++) {
if (v[i] >= 0)
v[i] = compress[v[i]];
else
v[i] = -compress[-v[i]];
}
vector<pair<long long, long long>> ve;
for (long long i = 0; i < n; i++) ve.push_back({x[i], v[i]});
sort((ve).begin(), (ve).end());
for (long long i = 0; i < n; i++) {
x[i] = ve[i].first;
v[i] = ve[i].second;
}
long long left = 0, right = 0;
long long cntl = 0, cntr = 0;
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (v[i] > 0) {
ans += x[i] * cntl - left;
} else if (v[i] < 0) {
cntl++;
left += x[i];
}
}
for (long long i = 0; i < n; i++) {
if (v[i] >= 0) {
ans += ft.sum(0, v[i]).second * x[i] - ft.sum(0, v[i]).first;
ft.add(v[i], x[i]);
}
}
for (long long i = 0; i < 1000005; i++) {
ft.bit[i] = 0;
ft.cnt[i] = 0;
}
for (long long i = 0; i < n; i++) {
if (v[i] <= 0) {
v[i] = -v[i];
ans +=
ft.sum(v[i], 1000000).second * x[i] - ft.sum(v[i], 1000000).first;
ft.add(v[i], x[i]);
}
}
long long sum = 0;
long long cnt = 0;
for (long long i = 0; i < n; i++) {
if (v[i] == 0) {
ans -= cnt * x[i] - sum;
sum += x[i];
cnt++;
}
}
cout << ans;
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> o[(int)2e5 + 10];
long long n, ts[(int)2e5 + 10], tc[(int)2e5 + 10];
int main(void) {
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &o[i].second);
}
for (int i = 0; i < n; i++) {
scanf("%lld", &o[i].first);
}
sort(o, o + n);
for (int i = 0; i < n; i++) {
o[i] = {o[i].second, i + 1};
}
sort(o, o + n);
long long ans = 0;
for (int i = n - 1; - 1 < i; i--) {
long long l = o[i].second - 1, r = n, idx = o[i].first;
long long s = 0, c = 0;
while (0 < r) {
s += ts[r];
c += tc[r];
r -= (r & -r);
}
while (0 < l) {
s -= ts[l];
c -= tc[l];
l -= (l & -l);
}
ans += s - c * idx;
int v = o[i].second;
while (v <= n) {
ts[v] += idx;
tc[v]++;
v += (v & -v);
}
}
printf("%lld\n", ans);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 7;
int n;
vector<pair<int, int>> p;
vector<int> vv1;
long long get(vector<long long> &f, int pos) {
long long res = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
res += f[pos];
}
return res;
}
void upd(vector<long long> &f, int pos, int val) {
for (; pos < f.size(); pos |= pos + 1) f[pos] += val;
}
int main() {
scanf("%d", &n);
p.resize(n);
for (int i = 0; i < n; i++) scanf("%d", &p[i].first);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i].second);
vv1.push_back(p[i].second);
}
sort(vv1.begin(), vv1.end());
vv1.resize(unique(vv1.begin(), vv1.end()) - vv1.begin());
sort(p.begin(), p.end());
long long ans = 0;
vector<long long> tmpv1(vv1.size()), tmpv2(vv1.size());
for (int i = 0; i < n; i++) {
int pos = lower_bound(vv1.begin(), vv1.end(), p[i].second) - vv1.begin();
ans += get(tmpv1, pos) * 1ll * p[i].first - get(tmpv2, pos);
upd(tmpv1, pos, 1);
upd(tmpv2, pos, p[i].first);
}
printf("%lld\n", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
const int NN = 1e3 + 1;
const long long MOD = 1e9 + 7;
const long long oo = 1e18 + 7;
const int BASE = 10000;
void solve() {
int n;
cin >> n;
vector<int> x(n + 1);
for (int i = 1; i <= n; i++) {
cin >> x[i];
}
vector<int> v(n + 1);
for (int i = 1; i <= n; i++) {
cin >> v[i];
}
vector<int> pos(n + 1);
iota(1 + (pos).begin(), (pos).end(), 1);
sort(1 + (pos).begin(), (pos).end(),
[&](int a, int b) { return x[a] < x[b]; });
vector<int> val = v;
sort(1 + (val).begin(), (val).end());
val.resize(unique((val).begin(), (val).end()) - val.begin());
map<int, int> Pos;
for (int i = 1; i < val.size(); i++) {
Pos[val[i]] = i;
}
vector<pair<long long, long long> > BIT(val.size());
auto update = [&](int pos, int _val) {
for (int i = pos; i < BIT.size(); i += i & -i) {
BIT[i].first += 1LL * _val;
BIT[i].second++;
}
};
auto get = [&](int pos) {
long long res = 0, cnt = 0;
for (int i = pos; i; i -= i & -i) {
res += BIT[i].first;
cnt += BIT[i].second;
}
pair<long long, long long> t = {res, cnt};
return t;
};
long long res = 0;
for (int i = 1; i <= n; i++) {
pair<long long, long long> cur = get(Pos[v[pos[i]]]);
res += x[pos[i]] * cur.second - cur.first;
update(Pos[v[pos[i]]], x[pos[i]]);
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(10);
solve();
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
long long BIT[515151];
int BIT2[515151];
map<int, int> hs;
void update(int x, int y) {
for (int i = x; i <= 5e5; i += (i & (-i))) BIT[i] += y, BIT2[i]++;
}
long long query(int x) {
long long tmp = 0;
for (int i = x; i >= 1; i -= (i & (-i))) tmp += BIT[i];
return tmp;
}
long long query2(int x) {
int tmp = 0;
for (int i = x; i >= 1; i -= (i & (-i))) tmp += BIT2[i];
return tmp;
}
int main() {
scanf("%d", &n);
int x[n + 5], v[n + 5];
for (int i = 0; i < n; i++) {
scanf("%d", &x[i]);
}
vector<int> tmp;
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
tmp.push_back(v[i]);
}
sort(tmp.begin(), tmp.end());
int idx = 1;
for (auto i : tmp) {
hs[i] = idx;
idx++;
}
for (int i = 0; i < n; i++) {
v[i] = hs[v[i]];
}
vector<pair<int, int> > data;
for (int i = 0; i < n; i++) {
data.push_back(make_pair(x[i], v[i]));
}
sort(data.begin(), data.end());
long long ans = 0;
for (auto i : data) {
long long cnt1 = query(i.second);
long long cnt2 = query2(i.second);
ans += (cnt2 * i.first - cnt1);
update(i.second, i.first);
}
printf("%I64d\n", ans);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200009;
int n, b[N], p[N], tot;
long long c1[N], c2[N];
struct P {
int x, v;
bool operator<(const P &A) const { return x < A.x; }
} a[N];
int lowbit(int x) { return x & (x ^ (x - 1)); }
void add(int x, int k, long long c[]) {
while (x <= tot) {
c[x] += k;
x += lowbit(x);
}
}
long long getsum(int x, long long c[]) {
long long ans = 0;
while (x) {
ans += c[x];
x -= lowbit(x);
}
return ans;
}
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].v);
sort(a + 1, a + 1 + n);
}
void work() {
for (int i = 1; i <= n; i++) p[i] = a[i].v;
sort(p + 1, p + 1 + n);
tot = unique(p + 1, p + 1 + n) - (p + 1);
for (int i = 1; i <= n; i++)
b[i] = lower_bound(p + 1, p + 1 + tot, a[i].v) - p;
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += getsum(b[i], c1) * a[i].x - getsum(b[i], c2);
add(b[i], 1, c1), add(b[i], a[i].x, c2);
}
printf("%lld\n", ans);
}
int main() {
init();
work();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
long long positions[maxn], speeds[maxn];
pair<long long, long long> pairs[maxn];
map<long long, long long> m;
bool comp(pair<long long, long long>& a, pair<long long, long long>& b) {
if (a.second == b.second) return a.first < b.first;
return a.second < b.second;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> positions[i];
for (int i = 0; i < n; ++i) cin >> speeds[i];
for (long long i = 0; i < n; ++i) pairs[i] = {positions[i], speeds[i]};
sort(positions, positions + n);
sort(pairs, pairs + n, comp);
long long ans = 0;
for (long long i = 0; i < n; ++i) {
ans += ((2 * i) - n + 1) * positions[i];
m[positions[i]] = i;
}
for (int i = 0; i < n; ++i) ans -= pairs[i].first * (m[pairs[i].first] - i);
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> a[200005];
long long sum[1000005], cnt[1000005];
long long querysum(long long pos) {
long long ret = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
ret += sum[pos];
}
return ret;
}
long long querycnt(long long pos) {
long long ret = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
ret += cnt[pos];
}
return ret;
}
void updatesum(long long pos, long long val) {
for (; pos < 1000000; pos |= pos + 1) {
sum[pos] += val;
}
}
void updatecnt(long long pos, long long val) {
for (; pos < 1000000; pos |= pos + 1) {
cnt[pos] += val;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i].first;
for (long long i = 1; i <= n; i++) cin >> a[i].second;
vector<long long> v;
for (long long i = 1; i <= n; i++) {
v.push_back(a[i].second);
}
sort(v.begin(), v.end());
map<long long, long long> num;
for (long long i = 0; i < v.size(); i++) {
num[v[i]] = i;
}
for (long long i = 1; i <= n; i++) {
a[i].second = num[a[i].second];
}
sort(a + 1, a + n + 1);
memset(sum, 0, sizeof(sum));
memset(cnt, 0, sizeof(cnt));
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans += a[i].first * querycnt(a[i].second) - querysum(a[i].second);
updatesum(a[i].second, a[i].first);
updatecnt(a[i].second, 1);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 20;
int n;
pair<int, int> p[N];
struct node {
long long sum, count;
node(long long s = 0, long long c = 0) : sum(s), count(c) {}
} bit[N];
void update(int x, int delta) {
for (; x <= n; x += x & -x) {
auto &[sum, count] = bit[x];
sum += delta;
count++;
}
}
node query(int x) {
auto ans = node();
for (; x > 0; x -= x & -x) {
auto &[sum, count] = bit[x];
ans.sum += sum;
ans.count += count;
}
return ans;
}
int compress(vector<int> &v) {
if (v.empty()) return 0;
vector<int> s = v;
sort(s.begin(), s.end());
s.resize(unique(s.begin(), s.end()) - s.begin());
int mx = 1;
for (int &x : v) {
x = lower_bound(s.begin(), s.end(), x) - s.begin() + 1;
mx = max(mx, x);
}
return mx;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> p[i].first;
for (int i = 0; i < n; i++) cin >> p[i].second;
sort(p, p + n);
vector<int> vec(n);
for (int i = 0; i < n; i++) vec[i] = p[i].second;
compress(vec);
long long ans = 0;
for (int i = 0; i < n; i++) {
auto [sum, cnt] = query(vec[i]);
ans += cnt * p[i].first - sum;
update(vec[i], p[i].first);
}
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long a = 0, b = getchar(), c = 1;
while (!isdigit(b)) c = b == '-' ? -1 : 1, b = getchar();
while (isdigit(b)) a = a * 10 + b - '0', b = getchar();
return a * c;
}
long long n, ans, p[200005];
pair<long long, long long> a[200005];
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i].second = read();
p[i] = a[i].second;
}
for (int i = 1; i <= n; i++) a[i].first = read();
sort(a + 1, a + n + 1);
sort(p + 1, p + n + 1);
for (int i = 1; i <= n; i++)
ans += (lower_bound(p + 1, p + n + 1, a[i].second) - p - n + i - 1) *
a[i].second;
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 500;
long long n, t1[N], t2[N];
void upd1(long long val, long long pos) {
while (pos < n) {
t1[pos] += val;
pos = (pos | (pos + 1));
}
}
void upd2(long long val, long long pos) {
while (pos < n) {
t2[pos] += val;
pos = (pos | (pos + 1));
}
}
long long get1(long long pos) {
long long res = 0;
while (pos >= 0) {
res += t1[pos];
pos = (pos & (pos + 1)) - 1;
}
return res;
}
long long get2(long long pos) {
long long res = 0;
while (pos >= 0) {
res += t2[pos];
pos = (pos & (pos + 1)) - 1;
}
return res;
}
int main() {
cin >> n;
vector<pair<long long, long long> > a(n);
vector<long long> comp;
map<long long, long long> new_val;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
}
for (int i = 0; i < n; i++) {
cin >> a[i].second;
comp.push_back(a[i].second);
}
sort(a.begin(), a.end());
sort(comp.begin(), comp.end());
long long k = 0;
new_val[comp[0]] = k;
for (int i = 1; i < comp.size(); i++) {
if (comp[i] != comp[i - 1]) k++;
new_val[comp[i]] = k;
}
for (int i = 0; i < n; i++) {
a[i].second = new_val[a[i].second];
}
long long ans = 0;
for (int i = 0; i < n; i++) {
long long pos = a[i].second;
long long cnt = get1(pos);
long long sum = get2(pos);
ans += ((cnt * a[i].first) - sum);
upd1(1, pos);
upd2(a[i].first, pos);
}
cout << ans << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long int power(long long int x, long long int y) {
long long int ans = 1;
x %= 1000000007;
while (y) {
if (y & 1) ans = (x * ans) % 1000000007;
x = (x * x) % 1000000007;
y >>= 1;
}
return ans;
}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
struct FenwickTree {
vector<long long int> bit;
int n;
FenwickTree(int n) {
this->n = n;
bit.assign(n, 0);
}
FenwickTree(vector<int> a) : FenwickTree(a.size()) {
for (size_t i = 0; i < a.size(); i++) add(i, a[i]);
}
long long int sum(int r) {
long long int ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
return ret;
}
long long int sum(int l, int r) { return sum(r) - sum(l - 1); }
void add(int idx, int delta) {
for (; idx < n; idx = idx | (idx + 1)) bit[idx] += delta;
}
};
void solve() {
long long int n;
cin >> n;
vector<pair<long long int, long long int> > arr(n);
vector<long long int> vel(n);
for (int i = 0; i < n; i++) {
cin >> arr[i].first;
}
for (int i = 0; i < n; i++) {
cin >> arr[i].second;
vel[i] = arr[i].second;
}
sort(arr.begin(), arr.end());
sort(vel.begin(), vel.end());
map<long long int, long long int> mp;
for (int i = 0; i < n; i++) {
long long int in =
lower_bound(vel.begin(), vel.end(), vel[i]) - vel.begin();
mp[vel[i]] = in;
}
long long int ans = 0;
FenwickTree count(n + 10), dist(n + 10);
for (int i = 0; i < n; i++) {
long long int v = mp[arr[i].second];
long long int cnt = count.sum(v);
long long int sum = dist.sum(v);
ans += (cnt * arr[i].first - sum);
count.add(v, 1);
dist.add(v, arr[i].first);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 10, MAXM = 2e6 + 10;
const int INF = INT_MAX, SINF = 0x3f3f3f3f;
const long long llINF = LLONG_MAX;
const int MOD = 1e9 + 7, mod = 998244353;
long long tr[MAXN], tot, n, t[MAXN];
void add(int x, long long val) {
while (x <= n) {
tr[x] += val;
t[x] += 1;
x += x & -x;
}
}
pair<long long, long long> query(int x) {
long long ans = 0, ans1 = 0;
while (x) {
ans += tr[x];
ans1 += t[x];
x -= x & -x;
}
return {ans, ans1};
}
struct Node {
long long x, v;
bool operator<(const Node &rhs) const { return x < rhs.x; }
} e[MAXN];
vector<long long> v;
map<long long, long long> mp;
int main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &e[i].x);
for (int i = 1; i <= n; i++) scanf("%lld", &e[i].v), v.push_back(e[i].v);
sort(e + 1, e + n + 1);
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
for (int i = 0; i < ((int)v.size()); i++) mp[v[i]] = i + 1;
long long ans = 0;
for (int i = 1; i <= n; i++) {
pair<long long, long long> tmp = query(mp[e[i].v]);
ans += e[i].x * tmp.second - tmp.first;
add(mp[e[i].v], e[i].x);
}
printf("%lld", ans);
return 0;
}
| 12 | CPP |
import sys
input = sys.stdin.readline
import bisect
def query(f, i):
ret = 0
while i:
ret += f[i]
i -= (i & -i)
return ret
def update(f, i, d):
n = len(f)
while i < n:
f[i] += d
i += (i & -i)
n = int(input())
X = list(map(int, input().split()))
V = list(map(int, input().split()))
r = list(range(n))
r.sort(key=lambda i: X[i])
vlist = sorted(set(V))
f = [0] * (len(vlist) + 1)
f2 = [0] * (len(vlist) + 1)
ans = 0
for i in r:
x, v = X[i], V[i]
ii = bisect.bisect_left(vlist, v)
sm = query(f, ii + 1)
cnt = query(f2, ii + 1)
ans += x * cnt - sm
update(f, ii+1, x)
update(f2, ii+1, 1)
print(ans) | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int b[200005], m;
long long c[200005][2];
struct node {
int x, v;
bool operator<(const node t) const { return x < t.x; }
} a[200005];
int lsh(long long x) { return lower_bound(b + 1, b + 1 + m, x) - b; }
long long query(int x, int k) {
long long ret = 0;
for (int i = x; i >= 1; i -= i & -i) ret += c[i][k];
return ret;
}
void update(int x, int y) {
for (int i = x; i <= m; i += i & -i) {
c[i][0]++;
c[i][1] += y;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
b[i] = a[i].v;
}
sort(b + 1, b + 1 + n);
m = unique(b + 1, b + 1 + n) - b - 1;
sort(a + 1, a + 1 + n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int t = lsh(a[i].v);
ans += query(t, 0) * a[i].x - query(t, 1);
update(t, a[i].x);
}
printf("%lld", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mx = 105;
const long long mod = 1000000007;
const long long maxn = 1e17;
vector<long long> v1;
vector<long long> v2;
long long get(long long x, long long vt) {
long long i, j, k;
long long res = 0;
for (i = x; i > 0; i -= (i & -i)) {
if (vt == 1) {
res += v1[i];
} else {
res += v2[i];
}
}
return res;
}
void upd(long long x, long long vt, long long val) {
long long i, j, k;
long long si = (vt == 1 ? (int)v1.size() : (int)v2.size());
for (i = x; i < si; i += (i & -i)) {
if (vt == 1) {
v1[i] += val;
} else {
v2[i] += val;
}
}
}
void solve() {
long long n, i, j, k;
cin >> n;
long long x[n + 1], v[n + 1];
vector<pair<long long, long long>> v4;
for (i = 1; i <= n; i++) {
cin >> x[i];
}
for (i = 1; i <= n; i++) {
cin >> v[i];
}
for (i = 1; i <= n; i++) {
v4.push_back({x[i], v[i]});
}
sort(v4.begin(), v4.end());
for (i = 1; i <= n; i++) {
x[i] = v4[i - 1].first;
v[i] = v4[i - 1].second;
}
vector<long long> disx;
for (i = 1; i <= n; i++) {
disx.push_back(v[i]);
}
sort(disx.begin(), disx.end());
disx.resize(unique(disx.begin(), disx.end()) - disx.begin());
v1.resize(disx.size() + 1);
v2.resize(disx.size() + 1);
long long res = 0;
for (i = 1; i <= n; i++) {
long long pos = lower_bound(disx.begin(), disx.end(), v[i]) - disx.begin();
res += get(pos + 1, 1) * x[i] - get(pos + 1, 2);
upd(pos + 1, 1, 1);
upd(pos + 1, 2, x[i]);
}
cout << res << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
while (t--) {
solve();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
void dout() { cerr << '\n'; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << " " << H;
dout(T...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 7;
int n, m, cnt[N];
long long sum[N];
pair<int, int> p[N];
void upd(int x, int y) {
for (; x <= m; x |= (x + 1)) {
cnt[x]++;
sum[x] += y;
}
}
int getnum(int x) {
int res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += cnt[x];
}
return res;
}
long long getsum(int x) {
long long res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += sum[x];
}
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
cin >> n;
vector<int> vec;
for (int i = 1; i <= n; i++) {
cin >> p[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> p[i].second;
vec.push_back(p[i].second);
}
sort((vec).begin(), (vec).end());
map<int, int> ind;
for (int i = 1; i <= n; i++) {
if (!ind.count(vec[i - 1])) {
ind[vec[i - 1]] = ++m;
}
}
for (int i = 1; i <= n; i++) {
p[i].second = ind[p[i].second];
}
sort(p + 1, p + n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += (long long)getnum(p[i].second) * p[i].first - getsum(p[i].second);
upd(p[i].second, p[i].first);
}
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5;
int m;
long long val[maxn + 11];
int cnt[maxn + 11];
pair<int, int> p[maxn + 11];
vector<int> v;
int lowbit(int x) { return x & (-x); }
void add(int x, int o) {
for (; x <= m; x += lowbit(x)) {
cnt[x] += 1;
val[x] += o;
}
}
pair<int, long long> query(int x) {
int resc = 0;
long long resv = 0;
for (; x; x -= lowbit(x)) {
resc += cnt[x];
resv += val[x];
}
return make_pair(resc, resv);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i].first;
for (int i = 1; i <= n; i++) {
cin >> p[i].second;
v.emplace_back(p[i].second);
}
sort(p + 1, p + 1 + n);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
m = v.size();
long long ans = 0;
for (int i = 1; i <= n; i++) {
int pos = lower_bound(v.begin(), v.end(), p[i].second) - v.begin() + 1;
pair<int, long long> pi = query(pos);
ans += 1ll * pi.first * p[i].first - pi.second;
add(pos, p[i].first);
}
cout << ans << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
pair<int, int> p[maxn];
int n;
long long d[maxn];
long long e[maxn];
void add(long long *c, int i, int k) {
while (i <= n) {
c[i] += k;
i += i & (-i);
}
}
long long sum(long long *c, int i) {
long long res = 0;
while (i > 0) {
res += c[i];
i -= i & (-i);
}
return res;
}
int main() {
cin >> n;
for (int i = 0; i <= n - 1; i++) cin >> p[i].first;
for (int i = 0; i <= n - 1; i++) cin >> p[i].second;
sort(p, p + n);
vector<int> es(n);
for (int i = 0; i <= n - 1; i++) es[i] = p[i].second;
sort(es.begin(), es.end());
long long res = 0;
for (int i = 0; i <= n - 1; i++) {
int pp = lower_bound(es.begin(), es.end(), p[i].second) - es.begin() + 1;
res += sum(d, pp) * p[i].first - sum(e, pp);
add(d, pp, 1);
add(e, pp, p[i].first);
}
cout << res << "\n";
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long BIT[200009][4], N = 200009, n, ans, I;
struct st {
long long x, v;
} a[200009];
bool cmp(st a, st b) {
if (a.v == b.v) return a.x > b.x;
return a.v > b.v;
}
bool cmp2(st a, st b) {
if (a.v == b.v) return a.x > b.x;
return a.v > b.v;
}
set<long long> s;
map<long long, long long> mp;
void update(long long x, long long val, long long zz) {
for (; x < N; x += x & -x) BIT[x][zz] += val;
}
long long query(long long x, long long zz) {
long long sum = 0;
for (; x > 0; x -= x & -x) sum += BIT[x][zz];
return sum;
}
long long q(long long l, long long r, long long zz) {
return query(r, zz) - query(l - 1, zz);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].x;
s.insert(a[i].x);
}
for (int i = 0; i < n; i++) {
cin >> a[i].v;
}
for (auto x : s) mp[x] = ++I;
sort(a, a + n, cmp);
for (int i = 0; i < n; i++) {
ans += q(mp[a[i].x] + 1, I, 1) - a[i].x * q(mp[a[i].x] + 1, I, 2);
update(mp[a[i].x], a[i].x, 1);
update(mp[a[i].x], 1, 2);
}
cout << ans << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
pair<int, int> p[N];
struct fenwick {
long long fen[N];
void add(int first, int d) {
for (int i = first + 1; i < N; i += i & -i) {
fen[i] += d;
}
}
long long sum(int first) {
long long ans = 0;
for (int i = first + 1; i; i -= i & -i) {
ans += fen[i];
}
return ans;
}
long long sum(int l, int r) { return sum(r) - sum(l - 1); }
} val, cnt;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> p[i].first;
for (int i = 0; i < n; ++i) cin >> p[i].second;
sort(p, p + n);
vector<int> a(n);
for (int i = 0; i < n; ++i) a[i] = p[i].second;
sort(a.begin(), a.end());
a.resize(unique(a.begin(), a.end()) - a.begin());
for (int i = 0; i < n; ++i) {
p[i].second = lower_bound(a.begin(), a.end(), p[i].second) - a.begin();
}
long long ans = 0;
for (int i = n - 1; ~i; --i) {
val.add(p[i].second, p[i].first);
cnt.add(p[i].second, 1);
ans += val.sum(p[i].second, 2e5) - cnt.sum(p[i].second, 2e5) * p[i].first;
}
cout << ans << '\n';
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> t;
pair<long long, long long> get(long long v, long long l, long long r,
long long a, long long b) {
if (l > b || a > r) {
return {0, 0};
}
if (a <= l && r <= b) {
return t[v];
}
long long m = (l + r) / 2;
pair<long long, long long> tmp = get(2 * v, l, m, a, b),
tmp2 = get(2 * v + 1, m + 1, r, a, b);
return {tmp.first + tmp2.first, tmp.second + tmp2.second};
}
void update(long long v, long long l, long long r, long long i, long long x) {
if (l > i || i > r) {
return;
}
if (l == r) {
t[v] = {t[v].first + x, t[v].second + 1};
return;
}
long long m = (l + r) / 2;
update(2 * v, l, m, i, x);
update(2 * v + 1, m + 1, r, i, x);
t[v].first = t[2 * v].first + t[2 * v + 1].first;
t[v].second = t[2 * v].second + t[2 * v + 1].second;
}
signed main() {
long long n;
cin >> n;
long long q = 1 << (long long)ceil(log2(n));
t.resize(2 * q);
vector<pair<long long, long long>> x(n);
for (long long i = 0; i < n; ++i) {
cin >> x[i].first;
}
for (long long i = 0; i < n; ++i) {
cin >> x[i].second;
}
sort(x.begin(), x.end());
vector<long long> a(n);
for (long long i = 0; i < n; ++i) {
a[i] = x[i].second;
}
unordered_map<long long, long long> b;
sort(a.begin(), a.end());
a.resize(unique(a.begin(), a.end()) - a.begin());
for (long long i = 0; i < a.size(); ++i) {
b[a[i]] = i;
}
vector<long long> c(n);
for (long long i = 0; i < n; ++i) {
c[i] = b[x[i].second];
}
long long now = 0;
long long sum = 0, kol = 0;
for (long long i = 0; i < n; ++i) {
if (x[i].second < 0) {
sum += x[i].first;
++kol;
continue;
}
if (x[i].second > 0) {
pair<long long, long long> tmp = get(1, 0, q - 1, 0, c[i]);
now += tmp.second * x[i].first - tmp.first;
update(1, 0, q - 1, c[i], x[i].first);
} else {
now += kol * x[i].first - sum;
sum += x[i].first;
++kol;
}
}
t.assign(2 * q, {0, 0});
sum = 0;
kol = 0;
for (long long i = n - 1; i >= 0; --i) {
if (x[i].second > 0) {
sum += x[i].first;
++kol;
continue;
}
if (x[i].second < 0) {
pair<long long, long long> tmp = get(1, 0, q - 1, c[i], n - 1);
now += tmp.first - tmp.second * x[i].first;
update(1, 0, q - 1, c[i], x[i].first);
} else {
now += sum - kol * x[i].first;
}
}
long long nowl = 0, koll = 0, nowr = 0, kolr = 0;
for (long long i = 0; i < n; ++i) {
if (x[i].second > 0) {
now += koll * x[i].first - nowl;
++kolr;
nowr += x[i].first;
} else if (x[i].second < 0) {
++koll;
nowl += x[i].first;
}
}
cout << now;
return 0;
}
| 12 | CPP |
class BIT():
def __init__(self, array):
self.n = len(array)
self.bit = [0] + array
self.build()
def build(self):
for i in range(1, self.n):
if i + (i & -i) > self.n:
continue
self.bit[i + (i & -i)] += self.bit[i]
def _sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, val):
i += 1
while i <= self.n:
self.bit[i] += val
i += i & -i
def get_sum(self, l, r):
return self._sum(r) - self._sum(l)
from operator import itemgetter
import sys
input = sys.stdin.readline
n = int(input())
x = list(map(int, input().split()))
v = list(map(int, input().split()))
sorted_x = sorted(x)
bit = BIT(sorted_x)
bit_ind = BIT([1] * n)
to_ind = {v: i for i, v in enumerate(sorted_x)}
info = [None] * n
for i in range(n):
info[i] = (v[i] + 10**18, x[i])
info = sorted(info, key=itemgetter(1), reverse=True)
info = sorted(info, key=itemgetter(0), reverse=True)
ans = 0
for i in range(n):
_, pos = info[i]
ind = to_ind[pos]
sum_ = bit.get_sum(0, ind)
num = bit_ind.get_sum(0, ind)
ans += num * pos - sum_
bit.add(ind, -pos)
bit_ind.add(ind, -1)
print(ans)
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int b[200005], m;
long long c[200005][2];
struct node {
int x, v;
bool operator<(const node t) const { return x < t.x; }
} a[200005];
int lsh(long long x) { return lower_bound(b + 1, b + 1 + m, x) - b; }
long long query(int x, int k) {
long long ret = 0;
for (int i = x; i >= 1; i -= i & -i) ret += c[i][k];
return ret;
}
void update(int x, int y) {
for (int i = x; i <= m; i += i & -i) {
c[i][0]++;
c[i][1] += y;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
b[i] = a[i].v;
}
sort(b + 1, b + 1 + n);
m = unique(b + 1, b + 1 + n) - b - 1;
sort(a + 1, a + 1 + n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int t = lsh(a[i].v);
ans += query(t, 0) * a[i].x - query(t, 1);
update(t, a[i].x);
}
printf("%lld", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct segtree {
long long int M = 1, INIT;
vector<long long int> dat;
segtree(long long int N, long long int num) {
INIT = num;
while (M < N) M *= 2;
for (int i = 0; i < M * 2 - 1; i++) dat.push_back(num);
}
void update(long long int x, long long int k, long long int l = 0,
int r = -1) {
if (r == -1) r = M;
k += M - 1;
dat[k] += x;
while (k > 0) k = (k - 1) / 2, dat[k] = dat[k * 2 + 1] + dat[k * 2 + 2];
}
long long int query(long long int a, long long int b = -1,
long long int k = 0, long long int l = 0,
long long int r = -1) {
if (r == -1) r = M;
if (b == -1) b = M;
if (r <= a || b <= l) return INIT;
if (a <= l && r <= b) return dat[k];
long long int A = query(a, b, k * 2 + 1, l, (l + r) / 2);
long long int B = query(a, b, k * 2 + 2, (l + r) / 2, r);
return A + B;
}
};
int main(int argc, char const *argv[]) {
long long int n;
scanf("%lld", &n);
vector<vector<long long int> > l = vector<vector<long long int> >(
0, vector<long long int>(3, 0)),
r = vector<vector<long long int> >(
0, vector<long long int>(3, 0));
long long int b;
map<long long int, long long int> mp, point;
vector<long long int> x(n);
for (long long int i = 0; i < n; i++) scanf("%lld", &x[i]);
vector<vector<long long int> > d =
vector<vector<long long int> >(n, vector<long long int>(3, 0));
for (long long int i = 0; i < n; i++) {
scanf("%lld", &b);
d[i][0] = x[i], d[i][1] = b;
if (b <= 0) l.push_back(vector<long long int>{x[i], abs(b), 0});
if (b >= 0) r.push_back(vector<long long int>{x[i], abs(b), 0});
mp.emplace(abs(b), 0);
point.emplace(x[i], 0);
}
long long int c = 0;
for (auto itr = mp.begin(); itr != mp.end(); itr++, c++) (*itr).second = c;
c = 0;
for (auto itr = point.begin(); itr != point.end(); itr++, c++)
(*itr).second = c;
long long int ans = 0;
for (long long int i = 0; i < l.size(); i++) l[i][2] = mp.at(l[i][1]);
for (long long int i = 0; i < r.size(); i++) r[i][2] = mp.at(r[i][1]);
for (long long int i = 0; i < n; i++) d[i][2] = point.at(d[i][0]);
segtree seg_l(mp.size(), 0), seg_r(mp.size(), 0), p(point.size(), 0);
segtree seg_l_num(mp.size(), 0), seg_r_num(mp.size(), 0),
p_num(point.size(), 0);
sort((l).begin(), (l).end());
sort((r).begin(), (r).end());
sort((d).begin(), (d).end());
for (int i = r.size() - 1; i >= 0; i--) {
long long int SUM = seg_r.query(r[i][2], mp.size() + 1);
long long int NUM = seg_r_num.query(r[i][2], mp.size() + 1);
ans += (SUM - r[i][0] * NUM);
if (r[i][1] != 0)
seg_r.update(r[i][0], r[i][2]), seg_r_num.update(1, r[i][2]);
}
for (long long int i = 0; i < l.size(); i++) {
long long int SUM = seg_l.query(l[i][2], mp.size() + 1);
long long int NUM = seg_l_num.query(l[i][2], mp.size() + 1);
ans += (l[i][0] * NUM - SUM);
seg_l.update(l[i][0], l[i][2]), seg_l_num.update(1, l[i][2]);
}
for (long long int i = 0; i < n; i++) {
if (d[i][1] < 0) p.update(d[i][0], d[i][2]), p_num.update(1, d[i][2]);
if (d[i][1] > 0) {
long long int SUM = p.query(0, d[i][2]);
long long int NUM = p_num.query(0, d[i][2]);
ans += (d[i][0] * NUM - SUM);
}
}
std::cout << ans << '\n';
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<long long, long long>>> mt(4 * 200005);
vector<pair<long long, long long>> a;
void buildTree(long long idx, long long second, long long se) {
if (second == se) {
mt[idx].push_back({a[second].second, a[second].first});
return;
}
long long mid = (second + se) / 2;
buildTree(2 * idx + 1, second, mid);
buildTree(2 * idx + 2, mid + 1, se);
merge(mt[2 * idx + 1].begin(), mt[2 * idx + 1].end(), mt[2 * idx + 2].begin(),
mt[2 * idx + 2].end(), back_inserter(mt[idx]));
}
pair<long long, long long> query(long long node, long long qs, long long qe,
long long second, long long se,
long long diff) {
if (qs > se || qe < second) return {0, 0};
if (qs <= second && qe >= se) {
long long l = 0, r = mt[node].size() - 1, ind = 1e9;
while (l <= r) {
long long mid = (l + r) / 2;
if (mt[node][mid].first >= diff) {
ind = min(ind, mid);
r = mid - 1;
} else {
l = mid + 1;
}
}
pair<long long, long long> ans = {0, 0};
if (ind != 1e9) {
ans.second = mt[node].size() - ind;
ans.first = mt[node][mt[node].size() - 1].second;
if (ind != 0) ans.first -= mt[node][ind - 1].second;
}
return ans;
}
long long mid = (second + se) / 2;
pair<long long, long long> p1 =
query(2 * node + 1, qs, qe, second, mid, diff);
pair<long long, long long> p2 =
query(2 * node + 2, qs, qe, mid + 1, se, diff);
p1.first += p2.first;
p1.second += p2.second;
return p1;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
a.resize(n);
for (int i = 0; i < n; i++) cin >> a[i].first;
for (int i = 0; i < n; i++) cin >> a[i].second;
sort(a.begin(), a.end());
buildTree(0, 0, n - 1);
for (int i = 0; i < (4 * n) + 5; i++) {
for (int j = 1; j < mt[i].size(); j++)
mt[i][j].second += mt[i][j - 1].second;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
pair<long long, long long> q =
query(0, i + 1, n - 1, 0, n - 1, a[i].second);
ans += (q.first - (q.second * a[i].first));
}
cout << ans << "\n";
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int num[800005], m;
long long b[200005], sum[200005], cnt[200005], tr[800005];
struct node {
int x, v;
bool operator<(const node t) const { return x < t.x; }
} a[200005];
int lsh(long long x) { return lower_bound(b + 1, b + 1 + m, x) - b; }
void build(int l, int r, int p) {
if (l == r) {
tr[p] = sum[l];
num[p] = cnt[l];
return;
}
int mid = l + r >> 1;
build(l, mid, p << 1);
build(mid + 1, r, p << 1 | 1);
tr[p] = tr[p << 1] + tr[p << 1 | 1];
num[p] = num[p << 1] + num[p << 1 | 1];
}
pair<long long, int> query(int l, int r, int x, int y, int p) {
if (l == x && r == y) return make_pair(tr[p], num[p]);
int mid = l + r >> 1;
if (y <= mid)
return query(l, mid, x, y, p << 1);
else if (x > mid)
return query(mid + 1, r, x, y, p << 1 | 1);
else {
pair<long long, int> v1 = query(l, mid, x, mid, p << 1),
v2 = query(mid + 1, r, mid + 1, y, p << 1 | 1);
return make_pair(v1.first + v2.first, v1.second + v2.second);
}
}
void update(int l, int r, int x, int y, int p) {
if (l == r) {
tr[p] -= y;
num[p]--;
return;
}
int mid = l + r >> 1;
if (x <= mid)
update(l, mid, x, y, p << 1);
else
update(mid + 1, r, x, y, p << 1 | 1);
tr[p] = tr[p << 1] + tr[p << 1 | 1];
num[p] = num[p << 1] + num[p << 1 | 1];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
b[i] = a[i].v;
}
sort(b + 1, b + 1 + n);
m = unique(b + 1, b + 1 + n) - b - 1;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
int x = lsh(a[i].v);
sum[x] += a[i].x;
cnt[x]++;
}
build(1, m, 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int x = lsh(a[i].v);
update(1, m, x, a[i].x, 1);
pair<long long, int> t = query(1, m, x, m, 1);
ans += t.first - (long long)a[i].x * t.second;
}
printf("%lld", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
class BIT {
private:
vector<T> dat;
int n;
public:
BIT(int _n) : dat(_n + 1), n(_n) {}
T sum(int i) {
T s = 0;
while (i > 0) s += dat[i], i -= i & -i;
return s;
}
T sum(int l, int r) { return l > r ? 0 : sum(r) - sum(l - 1); }
void add(int i, T x) {
while (i <= n) dat[i] += x, i += i & -i;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<pair<int64_t, int64_t>> P(N);
for (auto &p : P) cin >> p.second;
for (auto &p : P) cin >> p.first;
sort(P.begin(), P.end());
vector<int> vs;
for (auto &p : P) vs.push_back(p.first);
P[0].first = 1;
for (int i = 1; i < N; ++i) {
P[i].first = P[i - 1].first + (vs[i - 1] != vs[i]);
}
for (auto &p : P) swap(p.first, p.second);
sort(P.begin(), P.end(), greater<pair<int, int>>());
int64_t ans = 0LL;
BIT<int64_t> bit(N), cnt(N);
for (auto &p : P) {
int x, v;
tie(x, v) = p;
ans += bit.sum(v, N) - x * cnt.sum(v, N);
bit.add(v, x);
cnt.add(v, 1);
}
cout << ans << '\n';
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
long long bit[200005][2];
void update(int x, long long val) {
for (int i = x; i <= n; i += (i & -i)) bit[i][0] += val;
for (int i = x; i <= n; i += (i & -i)) bit[i][1] += 1;
}
pair<long long, long long> query(int x) {
long long ret1 = 0;
long long ret2 = 0;
for (int i = x; i > 0; i -= (i & -i)) ret1 += bit[i][0];
for (int i = x; i > 0; i -= (i & -i)) ret2 += bit[i][1];
return {ret1, ret2};
}
int main() {
cin >> n;
vector<long long> vel, tmp;
vector<pair<long long, int> > pos;
map<long long, int> mp;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
pos.push_back({x, i});
}
sort(pos.begin(), pos.end());
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
vel.push_back(x);
tmp.push_back(x);
}
sort(tmp.begin(), tmp.end());
for (int i = 0; i < n; i++) {
mp[tmp[i]] = i + 1;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
int posnow = pos[i].second;
long long xnow = pos[i].first;
int now = mp[vel[posnow]];
pair<long long, long long> q = query(now);
long long val = xnow * q.second - q.first;
ans += val;
update(now, xnow);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
set<int> st;
set<int>::iterator it;
pair<int, int> arr[200005];
pair<long long, long long> tree[4 * 200005];
void update(int node, int b, int e, int i, long long v) {
if (b > i || e < i) return;
if (b == e && b == i) {
tree[node].first += v;
tree[node].second++;
return;
}
int left = 2 * node, right = left + 1, mid = (b + e) / 2;
update(left, b, mid, i, v);
update(right, mid + 1, e, i, v);
tree[node].first = tree[left].first + tree[right].first;
tree[node].second = tree[left].second + tree[right].second;
}
pair<long long, long long> query(int node, int b, int e, int l, int r) {
if (b > r || e < l) return make_pair(0ll, 0ll);
if (b >= l && e <= r) return tree[node];
int left = 2 * node, right = left + 1, mid = (b + e) / 2;
pair<long long, long long> ret;
pair<long long, long long> p = query(left, b, mid, l, r);
pair<long long, long long> q = query(right, mid + 1, e, l, r);
ret.first = p.first + q.first;
ret.second = p.second + q.second;
return ret;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &arr[i].first);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i].second);
st.insert(arr[i].second);
}
int N = 1;
for (it = st.begin(); it != st.end(); it++) {
mp[*it] = ++N;
}
for (int i = 1; i <= n; i++) arr[i].second = mp[arr[i].second];
sort(arr + 1, arr + n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
pair<long long, long long> z = query(1, 1, N, 1, arr[i].second);
long long p = ((long long)arr[i].first) * z.second;
p -= z.first;
ans += p;
update(1, 1, N, arr[i].second, arr[i].first);
}
cout << ans << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct node {
int loc, v;
} a[200010];
int n, m, b[200010];
long long c[200010], e[200010];
int cmp(node a, node b) { return a.loc < b.loc; }
int lowbit(int x) { return x & -x; }
void update(int pos, int delta, long long *d) {
for (int i = pos; i <= n; i += lowbit(i)) d[i] += delta;
}
long long sum(int pos, long long *d) {
long long ret = 0;
for (int i = pos; i > 0; i -= lowbit(i)) ret += d[i];
return ret;
}
int main() {
int i;
long long ans = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i].loc);
for (i = 1; i <= n; i++) scanf("%d", &a[i].v), b[i] = a[i].v;
sort(b + 1, b + 1 + n);
m = unique(b + 1, b + 1 + n) - (b + 1);
for (i = 1; i <= n; i++) a[i].v = lower_bound(b + 1, b + 1 + m, a[i].v) - b;
sort(a + 1, a + 1 + n, cmp);
for (i = 1; i <= n; i++) {
ans += abs(sum(a[i].v, e) - sum(a[i].v, c) * a[i].loc);
update(a[i].v, 1, c), update(a[i].v, a[i].loc, e);
}
printf("%lld\n", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
void dout() { cerr << '\n'; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << " " << H;
dout(T...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 7;
int n, m, cnt[N];
long long sum[N];
pair<int, int> p[N];
void upd(int x, int y) {
for (; x <= m; x |= (x + 1)) {
cnt[x]++;
sum[x] += y;
}
}
int getnum(int x) {
int res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += cnt[x];
}
return res;
}
long long getsum(int x) {
long long res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += sum[x];
}
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
cin >> n;
vector<int> vec, v;
for (int i = 1; i <= n; i++) {
cin >> p[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> p[i].second;
vec.push_back(p[i].second);
}
sort((vec).begin(), (vec).end());
m = unique((vec).begin(), (vec).end()) - vec.begin();
for (int i = 1; i <= n; i++) {
p[i].second = lower_bound(vec.begin(), vec.begin() + m, p[i].second) -
vec.begin() + 1;
}
sort(p + 1, p + n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += (long long)getnum(p[i].second) * p[i].first - getsum(p[i].second);
upd(p[i].second, p[i].first);
}
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const int MAX = 2e5 + 10;
vector<pair<int, int>> v(MAX);
vector<int> spdv(MAX), compress(MAX);
long long n, bit[2][MAX];
void poe(int a, long long x, long long p) {
for (; p <= n; p += p & -p) bit[a][p] += x;
}
long long pref(int a, long long p) {
long long ret = 0;
for (; p; p -= p & -p) ret += bit[a][p];
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> v[i].first;
v[i].second = i;
}
for (int i = 0; i < n; i++) {
cin >> spdv[i];
compress[i] = spdv[i];
}
sort(v.begin(), v.begin() + n);
sort(compress.begin(), compress.begin() + n);
map<int, int> newidx;
for (int i = 0; i < n; i++) newidx[compress[i]] = i;
long long ans = 0;
for (int i = 0; i < n; i++) {
int pos = newidx[spdv[v[i].second]] + 1;
ans += v[i].first * pref(0, pos) - pref(1, pos);
poe(0, 1, pos);
poe(1, v[i].first, pos);
}
cout << ans << '\n';
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long ts[(int)8e5 + 10], tc[(int)8e5 + 10], n;
pair<long long, long long> o[(int)2e5 + 10];
void update(long long i, long long v, long long t = 1, long long nl = 1,
long long nr = n) {
if (i < nl || nr < i) return;
if (nl == nr) {
ts[t] += v;
tc[t] += 1;
return;
}
long long mid = nl + nr >> 1;
update(i, v, t * 2, nl, mid);
update(i, v, t * 2 + 1, mid + 1, nr);
ts[t] = ts[t * 2] + ts[t * 2 + 1];
tc[t] = tc[t * 2] + tc[t * 2 + 1];
}
long long ans = 0;
void get(long long x, long long ql, long long qr = n, long long t = 1,
long long nl = 1, long long nr = n) {
if (nr < ql || qr < nl) return;
if (ql <= nl && nr <= qr) {
ans += ts[t] - x * tc[t];
return;
}
long long mid = nl + nr >> 1;
get(x, ql, qr, t * 2, nl, mid);
get(x, ql, qr, t * 2 + 1, mid + 1, nr);
}
int main(void) {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &o[i].second);
}
for (long long i = 1; i <= n; i++) {
scanf("%lld", &o[i].first);
}
sort(o + 1, o + 1 + n);
for (long long i = 1; i <= n; i++) {
o[i].first = i;
swap(o[i].first, o[i].second);
}
sort(o + 1, o + 1 + n);
for (long long i = n; 0 < i; i--) {
long long idx = o[i].first, v = o[i].second;
get(idx, v);
update(v, idx);
}
printf("%lld\n", ans);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
long long gcd(long long a, long long b) {
for (; b; a %= b, swap(a, b))
;
return a;
}
const int N = 200002;
pair<long long, long long> segTree[N * 4];
vector<long long> vIdx;
void update(int ptr, int s, int e, int i, pair<long long, long long> val) {
if (i < s || e < i) return;
if (s == e) {
segTree[ptr].first += val.first;
segTree[ptr].second += val.second;
return;
}
update(ptr * 2, s, (s + e) / 2, i, val);
update(ptr * 2 + 1, (s + e) / 2 + 1, e, i, val);
segTree[ptr].first = segTree[ptr * 2].first + segTree[ptr * 2 + 1].first;
segTree[ptr].second = segTree[ptr * 2].second + segTree[ptr * 2 + 1].second;
}
pair<long long, long long> getVal(int ptr, int s, int e, int l, int r) {
if (r < s || e < l) return {0, 0};
if (l <= s && e <= r) return segTree[ptr];
pair<long long, long long> r1 = getVal(ptr * 2, s, (s + e) / 2, l, r);
pair<long long, long long> r2 = getVal(ptr * 2 + 1, (s + e) / 2 + 1, e, l, r);
return {r1.first + r2.first, r1.second + r2.second};
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<pair<long long, long long> > a(n);
for (int i = 0; i < n; i++) cin >> a[i].first;
for (int i = 0; i < n; i++) {
cin >> a[i].second;
vIdx.push_back(a[i].second);
}
sort(a.begin(), a.end());
sort(vIdx.begin(), vIdx.end());
vIdx.erase(unique(vIdx.begin(), vIdx.end()), vIdx.end());
for (int i = 0; i < n; i++) {
int idx = lower_bound(vIdx.begin(), vIdx.end(), a[i].second) - vIdx.begin();
a[i].second = idx;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
pair<long long, long long> res =
getVal(1, 0, vIdx.size() - 1, 0, a[i].second);
long long cnt = res.first, x_total = res.second;
ans += a[i].first * cnt - x_total;
update(1, 0, vIdx.size() - 1, a[i].second, {1, a[i].first});
}
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
void setmax(T& a, T b) {
a = max(a, b);
};
template <typename T>
void setmin(T& a, T b) {
a = min(a, b);
};
template <typename T>
bool in(T v, T lo, T hi) {
return lo <= v && v <= hi;
};
const int N = 2e5 + 10;
int n;
long long fena[N], fenb[N];
void add(long long* first, int i, long long delta) {
for (int j = i; j < N; j += j & -j) {
first[j] += delta;
}
}
long long sum(long long* first, int i) {
long long res = 0;
for (int j = i; j; j -= j & -j) {
res += first[j];
}
return res;
}
struct FastCoordinateCompression {
vector<int> a;
void add(int x) { a.push_back(x); }
void compress() {
sort(a.begin(), a.end());
a.resize(unique(a.begin(), a.end()) - a.begin());
}
int operator[](int x) {
return lower_bound(a.begin(), a.end(), x) - a.begin() + 1;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<pair<int, int>> xv(n);
for (auto& [x, v] : xv) {
cin >> x;
}
for (auto& [x, v] : xv) {
cin >> v;
}
FastCoordinateCompression compr;
for (auto& [x, v] : xv) {
compr.add(x);
}
compr.compress();
sort(xv.begin(), xv.end(), [&](pair<int, int>& a, pair<int, int>& b) {
if (a.second != b.second) return a.second < b.second;
return a.first < b.first;
});
long long ans = 0;
for (auto& [x, v] : xv) {
long long num = sum(fena, compr[x]);
long long tot = sum(fenb, compr[x]);
ans += x * num - tot;
add(fena, compr[x], 1);
add(fenb, compr[x], x);
}
cout << ans << '\n';
return 0;
}
| 12 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.