text
stringlengths 49
983k
|
|---|
#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;
}
|
#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;
}
|
#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();
}
}
|
#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;
}
|
#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;
}
|
#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";
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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';
}
|
#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";
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, bit1[200050], bit2[200050];
vector<pair<long long int, long long int> > arr(200050);
map<long long int, long long int> mp;
long long int get1(int idx) {
long long int ans = 0;
while (idx > 0) {
ans += bit1[idx];
idx -= (idx & -idx);
}
return ans;
}
long long int get2(int idx) {
long long int ans = 0;
while (idx > 0) {
ans += bit2[idx];
idx -= (idx & -idx);
}
return ans;
}
void update1(int idx, int inc) {
while (idx <= n) {
bit1[idx] += inc;
idx += (idx & -idx);
}
}
void update2(int idx, int inc) {
while (idx <= n) {
bit2[idx] += inc;
idx += (idx & -idx);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
arr.resize(n);
for (int i = 0; i < n; i++) cin >> arr[i].first;
for (int i = 0; i < n; i++) cin >> arr[i].second;
sort(arr.begin(), arr.end());
vector<long long int> v;
for (auto a : arr) v.push_back(a.second);
sort(v.begin(), v.end());
int p = 1;
for (auto x : v) mp[x] = p++;
long long int ans = 0;
for (int i = 0; i < n; i++) {
long long int cnt = get1(mp[arr[i].second]);
long long int sum = get2(mp[arr[i].second]);
ans += cnt * arr[i].first - sum;
update1(mp[arr[i].second], 1);
update2(mp[arr[i].second], arr[i].first);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
pair<int, int> p[N];
long long sum[N];
long long ans = 0;
int n;
pair<long long, long long> tree[N];
inline int lowbit(int x) { return x & (-x); }
void update(int x, int v) {
while (x <= n) {
tree[x].first++;
tree[x].second += v;
x += lowbit(x);
}
}
pair<long long, long long> ask(int x) {
pair<long long, long long> res;
res.first = res.second = 0;
while (x) {
res.first += tree[x].first;
res.second += tree[x].second;
x -= lowbit(x);
}
return res;
}
int x[N];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> p[i].first;
for (int i = 0; i < n; i++) cin >> p[i].second, x[i] = p[i].second;
sort(x, x + n);
sort(p, p + n);
for (int i = 0; i < n; i++)
p[i].second = lower_bound(x, x + n, p[i].second) - x + 1;
for (int i = 0; i < n; i++) {
pair<long long, long long> pai = ask(p[i].second);
ans += pai.first * p[i].first - pai.second;
update(p[i].second, p[i].first);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937_64 mt_rnd_64(chrono::steady_clock::now().time_since_epoch().count());
long long rnd(long long l, long long r) {
return (mt_rnd_64() % (r - l + 1)) + l;
}
using ll = long long;
using ld = long double;
using ull = unsigned long long;
const double PI = acos(-1.0);
const ll mod = 1e9 + 7;
const ll INF = 1e17;
ll n;
unordered_map<ll, ll> q;
void add(ll pos, ll val, vector<ll> &t) {
while (pos < n) {
t[pos] += val;
pos = (pos | (pos + 1));
}
}
ll sum(ll pos, vector<ll> &t) {
ll ans = 0;
while (pos >= 0) {
ans += t[pos];
pos = (pos & (pos + 1)) - 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << setprecision(10) << fixed;
cin >> n;
vector<pair<ll, ll> > x(n);
for (ll i = 0; i < n; ++i) {
cin >> x[i].first;
x[i].second = i;
}
vector<ll> v(n);
set<ll> SET;
for (ll i = 0; i < n; ++i) {
cin >> v[i];
SET.insert(v[i]);
}
ll c = 0;
for (ll i : SET) {
q[i] = c;
++c;
}
vector<ll> t(n * 2, 0), t1(n * 2, 0);
sort(begin(x), end(x));
ll ans = 0;
for (ll i = 0; i < n; ++i) {
ans += sum(q[v[x[i].second]], t) * x[i].first - sum(q[v[x[i].second]], t1);
add(q[v[x[i].second]], 1, t);
add(q[v[x[i].second]], x[i].first, t1);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
pair<long long, long long> a[200001];
long long cnt[200001], sum[200001];
void update(long long x, long long val) {
for (; x <= 200000; x += x & (-x)) {
cnt[x]++;
sum[x] += val;
}
}
long long query(long long x, long long val) {
long long ans = 0;
for (; x > 0; x -= x & (-x)) ans += (cnt[x] * val - sum[x]);
return ans;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i].first;
vector<pair<long long, long long> > val;
for (long long i = 1; i <= n; i++) cin >> a[i].second;
sort(a + 1, a + 1 + n);
for (long long i = 1; i <= n; i++)
val.push_back(pair<long long, long long>(a[i].second, i));
sort(val.begin(), val.end());
long long pre = -1e9, top = 0;
for (long long i = 0; i < val.size(); i++) {
if (val[i].first != pre) {
pre = val[i].first;
top++;
}
a[val[i].second].second = top;
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans += query(a[i].second, a[i].first);
update(a[i].second, a[i].first);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> t[2 * 200004];
vector<long long> tpre[2 * 200004];
long long ans = 0;
int cntlo = 0, cnthi = 0;
void build(int n) {
for (int i = n - 1; i > 0; i--)
merge(t[i << 1].begin(), t[i << 1].end(), t[i << 1 | 1].begin(),
t[i << 1 | 1].end(), back_inserter(t[i]));
}
void buildpre(int n) {
for (int i = 1, up = 2 * n; i < up; i++) {
int sz = (int)t[i].size() + 1;
tpre[i].resize(sz);
for (int j = sz - 2; j >= 0; j--) {
tpre[i][j] = tpre[i][j + 1] + t[i][j].second;
}
}
}
void queryhi(int n, int l, int r, long long v) {
l += n;
r += n;
while (l < r) {
if (l & 1) {
int dist = lower_bound(t[l].begin(), t[l].end(),
pair<long long, long long>(v, 1ll * INT_MIN)) -
t[l].begin();
if (dist > (int)t[l].size()) dist = (int)t[l].size();
cnthi += (t[l].size() - dist);
ans += tpre[l][dist];
l++;
}
if (r & 1) {
int dist = lower_bound(t[r - 1].begin(), t[r - 1].end(),
pair<long long, long long>(v, 1ll * INT_MIN)) -
t[r - 1].begin();
if (dist > (int)t[r - 1].size()) dist = (int)t[r - 1].size();
cnthi += (t[r - 1].size() - dist);
ans += tpre[r - 1][dist];
r--;
}
l >>= 1;
r >>= 1;
}
}
void querylo(int n, int l, int r, long long v) {
l += n;
r += n;
while (l < r) {
if (l & 1) {
int dist = upper_bound(t[l].begin(), t[l].end(),
pair<long long, long long>(v, 1ll * INT_MAX)) -
t[l].begin();
if (dist > (int)t[l].size()) dist = (int)t[l].size();
cntlo += dist;
ans -= (tpre[l][0] - tpre[l][dist]);
l++;
}
if (r & 1) {
int dist = upper_bound(t[r - 1].begin(), t[r - 1].end(),
pair<long long, long long>(v, 1ll * INT_MAX)) -
t[r - 1].begin();
if (dist > (int)t[r - 1].size()) dist = (int)t[r - 1].size();
cntlo += dist;
ans -= (tpre[r - 1][0] - tpre[r - 1][dist]);
r--;
}
l >>= 1;
r >>= 1;
}
}
int v[200004];
long long x[200004];
pair<long long, long long> xv[200004];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld", &x[i]);
for (int i = 0; i < n; i++) scanf("%d", &v[i]);
for (int i = 0; i < n; i++)
xv[i] = pair<long long, long long>(x[i], 1ll * v[i]);
sort(xv, xv + n);
for (int i = n, up = n << 1; i < up; i++)
t[i] = vector<pair<long long, long long>>(
{pair<long long, long long>(xv[i - n].second, xv[i - n].first)});
build(n);
buildpre(n);
long long res = 0;
for (int i = 0; i < n; i++) {
ans = 0;
cntlo = cnthi = 0;
queryhi(n, i + 1, n, xv[i].second);
querylo(n, 0, i, xv[i].second);
res += ans;
res += (1ll * (cntlo - cnthi) * xv[i].first);
}
cout << res / 2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n;
long long ans = 0;
vector<long long> T1(N, 0), T2(N, 0);
pair<int, int> a[N];
vector<int> b;
void update(vector<long long>& T, int x, long long v) {
for (; x <= (int)b.size(); x += (x & (-x))) T[x] += v;
}
long long get(const vector<long long>& T, int x) {
long long res = 0;
for (; x; x -= (x & (-x))) res += T[x];
return res;
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n;
for (int i = (0); i < (n); i++) cin >> a[i].first;
for (int i = (0); i < (n); i++) {
cin >> a[i].second;
b.push_back(a[i].second);
}
sort(a, a + n);
sort(b.begin(), b.end());
b.resize(unique(b.begin(), b.end()) - b.begin());
int vt = lower_bound(b.begin(), b.end(), a[0].second) - b.begin() + 1;
update(T1, vt, 1ll * a[0].first);
update(T2, vt, 1);
for (int i = (1); i < (n); i++) {
vt = lower_bound(b.begin(), b.end(), a[i].second) - b.begin() + 1;
ans += get(T2, vt) * a[i].first - get(T1, vt);
update(T1, vt, 1ll * a[i].first);
update(T2, vt, 1);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005;
long long n;
pair<long long, long long> x[N];
long long ans;
struct seg {
long long vals[2 * N];
long long q(long long l, long long r) {
long long ret = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) ret += vals[l++];
if (r & 1) ret += vals[--r];
}
return ret;
}
void inc(long long i, long long v) {
i += n;
vals[i] += v;
while (i > 1) {
vals[i >> 1] = vals[i] + vals[i ^ 1];
i >>= 1;
}
}
void print() {
for (long long i = 1; i < 2 * n; ++i) {
cerr << vals[i] << ' ';
}
cerr << endl;
}
} sm, ct;
bool compSecond(pair<long long, long long>& a, pair<long long, long long>& b) {
if (a.second != b.second) return a.second < b.second;
return a.first < b.first;
}
void doMapping() {
sort(x, x + n, compSecond);
for (long long i = 0; i < n; ++i) {
x[i].second = i;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> 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;
}
doMapping();
sort(x, x + n);
for (long long i = 0; i < n; ++i) {
long long pt = x[i].first;
long long cur = x[i].second;
long long cur_sum = sm.q(0, cur), cur_ct = ct.q(0, cur);
ans += pt * cur_ct - cur_sum;
sm.inc(cur, pt);
ct.inc(cur, 1);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct seg {
vector<long long> tree;
int n;
seg(int n) {
tree = vector<long long>(n);
for (int i = 0; i < n; i++) tree[i] = 0;
}
void update(int node, int l, int r, int x, int y) {
if (l > r) return;
if (x > r || x < l) return;
if (l == x && r == x) {
tree[node] += y;
return;
}
update(2 * node + 1, l, (l + r) / 2, x, y);
update(2 * node + 2, (l + r) / 2 + 1, r, x, y);
tree[node] = tree[2 * node + 1] + tree[2 * node + 2];
}
long long get(int node, int l, int r, int x, int y) {
if (x > y) return 0;
if (l > r) return 0;
if (x > r || y < l) return 0;
if (l >= x && r <= y) return tree[node];
return get(2 * node + 1, l, (l + r) / 2, x, y) +
get(2 * node + 2, (l + r) / 2 + 1, r, x, y);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<long long> x(n), v(n);
for (int i = 0; i < n; i++) {
cin >> x[i];
}
set<int> D;
vector<int> Z;
for (int i = 0; i < n; i++) {
cin >> v[i];
if (D.count(v[i]) == 0) Z.push_back(v[i]);
D.insert(v[i]);
}
sort(Z.begin(), Z.end());
map<int, int> dp;
for (int i = 0; i < Z.size(); i++) {
dp[Z[i]] = i;
}
for (int i = 0; i < n; i++) {
v[i] = dp[v[i]];
}
vector<pair<int, int>> S;
seg t1(3 * 2000000), t2(3 * 2000000);
for (int i = 0; i < n; i++) {
S.push_back(make_pair(x[i], v[i]));
}
sort(S.begin(), S.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
long long x1 = t1.get(0, 0, 2000000 - 1, 0, S[i].second);
long long x2 = t2.get(0, 0, 2000000 - 1, 0, S[i].second);
ans += (S[i].first * x1 - x2);
t1.update(0, 0, 2000000 - 1, S[i].second, 1);
t2.update(0, 0, 2000000 - 1, S[i].second, S[i].first);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n;
long long ans;
pair<long long, long long> a[N];
bool cmp(pair<long long, long long> x, pair<long long, long long> y) {
if (x.second != y.second) {
return x.second < y.second;
} else {
return x.first < y.first;
}
}
vector<long long> segmenttree[4 * N], segmenttree2[4 * N];
void build(int id, int l, int r) {
if (l == r) {
segmenttree[id] = {a[l].first};
segmenttree2[id] = {a[l].first};
return;
}
int mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
merge(segmenttree[id << 1].begin(), segmenttree[id << 1].end(),
segmenttree[id << 1 | 1].begin(), segmenttree[id << 1 | 1].end(),
back_inserter(segmenttree[id]));
segmenttree2[id].resize(r - l + 1);
segmenttree2[id][r - l] = segmenttree[id][r - l];
for (int i = r - l - 1; i >= 0; i--) {
segmenttree2[id][i] = segmenttree2[id][i + 1] + segmenttree[id][i];
}
}
long long get(int id, int l, int r, int u, int v, long long val) {
if (v < l || r < u) {
return 0;
}
if (u <= l && r <= v) {
long long idx =
lower_bound(segmenttree[id].begin(), segmenttree[id].end(), val) -
segmenttree[id].begin();
if (idx == r - l + 1) {
return 0;
} else {
return segmenttree2[id][idx] - (r - l + 1 - idx) * val;
}
}
int mid = (l + r) >> 1;
return get(id << 1, l, mid, u, v, val) +
get(id << 1 | 1, mid + 1, r, u, v, val);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.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;
}
sort(a + 1, a + 1 + n, cmp);
build(1, 1, n);
for (int i = 1; i < n; i++) {
ans += get(1, 1, n, i + 1, n, a[i].first);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v;
vector<long long> v1;
long long a[200005], b[200005], c[200005], d[200005], n, m;
map<long long, long long> mp;
long long get(long long f[], long long pos) {
long long res = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) res += f[pos];
return res;
}
void upd(long long f[], long long pos, long long val) {
for (; pos < m; pos |= pos + 1) f[pos] += val;
}
int main() {
long long i;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
for (i = 0; i < n; i++) {
v.push_back({a[i], b[i]});
if (!mp[b[i]]) v1.push_back(b[i]);
mp[b[i]] = 1;
}
sort(v.begin(), v.end());
sort(v1.begin(), v1.end());
m = v1.size();
long long s = 0;
for (auto x : v) {
long long y = lower_bound(v1.begin(), v1.end(), x.second) - v1.begin();
s += get(c, y) * x.first - get(d, y);
upd(c, y, 1);
upd(d, y, x.first);
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const int MOD = 1000000007;
const long long INFLL = 1e18;
const int INF = 1e9;
const int NMAX = 2e5 + 5;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int n;
array<int, 2> a[NMAX];
struct BIT {
long long aib[NMAX];
void update(int pos, int val) {
for (int i = pos + 1; i <= n; i += (i & (-i))) {
aib[i] += val;
}
}
long long query(int pos) {
long long sum = 0;
for (int i = pos; i >= 1; i -= (i & (-i))) {
sum += aib[i];
}
return sum;
}
} f0, f1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i][0];
}
vector<int> v;
for (int i = 0; i < n; ++i) {
cin >> a[i][1];
v.push_back(a[i][1]);
}
long long ans = 0;
sort(v.begin(), v.end());
sort(a, a + n);
for (int i = 0; i < n; ++i) {
int pos = lower_bound(v.begin(), v.end(), a[i][1]) - v.begin();
ans += f0.query(pos + 1) * a[i][0] - f1.query(pos + 1);
f0.update(pos, 1);
f1.update(pos, a[i][0]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[8] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy[8] = {1, -1, -1, 0, 1, -1, 0, 1};
long long bit[1000005], bit1[1000005];
long long sum(long long x) {
long long s = 0;
while (x > 0) {
s += bit[x];
x -= (x & (-x));
}
return s;
}
void update(long long x, long long val) {
while (x < 1000005) {
bit[x] += val;
x += (x & (-x));
}
}
long long cnt(long long x) {
long long s = 0;
while (x > 0) {
s += bit1[x];
x -= (x & (-x));
}
return s;
}
void updatecnt(long long x) {
while (x < 1000005) {
bit1[x] += 1;
x += (x & (-x));
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long pos[n + 1], vel[n + 1];
vector<long long> v;
map<long long, long long> h, h1;
for (long long i = 1; i < n + 1; i++) cin >> pos[i];
for (long long i = 1; i < n + 1; i++) {
cin >> vel[i];
if (!h[vel[i]]) v.push_back(vel[i]);
h[vel[i]] = 1;
}
v.push_back(-1000000000);
sort(v.begin(), v.end());
for (long long i = 1; i < v.size(); i++) {
if (!h1[v[i]]) h1[v[i]] = i;
}
vector<pair<long long, long long> > v1;
for (long long i = 1; i < n + 1; i++) {
vel[i] = h1[vel[i]];
v1.push_back({pos[i], vel[i]});
}
sort(v1.begin(), v1.end());
long long ans = 0;
for (long long i = 0; i < v1.size(); i++) {
long long s = sum(v1[i].second);
long long c = cnt(v1[i].second);
ans += c * v1[i].first - s;
update(v1[i].second, v1[i].first);
updatecnt(v1[i].second);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool test_cases_exist = false;
class FenwickTree {
public:
vector<long long int> tree;
long long int n;
FenwickTree(long long int n) {
this->n = n;
tree.resize(n + 5);
}
void update(long long int ind, long long int delta) {
while (ind <= n) {
tree[ind] += delta;
ind += ind & -ind;
}
}
long long int query(long long int ind) {
long long int res = 0;
while (ind >= 1) {
res += tree[ind];
ind -= ind & -ind;
}
return res;
}
};
void solve() {
long long int n;
cin >> n;
vector<pair<long long int, long long int>> pnt(n);
for (auto &z : pnt) cin >> z.first;
for (auto &z : pnt) cin >> z.second;
vector<long long int> speed;
for (auto &z : pnt) speed.push_back(z.second);
sort(pnt.begin(), pnt.end());
sort(speed.begin(), speed.end());
long long int ans = 0;
vector<FenwickTree> ft(2, {n});
for (auto z : pnt) {
int pos = lower_bound(speed.begin(), speed.end(), z.second) - speed.begin();
ans += ft[0].query(pos + 1) * z.first;
ans -= ft[1].query(pos + 1);
ft[0].update(pos + 1, 1);
ft[1].update(pos + 1, z.first);
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
if (test_cases_exist) cin >> t;
while (t--) solve();
}
|
#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(int 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 > 0; 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(a + 1, a + 1 + n);
sort(b + 1, b + 1 + n);
m = unique(b + 1, b + 1 + n) - b - 1;
long long ans = 0;
for (int i = 1; i <= n; i++) {
int x = lsh(a[i].v);
ans += query(x, 0) * a[i].x - query(x, 1);
update(x, a[i].x);
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 1000;
pair<long long, long long> p[maxn];
vector<long long> v;
int getpos(long long V) {
return lower_bound(v.begin(), v.end(), V) - v.begin() + 1;
}
long long C1[2][maxn];
long long C2[2][maxn];
void add(int x, long long K, long long C[][maxn], int flag) {
while (0 < x && x < maxn) {
C[0][x] += 1;
C[1][x] += K;
if (flag == -1)
x += (x) & (-x);
else
x -= (x) & (-x);
}
}
pair<long long, long long> getsum(int x, long long C[][maxn], int flag) {
long long sum = 0;
int num = 0;
while (0 < x && x < maxn) {
num += C[0][x];
sum += C[1][x];
if (flag == -1)
x -= (x) & (-x);
else
x += (x) & (-x);
}
return pair<long long, long long>(num, sum);
}
int main() {
ios::sync_with_stdio(false);
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.push_back(abs(p[i].second));
sort(p + 1, p + 1 + N);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
long long ans = 0;
long long cnt2 = 0;
long long cnts2 = 0;
for (int i = 1; i <= N; i++) {
if (p[i].second >= 0) {
pair<long long, long long> s = getsum(getpos(p[i].second), C1, -1);
ans += p[i].first * s.first - s.second;
add(getpos(p[i].second), p[i].first, C1, -1);
ans += p[i].first * cnt2 - cnts2;
} else {
pair<long long, long long> s = getsum(getpos(-p[i].second), C2, 1);
ans += p[i].first * s.first - s.second;
add(getpos(-p[i].second), p[i].first, C2, 1);
cnt2 += 1;
cnts2 += p[i].first;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Scanner {
bool hasNext = 1;
bool hasRead = 1;
int nextInt() {
hasRead = 0;
int res = 0;
char flag = 1, ch = getchar();
while (ch != EOF && !isdigit(ch)) {
hasRead = 1;
flag = (ch == '-') ? -flag : flag;
ch = getchar();
}
while (ch != EOF && isdigit(ch)) {
hasRead = 1;
res = res * 10 + (ch - '0');
ch = getchar();
}
if (ch == EOF) hasNext = 0;
return res * flag;
}
long long nextLL() {
hasRead = 0;
long long res = 0;
char flag = 1, ch = getchar();
while (ch != EOF && !isdigit(ch)) {
hasRead = 1;
flag = (ch == '-') ? -flag : flag;
ch = getchar();
}
while (ch != EOF && isdigit(ch)) {
hasRead = 1;
res = res * 10 + (ch - '0');
ch = getchar();
}
if (ch == EOF) hasNext = 0;
return res * flag;
}
char nextChar() {
hasRead = 0;
char ch = getchar();
while (ch != EOF && isspace(ch)) {
hasRead = 1;
ch = getchar();
}
if (ch == EOF) hasNext = 0;
return ch;
}
int nextString(char *str) {
hasRead = 0;
int len = 0;
char ch = getchar();
while (ch != EOF && isspace(ch)) {
hasRead = 1;
ch = getchar();
}
while (ch != EOF && !isspace(ch)) {
hasRead = 1;
str[++len] = ch;
ch = getchar();
}
str[len + 1] = 0;
if (ch == EOF) hasNext = 0;
return len;
}
} sc;
long long rd() {
long long x = sc.nextLL();
return x;
}
void rd(int &x) { x = sc.nextInt(); }
void rd(long long &x) { x = sc.nextLL(); }
void rd(char &x) { x = sc.nextChar(); }
void rd(char *x) { sc.nextString(x); }
template <typename T1, typename T2>
void rd(pair<T1, T2> &x) {
rd(x.first);
rd(x.second);
}
template <typename T>
void rd(T *x, int n) {
for (int i = 1; i <= n; ++i) rd(x[i]);
}
void printInt(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) printInt(x / 10);
putchar('0' + x % 10);
}
void printLL(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) printLL(x / 10);
putchar('0' + x % 10);
}
void pr(int x, char ch = '\n') {
printInt(x);
putchar(ch);
}
void pr(long long x, char ch = '\n') {
printLL(x);
putchar(ch);
}
template <typename T1, typename T2>
void pr(pair<T1, T2> x, char ch = '\n') {
pr(x.first, ' ');
pr(x.second, ch);
}
template <typename T>
void pr(T *x, int n) {
for (int i = 1; i <= n; ++i) pr(x[i], " \n"[i == n]);
}
template <typename T>
void pr(vector<T> &x) {
int n = x.size();
for (int i = 1; i <= n; ++i) pr(x[i - 1], " \n"[i == n]);
}
template <typename T>
void cmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
void cmax(T &x, T y) {
if (y > x) x = y;
}
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1.0);
const double EPS = 1e-9;
const int MOD = 1000000007;
int n;
int x[200005];
int v[200005];
pair<int, int> p[200005];
struct Treap {
static const int MAXN = 200000 + 10;
int top, root, ch[MAXN][2], rnd[MAXN];
pair<int, long long> val[MAXN];
long long sum[MAXN];
int NewNode(pair<int, long long> v) {
int id = ++top;
ch[id][0] = 0, ch[id][1] = 0, rnd[id] = rand();
val[id] = v;
sum[id] = 1LL * v.second;
return id;
}
void PushUp(int id) {
sum[id] = sum[ch[id][0]] + sum[ch[id][1]] + 1LL * val[id].second;
}
void Rotate(int &id, int d) {
int tmp = ch[id][d ^ 1];
ch[id][d ^ 1] = ch[tmp][d];
ch[tmp][d] = id, id = tmp;
PushUp(ch[id][d]), PushUp(id);
}
void InsertHelp(int &id, pair<int, long long> v) {
if (!id) {
id = NewNode(v);
return;
}
if (v.first == val[id].first)
val[id].second += v.second;
else {
int d = val[id].first > v.first ? 0 : 1;
InsertHelp(ch[id][d], v);
if (rnd[id] < rnd[ch[id][d]]) Rotate(id, d ^ 1);
}
PushUp(id);
}
void Init() { top = 0, root = 0; }
void Insert(pair<int, int> v) { InsertHelp(root, v); }
long long GetSumValue(int v) {
int id = root;
long long res = 0;
while (id) {
if (val[id].first > v)
id = ch[id][0];
else if (val[id].first == v) {
res += sum[ch[id][0]] + 1LL * val[id].second;
break;
} else {
res += sum[ch[id][0]] + 1LL * val[id].second;
id = ch[id][1];
}
}
return res;
}
} treap1, treap2;
struct Solver {
void InitOnce() {}
void Read() {
rd(n);
rd(x, n);
rd(v, n);
for (int i = 1; i <= n; ++i) {
p[i].first = x[i];
p[i].second = v[i];
}
}
void Solve() {
treap1.Init();
treap2.Init();
sort(p + 1, p + 1 + n);
long long sum = 0;
for (int i = 1; i <= n; ++i) {
sum += treap2.GetSumValue(p[i].second) * p[i].first;
sum -= treap1.GetSumValue(p[i].second);
treap1.Insert({p[i].second, p[i].first});
treap2.Insert({p[i].second, 1});
}
pr(sum);
}
} solver;
int main() {
solver.InitOnce();
int t = 1;
t = INF;
while (t--) {
solver.Read();
if (!sc.hasRead) break;
solver.Solve();
if (!sc.hasNext) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using pr = pair<T, T>;
const int mod = 1e9 + 7;
struct SegTree {
vector<pr<long long>> segtree;
long long N;
SegTree(long long n) {
N = 1;
while (N < n) N <<= 1;
segtree = vector<pr<long long>>(2 * N);
}
void modify(long long k, long long x) {
k += N;
segtree[k].second += x;
segtree[k].first += 1;
for (k /= 2; k > 0; k /= 2) {
segtree[k].first = segtree[k * 2].first + segtree[k * 2 + 1].first;
segtree[k].second = segtree[k * 2].second + segtree[k * 2 + 1].second;
}
}
pr<long long> query(long long b) {
long long a = 0;
long long ansx = 0, ansy = 0;
for (a += N, b += N; a <= b; a /= 2, b /= 2) {
if (a % 2 == 1) ansx += segtree[a].first, ansy += segtree[a++].second;
if (b % 2 == 0) ansx += segtree[b].first, ansy += segtree[b--].second;
}
return make_pair(ansx, ansy);
}
};
void solve() {
long long n;
cin >> n;
vector<pr<long long>> xv(n);
vector<long long> v(n);
for (signed i = 0; i < n; ++i) cin >> xv[i].first;
for (signed i = 0; i < n; ++i) cin >> xv[i].second, v[i] = xv[i].second;
sort((xv).begin(), (xv).end());
sort((v).begin(), (v).end());
map<long long, int> cmp;
for (signed i = 0; i < n; ++i) cmp[v[i]] = i;
long long ans = 0;
SegTree x(n);
x.modify(cmp[xv[0].second], xv[0].first);
for (signed i = 1; i < n; ++i) {
pr<long long> qa = x.query(cmp[xv[i].second]);
ans += qa.first * xv[i].first - qa.second;
x.modify(cmp[xv[i].second], xv[i].first);
}
cout << ans << endl;
}
signed main() {
signed t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct BIT {
int n;
vector<T> bit;
BIT(int n_ = 0) : n(n_), bit(n_ + 1) {}
T sum(int i) {
T ans = 0;
for (; i > 0; i -= i & -i) ans += bit[i];
return ans;
}
void add(int i, T a) {
if (i == 0) return;
for (; i <= n; i += i & -i) bit[i] += a;
}
int lower_bound(T k) {
if (k <= 0) return 0;
int ret = 0, i = 1;
while ((i << 1) <= n) i <<= 1;
for (; i; i >>= 1)
if (ret + i <= n && bit[ret + i] < k) k -= bit[ret += i];
return ret + 1;
}
};
int N;
int main() {
scanf("%d", &N);
vector<int> X(N);
vector<pair<int, int> > vs(N);
for (int i = 0; i < N; i++) {
scanf("%d", &X[i]);
}
for (int i = 0; i < N; i++) {
scanf("%d", &vs[i].first);
vs[i].second = X[i];
}
sort(X.begin(), X.end());
sort(vs.begin(), vs.end());
reverse(vs.begin(), vs.end());
BIT<long long> P(N);
BIT<int> cnt(N);
long long ans = 0;
for (pair<int, int> p : vs) {
int v = p.first, x = p.second;
int id = lower_bound(X.begin(), X.end(), x) - X.begin() + 1;
ans += P.sum(N) - P.sum(id) - (long long)x * (cnt.sum(N) - cnt.sum(id));
cnt.add(id, 1);
P.add(id, x);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct FTDown {
long long ft[N + 5];
FTDown() {
for (int i = 1; i <= N; i++) ft[i] = 0;
}
void update(int p, long long v) {
for (; p <= N; p += (p & -p)) ft[p] += v;
}
long long get(int p) {
long long sum = 0;
for (; p; p -= (p & -p)) sum += ft[p];
return sum;
}
};
int n, b[N];
pair<int, int> a[N];
FTDown sumXDown, cntDown;
int main() {
ios_base::sync_with_stdio(0);
cin.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;
b[i] = a[i].second;
}
b[n + 1] = 0;
sort(b + 1, b + n + 2);
int m = 1;
for (int i = 2; i <= n + 1; i++)
if (b[i] != b[m]) b[++m] = b[i];
for (int i = 1; i <= n; i++)
a[i].second = lower_bound(b + 1, b + m + 1, a[i].second) - b;
sort(a + 1, a + n + 1);
int ind0 = lower_bound(b + 1, b + m + 1, 0) - b;
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long cnt = cntDown.get(a[i].second);
long long sumX = sumXDown.get(a[i].second);
ans += cnt * a[i].first - sumX;
cntDown.update(a[i].second, 1);
sumXDown.update(a[i].second, a[i].first);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 1000;
const long long M = 1e5 + 10;
const long long inf = 1e9 + 7;
const long long Mod = 1e9 + 7;
const double eps = 1e-6;
int T;
pair<int, int> a[N];
int b[N];
int n;
pair<long long, long long> sg[4 * N];
void build(int k, int l, int r) {
if (l == r) {
sg[k].first = 0;
sg[k].second = 0;
return;
}
build(2 * k, l, (l + r) / 2);
build(2 * k + 1, (l + r) / 2 + 1, r);
}
void up(int k) {
sg[k].first = sg[2 * k].first + sg[2 * k + 1].first;
sg[k].second = sg[2 * k].second + sg[2 * k + 1].second;
}
void modify(int k, int l, int r, int pos, int val) {
if (l == r) {
sg[k].first += val;
sg[k].second++;
return;
}
if (pos <= (l + r) / 2)
modify(2 * k, l, (l + r) / 2, pos, val);
else if (pos > (l + r) / 2)
modify(2 * k + 1, (l + r) / 2 + 1, r, pos, val);
up(k);
}
pair<long long, long long> query(int k, int l, int r, int L, int R) {
if (L <= l && r <= R) return sg[k];
pair<long long, long long> res{0, 0};
pair<long long, long long> cur;
if (L <= (l + r) / 2) {
cur = query(2 * k, l, (l + r) / 2, L, R);
res.first += cur.first;
res.second += cur.second;
};
if (R > (l + r) / 2) {
cur = query(2 * k + 1, (l + r) / 2 + 1, r, L, R);
res.first += cur.first;
res.second += cur.second;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].first);
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].second);
b[i] = a[i].second;
}
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
int len = unique(b + 1, b + n + 1) - b - 1;
build(1, 1, len);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int id = lower_bound(b + 1, b + len + 1, a[i].second) - b;
pair<long long, long long> cur = query(1, 1, n, 1, id);
ans -= cur.first - cur.second * a[i].first;
modify(1, 1, n, id, a[i].first);
}
printf("%lld", ans);
return 0;
}
|
#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 = 0; i < n; i++) {
long long r = o[i].second, idx = o[i].first;
long long s = 0, c = 0;
while (0 < r) {
s += ts[r];
c += tc[r];
r -= (r & -r);
}
ans += idx * c - s;
long long v = o[i].second;
while (v <= n) {
ts[v] += idx;
tc[v]++;
v += (v & -v);
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, T;
long long cnt[200010], sum[200010];
pair<int, int> a[200010];
long long getval(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(long long f[], int pos, int val) {
pos++;
for (int i = pos; i <= n; 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());
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;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int maxn = 2e5 + 10;
inline int lowbit(int x) { return x & (-x); }
struct point {
int x, v;
} p[maxn];
int v[maxn];
long long c1[maxn], c2[maxn];
bool comp(point a, point b) { return a.x < b.x; }
long long getnum(long long c[], int i) {
long long res = 0LL;
while (i > 0) {
res += c[i];
i -= lowbit(i);
}
return res;
}
void update(int i, int value) {
while (i <= n) {
c1[i]++;
c2[i] += value;
i += lowbit(i);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i].x);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i].v);
v[i] = p[i].v;
}
sort(p + 1, p + n + 1, comp);
sort(v + 1, v + n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int pos = lower_bound(v + 1, v + 1 + n, p[i].v) - v;
ans += getnum(c1, pos) * p[i].x - getnum(c2, pos);
update(pos, p[i].x);
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long st[800001], st2[800001];
vector<long long> vx[200001], idxs[200001];
long long getMid(long long s, long long e) { return s + (e - s) / 2; }
long long SumUtil(long long* st, long long ss, long long se, long long l,
long long r, long long node) {
if (l <= ss && r >= se) return st[node];
if (se < l || ss > r) return 0ll;
long long mid = getMid(ss, se);
return SumUtil(st, ss, mid, l, r, 2 * node + 1) +
SumUtil(st, mid + 1, se, l, r, 2 * node + 2);
}
void updateValue(long long* st, long long ss, long long se, long long index,
long long value, long long node) {
if (ss == se) {
st[node] += value;
} else {
long long mid = getMid(ss, se);
if (index >= ss && index <= mid)
updateValue(st, ss, mid, index, value, 2 * node + 1);
else
updateValue(st, mid + 1, se, index, value, 2 * node + 2);
st[node] = st[2 * node + 1] + st[2 * node + 2];
}
return;
}
long long getSum(long long* st, long long n, long long l, long long r) {
if (l < 0 || r > n - 1 || l > r) {
return 0;
}
return SumUtil(st, 0, n - 1, l, r, 0);
}
void solve() {
set<long long> stt;
stt.clear();
long long n, i, j, k, x[200001], v[200001];
for (i = 0; i < 800001; i++) st[i] = st2[i] = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x[i];
}
for (i = 0; i < n; i++) {
cin >> v[i];
stt.insert(v[i]);
}
vector<long long> temp_vec;
temp_vec.clear();
for (auto xx : stt) temp_vec.push_back(xx);
long long velos = temp_vec.size();
for (i = 0; i < velos; i++) {
vx[i].clear();
idxs[i].clear();
}
for (i = 0; i < n; i++) {
long long sta = 0, ed = velos - 1, md;
while (sta <= ed) {
md = sta + (ed - sta) / 2;
if (temp_vec[md] == v[i]) break;
if (temp_vec[md] < v[i])
sta = md + 1;
else
ed = md - 1;
}
vx[md].push_back(x[i]);
}
for (i = 0; i < velos; i++) sort(vx[i].begin(), vx[i].end());
vector<pair<long long, long long> > temp_vec_2;
temp_vec_2.clear();
for (i = 0; i < velos; i++) {
for (auto xx : vx[i]) {
temp_vec_2.push_back({xx, i});
}
}
sort(temp_vec_2.begin(), temp_vec_2.end());
i = 0;
for (auto xx : temp_vec_2) {
idxs[xx.second].push_back(i);
i++;
}
long long ans = 0;
for (i = 0; i < velos; i++) {
for (auto xx : vx[i]) {
long long sta = 0, ed = temp_vec_2.size(), md;
ed--;
while (sta <= ed) {
md = ed + (sta - ed) / 2;
if (temp_vec_2[md].first == xx) break;
if (temp_vec_2[md].first < xx)
sta = md + 1;
else
ed = md - 1;
}
ans += (getSum(st2, n, 0, md)) * xx - getSum(st, n, 0, md);
}
for (auto xx : idxs[i]) {
updateValue(st, 0, n - 1, xx, temp_vec_2[xx].first, 0);
updateValue(st2, 0, n - 1, xx, 1, 0);
}
}
for (i = 0; i < velos; i++) {
long long p = 0, m = vx[i].size();
m--;
for (auto xx : vx[i]) {
ans += (p - m) * xx;
p++;
m--;
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <class Ch, class Tr, class Container>
basic_ostream<Ch, Tr>& operator<<(basic_ostream<Ch, Tr>& os,
Container const& x) {
os << "{ ";
for (auto& y : x) os << y << " ";
return os << "}";
}
template <class X, class Y>
ostream& operator<<(ostream& os, pair<X, Y> const& p) {
return os << "[ " << p.first << ", " << p.second << "]";
}
typedef struct {
long long pos, v;
} Point;
long long P[200005], V[200005], sum = 0, maxNeg = 0;
long long l = 0, r = 100000000;
int n;
vector<Point> v;
set<long long> usados;
map<long long, long long> DondeEsta;
bool sort_vel(Point a, Point b) {
if (a.v == b.v) return a.pos > b.pos;
return a.v > b.v;
}
bool sort_pos(Point a, Point b) { return a.pos < b.pos; }
long long ft[200005];
long long ft2[200005];
void upd(int i0, long long v) {
for (int i = i0 + 1; i <= 200005; i += i & -i) ft[i] += v;
}
long long get(int i0) {
long long r = 0;
for (int i = i0; i; i -= i & -i) r += ft[i];
return r;
}
long long get_sum(int i0, int i1) { return get(i1) - get(i0); }
void upd2(int i0, long long v) {
for (int i = i0 + 1; i <= 200005; i += i & -i) ft2[i] += v;
}
long long get2(int i0) {
long long r = 0;
for (int i = i0; i; i -= i & -i) r += ft2[i];
return r;
}
long long get_sum2(int i0, int i1) { return get2(i1) - get2(i0); }
int main() {
cin >> n;
for (int i = 0; i < (n); i++) cin >> P[i];
for (int i = 0; i < (n); i++) {
cin >> V[i];
v.push_back({P[i], V[i]});
}
sort((v.begin()), (v.end()), sort_pos);
for (int i = 0; i < (n); i++) {
upd(i, r - v[i].pos);
upd2(i, 1);
}
for (int i = 0; i < (n); i++) DondeEsta[v[i].pos] = i;
sort((v.begin()), (v.end()), sort_vel);
for (auto x : v) {
long long i = DondeEsta[x.pos];
sum += get_sum(0, i) - ((r - x.pos) * get_sum2(0, i));
upd(i, x.pos - r);
upd2(i, -1);
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > mtree, msum, mpos;
void merge_sort(vector<pair<long long, long long> >& arr, long long l,
long long h, long long id) {
long long m = (l + h) / 2;
if (l == h) {
mtree[id].push_back(arr[l].second);
msum[id].push_back(arr[l].first);
mpos[id].push_back(l);
return;
}
merge_sort(arr, l, m, 2 * id);
merge_sort(arr, m + 1, h, 2 * id + 1);
long long i = 0, j = 0;
while (i < mtree[2 * id].size() && j < mtree[2 * id + 1].size()) {
if (mtree[2 * id][i] < mtree[2 * id + 1][j]) {
mtree[id].push_back(mtree[2 * id][i]);
mpos[id].push_back(mpos[2 * id][i]);
if (!msum[id].empty())
msum[id].push_back(msum[id].back() + arr[mpos[2 * id][i]].first);
else
msum[id].push_back(arr[mpos[2 * id][i]].first);
i++;
} else {
mtree[id].push_back(mtree[2 * id + 1][j]);
mpos[id].push_back(mpos[2 * id + 1][j]);
if (!msum[id].empty())
msum[id].push_back(msum[id].back() + arr[mpos[2 * id + 1][j]].first);
else
msum[id].push_back(arr[mpos[2 * id + 1][j]].first);
j++;
}
}
while (i < mtree[2 * id].size()) {
mtree[id].push_back(mtree[2 * id][i]);
mpos[id].push_back(mpos[2 * id][i]);
if (!msum[id].empty())
msum[id].push_back(msum[id].back() + arr[mpos[2 * id][i]].first);
else
msum[id].push_back(arr[mpos[2 * id][i]].first);
i++;
}
while (j < mtree[2 * id + 1].size()) {
mtree[id].push_back(mtree[2 * id + 1][j]);
mpos[id].push_back(mpos[2 * id + 1][j]);
if (!msum[id].empty())
msum[id].push_back(msum[id].back() + arr[mpos[2 * id + 1][j]].first);
else
msum[id].push_back(arr[mpos[2 * id + 1][j]].first);
j++;
}
}
long long solve(long long s, long long e, long long l, long long h,
long long id, long long x, long long v) {
long long m = (s + e) / 2;
if (s == l && e == h) {
long long p =
lower_bound(mtree[id].begin(), mtree[id].end(), v) - mtree[id].begin();
long long a = msum[id].back();
if (p != 0) a -= msum[id][p - 1];
return a - x * (mtree[id].size() - p);
} else if (l > h)
return 0;
long long r1 = solve(s, m, l, min(h, m), 2 * id, x, v);
long long r2 = solve(m + 1, e, max(m + 1, l), h, 2 * id + 1, x, v);
return r1 + r2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n;
cin >> n;
mtree.resize(4 * n);
msum.resize(4 * n);
mpos.resize(4 * n);
vector<pair<long long, long long> > arr(n);
for (long long i = 0; i < n; i++) cin >> arr[i].first;
for (long long i = 0; i < n; i++) cin >> arr[i].second;
sort(arr.begin(), arr.end());
merge_sort(arr, 0, n - 1, 1);
long long ans = 0;
for (long long i = 0; i < n - 1; i++)
ans += solve(0, n - 1, i + 1, n - 1, 1, arr[i].first, arr[i].second);
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int b[200005], cnt[200005], num[800005], m;
long long sum[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;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
void update(vector<long long>& v, long long ind, long long val) {
ind++;
long long n = v.size();
while (ind <= n) {
v[ind] += val;
ind += ((ind) & (-ind));
}
}
long long query(vector<long long>& v, long long ind) {
ind++;
long long res = 0;
while (ind > 0) {
res += v[ind];
ind -= ((ind) & (-ind));
}
return res;
}
void solve() {
long long n;
cin >> n;
vector<pair<long long, long long>> points(n);
for (long long i = 0; i < n; i++) cin >> points[i].first;
vector<long long> vel;
for (long long i = 0; i < n; i++) {
cin >> points[i].second;
vel.push_back(points[i].second);
}
sort((vel).begin(), (vel).end());
sort((points).begin(), (points).end());
vel.resize(unique((vel).begin(), (vel).end()) - vel.begin());
vector<long long> no(vel.size() + 1, 0), csum(vel.size() + 1, 0);
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long v_new =
lower_bound(vel.begin(), vel.end(), points[i].second) - vel.begin();
ans += -(query(csum, v_new)) + (points[i].first * query(no, v_new));
update(csum, v_new, points[i].first);
update(no, v_new, 1);
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, long long> a[200005];
int t[200005];
map<int, int> M;
pair<int, long long> f[200005];
int n;
void update(int gt) {
int x = M[gt];
while (x <= n) {
f[x] = {f[x].first + 1, f[x].second + gt};
x += (x & -x);
}
}
pair<int, long long> get(int x) {
int cnt = 0;
long long sum = 0;
while (x >= 1) {
cnt += f[x].first;
sum += f[x].second;
x -= (x & -x);
}
return make_pair(cnt, sum);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].second;
t[i] = a[i].second;
}
for (int i = 1; i <= n; i++) cin >> a[i].first;
sort(a + 1, a + n + 1);
sort(t + 1, t + n + 1);
for (int i = 1; i <= n; i++) M[t[i]] = i;
long long ans = 0;
for (int i = 1; i <= n; i++) {
pair<int, long long> res;
res = get(M[a[i].second] - 1);
ans += (1ll * a[i].second * res.first - res.second);
update(a[i].second);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <class T>
void mxi(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void mni(T& a, const T& b) {
a = min(a, b);
}
long double EPS = 1e-9;
mt19937 RNG(chrono::steady_clock::now().time_since_epoch().count());
struct node {
long long sum, cnt;
node() {
sum = 0;
cnt = 0;
}
};
node t[4 * 200200];
node merge(node a, node b) {
node tmp;
tmp.sum = a.sum + b.sum;
tmp.cnt = a.cnt + b.cnt;
return tmp;
}
void upd(long long id, long long l, long long r, long long pos, long long val) {
if (pos < l || pos > r)
return;
else if (l == r) {
t[id].sum += val;
t[id].cnt++;
return;
}
upd(id << 1, l, ((l + r) >> 1), pos, val);
upd(id << 1 | 1, ((l + r) >> 1) + 1, r, pos, val);
t[id] = merge(t[id << 1], t[id << 1 | 1]);
}
node query(long long id, long long l, long long r, long long lq, long long rq) {
if (lq > r || l > rq)
return node();
else if (lq <= l && rq >= r)
return t[id];
return merge(query(id << 1, l, ((l + r) >> 1), lq, rq),
query(id << 1 | 1, ((l + r) >> 1) + 1, r, lq, rq));
}
void solve() {
long long n;
cin >> n;
vector<pair<long long, long long> > v;
for (long long i = 0; i < (n); i++) {
long long x;
cin >> x;
v.push_back({x, 0});
}
set<long long> vel;
for (long long j = 0; j < (n); j++) {
long long w;
cin >> w;
vel.insert(w);
v[j].second = w;
}
sort((v).begin(), (v).end());
map<long long, long long> mp;
long long cnt = 0;
for (auto x : vel) {
mp[x] = cnt++;
}
long long an = 0;
for (long long i = n - 1; ~i; i--) {
node ans = query(1, 0, 200010, mp[v[i].second], 200010);
long long cc = ans.cnt;
an += (ans.sum - cc * v[i].first);
upd(1, 0, 200010, mp[v[i].second], v[i].first);
}
cout << an << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, tab;
t = 1;
tab = t;
while (t--) {
solve();
}
cerr << ((double)clock() / CLOCKS_PER_SEC);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const long long INF = 1e18;
const int maxn = 1e6 + 6;
const int mod = 1e9 + 7;
const double eps = 1e-9;
inline bool read(long long &num) {
char in;
bool IsN = false;
in = getchar();
if (in == EOF) return false;
while (in != '-' && (in < '0' || in > '9')) in = getchar();
if (in == '-') {
IsN = true;
num = 0;
} else
num = in - '0';
while (in = getchar(), in >= '0' && in <= '9') {
num *= 10, num += in - '0';
}
if (IsN) num = -num;
return true;
}
long long n, m;
struct node {
int x, v;
bool friend operator<(node a, node b) { return a.x < b.x; }
} save[maxn];
vector<int> v;
long long a[maxn], b[maxn];
int nn;
void update(long long *p, int pos, long long x) {
while (pos <= nn) {
p[pos] += x;
pos += pos & -pos;
}
}
long long GetSum(long long *p, long long x) {
long long ans = 0;
while (x > 0) {
ans += p[x];
x -= x & -x;
}
return ans;
}
int getid(long long x) {
return lower_bound(v.begin(), v.end(), x) - v.begin() + 1;
}
int main() {
read(n);
for (int i = 1; i <= n; i++) scanf("%d", &save[i].x);
for (int i = 1; i <= n; i++) {
scanf("%d", &save[i].v);
v.push_back(save[i].v);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
nn = v.size();
sort(save + 1, save + 1 + n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int id = getid(save[i].v);
long long tempx = GetSum(b, id);
long long tempy = GetSum(a, id);
ans += tempx * save[i].x - tempy;
update(b, id, 1);
update(a, id, save[i].x);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long Bit[N][2], n;
long long get(long long i, long long k) {
long long ans = 0;
for (i; i > 0; i -= i & (-i)) {
ans += Bit[i][k];
}
return ans;
}
void update(long long i, long long val, long long k) {
for (i; i <= n; i += i & (-i)) {
Bit[i][k] += val;
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
long long k, i, t, j, m, x, y, z, c = 0, ans = 0;
cin >> n;
vector<pair<long long, long long> > v(n), v1(n);
for (i = 0; i < n; i++) cin >> v[i].first;
for (i = 0; i < n; i++) cin >> v[i].second;
sort((v).begin(), (v).end());
vector<long long> v0(n);
map<long long, long long> mp;
c = 1;
for (i = 0; i < n; i++) {
v1[i].first = v[i].second;
v1[i].second = i;
}
sort((v1).begin(), (v1).end());
for (i = 0; i < n; i++) {
if (mp[v1[i].first] == 0) {
mp[v1[i].first] = c;
c++;
}
v0[v1[i].second] = mp[v1[i].first];
}
for (i = 0; i < n; i++) {
x = get(v0[i], 0);
y = get(v0[i], 1);
ans += x * v[i].first - y;
update(v0[i], 1, 0);
update(v0[i], v[i].first, 1);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t INF = (int64_t)(2e18);
const int64_t inf = (int64_t)(1e9 + 7);
struct stree {
vector<int64_t> t;
int64_t n = 1;
stree() {}
stree(int64_t nn) {
while (n < nn) n *= 2;
t.assign(2 * n, 0);
}
void set(int64_t i, int64_t x) {
t[i += n] += x;
for (i /= 2; i; i /= 2) t[i] = t[i + i] + t[i + i + 1];
}
int64_t get(int64_t l, int64_t r) {
int64_t res = 0;
for (l += n, r += n; l <= r; l /= 2, r /= 2) {
if (l & 1) res += t[l++];
if (~r & 1) res += t[r--];
}
return res;
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
cin.tie(nullptr);
int64_t n;
cin >> n;
vector<int64_t> x(n);
for (auto& it : x) cin >> it;
vector<int64_t> v(n);
for (auto& it : v) cin >> it;
vector<int64_t> vs;
for (auto& it : v) vs.push_back(it);
sort((vs).begin(), (vs).end());
vs.resize(unique((vs).begin(), (vs).end()) - begin(vs));
for (auto& it : v) it = lower_bound((vs).begin(), (vs).end(), it) - begin(vs);
vector<pair<int64_t, int64_t>> pts(n);
for (int64_t i = 0; i < n; ++i) {
pts[i].first = x[i];
pts[i].second = v[i];
}
sort((pts).begin(), (pts).end());
stree ls(vs.size());
stree lc(vs.size());
stree rs(vs.size());
stree rc(vs.size());
for (auto& p : pts) {
rs.set(p.second, p.first);
rc.set(p.second, 1);
}
int64_t res = 0;
for (auto& p : pts) {
rs.set(p.second, -p.first);
rc.set(p.second, -1);
res += lc.get(0, p.second) * p.first;
res -= ls.get(0, p.second);
res -= rc.get(p.second, vs.size() - 1) * p.first;
res += rs.get(p.second, vs.size() - 1);
ls.set(p.second, p.first);
lc.set(p.second, 1);
}
cout << res / 2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T& a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T& a, T b) {
return a < b ? (a = b, true) : false;
}
template <typename T>
class fenwick {
public:
vector<T> fenw;
int n;
fenwick(int _n) : n(_n) { fenw.resize(n); }
void modify(int x, T v) {
while (x < n) {
fenw[x] += v;
x |= (x + 1);
}
}
T get(int x) {
T v{};
while (x >= 0) {
v += fenw[x];
x = (x & (x + 1)) - 1;
}
return v;
}
};
const int nax = 2e5 + 10;
int N;
vector<int> v;
vector<pair<int, int>> P;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
P.resize(N);
v.resize(N);
fenwick<long long> sum_tree(N), count_tree(N);
for (int i = 0; i < N; ++i) {
cin >> P[i].first;
}
for (int i = 0; i < N; ++i) {
cin >> P[i].second;
v[i] = P[i].second;
}
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
sort(P.begin(), P.end());
long long total = 0;
for (int i = 0; i < N; ++i) {
int id = lower_bound(v.begin(), v.end(), P[i].second) - v.begin();
long long count = count_tree.get(id);
long long sum = sum_tree.get(id);
total += count * 1LL * P[i].first - sum;
count_tree.modify(id, 1);
sum_tree.modify(id, P[i].first);
}
cout << total << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Monoid>
struct SegmentTree {
typedef function<Monoid(Monoid, Monoid)> F;
int n;
F f;
Monoid id;
vector<Monoid> dat;
SegmentTree(int n_, F f, Monoid id) : f(f), id(id) { init(n_); }
void init(int n_) {
n = 1;
while (n < n_) n <<= 1;
dat.assign(n << 1, id);
}
void build(const vector<Monoid> &v) {
for (int i = 0; i < v.size(); ++i) dat[i + n] = v[i];
for (int i = n - 1; i; --i) dat[i] = f(dat[i << 1 | 0], dat[i << 1 | 1]);
}
void update(int k, Monoid x) {
dat[k += n] = x;
while (k >>= 1) dat[k] = f(dat[k << 1 | 0], dat[k << 1 | 1]);
}
Monoid query(int a, int b) {
if (a >= b) return id;
Monoid vl = id, vr = id;
for (int l = a + n, r = b + n; l < r; l >>= 1, r >>= 1) {
if (l & 1) vl = f(vl, dat[l++]);
if (r & 1) vr = f(dat[--r], vr);
}
return f(vl, vr);
}
Monoid operator[](int i) { return dat[i + n]; }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<long long> x(n), v(n);
for (int i = 0; i < n; ++i) cin >> x[i];
for (int i = 0; i < n; ++i) cin >> v[i];
vector<long long> compress(n);
for (int i = 0; i < n; ++i) compress[i] = v[i];
sort(compress.begin(), compress.end());
compress.erase(unique(compress.begin(), compress.end()), compress.end());
for (int i = 0; i < n; ++i)
v[i] =
lower_bound(compress.begin(), compress.end(), v[i]) - compress.begin();
int m = compress.size();
auto f = [](pair<long long, long long> a, pair<long long, long long> b) {
return pair<long long, long long>{a.first + b.first, a.second + b.second};
};
SegmentTree<pair<long long, long long> > seg(m, f, {0, 0});
vector<pair<long long, long long> > xv;
for (int i = 0; i < n; ++i) xv.emplace_back(x[i], v[i]);
sort(xv.begin(), xv.end());
for (int i = 0; i < n; ++i) {
auto p = seg[xv[i].second];
seg.update(xv[i].second, {p.first + xv[i].first, p.second + 1});
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
auto p = seg.query(xv[i].second, m), q = seg[xv[i].second];
ans += p.first - xv[i].first * p.second;
seg.update(xv[i].second, {q.first - xv[i].first, q.second - 1});
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 3;
const int maxm = 1e6 + 3;
const int mod = 1e9 + 7;
const int oo = 1e9 + 5;
const long double pi = 3.141592653589793238462643383279502884;
void input() {
if (fopen("abc"
".inp",
"r")) {
freopen(
"abc"
".inp",
"r", stdin);
freopen(
"abc"
".out",
"w", stdout);
}
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int n;
pair<long long, long long> a[maxn], f[maxn];
vector<long long> v;
pair<long long, long long> operator+(const pair<long long, long long>& a,
const pair<long long, long long>& b) {
return {a.first + b.first, a.second + b.second};
}
void update(int p, int v) {
for (int i = p; i <= n; i += i & -i)
f[i] = f[i] + pair<long long, long long>(v, 1);
}
pair<long long, long long> get(int p) {
pair<long long, long long> ans = {0, 0};
for (int i = p; i > 0; i -= i & -i) ans = ans + f[i];
return ans;
}
int main() {
input();
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i].first;
for (int i = 1; i <= n; ++i) {
cin >> a[i].second;
v.push_back(a[i].second);
}
sort(a + 1, a + 1 + n);
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
long long ans = 0;
for (int i = 1; i <= n; ++i) {
auto it = lower_bound(v.begin(), v.end(), a[i].second) - v.begin() + 1;
pair<long long, long long> cur = get(it);
ans += a[i].first * cur.second - cur.first;
update(it, a[i].first);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll ftget(vector<ll> &ft, ll idx) {
ll ans = 0;
while (idx > 0) {
ans += ft[idx];
idx -= (idx & (-idx));
}
return ans;
}
void ftput(vector<ll> &ft, ll idx, ll value) {
while (idx < ft.size()) {
ft[idx] += value;
idx += (idx & (-idx));
}
}
void run() {
ll n;
cin >> n;
vector<pair<ll, ll>> data;
vector<ll> vx, vv;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
vx.push_back(x);
}
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
vv.push_back(x);
data.emplace_back(vx[i], x);
}
vx.clear();
vx.shrink_to_fit();
sort(vv.begin(), vv.end());
map<ll, ll> comp;
for (int i = 0; i < n; ++i) {
comp[vv[i]] = i + 1;
}
vv.clear();
vv.shrink_to_fit();
for (auto &x : data) {
x.second = comp[x.second];
}
comp.clear();
vector<ll> ftdist(n + 10, 0);
vector<ll> ftcnt(n + 10, 0);
ll ans = 0;
sort(data.begin(), data.end());
for (auto pt : data) {
ll prevno = ftget(ftcnt, pt.second);
ll prevdst = ftget(ftdist, pt.second);
ans += prevno * pt.first - prevdst;
ftput(ftcnt, pt.second, 1);
ftput(ftdist, pt.second, pt.first);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e18, M = 1e9 + 7;
const long long int N = 2e5 + 10;
vector<pair<long long int, long long int> > tree(4 * N, make_pair(0, 0));
map<long long int, long long int> mp;
pair<long long int, long long int> combine(
pair<long long int, long long int> a,
pair<long long int, long long int> b) {
pair<long long int, long long int> z;
z.first = a.first + b.first;
z.second = a.second + b.second;
return z;
}
void update(long long int node, long long int start, long long int en,
long long int idx, long long int val) {
if (start == en) {
tree[node].first += val;
tree[node].second++;
return;
}
long long int mid = (start + en) / 2;
if (start <= idx and idx <= mid)
update(2 * node, start, mid, idx, val);
else
update(2 * node + 1, mid + 1, en, idx, val);
tree[node] = combine(tree[2 * node], tree[2 * node + 1]);
}
pair<long long int, long long int> query(long long int node,
long long int start, long long int en,
long long int l, long long int r) {
if (r < start || en < l) return {0, 0};
if (l <= start && en <= r) return tree[node];
long long int mid = (start + en) / 2;
pair<long long int, long long int> q1 = query(2 * node, start, mid, l, r);
pair<long long int, long long int> q2 =
query(2 * node + 1, mid + 1, en, l, r);
return combine(q1, q2);
}
void solve() {
long long int n;
cin >> n;
vector<pair<long long int, long long int> > v(n);
for (long long int i = 0; i < n; ++i) cin >> v[i].first;
for (long long int i = 0; i < n; ++i) cin >> v[i].second, mp[v[i].second];
long long int cnt = 0;
for (auto& c : mp) c.second = cnt++;
sort(v.begin(), v.end());
pair<long long int, long long int> p;
long long int ans = 0;
for (long long int i = 0; i < n; ++i) {
p = query(1, 0, n, 0, mp[v[i].second]);
ans += p.first * -1ll + v[i].first * p.second;
update(1, 0, n, mp[v[i].second], v[i].first);
}
cout << ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 200005;
int n, m, w[M];
long long ans, c[M][2];
struct node {
int x, v;
} p[M];
bool cmp(node a, node b) { return a.x < b.x; }
long long query(int x, int t) {
long long r = 0;
for (int i = x; i; i -= i & -i) r += c[i][t];
return r;
}
void upd(int x, int y) {
for (int i = x; i <= m; i += i & -i) c[i][0]++, c[i][1] += y;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i].x);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i].v);
w[i] = p[i].v;
}
sort(p + 1, p + 1 + n, cmp);
sort(w + 1, w + 1 + n);
m = unique(w + 1, w + 1 + n) - (w + 1);
for (int i = 1; i <= n; i++) {
int a = lower_bound(w + 1, w + 1 + m, p[i].v) - w;
ans += query(a, 0) * p[i].x - query(a, 1);
upd(a, p[i].x);
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, op;
pair<long long, int> tree[201000];
pair<long long, int> q[201000];
long long a[201000];
int lowbits(int x) { return x & (-x); }
void add(long long x, int pos) {
while (pos <= n) {
tree[pos].first += x;
tree[pos].second++;
pos += lowbits(pos);
}
}
pair<long long, int> getsum(int x) {
pair<long long, int> res;
while (x > 0) {
res.first += tree[x].first;
res.second += tree[x].second;
x -= lowbits(x);
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &q[i].first);
for (int i = 1; i <= n; i++) scanf("%d", &q[i].second), a[++op] = q[i].second;
sort(a + 1, a + 1 + n), sort(q + 1, q + 1 + n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int pos = lower_bound(a + 1, a + 1 + n, q[i].second) - a;
pair<long long, int> now = getsum(pos);
ans += now.second * q[i].first - now.first;
add(q[i].first, pos);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("no-stack-protector")
using namespace std;
const int inf = 1e9 + 7;
const int max_n = 2e5 + 1;
struct fenwick {
vector<int> sum;
fenwick(int n) {
sum.clear();
sum.resize(n, 0);
}
int f(int v) { return (v & (v + 1)); }
int h(int v) { return (v | (v + 1)); }
void add(int v) {
while (v < sum.size()) {
sum[v]++;
v = h(v);
}
}
int get(int r) {
int ans = 0;
while (r >= 0) {
ans += sum[r];
r = f(r) - 1;
}
return ans;
}
int get(int l, int r) { return get(r) - get(l - 1); }
};
int n;
pair<int, int> a[max_n];
int sq[max_n];
void scan() {
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);
map<int, vector<int>> temp;
for (int i = 0; i < n; i++) temp[a[i].second].emplace_back(i);
int cnt = 0;
for (auto i : temp) {
for (int j : i.second) {
sq[j] = cnt;
cnt++;
}
}
}
void solve() {
scan();
long long ans = 0;
fenwick one = fenwick(n);
for (int i = 0; i < n; i++) {
ans += (long long)one.get(sq[i]) * a[i].first;
one.add(sq[i]);
}
fenwick two = fenwick(n);
for (int i = n - 1; i >= 0; i--) {
ans -= (long long)two.get(sq[i], n - 1) * a[i].first;
two.add(sq[i]);
}
cout << ans;
}
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
solve();
}
|
#include <bits/stdc++.h>
using rmain = int;
using namespace std;
long long n;
vector<pair<long long, long long>> points;
vector<long long> v, cnt, xs;
long long LSOne(long long k) { return (k & (-k)); }
void update(vector<long long>& f, long long pos, long long val) {
for (; pos <= n; pos += LSOne(pos)) f[pos] += val;
}
long long rsq(vector<long long>& f, long long pos) {
long long sum = 0;
for (; pos; pos -= LSOne(pos)) sum += f[pos];
return sum;
}
rmain main() {
ios_base::sync_with_stdio(false);
cin >> n;
points.resize(n + 1);
v.resize(n + 1);
cnt.resize(n + 1);
xs.resize(n + 1);
for (long long i = 1; i <= n; ++i) cin >> points[i].first;
for (long long i = 1; i <= n; ++i) {
cin >> points[i].second;
v[i] = points[i].second;
}
sort(points.begin() + 1, points.begin() + n + 1);
sort(v.begin() + 1, v.begin() + n + 1);
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
long long pos =
lower_bound(v.begin() + 1, v.begin() + n + 1, points[i].second) -
v.begin();
ans += rsq(cnt, pos) * points[i].first - rsq(xs, pos);
update(cnt, pos, 1);
update(xs, pos, points[i].first);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const long long mod = 998244353;
int T, n;
struct node {
long long d, v;
friend bool operator<(node a, node b) { return a.d < b.d; }
} a[maxn];
long long c[maxn], d[maxn];
int b[maxn];
void update(int x, int y) {
for (int i = x; i <= n; i += (i & (-i))) c[i] += y, d[i]++;
}
long long query1(int x) {
long long ans = 0;
for (int i = x; i > 0; i -= (i & (-i))) ans += c[i];
return ans;
}
long long query2(int x) {
long long ans = 0;
for (int i = x; i > 0; i -= (i & (-i))) ans += d[i];
return ans;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i].d);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i].v), b[i] = a[i].v;
sort(b + 1, b + 1 + n);
int m = unique(b + 1, b + 1 + n) - b - 1;
for (int i = 1; i <= n; ++i) {
a[i].v = lower_bound(b + 1, b + 1 + m, a[i].v) - b;
}
sort(a + 1, a + 1 + n);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
ans += (query2(a[i].v) * a[i].d - query1(a[i].v));
update(a[i].v, a[i].d);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
pair<int, int> p[N];
long long cnt[N << 2], val[N << 2];
void update(int a, int b, int l, int r, int rt, int v) {
if (a <= l && b >= r) {
val[rt] += v, cnt[rt]++;
return;
}
int mid = l + r >> 1;
if (a <= mid) update(a, b, l, mid, rt << 1, v);
if (b > mid) update(a, b, mid + 1, r, rt << 1 | 1, v);
cnt[rt] = cnt[rt << 1] + cnt[rt << 1 | 1];
val[rt] = val[rt << 1] + val[rt << 1 | 1];
}
pair<long long, long long> query(int a, int b, int l, int r, int rt) {
if (a <= l && b >= r) {
return {val[rt], cnt[rt]};
}
int mid = l + r >> 1;
pair<long long, long long> ans = {0, 0}, t = {0, 0}, t2 = {0, 0};
if (a <= mid) t = query(a, b, l, mid, rt << 1);
if (b > mid) t2 = query(a, b, mid + 1, r, rt << 1 | 1);
ans.first = t.first + t2.first;
ans.second = t.second + t2.second;
return ans;
}
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() + 1;
}
long long ans = 0;
for (int i = n - 1; ~i; --i) {
update(p[i].second, p[i].second, 1, 200000, 1, p[i].first);
auto t = query(p[i].second, 200000, 1, 200000, 1);
ans += t.first - t.second * p[i].first;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct fenwick {
long long N;
vector<long long> Bit;
fenwick(long long n = 1e5) {
N = n;
n += 5;
Bit.resize(n, 0);
}
void update(long long id, long long val) {
while (id <= N) {
Bit[id] += val;
id += id & -id;
}
}
long long query(long long id) {
long long res = 0;
while (id) {
res += Bit[id];
id -= id & -id;
}
return res;
}
long long query(long long l, long long r) { return query(r) - query(l - 1); }
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n;
cin >> n;
vector<pair<long long, long long> > a(n);
for (long long i = (0); i < (n); i++) cin >> a[i].first;
for (long long i = (0); i < (n); i++) cin >> a[i].second;
sort(a.begin(), a.end());
map<long long, long long> cmp;
for (long long i = (0); i < (n); i++) cmp[a[i].second];
long long c = 1;
for (auto &i : cmp) i.second = c++;
for (long long i = (0); i < (n); i++) a[i].second = cmp[a[i].second];
fenwick f1(c + 100), f2(c + 100);
long long ans = 0;
for (long long i = (n - 1); i > (-1); i--) {
ans += f1.query(a[i].second, c + 5);
ans -= f2.query(a[i].second, c + 5) * a[i].first;
f1.update(a[i].second, a[i].first);
f2.update(a[i].second, 1);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int MOD = 1e9 + 7;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umod(T& a) {
while (a < 0) a += MOD;
a %= MOD;
return 1;
}
int n, cn, a[N], b[N], c[N];
long long T[N << 2], S[N << 2], ans;
map<int, int> mk;
pair<int, int> p[N];
void upd(int x, int val, int l, int r, int v) {
S[v]++, T[v] += val;
if (l == r) return;
if (x <= ((l + r) >> 1))
upd(x, val, l, ((l + r) >> 1), v << 1);
else
upd(x, val, ((l + r) >> 1) + 1, r, v << 1 | 1);
}
long long getT(int x, int y, int l, int r, int v) {
if (y < l || r < x) return 0LL;
if (x <= l && r <= y) return T[v];
return getT(x, y, l, ((l + r) >> 1), v << 1) +
getT(x, y, ((l + r) >> 1) + 1, r, v << 1 | 1);
}
long long getS(int x, int y, int l, int r, int v) {
if (y < l || r < x) return 0LL;
if (x <= l && r <= y) return S[v];
return getS(x, y, l, ((l + r) >> 1), v << 1) +
getS(x, y, ((l + r) >> 1) + 1, r, v << 1 | 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) scanf("%d", b + i), mk[b[i]] = 1;
for (__typeof(mk.begin()) i = (mk.begin()); i != (mk.end()); i++)
i->second = ++cn;
for (int i = 1; i <= n; i++) {
c[i] = mk[b[i]];
p[i] = {a[i], i};
}
sort(p + 1, p + n + 1);
for (int i = 1; i <= n; i++) {
long long s, t;
ans += (1LL * (s = getS(1, c[p[i].second], 1, cn, 1)) * p[i].first) -
(t = getT(1, c[p[i].second], 1, cn, 1));
upd(c[p[i].second], p[i].first, 1, cn, 1);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void FastInputOutput() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
inline int D() {
int t;
scanf("%d", &t);
return t;
}
inline long long LLD() {
long long t;
scanf("%lld", &t);
return t;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long power(long long x, long long p, long long m) {
long long res = 1;
while (p) {
if (p & 1) res = (res * x) % m;
x = ((x % m) * (x % m)) % m;
p >>= 1ll;
}
return res;
}
long double ModLog(long double base, long double x) {
return (logl(x) / logl(base));
}
int mod(int a, int m) { return (((a % m) + m) % m); }
const int N = 2e5 + 5, MOD = 998244353;
struct BIT {
int n;
vector<long long> sum;
BIT(int n) {
this->n = n;
sum.resize(n + 5);
for (int i = 1; i < n; ++i) sum[i] = 0;
}
long long get(int r) {
long long ret = 0;
while (r) {
ret += sum[r];
r -= (r & -r);
}
return ret;
}
long long get(int l, int r) { return get(r) - get(l - 1); }
void update(int l, long long x) {
while (l < n) {
sum[l] += x;
l += (l & -l);
}
}
};
int id[N], x[N], v[N];
bool cmp(int s, int f) { return x[f] > x[s]; }
void solve() {
int n = D();
for (int i = 0; i < n; ++i) {
id[i] = i;
x[i] = D();
}
vector<int> compress(n);
for (int i = 0; i < n; ++i) {
v[i] = D();
compress[i] = v[i];
}
sort(id, id + n, cmp);
sort(compress.begin(), compress.end());
compress.erase(unique(compress.begin(), compress.end()), compress.end());
for (int i = 0, idx; i < n; ++i) {
idx = id[i];
v[idx] = lower_bound(compress.begin(), compress.end(), v[idx]) -
compress.begin();
++v[idx];
}
BIT inv(n + 1), sum(n + 1);
long long ans = 0;
for (int i = 0, idx; i < n; ++i) {
idx = id[i];
long long cnt = inv.get(v[idx]);
long long curr = cnt * x[idx] - sum.get(v[idx]);
ans += curr;
inv.update(v[idx], 1);
sum.update(v[idx], x[idx]);
}
printf("%lld\n", ans);
}
int main() {
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 200001;
struct E {
int x, v, w;
bool operator<(const E &e) const { return x < e.x; }
} e[kMaxN];
struct T {
long long c, v;
} t[kMaxN];
int a[kMaxN];
int n;
long long ans;
int LowBit(int x) { return x & (-x); }
void Calc(int x) {
t[0] = {0, 0};
while (x) {
t[0].c += t[x].c;
t[0].v += t[x].v;
x -= LowBit(x);
}
}
void Add(int x, int v) {
while (x <= n) {
t[x].c++;
t[x].v += v;
x += LowBit(x);
}
}
void Dis() {
sort(a + 1, a + 1 + n, [](int i, int j) { return e[i].v < e[j].v; });
e[0].v = 1 << 31;
for (int i = 1, j = 0; i <= n; i++) {
j += e[a[i]].v != e[a[i - 1]].v;
e[a[i]].w = j;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> e[i].x;
}
for (int i = 1; i <= n; i++) {
cin >> e[i].v;
a[i] = i;
}
Dis();
sort(e + 1, e + 1 + n);
for (int i = 1; i <= n; i++) {
Calc(e[i].w);
ans += e[i].x * t[0].c - t[0].v;
Add(e[i].w, e[i].x);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200200;
int n;
long long ans, bit[2][MAXN];
pair<int, int> a[MAXN];
void compress() {
map<int, int> m;
for (int i = 1; i <= n; ++i) m[a[i].second];
int cnt = 1;
for (auto& [key, val] : m) val = cnt++;
for (int i = 1; i <= n; ++i) a[i].second = m[a[i].second];
}
void add(int b, int pos, int val) {
for (; 0 < pos && pos < MAXN; pos += pos & -pos) bit[b][pos] += val;
}
long long get(int b, int pos) {
long long ret = 0;
for (; 0 < pos && pos < MAXN; pos -= pos & -pos) ret += bit[b][pos];
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i].first);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i].second);
sort(a + 1, a + n + 1);
compress();
for (int i = 1; i <= n; ++i) {
auto [x, v] = a[i];
ans += 1LL * x * get(0, v) - get(1, v);
add(1, v, x);
add(0, v, 1);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
struct Pt {
int x, v;
bool operator<(const Pt &a) const { return x < a.x; }
};
struct BIT {
vector<long long> bit, cnt;
int n;
BIT(int sz) {
bit.resize(sz + 1);
cnt.resize(sz + 1);
n = sz;
}
void add(int x, long long v) {
while (x <= n) {
cnt[x]++;
bit[x] += v;
x += x & (-x);
}
}
pair<long long, long long> ask(int x) {
pair<long long, long long> ret(0, 0);
while (x) {
ret.first += bit[x];
ret.second += cnt[x];
x -= x & (-x);
}
return ret;
}
};
vector<int> V;
Pt arr[200005];
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i].x);
}
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i].v);
V.push_back(arr[i].v);
}
long long ans = 0;
sort(arr, arr + n);
sort(begin(V), end(V));
V.erase(unique(begin(V), end(V)), end(V));
BIT loli(V.size());
for (int i = 0; i < n; i++) {
int p = lower_bound(begin(V), end(V), arr[i].v) - begin(V) + 1;
auto val = loli.ask(p);
ans = ans + arr[i].x * val.second - val.first;
loli.add(p, arr[i].x);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1e-6;
const int INF = 0x3f3f3f3f;
const int MAXN = 200005;
int n, m;
int maps[MAXN];
long long sum[MAXN][2];
pair<long long, long long> node[MAXN];
inline long long lowbit(long long x) { return x & (-x); }
void add(long long id, long long x) {
while (id <= m) {
sum[id][0]++;
sum[id][1] += x;
id += lowbit(id);
}
}
long long query(int id, int op) {
long long ans = 0;
while (id > 0) {
ans += sum[id][op];
id -= lowbit(id);
}
return ans;
}
void Solve() {
sort(node + 1, node + n + 1);
sort(maps + 1, maps + n + 1);
m = unique(maps + 1, maps + n + 1) - (maps + 1);
long long ans = 0, id = -1;
for (int i = 1; i <= n; ++i) {
id = lower_bound(maps + 1, maps + m + 1, node[i].second) - maps;
ans += node[i].first * query(id, 0) - query(id, 1);
add(id, node[i].first);
}
cout << ans << endl;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> node[i].first;
for (int i = 1; i <= n; ++i) {
cin >> node[i].second;
maps[i] = node[i].second;
}
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF32 = 1E9;
const long long INF64 = 4E18;
const long long M = 1E9 + 7;
const double EPS = 1E-9;
const double PI = 2 * acos(0);
vector<long long> suffix_sum(1E6);
bool cmp_v(pair<long long, long long> a, pair<long long, long long> b) {
return (a.second < b.second);
}
long long solve(vector<pair<long long, long long> >& points, int start,
int end) {
if ((end - start) == 1) return 0;
int mid = (start + end) / 2;
long long d1 = solve(points, start, mid);
long long d2 = solve(points, mid, end);
sort(points.begin() + mid, points.begin() + end, cmp_v);
for (int i = end - 1; i >= mid; --i) {
suffix_sum[i] = points[i].first;
if (i != end - 1) suffix_sum[i] += suffix_sum[i + 1];
}
long long d = 0;
for (int i = start; i < mid; ++i) {
int p = lower_bound(points.begin() + mid, points.begin() + end, points[i],
cmp_v) -
points.begin();
d += suffix_sum[p];
d -= (end - p) * points[i].first;
}
return d1 + d2 + d;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<pair<long long, long long> > points(n);
for (int i = 0; i < n; ++i) {
cin >> points[i].first;
}
for (int i = 0; i < n; ++i) {
cin >> points[i].second;
}
sort(points.begin(), points.end());
cout << solve(points, 0, n) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (!y) return x;
return gcd(y, x % y);
}
const long long MOD = 1e9 + 7;
int inf = 1e9 + 7;
long long INF = 2e18 + 9;
long long power(long long x, long long y) {
long long res = 1ll;
x %= MOD;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % MOD;
y = y >> 1ll;
x = (x * x) % MOD;
}
return res;
}
long long inv(long long x) {
long long r = 1ll, t = x, k = MOD - 2ll;
while (k) {
if (k & 1ll) r = (long long)r * t % MOD;
t = (long long)t * t % MOD;
k >>= 1;
}
return r;
}
bool isPrime(long long x) {
if (x == 1) return false;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
const int nax = 5e5 + 13;
void prep() {}
void solve() {}
vector<long long> fenwick[2];
int n;
void add(int pos, long long val, int ind) {
pos++;
while (pos <= n) {
fenwick[ind][pos] += val;
pos += pos & (-pos);
}
}
long long query(int pos, int ind) {
long long res = 0;
pos++;
while (pos) {
res += fenwick[ind][pos];
pos -= pos & (-pos);
}
return res;
}
void read() {
cin >> n;
vector<pair<int, int> > xv(n);
for (int i = 0; i < n; i++) {
cin >> xv[i].first;
}
for (int i = 0; i < n; i++) {
cin >> xv[i].second;
}
vector<int> tmp;
for (int i = 0; i < n; i++) tmp.push_back(xv[i].second);
sort(tmp.begin(), tmp.end());
auto it = unique(tmp.begin(), tmp.end());
tmp.resize(distance(tmp.begin(), it));
map<int, int> M;
for (int i = 0; i < tmp.size(); i++) {
M[tmp[i]] = i;
}
for (int i = 0; i < n; i++) {
xv[i].second = M[xv[i].second];
}
sort(xv.begin(), xv.end());
int N = n;
n = tmp.size();
fenwick[0].resize(n + 1);
fenwick[1].resize(n + 1);
for (auto& el : fenwick[0]) el = 0;
for (auto& el : fenwick[1]) el = 0;
long long res = 0;
for (int i = 0; i < N; i++) {
res += xv[i].first * query(xv[i].second, 0) - query(xv[i].second, 1);
add(xv[i].second, 1, 0);
add(xv[i].second, xv[i].first, 1);
}
cout << res << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
srand(time(NULL));
int T = 1;
prep();
for (int i = 1; i <= T; i++) {
read();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int N = 2e5 + 5, mod = 998244353, M = 1e7 + 7;
const long long MAX = 5e18;
int n;
pair<int, int> a[N];
long long ans;
struct BIT {
long long s[N][2], sum[2];
void init() {
memset(s, 0, sizeof s);
sum[0] = sum[1] = 0;
}
void add(int x, int v) {
while (x < N) {
s[x][0] += v;
s[x][1]++;
x += x & -x;
}
sum[0] += v;
sum[1]++;
}
pair<long long, long long> lSum(int x) {
pair<long long, long long> c = {0, 0};
while (x) {
c.first += s[x][0];
c.second += s[x][1];
x -= x & -x;
}
return c;
}
pair<long long, long long> rSum(int x) {
pair<long long, long long> ret = lSum(x - 1);
ret.first = sum[0] - ret.first;
ret.second = sum[1] - ret.second;
return ret;
}
} p, nz;
void compress() {
map<int, int> mp[2];
set<int> s[2];
for (int i = 0; i < n; i++) {
if (a[i].second > 0)
s[0].insert(a[i].second);
else
s[1].insert(-a[i].second);
}
for (int i = 0; i < 2; i++) {
int c = 1;
for (int j : s[i]) mp[i][j] = c++;
}
for (int i = 0; i < n; i++) {
if (a[i].second > 0)
a[i].second = mp[0][a[i].second];
else
a[i].second = -mp[1][-a[i].second];
}
}
void add(pair<int, int> x) {
pair<long long, long long> s;
if (x.second > 0) {
s = p.rSum(x.second);
ans += s.first - s.second * x.first;
p.add(x.second, x.first);
} else {
x.second *= -1;
s = p.rSum(1);
ans += s.first - s.second * x.first;
s = nz.lSum(x.second);
ans += s.first - s.second * x.first;
nz.add(x.second, x.first);
}
}
int main() {
p.init();
nz.init();
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i].first);
for (int i = 0; i < n; i++) scanf("%d", &a[i].second);
sort(a, a + n);
compress();
for (int i = n - 1; i >= 0; i--) add(a[i]);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MX = 4e5 + 7;
int n;
long long c[MX][2];
int v[MX];
struct p {
int x, v;
inline bool operator<(const p& w) const { return x < w.x; }
} a[MX];
inline int lowbit(int x) { return x & -x; }
void add(int pos, long long k) {
while (pos <= n) {
c[pos][0]++;
c[pos][1] += k;
pos += lowbit(pos);
}
}
long long sum(int pos, int k) {
long long res = 0;
while (pos) {
res += c[pos][k];
pos -= lowbit(pos);
}
return res;
}
int main() {
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), v[i] = a[i].v;
sort(a + 1, a + 1 + n);
sort(v + 1, v + 1 + n);
int m = unique(v + 1, v + 1 + n) - v - 1;
long long res = 0;
for (int i = 1; i <= n; ++i) {
int pos = lower_bound(v + 1, v + 1 + m, a[i].v) - v;
res += a[i].x * sum(pos, 0) - sum(pos, 1);
add(pos, a[i].x);
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 7;
const long long INF = 1e18;
long long n, k, q, st[N][2];
pair<long long, long long> p[N];
map<long long, bool> 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;
}
void compress() {
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
cnt += (m[p[i].second] == 0);
m[p[i].second] = 1;
p[i].second = cnt;
}
}
void update(long long node, long long s, long long e, long long ind,
long long val, bool type) {
if (s == e) {
st[node][type] += val;
} else {
long long mid = s + (e - s) / 2;
if (ind <= mid) {
update(node * 2, s, mid, ind, val, type);
} else {
update(node * 2 + 1, mid + 1, e, ind, val, type);
}
st[node][type] = st[node * 2][type] + st[node * 2 + 1][type];
}
}
long long query(long long node, long long s, long long e, long long l,
long long r, bool type) {
if (s >= l && e <= r) {
return st[node][type];
}
if (s > r || e < l) {
return 0;
}
long long mid = s + (e - s) / 2;
return query(node * 2, s, mid, l, r, type) +
query(node * 2 + 1, mid + 1, e, l, r, type);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> p[i].first;
}
for (long long i = 1; i <= n; i++) {
cin >> p[i].second;
}
sort(p + 1, p + n + 1, comp);
compress();
sort(p + 1, p + n + 1);
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans += p[i].first * query(1, 1, n, 1, p[i].second, 0) -
query(1, 1, n, 1, p[i].second, 1);
update(1, 1, n, p[i].second, 1, 0);
update(1, 1, n, p[i].second, p[i].first, 1);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
struct {
int l, r;
long long sum;
long long cnt;
} A[N * 4];
pair<pair<long long, long long>, int> pt[N];
int n;
bool cmp(pair<pair<long long, long long>, int> x1,
pair<pair<long long, long long>, int> x2) {
return x1.first.first < x2.first.first;
}
bool cmp1(pair<pair<long long, long long>, int> x1,
pair<pair<long long, long long>, int> x2) {
if (x1.first.second == x2.first.second) {
return x1.first.first > x2.first.first;
}
return x1.first.second > x2.first.second;
}
void build(int rt, int l, int r) {
A[rt].l = l;
A[rt].r = r;
if (l != r) {
build(rt * 2, l, (l + r) / 2);
build(rt * 2 + 1, (l + r) / 2 + 1, r);
}
}
void update(int rt, int index, long long v) {
if (A[rt].l > index || A[rt].r < index) {
return;
}
if (A[rt].l == A[rt].r) {
A[rt].sum = v;
if (v == 0) {
A[rt].cnt = 0;
} else
A[rt].cnt = 1;
return;
} else {
update(rt * 2, index, v);
update(rt * 2 + 1, index, v);
A[rt].sum = A[rt * 2].sum + A[rt * 2 + 1].sum;
A[rt].cnt = A[rt * 2].cnt + A[rt * 2 + 1].cnt;
}
}
long long query(int rt, int l, int r) {
if (A[rt].l > r || A[rt].r < l) {
return 0;
}
if (A[rt].l >= l && A[rt].r <= r) {
return A[rt].sum;
}
return query(rt * 2, l, r) + query(rt * 2 + 1, l, r);
}
long long query2(int rt, int l, int r) {
if (A[rt].l > r || A[rt].r < l) {
return 0;
}
if (A[rt].l >= l && A[rt].r <= r) {
return A[rt].cnt;
}
return query2(rt * 2, l, r) + query2(rt * 2 + 1, l, r);
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> pt[i].first.first;
}
for (int i = 1; i <= n; i++) {
cin >> pt[i].first.second;
}
sort(pt + 1, pt + 1 + n, cmp);
build(1, 1, n);
for (int i = 1; i <= n; i++) {
pt[i].second = i;
update(1, i, pt[i].first.first);
}
sort(pt + 1, pt + 1 + n, cmp1);
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans += query2(1, 1, pt[i].second - 1) * pt[i].first.first -
query(1, 1, pt[i].second - 1);
update(1, pt[i].second, 0);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
constexpr int MAXN = 5 + 200000;
struct Bit {
ll b[MAXN];
Bit() { fill(b, b + MAXN, 0); }
void upd(int x, ll val) {
for (; x < MAXN; x += (x & -x)) b[x] += val;
}
ll query(int x) {
ll ans = 0LL;
for (; x; x -= (x & -x)) ans += b[x];
return ans;
}
};
ii a[MAXN];
namespace comp {
int v[MAXN];
void compress(ii arr[], int n, int BEG) {
for (int i = (int)0; i < (int)n; ++i) v[i] = arr[i].second;
sort(v, v + n);
int sz = unique(v, v + n) - v;
for (int i = (int)0; i < (int)n; ++i) {
arr[i].second = BEG + lower_bound(v, v + sz, arr[i].second) - v;
}
}
} // namespace comp
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
for (int i = (int)0; i < (int)n; ++i) {
cin >> a[i].first;
}
for (int i = (int)0; i < (int)n; ++i) {
cin >> a[i].second;
}
sort(a, a + n,
[](const ii& p, const ii& q) -> bool { return p.first < q.first; });
ll tot = 0LL, pre = 0LL;
for (int i = (int)0; i < (int)n; ++i) {
tot += ((1LL * i * a[i].first) - pre);
pre += a[i].first;
}
comp::compress(a, n, 1);
Bit suma, cuenta;
ll ans = 0LL;
for (int i = n - 1; i >= 0; --i) {
ans += (suma.query(a[i].second - 1) -
1LL * cuenta.query(a[i].second - 1) * a[i].first);
suma.upd(a[i].second, a[i].first);
cuenta.upd(a[i].second, 1);
}
cout << tot - ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100011;
const long long INF = (1 << 29) + 123;
const long long MOD = 1000000007;
const long double PI = 4 * atan((long double)1);
int fenw[2 * MAX_N];
int n;
void mod(int i, int v) {
while (i <= n) {
fenw[i] += v;
i += i & -i;
}
}
int query(int i) {
int sum = 0;
while (i > 0) {
sum += fenw[i];
i -= i & -i;
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<pair<int, int> > p;
int x[n], v[n];
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < n; i++) {
cin >> v[i];
p.push_back(make_pair(v[i], x[i]));
}
unordered_map<int, int> m;
int rev_map[n];
sort(x, x + n);
for (int i = 0; i < n; i++) {
m[x[i]] = i + 1;
rev_map[i] = x[i];
}
for (int i = 0; i < n; i++) {
p[i].second = m[p[i].second];
}
sort(p.begin(), p.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
int q = query(p[i].second);
ans += 1LL * q * rev_map[p[i].second - 1];
ans -=
1LL * ((n - i - 1) - (p[i].second - 1 - q)) * rev_map[p[i].second - 1];
mod(p[i].second, 1);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
struct nod {
long long x, v;
} a[maxn];
bool cmp(nod p, nod q) { return p.x < q.x; }
int L = 0, R = 2e8, rt = 0, tot = 0;
class dsegtree {
public:
struct dsegnode {
int l, r;
long long sum1, sum2;
} node[maxn * 50];
void pushup(int now) {
node[now].sum1 = node[node[now].l].sum1 + node[node[now].r].sum1;
node[now].sum2 = node[node[now].l].sum2 + node[node[now].r].sum2;
}
void update(int pos, int &now, int x, int l = L, int r = R) {
if (!now) now = ++tot;
if (l == r) {
node[now].sum1++;
node[now].sum2 += x;
return;
}
if (pos <= (l + r) / 2)
update(pos, node[now].l, x, l, (l + r) / 2);
else
update(pos, node[now].r, x, (l + r) / 2 + 1, r);
pushup(now);
}
pair<long long, long long> query(int s, int t, int now, int l = L,
int r = R) {
if (!now) return pair<long long, long long>(0, 0);
if (s <= l && r <= t)
return pair<long long, long long>(node[now].sum1, node[now].sum2);
pair<long long, long long> temp;
temp.first = temp.second = 0;
if ((l + r) / 2 >= s) {
pair<long long, long long> tmp = query(s, t, node[now].l, l, (l + r) / 2);
temp.first += tmp.first;
temp.second += tmp.second;
}
if ((l + r) / 2 + 1 <= t) {
pair<long long, long long> tmp =
query(s, t, node[now].r, (l + r) / 2 + 1, r);
temp.first += tmp.first;
temp.second += tmp.second;
}
return temp;
}
} tree;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].x;
for (int i = 1; i <= n; i++) cin >> a[i].v;
sort(a + 1, a + n + 1, cmp);
long long res = 0, m = 1e8;
for (int i = 1; i <= n; i++) {
pair<long long, long long> temp = tree.query(L, a[i].v + m, rt);
res += a[i].x * temp.first - temp.second;
tree.update(a[i].v + m, rt, a[i].x);
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5;
int N;
pair<long long, long long> A[MAXN + 10];
long long ans;
vector<long long> comp;
long long tree1[MAXN + 10];
void update1(int i, long long v) {
for (; i <= N; i += (i & -i)) tree1[i] += v;
}
long long query1(int i) {
long long ret = 0;
for (; i > 0; i -= (i & -i)) ret += tree1[i];
return ret;
}
long long tree2[MAXN + 10];
void update2(int i, long long v) {
for (; i <= N; i += (i & -i)) tree2[i] += v;
}
long long query2(int i) {
long long ret = 0;
for (; i > 0; i -= (i & -i)) ret += tree2[i];
return ret;
}
int main() {
int i, j;
scanf("%d", &N);
for (i = 1; i <= N; i++) scanf("%lld", &A[i].first);
for (i = 1; i <= N; i++)
scanf("%lld", &A[i].second), comp.push_back(A[i].second);
sort(A + 1, A + N + 1);
sort(comp.begin(), comp.end());
comp.erase(unique(comp.begin(), comp.end()), comp.end());
for (i = 1; i <= N; i++)
A[i].second =
lower_bound(comp.begin(), comp.end(), A[i].second) - comp.begin() + 1;
for (i = 1; i <= N; i++) {
ans += query2(A[i].second) * A[i].first - query1(A[i].second);
update1(A[i].second, A[i].first);
update2(A[i].second, 1);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int ans = 0;
void merger(vector<pair<long long int, long long int> > &v, long long int l,
long long int mid, long long int r) {
long long int n1 = mid - l + 1, n2 = r - mid;
pair<long long int, long long int> larr[n1], rarr[n2];
long long int lsum[n1], rsum[n2];
for (long long int i = 0; i < n1; i++) larr[i] = v[l + i];
for (long long int i = n1 - 1; i >= 0; i--) {
if (i == n1 - 1)
lsum[i] = larr[i].first;
else
lsum[i] = lsum[i + 1] + larr[i].first;
}
for (long long int i = 0; i < n2; i++) rarr[i] = v[mid + i + 1];
for (long long int i = n2 - 1; i >= 0; i--) {
if (i == n2 - 1)
rsum[i] = rarr[i].first;
else
rsum[i] = rsum[i + 1] + rarr[i].first;
}
long long int i = 0, j = 0, k = l;
while (i < n1 && j < n2) {
if (larr[i].second <= rarr[j].second) {
v[k] = larr[i];
ans += rsum[j];
ans -= ((n2 - j) * (larr[i].first));
i++;
} else {
v[k] = rarr[j++];
}
k++;
}
while (i < n1) v[k++] = larr[i++];
while (j < n2) v[k++] = rarr[j++];
}
void msort(vector<pair<long long int, long long int> > &v, long long int l,
long long int r) {
if (l < r) {
long long int mid = l + (r - l) / 2;
msort(v, l, mid);
msort(v, mid + 1, r);
merger(v, l, mid, r);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
vector<pair<long long int, long long int> > v;
long long int a[n], 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];
for (long long int i = 0; i < n; i++) v.push_back(make_pair(a[i], b[i]));
sort(v.begin(), v.end());
msort(v, 0, n - 1);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m, pos, v[N];
long long tot, s[N][2];
struct node {
long long x, v;
} a[N];
bool cmp(node x, node y) { return x.x < y.x; }
int lowbit(int x) { return x & (-x); }
void update(int x, int val) {
while (x <= n) {
s[x][0]++;
s[x][1] += val;
x += lowbit(x);
}
}
long long getsum(int x, int flag) {
long long res = 0;
while (x) {
res += s[x][flag];
x -= lowbit(x);
}
return res;
}
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].v);
v[i] = a[i].v;
}
sort(a + 1, a + n + 1, cmp);
sort(v + 1, v + n + 1);
m = unique(v + 1, v + n + 1) - v - 1;
for (int i = 1; i <= n; i++) {
pos = lower_bound(v + 1, v + m + 1, a[i].v) - v;
tot += getsum(pos, 0) * a[i].x - getsum(pos, 1);
update(pos, a[i].x);
}
printf("%lld", tot);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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;
}
|
#include <bits/stdc++.h>
using namespace std;
struct OrderSet {
struct Trie {
int cnt;
int next[2];
Trie() {
memset(next, -1, sizeof(next));
cnt = 0;
}
};
vector<Trie*> trie;
OrderSet() {
auto u = new Trie();
trie.push_back(u);
}
bool find(int first) {
int cur = 0;
for (int i = 30; i >= 0; i--) {
auto u = ((first >> i) & 1);
if (trie[cur]->next[u] == -1)
return 0;
else
cur = trie[cur]->next[u];
}
return 1;
}
void insert(int first) {
int cur = 0;
trie[cur]->cnt++;
for (int i = 30; i >= 0; i--) {
auto u = ((first >> i) & 1);
if (trie[cur]->next[u] == -1) {
auto newTrie = new Trie();
trie.push_back(newTrie);
trie[cur]->next[u] = trie.size() - 1;
cur = trie[cur]->next[u];
} else {
cur = trie[cur]->next[u];
}
trie[cur]->cnt++;
}
}
void deletee(int first) {
int cur = 0;
trie[cur]->cnt--;
for (int i = 30; i >= 0; i--) {
auto u = ((first >> i) & 1);
int temp = trie[cur]->next[u];
if (trie[temp]->cnt == 1) trie[cur]->next[u] = -1;
cur = temp;
trie[cur]->cnt--;
}
}
int order_of_key(int first) {
int cur = 0;
int res = 0;
for (int i = 30; i >= 0; i--) {
auto u = ((first >> i) & 1);
if (u == 1 && trie[cur]->next[0] != -1) {
int temp = trie[cur]->next[0];
res += trie[temp]->cnt;
}
if (trie[cur]->next[u] == -1) return res;
cur = trie[cur]->next[u];
}
return res;
}
int find_by_order(int k) {
int cur = 0;
int res = 0;
if (trie[cur]->cnt < k) return -1;
for (int i = 30; i >= 0; i--) {
int temp = trie[cur]->next[0];
if (temp == -1) {
cur = trie[cur]->next[1];
res += (1 << i);
continue;
}
if (trie[temp]->cnt < k) {
k -= trie[temp]->cnt;
cur = trie[cur]->next[1];
res += (1 << i);
} else {
cur = trie[cur]->next[0];
}
}
return res;
}
} os;
pair<int, int> a[200005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> a[i].second;
a[i].second += 2e8;
}
sort(a + 1, a + n + 1);
long long ans = 0;
map<int, int> cnt;
for (int i = 1; i <= n; i++) {
ans += 1LL * (os.order_of_key(a[i].second) + cnt[a[i].second]) * a[i].first;
os.insert(a[i].second);
cnt[a[i].second]++;
}
os = OrderSet();
for (int i = n; i >= 1; i--) {
ans -= 1LL * (n - i - os.order_of_key(a[i].second)) * a[i].first;
os.insert(a[i].second);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 1000;
pair<long long, long long> p[maxn];
vector<long long> v;
int getpos(long long V) {
return lower_bound(v.begin(), v.end(), V) - v.begin() + 1;
}
long long C[2][maxn];
void add(int x, long long K) {
while (0 < x && x < maxn) {
C[0][x] += 1;
C[1][x] += K;
x += (x) & (-x);
}
}
pair<long long, long long> getsum(int x) {
long long sum = 0;
int num = 0;
while (0 < x && x < maxn) {
num += C[0][x];
sum += C[1][x];
x -= (x) & (-x);
}
return pair<long long, long long>(num, sum);
}
int main() {
ios::sync_with_stdio(false);
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.push_back(p[i].second);
sort(p + 1, p + 1 + N);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
long long ans = 0;
for (int i = 1; i <= N; i++) {
pair<long long, long long> s = getsum(getpos(p[i].second));
ans += s.first * p[i].first - s.second;
add(getpos(p[i].second), p[i].first);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 10;
const long long maxX = 2e8 + 10;
long long n;
long long sz = 1;
pair<long long, long long> p[maxn];
long long segsum[25 * maxn];
long long segtedad[25 * maxn];
long long L[25 * maxn];
long long R[25 * maxn];
long long ans;
void in();
void solve();
void add(long long id, long long l, long long r, long long idx, long long v);
pair<long long, long long> get(long long id, long long l, long long r,
long long L, long long R);
void out();
int main() {
in();
solve();
out();
}
void in() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) cin >> p[i].first;
for (long long i = 0; i < n; i++) cin >> p[i].second;
for (long long i = 0; i < n; i++) p[i].second += 1e8;
}
void solve() {
sort(p, p + n);
for (long long i = 0; i < n; i++) {
pair<long long, long long> wow = get(0, 0, maxX, 0, p[i].second + 1);
add(0, 0, maxX, p[i].second, p[i].first);
ans += p[i].first * wow.second - wow.first;
}
}
void add(long long id, long long l, long long r, long long idx, long long v) {
if (r - l == 1) {
segsum[id] += v;
segtedad[id]++;
return;
}
long long mid = (l + r) >> 1;
if (L[id] == 0) {
L[id] = sz++;
R[id] = sz++;
}
if (idx < mid)
add(L[id], l, mid, idx, v);
else
add(R[id], mid, r, idx, v);
segtedad[id] = segtedad[L[id]] + segtedad[R[id]];
segsum[id] = segsum[L[id]] + segsum[R[id]];
}
pair<long long, long long> get(long long id, long long l, long long r,
long long second, long long e) {
if (r <= second || e <= l) return {0, 0};
if (second <= l && r <= e) return {segsum[id], segtedad[id]};
long long mid = (l + r) >> 1;
if (L[id] == 0) {
L[id] = sz++;
R[id] = sz++;
}
auto a = get(L[id], l, mid, second, e);
auto b = get(R[id], mid, r, second, e);
a.first += b.first;
a.second += b.second;
return a;
}
void out() { cout << ans; }
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 3e5 + 10;
void init(vector<pair<int, int>>& vp) {
vector<int> v;
for (auto& p : vp) v.push_back(p.second);
sort(v.begin(), v.end());
for (auto& p : vp) {
p.second = lower_bound(v.begin(), v.end(), p.second) - v.begin() + 1;
}
}
class BIT {
public:
long long a[N];
void add(int x, long long val) {
while (x < N) {
a[x] += val;
x += x & -x;
}
}
long long sum(int x) {
long long ret = 0;
while (x) {
ret += a[x];
x -= x & -x;
}
return ret;
}
} b1, b2;
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int>> vp(n);
for (auto& p : vp) scanf("%d", &p.first);
for (auto& p : vp) scanf("%d", &p.second);
init(vp);
long long ans = 0;
sort(vp.begin(), vp.end());
for (auto& p : vp) {
b1.add(p.second, 1);
b2.add(p.second, p.first);
ans += b1.sum(p.second) * p.first - b2.sum(p.second);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int M = 2e3 + 5;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1);
template <class T>
inline void read(T &x) {
char c;
x = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') x = -1;
T res = c - '0';
while ((c = getchar()) >= '0' && c <= '9') res = res * 10 + c - '0';
x *= res;
}
int n, m;
char str[N];
long long f[N][2];
int lowbit(int x) { return x & (-x); }
long long get(int pos, int type) {
long long res = 0;
while (pos) {
res += f[pos][type];
pos -= lowbit(pos);
}
return res;
}
void update(int pos, int v) {
while (pos <= m) {
f[pos][0]++;
f[pos][1] += v;
pos += lowbit(pos);
}
}
void solve() {
read(n);
vector<pair<int, int> > p(n);
for (pair<int, int> &pp : p) read(pp.first);
for (pair<int, int> &pp : p) read(pp.second);
sort(p.begin(), p.end());
vector<int> v;
for (pair<int, int> &pp : p) v.push_back(pp.second);
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
m = v.size();
long long ans = 0;
for (pair<int, int> &pp : p) {
int pos = lower_bound(v.begin(), v.end(), pp.second) - v.begin();
long long cnt = get(pos + 1, 0), sum = get(pos + 1, 1);
ans += cnt * pp.first - sum;
update(pos + 1, pp.first);
}
cout << ans << endl;
}
int main() {
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int bit[N];
void add(int p, int v) {
for (p += 2; p < N; p += p & -p) bit[p] += v;
}
long long query(int p) {
int r = 0;
for (p += 2; p; p -= p & -p) r += bit[p];
return r;
}
int n;
pair<int, int> p[N];
long long l[N], r[N];
int ql[N], qr[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i].second;
for (int i = 1; i <= n; i++) cin >> p[i].first;
sort(p + 1, p + n + 1);
map<int, int> id;
int cnt = 0, last = 0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
int v = p[i].first;
if (v != last) id[v] = ++cnt, last = v;
swap(p[i].first, p[i].second);
}
sort(p + 1, p + n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long x = p[i].first, v = id[p[i].second];
ans += query(v) * x;
add(v, 1);
}
memset(bit, 0, sizeof(bit));
for (int i = n; i >= 1; i--) {
long long x = p[i].first, v = id[p[i].second];
ans -= (query(n) - query(v - 1)) * x;
add(v, 1);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long int g[800010][2];
void up(int l, int r, int n, int x, int i, long long int val) {
if (l == r) {
g[n][i] = val;
} else {
int mid = (l + r) / 2;
if (x <= mid && x >= l)
up(l, mid, 2 * n, x, i, val);
else
up(mid + 1, r, 2 * n + 1, x, i, val);
g[n][i] = g[2 * n][i] + g[2 * n + 1][i];
}
return;
}
long long int q(int l, int r, int n, int st, int en, int i) {
if (en == 0) return 0;
if (st <= l && r <= en) {
return g[n][i];
} else if (r < st || en < l)
return 0;
else {
int mid = (l + r) / 2;
return (q(l, mid, 2 * n, st, en, i) + q(mid + 1, r, 2 * n + 1, st, en, i));
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<pair<long long int, long long int> > v(n);
vector<int> x(n);
map<int, int> m;
for (int i = 0; i < n; i++) {
cin >> v[i].second;
x[i] = v[i].second;
}
for (int i = 0; i < n; i++) cin >> v[i].first;
sort(x.begin(), x.end());
for (int i = 0; i < x.size(); i++) {
m[x[i]] = i + 1;
}
sort(v.begin(), v.end());
long long int ans = 0;
for (int i = 0; i < n; i++) {
long long int z = q(1, n, 1, 1, m[v[i].second], 0);
long long int z1 = q(1, n, 1, 1, m[v[i].second], 1);
ans += (v[i].second * z1 - z);
up(1, n, 1, m[v[i].second], 0, v[i].second);
up(1, n, 1, m[v[i].second], 1, 1);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,-O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int oo = 2e9;
const long long OO = 4e18;
const int md = 0x3b800001;
const int MD = 1e9 + 7;
inline long long time() {
return chrono ::system_clock().now().time_since_epoch().count();
}
mt19937 rnd(time());
mt19937_64 RND(time());
template <typename t>
inline void umin(t &a, t b) {
a = min(a, b);
}
template <typename t>
inline void umax(t &a, t b) {
a = max(a, b);
}
const int N = 2e5 + 228;
int n, x[N], v[N], p[N], s[N];
int f0[N];
int gf0(int i) {
int ans = 0;
for (i = s[i] + 1; i; i -= i & -i) ans += f0[i];
return ans;
}
void uf0(int i, int v) {
for (i = s[i] + 1; i < N; i += i & -i) f0[i] += v;
}
long long f1[N];
long long gf1(int i) {
long long ans = 0;
for (i = s[i] + 1; i; i -= i & -i) ans += f1[i];
return ans;
}
void uf1(int i, long long v) {
for (i = s[i] + 1; i < N; i += i & -i) f1[i] += v;
}
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> x[i];
for (int i = 0; i < n; ++i) cin >> v[i], p[i] = i;
sort(p, p + n, [&](int a, int b) { return x[a] < x[b]; });
for (int i = 0; i < n; ++i) s[p[i]] = i;
sort(p, p + n,
[&](int a, int b) { return v[a] == v[b] ? x[a] < x[b] : v[a] < v[b]; });
memset(f0, 0, sizeof f0);
memset(f1, 0, sizeof f1);
long long ans = 0;
for (int j = 0; j < n; ++j) {
int i = p[j];
ans += 1ll * gf0(i) * x[i] - gf1(i);
uf0(i, 1);
uf1(i, x[i]);
}
cout << ans << endl;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename C>
class fenwick {
vector<C> t;
int n;
public:
fenwick(int _n) : n(_n) { t.resize(n); }
fenwick(const vector<C>& a) : n(a.size()) {
t.resize(n);
for (int i = 0; i < n; ++i) {
upd(i, a[i]);
}
}
C get(int k) {
C res = 0;
for (k; k >= 0; k = (k & (k + 1)) - 1) {
res += t[k];
}
return res;
}
void upd(int k, C x) {
for (k; k < n; k |= k + 1) {
t[k] += x;
}
}
C get(int l, int r) { return get(r) - get(l - 1); }
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> x(n), v(n);
for (int i = 0; i < n; ++i) {
cin >> x[i];
}
map<int, int> mapchik;
for (int i = 0; i < n; ++i) {
cin >> v[i];
mapchik[v[i]] = 1;
}
int sz = 0;
for (auto& [a, b] : mapchik) {
b = sz++;
}
for (int i = 0; i < n; ++i) {
v[i] = mapchik[v[i]];
}
vector<int> ord(n);
iota(ord.begin(), ord.end(), 0);
sort(ord.begin(), ord.end(), [&](int i, int j) { return x[i] < x[j]; });
long long ans = 0;
fenwick<int> cnt(sz);
fenwick<long long> sum(sz);
for (int i : ord) {
ans += 1ll * cnt.get(0, v[i]) * x[i] - sum.get(0, v[i]);
cnt.upd(v[i], 1);
sum.upd(v[i], x[i]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> x, v;
int idX(int val) { return (lower_bound(x.begin(), x.end(), val) - x.begin()); }
int idV(int val) { return (lower_bound(v.begin(), v.end(), val) - v.begin()); }
struct FenwickTree {
vector<long long> bit;
int n;
FenwickTree(int n) {
this->n = n;
bit.assign(n, 0);
}
long long sum(int r) {
long long ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
return ret;
}
long long sum(int l, int r) { return sum(r) - sum(l - 1); }
void upd(int idx, int delta) {
for (; idx < n; idx = idx | (idx + 1)) bit[idx] += delta;
}
};
void nikal_pehli_fursat_mai() {
int n;
cin >> n;
vector<array<long long, 2>> arr(n);
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i][0];
x.push_back(arr[i][0]);
}
for (int i = 0; i < n; i++) {
cin >> arr[i][1];
v.push_back(abs(arr[i][1]));
}
sort(v.begin(), v.end());
sort(x.begin(), x.end());
sort(arr.begin(), arr.end());
FenwickTree pos(n), neg(n), zero(n), cntp(n), cntn(n), cntz(n);
for (int i = 0; i < n; i++) {
int id = idV(abs(arr[i][1]));
if (arr[i][1] > 0) {
cntp.upd(id, 1);
pos.upd(id, arr[i][0]);
} else if (arr[i][1] < 0) {
cntn.upd(id, 1);
neg.upd(id, arr[i][0]);
} else {
cntz.upd(id, 1);
zero.upd(id, arr[i][0]);
}
}
for (int i = 0; i < n; i++) {
int id = idV(abs(arr[i][1]));
if (arr[i][1] > 0) {
ans += pos.sum(id, n - 1) - cntp.sum(id, n - 1) * arr[i][0];
cntp.upd(id, -1);
pos.upd(id, -arr[i][0]);
} else if (arr[i][1] < 0) {
ans += pos.sum(0, n - 1) - cntp.sum(0, n - 1) * arr[i][0];
ans += zero.sum(0, n - 1) - cntz.sum(0, n - 1) * arr[i][0];
ans += neg.sum(0, id) - cntn.sum(0, id) * arr[i][0];
cntn.upd(id, -1);
neg.upd(id, -arr[i][0]);
} else {
ans += pos.sum(id, n - 1) - cntp.sum(id, n - 1) * arr[i][0];
ans += zero.sum(0, n - 1) - cntz.sum(0, n - 1) * arr[i][0];
cntz.upd(id, -1);
zero.upd(id, -arr[i][0]);
}
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int tc = 1;
while (tc--) {
nikal_pehli_fursat_mai();
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct FT {
vector<long long> f;
FT(long long n) { f.resize(n + 1, 0); }
long long sum(long long r) {
long long res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) {
res += f[r];
}
return res;
}
long long sum(long long l, long long r) { return sum(r) - sum(l - 1); }
void upd(long long i, long long x) {
for (; i < (long long)f.size(); i = (i | (i + 1))) f[i] += x;
}
};
map<long long, long long> f;
signed main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<pair<long long, long long>> a(n);
for (long long i = 0; i < n; i++) cin >> a[i].first;
for (long long i = 0; i < n; i++) cin >> a[i].second, f[a[i].second] = 0;
long long s = 0;
for (auto u : f) f[u.first] = s++;
sort(a.begin(), a.end());
FT ft1(s + 1), ft2(s + 1);
long long ans = 0;
for (auto u : a) {
long long x = u.first, y = u.second;
long long v = f[y];
long long cnt = ft1.sum(0, v);
long long sum = ft2.sum(0, v);
ans += x * cnt - sum;
ft1.upd(v, 1);
ft2.upd(v, x);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("fast-math")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC diagnostic ignored "-Woverflow"
using namespace std;
const short INF16 = ~(1 << 15);
const int INF32 = 2e9 + 11;
const int SZ = (1 << 19);
const int SZ2 = int(1e6 + 11);
const int mod = 998244353;
const int mod2 = 998244353;
const int PIVO = 5e5 + 11;
const long long INF64 = 8e18;
const long long P1 = 53;
const long long P2 = 47;
const long double eps = 1e-10;
const long double PI = acosl(-1);
inline long long MOD(long long x) {
x %= mod, x += mod;
return x % mod;
}
inline long long MOD(long long x, long long m) {
x %= m, x += m;
return x % m;
}
inline long long T(int x) { return 1ll * x * (x + 1) >> 1; }
inline long long TT(int x) { return 1ll * x * (x + 1) * (x + 2) / 6; }
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long fpow(long long a, long long b, long long mod) {
if (!b) return 1;
if (b == 1) return a % mod;
if (b & 1) return fpow(a, b ^ 1, mod) * a % mod;
long long d = fpow(a, b >> 1, mod);
return d * d % mod;
}
long long fpow(long long a, long long b) {
if (!b) return 1;
if (b == 1) return a;
if (b & 1) return fpow(a, b ^ 1) * a;
long long d = fpow(a, b >> 1);
return d * d;
}
long long n;
pair<long long, long long> t[SZ << 1];
pair<long long, long long> operator+(pair<long long, long long> a,
pair<long long, long long> b) {
return {a.first + b.first, a.second + b.second};
}
void Biuld(long long v, long long l, long long r) {
if (r - l == 1) return;
long long mid = (l + r) >> 1;
Biuld(v << 1, l, mid);
Biuld(v << 1 | 1, mid, r);
t[v] = t[v << 1] + t[v << 1 | 1];
}
void upd(long long v, long long l, long long r, long long k, long long x) {
if (r - l == 1) {
t[v] = {x, 0};
return;
}
long long mid = (l + r) >> 1;
if (k < mid)
upd(v << 1, l, mid, k, x);
else
upd(v << 1 | 1, mid, r, k, x);
t[v] = t[v << 1] + t[v << 1 | 1];
}
pair<long long, long long> get(long long v, long long l, long long r,
long long ql, long long qr) {
if (qr <= l || r <= ql) return {0, 0};
if (ql <= l && r <= qr) return t[v];
long long mid = (l + r) >> 1;
return get(v << 1, l, mid, ql, qr) + get(v << 1 | 1, mid, r, ql, qr);
}
bool cmp(pair<pair<long long, long long>, long long> &a,
pair<pair<long long, long long>, long long> &b) {
if (a.first.second != b.first.second) return a.first.second < b.first.second;
return a.first.first < b.first.first;
}
void Solve(long long num_test) {
cin >> n;
vector<pair<pair<long long, long long>, long long>> v(n);
for (auto &i : v) cin >> i.first.first;
for (auto &i : v) cin >> i.first.second;
sort(v.begin(), v.end(), cmp);
for (long long i = 0; i < n; i++) {
t[SZ + i] = {v[i].first.first, 1};
v[i].second = i;
}
Biuld(1, 0, SZ);
sort(v.begin(), v.end());
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long id = v[i].second;
ans += get(1, 0, SZ, id, n).first -
get(1, 0, SZ, id, n).second * v[i].first.first;
upd(1, 0, SZ, id, 0);
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(10);
srand(time(NULL));
long long test = 1;
for (long long i = 1; i <= test; i++) Solve(i);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = double;
const ll MODBASE = 1000000007LL;
const int MAXN = 200010;
const int MAXM = 1000;
const int MAXK = 16;
const int MAXQ = 200010;
struct Car {
int x, v;
Car(int x = 0, int v = 0) : x(x), v(v) {}
};
bool operator<(Car a, Car b) { return a.x < b.x; }
int n;
pair<ll, ll> t[MAXN];
Car a[MAXN];
set<int> s;
vector<int> b;
pair<ll, ll> get(int u) {
pair<ll, ll> res = pair<ll, ll>(0, 0);
while (u) {
res.first += t[u].first;
res.second += t[u].second;
u = u - (u & (-u));
}
return res;
}
void update(int u, int gt, int num) {
while (u <= 200000) {
t[u].first += gt;
t[u].second += num;
u = u + (u & (-u));
}
}
int getPos(int u) {
int dau = 0, cuoi = int((b).size()) - 1;
while (dau <= cuoi) {
int mid = (dau + cuoi) >> 1;
if (b[mid] >= u)
cuoi = mid - 1;
else
dau = mid + 1;
}
return dau + 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cin >> n;
for (int i = (1); i <= (n); i++) cin >> a[i].x;
for (int i = (1); i <= (n); i++) cin >> a[i].v;
sort(a + 1, a + n + 1);
for (int i = (1); i <= (n); i++) s.insert(a[i].v);
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); it++)
b.push_back(*it);
for (int i = (1); i <= (n); i++) a[i].v = getPos(a[i].v);
ll res = 0;
for (int i = (1); i <= (n); i++) {
pair<ll, ll> r = get(a[i].v);
res += (ll)a[i].x * r.second - r.first;
update(a[i].v, a[i].x, 1);
}
cout << res;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.