solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 4e18 + 10;
long long power(long long a, long long b, long long in_mod) {
long long ans = 1;
long long prod = a;
while (b) {
if (b % 2) ans = (ans * prod) % in_mod;
prod = (prod * prod) % in_mod;
b /= 2;
}
return ans;
}
long long mod_inv(long long q, long long in_mod) {
return power(q, in_mod - 2, in_mod);
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long fact(long long n, long long in_mod) {
long long f = 1;
for (long long i = 1; i <= n; i++) f = (f * i) % in_mod;
return f;
}
long long ncr(long long n, long long r, long long in_mod) {
return (((fact(n, in_mod) * mod_inv(fact(r, in_mod), in_mod)) % in_mod) *
mod_inv(fact(n - r, in_mod), in_mod)) %
in_mod;
}
long long A[200005] = {};
long long tree[4 * 200005] = {};
long long cnt[4 * 200005] = {};
void update(long long node, long long start, long long end, long long idx,
long long val) {
if (start == end) {
A[idx] += val;
tree[node] += val;
cnt[node] += 1;
} else {
long long mid = (start + end) / 2;
if (start <= idx and idx <= mid) {
update(2 * node, start, mid, idx, val);
} else {
update(2 * node + 1, mid + 1, end, idx, val);
}
tree[node] = tree[2 * node] + tree[2 * node + 1];
cnt[node] = cnt[2 * node] + cnt[2 * node + 1];
}
}
long long query1(long long node, long long start, long long end, long long l,
long long r) {
if (r < start or end < l) {
return 0;
}
if (l <= start and end <= r) {
return tree[node];
}
long long mid = (start + end) / 2;
long long p1 = query1(2 * node, start, mid, l, r);
long long p2 = query1(2 * node + 1, mid + 1, end, l, r);
return (p1 + p2);
}
long long query2(long long node, long long start, long long end, long long l,
long long r) {
if (r < start or end < l) {
return 0;
}
if (l <= start and end <= r) {
return cnt[node];
}
long long mid = (start + end) / 2;
long long p1 = query2(2 * node, start, mid, l, r);
long long p2 = query2(2 * node + 1, mid + 1, end, l, r);
return (p1 + p2);
}
void solve() {
long long n;
cin >> n;
map<long long, long long> mp;
vector<long long> dis(n);
vector<pair<long long, long long> > v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i].second;
dis[i] = v[i].second;
}
for (long long i = 0; i < n; i++) cin >> v[i].first;
sort((v).begin(), (v).end());
sort((dis).begin(), (dis).end());
for (long long i = 0; i < n; i++) mp[dis[i]] = i;
update(1, 0, 200005 - 1, mp[v[0].second], v[0].second);
long long ans = 0;
for (long long i = 1; i < n; i++) {
long long _sum = query1(1, 0, 200005 - 1, 0, mp[v[i].second]);
long long _cnt = query2(1, 0, 200005 - 1, 0, mp[v[i].second]);
ans += _cnt * (v[i].second) - _sum;
update(1, 0, 200005 - 1, mp[v[i].second], v[i].second);
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(10);
auto clk = clock();
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long t = 1;
for (long long test = 1; test <= t; test++) {
solve();
}
clk = clock() - clk;
cerr << fixed << setprecision(6)
<< "Time: " << ((long double)clk) / CLOCKS_PER_SEC << "\n";
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Z = (int)1e3 + 228;
const int N = (int)2e5 + 228;
const int INF = (int)1e9 + 228;
const int MOD = (int)998244353;
const long long LLINF = (long long)1e18 + 228;
const long double eps = (long double)1e-6;
pair<long long, long long> t[4 * N];
void update(int v, int tl, int tr, int pos, int x) {
if (tl == tr) {
t[v].first += x;
t[v].second++;
return;
}
int mid = (tl + tr) / 2;
if (pos <= mid)
update(2 * v, tl, mid, pos, x);
else
update(2 * v + 1, mid + 1, tr, pos, x);
t[v].first = t[2 * v].first + t[2 * v + 1].first;
t[v].second = t[2 * v].second + t[2 * v + 1].second;
}
pair<long long, long long> get_sum(int v, int tl, int tr, int l, int r) {
if (tl >= l && tr <= r) {
return t[v];
}
if (tl > r || tr < l) {
return {0, 0};
}
int mid = (tl + tr) / 2;
pair<long long, long long> ql = get_sum(2 * v, tl, mid, l, r);
pair<long long, long long> qr = get_sum(2 * v + 1, mid + 1, tr, l, r);
return {ql.first + qr.first, ql.second + qr.second};
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first;
}
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> a[i].second;
v.push_back(a[i].second);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
sort(a.begin(), a.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
int pos = lower_bound(v.begin(), v.end(), a[i].second) - v.begin();
pair<long long, long long> p = get_sum(1, 0, v.size() - 1, 0, pos);
ans += p.second * a[i].first - p.first;
update(1, 0, v.size() - 1, pos, a[i].first);
}
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 2e5 + 100;
pair<int, long long> a[mxn];
long long r[mxn], b1[mxn], b2[mxn], ans;
void add(long long *b, int idx, int val, int n) {
for (; idx <= n; idx += idx & -idx) b[idx] += val;
}
long long ask(long long *b, int idx) {
long long ret = 0;
for (; idx > 0; idx -= idx & -idx) ret += b[idx];
return ret;
}
int main() {
int n, m;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].first);
for (int i = 1; i <= n; i++)
scanf("%lld", &a[i].second), r[i - 1] = a[i].second;
sort(r, r + n), m = unique(r, r + n) - r;
for (int i = 1; i <= n; i++)
a[i].second = lower_bound(r, r + m, a[i].second) - r + 1;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) {
long long x = ask(b2, a[i].second), y = ask(b1, a[i].second);
ans += 1LL * y * a[i].first - x;
add(b2, a[i].second, a[i].first, n);
add(b1, a[i].second, 1, n);
}
printf("%lld\n", ans);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long ans, n, a1[202020], a2[202020], od[202020];
pair<long long, long long> p[202020];
map<long long, long long> mp;
void gx1(long long x, long long v) {
for (long long i = x; i < 200200; i += i & -i) {
a1[i] += v;
}
}
void gx2(long long x, long long v) {
for (long long i = x; i < 200200; i += i & -i) {
a2[i] += v;
}
}
long long gt1(long long p) {
long long rt = 0;
for (long long i = p; i > 0; i -= i & -i) {
rt += a1[i];
}
return rt;
}
long long gt2(long long p) {
long long rt = 0;
for (long long i = p; i > 0; i -= i & -i) {
rt += a2[i];
}
return rt;
}
signed main() {
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;
od[i] = p[i].second;
}
sort(od + 1, od + n + 1);
sort(p + 1, p + n + 1);
long long pp = 1;
for (long long i = 1; i <= n; i++) {
if (!mp[od[i]]) {
mp[od[i]] = pp;
pp++;
}
}
for (long long i = 1; i <= n; i++) {
ans += p[i].first * gt1(mp[p[i].second]) - gt2(mp[p[i].second]);
gx1(mp[p[i].second], 1ll);
gx2(mp[p[i].second], p[i].first);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
import sys
input = sys.stdin.readline
from heapq import heappush, heappop, heapify
def query(f, i):
ret = [0, 0]
while i:
ret[0] += f[i][0]
ret[1] += f[i][1]
i -= (i & -i)
return ret
def update(f, i, d):
n = len(f)
while i < n:
f[i][0] += d[0]
f[i][1] += d[1]
i += (i & -i)
n = int(input())
x = list(map(int, input().split()))
v = list(map(int, input().split()))
a = [()] * (n+1)
for i in range(1, n+1):
a[i] = (x[i-1], v[i-1])
a.sort()
f = [[0, 0] for i in range(n+1)]
for i in range(1, n+1):
update(f, i, [a[i][0], 1])
b = []
for i in range(1, n+1):
b.append((-a[i][1], -i))
heapify(b)
ans = 0
while b:
v, i = heappop(b)
v, i = -v, -i
x = a[i][0]
if i > 1:
sum, cnt = query(f, i-1)
ans += x * cnt - sum
update(f, i, [-x, -1])
print(ans) | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int dddx[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dddy[] = {0, 0, 1, -1, 1, -1, 1, -1};
vector<pair<long long int, long long int> > vec;
int n;
long long int tree[(int)(2 * 1e5 + 1)], tree2[(int)(2 * 1e5 + 1)];
void atualiza(int x, int v) {
for (; x < n; x = x | (x + 1)) tree[x] += v;
}
void atualiza2(int x, int v) {
for (; x < n; x = x | (x + 1)) tree2[x] += v;
}
long long int sum(long long int x) {
long long int s = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) s += tree[x];
return s;
}
long long int sum2(int x) {
long long int s = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) s += tree2[x];
return s;
}
void compress() {
vector<int> aux2;
for (int i = 0; i < n; i++) aux2.push_back(vec[i].second);
sort(aux2.begin(), aux2.end());
for (int j = 0; j < n; j++) {
auto i = vec[j];
vec[j].second =
lower_bound(aux2.begin(), aux2.end(), i.second) - aux2.begin();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
vector<int> aux;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
vec.push_back({a, 1});
}
for (int i = 0; i < n; i++) {
int a;
cin >> a;
vec[i].second = a;
}
sort(vec.begin(), vec.end());
compress();
for (int i = 0; i < n; i++) aux.push_back(vec[i].second);
sort(aux.begin(), aux.end());
long long int ans = 0;
for (int i = 0; i < n; i++) {
int pos = lower_bound(aux.begin(), aux.end(), vec[i].second) - aux.begin();
ans += (sum2(pos) * vec[i].first - sum(pos));
atualiza(pos, vec[i].first);
atualiza2(pos, 1);
}
cout << ans << "\n";
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
bool prime[10000001];
long long P = 1000000007 - 2;
long long factorial[10000001] = {0};
long long powerFunction(long long x, long long y) {
long long res = 1;
long long p = 1000000007;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void sieveFunction(long long maxLimit) {
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (long long i = 2; maxLimit >= i; i++) {
if (prime[i]) {
for (long long j = 2 * i; maxLimit >= j; j += i) prime[j] = false;
}
}
}
void factorialFunction(long long maxLimit) {
factorial[0] = 1;
for (long long i = 1; i <= maxLimit; i++)
factorial[i] = (factorial[i - 1] * i) % 1000000007;
return;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<pair<long long, long long>> tree[800001];
vector<long long> treesum[800001];
vector<pair<long long, long long>> v;
void build(long long node, long long start, long long end) {
if (start == end) {
vector<pair<long long, long long>> temp;
temp.push_back({v[start].second, v[start].first});
tree[node] = temp;
vector<long long> sum;
long long s = 0;
for (long long i = 0; tree[node].size() > i; i++) {
s += tree[node][i].second;
treesum[node].push_back(s);
}
return;
}
long long mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
long long i = 0, j = 0;
while (i < tree[2 * node].size() && j < tree[2 * node + 1].size()) {
if (tree[2 * node][i] <= tree[2 * node + 1][j]) {
tree[node].push_back(tree[2 * node][i]);
i++;
} else {
tree[node].push_back(tree[2 * node + 1][j]);
j++;
}
}
for (long long k = i; k < tree[2 * node].size(); k++)
tree[node].push_back(tree[2 * node][k]);
for (long long k = j; k < tree[2 * node + 1].size(); k++)
tree[node].push_back(tree[2 * node + 1][k]);
long long s = 0;
for (long long k = 0; tree[node].size() > k; k++) {
s += tree[node][k].second;
treesum[node].push_back(s);
}
}
long long n;
long long SEC;
long long query(long long node, long long start, long long end, long long x) {
if (start > x && end <= n) {
pair<long long, long long> tem = {v[x].second, INT64_MIN};
long long id = lower_bound(tree[node].begin(), tree[node].end(), tem) -
tree[node].begin();
if (id) {
SEC += (long long)tree[node].size() - id;
return treesum[node].back() - treesum[node][id - 1];
}
SEC += tree[node].size();
return treesum[node].back();
}
if (end <= x || start > n) {
return 0;
}
long long mid = (start + end) / 2;
return query(2 * node, start, mid, x) + query(2 * node + 1, mid + 1, end, x);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
long long x[n + 1], s[n + 1];
for (long long i = 1; n >= i; i++) {
cin >> x[i];
}
for (long long i = 1; n >= i; i++) {
cin >> s[i];
}
v.push_back({INT64_MIN, INT64_MIN});
for (long long i = 1; n >= i; i++) {
v.push_back({x[i], s[i]});
}
sort(v.begin(), v.end());
build(1, 1, n);
long long ans = 0;
for (long long i = 1; n >= i; i++) {
SEC = 0;
long long xx = v[i].first;
long long temp = query(1, 1, n, i);
temp -= xx * SEC;
ans += temp;
}
cout << ans << "\n";
}
| 12 | CPP |
import bisect
import sys
class ft:
def __init__(self,n):
self.a = [0]*(200000)
self.n = n
def qry(self,r):
ret = 0
while r>=0:
ret+=self.a[r]
r=(r&(r+1))-1
return ret
def upd(self,i,v):
while i<self.n:
self.a[i]+=v
i=(i|(i+1))
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
n = int(input())
x = list(map(int,input().split()))
v = list(map(int,input().split()))
f0 = ft(n)
f1 = ft(n)
a1 = [[] for _ in range(n)]
for i in range(n):
a1[i].append(x[i])
a1[i].append(v[i])
a1.sort()
v.sort()
ans = 0
for i in range(n):
p = bisect.bisect_left(v,a1[i][1])
ans+=(f0.qry(p)*a1[i][0])-(f1.qry(p));
f0.upd(p,1)
f1.upd(p,a1[i][0])
print(ans) | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long int savev[maxn];
struct node {
long long int x, v;
node(){};
node(long long int x, long long int v) : x(x), v(v){};
bool operator<(const node& n) const { return x < n.x; }
} save[maxn];
map<long long int, long long int> getv;
long long int stree[maxn];
long long int vtree[maxn];
long long int n;
void add(long long int x, long long int d, long long int* tree) {
while (x <= n) {
tree[x] += d;
x += (x & (-x));
}
}
long long int sum(long long int x, long long int* tree) {
long long int sum = 0;
while (x > 0) {
sum += tree[x];
x -= (x & (-x));
}
return sum;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%lld", &save[i].x);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &save[i].v);
savev[i] = save[i].v;
}
sort(savev + 1, savev + 1 + n);
sort(save + 1, save + 1 + n);
int vcnt = 0;
for (int i = 1; i <= n; i++) {
if (!getv[savev[i]]) {
getv[savev[i]] = ++vcnt;
}
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
node& nownode = save[i];
long long int nowv = getv[nownode.v];
long long int sumdis = sum(nowv, vtree);
long long int sumsmall = sum(nowv, stree);
ans += nownode.x * sumsmall - sumdis;
add(nowv, nownode.x, vtree);
add(nowv, 1, stree);
}
printf("%lld", ans);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) { return a > b ? a : b; }
void swap(long long& a, long long& b) {
long long tmp = a;
a = b;
b = tmp;
}
long long t, n;
long long x[200006], v[200006];
pair<long long, long long> xv[200006];
long long prfxSum[200006];
pair<long long, long long> sgmTree[4 * 200006];
pair<long long, long long> get(long long node, long long st, long long en,
long long pos) {
if (st > en) {
return make_pair(0, 0);
}
if (en == pos) {
return sgmTree[node];
}
if ((st + en) / 2 >= pos) {
return get(2 * node, st, (st + en) / 2, pos);
} else {
pair<long long, long long> to_ret =
get(2 * node + 1, (st + en) / 2 + 1, en, pos);
return make_pair(sgmTree[2 * node].first + to_ret.first,
sgmTree[2 * node].second + to_ret.second);
}
}
void remove(long long node, long long st, long long en, long long pos) {
if (st > en) {
return;
}
if (st == en) {
sgmTree[node] = make_pair(0, 0);
return;
}
if ((st + en) / 2 >= pos) {
remove(2 * node, st, (st + en) / 2, pos);
} else {
remove(2 * node + 1, (st + en) / 2 + 1, en, pos);
}
sgmTree[node].first = sgmTree[2 * node].first + sgmTree[2 * node + 1].first;
sgmTree[node].second =
sgmTree[2 * node].second + sgmTree[2 * node + 1].second;
}
void buildtree(long long node, long long st, long long en) {
if (st > en) {
return;
}
if (st == en) {
sgmTree[node] = make_pair(x[st], 1);
return;
}
buildtree(2 * node, st, (st + en) / 2);
buildtree(2 * node + 1, (st + en) / 2 + 1, en);
sgmTree[node].first = sgmTree[2 * node].first + sgmTree[2 * node + 1].first;
sgmTree[node].second =
sgmTree[2 * node].second + sgmTree[2 * node + 1].second;
}
void solve() {
cin >> n;
for (int i = 1; i <= 4 * n; ++i) {
sgmTree[i] = make_pair(0, 0);
}
for (int i = 1; i <= n; ++i) {
cin >> x[i];
}
for (int i = 1; i <= n; ++i) {
cin >> v[i];
}
for (int i = 1; i <= n; ++i) {
xv[i] = make_pair(x[i], v[i]);
}
sort(xv + 1, xv + 1 + n);
for (int i = 1; i <= n; ++i) {
x[i] = xv[i].first;
}
for (int i = 1; i <= n; ++i) {
v[i] = xv[i].second;
}
priority_queue<pair<long long, long long> > pq;
for (int i = 1; i <= n; ++i) {
pq.push(make_pair(v[i], i));
}
prfxSum[1] = x[1];
for (int i = 2; i <= n; ++i) {
prfxSum[i] = prfxSum[i - 1] + x[i];
}
buildtree(1, 1, n);
long long ans = 0;
while (!pq.empty()) {
pair<long long, long long> pair = pq.top();
long long mxv = pair.first;
long long pos = pair.second;
pq.pop();
long long val = 0;
val += get(1, 1, n, pos).first;
val -= get(1, 1, n, pos).second * x[pos];
remove(1, 1, n, pos);
if (val < 0) {
val *= -1;
}
ans += val;
}
cout << ans << endl;
return;
}
int main(int argc, char const* argv[]) {
t = 1;
while (t--) {
solve();
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
struct Node {
int x, v;
bool operator<(const Node &rhs) const { return x < rhs.x; }
} p[maxn];
int b[maxn], n, to;
long long t[maxn], tt[maxn];
inline int lowbit(int x) { return x & -x; }
void update(long long *t, int x, int v) {
for (; x <= n; x += lowbit(x)) {
t[x] += v;
}
}
long long query(long long *t, int x) {
long long sum = 0;
for (; x; x -= lowbit(x)) {
sum += t[x];
}
return sum;
}
int find(int x) { return lower_bound(b + 1, b + to + 1, x) - b; }
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);
b[i] = p[i].v;
}
sort(p + 1, p + n + 1);
sort(b + 1, b + n + 1);
to = unique(b + 1, b + n + 1) - b - 1;
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int v = find(p[i].v);
ans += 1LL * query(tt, v) * p[i].x - query(t, v);
update(t, v, p[i].x);
update(tt, v, 1);
}
printf("%lld\n", ans);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
void dout() { cerr << '\n'; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << " " << H;
dout(T...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 7;
int n, m, cnt[N];
long long sum[N];
pair<int, int> p[N];
void upd(int x, int y) {
for (; x <= m; x |= (x + 1)) {
cnt[x]++;
sum[x] += y;
}
}
int getnum(int x) {
int res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += cnt[x];
}
return res;
}
long long getsum(int x) {
long long res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += sum[x];
}
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
cin >> n;
vector<int> vec, v;
for (int i = 1; i <= n; i++) {
cin >> p[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> p[i].second;
vec.push_back(p[i].second);
}
sort((vec).begin(), (vec).end());
map<int, int> ind;
for (int i = 1; i <= n; i++) {
if (!ind.count(vec[i - 1])) {
ind[vec[i - 1]] = ++m;
}
}
for (int i = 1; i <= n; i++) {
p[i].second = ind[p[i].second];
}
sort(p + 1, p + n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += (long long)getnum(p[i].second) * p[i].first - getsum(p[i].second);
upd(p[i].second, p[i].first);
}
cout << ans;
}
| 12 | CPP |
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
#import threading
from collections import defaultdict
#threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
#sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default='z', func=lambda a, b: min(a, b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n=int(input())
l=list(map(int,input().split()))
s=list(map(int,input().split()))
d1=defaultdict(list)
for i in range(n):
d1[l[i]].append(s[i])
s.sort()
d=defaultdict(list)
for i in range(n):
d[s[i]].append(i)
for i in d:
d[i].sort()
d[i]=deque(d[i])
l.sort()
u=[0]*n
u1=[0]*n
s=SegmentTree(u)
s1=SegmentTree(u1)
ans=0
for i in range(n):
sp=d1[l[i]][-1]
d1[l[i]].pop()
pos=d[sp][0]
#print(pos,sp)
d[sp].popleft()
ans+=s.query(0,pos-1)*l[i]-s1.query(0,pos-1)
s.__setitem__(pos,1)
s1.__setitem__(pos,l[i])
#print(ans)
print(ans)
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n;
pair<int, int> a[maxn];
int m;
vector<int> v;
struct fenwick {
long long val[maxn];
void init() { fill(begin(val), end(val), 0); }
void upd(int x, int k) {
for (; x < maxn; x += x & -x) val[x] += k;
}
long long get(int x) {
long long res = 0;
for (; x > 0; x -= x & -x) res += val[x];
return res;
}
long long get(int l, int r) {
if (l > r) return 0;
return get(r) - get(l - 1);
}
} tree_tot, tree_cnt;
void read_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;
}
void init() {
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) v.push_back(a[i].second);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
m = v.size();
for (int i = 1; i <= n; ++i)
a[i].second = lower_bound(v.begin(), v.end(), a[i].second) - v.begin() + 1;
tree_tot.init();
tree_cnt.init();
for (int i = 1; i <= n; ++i) {
tree_tot.upd(a[i].second, a[i].first);
tree_cnt.upd(a[i].second, 1);
}
}
void solve() {
long long ans = 0;
for (int i = 1; i <= n; ++i) {
tree_tot.upd(a[i].second, -a[i].first);
tree_cnt.upd(a[i].second, -1);
ans += tree_tot.get(a[i].second, m) -
a[i].first * 1LL * tree_cnt.get(a[i].second, m);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
read_input();
init();
solve();
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N;
pair<signed long long, signed long long> P[202020];
pair<signed long long, signed long long> Q[202020];
template <class V, int ME>
class BIT {
public:
V bit[1 << ME];
V operator()(int e) {
if (e < 0) return 0;
V s = 0;
e++;
while (e) s += bit[e - 1], e -= e & -e;
return s;
}
void add(int e, V v) {
e++;
while (e <= 1 << ME) bit[e - 1] += v, e += e & -e;
}
};
BIT<signed long long, 20> bt, bt2;
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N;
for (i = 0; i < (N); i++) cin >> P[i].first;
for (i = 0; i < (N); i++) cin >> P[i].second;
sort(P, P + N);
signed long long ret = 0;
for (i = 0; i < (N); i++) Q[i] = {P[i].second, i};
sort(Q, Q + N);
for (i = 0; i < (N); i++) {
ret += bt(Q[i].second) * P[Q[i].second].first;
bt.add(Q[i].second, 1);
}
reverse(Q, Q + N);
for (i = 0; i < (N); i++) {
ret -= (bt2(N) - bt2(Q[i].second)) * P[Q[i].second].first;
bt2.add(Q[i].second, 1);
}
cout << ret << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long, long long> p1, pair<long long, long long> p2) {
if (p1.second == p2.second) return p1.first < p2.first;
return p1.second < p2.second;
}
signed main() {
long long n;
cin >> n;
vector<pair<long long, long long> > v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i].first;
}
for (long long i = 0; i < n; i++) {
cin >> v[i].second;
}
sort(v.begin(), v.end());
map<long long, long long> mp;
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans += (2 * i - n + 1) * v[i].first;
mp[v[i].first] = i;
}
sort(v.begin(), v.end(), comp);
for (long long i = 0; i < n; i++) {
ans += (i - mp[v[i].first]) * v[i].first;
}
cout << ans << endl;
}
| 12 | CPP |
#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;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> o[(int)2e5 + 10];
long long n, ts[(int)2e5 + 10], tc[(int)2e5 + 10];
int main(void) {
scanf("%lld", &n);
for (long long i = 0; i < n; i++) {
scanf("%lld", &o[i].second);
}
for (long long i = 0; i < n; i++) {
scanf("%lld", &o[i].first);
}
sort(o, o + n);
for (long long i = 0; i < n; i++) {
o[i] = {o[i].second, i + 1};
}
sort(o, o + n);
long long ans = 0;
for (long long 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);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200000 + 50;
const long long LIM = 17;
const long long INF = (long long)1e9 + 7;
long long N;
long long h[maxn];
long long sum[maxn << 1], cnt[maxn << 1];
struct node {
long long x, v;
} a[maxn];
bool cmp(const node& a, const node& b) { return a.x < b.x; }
inline long long lowerbit(long long x) { return x & -x; }
void updata(long long x, long long val, long long tree[]) {
while (x <= N) {
tree[x] += val;
x += lowerbit(x);
}
}
long long query(long long x, long long tree[]) {
long long sum = 0;
while (x > 0) {
sum += tree[x];
x -= lowerbit(x);
}
return sum;
}
int main() {
scanf("%lld", &N);
for (long long i = 1; i <= N; i++) {
scanf("%lld", &a[i].x);
}
for (long long i = 1; i <= N; i++) {
scanf("%lld", &a[i].v);
}
sort(a + 1, a + 1 + N, cmp);
long long l = -1e8;
for (long long i = 1; i <= N; i++) {
h[i] = a[i].v;
}
sort(h + 1, h + 1 + N);
long long d = unique(h + 1, h + 1 + N) - h - 1;
long long ans = 0;
for (long long i = 1; i <= N; i++) {
long long x = lower_bound(h + 1, h + 1 + d, a[i].v) - h;
ans += (query(x, cnt) * (a[i].x - l) - query(x, sum));
updata(x, 1, cnt);
updata(x, a[i].x - l, sum);
}
cout << ans << endl;
}
| 12 | CPP |
#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;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct tree {
tree* l;
tree* r;
long long sum;
long long cnt;
tree() {
l = r = nullptr;
sum = cnt = 0;
}
}* rt = new tree;
tree* get_l(tree* v) {
if (!v->l) {
v->l = new tree;
}
return v->l;
}
tree* get_r(tree* v) {
if (!v->r) {
v->r = new tree;
}
return v->r;
}
void add(tree* v, long long l, long long r, long long V, long long x) {
v->cnt++;
v->sum += x;
if (l == r - 1) {
return;
}
long long m = (l + r) / 2;
if (V < m)
add(get_l(v), l, m, V, x);
else
add(get_r(v), m, r, V, x);
}
pair<long long, long long> get_sum(tree* v, long long l, long long r,
long long L, long long R) {
if (r <= L || l >= R) return {0, 0};
if (L <= l && r <= R) return {v->sum, v->cnt};
long long m = (l + r) / 2;
pair<long long, long long> t1 = get_sum(get_l(v), l, m, L, R);
pair<long long, long long> t2 = get_sum(get_r(v), m, r, L, R);
return {t1.first + t2.first, t1.second + t2.second};
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<pair<long long, long long>> xv(n);
for (long long i = 0; i < n; ++i) {
cin >> xv[i].first;
}
for (long long i = 0; i < n; ++i) {
cin >> xv[i].second;
xv[i].second += 1e8;
}
long long MX_V = 2e8 + 10;
sort(xv.begin(), xv.end());
long long res = 0;
for (long long i = 0; i < n; ++i) {
pair<long long, long long> k = get_sum(rt, 0, MX_V, 0, xv[i].second + 1);
res += xv[i].first * k.second - k.first;
add(rt, 0, MX_V, xv[i].second, xv[i].first);
}
cout << res << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX_SIZE = 200010;
pair<int, int> arr[MAX_SIZE], backup[MAX_SIZE];
long long prefix[MAX_SIZE];
int N;
void sortX(int l, int r) {
if (l >= r) return;
int mi = (l + r) / 2;
sortX(l, mi);
sortX(mi + 1, r);
int i = l, j = mi + 1, k = l;
while (i <= mi && j <= r) {
if (arr[i] < arr[j]) {
backup[k++] = arr[i++];
} else {
backup[k++] = arr[j++];
}
}
while (i <= mi) {
backup[k++] = arr[i++];
}
while (j <= r) {
backup[k++] = arr[j++];
}
for (int i = l; i <= r; i++) {
arr[i] = backup[i];
}
}
int lowerBound(int l, int r, int val) {
while (l <= r) {
int mi = (l + r) / 2;
if (arr[mi].second <= val) {
l = mi + 1;
} else {
r = mi - 1;
}
}
int mi = (l + r) / 2;
if (mi >= l && arr[mi].second > val) return mi - 1;
return mi;
}
long long mergeSortV(int l, int r) {
if (l >= r) return 0;
int mi = (l + r) / 2;
long long left = mergeSortV(l, mi);
long long right = mergeSortV(mi + 1, r);
long long mix = 0LL;
prefix[l] = 0LL;
for (int i = l; i <= mi; i++) {
prefix[i + 1] = prefix[i] + (long long)arr[i].first;
}
for (int i = mi + 1; i <= r; i++) {
int pos = lowerBound(l, mi, arr[i].second);
long long cnt = pos - l + 1;
mix += ((long long)arr[i].first * cnt - (prefix[pos + 1] - prefix[l]));
}
int i = l, j = mi + 1, k = l;
while (i <= mi && j <= r) {
if (arr[i].second < arr[j].second) {
backup[k++] = arr[i++];
} else {
backup[k++] = arr[j++];
}
}
while (i <= mi) {
backup[k++] = arr[i++];
}
while (j <= r) {
backup[k++] = arr[j++];
}
for (i = l; i <= r; i++) {
arr[i] = backup[i];
}
return left + right + mix;
}
long long solveBruteforce() {
long long sum = 0LL;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
if (arr[i].second > arr[j].second) {
sum += (long long)max(arr[i].first - arr[j].first, 0);
} else if (arr[i].second < arr[j].second) {
sum += (long long)max(arr[j].first - arr[i].first, 0);
} else {
sum += (long long)max(arr[j].first - arr[i].first,
arr[i].first - arr[j].first);
}
}
}
return sum;
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
arr[i].first = x;
}
for (int i = 0; i < N; i++) {
int v;
cin >> v;
arr[i].second = v;
}
sortX(0, N - 1);
cout << mergeSortV(0, N - 1) << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
int xx[200000], vv[200000];
int compare_v(const void *a, const void *b) {
int i = *(int *)a;
int j = *(int *)b;
return vv[i] - vv[j];
}
int compare_x(const void *a, const void *b) {
int i = *(int *)a;
int j = *(int *)b;
return xx[i] - xx[j];
}
void sort(int *ii, int n, int (*compare)(const void *, const void *)) {
qsort(ii, n, sizeof *ii, compare);
}
void update(long long *ft, int i, int n, int x) {
while (i < n) {
ft[i] += x;
i |= i + 1;
}
}
long long query(long long *ft, int i) {
long long x = 0;
while (i >= 0) {
x += ft[i];
i &= i + 1, i--;
}
return x;
}
int main() {
static long long ft_cnt[200000], ft_sum[200000];
static int ii[200000];
int n, n_, i;
long long ans;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &xx[i]);
for (i = 0; i < n; i++) scanf("%d", &vv[i]);
for (i = 0; i < n; i++) ii[i] = i;
sort(ii, n, compare_v);
n_ = 0;
for (i = 0; i < n; i++)
vv[ii[i]] = i + 1 == n || vv[ii[i + 1]] != vv[ii[i]] ? n_++ : n_;
sort(ii, n, compare_x);
ans = 0;
for (i = 0; i < n; i++) {
int i_ = ii[i], x = xx[i_], v = vv[i_];
ans += query(ft_cnt, v) * x - query(ft_sum, v);
update(ft_cnt, v, n_, 1);
update(ft_sum, v, n_, x);
}
printf("%lld\n", ans);
return 0;
}
| 12 | CPP |
import sys
input = sys.stdin.readline
from collections import defaultdict
def compress(l):
l = list(set(l))
l.sort()
idx = defaultdict(int)
c = 0
for li in l:
idx[li] = c
c += 1
return idx
class BIT:
#n:要素数
def __init__(self, n):
self.n = n
self.bit = [0]*(n+1)
#i番目(0-indexed)の値にxを足す
def add(self, i, x):
i += 1
while i<=self.n:
self.bit[i] += x
i += i&(-i)
#0からi番目までの値の和を求める
def acc(self, i):
i += 1
s = 0
while i>0:
s += self.bit[i]
i -= i&(-i)
return s
n = int(input())
x = list(map(int, input().split()))
v = list(map(int, input().split()))
xv = [(xi, vi) for xi, vi in zip(x, v)]
xv.sort(key=lambda t: t[0])
idx = compress(v)
sum_bit = BIT(len(idx))
cnt_bit = BIT(len(idx))
ans = 0
for xi, vi in xv:
ans += cnt_bit.acc(idx[vi])*xi-sum_bit.acc(idx[vi])
sum_bit.add(idx[vi], xi)
cnt_bit.add(idx[vi], 1)
print(ans)
| 12 | PYTHON3 |
#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> bt[N];
pair<long long, long long> query(int first) {
pair<long long, long long> res{0, 0};
while (first) {
res.first += bt[first].first;
res.second += bt[first].second;
first -= ((first) & (-first));
}
return res;
}
void modify(int first, int val) {
while (first <= n) {
bt[first].first += val;
bt[first].second++;
first += ((first) & (-first));
}
}
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;
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(id);
ans -= cur.first - cur.second * a[i].first;
modify(id, a[i].first);
}
printf("%lld", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct treap {
treap* l = nullptr;
treap* r = nullptr;
long long int pos;
long long int vel;
long long int y;
long long int sum;
int ch;
static long long int s(treap* A) {
if (A == nullptr) return 0;
return A->sum;
}
static int c(treap* A) {
if (A == nullptr) return 0;
return A->ch;
}
static void re(treap* A) {
if (A == nullptr) return;
A->sum = s(A->l) + s(A->r) + A->pos;
A->ch = c(A->l) + c(A->r) + 1;
}
treap(long long int pos, long long int vel) {
this->vel = vel;
this->pos = pos;
this->y = rand() % 1000000000;
re(this);
}
static treap* merge(treap* A, treap* B) {
if (A == nullptr) return B;
if (B == nullptr) return A;
if (A->y > B->y) {
A->r = merge(A->r, B);
re(A);
return A;
} else {
B->l = merge(A, B->l);
re(B);
return B;
}
}
static pair<treap*, treap*> split(treap* A, long long int x) {
if (A == nullptr) return {nullptr, nullptr};
if (A->vel <= x) {
auto T1 = split(A->r, x);
A->r = T1.first;
re(A);
return {A, T1.second};
} else {
auto T1 = split(A->l, x);
A->l = T1.second;
re(A);
return {T1.first, A};
}
}
static treap* insert(treap* A, long long int pos, long long int vel) {
auto T1 = split(A, vel);
auto T2 = merge(T1.first, new treap(pos, vel));
return merge(T2, T1.second);
}
static void func(treap* A, long long int x, long long int& cnt,
long long int& sum) {
auto T1 = split(A, x);
cnt = c(T1.first);
sum = s(T1.first);
merge(T1.first, T1.second);
}
};
const int le = 2 * 1e5;
struct point {
long long int pos = 0;
long long int vel = 0;
point(int pos = 0, int vel = 0) {
this->pos = pos;
this->vel = vel;
}
bool operator<(const point& other) const { return this->pos < other.pos; }
};
point arr[le];
int main() {
iostream::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i].pos;
}
for (int i = 0; i < n; i++) {
cin >> arr[i].vel;
}
sort(arr, arr + n);
long long int ans = 0;
treap* cur = nullptr;
for (int i = 0; i < n; i++) {
long long int cnt, sum;
treap::func(cur, arr[i].vel, cnt, sum);
cur = treap::insert(cur, arr[i].pos, arr[i].vel);
ans += cnt * arr[i].pos - sum;
}
cout << ans << '\n';
;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int X, V;
inline friend bool operator<(Node x, Node y) {
if (x.V == y.V) {
return x.X < y.X;
}
return x.V < y.V;
}
} p[200000];
map<int, int> A;
set<int> B;
int ct;
long long c1[200001];
int c2[200001];
inline void Add(int x, int d) {
for (register int i = x; i <= ct; i += i & -i) {
c1[i] += d;
c2[i]++;
}
}
inline pair<long long, int> Get(int x) {
int s2 = 0;
long long s1 = 0;
for (register int i = x; i != 0; i -= i & -i) {
s1 += c1[i];
s2 += c2[i];
}
return make_pair(s1, s2);
}
int main() {
int n, k;
scanf("%d", &n);
for (register int i = 0; i != n; i++) {
scanf("%d", &p[i].X);
B.insert(p[i].X);
}
for (register int i = 0; i != n; i++) {
scanf("%d", &p[i].V);
}
sort(p, p + n);
for (set<int>::iterator T = B.begin(); T != B.end(); T++) {
ct++;
A[*T] = ct;
}
long long ans = 0;
for (register int i = 0; i != n; i++) {
k = A[p[i].X];
pair<long long, int> Tem = Get(k);
ans += (long long)p[i].X * Tem.second - Tem.first;
Add(k, p[i].X);
}
printf("%lld", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, m, ans[200005 << 2], tag[200005 << 2], cnt[200005 << 2],
tagg[200005 << 2];
struct p {
long long x, v, vv;
} a[200005];
int cmp(p a, p b) { return a.v < b.v; }
int cmpp(p a, p b) { return a.x < b.x; }
inline long long ls(long long x) { return x << 1; }
inline long long rs(long long x) { return x << 1 | 1; }
inline void push_up(long long p) {
cnt[p] = cnt[ls(p)] + cnt[rs(p)];
ans[p] = ans[ls(p)] + ans[rs(p)];
}
void build(long long p, long long l, long long r) {
tag[p] = 0;
if (l == r) {
ans[p] = 0;
return;
}
long long mid = (l + r) >> 1;
build(ls(p), l, mid);
build(rs(p), mid + 1, r);
push_up(p);
}
inline void f(long long p, long long l, long long r, long long k) {
tag[p] = tag[p] + k;
ans[p] = ans[p] + k * (r - l + 1);
}
inline void push_down(long long p, long long l, long long r) {
long long mid = (l + r) >> 1;
f(ls(p), l, mid, tag[p]);
f(rs(p), mid + 1, r, tag[p]);
tag[p] = 0;
}
inline void update(long long nl, long long nr, long long l, long long r,
long long p, long long k) {
if (nl <= l && r <= nr) {
ans[p] += k * (r - l + 1);
tag[p] += k;
cnt[p]++;
return;
}
push_down(p, l, r);
long long mid = (l + r) >> 1;
if (nl <= mid) update(nl, nr, l, mid, ls(p), k);
if (nr > mid) update(nl, nr, mid + 1, r, rs(p), k);
push_up(p);
}
long long query(long long q_x, long long q_y, long long l, long long r,
long long p) {
long long res = 0;
if (q_x <= l && r <= q_y) return ans[p];
long long mid = (l + r) >> 1;
push_down(p, l, r);
if (q_x <= mid) res += query(q_x, q_y, l, mid, ls(p));
if (q_y > mid) res += query(q_x, q_y, mid + 1, r, rs(p));
return res;
}
long long query2(long long q_x, long long q_y, long long l, long long r,
long long p) {
long long res = 0;
if (q_x <= l && r <= q_y) return cnt[p];
long long mid = (l + r) >> 1;
push_down(p, l, r);
if (q_x <= mid) res += query2(q_x, q_y, l, mid, ls(p));
if (q_y > mid) res += query2(q_x, q_y, mid + 1, r, rs(p));
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);
}
build(1, 1, n);
sort(a + 1, a + 1 + n, cmp);
long long tmp = 1;
a[1].vv = 1;
for (int i = 2; i <= n; i++) {
if (a[i].v != a[i - 1].v) tmp++;
a[i].vv = tmp;
}
long long ans = 0;
sort(a + 1, a + 1 + n, cmpp);
vector<long long> v;
for (int i = 1; i <= n; i++) {
long long tmpp = query(1, a[i].vv, 1, n, 1);
long long cntt = query2(1, a[i].vv, 1, n, 1);
ans += a[i].x * cntt - tmpp;
update(a[i].vv, a[i].vv, 1, n, 1, a[i].x);
}
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct data {
long long x, v, pos;
} p[200005];
struct seg {
long long val, cnt;
} f[1000005];
long n;
bool cmp(data a, data b) {
if (a.v == b.v)
return a.x < b.x;
else
return a.v < b.v;
}
bool cmp2(data a, data b) { return a.x < b.x; }
void update(long id, long l, long r, long u, long long k) {
if (l > u || r < u) return;
if (l == r) {
f[id].val = k;
f[id].cnt = 1;
return;
}
long mid = (l + r) >> 1;
update(id * 2, l, mid, u, k);
update(id * 2 + 1, mid + 1, r, u, k);
f[id].val = f[id * 2].val + f[id * 2 + 1].val;
f[id].cnt = f[id * 2].cnt + f[id * 2 + 1].cnt;
}
seg get(long id, long l, long r, long u, long v) {
if (l > v || r < u) return {0, 0};
if (l >= u && r <= v) return f[id];
long mid = (l + r) >> 1;
seg res, res1, res2;
res1 = get(id * 2, l, mid, u, v);
res2 = get(id * 2 + 1, mid + 1, r, u, v);
res.val = res1.val + res2.val;
res.cnt = res1.cnt + res2.cnt;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long i = 1; i <= n; i++) cin >> p[i].x;
for (long i = 1; i <= n; i++) cin >> p[i].v;
sort(p + 1, p + n + 1, cmp);
for (long i = 1; i <= n; i++) p[i].pos = i;
sort(p + 1, p + n + 1, cmp2);
long long res = 0;
for (long i = 1; i <= n; i++) {
seg tmp = get(1, 1, n, 1, p[i].pos - 1);
res += p[i].x * tmp.cnt - tmp.val;
update(1, 1, n, p[i].pos, p[i].x);
}
cout << res;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 100000007;
long long int MX = 1000000000;
long long int n;
pair<long long int, long long int> a[200200];
map<long long int, long long int> sor;
map<long long int, long long int> val;
long long int tree[600005];
long long int lazy[600005];
long long int tree1[600005];
long long int lazy1[600005];
void construct(long long int low, long long int high, long long int pos) {
if (low == high) {
tree[pos] = 0;
return;
}
long long int mid = (low + high) / 2;
construct(low, mid, 2 * pos + 1);
construct(mid + 1, high, 2 * pos + 2);
tree[pos] = tree[2 * pos + 1] + tree[2 * pos + 2];
}
long long int MRQ(long long int ql, long long int qh, long long int low,
long long int high, long long int pos) {
if (lazy[pos] != 0) {
tree[pos] += lazy[pos] * (high - low + 1);
if (low != high) {
lazy[2 * pos + 1] += lazy[pos];
lazy[2 * pos + 2] += lazy[pos];
}
lazy[pos] = 0;
}
if (low > qh || high < ql) return 0;
if (ql <= low && qh >= high) return tree[pos];
long long int mid = (low + high) / 2;
return MRQ(ql, qh, low, mid, 2 * pos + 1) +
MRQ(ql, qh, mid + 1, high, 2 * pos + 2);
}
void update(long long int ql, long long int qh, long long int val,
long long int low, long long int high, long long int pos) {
if (lazy[pos] != 0) {
tree[pos] += lazy[pos] * (high - low + 1);
if (low != high) {
lazy[2 * pos + 1] += lazy[pos];
lazy[2 * pos + 2] += lazy[pos];
}
lazy[pos] = 0;
}
if (low > qh || high < ql) return;
if (ql <= low && qh >= high) {
tree[pos] += val * (high - low + 1);
if (low != high) {
lazy[2 * pos + 1] += val;
lazy[2 * pos + 2] += val;
}
return;
}
long long int mid = (low + high) / 2;
update(ql, qh, val, low, mid, 2 * pos + 1);
update(ql, qh, val, mid + 1, high, 2 * pos + 2);
tree[pos] = tree[2 * pos + 1] + tree[2 * pos + 2];
}
void construct1(long long int low, long long int high, long long int pos) {
if (low == high) {
tree1[pos] = 0;
return;
}
long long int mid = (low + high) / 2;
construct1(low, mid, 2 * pos + 1);
construct1(mid + 1, high, 2 * pos + 2);
tree1[pos] = tree1[2 * pos + 1] + tree1[2 * pos + 2];
}
long long int MRQ1(long long int ql, long long int qh, long long int low,
long long int high, long long int pos) {
if (lazy1[pos] != 0) {
tree1[pos] += lazy1[pos] * (high - low + 1);
if (low != high) {
lazy1[2 * pos + 1] += lazy1[pos];
lazy1[2 * pos + 2] += lazy1[pos];
}
lazy1[pos] = 0;
}
if (low > qh || high < ql) return 0;
if (ql <= low && qh >= high) return tree1[pos];
long long int mid = (low + high) / 2;
return MRQ1(ql, qh, low, mid, 2 * pos + 1) +
MRQ1(ql, qh, mid + 1, high, 2 * pos + 2);
}
void update1(long long int ql, long long int qh, long long int val,
long long int low, long long int high, long long int pos) {
if (lazy1[pos] != 0) {
tree1[pos] += lazy1[pos] * (high - low + 1);
if (low != high) {
lazy1[2 * pos + 1] += lazy1[pos];
lazy1[2 * pos + 2] += lazy1[pos];
}
lazy1[pos] = 0;
}
if (low > qh || high < ql) return;
if (ql <= low && qh >= high) {
tree1[pos] += val * (high - low + 1);
if (low != high) {
lazy1[2 * pos + 1] += val;
lazy1[2 * pos + 2] += val;
}
return;
}
long long int mid = (low + high) / 2;
update1(ql, qh, val, low, mid, 2 * pos + 1);
update1(ql, qh, val, mid + 1, high, 2 * pos + 2);
tree1[pos] = tree1[2 * pos + 1] + tree1[2 * pos + 2];
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].first;
for (int i = 1; i <= n; i++) cin >> a[i].second;
for (int i = n; i >= 1; i--) {
sor[a[i].second]++;
}
map<long long int, long long int>::iterator itr;
int cnt = 0;
for (itr = sor.begin(); itr != sor.end(); itr++) {
cnt++;
val[itr->first] = cnt;
}
for (int i = 1; i <= n; i++) a[i].second = val[a[i].second];
sort(a + 1, a + n + 1);
construct(0, n, 0);
construct1(0, n, 0);
long long int res = 0;
for (int i = n; i >= 1; i--) {
res += MRQ(a[i].second, n, 0, n, 0) -
MRQ1(a[i].second, n, 0, n, 0) * a[i].first;
update1(a[i].second, a[i].second, 1, 0, n, 0);
update(a[i].second, a[i].second, a[i].first, 0, n, 0);
}
cout << res << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10, mod = 1e9 + 7, INF = 0x3f3f3f3f;
long long fwk[maxn], cnt[maxn];
void upd(int p, int c) {
for (; p < maxn; p += p & -p) fwk[p] += c, cnt[p]++;
}
void qry(int p, long long& sum, long long& c) {
sum = c = 0;
for (; p; p -= p & -p) sum += fwk[p], c += cnt[p];
}
vector<int> d;
inline int hs(int x) {
return lower_bound(d.begin(), d.end(), x) - d.begin() + 1;
}
pair<int, int> p[maxn];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%d", &p[i].first);
for (int i = 1; i <= n; ++i) {
scanf("%d", &p[i].second);
d.push_back(p[i].second);
}
sort(p + 1, p + 1 + n);
sort(d.begin(), d.end());
d.erase(unique(d.begin(), d.end()), d.end());
long long ans = 0, sum, c;
for (int i = 1; i <= n; ++i) {
qry(hs(p[i].second), sum, c);
ans += c * p[i].first - sum;
upd(hs(p[i].second), p[i].first);
}
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
constexpr long long maxN = 2e5 + 43;
long long n;
vector<pair<long long, long long>> point;
vector<long long> val, cnt, cval;
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;
}
bool Comp(const pair<long long, long long>& a,
const pair<long long, long long>& b) {
return a.first < b.first;
}
signed main() {
ios_base::sync_with_stdio(false);
cin >> n;
point.resize(n + 1);
val.resize(n + 1);
cnt.resize(n + 1);
cval.resize(n + 1);
for (long long i = 1; i <= n; ++i) {
cin >> point[i].first;
}
for (long long i = 1; i <= n; ++i) {
cin >> point[i].second;
val[i] = point[i].second;
}
sort(point.begin() + 1, point.begin() + n + 1);
sort(val.begin() + 1, val.begin() + n + 1);
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
long long pos =
lower_bound(val.begin() + 1, val.begin() + n + 1, point[i].second) -
val.begin();
ans += rsq(cnt, pos) * point[i].first - rsq(cval, pos);
update(cnt, pos, 1);
update(cval, pos, point[i].first);
}
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int MOD = 1000000000 + 7;
long long int inverse(long long int i) {
if (i == 1) return 1;
return (MOD - ((MOD / i) * inverse(MOD % i)) % MOD + MOD) % MOD;
}
long long int calc(vector<pair<long long int, long long int>>& v1, int st,
int fn) {
if (fn - st + 1 <= 1) return 0;
vector<pair<int, int>> temp(fn - st + 1);
int mid = (st + fn) / 2;
long long int r1 = calc(v1, st, mid);
r1 = r1 + calc(v1, mid + 1, fn);
long long int sum3 = 0;
for (int i = mid + 1; i <= fn; ++i) sum3 += v1[i].first;
int j = mid + 1;
for (int i = st; i <= mid; ++i) {
while (j <= fn && v1[j].second < v1[i].second) {
sum3 -= v1[j].first;
j++;
}
r1 = r1 + (sum3 - (fn - j + 1) * v1[i].first);
}
int st1 = st, st2 = mid + 1;
int count1 = 0;
while (st1 <= mid && st2 <= fn) {
if (v1[st1].second <= v1[st2].second) {
temp[count1].first = v1[st1].first;
temp[count1].second = v1[st1].second;
count1++;
st1++;
} else {
temp[count1].first = v1[st2].first;
temp[count1].second = v1[st2].second;
count1++;
st2++;
}
}
for (int i = st1; i <= mid; ++i) {
temp[count1].first = v1[i].first;
temp[count1].second = v1[i].second;
count1++;
}
for (int i = st2; i <= fn; ++i) {
temp[count1].first = v1[i].first;
temp[count1].second = v1[i].second;
count1++;
}
for (int i = st; i <= fn; ++i) {
v1[i].first = temp[i - st].first;
v1[i].second = temp[i - st].second;
}
return r1;
}
int main() {
int n;
cin >> n;
vector<pair<long long int, long long int>> v1, v2;
vector<long long int> temp1, temp2;
long long int x[n], v[n];
for (int i = 0; i < n; ++i) scanf("%lld", x + i);
for (int i = 0; i < n; ++i) scanf("%lld", v + i);
for (int i = 0; i < n; ++i) {
if (v[i] >= 0) {
v1.push_back({x[i], v[i]});
temp1.push_back(x[i]);
} else {
v2.push_back({x[i], v[i]});
temp2.push_back(x[i]);
}
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
long long int y = 0;
int n1 = v1.size();
int n2 = v2.size();
y = y + calc(v1, 0, n1 - 1);
y = y + calc(v2, 0, n2 - 1);
sort(temp1.begin(), temp1.end());
sort(temp2.begin(), temp2.end());
int n3 = temp2.size();
long long int sum4 = 0;
int st1 = 0;
for (int i = 0; i < temp1.size(); ++i) {
while (st1 < n3 && temp2[st1] < temp1[i]) {
sum4 += temp2[st1];
st1++;
}
y = y + st1 * temp1[i] - sum4;
}
printf("%lld\n", y);
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pli = pair<ll, int>;
using pii = pair<int, int>;
constexpr ll mod = 1e9 + 7;
constexpr int N = 200010;
struct node {
ll x;
int v, id;
bool operator<(const node &o) const { return x < o.x; }
} q[N];
int n, nn, b[N];
ll fw[2][N];
int lowbit(int x) { return x & -x; }
void update(int op, int k, int x) {
for (; k <= n; k += lowbit(k)) fw[op][k] += x;
}
ll query(int op, int k) {
ll res = 0;
for (; k; k -= lowbit(k)) res += fw[op][k];
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T = 1;
while (T--) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> q[i].x;
for (int i = 1; i <= n; i++) {
cin >> q[i].v;
b[i] = q[i].v;
q[i].id = i;
}
sort(b + 1, b + 1 + n);
nn = unique(b + 1, b + 1 + n) - b - 1;
for (int i = 1; i <= n; i++)
q[i].v = lower_bound(b + 1, b + 1 + nn, q[i].v) - b;
sort(q + 1, q + 1 + n);
ll res = 0;
for (int i = 1; i <= n; i++) {
res += q[i].x * query(0, q[i].v) - query(1, q[i].v);
update(0, q[i].v, 1);
update(1, q[i].v, q[i].x);
}
cout << res << '\n';
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 5;
int n, t[M], k;
long long ans;
struct node {
long long p;
int v;
} a[M];
struct BIT {
long long s[M];
void add(int i, long long x) {
for (; i <= k; i += i & -i) s[i] += x;
}
long long ask(int i) {
long long res = 0;
for (; i > 0; i -= i & -i) res += s[i];
return res;
}
} f1, f2;
inline int find(int x) {
int l = 1, r = k, mid;
while (l < r) {
mid = (l + r) >> 1;
if (t[mid] < x)
l = mid + 1;
else
r = mid;
}
return l;
}
int cmp(node x, node y) { return x.p < y.p; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i].p);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
t[i] = a[i].v;
}
sort(a + 1, a + n + 1, cmp);
sort(t + 1, t + n + 1);
k++;
for (int i = 2; i <= n; i++)
if (t[i] != t[i - 1]) t[++k] = t[i];
for (int i = 1; i <= n; i++) {
int w = find(a[i].v);
ans += a[i].p * f1.ask(w) - f2.ask(w);
f1.add(w, 1);
f2.add(w, a[i].p);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long lxt() {
long long aaa;
scanf("%lld", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
class fenwick {
public:
long long tree[200005] = {0};
void Update(int pos, long long val, int limit) {
while (pos <= limit) {
tree[pos] += val;
pos += pos & (-pos);
}
}
long long Query(int pos) {
long long sum = 0;
while (pos > 0) {
sum += tree[pos];
pos -= pos & (-pos);
}
return sum;
}
} past, pastSum;
void solve() {
vector<pair<long long, long long>> v;
int n = nxt();
for (int i = 0; i < n; i++) {
v.emplace_back(lxt(), 0);
}
for (int i = 0; i < n; i++) {
v[i].second = lxt();
}
sort(v.begin(), v.end());
set<long long> st;
for (int i = 0; i < n; i++) st.insert(v[i].second);
vector<long long> velocity(st.begin(), st.end());
n = (int)(velocity).size();
long long ans = 0;
for (int i = 0; i < (int)(v).size(); i++) {
int pos = lower_bound(velocity.begin(), velocity.end(), v[i].second) -
velocity.begin();
ans += past.Query(pos + 1) * v[i].first - pastSum.Query(pos + 1);
past.Update(pos + 1, 1LL, n);
pastSum.Update(pos + 1, v[i].first, n);
}
printf("%lld\n", ans);
}
int main() {
cout.setf(ios::fixed);
cout.precision(10);
int tc = 1;
while (tc--) {
solve();
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long bit1[200005], bit2[200005];
inline void upd(long long idx, long long val, long long bit[]) {
while (idx < 200005) {
bit[idx] += val;
idx += (idx & -idx);
}
}
inline long long que(long long idx, long long bit[]) {
long long ans = 0;
while (idx > 0) {
ans += bit[idx];
idx -= (idx & -idx);
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<long long> v;
map<long long, long long> m;
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;
if (m[arr[i].second] == 0) {
m[arr[i].second]++;
v.push_back(arr[i].second);
}
}
sort(v.begin(), v.end());
sort(arr, arr + n);
for (long long i = 0; i < n; i++) {
long long x = lower_bound(v.begin(), v.end(), arr[i].second) - v.begin();
arr[i].second = x + 1;
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long x = que(arr[i].second, bit1), y = que(arr[i].second, bit2);
ans += (x * arr[i].first - y);
upd(arr[i].second, 1, bit1);
upd(arr[i].second, arr[i].first, bit2);
}
cout << ans << '\n';
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n;
pair<long long, long long> p[200005];
long long v[200005];
map<long long, long long> m;
long long f0[200005];
long long f1[200005];
void up0(long long x, long long val) {
for (long long i = x; i <= 200000; i += i & -i) f0[i] += val;
}
void up1(long long x, long long val) {
for (long long i = x; i <= 200000; i += i & -i) f1[i] += val;
}
long long get0(long long pos) {
long long ans = 0;
for (long long i = pos; i > 0; i -= i & -i) ans += f0[i];
return ans;
}
long long get1(long long pos) {
long long ans = 0;
for (long long i = pos; i > 0; i -= i & -i) ans += f1[i];
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 >> p[i].first;
for (long long i = 1; i <= n; i++) {
cin >> p[i].second;
v[i] = p[i].second;
}
sort(v + 1, v + 1 + n);
sort(p + 1, p + 1 + n);
long long c = 0;
for (long long i = 1; i <= n; i++) {
if (m[v[i]] == 0) {
m[v[i]] = ++c;
}
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
long long x = p[i].first;
long long sp = p[i].second;
long long c = get0(m[sp]);
long long cur = get1(m[sp]);
ans += x * c - cur;
up0(m[sp], 1);
up1(m[sp], x);
}
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {1, -1, 1, 0, -1, 0, 1, -1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
long long a[200005];
long long dp[200005];
long long tr[2][200005];
void update(long long f, long long x, long long val) {
while (x < 200005) {
tr[f][x] += val;
x += x & (-x);
}
}
long long query(long long f, long long x) {
long long s = 0;
while (x > 0) {
s += tr[f][x];
x -= x & (-x);
}
return s;
}
int main() {
long long n, i, j;
string t;
while (cin >> n) {
for (i = 1; i <= n; i++) cin >> a[i];
vector<pair<long long, long long> > v;
map<long long, long long> mp;
for (i = 1; i <= n; i++) {
long long x;
cin >> x;
v.push_back(make_pair(a[i], x));
mp[x];
}
map<long long, long long>::iterator it;
sort(v.begin(), v.end());
long long cn = 0;
for (it = mp.begin(); it != mp.end(); it++) it->second = ++cn;
long long ans = 0;
reverse(v.begin(), v.end());
for (i = 0; i < v.size(); i++) {
long long p = v[i].first;
long long q = mp[v[i].second];
long long r = query(0, cn) - query(0, q - 1);
long long r1 = query(1, cn) - query(1, q - 1);
update(0, q, 1);
update(1, q, p);
ans += (r1 - p * r);
}
cout << ans << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int tab_x[200000 + 5];
int tab_v[200000 + 5];
long long D_dist[550000 + 5];
int D_ile[550000 + 5];
int zakresy[550000 + 5][2];
int max_pot = 1;
int QUERRY_ile(int L, int R, int w) {
if (zakresy[w][0] > R || L > zakresy[w][1]) return 0;
if (L <= zakresy[w][0] && zakresy[w][1] <= R) return D_ile[w];
return QUERRY_ile(L, R, w * 2) + QUERRY_ile(L, R, w * 2 + 1);
}
long long QUERRY_dist(int L, int R, int w) {
if (zakresy[w][0] > R || L > zakresy[w][1]) return 0;
if (L <= zakresy[w][0] && zakresy[w][1] <= R) return D_dist[w];
return QUERRY_dist(L, R, w * 2) + QUERRY_dist(L, R, w * 2 + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> tab_x[i];
for (int i = 0; i < n; i++) cin >> tab_v[i];
vector<pair<int, int> > V_0;
for (int i = 0; i < n; i++) V_0.push_back({tab_x[i], tab_v[i]});
sort(V_0.begin(), V_0.end());
for (int i = 0; i < n; i++) {
tab_x[i] = V_0[i].first;
tab_v[i] = V_0[i].second;
}
priority_queue<pair<int, int> > PQ;
for (int i = 0; i < n; i++) PQ.push({-tab_v[i], i});
int last_ = INT_MIN;
int name_num = 0;
while (!PQ.empty()) {
int top_val = -PQ.top().first;
int top_place = PQ.top().second;
PQ.pop();
if (top_val != last_) {
name_num++;
last_ = top_val;
}
tab_v[top_place] = name_num;
}
while (max_pot < name_num) max_pot *= 2;
for (int i = max_pot; i < 2 * max_pot; i++)
zakresy[i][0] = zakresy[i][1] = i - max_pot + 1;
for (int i = max_pot - 1; i >= 1; i--) {
zakresy[i][0] = zakresy[2 * i][0];
zakresy[i][1] = zakresy[2 * i + 1][1];
}
long long RESULT = 0;
for (int i = 0; i < n; i++) {
long long akt_x = tab_x[i];
int akt_v = tab_v[i];
int ile_ = QUERRY_ile(1, akt_v, 1);
long long suma_dist = QUERRY_dist(1, akt_v, 1);
long long bazowy_koszt = ile_;
bazowy_koszt *= akt_x;
bazowy_koszt -= suma_dist;
RESULT += bazowy_koszt;
int w = max_pot + akt_v - 1;
while (w) {
D_ile[w]++;
D_dist[w] += akt_x;
w /= 2;
}
}
cout << RESULT;
}
| 12 | CPP |
def bitadd(a,w,bit):
x = a
while x <= (len(bit)-1):
bit[x] += w
x += x & (-1 * x)
def bitsum(a,bit):
ret = 0
x = a
while x > 0:
ret += bit[x]
x -= x & (-1 * x)
return ret
n = int(input())
x = list(map(int,input().split()))
v = list(map(int,input().split()))
vlis = []
for i in v:
vlis.append(i)
vlis.sort()
vdic = {}
for i in range(n):
vdic[vlis[i]] = i+1
#print (vdic)
xv = []
for i in range(n):
xv.append([x[i],v[i]])
xv.sort()
ans = 0
BIT = [0] * (n+1)
BIT2 = [0] * (n+1)
for i in range(n):
x,v = xv[i]
ans += x * bitsum(vdic[v],BIT2) - bitsum(vdic[v],BIT)
bitadd(vdic[v] , x , BIT)
bitadd(vdic[v] , 1 , BIT2)
print (ans) | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
const int xn = 2e5 + 10;
const int xm = 5e5;
const int SQ = 750;
const int sq = 1e3 + 10;
const long long inf = 1e18 + 10;
long long power(long long a, long long b) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2) % md
: power(a * a % md, b / 2) % md));
}
int n;
map<int, int> mp;
pair<long long, long long> X[xn];
long long x[xn], v[xn], PS[xn], t[xn], ans;
void Get(int l, int r, int ind) {
for (int i = l; i <= r;) {
if (i % SQ == 0 && i + SQ - 1 <= r) {
ans -= PS[i / SQ] - x[ind] * t[i / SQ];
i += SQ;
} else {
if (v[i] <= v[ind]) ans += x[ind] - x[i];
i++;
}
}
}
void Update(int ind) {
PS[ind / SQ] += x[ind];
t[ind / SQ]++;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++) X[i] = {x[i], v[i]};
sort(X, X + n);
for (int i = 0; i < n; i++)
x[i] = X[i].first, v[i] = X[i].second, swap(X[i].first, X[i].second),
mp[x[i]] = i;
sort(X, X + n);
for (int i = 0; i < n; i++) {
Get(0, mp[X[i].second] - 1, mp[X[i].second]);
Update(mp[X[i].second]);
}
cout << ans << '\n';
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long ppow(long long a, long long b, long long mod) {
a %= mod;
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long readdd() {
long long x = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') f = -1, c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return f * x;
}
void printtt(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) printtt(x / 10);
putchar(x % 10 + '0');
}
const long long maxm = 1e6 + 5;
long long c[maxm];
long long cc[maxm];
long long xx[maxm];
struct Node {
long long x, v;
} e[maxm];
bool cmp(Node a, Node b) {
if (a.v != b.v) {
return a.v < b.v;
} else {
return a.x < b.x;
}
}
long long lowbit(long long i) { return i & -i; }
void add(long long i, long long c[], long long t) {
while (i < maxm) {
c[i] += t;
i += lowbit(i);
}
}
long long ask(long long i, long long c[]) {
long long ans = 0;
while (i) {
ans += c[i];
i -= lowbit(i);
}
return ans;
}
signed main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> e[i].x;
xx[i] = e[i].x;
}
for (long long i = 1; i <= n; i++) {
cin >> e[i].v;
}
sort(xx + 1, xx + 1 + n);
long long num = unique(xx + 1, xx + 1 + n) - xx - 1;
for (long long i = 1; i <= n; i++) {
e[i].x = lower_bound(xx + 1, xx + 1 + num, e[i].x) - xx;
}
sort(e + 1, e + 1 + n, cmp);
long long ans = 0;
for (long long i = 1; i <= n; i++) {
if (e[i].x != 1) {
long long mi = ask(e[i].x, c);
long long temp = ask(e[i].x, cc);
temp -= mi * ((long long)1e9 - xx[e[i].x]);
ans += temp;
}
add(e[i].x, c, 1);
add(e[i].x, cc, ((long long)1e9 - xx[e[i].x]));
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 15;
int tot = 1, N;
const int L = -2e8;
const int R = 2e8;
struct Node {
int l, r, num;
long long sum;
Node() { l = 0, r = 0, num = 0, sum = 0; }
} E[maxn * 40];
struct Point {
long long x, v;
bool operator<(const Point &T) const { return x > T.x; }
} P[maxn];
void update(int l, int r, int x, int v, int id) {
if (l == r) {
E[id].num++;
E[id].sum += x;
return;
}
int mid = (l + r) >> 1;
if (v <= mid) {
if (!E[id].l) E[id].l = ++tot;
update(l, mid, x, v, E[id].l);
} else {
if (!E[id].r) E[id].r = ++tot;
update(mid + 1, r, x, v, E[id].r);
}
E[id].num = E[E[id].l].num + E[E[id].r].num;
E[id].sum = E[E[id].l].sum + E[E[id].r].sum;
}
void getSum(int l, int r, int ln, int rn, int id, int &num, long long &sum) {
if (ln > rn) return;
if (ln == l && rn == r) {
num += E[id].num;
sum += E[id].sum;
return;
}
int mid = (l + r) >> 1;
if (ln > mid && E[id].r)
getSum(mid + 1, r, ln, rn, E[id].r, num, sum);
else if (rn <= mid && E[id].l)
getSum(l, mid, ln, rn, E[id].l, num, sum);
else {
if (E[id].r) getSum(mid + 1, r, mid + 1, rn, E[id].r, num, sum);
if (E[id].l) getSum(l, mid, ln, mid, E[id].l, num, sum);
}
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%lld", &P[i].x);
for (int i = 1; i <= N; i++) scanf("%lld", &P[i].v);
sort(P + 1, P + 1 + N);
long long ans = 0;
for (int i = 1; i <= N; i++) {
int num = 0;
long long sum = 0;
getSum(L, R, P[i].v, R, 1, num, sum);
ans += (sum - 1LL * num * P[i].x);
update(L, R, P[i].x, P[i].v, 1);
}
printf("%lld\n", ans);
return 0;
}
| 12 | CPP |
class Points:
def __init__(self, x = 0, v = 0):
self.x, self.v = x, v
class Fenwick_tree:
def __init__(self, n = 0):
self.n = n
self.bit = [0] * (n + 1)
def update(self, x, value):
while x <= self.n:
self.bit[x] += value
x += x & -x
def get(self, x):
sum = 0;
while x > 0:
sum += self.bit[x];
x -= x & -x
return sum
# Input:
n, x, v = int(input()), list(map(int,input().split())), list(map(int,input().split()))
a = [Points(x[i], v[i]) for i in range(n)]
a.sort(key = lambda value: value.x)
# Compress data:
v = [a[i].v for i in range(n)]
v.sort()
data = {}
cnt = 1
for i in range(n):
if not data.__contains__(v[i]):
data[v[i]] = cnt
cnt += 1
# Solve the problem:
cnt = Fenwick_tree(n)
sum = Fenwick_tree(n)
res, i = 0, 0
for i in range(n):
a[i].v = data[a[i].v]
res += a[i].x * cnt.get(a[i].v) - sum.get(a[i].v)
cnt.update(a[i].v, 1)
sum.update(a[i].v, a[i].x)
print(res) | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const int MOD = 998244353;
const int INF = 0x3f3f3f3f;
struct Node {
int x;
int v;
} a[MAXN];
bool cmp(Node a, Node b) {
if (a.v == b.v) {
return a.x < b.x;
}
return a.v < b.v;
}
int N, M;
vector<int> dic;
int main() {
int now;
long long ans;
while (~scanf("%d", &N)) {
dic.clear();
for (int i = 0; i < N; i++) {
scanf("%d", &a[i].x);
dic.push_back(a[i].x);
}
for (int i = 0; i < N; i++) {
scanf("%d", &a[i].v);
}
sort(a, a + N, cmp);
sort(dic.begin(), dic.end());
ans = 0;
for (int i = 0; i < N; i++) {
now = upper_bound(dic.begin(), dic.end(), a[i].x) - dic.begin();
ans += (long long)(now - N + i) * a[i].x;
}
printf("%lld\n", ans);
}
return 0;
}
| 12 | CPP |
class SegmentTree():
def __init__(self,arr,func,initialRes=0):
self.f=func
self.N=len(arr)
self.tree=[0 for _ in range(4*self.N)]
self.initialRes=initialRes
for i in range(self.N):
self.tree[self.N+i]=arr[i]
for i in range(self.N-1,0,-1):
self.tree[i]=self.f(self.tree[i<<1],self.tree[i<<1|1])
def updateTreeNode(self,idx,value): #update value at arr[idx]
self.tree[idx+self.N]=value
idx+=self.N
i=idx
while i>1:
self.tree[i>>1]=self.f(self.tree[i],self.tree[i^1])
i>>=1
def query(self,l,r): #get sum (or whatever function) on interval [l,r] inclusive
r+=1
res=self.initialRes
l+=self.N
r+=self.N
while l<r:
if l&1:
res=self.f(res,self.tree[l])
l+=1
if r&1:
r-=1
res=self.f(res,self.tree[r])
l>>=1
r>>=1
return res
def getMaxSegTree(arr):
return SegmentTree(arr,lambda a,b:max(a,b),initialRes=-float('inf'))
def getMinSegTree(arr):
return SegmentTree(arr,lambda a,b:min(a,b),initialRes=float('inf'))
def getSumSegTree(arr):
return SegmentTree(arr,lambda a,b:a+b,initialRes=0)
def main():
n=int(input())
xes=readIntArr()
ves=readIntArr()
#perform coordinate compression on xes. Compressed values shall be the indexes of segment tree
xes2=list(sorted(xes)) #xes2[compressed]=x
xTox2Map=dict()
for i,x in enumerate(xes2):
xTox2Map[x]=i #xTox2Map[x]=i
arr=[] #[original x, compressed x, v]
for i in range(n):
arr.append([xes[i],xTox2Map[xes[i]],ves[i]])
arr.sort(key=lambda x:(x[2],x[0])) #sort by v asc, then position asc
segArray=[0 for _ in range(n)] #index shall be compressed x, value is actual x
st=getSumSegTree(segArray) #for sum of xes
stCnts=getSumSegTree(segArray.copy()) #for counts
# print(arr)
ans=0
for originalX,compressedX,v in arr:
smallerSums=st.query(0,compressedX)
smallerCounts=stCnts.query(0,compressedX)
ans+=originalX*smallerCounts-smallerSums
st.updateTreeNode(compressedX,originalX) #update the tree
stCnts.updateTreeNode(compressedX,1)
# print(ans)
print(ans)
return
import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
# import sys
# input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
inf=float('inf')
MOD=10**9+7
main() | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void coordinatecompress(vector<int> &data) {
int n = data.size();
vector<pair<int, int> > tempdata(n);
for (int i = 0; i < n; i++) tempdata[i] = {data[i], i};
sort(tempdata.begin(), tempdata.end());
data[tempdata[0].second] = 0;
for (int i = 1; i < n; i++)
data[tempdata[i].second] = data[tempdata[i - 1].second] +
(tempdata[i - 1].first != tempdata[i].first);
}
struct segTree {
long long cnt, sum;
};
const int N = 2e5;
segTree tree[4 * N + 1], lazy[4 * N + 1];
void updt(int s, int e, int node, int l, int r, int val) {
tree[node].sum += lazy[node].sum * (e - s + 1);
tree[node].cnt += lazy[node].cnt * (e - s + 1);
int mid = (s + e) / 2;
if (s != e) {
lazy[2 * node + 1].sum += lazy[node].sum;
lazy[2 * node + 2].sum += lazy[node].sum;
lazy[2 * node + 1].cnt += lazy[node].cnt;
lazy[2 * node + 2].cnt += lazy[node].cnt;
}
lazy[node] = {0, 0};
if (r < s || l > e) return;
if (s >= l && e <= r) {
tree[node].sum += val * (e - s + 1);
tree[node].cnt += e - s + 1;
if (s != e) {
lazy[2 * node + 1].sum += val;
lazy[2 * node + 2].sum += val;
lazy[2 * node + 1].cnt++;
;
lazy[2 * node + 2].cnt++;
;
}
return;
}
updt(s, mid, 2 * node + 1, l, r, val);
updt(mid + 1, e, 2 * node + 2, l, r, val);
tree[node].sum = tree[2 * node + 1].sum + tree[2 * node + 2].sum;
tree[node].cnt = tree[2 * node + 1].cnt + tree[2 * node + 2].cnt;
}
segTree qry(int s, int e, int node, int i, int j) {
tree[node].sum += lazy[node].sum * (e - s + 1);
tree[node].cnt += lazy[node].cnt * (e - s + 1);
int mid = (s + e) / 2;
if (s != e) {
lazy[2 * node + 1].sum += lazy[node].sum;
lazy[2 * node + 2].sum += lazy[node].sum;
lazy[2 * node + 1].cnt += lazy[node].cnt;
lazy[2 * node + 2].cnt += lazy[node].cnt;
}
lazy[node] = {0, 0};
if (e < i || s > j) return {0, 0};
if (s >= i && e <= j) {
return tree[node];
}
segTree ans1 = qry(s, mid, 2 * node + 1, i, j),
ans2 = qry(mid + 1, e, 2 * node + 2, i, j);
tree[node].sum = ans1.sum + ans2.sum;
tree[node].cnt = ans1.cnt + ans2.cnt;
return tree[node];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<pair<int, int> > point(n);
vector<int> p(n), v(n), tmp, org(n);
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < n; i++) cin >> v[i];
tmp = p;
coordinatecompress(p);
for (int i = 0; i < n; i++) {
org[p[i]] = tmp[i];
point[i] = {v[i], p[i]};
}
long long ans = 0;
sort(point.begin(), point.end());
for (auto [s, x] : point) {
segTree res = qry(0, n - 1, 0, x, x);
ans += res.cnt * org[x] - res.sum;
updt(0, n - 1, 0, x + 1, n - 1, org[x]);
}
cout << ans;
return 0;
}
| 12 | CPP |
# -*- coding: utf-8 -*-
import sys
from collections import Counter
from bisect import bisect_left
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
# sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
class BIT:
def __init__(self, n):
n += 1
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def get(self, l, r=None):
if r is None: r = l + 1
res = 0
if r: res += self.sum(r-1)
if l: res -= self.sum(l-1)
return res
def update(self, i, x):
self.add(i, x - self.get(i))
N = INT()
A = LIST()
B = LIST()
AB = list(zip(A, B))
AB.sort()
B = sorted(set(B))
M = len(B)
bit1 = BIT(M)
bit2 = BIT(M)
ans = 0
for a, b in AB:
pos = bisect_left(B, b)
sm = bit1.sum(pos)
cnt = bit2.sum(pos)
ans += cnt * a - sm
bit1.add(pos, a)
bit2.add(pos, 1)
print(ans)
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> v;
long long arr[200005];
map<long long, long long> mp;
map<long long, long long> rmp;
pair<long long, long long> bit[200005];
set<long long> s;
void insert(long long ind) {
for (long long i = ind; i < 200005; i += i & -i)
bit[i].first += 1, bit[i].second += rmp[ind];
}
pair<long long, long long> query(long long ind) {
pair<long long, long long> ret = {0, 0};
if (ind == 0) return ret;
for (long long i = ind; i > 0; i -= i & -i)
ret.first += bit[i].first, ret.second += bit[i].second;
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> arr[i], s.insert(arr[i]);
long long c = 1;
for (auto i : s) rmp[c] = i, mp[i] = c++;
for (long long i = 0; i < n; i++) {
long long ve;
cin >> ve;
v.push_back({ve, mp[arr[i]]});
}
sort(v.begin(), v.end(), greater<pair<long long, long long>>());
long long ans = 0;
c = 0;
long long val = 0;
for (auto i : v) {
pair<long long, long long> q = query(i.second);
long long num = c - q.first;
long long sum = val - q.second;
ans += (sum - num * rmp[i.second]);
c++;
val += rmp[i.second];
insert(i.second);
}
cout << ans << "\n";
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const ll INF = static_cast<ll>(1e18);
struct FlowEdge {
int v, u;
long long cap, flow = 0;
FlowEdge(int v, int u, long long cap) : v(v), u(u), cap(cap) {}
};
struct Dinic {
const long long flow_inf = 1e18;
vector<FlowEdge> edges;
vector<vector<int>> adj;
int n, m = 0;
int s, t;
vector<int> level, ptr;
queue<int> q;
Dinic(int n, int s, int t) : n(n), s(s), t(t) {
adj.resize(n);
level.resize(n);
ptr.resize(n);
}
void add_edge(int v, int u, long long cap) {
edges.emplace_back(v, u, cap);
edges.emplace_back(u, v, 0);
adj[v].push_back(m);
adj[u].push_back(m + 1);
m += 2;
}
bool bfs() {
while (!q.empty()) {
int v = q.front();
q.pop();
for (int id : adj[v]) {
if (edges[id].cap - edges[id].flow < 1) continue;
if (level[edges[id].u] != -1) continue;
level[edges[id].u] = level[v] + 1;
q.push(edges[id].u);
}
}
return level[t] != -1;
}
long long dfs(int v, long long pushed) {
if (pushed == 0) return 0;
if (v == t) return pushed;
for (int& cid = ptr[v]; cid < (int)adj[v].size(); cid++) {
int id = adj[v][cid];
int u = edges[id].u;
if (level[v] + 1 != level[u] || edges[id].cap - edges[id].flow < 1)
continue;
long long tr = dfs(u, min(pushed, edges[id].cap - edges[id].flow));
if (tr == 0) continue;
edges[id].flow += tr;
edges[id ^ 1].flow -= tr;
return tr;
}
return 0;
}
long long flow() {
long long f = 0;
while (true) {
fill(level.begin(), level.end(), -1);
level[s] = 0;
q.push(s);
if (!bfs()) break;
fill(ptr.begin(), ptr.end(), 0);
while (long long pushed = dfs(s, flow_inf)) {
f += pushed;
}
}
return f;
}
};
template <typename T>
struct FenwickTree {
vector<T> bit;
FenwickTree(int sz) : bit(sz + 1) {}
void update(int x, T delta) {
for (int i = ++x; i < bit.size(); i += i & -i) bit[i] += delta;
}
T query(int x) {
T ans{};
for (int i = ++x; i > 0; i -= i & -i) ans += bit[i];
return ans;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
srand(time(nullptr));
int n;
cin >> n;
vector<pair<int, int>> P(n);
for (int i = 0; i < n; i++) cin >> P[i].first;
set<int> speeds, pos;
for (int i = 0; i < n; i++) {
cin >> P[i].second;
speeds.insert(P[i].second);
pos.insert(P[i].first);
}
int cnt = 0;
map<int, int> mp;
for (int s : speeds) mp[s] = cnt++;
sort(P.begin(), P.end());
ll tot = 0, pt = 0;
for (int i = 0; i < n; i++) {
tot += 1LL * i * P[i].first - pt;
pt += P[i].first;
}
const int MAXS = cnt + 10;
FenwickTree<ll> fenw(MAXS);
FenwickTree<int> fpos(MAXS);
for (int i = 0; i < n; i++) {
ll times = fpos.query(MAXS - 1) - fpos.query(mp[P[i].second]);
tot -= (1LL * P[i].first * times);
tot += fenw.query(MAXS - 1) - fenw.query(mp[P[i].second]);
fenw.update(mp[P[i].second], P[i].first);
fpos.update(mp[P[i].second], +1);
}
cout << tot << '\n';
return 0;
}
| 12 | CPP |
import sys
input=sys.stdin.readline
def getsum(BITTree,i):
s = 0
while i > 0:
s += BITTree[i]
i -= i & (-i)
return(s)
def updatebit(BITTree , n , i ,v):
while i <= n:
BITTree[i] += v
i += i & (-i)
n=int(input())
x=[int(i) for i in input().split() if i!='\n']
v=[int(i) for i in input().split() if i!='\n']
for i in range(n):
v[i]=[v[i],i]
v.sort()
pos=dict()
store,prev=1,v[0][0]
for i in range(n):
if i>0:
if prev==v[i][0]:
pos[x[v[i][1]]]=store
else:
store+=1
pos[x[v[i][1]]]=store
prev=v[i][0]
else:
pos[x[v[i][1]]]=store
sort=sorted(pos.keys())
bit=[0]*(n+1)
ind=[0]*(n+1)
ans,count,diff=0,0,0
length=max(sort)
total=0
for i in range(len(sort)-1,-1,-1):
count=getsum(bit,pos[sort[i]]-1)
diff=getsum(ind,pos[sort[i]]-1)
if i<(n-1):
total+=(sort[i+1]-sort[i])*(n-1-i)
ans+=total-(diff-count*sort[i])
updatebit(bit,len(bit)-1,pos[sort[i]],1)
updatebit(ind,len(ind)-1,pos[sort[i]],sort[i])
print(int(ans))
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mx = 2 * 1e5 + 5;
const long long mod = 1e9 + 7;
long long sum[mx];
long long num[mx];
void update(int pos, int value) {
while (pos <= mx) {
sum[pos] += value;
num[pos]++;
pos += (pos & -pos);
}
}
pair<int, long long> query(int pos) {
long long summ = 0;
long long numm = 0;
while (pos >= 1) {
summ += sum[pos];
numm += num[pos];
pos -= (pos & -pos);
}
return {numm, summ};
}
int main() {
int n;
cin >> n;
pair<long long, long long> p[n];
map<long long, int> mp;
for (int i = 0; i < n; i++) {
cin >> p[i].first;
}
for (int i = 0; i < n; i++) {
cin >> p[i].second;
mp[p[i].second] = i;
}
int cur = 1LL;
for (auto& i : mp) {
i.second = cur;
cur++;
}
for (int i = 0; i < n; i++) {
p[i].second = mp[p[i].second];
}
sort(p, p + n);
long long ans = 0;
for (int i = 0; i < n; i++) {
long long myv = p[i].second;
long long myx = p[i].first;
pair<long long, long long> cnt = query(myv);
ans += (1LL * myx * cnt.first);
ans -= cnt.second;
update(myv, myx);
}
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
struct node {
long long a;
long long t;
} w[N];
bool cmp(node a, node b) { return a.a < b.a; }
long long c[N][2], cnt[N], n;
long long lowbit(long long x) { return x & (-x); }
void add(long long x, long long val) {
while (x <= n) c[x][0]++, c[x][1] += val, x += lowbit(x);
}
long long ask(long long x, long long k) {
long long res = 0;
while (x) res += c[x][k], x -= lowbit(x);
return res;
}
long long ans = 0, len = 0;
struct EDGE {
long long to, next;
long long dis;
} edge[N];
struct ha {
long long pos;
long long dis;
friend bool operator<(ha a, ha b) { return a.dis > b.dis; }
};
long long tot;
long long head[N];
long long dis[N];
bool vis[N];
void Init(long long n) {
for (long long i = 1; i <= n; ++i) dis[i] = 1;
}
void add(long long from, long long to, long long cost) {
++tot;
edge[tot].to = to;
edge[tot].dis = cost;
edge[tot].next = head[from];
head[from] = tot;
}
priority_queue<ha> q;
void Dijkstra(long long s) {
dis[s] = 0;
q.push({s, 0});
while (!q.empty()) {
ha tmp = q.top();
q.pop();
long long x = tmp.pos;
if (vis[x]) continue;
vis[x] = 1;
for (long long i = head[x]; i; i = edge[i].next) {
long long y = edge[i].to;
if (dis[y] > dis[x] + edge[i].dis) {
dis[y] = dis[x] + edge[i].dis;
if (!vis[y]) {
q.push({y, dis[y]});
}
}
}
}
}
void solve() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> w[i].a;
for (long long i = 1; i <= n; i++) cin >> w[i].t, cnt[++len] = w[i].t;
sort(w + 1, w + 1 + n, cmp);
sort(cnt + 1, cnt + 1 + len);
len = unique(cnt + 1, cnt + 1 + len) - cnt - 1;
for (long long i = 1; i <= n; i++) {
long long now = lower_bound(cnt + 1, cnt + 1 + len, w[i].t) - cnt;
ans += w[i].a * ask(now, 0) - ask(now, 1);
add(now, w[i].a);
}
cout << ans << '\n';
}
signed main() {
solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
class STlazy {
private:
int n;
vector<long long> node, lazy;
public:
STlazy(vector<long long> v) {
int siz = v.size();
n = 1;
while (n < siz) n *= 2;
node.resize(2 * n - 1, 0);
lazy.resize(2 * n - 1, 0);
for (int i = 0; i < siz; i++) node[n - 1 + i] = v[i];
for (int i = n - 2; i >= 0; i--)
node[i] = node[2 * i + 1] + node[2 * i + 2];
}
void eval(int k, int l, int r) {
if (lazy[k] == 0) return;
node[k] += lazy[k];
if (r - l > 1) {
lazy[2 * k + 1] += lazy[k] / 2;
lazy[2 * k + 2] += lazy[k] / 2;
}
lazy[k] = 0;
}
void add(int a, int b, long long x, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
eval(k, l, r);
if (r <= a || b <= l) return;
if (a <= l && r <= b) {
lazy[k] += (r - l) * x;
eval(k, l, r);
return;
}
add(a, b, x, 2 * k + 1, l, (l + r) / 2);
add(a, b, x, 2 * k + 2, (l + r) / 2, r);
node[k] = node[2 * k + 1] + node[2 * k + 2];
}
long long query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
if (r <= a || b <= l) return 0;
eval(k, l, r);
if (a <= l && r <= b) return node[k];
long long lx = query(a, b, 2 * k + 1, l, (l + r) / 2);
long long rx = query(a, b, 2 * k + 2, (l + r) / 2, r);
return lx + rx;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<pair<int, int> > vp(n);
for (int i = 0; i < n; i++) {
cin >> vp[i].first;
}
for (int i = 0; i < n; i++) {
cin >> vp[i].second;
}
sort(vp.begin(), vp.end());
vector<long long> vel;
for (pair<int, int> &p : vp) vel.push_back(p.second);
sort(vel.begin(), vel.end());
vel.erase(unique(vel.begin(), vel.end()), vel.end());
auto f = [&](long long x) -> int {
return lower_bound(vel.begin(), vel.end(), x) - vel.begin();
};
int siz = vel.size();
vector<long long> tmp(siz, 0), cnt(siz, 0);
for (pair<int, int> &p : vp) {
int pos = f(p.second);
tmp[pos] += p.first;
cnt[pos]++;
}
STlazy A(tmp), B(cnt);
long long ans = 0;
for (int i = 0; i < n; i++) {
int v = vp[i].second;
int pos = f(v);
A.add(pos, pos + 1, -vp[i].first);
B.add(pos, pos + 1, -1);
if (v == 0) {
ans += A.query(pos, siz + 1) - B.query(pos, siz + 1) * vp[i].first;
} else if (v > 0) {
ans += A.query(pos, siz + 1) - B.query(pos, siz + 1) * vp[i].first;
} else if (v < 0) {
ans += A.query(pos, siz + 1) - B.query(pos, siz + 1) * vp[i].first;
}
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200005;
map<long long, long long> g;
map<long long, long long> invG;
long long tree[8][maxn];
long long sum(long long k, long long t) {
long long res = 0;
for (long long i = k; i >= 1; i -= i & -i) res += tree[t][i];
return res;
}
void add(long long k, long long v, long long t) {
for (long long i = k; i < maxn; i += i & -i) tree[t][i] += v;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
for (long long i = 0; i < maxn; i++)
for (long long j = 0; j < 8; j++) tree[j][i] = 0;
long long n;
cin >> n;
priority_queue<pair<long long, pair<long long, long long>>> pq;
vector<long long> xs;
vector<long long> vs;
set<long long> distinct;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
xs.push_back(x);
distinct.emplace(x);
}
for (long long i = 0; i < n; i++) {
long long v;
cin >> v;
vs.push_back(v);
}
vector<long long> vec(distinct.begin(), distinct.end());
for (long long i = 0; i < n; i++) {
g[vec[i]] = i + 1;
invG[i + 1] = vec[i];
}
for (long long i = 0; i < n; i++) {
long long dir = 0;
if (vs[i] < 0) dir = 1;
pq.emplace(abs(vs[i]), make_pair(g[xs[i]], dir));
}
long long res = 0;
while (!pq.empty()) {
pair<long long, pair<long long, long long>> t = pq.top();
queue<pair<long long, long long>> q;
queue<pair<long long, long long>> q2;
while (!pq.empty() && pq.top().first == t.first) {
pair<long long, pair<long long, long long>> p = pq.top();
pq.pop();
q.emplace(p.second);
}
while (!q.empty()) {
pair<long long, long long> p = q.front();
q.pop();
q2.emplace(p);
long long x = p.first;
long long dir = p.second;
long long sumRight = sum(maxn - 1, 0) - sum(x, 0);
sumRight -= invG[x] * (sum(maxn - 1, 0 + 2) - sum(x, 0 + 2));
long long sumLeft = sum(x - 1, 1);
sumLeft -= invG[x] * sum(x - 1, 1 + 2);
res += abs(sumRight) + abs(sumLeft);
}
vector<pair<long long, long long>> same;
while (!q2.empty()) {
pair<long long, long long> p = q2.front();
q2.pop();
long long x = p.first;
long long dir = p.second;
add(x, invG[x], dir);
add(x, 1, dir + 2);
same.push_back(make_pair(x, dir));
add(x, invG[x], dir + 4);
add(x, 1, dir + 4 + 2);
}
long long cnt = 0;
for (pair<long long, long long> p : same) {
long long x = p.first;
long long dir = p.second;
if (dir == 0) {
long long sumRight = sum(maxn - 1, 4) - sum(x, 4);
sumRight -= invG[x] * (sum(maxn - 1, 4 + 2) - sum(x, 4 + 2));
long long sumLeft = sum(x - 1, 5);
sumLeft -= invG[x] * sum(x - 1, 5 + 2);
long long extra = sum(x - 1, 4);
extra -= invG[x] * sum(x - 1, 4 + 2);
cnt += abs(sumRight) + abs(sumLeft) + abs(extra);
} else {
long long sumRight = sum(maxn - 1, 4) - sum(x, 4);
sumRight -= invG[x] * (sum(maxn - 1, 4 + 2) - sum(x, 4 + 2));
long long sumLeft = sum(x - 1, 5);
sumLeft -= invG[x] * sum(x - 1, 5 + 2);
long long extra = sum(maxn - 1, 5) - sum(x, 5);
extra -= invG[x] * (sum(maxn - 1, 5 + 2) - sum(x, 5 + 2));
cnt += abs(sumRight) + abs(sumLeft) + abs(extra);
}
}
cnt /= 2;
res += cnt;
for (pair<long long, long long> p : same) {
long long x = p.first;
long long dir = p.second;
add(x, -invG[x], dir + 4);
add(x, -1, dir + 4 + 2);
}
}
cout << res << '\n';
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 22, inf = 1e9 + 7;
int n;
long long s[4 * N], cursum;
vector<pair<int, int> > t[4 * N];
vector<long long> p[4 * N];
pair<int, int> a[N];
void build(int v, int tl, int tr) {
if (tl == tr) {
s[v] = a[tl].first;
t[v].push_back({a[tl].second, a[tl].first});
p[v].push_back(a[tl].first);
return;
}
int tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm + 1, tr);
s[v] = s[v * 2] + s[v * 2 + 1];
t[v].resize(tr - tl + 1);
p[v].resize(tr - tl + 1);
merge(t[v * 2].begin(), t[v * 2].end(), t[v * 2 + 1].begin(),
t[v * 2 + 1].end(), t[v].begin());
for (int i = 0; i < t[v].size(); i++) {
if (i == 0)
p[v][i] = t[v][i].second;
else
p[v][i] = p[v][i - 1] + t[v][i].second;
}
}
long long sum(int v, int tl, int tr, int l, int r) {
if (l <= tl && tr <= r) {
return s[v];
}
if (tl > r || tr < l) return 0LL;
int tm = (tl + tr) / 2;
return sum(v * 2, tl, tm, l, r) + sum(v * 2 + 1, tm + 1, tr, l, r);
}
int get(int v, int tl, int tr, int l, int r, int val) {
if (l <= tl && tr <= r) {
int id = lower_bound(t[v].begin(), t[v].end(), make_pair(val, -inf)) -
t[v].begin();
if (id != 0) cursum += p[v][id - 1];
return id;
}
if (tl > r || tr < l) {
return 0;
}
int tm = (tl + tr) / 2;
return get(v * 2, tl, tm, l, r, val) + get(v * 2 + 1, tm + 1, tr, l, r, val);
}
signed 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].first;
}
for (int i = 1; i <= n; i++) {
cin >> a[i].second;
}
sort(a + 1, a + n + 1);
build(1, 1, n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
cursum = 0;
int cnt = get(1, 1, n, i + 1, n, a[i].second);
long long cur = 0;
cur += sum(1, 1, n, i + 1, n);
cur -= cursum;
cur -= a[i].first * 1LL * (n - i - cnt);
ans += cur;
}
cout << endl;
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long c1[maxn], c2[maxn];
void add(long long *c, int x, int y) {
for (; x < maxn; x += x & -x) c[x] += y;
}
long long ask(long long *c, int x) {
long long ret = 0;
for (; x > 0; x -= x & -x) ret += c[x];
return ret;
}
struct node {
int x, v;
} p[maxn];
int b[maxn];
bool cmp(node a, node b) {
if (a.x == b.x) return a.v < b.v;
return a.x < b.x;
}
int main() {
int n;
cin >> n;
int m = 0;
for (int i = 0; i < n; i++) scanf("%d", &p[i].x);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i].v);
b[m++] = p[i].v;
}
sort(b, b + m);
m = unique(b, b + m) - b;
for (int i = 0; i < n; i++) {
p[i].v = lower_bound(b, b + m, p[i].v) - b + 1;
}
sort(p, p + n, cmp);
long long Ans = 0;
for (int i = 0; i < n; i++) {
long long cnt = ask(c1, p[i].v), sum = ask(c2, p[i].v);
Ans += cnt * p[i].x - sum;
add(c1, p[i].v, 1);
add(c2, p[i].v, p[i].x);
}
cout << Ans << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, i;
pair<int, int> dot[N];
long long mergeMoving(pair<int, int> arr[], pair<int, int> temp[], int left,
int right);
long long merge(pair<int, int> arr[], pair<int, int> temp[], int left, int mid,
int right);
long long movingdot(pair<int, int> arr[], int array_size) {
pair<int, int> temp[array_size];
return mergeMoving(arr, temp, 0, array_size - 1);
}
long long mergeMoving(pair<int, int> arr[], pair<int, int> temp[], int left,
int right) {
int mid;
long long dis = 0LL;
mid = right + left >> 1;
if (left != mid) dis += mergeMoving(arr, temp, left, mid);
if (right != mid + 1) dis += mergeMoving(arr, temp, mid + 1, right);
dis += merge(arr, temp, left, mid + 1, right);
return dis;
}
long long merge(pair<int, int> arr[], pair<int, int> temp[], int left, int mid,
int right) {
int i = left;
int j = mid;
int k = left;
long long dis = 0;
long long quick[right + 1];
for (i = left; i <= right; i++) {
dis += arr[i].first;
quick[i] = dis;
}
dis = 0;
i = left;
while ((i < mid) && (j < right + 1)) {
if (arr[i].second <= arr[j].second) {
dis = dis + quick[right] - quick[j - 1] -
1LL * (right - j + 1) * arr[i].first;
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
while (i <= mid - 1) temp[k++] = arr[i++];
while (j <= right) temp[k++] = arr[j++];
for (i = left; i <= right; i++) arr[i] = temp[i];
return dis;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (i = 0; i < n; i++) cin >> dot[i].first;
for (i = 0; i < n; i++) cin >> dot[i].second;
sort(dot, dot + n);
cout << movingdot(dot, n);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5, MOD = 1e9 + 7;
pair<long long, long long> a[N];
vector<pair<long long, long long> > tree[4 * N];
void build(long long node, long long st, long long en) {
if (st == en) {
tree[node].push_back({a[st].first, a[st].first});
return;
}
long long mid = (st + en) / 2;
build(2 * node, st, mid);
build(2 * node + 1, mid + 1, en);
long long x = tree[2 * node].size();
long long y = tree[2 * node + 1].size();
long long i = 0, j = 0;
while (i < x && j < y) {
if (tree[2 * node][i].first < tree[2 * node + 1][j].first) {
tree[node].push_back(tree[2 * node][i]);
i++;
} else {
tree[node].push_back(tree[2 * node + 1][j]);
j++;
}
}
while (i < x) {
tree[node].push_back(tree[2 * node][i]);
i++;
}
while (j < y) {
tree[node].push_back(tree[2 * node + 1][j]);
j++;
}
long long z = x + y;
tree[node][z - 1].second = tree[node][z - 1].first;
for (long long k = z - 2; k >= 0; k--) {
tree[node][k].second = tree[node][k + 1].second + tree[node][k].first;
}
}
pair<long long, long long> query(long long node, long long st, long long en,
long long l, long long r, long long val) {
if (l > en || r < st) return {0, 0};
if (l <= st && en <= r) {
long long lo = 0, hi = tree[node].size() - 1, idx = MOD;
while (lo <= hi) {
long long m = (lo + hi) / 2;
if (tree[node][m].first > val) {
idx = min(idx, m);
hi = m - 1;
} else
lo = m + 1;
}
if (idx == MOD)
return {0, 0};
else
return {tree[node][idx].second, tree[node].size() - idx};
}
long long mid = (st + en) / 2;
long long ans = 0;
pair<long long, long long> p1 = query(2 * node, st, mid, l, r, val);
pair<long long, long long> p2 = query(2 * node + 1, mid + 1, en, l, r, val);
pair<long long, long long> p;
p.first = p1.first + p2.first;
p.second = p1.second + p2.second;
return p;
}
bool compare(pair<long long, long long> p1, pair<long long, long long> p2) {
if (p1.second == p2.second) return p1.first > p2.first;
return p1.second > p2.second;
}
void solve() {
long long n;
cin >> 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, a + n, compare);
build(1, 0, n - 1);
long long ans = 0;
for (long long i = 1; i < n; i++) {
pair<long long, long long> p = query(1, 0, n - 1, 0, i - 1, a[i].first);
long long temp = abs(p.first - p.second * a[i].first);
ans += temp;
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
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<vector<pair<long long, long long>>> ps(2);
for (int i = 0; i < n; ++i) {
if (0 <= v[i])
ps[0].emplace_back(v[i], x[i]);
else
ps[1].emplace_back(-v[i], -x[i]);
}
vector<long long> vs;
vector<pair<long long, int>> xs;
auto f = [](pair<long long, int> a, pair<long long, int> b) {
return pair<long long, int>{a.first + b.first, a.second + b.second};
};
SegmentTree<pair<long long, int>> seg(n, f, {0, 0});
vector<pair<long long, int>> initializer(n, {0, 0});
long long ans = 0;
for (int i = 1; i >= 0; --i) {
sort(ps[i].begin(), ps[i].end());
int m = ps[i].size();
vs.clear();
xs.clear();
for (int j = 0; j < m; ++j) {
vs.emplace_back(ps[i][j].first);
xs.emplace_back(ps[i][j].second, j);
}
if (!i) seg.build(initializer);
sort(xs.begin(), xs.end());
for (int j = 0; j < m; ++j) seg.update(xs[j].second, {xs[j].first, 1});
for (int j = 0; j < m; ++j) {
int s = lower_bound(vs.begin(), vs.end(), ps[i][xs[j].second].first) -
vs.begin();
auto p = seg.query(s, m);
ans += p.first - xs[j].first * p.second;
seg.update(xs[j].second, {0, 0});
}
}
int t = ps[0].size();
vector<long long> sum(t + 1, 0);
for (int i = 0; i < t; ++i) {
sum[i + 1] = sum[i] + xs[i].first;
vs[i] = xs[i].first;
}
for (int i = 0; i < ps[1].size(); ++i) {
int b = upper_bound(vs.begin(), vs.end(), -ps[1][i].second) - vs.begin();
ans += sum[t] - sum[b] + ps[1][i].second * (t - b);
}
cout << ans << '\n';
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i;
cin >> n;
pair<long long, long long> p[n];
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
p[i].second = a[i];
}
for (i = 0; i < n; i++) cin >> p[i].first;
sort(a, a + n);
sort(p, p + n);
map<long long, long long> mp;
long long ans = 0;
for (i = 0; i < n; i++) {
ans += a[i] * (2 * i + 1 - n);
mp[a[i]] = i;
}
for (i = 0; i < n; i++) {
ans -= p[i].second * (mp[p[i].second] - i);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
inline int read() {
int x = 0, neg = 1;
char op = getchar();
while (!isdigit(op)) {
if (op == '-') neg = -1;
op = getchar();
}
while (isdigit(op)) {
x = 10 * x + op - '0';
op = getchar();
}
return neg * x;
}
inline void print(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
const int N = 200005;
struct ele {
int x;
long long v;
friend bool operator<(const ele &a, const ele &b) { return a.x < b.x; }
} a[N];
int b[N], tot;
int n;
struct Bitcount {
int c[N];
void add(int x, int v) {
while (x < N) {
c[x] += v;
x += (x & -x);
}
}
int qry(int x) {
int ret = 0;
if (x < 0) return 0;
while (x > 0) {
ret += c[x];
x -= (x & -x);
}
return ret;
}
int query(int l, int r) { return qry(r) - qry(l - 1); }
} bitc;
struct Bitsum {
long long c[N];
void add(int x, long long v) {
while (x < N) {
c[x] += v;
x += (x & -x);
}
}
long long qry(int x) {
long long ret = 0;
if (x < 0) return 0;
while (x > 0) {
ret += c[x];
x -= (x & -x);
}
return ret;
}
long long query(int l, int r) { return qry(r) - qry(l - 1); }
} bits;
int main() {
n = read();
for (register int i = 1; i <= n; i++) {
a[i].x = read();
}
for (register int i = 1; i <= n; i++) {
a[i].v = read();
b[++tot] = a[i].v;
}
sort(b + 1, b + tot + 1);
tot = unique(b + 1, b + tot + 1) - (b + 1);
sort(a + 1, a + n + 1);
for (register int i = 1; i <= n; i++) {
a[i].v = lower_bound(b + 1, b + tot + 1, a[i].v) - b;
}
long long ans = 0ll;
for (register int i = n; i >= 1; i--) {
long long possum = bits.query(a[i].v, N - 1);
long long posnum = bitc.query(a[i].v, N - 1);
ans += possum - 1ll * a[i].x * posnum;
bits.add(a[i].v, a[i].x);
bitc.add(a[i].v, 1);
}
printf("%lld\n", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 6e6;
const long long inf = 1e9;
const long long maxv = 2e8 + 100;
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
struct point {
long long x, v;
point() {}
};
vector<point> foo;
unordered_map<long long, pair<long long, long long>> tree(maxn);
const long long toadd = 1e8 + 1;
inline long long f(long long i) { return i & (i + 1); }
void inc(long long st) {
long long ind = foo[st].v + toadd;
while (ind < maxv) {
tree[ind].first++;
tree[ind].second += foo[st].x;
ind |= (ind + 1);
}
}
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};
}
pair<long long, long long> prefsum(long long ind) {
pair<long long, long long> res = {0, 0};
while (ind >= 0) {
res = res + tree[ind];
ind = f(ind) - 1;
}
return res;
}
int main() {
init();
tree.rehash(maxn);
long long n;
cin >> n;
foo.resize(n);
for (long long i = 0; i < n; i++) {
cin >> foo[i].x;
}
for (long long i = 0; i < n; i++) {
cin >> foo[i].v;
}
sort(foo.begin(), foo.end(),
[&](point &p1, point &p2) { return p1.x < p2.x; });
long long ans = 0;
for (long long i = 0; i < n; i++) {
auto cur = prefsum(foo[i].v + toadd);
ans += (cur.first * foo[i].x - cur.second);
inc(i);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
# BIT
def add(bit, x, v):
while x < len(bit):
bit[x] += v
x += x & (-x)
def query(bit, x):
ans = 0
while x > 0:
ans += bit[x]
x -= x & (-x)
return ans
def relabel(arr):
srt = sorted(set(arr))
mp = {v:k for k, v in enumerate(srt, 1)}
arr = [mp[a] for a in arr]
return arr
# main
n = int(input())
x = list(map(int, input().split()))
v = relabel(list(map(int, input().split())))
arr = sorted(list(zip(x, v)));
ans = 0
bitSum = [0]*(n+1)
bitCnt = [0]*(n+1)
for x, v in arr:
ans += query(bitCnt, v)*x - query(bitSum, v)
add(bitSum, v, x)
add(bitCnt, v, 1)
print(ans)
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000007, inf = 0x3f3f3f3f;
int x[N], v[N];
pair<long long, int> seg[N + N];
pair<long long, int> soma(pair<long long, int> x, pair<long long, int> y) {
return pair<long long, int>(x.first + y.first, x.second + y.second);
}
pair<long long, int> query(int l, int r) {
pair<long long, int> tot = pair<long long, int>(0ll, 0);
for (l += N, r += N; l < r; l >>= 1, r >>= 1) {
if (l & 1) tot = soma(tot, seg[l++]);
if (r & 1) tot = soma(tot, seg[--r]);
}
return tot;
}
void update(int p, int val) {
p += N;
for (seg[p] = pair<long long, int>(seg[p].first + val, seg[p].second + 1);
p > 1; p >>= 1) {
seg[p >> 1] = soma(seg[p], seg[p ^ 1]);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x[i];
}
vector<int> vec;
for (int i = 0; i < n; ++i) {
cin >> v[i];
vec.push_back(v[i]);
}
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
vector<int> id(n);
iota(id.begin(), id.end(), 0);
sort(id.begin(), id.end(), [](int i, int j) { return x[i] < x[j]; });
long long ans = 0;
for (int i : id) {
int j = lower_bound(vec.begin(), vec.end(), v[i]) - vec.begin();
long long sx;
int cnt;
tie(sx, cnt) = query(0, j + 1);
ans += (long long)x[i] * cnt - sx;
update(j, x[i]);
}
memset(seg, 0, sizeof seg);
reverse(id.begin(), id.end());
for (int i : id) {
int j = lower_bound(vec.begin(), vec.end(), v[i]) - vec.begin();
long long sx;
int cnt;
tie(sx, cnt) = query(j, vec.size());
ans += sx - (long long)x[i] * cnt;
update(j, x[i]);
}
cout << ans / 2 << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int tree[800005], sree[800005];
struct sc {
long long int a, b;
};
bool comp(sc x, sc y) {
if (x.a < y.a) return 1;
return 0;
}
void update(long long int node, long long int s, long long int e,
long long int ind, long long int val) {
if (s == e) {
tree[node] += val;
sree[node] += 1;
} else {
long long int m = (s + e) / 2;
if (s <= ind && ind <= m)
update(2 * node, s, m, ind, val);
else
update(2 * node + 1, m + 1, e, ind, val);
tree[node] = tree[2 * node] + tree[2 * node + 1];
sree[node] = sree[2 * node] + sree[2 * node + 1];
}
}
long long int q_sum(long long int node, long long int s, long long int e,
long long int l, long long int r) {
if (r < s || e < l) return 0;
if (l <= s && e <= r) return tree[node];
long long int m = (s + e) / 2;
long long int ans1 = q_sum(2 * node, s, m, l, r);
long long int ans2 = q_sum(2 * node + 1, m + 1, e, l, r);
long long int ans = ans1 + ans2;
return ans;
}
long long int q_cnt(long long int node, long long int s, long long int e,
long long int l, long long int r) {
if (r < s || e < l) return 0;
if (l <= s && e <= r) return sree[node];
long long int m = (s + e) / 2;
long long int ans1 = q_cnt(2 * node, s, m, l, r);
long long int ans2 = q_cnt(2 * node + 1, m + 1, e, l, r);
long long int ans = ans1 + ans2;
return ans;
}
int main() {
long long int n, i, j, ans = 0;
cin >> n;
sc e[n + 1];
long long int c[n + 1];
for (i = 1; i <= n; ++i) {
cin >> e[i].a;
}
for (i = 1; i <= n; ++i) {
cin >> e[i].b;
c[i] = e[i].b;
}
sort(e + 1, e + n + 1, comp);
sort(c + 1, c + n + 1);
long long int l = 1;
map<long long int, long long int> mp;
for (i = 1; i <= n; ++i)
if (mp.find(c[i]) == mp.end()) mp[c[i]] = l++;
for (i = n; i >= 1; --i) {
update(1, 1, n, mp[e[i].b], e[i].a);
ans = ans + (q_sum(1, 1, n, mp[e[i].b], l) -
(q_cnt(1, 1, n, mp[e[i].b], l) * e[i].a));
}
cout << ans << "\n";
return 0;
}
| 12 | CPP |
class SegmentTree():
def __init__(self,N,func,initialRes=0):
self.f=func
self.N=N
self.tree=[0 for _ in range(4*self.N)]
self.initialRes=initialRes
# for i in range(self.N):
# self.tree[self.N+i]=arr[i]
# for i in range(self.N-1,0,-1):
# self.tree[i]=self.f(self.tree[i<<1],self.tree[i<<1|1])
def updateTreeNode(self,idx,value): #update value at arr[idx]
self.tree[idx+self.N]=value
idx+=self.N
i=idx
while i>1:
self.tree[i>>1]=self.f(self.tree[i],self.tree[i^1])
i>>=1
def query(self,l,r): #get sum (or whatever function) on interval [l,r] inclusive
r+=1
res=self.initialRes
l+=self.N
r+=self.N
while l<r:
if l&1:
res=self.f(res,self.tree[l])
l+=1
if r&1:
r-=1
res=self.f(res,self.tree[r])
l>>=1
r>>=1
return res
def getMaxSegTree(arr):
return SegmentTree(arr,lambda a,b:max(a,b),initialRes=-float('inf'))
def getMinSegTree(arr):
return SegmentTree(arr,lambda a,b:min(a,b),initialRes=float('inf'))
def getSumSegTree(arr):
return SegmentTree(arr,lambda a,b:a+b,initialRes=0)
def main():
n=int(input())
xes=readIntArr()
ves=readIntArr()
#perform coordinate compression on xes. Compressed values shall be the indexes of segment tree
xes2=list(sorted(xes)) #xes2[compressed]=x
xTox2Map=dict()
for i,x in enumerate(xes2):
xTox2Map[x]=i #xTox2Map[x]=i
arr=[] #[original x, compressed x, v]
for i in range(n):
arr.append([xes[i],xTox2Map[xes[i]],ves[i]])
arr.sort(key=lambda x:(x[2],x[0])) #sort by v asc, then position asc
st=getSumSegTree(n) #for sum of xes
stCnts=getSumSegTree(n) #for counts
# print(arr)
ans=0
for originalX,compressedX,v in arr:
smallerSums=st.query(0,compressedX)
smallerCounts=stCnts.query(0,compressedX)
ans+=originalX*smallerCounts-smallerSums
st.updateTreeNode(compressedX,originalX) #update the tree
stCnts.updateTreeNode(compressedX,1)
# print(ans)
print(ans)
return
import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
# import sys
# input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
inf=float('inf')
MOD=10**9+7
main() | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, tot;
long long ans, ans1, ans2;
struct dot {
long long x, v, nv;
} a[maxn];
struct node {
long long cnt, d;
} T[maxn * 4];
bool cmp1(dot x, dot y) { return x.v < y.v; }
bool cmp2(dot x, dot y) { return x.x < y.x; }
void pushup(int x) {
T[x].cnt = T[(x << 1)].cnt + T[(x << 1 | 1)].cnt;
T[x].d = T[(x << 1)].d + T[(x << 1 | 1)].d;
}
void insert(int x, int l, int r, int pos, int p) {
if (l == r) {
T[x].cnt++;
T[x].d += a[p].x;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
insert((x << 1), l, mid, pos, p);
else
insert((x << 1 | 1), mid + 1, r, pos, p);
pushup(x);
}
void query(int x, int l, int r, int sj, int tj) {
if (sj <= l && r <= tj) {
ans1 += T[x].cnt;
ans2 += T[x].d;
return;
}
int mid = (l + r) >> 1;
if (sj <= mid) query((x << 1), l, mid, sj, tj);
if (mid + 1 <= tj) query((x << 1 | 1), mid + 1, r, sj, tj);
}
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);
sort(a + 1, a + n + 1, cmp1);
tot = 0;
a[1].nv = ++tot;
for (int i = 2; i <= n; i++) {
if (a[i].v == a[i - 1].v)
a[i].nv = tot;
else
a[i].nv = ++tot;
}
sort(a + 1, a + n + 1, cmp2);
ans = 0;
for (int i = 1; i <= n; i++) {
ans1 = ans2 = 0;
query(1, 1, tot, 1, a[i].nv);
ans += ans1 * a[i].x - ans2;
insert(1, 1, tot, a[i].nv, i);
}
printf("%lld", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
template <class C>
inline void log_c(const C& c) {}
template <class C>
inline int sz(const C& c) {
return static_cast<int>(c.size());
}
using namespace std;
using pii = pair<int, int>;
using num = int64_t;
using pll = pair<num, num>;
const std::string eol = "\n";
const int max_x = 100000000;
using It = vector<int>::iterator;
int64_t min_distance_sum(It begin, It end, It tmp_begin) {
if (next(begin) == end) return 0;
int64_t left_count = distance(begin, end) / 2;
It mid = next(begin, left_count);
const int64_t ans_left = min_distance_sum(begin, mid, tmp_begin);
const int64_t ans_right =
min_distance_sum(mid, end, next(tmp_begin, left_count));
int64_t ans_cross = 0;
It it1 = begin;
It it2 = mid;
It tmp = tmp_begin;
int64_t left_sum = 0;
while (it1 != mid && it2 != end) {
if (*it1 < *it2) {
left_sum += *it1;
*tmp++ = *it1++;
} else {
ans_cross += static_cast<int64_t>(*it2) * distance(begin, it1) - left_sum;
*tmp++ = *it2++;
}
}
copy(it1, mid, tmp);
while (it2 != end) {
ans_cross += static_cast<int64_t>(*it2) * left_count - left_sum;
*tmp++ = *it2++;
}
copy(tmp_begin, next(tmp_begin, distance(begin, end)), begin);
return ans_left + ans_right + ans_cross;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<pii> data(n);
for (int k = 0; k < (n); ++k) cin >> data[k].second;
for (int k = 0; k < (n); ++k) cin >> data[k].first;
sort(begin(data), end(data));
vector<int> x(n), tmp(n);
for (int k = 0; k < (n); ++k) x[k] = data[k].second;
cout << min_distance_sum(begin(x), end(x), tmp.begin()) << eol;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int dddx[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dddy[] = {0, 0, 1, -1, 1, -1, 1, -1};
struct FenwickTree {
vector<long long int> bit;
int n;
FenwickTree(int n) {
this->n = n;
bit.assign(n, 0);
}
long long int sum(int r) {
long long int ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
return ret;
}
long long int sum(int l, int r) { return sum(r) - sum(l - 1); }
void add(int idx, int delta) {
for (; idx < n; idx = idx | (idx + 1)) bit[idx] += delta;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<pair<int, int> > vec(n + 1);
vector<int> aux;
vec.resize(n);
for (int i = 0; i < n; i++) cin >> vec[i].first;
for (int i = 0; i < n; i++) cin >> vec[i].second;
sort(vec.begin(), vec.end());
FenwickTree cnt(n), soma(n);
for (auto i : vec) aux.push_back(i.second);
sort(aux.begin(), aux.end());
long long int ans = 0;
for (auto i : vec) {
int pos = lower_bound(aux.begin(), aux.end(), i.second) - aux.begin();
ans += (cnt.sum(pos) * i.first) - soma.sum(pos);
cnt.add(pos, 1);
soma.add(pos, i.first);
}
cout << ans << "\n";
return 0;
}
| 12 | CPP |
#Pye
from os import path
from sys import stdin, stdout
from bisect import bisect_left
if path.exists('inp.txt'): stdin = open("inp.txt", "r")
maxn = 200005
a = []; b = []; fen = [(0, 0) for i in range(maxn)]
res = 0
n = int(stdin.readline())
def update(x, val):
global fen
while x > 0:
fen[x] = (fen[x][0] + val, fen[x][1] + 1)
x -= x & (-x)
def get(x, val):
global n, fen
A = 0; B = 0
while x < n+2:
A += fen[x][0]
B += fen[x][1]
x += x & (-x)
return A - B * val
af = list(map(int, stdin.readline().split()))
ad = list(map(int, stdin.readline().split()))
for i in range(n): a.append((af[i], ad[i])); b.append(ad[i])
a.sort()
b.sort()
for i in range(n): a[i] = (a[i][0], bisect_left(b, a[i][1]) + 1)
for i in range(n-1, -1, -1):
res += get(a[i][1], a[i][0])
update(a[i][1], a[i][0])
print(res) | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T, class U>
using Pa = pair<T, U>;
template <class T>
using vec = vector<T>;
template <class T>
using vvec = vector<vec<T>>;
template <typename Monoid, typename F>
class SegmentTree {
private:
int sz;
vector<Monoid> seg;
const F op;
const Monoid e;
public:
SegmentTree(int n, const F op, const Monoid &e) : op(op), e(e) {
sz = 1;
while (sz <= n) sz <<= 1;
seg.assign(2 * sz, e);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int i = sz - 1; i > 0; i--) {
seg[i] = op(seg[2 * i], seg[2 * i + 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = op(seg[2 * k], seg[2 * k + 1]);
}
}
Monoid query(int l, int r) {
Monoid L = e, R = e;
for (l += sz, r += sz; l < r; l >>= 1, r >>= 1) {
if (l & 1) L = op(L, seg[l++]);
if (r & 1) R = op(seg[--r], R);
}
return op(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
template <class T>
class Compress {
map<T, int> idx;
map<int, T> value;
vector<T> cmp;
public:
int N;
Compress(vector<T> v) {
for (auto &x : v) cmp.push_back(x);
sort(cmp.begin(), cmp.end());
cmp.erase(unique(cmp.begin(), cmp.end()), cmp.end());
N = cmp.size();
for (int i = 0; i < N; i++) idx[cmp[i]] = i;
}
int id(T val) { return idx[val]; }
T val(int id) { return cmp[id]; }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vec<ll> X(N), V(N);
for (int i = 0; i < N; i++) cin >> X[i];
for (int i = 0; i < N; i++) cin >> V[i];
Compress<ll> cmp(X);
vec<ll> P(N + 1), M(N + 1), Z(N + 1);
vec<ll> PC(N + 1), MC(N + 1), ZC(N + 1);
for (int i = 0; i < N; i++) {
if (V[i] > 0) {
P[cmp.id(X[i])] += X[i];
PC[cmp.id(X[i])]++;
} else if (V[i] < 0) {
M[cmp.id(X[i])] += X[i];
MC[cmp.id(X[i])]++;
} else {
Z[cmp.id(X[i])] += X[i];
ZC[cmp.id(X[i])]++;
}
}
for (int i = 0; i < N; i++) {
M[i + 1] += M[i];
MC[i + 1] += MC[i];
Z[i + 1] += Z[i];
ZC[i + 1] += ZC[i];
}
for (int i = N - 1; i >= 0; i--) {
P[i] += P[i + 1];
PC[i] += PC[i + 1];
}
struct state {
ll sum, cnt;
};
auto op = [](state L, state R) {
return (state){L.sum + R.sum, L.cnt + R.cnt};
};
SegmentTree<state, decltype(op)> seg(N, op, (state){0, 0});
vec<int> idx(N);
iota(idx.begin(), idx.end(), 0);
sort(idx.begin(), idx.end(), [&](int i, int j) {
return (V[i] != V[j] ? V[i] > V[j] : X[i] > X[j]);
});
ll ans = 0;
for (int i = 0; i < N; i++) {
int id = idx[i];
if (V[id] <= 0) break;
int xid = cmp.id(X[id]);
ans += MC[xid] * X[id] - M[xid];
state res = seg.query(xid, N);
ans += res.sum - X[id] * res.cnt;
seg.update(xid, {X[id], 1});
}
sort(idx.begin(), idx.end(), [&](int i, int j) {
return (V[i] != V[j] ? V[i] < V[j] : X[i] < X[j]);
});
for (int i = 0; i < N; i++) seg.set(i, {0, 0});
seg.build();
for (int i = 0; i < N; i++) {
int id = idx[i];
if (V[id] >= 0) continue;
int xid = cmp.id(X[id]);
state res = seg.query(0, xid);
ans += X[id] * res.cnt - res.sum;
seg.update(xid, {X[id], 1});
}
for (int i = 0; i < N; i++)
if (V[i] == 0) {
int xid = cmp.id(X[i]);
ans += MC[xid] * X[i] - M[xid];
ans += P[xid] - PC[xid] * X[i];
ans += ZC[xid] * X[i] - Z[xid];
}
cout << ans << "\n";
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 2e5 + 2;
struct Fenwick {
long long int BIT[N] = {};
void update(long long int idx, long long int val) {
for (long long int i = idx; i < N; i += (i & -i)) {
BIT[i] += val;
}
}
long long int query(long long int k) {
long long int sum = 0;
for (long long int i = k; i > 0; i -= (i & -i)) {
sum += BIT[i];
}
return sum;
}
};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n;
cin >> n;
long long int x[n + 1], v[n + 1];
vector<pair<long long int, long long int> > vp;
for (long long int i = 1; i <= n; i++) cin >> x[i];
vector<pair<long long int, long long int> > rr;
for (long long int i = 1; i <= n; i++) {
cin >> v[i];
vp.push_back({x[i], v[i]});
}
sort(vp.begin(), vp.end());
for (long long int i = 0; i < n; i++) {
rr.push_back({vp[i].second, i});
}
sort(rr.begin(), rr.end());
long long int rank = 1;
for (auto it : rr) {
long long int idx = it.second;
vp[idx].second = rank++;
}
long long int ans = 0;
Fenwick ob1, ob2;
long long int leftLess[n + 5], rightBade[n + 5];
for (long long int i = 0; i < n; i++) {
long long int vel = vp[i].second;
leftLess[i] = ob1.query(vel - 1);
ob1.update(vel, 1);
}
for (long long int i = n - 1; i >= 0; i--) {
long long int vel = vp[i].second;
long long int total = n - 1 - i;
long long int less = ob2.query(vel - 1);
rightBade[i] = total - less;
ob2.update(vel, 1);
}
for (long long int i = 0; i < n; i++) {
long long int val = vp[i].first;
ans += val * (leftLess[i] - rightBade[i]);
}
cout << ans;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, i;
pair<int, int> dot[N];
long long mergeMoving(pair<int, int> arr[], pair<int, int> temp[], int left,
int right);
long long merge(pair<int, int> arr[], pair<int, int> temp[], int left, int mid,
int right);
long long movingdot(pair<int, int> arr[], int array_size) {
pair<int, int> temp[array_size];
return mergeMoving(arr, temp, 0, array_size - 1);
}
long long mergeMoving(pair<int, int> arr[], pair<int, int> temp[], int left,
int right) {
int mid;
long long dis = 0LL;
mid = right + left >> 1;
if (left != mid) dis += mergeMoving(arr, temp, left, mid);
if (right != mid + 1) dis += mergeMoving(arr, temp, mid + 1, right);
dis += merge(arr, temp, left, mid + 1, right);
return dis;
}
long long merge(pair<int, int> arr[], pair<int, int> temp[], int left, int mid,
int right) {
int i = left;
int j = mid;
int k = left;
long long dis = 0;
long long quick[right + 1];
for (i = left; i <= right; i++) {
dis += arr[i].first;
quick[i] = dis;
}
dis = 0;
i = left;
while ((i < mid) && (j < right + 1)) {
if (arr[i].second <= arr[j].second) {
dis = dis + quick[right] - quick[j - 1] -
1LL * (right - j + 1) * arr[i].first;
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
while (i <= mid - 1) temp[k++] = arr[i++];
while (j <= right) temp[k++] = arr[j++];
for (i = left; i <= right; i++) arr[i] = temp[i];
return dis;
}
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> dot[i].first;
for (i = 0; i < n; i++) cin >> dot[i].second;
sort(dot, dot + n);
cout << movingdot(dot, n);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 500007;
long long n, C1[maxn], C2[maxn];
long long ans, p1[maxn], p2[maxn];
pair<long long, long long> fk[maxn];
bool cmp2(long long u, long long v) {
if (fk[u].second < fk[v].second) {
return 1;
} else {
if (fk[u].second == fk[v].second && fk[u].first > fk[v].first) return 1;
}
return 0;
}
long long lowbit(long long u) { return u & (-u); }
void update(long long u, long long w) {
for (long long i = u; i <= n; i += lowbit(i)) C1[i] += w, C2[i] += 1;
}
pair<long long, long long> query(long long u) {
long long ans = 0, ret = 0;
for (long long i = u; i > 0; i -= lowbit(i)) ans += C1[i], ret += C2[i];
return {ans, ret};
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> fk[i].second;
p1[i] = i;
}
for (int i = 1; i <= n; ++i) {
cin >> fk[i].first;
p2[i] = i;
}
sort(fk + 1, fk + n + 1);
sort(p1 + 1, p1 + n + 1, cmp2);
for (int i = 1; i <= n; ++i) {
p2[p1[i]] = i;
}
for (int i = 1; i <= n; ++i) {
update(p2[i], fk[i].second);
pair<long long, long long> ret = query(p2[i]);
ans -= ret.first;
ans += ret.second * fk[i].second;
}
cout << ans << endl;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
long long BIT1[200001];
long long cnt1[200001];
map<long long, long long> r, l;
pair<long long, long long> arr[200001];
int n;
void upd1(long long idx, long long val) {
for (; idx <= N; idx = (idx | (idx + 1))) {
BIT1[idx] += val;
cnt1[idx]++;
}
}
pair<long long, long long> query1(int idx) {
if (idx < 0) return {0, 0};
long long sum = 0;
int ct = 0;
for (; idx >= 0; idx = (idx & (idx + 1)) - 1) {
sum += BIT1[idx];
ct += cnt1[idx];
}
return {sum, ct};
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> arr[i].first;
for (int i = 1; i <= n; i++) cin >> arr[i].second;
sort(arr + 1, arr + n + 1);
for (int i = 1; i <= n; i++) r[arr[i].second] = 0;
long long ind = 1;
for (auto &it : r) {
it.second = ind;
ind++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long vel = r[arr[i].second];
pair<long long, long long> p = query1(vel);
ans += (p.second) * (arr[i].first);
ans -= p.first;
upd1(vel, arr[i].first);
}
cout << ans;
}
| 12 | CPP |
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
class RangeMinimumQuery:
def __init__(self, n, inf=float("inf")):
self.n0 = 2**(n-1).bit_length()
self.inf = inf
self.data = [self.inf]*(2*self.n0)
self.cnt = [0]*(2*self.n0)
def query(self, l,r):
l += self.n0
r += self.n0
res = 0
cnt = 0
while l < r:
if r&1:
r -= 1
res += self.data[r-1]
cnt += self.cnt[r-1]
if l&1:
res += self.data[l-1]
cnt += self.cnt[l-1]
l += 1
l >>=1
r >>=1
return res, cnt
def update(self, i, x):
i += self.n0-1
self.data[i] += x
self.cnt[i] += 1
while i:
i = ~-i//2
self.data[i] = self.data[2*i+1] + self.data[2*i+2]
self.cnt[i] = self.cnt[2*i+1] + self.cnt[2*i+2]
n = int(input())
xs = list(map(int, input().split()))
vs = list(map(int, input().split()))
xv = [[x,v] for x,v in zip(xs,vs)]
xv.sort()
d = sorted(set(vs))
dd = {j:i for i,j in enumerate(d)}
m = len(dd)
RSQ = RangeMinimumQuery(m, 0)
ans = 0
for x, v in xv:
nv = dd[v]
su, cnt = RSQ.query(0, nv+1)
ans += cnt*x - su
RSQ.update(nv, x)
print(ans)
| 12 | PYTHON3 |
class Points:
def __init__(self, x = 0, v = 0):
self.x, self.v = x, v
class Fenwick_tree:
def __init__(self, n = 0):
self.n = n
self.bit = [0] * (n + 1)
def update(self, x, value):
while x <= self.n:
self.bit[x] += value
x += x & -x
def get(self, x):
sum = 0;
while x > 0:
sum += self.bit[x];
x -= x & -x
return sum
# Input:
n, x, v = int(input()), list(map(int,input().split())), list(map(int,input().split()))
a = [Points(x[i], v[i]) for i in range(n)]
a.sort(key = lambda value: value.x)
# Compress data:
temp = sorted(set(v))
mp = {v: k for k, v in enumerate(temp, 1)}
# Solve the problem:
cnt = Fenwick_tree(n)
sum = Fenwick_tree(n)
res, i = 0, 0
for i in range(n):
a[i].v = mp[a[i].v]
res += a[i].x * cnt.get(a[i].v) - sum.get(a[i].v)
cnt.update(a[i].v, 1)
sum.update(a[i].v, a[i].x)
print(res) | 12 | PYTHON3 |
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 2020/3/13
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, X, S):
si = {}
ss = list(sorted(set(S)))
for i, s in enumerate(ss):
si[s] = i
xs = [(x, si[s]) for x, s in zip(X, S)]
xs.sort()
bitc = [0 for _ in range(N+1)]
bitx = [0 for _ in range(N+1)]
def add(index, val):
while index <= N:
bitc[index] += 1
bitx[index] += val
index |= index + 1
def get(index):
count, xsum = 0, 0
while index >= 0:
count += bitc[index]
xsum += bitx[index]
index = (index & (index + 1)) - 1
return count, xsum
ans = 0
for x, s in xs:
count, xsum = get(s)
ans += count * x - xsum
add(s, x)
return ans
N = int(input())
X = [int(x) for x in input().split()]
S = [int(x) for x in input().split()]
print(solve(N, X, S))
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int b[200005], m;
long long c[200005][2];
struct node {
int x, v;
bool operator<(const node t) const { return x < t.x; }
} a[200005];
int lsh(long long x) { return lower_bound(b + 1, b + 1 + m, x) - b; }
long long query(int x, int k) {
long long ret = 0;
for (int i = x; i >= 1; i -= i & -i) ret += c[i][k];
return ret;
}
void update(int x, int y) {
for (int i = x; i <= m; i += i & -i) {
c[i][0]++;
c[i][1] += y;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
b[i] = a[i].v;
}
sort(b + 1, b + 1 + n);
m = unique(b + 1, b + 1 + n) - b - 1;
sort(a + 1, a + 1 + n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int t = lsh(a[i].v);
ans += query(t, 0) * a[i].x - query(t, 1);
update(t, a[i].x);
}
printf("%lld", ans);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const long long maxn = 500010;
long long T, n, m, p[maxn], v[maxn], mxval = 0, tree[maxn], cnt[maxn], ans = 0;
struct node {
int pos, val, v;
} a[maxn];
void add(int pos, long long val) {
pos += n;
cnt[pos] += 1;
tree[pos] += val;
while (pos) {
pos /= 2;
cnt[pos] = cnt[pos << 1] + cnt[pos << 1 | 1];
tree[pos] = tree[pos << 1] + tree[pos << 1 | 1];
}
}
pair<long long, long long> sum(int l, int r) {
long long ret = 0, p = 0;
for (l += n - 1, r += n + 1; l ^ r ^ 1; l /= 2, r /= 2) {
if (~l & 1) ret += tree[l ^ 1], p += cnt[l ^ 1];
if (r & 1) ret += tree[r ^ 1], p += cnt[r ^ 1];
}
return make_pair(p, ret);
}
int main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].pos);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].v);
sort(a + 1, a + 1 + n, [](node a, node b) { return a.v < b.v; });
a[1].val = 1;
for (int i = 2; i <= n; i++) {
if (a[i].v > a[i - 1].v)
a[i].val = a[i - 1].val + 1;
else
a[i].val = a[i - 1].val;
}
mxval = a[n].val;
sort(a + 1, a + 1 + n, [](node a, node b) { return a.pos < b.pos; });
memset(tree, 0, sizeof(tree));
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= n; i++) {
pair<long long, long long> x = sum(1, a[i].val);
ans += x.first * a[i].pos - x.second;
add(a[i].val, a[i].pos);
}
memset(tree, 0, sizeof(tree));
memset(cnt, 0, sizeof(cnt));
for (int i = n; i >= 1; i--) {
pair<long long, long long> x = sum(a[i].val, mxval);
ans += x.second - x.first * a[i].pos;
add(a[i].val, a[i].pos);
}
printf("%lld\n", ans / 2);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long query(int a, vector<long long>& ft) {
long long res = 0;
for (; ~a; a = (a & (a + 1)) - 1) {
res += ft[a];
}
return res;
}
void update(int a, int val, vector<long long>& ft) {
for (; a < ft.size(); a = a | (a + 1)) {
ft[a] += val;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, int>> pt(n);
map<int, int> idx;
for (auto& i : pt) {
cin >> i.first;
}
for (auto& i : pt) {
cin >> i.second;
idx[i.second] = 0;
}
sort(pt.begin(), pt.end());
int sz = 0;
for (auto& i : idx) {
i.second = sz++;
}
long long ans = 0;
vector<long long> ct(sz), coord(sz);
for (auto i : pt) {
int tmp = idx[i.second];
ans += i.first * query(tmp, ct) - query(tmp, coord);
update(tmp, 1, ct);
update(tmp, i.first, coord);
}
cout << ans << '\n';
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> st[800005];
void update(long long node, long long beg, long long end, long long pos,
long long dist) {
if (beg == end) {
st[node].first += 1;
st[node].second += dist;
return;
}
long long mid = beg + (end - beg) / 2;
if (pos <= mid)
update(2 * node + 1, beg, mid, pos, dist);
else
update(2 * node + 2, mid + 1, end, pos, dist);
st[node] = {st[2 * node + 1].first + st[2 * node + 2].first,
st[2 * node + 1].second + st[2 * node + 2].second};
}
pair<long long, long long> query(long long node, long long beg, long long end,
long long ql, long long qr) {
if (beg > end || beg > qr || end < ql) return {0, 0};
if (beg >= ql && end <= qr) return st[node];
long long mid = beg + (end - beg) / 2;
pair<long long, long long> a = query(2 * node + 1, beg, mid, ql, qr);
pair<long long, long long> b = query(2 * node + 2, mid + 1, end, ql, qr);
return {a.first + b.first, a.second + b.second};
}
int main() {
long long n;
cin >> n;
vector<pair<long long, long long> > v(n);
vector<long long> vel(n);
for (long long i = 0; i < n; i++) cin >> v[i].first;
map<long long, long long> velocity_idx;
for (long long i = 0; i < n; i++) {
cin >> v[i].second;
velocity_idx[v[i].second] = 1;
}
sort(v.begin(), v.end());
long long cnt = 0;
for (auto it : velocity_idx) velocity_idx[it.first] = cnt++;
memset(st, 0, sizeof(st));
long long sz = (long long)velocity_idx.size() - 1;
long long ans = 0;
for (long long i = 0; i < n; i++) {
pair<long long, long long> p =
query(0, 0, sz, 0, velocity_idx[v[i].second]);
ans += (v[i].first * p.first - p.second);
update(0, 0, sz, velocity_idx[v[i].second], v[i].first);
}
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> ara[200005];
map<long long, long long> mark;
long long seg[4 * 300005], seg2[4 * 300005];
long long query(long long qlo, long long qhi, long long lo, long long hi,
long long pos) {
if (qlo > hi || qhi < lo || qlo > qhi) return 0;
if (qlo <= lo && qhi >= hi) return seg[pos];
long long mid = (lo + hi) / 2;
return query(qlo, qhi, lo, mid, 2 * pos) +
query(qlo, qhi, mid + 1, hi, 2 * pos + 1);
}
void update(long long i, long long val, long long lo, long long hi,
long long pos) {
if (lo > i || hi < i) return;
if (lo == i && i == hi) {
seg[pos] += val;
return;
}
long long mid = (lo + hi) / 2;
update(i, val, lo, mid, 2 * pos);
update(i, val, mid + 1, hi, 2 * pos + 1);
seg[pos] = seg[2 * pos] + seg[2 * pos + 1];
}
long long query2(long long qlo, long long qhi, long long lo, long long hi,
long long pos) {
if (qlo > hi || qhi < lo || qlo > qhi) return 0;
if (qlo <= lo && qhi >= hi) return seg2[pos];
long long mid = (lo + hi) / 2;
return query2(qlo, qhi, lo, mid, 2 * pos) +
query2(qlo, qhi, mid + 1, hi, 2 * pos + 1);
}
void update2(long long i, long long val, long long lo, long long hi,
long long pos) {
if (lo > i || hi < i) return;
if (lo == i && i == hi) {
seg2[pos] += val;
return;
}
long long mid = (lo + hi) / 2;
update2(i, val, lo, mid, 2 * pos);
update2(i, val, mid + 1, hi, 2 * pos + 1);
seg2[pos] = seg2[2 * pos] + seg2[2 * pos + 1];
}
vector<long long> vec;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long i, j, k;
for (i = 1; i <= n; i++) {
cin >> ara[i].second;
vec.push_back(ara[i].second);
}
sort(vec.begin(), vec.end());
for (i = 0; i < n; i++) {
mark[vec[i]] = i + 1;
}
for (i = 1; i <= n; i++) {
cin >> ara[i].first;
}
sort(ara + 1, ara + n + 1);
long long fin = 0;
for (i = n; i >= 1; i--) {
long long cur = ara[i].second;
long long tmp = mark[cur];
long long ans = query(tmp + 1, n, 1, n, 1);
fin += ans;
ans = query2(tmp + 1, n, 1, n, 1);
fin -= (ans * cur);
update(tmp, cur, 1, n, 1);
update2(tmp, 1, 1, n, 1);
}
cout << fin << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 1000000007;
const int MAXN = (int)2e5 + 1;
void setIO(string name) {
ios_base::sync_with_stdio(0);
cin.tie(0);
freopen((name + ".in").c_str(), "r", stdin);
freopen((name + ".out").c_str(), "w", stdout);
}
pair<pair<long long, long long>, int> xv[MAXN];
long long n, BIT[MAXN], BIT2[MAXN];
void update(int x, long long val) {
for (; x <= n; x += x & -x) {
BIT[x] += val;
BIT2[x]++;
}
}
pair<long long, long long> query(int x) {
long long sum = 0;
long long num = 0;
for (; x > 0; x -= x & -x) {
sum += BIT[x];
num += BIT2[x];
}
return {sum, num};
}
bool comp(pair<pair<long long, long long>, int> a,
pair<pair<long long, long long>, int> b) {
if (a.first.second == b.first.second) return a.first.first < b.first.first;
return a.first.second < b.first.second;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> xv[i].first.first;
}
for (int i = 0; i < n; i++) {
cin >> xv[i].first.second;
}
sort(xv, xv + n);
for (int i = 0; i < n; i++) {
xv[i].second = i + 1;
}
long long ans = 0;
sort(xv, xv + n, comp);
for (int i = 0; i < n; i++) {
pair<long long, long long> res = query(xv[i].second);
ans += (res.second * xv[i].first.first - res.first);
update(xv[i].second, xv[i].first.first);
}
cout << ans;
return 0;
}
| 12 | CPP |
import bisect
class Bit :
def __init__(self, n) :
self.bit = [0 for i in range(0, n)]
def add(self, pos, x) :
while pos < len(self.bit) :
self.bit[pos] += x
pos = pos | (pos + 1)
def query(self, pos) :
res = 0
while pos > 0 :
res += self.bit[pos - 1];
pos = pos & (pos - 1)
return res
n = int(input())
x = [int(i) for i in input().split()]
v = [int(i) for i in input().split()]
r = [i for i in range(n)]
r.sort(key = lambda i : x[i])
unique = sorted(list(set(v)))
tree1, tree2 = Bit(len(unique)), Bit(len(unique))
ans = 0
for i in r :
ii = bisect.bisect_left(unique, v[i])
count = tree1.query(ii + 1)
dsum = tree2.query(ii + 1)
ans += count * x[i] - dsum
tree1.add(ii, 1)
tree2.add(ii, x[i])
print(ans)
| 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int cnt[400000], cnt1[400000], a[400000], b[400000], number[800000];
map<int, int> mp;
vector<pair<int, int> > v;
int q(int ind) {
int sum = 0;
while (ind > 0) {
sum += number[ind];
ind -= ind & (-ind);
}
return sum;
}
void u(int ind, int n) {
int sum = 0;
while (ind <= n) {
number[ind]++;
ind += ind & (-ind);
}
}
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(0);
};
int i, j, n, m, k, l = 0, h, t;
long long ans = 0;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
cin >> b[i];
v.push_back({a[i], b[i]});
}
sort(b + 1, b + n + 1);
j = 1;
for (i = 1; i <= n; i++) {
if (!mp[b[i]]) mp[b[i]] = j++;
cnt[mp[b[i]]]++;
}
for (i = 1; i < j; i++) b[i] = b[i - 1] + cnt[i - 1];
sort(v.begin(), v.end());
for (i = 0; i < n; i++) {
k = v[i].first;
l = v[i].second;
l = mp[l];
u(l, j - 1);
cnt1[l]++;
m = q(l);
h = n - i - 1 - (cnt[l] + b[l] - m) + cnt[l] - cnt1[l];
ans += (long long)k * (m - 1 - h);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long query(vector<long long>& ft, int pos) {
long long ans = 0;
while (pos > 0) {
ans += ft[pos - 1];
pos -= (pos & (-pos));
}
return ans;
}
void update(vector<long long>& ft, int pos, long long val, int& ceil) {
while (pos <= ceil) {
ft[pos - 1] += val;
pos += (pos & (-pos));
}
}
int main() {
int n;
cin >> n;
vector<pair<int, int>> p(n);
vector<int> v(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(p.begin(), p.end());
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
int ceil = v.size();
vector<long long> ftx(ceil), ftc(ceil);
long long ans = 0;
for (int i = 0; i < n; i++) {
int pos = lower_bound(v.begin(), v.end(), p[i].second) - v.begin();
ans += query(ftc, pos + 1) * (1ll * p[i].first) - query(ftx, pos + 1);
update(ftc, pos + 1, 1, ceil);
update(ftx, pos + 1, p[i].first, ceil);
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
import heapq
import sys
input = sys.stdin.readline
def make_tree(n):
tree = [0] * (n + 1)
return tree
def get_sum(i, tree):
s = 0
while i > 0:
s += tree[i]
i -= i & -i
return s
def add(i, x, tree):
while i <= n:
tree[i] += x
i += i & -i
n = int(input())
x = list(map(int, input().split()))
v = list(map(int, input().split()))
u = list(set(v))
u.sort(reverse = True)
m = len(u)
d = dict()
for i in range(m):
d[u[i]] = i + 2
tree = make_tree(n + 5)
cnt = make_tree(n + 5)
ans = 0
h = []
for i in range(n):
heapq.heappush(h, (x[i], i))
sx = []
while h:
xi, i = heapq.heappop(h)
sx.append(xi)
vi = v[i]
di = d[vi]
ans -= get_sum(di - 1, cnt) * xi - get_sum(di - 1, tree)
add(di, xi, tree)
add(di, 1, cnt)
for i in range(n - 1):
ans += (i + 1) * (n - i - 1) * (sx[i + 1] - sx[i])
print(ans) | 12 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int tc = 0;
int solve();
int main() {
ios_base::sync_with_stdio(0);
if (tc < 0) {
cout << "TC!\n";
cin.ignore(1e8);
} else if (!tc)
cin >> tc;
while (tc--) solve();
return 0;
}
int solve() {
long long l, r;
cin >> n >> l >> r;
l--;
r--;
long long a = 1;
while (1) {
if (l > 2 * (n - a)) {
l -= 2 * (n - a);
r -= 2 * (n - a);
a++;
} else
break;
}
vector<long long> ans;
int b = a + 1;
while (ans.size() <= r + 1) {
ans.push_back(a);
ans.push_back(b);
b++;
if (b == n + 1) {
a++;
if (a == n) {
ans.push_back(1);
break;
}
b = a + 1;
}
}
for (int i = l; i <= r; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int64_t n, l, r;
cin >> n >> l >> r;
l--, r--;
int64_t cnt = 0;
int64_t start = 1;
int64_t num = n - 1;
while (start < n) {
if (l < cnt + 2 * num && r >= cnt) {
for (int64_t i = 0; i < 2 * num; i++) {
if (l <= cnt + i && cnt + i <= r) {
if (i & 1)
cout << start + (i + 1) / 2 << ' ';
else
cout << start << ' ';
}
}
}
cnt += 2 * num;
num--;
start++;
}
if (r == cnt) cout << 1;
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
solve();
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int T;
int N;
long long L, R;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%lld%lld", &N, &L, &R);
if (L == R && L == 1LL * N * (N - 1) + 1) {
printf("1\n");
continue;
}
long long i = N - 1;
for (; i; i--) {
if (L > 2 * i)
L -= 2 * i, R -= 2 * i;
else
break;
}
long long u = N - i, v = (L - 1) / 2 + u;
for (i = L; i <= R; i++) {
if (v == N) u++, v = u;
if (u == N) {
printf("1 ");
break;
}
if (i & 1LL)
printf("%lld ", u);
else
v++, printf("%lld ", v);
}
printf("\n");
}
return 0;
}
| 10 | CPP |
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 2020/7/1
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(n, l, r):
# 1, 2, 1, 3, ..., 1, n
# 2, 3, 2, 4, ..., 2, n
# ...
# n-1, n
# 1
lo, hi = 1, n
while lo <= hi:
k = (lo + hi) // 2
s = k * (2*n-1-k)
if s < l:
lo = k + 1
else:
hi = k - 1
k = lo
s = k * (2*n-1-k)
b = k
# [b, b+1, b, b+2, ..., b, n]
row = []
for i in range(b+1, n+1):
row.append(b)
row.append(i)
ans = row[l-s-1:]
d = r-l+1
if len(ans) >= d:
return ans[:d]
while len(ans) < d:
b += 1
row = []
for i in range(b + 1, n + 1):
row.append(b)
row.append(i)
if not row:
break
ans += row
ans.append(1)
# print(ans[:d])
return ans[:d]
if __name__ == '__main__':
T = int(input())
ans = []
for ti in range(T):
N, L, R = map(int, input().split())
ans.append(solve(N, L, R))
print('\n'.join([' '.join(map(str, v)) for v in ans])) | 10 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, pstart, pend;
int t;
cin >> t;
for (int testcases = 1; testcases <= t; testcases++) {
cin >> n >> pstart >> pend;
bool completestart = true;
bool completeend = true;
bool flag = false;
bool paranoidcheck = false;
if (pstart == pend) {
paranoidcheck = true;
}
if (pend == n * (n - 1) + 1) {
if (pstart == pend) {
cout << 1 << endl;
continue;
} else {
flag = true;
pend -= 1;
}
}
if (pstart % 2 == 0) {
completestart = false;
} else {
pstart += 1;
}
pstart /= 2;
if (pend % 2 == 1) {
completeend = false;
pend += 1;
}
pend /= 2;
long long iter = pend - pstart;
if (paranoidcheck) {
iter -= 1;
}
long long a = 1;
long long b = 1;
while (pstart - (n - a) > 0) {
pstart -= (n - a);
a += 1;
}
b = a + pstart;
if (!completestart) {
cout << b << " ";
if (b < n) {
b += 1;
} else {
a += 1;
b = a + 1;
}
iter -= 1;
}
if (!completeend) {
iter -= 1;
}
for (int k = 0; k <= iter; k++) {
cout << a << " " << b << " ";
if (b < n) {
b += 1;
} else {
a += 1;
b = a + 1;
}
}
if (!completeend) {
cout << a << " ";
}
if (flag) {
cout << 1;
}
cout << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const int N = 3 * 1e5 + 5;
const long long MOD = 1000000007;
const long long inf = 1e18;
using namespace std;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void solve() {
long long n, l, r;
cin >> n >> l >> r;
long long ctr = 0;
long long lt = l;
if (l == n * (n - 1) + 1) {
cout << 1 << "\n";
return;
}
while (lt > 0) {
ctr++;
lt -= 2 * (n - ctr);
}
lt += 2 * (n - ctr);
long long val = (r - l + 1);
while (val) {
val--;
if (ctr == n) {
cout << "1"
<< " "
<< "\n";
return;
}
if (lt % 2 == 1)
cout << ctr;
else
cout << ctr + lt / 2;
cout << " ";
if (lt < 2 * (n - ctr))
lt++;
else {
ctr++;
lt = 1;
}
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 10 | CPP |
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
t = int(input())
for _ in range(t):
n,a,b = map(int,input().split(' '))
loop = b+1-a
a-=1
a%=n*(n-1)
a+=1
sbb = 2*(n-1)
ctr = 1
ans = []
while a>sbb:
ctr+=1
sbb+=2*n-2*ctr
d = a-sbb+2*n-2*ctr
cur = ctr
d-=1
p1 = 1+cur
ti = 0
while d:
d-=1
ti += 1
if ti & 1:
cur = p1
if p1 == n:
ctr += 1
# if ctr == n-1:
p1 = ctr
else:
if ctr == n and p1 == n:
ctr = 1
p1 = 1
p1 += 1
cur = ctr
for j in range(loop):
ans.append(cur)
ti+=1
if ti & 1:
cur = p1
if p1 == n:
ctr += 1
# if ctr == n-1:
p1 = ctr
else:
if ctr == n and p1 == n:
ctr = 1
p1 = 1
p1+=1
cur = ctr
print(*ans) | 10 | PYTHON3 |
t=int(input())
for _ in range(t):
n,l,r=map(int, input().split())
cycle_size = 2 * (n - 1)
cycle_start = 1
cycle_number = 1
# while True:
# if cycle_start + cycle_size >= l:
# break
# cycle_start += cycle_size
# cycle_number += 1
# cycle_size -= 2
# print [l,r]
while cycle_start + cycle_size <= l and cycle_number != n:
cycle_start += cycle_size
cycle_number += 1
cycle_size -= 2
# print('cycle_start, cycle_size', cycle_start, cycle_size)
ans = []
while l <= r:
# print('l, cycle_start, cycle_size', l, cycle_start, cycle_size)
if (l - cycle_start) & 1:
# print('cycle_size', cycle_size)
if not cycle_size:
ans.append(1)
else:
ans.append(cycle_number + (l - cycle_start + 1) // 2)
else:
# print('cycle_size', cycle_size)
if not cycle_size:
ans.append(1)
else:
ans.append(cycle_number)
# print('ans', ans)
# if (l - cycle_start) // 2
l += 1
if (l - cycle_start) >= cycle_size:
cycle_start += cycle_size
cycle_size -= 2
cycle_number += 1
print(' '.join(str(x) for x in ans))
| 10 | PYTHON3 |
for _ in range(int(input())):
numbers, LEFTs, RIGHTs = map(int, input().split())
KEYSs = 0
GREATS = 0
for i in range(1, numbers+1):
if KEYSs + 2 * (numbers-i) >= LEFTs:
GREATS = LEFTs-KEYSs-1
break
KEYSs += 2 * (numbers-i)
LISTs = []
while len(LISTs) < (RIGHTs-LEFTs+1) + GREATS:
for j in range(i+1, numbers+1):
LISTs.append(i)
LISTs.append(j)
i += 1
if i >= numbers:
LISTs.append(1)
break
print (' '.join(list(map(str, LISTs[GREATS:GREATS+RIGHTs-LEFTs+1]))))
| 10 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
long long binpow(long long base, long long exp, int mod) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % mod;
exp = exp >> 1;
base = (base * base) % mod;
}
return res;
}
long long mod(long long x) {
return ((x % 1000000007LL + 1000000007LL) % 1000000007LL);
}
long long add(long long a, long long b) { return mod(mod(a) + mod(b)); }
long long mul(long long a, long long b) { return mod(mod(a) * mod(b)); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t;
cin >> t;
while (t--) {
long long int n, l, r;
cin >> n >> l >> r;
long long int check[n];
check[0] = 2 * (n - 1);
long long int temp = n - 1;
for (int i = 1; i < n; i++) {
temp--;
if (i == n - 1) {
check[i] = check[i - 1] + 1;
} else {
check[i] = check[i - 1] + 2 * temp;
}
}
long long int val, offset;
for (int i = 0; i < n; i++) {
if (check[i] >= l) {
val = i + 1;
if (i == 0) {
offset = val + l / 2 + l % 2;
} else {
offset = val + (l - check[i - 1]) / 2 + (l - check[i - 1]) % 2;
}
break;
}
}
long long int ans[r - l + 1];
long long int y = l;
if (val == n) {
cout << 1 << "\n";
} else {
for (; l <= r; l++) {
if (l % 2 == 1) {
cout << val << " ";
} else {
cout << offset << " ";
if (offset == n) {
val++;
offset = val + 1;
} else {
offset++;
}
if (val == n) {
break;
}
}
}
if (r == ((n) * (n - 1) + 1)) {
cout << 1;
}
cout << "\n";
}
}
return 0;
}
| 10 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.