text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
template <class T>
class SegmentTree {
private:
int _size = 1;
T _def;
std::vector<T> _nodes;
std::function<T(T, T)> _op;
std::function<T(T, T)> _update_op;
public:
SegmentTree(int size, T default_value, std::function<T(T, T)> op,
std::function<T(T, T)> update_op)
: _def(default_value), _op(op), _update_op(update_op) {
while (_size < size) _size *= 2;
_nodes = std::vector<T>(2 * _size, default_value);
}
SegmentTree(std::vector<T> nodes, T default_value, std::function<T(T, T)> op,
std::function<T(T, T)> update_op)
: _def(default_value), _op(op), _update_op(update_op) {
int real_size = nodes.size();
while (_size < real_size) _size *= 2;
_nodes = std::vector<T>(2 * _size, default_value);
for (int i = 0; i < real_size; ++i) _nodes[i + _size] = nodes[i];
for (int i = _size - 1; i >= 0; --i)
_nodes[i] = _op(_nodes[i * 2], _nodes[i * 2 + 1]);
}
T find(int l, int r) { return find(l, r, 1, 0, _size); }
T find(int l, int r, int index, int cover_l, int cover_r) {
if (cover_r <= l || r <= cover_l) return _def;
if (l <= cover_l && cover_r <= r) return _nodes[index];
return _op(find(l, r, index * 2, cover_l, (cover_l + cover_r) >> 1),
find(l, r, index * 2 + 1, (cover_l + cover_r) >> 1, cover_r));
}
void update(int index, T value) {
index += _size;
_nodes[index] = _update_op(_nodes[index], value);
while (index > 0) {
index >>= 1;
_nodes[index] = _op(_nodes[index * 2], _nodes[index * 2 + 1]);
}
}
};
struct Point {
ll x, v;
bool operator<(const Point &other) const { return x < other.x; }
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
int n;
cin >> n;
int x, v;
set<int> vs;
vector<Point> ps;
for (ll i = 0, iLen = (n); i < iLen; ++i) {
cin >> x;
ps.push_back(Point{x, 0});
}
for (ll i = 0, iLen = (n); i < iLen; ++i) {
cin >> v;
ps[i].v = v;
vs.insert(v);
}
map<int, int> v_comp;
int i = 0;
for (auto &v : vs) {
v_comp[v] = i++;
}
int v_size = v_comp.size() + 10;
auto x_cnt = SegmentTree<ll>(
v_size, 0, [](ll x, ll y) { return x + y; },
[](ll x, ll y) { return x + y; });
auto x_acc = SegmentTree<ll>(
v_size, 0, [](ll x, ll y) { return x + y; },
[](ll x, ll y) { return x + y; });
for (ll i = 0, iLen = (n); i < iLen; ++i) {
ps[i].v = v_comp[ps[i].v];
x_cnt.update(ps[i].v, 1);
x_acc.update(ps[i].v, ps[i].x);
}
sort(ps.begin(), ps.end());
ll ans = 0;
for (auto &[x, v] : ps) {
x_cnt.update(v, -1);
x_acc.update(v, -x);
ans += x_acc.find(v, v_size) - x_cnt.find(v, v_size) * x;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void transform(long long int a[], long long int n) {
map<long long int, vector<long long int> > m;
for (long long int i = 0; i < (n); i++) m[a[i]].push_back(i);
long long int rank = 1;
for (auto c : m) {
for (auto i : c.second) a[i] = rank;
rank++;
}
}
const long long int N = 2e5 + 5;
long long int n = -1e9;
void update(long long int B[], long long int x, long long int val) {
for (; x <= n; x += x & -x) B[x] += val;
}
long long int query(long long int B[], long long int x) {
long long int sum = 0;
for (; x > 0; x -= x & -x) sum += B[x];
return sum;
}
int main() {
long long int num;
cin >> num;
long long int x[num + 5], v[num + 5], ans = 0;
vector<pair<long long int, long long int> > pts;
for (long long int i = 0; i < (num); i++) cin >> x[i];
for (long long int i = 0; i < (num); i++) cin >> v[i];
for (long long int i = 0; i < (num); i++)
pts.push_back(make_pair(x[i], v[i]));
sort((pts).begin(), (pts).end());
for (long long int i = 0; i < (num); i++)
x[i] = pts[i].first, v[i] = pts[i].second;
transform(v, num);
n = *max_element(v, v + num);
long long int pref[N] = {0}, freq[N] = {0};
update(pref, v[num - 1], x[num - 1]);
update(freq, v[num - 1], 1);
for (long long int i = num - 2; i > (-1); i--) {
long long int sum = query(pref, n) - query(pref, v[i] - 1);
long long int nump = query(freq, n) - query(freq, v[i] - 1);
ans += (sum - nump * x[i]);
update(pref, v[i], x[i]);
update(freq, v[i], 1);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 9;
int n, a[MAX], speed[MAX], b[MAX];
int idx[MAX];
vector<pair<int, int> > v;
unordered_map<int, int> startRange;
long long tree[(MAX << 2)][2], val;
int l, r, idxToUpd;
void build(int id, int low, int high, int pos) {
if (low == high) {
tree[pos][id] = b[low];
return;
}
int mid = ((low + high) >> 1);
build(id, low, mid, (pos << 1));
build(id, mid + 1, high, (pos << 1 | 1));
tree[pos][id] = tree[(pos << 1)][id] + tree[(pos << 1 | 1)][id];
}
long long qwr(int id, int low, int high, int pos) {
if (l > high || r < low) {
return 0;
}
if (l <= low && r >= high) {
return tree[pos][id];
}
int mid = ((low + high) >> 1);
return qwr(id, low, mid, (pos << 1)) + qwr(id, mid + 1, high, (pos << 1 | 1));
}
void upd(int id, int low, int high, int pos) {
if (low == high) {
tree[pos][id] = val;
return;
}
int mid = ((low + high) >> 1);
if (idxToUpd <= mid) {
upd(id, low, mid, (pos << 1));
} else {
upd(id, mid + 1, high, (pos << 1 | 1));
}
tree[pos][id] = tree[(pos << 1)][id] + tree[(pos << 1 | 1)][id];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
cin >> speed[i];
v.push_back({speed[i], i});
}
sort(v.begin(), v.end());
for (int i = 0; i < n; ++i) {
idx[v[i].second] = i + 1;
if (startRange.find(v[i].first) == startRange.end()) {
startRange[v[i].first] = i + 1;
}
}
for (int i = 1; i <= n; ++i) {
b[idx[i]] = a[i];
}
build(0, 1, n, 1);
v.clear();
for (int i = 1; i <= n; ++i) {
v.push_back({a[i], i});
}
sort(v.begin(), v.end());
long long ans = 0;
for (int i = 0; i < n; ++i) {
l = startRange[speed[v[i].second]];
r = n;
int cntRemoved = qwr(1, 1, n, 1);
long long sum = qwr(0, 1, n, 1);
long long rest = (n - startRange[speed[v[i].second]] + 1) - cntRemoved;
ans += sum - rest * (long long)v[i].first;
idxToUpd = idx[v[i].second];
val = 1;
upd(1, 1, n, 1);
val = 0;
upd(0, 1, n, 1);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 200005;
long long bit[mx][2];
int arr[mx];
int speed[mx];
vector<pair<int, int> > vec;
void update(int idx, int val) {
for (int i = idx; i < mx; i += (i & -i)) {
bit[i][0] += 1LL * val;
bit[i][1]++;
}
}
pair<long long, long long> query(int idx) {
pair<long long, long long> ans = make_pair(0, 0);
for (int i = idx; i > 0; i -= (i & -i)) {
ans.first += bit[i][0];
ans.second += bit[i][1];
}
return ans;
}
int main() {
map<int, int> mpp;
int n, i, j, k, x, v;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", arr + i);
}
for (i = 1; i <= n; i++) {
scanf("%d", speed + i);
vec.push_back(make_pair(speed[i], 0));
}
sort(vec.begin(), vec.end());
for (i = 0; i < n; i++) {
mpp[vec[i].first] = i + 1;
}
vec.clear();
for (i = 1; i <= n; i++) {
vec.push_back(make_pair(arr[i], mpp[speed[i]]));
}
sort(vec.begin(), vec.end());
pair<long long, long long> temp;
long long ans = 0, now;
for (i = 0; i < n; i++) {
temp = query(vec[i].second);
now = 1LL * temp.second * vec[i].first - temp.first;
ans += now;
update(vec[i].second, vec[i].first);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
struct BIT {
vector<long long int> bit;
int n;
BIT(long long int N) {
n = N;
bit.assign(n + 1, 0);
}
void add(int idx, int delta) {
while (idx <= n) {
bit[idx] += delta;
idx += (idx & -idx);
}
}
long long int sum(int idx) {
long long int res = 0;
while (idx > 0) {
res += bit[idx];
idx -= (idx & -idx);
}
return res;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int> > p(n);
for (auto &i : p) cin >> i.first;
for (auto &i : p) cin >> i.second;
sort(p.begin(), p.end());
vector<int> v;
for (auto i : p) v.push_back(i.second);
sort(v.begin(), v.end());
map<int, int> mp;
int cnt = 0;
for (auto i : v) mp[i] = ++cnt;
for (auto &i : p) i.second = mp[i.second];
long long int ans = 0;
BIT tree1(n), tree2(n);
for (auto i : p) {
long long int cnt = tree1.sum(i.second);
long long int sum_x = tree2.sum(i.second);
ans += cnt * i.first - sum_x;
tree1.add(i.second, 1);
tree2.add(i.second, i.first);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6 + 100, mod = 1e9 + 7, inf = 1e16 + 7;
pair<long long, long long> a[maxn];
long long get(long long l, long long r) {
if (r - l == 1) return 0;
long long m = (r + l) / 2;
long long ans = 0;
ans += get(l, m);
ans += get(m, r);
long long ptr = m;
vector<long long> pref(r - m + 2, 0);
for (long long i = r - 1; i >= m; --i) {
pref[i - m] = pref[i + 1 - m] + a[i].first;
}
vector<pair<long long, long long> > tmp;
for (long long i = l; i < m; ++i) {
while (ptr < r && a[i].second > a[ptr].second) {
tmp.push_back(a[ptr]);
ptr++;
}
tmp.push_back(a[i]);
ans += pref[ptr - m];
ans -= (r - ptr) * a[i].first;
}
while (ptr < r) tmp.push_back(a[ptr]), ptr++;
for (long long i = l; i < r; ++i) {
a[i] = tmp[i - l];
}
return ans;
}
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);
cout << get(0, n);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
srand(10);
cout << fixed << setprecision(2);
long long t = 1;
while (t--) {
solve();
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)2e5 + 100;
const int mod = (int)1e9 + 7;
int n, c[maxn];
long long ans;
pair<int, int> a[maxn];
int main() {
scanf("%d", &n);
for (auto i = (1); i <= (n); ++i)
scanf("%d", &a[i].second), c[i] = a[i].second;
for (auto i = (1); i <= (n); ++i) scanf("%d", &a[i].first);
sort(a + 1, a + 1 + n);
sort(c + 1, c + 1 + n);
for (auto i = (1); i <= (n); ++i)
ans += (i - 1 - n + lower_bound(c + 1, c + 1 + n, a[i].second) - c) *
(long long)a[i].second;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int b[200005], m;
long long tr[800005][2];
struct node {
int x, v;
bool operator<(const node t) const { return x < t.x; }
} a[200005];
int lsh(long long x) { return lower_bound(b + 1, b + 1 + m, x) - b; }
long long query(int l, int r, int x, int y, int z, int p) {
if (l == x && r == y) return tr[p][z];
int mid = l + r >> 1;
if (y <= mid)
return query(l, mid, x, y, z, p << 1);
else if (x > mid)
return query(mid + 1, r, x, y, z, p << 1 | 1);
else
return query(l, mid, x, mid, z, p << 1) +
query(mid + 1, r, mid + 1, y, z, p << 1 | 1);
}
void update(int l, int r, int x, int y, int p) {
if (l == r) {
tr[p][0]++;
tr[p][1] += y;
return;
}
int mid = l + r >> 1;
if (x <= mid)
update(l, mid, x, y, p << 1);
else
update(mid + 1, r, x, y, p << 1 | 1);
tr[p][0] = tr[p << 1][0] + tr[p << 1 | 1][0];
tr[p][1] = tr[p << 1][1] + tr[p << 1 | 1][1];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
b[i] = a[i].v;
}
sort(b + 1, b + 1 + n);
m = unique(b + 1, b + 1 + n) - b - 1;
sort(a + 1, a + 1 + n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int x = lsh(a[i].v);
ans += query(1, m, 1, x, 0, 1) * a[i].x - query(1, m, 1, x, 1, 1);
update(1, m, x, a[i].x, 1);
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int inf = 0x3f3f3f3f;
const long long INF = 0x7f7f7f7f7f7f7f7f;
const int mod = 1e9 + 7;
const double PI = acos(-1.0);
const double eps = 1e-5;
int n;
pair<long long, long long> a[maxn];
long long b[maxn];
long long s1[maxn], s2[maxn];
int lb(int x) { return x & (-x); }
void add(int x, long long w) {
for (int i = x; i <= n; i += lb(i)) {
s1[i]++;
s2[i] += w;
}
}
long long sum1(int x) {
long long res = 0;
for (int i = x; i >= 1; i -= lb(i)) res += s1[i];
return res;
}
long long sum2(int x) {
long long res = 0;
for (int i = x; i >= 1; i -= lb(i)) res += s2[i];
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i].first);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i].second);
b[i] = a[i].second;
}
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + n);
int len = unique(b + 1, b + 1 + n) - (b + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int pos = lower_bound(b + 1, b + 1 + len, a[i].second) - b;
long long res1 = sum1(pos);
long long res2 = sum2(pos);
ans += res1 * a[i].first - res2;
add(pos, a[i].first);
}
printf("%lld", ans);
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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";
}
|
#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);
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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();
}
|
#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;
}
|
#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;
}
|
#include <bits/stdc++.h>
using namespace std;
long long get(vector<long long> &f, int pos) {
long long res = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) res += f[pos];
return res;
}
void upd(vector<long long> &f, int pos, int val) {
for (; pos < int(f.size()); pos |= pos + 1) {
f[pos] += val;
}
}
int main() {
int n;
cin >> n;
vector<pair<int, int>> p(n);
for (auto &pnt : p) cin >> pnt.first;
for (auto &pnt : p) cin >> pnt.second;
sort(p.begin(), p.end());
vector<int> vs;
for (auto &pnt : p) vs.push_back(pnt.second);
sort(vs.begin(), vs.end());
vs.resize(unique(vs.begin(), vs.end()) - vs.begin());
long long ans = 0;
vector<long long> cnt(vs.size()), xs(vs.size());
for (auto &pnt : p) {
int pos = lower_bound(vs.begin(), vs.end(), pnt.second) - vs.begin();
ans += get(cnt, pos) * 1ll * pnt.first - get(xs, pos);
upd(cnt, pos, 1);
upd(xs, pos, pnt.first);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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);
}
|
#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;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int MOD = 1e9 + 7;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umod(T& a) {
while (a < 0) a += MOD;
a %= MOD;
return 1;
}
int n, cn, a[N], b[N], c[N];
long long T[N << 2], S[N << 2], ans;
map<int, int> mk;
pair<int, int> p[N];
void upd(int x, int val, int l, int r, int v) {
S[v]++, T[v] += val;
if (l == r) return;
if (x <= ((l + r) >> 1))
upd(x, val, l, ((l + r) >> 1), v << 1);
else
upd(x, val, ((l + r) >> 1) + 1, r, v << 1 | 1);
}
long long getT(int x, int y, int l, int r, int v) {
if (y < l || r < x) return 0LL;
if (x <= l && r <= y) return T[v];
return getT(x, y, l, ((l + r) >> 1), v << 1) +
getT(x, y, ((l + r) >> 1) + 1, r, v << 1 | 1);
}
long long getS(int x, int y, int l, int r, int v) {
if (y < l || r < x) return 0LL;
if (x <= l && r <= y) return S[v];
return getS(x, y, l, ((l + r) >> 1), v << 1) +
getS(x, y, ((l + r) >> 1) + 1, r, v << 1 | 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) scanf("%d", b + i), mk[b[i]] = 1;
for (__typeof(mk.begin()) i = (mk.begin()); i != (mk.end()); i++)
i->second = ++cn;
for (int i = 1; i <= n; i++) {
c[i] = mk[b[i]];
p[i] = {a[i], i};
}
sort(p + 1, p + n + 1);
for (int i = 1; i <= n; i++) {
long long s, t;
ans += (1LL * (s = getS(1, c[p[i].second], 1, cn, 1)) * p[i].first) -
(t = getT(1, c[p[i].second], 1, cn, 1));
upd(c[p[i].second], p[i].first, 1, cn, 1);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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';
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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";
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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';
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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';
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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";
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#include <bits/stdc++.h>
using namespace std;
int b[200005], m;
long long c[200005][2];
struct node {
int x, v;
bool operator<(const node t) const { return x < t.x; }
} a[200005];
int lsh(long long x) { return lower_bound(b + 1, b + 1 + m, x) - b; }
long long query(int x, int k) {
long long ret = 0;
for (int i = x; i >= 1; i -= i & -i) ret += c[i][k];
return ret;
}
void update(int x, int y) {
for (int i = x; i <= m; i += i & -i) {
c[i][0]++;
c[i][1] += y;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
b[i] = a[i].v;
}
sort(b + 1, b + 1 + n);
m = unique(b + 1, b + 1 + n) - b - 1;
sort(a + 1, a + 1 + n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int t = lsh(a[i].v);
ans += query(t, 0) * a[i].x - query(t, 1);
update(t, a[i].x);
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const 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);
}
|
#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';
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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();
}
}
|
#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;
}
|
#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;
}
|
#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();
}
}
|
#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;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long n, l, r;
cin >> n >> l >> r;
vector<long long> pre(n + 1);
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + 2 * (n - i);
}
pre[n]++;
for (long long i = l; i <= r; i++) {
int pos = lower_bound(pre.begin(), pre.end(), i) - pre.begin();
if (pos == n)
cout << "1"
<< " ";
else {
long long j = i - pre[pos - 1];
if (j % 2 == 1)
cout << pos << " ";
else
cout << (j / 2 + pos) << " ";
}
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, l, r;
cin >> n >> l >> r;
long long s = 0;
long long i;
for (i = 1; i <= n - 1; i++) {
s += 2 * (n - i);
if (l <= s) {
s = s - 2 * (n - i);
break;
}
}
long long j, x = i;
if (x == n) x = 1;
if ((l - s) % 2 == 1) {
j = i + (l + 1 - s) / 2;
int f = 0;
for (long long v = l; v <= r; v++) {
if (f == 0) {
cout << x << " ";
f = 1;
} else {
cout << j << " ";
j++;
f = 0;
if (j == n + 1) {
x++;
if (x == n) x = 1;
j = x + 1;
}
}
}
} else {
j = i + (l - s) / 2;
int f = 1;
for (long long v = l; v <= r; v++) {
if (f == 0) {
cout << x << " ";
f = 1;
} else {
cout << j << " ";
j++;
f = 0;
if (j == n + 1) {
x++;
if (x == n) x = 1;
j = x + 1;
}
}
}
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, l, r;
cin >> n >> l >> r;
if (l == n * (n - 1LL) + 1LL) {
cout << 1 << '\n';
return;
}
long long suma = 0LL;
long long trenutni = (long long)n - 1LL;
while (trenutni > 0) {
if (suma + 2 * trenutni >= l) break;
suma += 2 * trenutni;
--trenutni;
}
trenutni = (n - trenutni);
long long sledeci = trenutni;
for (long long i = suma + 1; i <= r; ++i) {
if (i == n * (n - 1) + 1) {
cout << 1 << ' ';
cout << '\n';
return;
}
if (i % 2 == 1) {
++sledeci;
}
if (i >= l) {
if (i % 2)
cout << trenutni << ' ';
else
cout << sledeci << ' ';
}
if (sledeci == n && i % 2 == 0) sledeci = ++trenutni;
}
cout << '\n';
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007, N = 1e5 + 5, M = 1e5 + 5, INF = 0x3f3f3f3f;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
long long n, l, r;
cin >> n >> l >> r;
if (l == r && l == n * (n - 1) + 1) {
cout << 1 << endl;
continue;
}
int nowx = 1, nowy = 2;
long long sum = 0;
while (sum < l) {
sum += 2 * (n - nowx);
++nowx;
}
--nowx;
sum -= 2 * (n - nowx);
++sum;
vector<int> ans;
nowy = nowx + 1;
int di = 1;
int cnt = sum;
while (sum <= r) {
if (di)
ans.push_back(nowx);
else {
ans.push_back(nowy);
++nowy;
if (nowy > n) {
nowx++;
nowy = nowx + 1;
if (nowx > n) nowx = 1;
}
}
++sum;
di ^= 1;
}
if (r == n * (n - 1) + 1) ans[ans.size() - 1] = 1;
cout << ans[l - cnt];
for (long long i = l - cnt + 1; i <= r - cnt; ++i) cout << ' ' << ans[i];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxc = 1e5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long k = 0;
long long n, l, r;
cin >> n >> l >> r;
for (long long i = 2 * (n - 1); i; k += i, i -= 2) {
for (long long j = max(l, k + 1); j <= min(r, k + i); j++) {
if (j % 2)
cout << n - i / 2 << " ";
else
cout << n - i / 2 + (j - k) / 2 << " ";
}
}
if (k + 1 == r) cout << 1;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct R {
long long int nd, i;
};
int main() {
long long int n, l, r, st;
scanf("%*d");
while (~scanf("%lld %lld %lld", &n, &l, &r)) {
long long int p, i, j, nd;
vector<R> v;
v.push_back({1, 1});
for (p = 1, i = 2, j = n - 1; i < n; i++, j--) v.push_back({i, p += j + j});
long long int st = 0, en = v.size() - 1, md, pos = -1;
while (st <= en) {
md = (st + en) / 2;
if (v[md].i > l)
en = md - 1;
else {
pos = max(pos, md);
st = md + 1;
}
}
vector<R> pet;
for (nd = v[pos].nd, i = v[pos].i; i <= r && nd < n; nd++) {
for (j = nd + 1; j <= n && i <= r; j++)
pet.push_back({nd, i++}), pet.push_back({j, i++});
}
if (nd == n) pet.push_back({1, i++});
for (auto it : pet)
if (it.i >= l && it.i <= r) printf("%lld ", it.nd);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 300010;
long long t, n, a[N], b[N], x[N];
int main() {
scanf("%lld", &t);
while (t--) {
long long l, r;
scanf("%lld", &n);
scanf("%lld%lld", &l, &r);
long long tot = r - l + 1;
long long high = n - 1, low = 1, mid, s = -1;
while (high >= low) {
mid = (high + low) / 2;
long long c = (2 * ((mid * n) - (mid * (mid + 1)) / 2));
if (c >= l) {
s = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
if (s == -1) {
printf("1\n");
continue;
}
long long ps = s - 1, pre = (2 * ((ps * n) - (ps * (ps + 1)) / 2));
long long pos = l - pre;
while (tot > 0 && s < n) {
long long len = (2 * (n - s));
while (tot > 0 && pos <= len) {
if (pos % 2)
printf("%lld ", s);
else {
printf("%lld ", s + (pos / 2));
}
pos++;
tot--;
}
if (tot > 0) {
pos = 1;
s++;
}
}
if (tot) printf("1 ");
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> func(int n, long long l, long long r) {
long long start = 1;
long long end = 2 * 1ll * (n - 1);
vector<int> ans;
if (start <= l && l <= end) {
while (l <= r && l <= end) {
if (l % 2 == 1) {
ans.push_back(1);
} else {
ans.push_back(l / 2 + 1);
}
l++;
}
}
for (int i = 2; i < n; ++i) {
if (i == n - 1) {
start = end + 1;
end = start + 1;
if (start <= l && l <= end) {
while (l <= r && l <= end) {
if (start == l) {
ans.push_back(n - 1);
} else {
ans.push_back(n);
}
l++;
}
}
} else {
long long tmp_start = end;
start = end + 1;
end = start + 2 + (n - i - 1) * 1ll * 2;
end = end - 1;
if (start <= l && l <= end) {
while (l <= r && l <= end) {
int ref_value = l - tmp_start;
if (ref_value == 1) {
ans.push_back(i);
} else if (l != end) {
if (ref_value % 2 == 0) {
ans.push_back(i + ref_value / 2);
} else {
ans.push_back(i);
}
} else {
ans.push_back(n);
}
l++;
}
}
}
}
start = end + 1;
end = end + 1;
if (start <= l && l <= end) {
while (l <= r && l <= end) {
ans.push_back(1);
l++;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int tt;
cin >> tt;
while (tt--) {
int n;
long long l, r;
cin >> n >> l >> r;
vector<int> v = func(n, l, r);
for (int x : v) {
cout << x << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int N = 2e5 + 2;
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long n, l, r;
scanf("%lld", &n);
scanf("%lld", &l);
scanf("%lld", &r);
long long cur = 0, val = 2 * (n - 1), ind = 1;
while (cur + val < l) {
cur += val;
val /= 2;
val--;
val *= 2;
ind++;
if (ind == n) val = 1;
}
long long total = n * (n - 1) + 1;
long long ptr = cur + 1;
long long x = ind, y = x + 1;
vector<pair<long long, long long> > v;
while (ptr <= r) {
if (ptr == total) {
v.push_back({1, ptr});
break;
}
v.push_back({x, ptr});
v.push_back({y, ptr + 1});
ptr += 2;
y++;
if (y > n) {
x++;
y = x + 1;
if (x == n) {
v.push_back({1, ptr});
break;
}
}
}
for (auto i : v)
if (i.second >= l && i.second <= r) printf("%d ", (int)i.first);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, t, l, r, o, e, pos;
long long Find(long long k) {
long long t = k;
if (t % 2 == 1)
t = (t + 1) / 2;
else
t /= 2;
for (long long i = 0; i <= n - 1; i++) {
if (n * i - i * (i + 1) / 2 < t && t <= n * (i + 1) - (i + 1) * (i + 2) / 2)
return i + 1;
}
}
int main() {
scanf("%lld", &t);
while (t--) {
scanf("%lld%lld%lld", &n, &l, &r);
if (l % 2 == 0) {
o = l + 1;
e = l + 2;
pos = Find(l);
} else {
o = l;
e = l + 1;
}
long long s1 = Find(o);
long long cnt = Find(e);
long long s2 = e / 2 - ((cnt - 1) * n - (cnt - 1) * cnt / 2) + cnt;
if (l % 2 == 0) {
printf("%lld ", l / 2 - ((pos - 1) * n - (pos - 1) * pos / 2) + pos);
}
for (long long i = o; i <= r; i++) {
if (i == n * (n - 1) + 1) {
printf("1");
break;
}
if (i % 2) {
printf("%lld ", s1);
if (s2 == n) s1++;
} else {
printf("%lld ", s2);
s2++;
if (s2 > n) s2 = s1 + 1;
}
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename S, typename T>
ostream& operator<<(ostream& out, pair<S, T> const& p) {
out << '(' << p.first << ", " << p.second << ')';
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& v) {
long long l = v.size();
for (long long i = 0; i < l - 1; i++) out << v[i] << ' ';
if (l > 0) out << v[l - 1];
return out;
}
template <typename T>
void trace(const char* name, T&& arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
trace(comma + 1, args...);
}
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const double EPS = 1e-9;
const long long N = 500005;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rand(long long l, long long r) {
uniform_int_distribution<long long> uid(l, r);
return uid(rng);
}
long long n, l, r;
void solve(long long x) {
cin >> n >> l >> r;
long long num = 0;
long long toadd = n - 1;
long long vert = 1;
long long to = 2;
vector<long long> ans;
for (long long i = 0; i < n - 1; i++) {
if (2 * (num + toadd) >= l) {
long long left = 2 * num + 1;
long long i = 0;
to = vert + 1;
while (left <= r and left <= n * (n - 1)) {
if (i % 2 == 0) {
if (left >= l) {
ans.push_back(vert);
}
} else {
if (left >= l) {
ans.push_back(to);
}
to++;
if (to > n) {
vert++;
to = vert + 1;
}
}
left++;
i++;
}
break;
}
num += toadd;
toadd--;
vert++;
}
long long last = (n * (n - 1)) + 1;
if (r == last) {
ans.push_back(1);
}
for (long long i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
cout << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(12);
long long t;
cin >> t;
long long i = 0;
while (i < t) {
solve(i + 1);
i++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int i, j, n, m, k;
long long int l, r;
cin >> n >> l >> r;
bool var1 = 0;
long long int var2 = 0, var = 0;
if (r == (n * (n - 1LL)) + 1LL) {
var1 = 1;
r--;
} else {
long long int o = 0;
while (o < 2) o++;
}
long long int o = 0;
for (i = 1; i <= n; i++) {
var2 += (n - i) * 2LL;
if (o == 1) {
o = 0;
} else if (var2 >= l) {
var2 -= (n - i) * 2LL;
var = i;
break;
} else {
o = 0;
}
}
var2 = l - var2;
long long int p = var2;
long long int var3 = 1;
var2 = (var + var2 / 2 + var2 % 2);
if (l <= r && (p % 2LL == 0)) {
cout << var2 << " ";
l++;
var2++;
} else {
o = 0;
}
o = 0;
while (l <= r && o == 0) {
if (var2 > n) {
var++;
var2 = var + 1;
}
if (o == 1)
o = 0;
else
o = 0;
if ((var3 % 2) == 1)
cout << var << " ";
else {
cout << var2 << " ";
var2++;
}
l++;
var3 = 1 - var3;
}
o = 1;
if (var1) cout << o << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, n, m, k;
long long int t;
cin >> t;
while (t--) {
solve();
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.