text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 7;
int n, k;
string s;
int l[maxn][2], r[maxn], cnt[maxn];
int getroot(int x) { return r[x] == x ? x : r[x] = getroot(r[x]); }
int calc(int x) {
int y = x <= k ? x + k : x - k;
x = getroot(x);
y = getroot(y);
if (x == 0 || y == 0) {
return cnt[x + y];
}
return min(cnt[x], cnt[y]);
}
void fmerge(int x, int y) {
x = getroot(x);
y = getroot(y);
if (y == 0) {
swap(x, y);
}
r[y] = x;
cnt[x] += cnt[y];
}
int main() {
cin >> n >> k;
cin >> s;
for (int i = 1; i <= k; i++) {
int c;
cin >> c;
for (int j = 0; j < c; j++) {
int x;
cin >> x;
if (l[x][0] == 0)
l[x][0] = i;
else
l[x][1] = i;
}
r[i] = i;
r[i + k] = i + k;
cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= calc(x);
if (s[i - 1] == '1') {
r[getroot(x + k)] = 0;
} else {
r[getroot(x)] = 0;
}
ans += calc(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (getroot(x) != getroot(y)) {
ans -= calc(x);
ans -= calc(y);
fmerge(x, y);
fmerge(x + k, y + k);
ans += calc(x);
}
} else {
if (getroot(x + k) != getroot(y)) {
ans -= calc(x);
ans -= calc(y);
fmerge(x + k, y);
fmerge(x, y + k);
ans += calc(x);
}
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
vector<int> g[maxn];
int f[maxn], d[maxn], L[maxn], R[maxn], fix[maxn], gt[maxn], ans = 0;
int n, k;
char str[maxn];
int calc(int x) {
if (fix[x])
return gt[x] ? R[x] : L[x];
else
return min(L[x], R[x]);
}
int find(int x) {
if (f[x] == x) return x;
int t = f[x];
f[x] = find(f[x]);
d[x] ^= d[t];
return f[x];
}
void merge(int u, int v, int dd) {
int fa = find(u), fb = find(v);
if (fa != fb) {
ans -= calc(fa) + calc(fb);
f[fa] = fb;
d[fa] = d[u] ^ d[v] ^ dd;
L[fb] += d[fa] ? R[fa] : L[fa];
R[fb] += d[fa] ? L[fa] : R[fa];
fix[fb] |= fix[fa];
if (fix[fa]) gt[fb] = gt[fa] ^ d[fa];
ans += calc(fb);
}
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", str + 1);
for (int i = 1; i <= k; i++) {
int c, x;
scanf("%d", &c);
for (int j = 1; j <= c; j++) scanf("%d", &x), g[x].push_back(i);
}
for (int i = 1; i <= k; i++) f[i] = i, d[i] = 0, L[i] = 1;
for (int i = 1; i <= n; i++) {
if (str[i] == '0') {
if (g[i].size() == 1) {
int x = g[i][0];
int c = find(x);
ans -= calc(c);
fix[c] = 1;
gt[c] = d[x];
ans += calc(c);
} else if (g[i].size() == 2) {
int x = g[i][0], y = g[i][1];
merge(x, y, 1);
}
} else {
if (g[i].size() == 1) {
int x = g[i][0];
int c = find(x);
ans -= calc(c);
fix[c] = 1;
gt[c] = d[x] ^ 1;
ans += calc(c);
} else if (g[i].size() == 2) {
int x = g[i][0], y = g[i][1];
merge(x, y, 0);
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int maxn = 6e5 + 5;
int fa[maxn], val[maxn], ans;
vector<int> V[maxn];
int n, k;
string s;
void init() {
for (int i = 0; i < maxn; ++i) fa[i] = i;
}
int getfa(int x) { return x == fa[x] ? x : fa[x] = getfa(fa[x]); }
void merge(int x, int y) {
int fx = getfa(x), fy = getfa(y);
if (fx != fy) {
fa[fx] = fy;
val[fy] += val[fx];
}
}
int va(int x) { return min(val[getfa(x)], val[getfa(x + k)]); }
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> s;
for (int i = 1; i <= k; ++i) {
int c;
cin >> c;
for (int j = 1; j <= c; ++j) {
int tmp;
cin >> tmp;
V[tmp].push_back(i);
}
}
for (int i = 1; i <= 2 * k; ++i) fa[i] = i, val[i] = i > k;
fa[2 * k + 1] = 2 * k + 1, val[2 * k + 1] = 0x3f3f3f3f;
for (int i = 1; i <= n; ++i) {
if (V[i].size() == 1) {
int x = V[i][0] + (s[i - 1] == '1') * k;
ans -= va(V[i][0]);
merge(x, k * 2 + 1);
ans += va(V[i][0]);
} else if (V[i].size() == 2) {
int x = V[i][0], y = V[i][1];
if (s[i - 1] == '0') {
if (getfa(x) != getfa(y + k)) {
ans -= va(x) + va(y);
merge(x, y + k);
merge(x + k, y);
ans += va(x);
}
} else {
if (getfa(x) != getfa(y)) {
ans -= va(x) + va(y);
merge(x, y);
merge(x + k, y + k);
ans += va(x);
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
enum class LampConstraint { Distinct, Same };
enum class LampSetState { On, Off, PhantomA, PhantomB };
bool isLampSetStateKnown(LampSetState st) {
return st == LampSetState::On || st == LampSetState::Off;
}
typedef struct Edge {
int nodeId;
LampConstraint cons;
Edge(int nodeId_, LampConstraint cons_) : nodeId(nodeId_), cons(cons_) {}
} Edge;
bool compareEdges(const Edge &a, const Edge &b) {
if (a.nodeId < b.nodeId) return true;
if (a.nodeId > b.nodeId) return true;
return a.cons < b.cons;
}
typedef struct LampSetInfo {
LampSetState state;
int ownerId;
int componentSize;
int onColorSize;
int offColorSize;
explicit LampSetInfo(int id)
: state(LampSetState::PhantomA),
ownerId(id),
componentSize(1),
onColorSize(1),
offColorSize(0){};
} LampSetInfo;
typedef std::set<Edge, decltype(compareEdges) *> Edges;
int componentOnBestSize(std::vector<LampSetInfo> &nodes, int nodeId) {
LampSetInfo &s = nodes[nodeId];
int ownerId = s.ownerId;
if (s.state == LampSetState::On || s.state == LampSetState::Off) {
return nodes[ownerId].onColorSize;
} else {
return std::min(nodes[ownerId].onColorSize, nodes[ownerId].offColorSize);
}
}
LampSetState deducedState(const LampConstraint &cons, LampSetState st) {
switch (cons) {
case LampConstraint::Same:
return st;
case LampConstraint::Distinct:
switch (st) {
case LampSetState::On:
return LampSetState::Off;
case LampSetState::Off:
return LampSetState::On;
case LampSetState::PhantomA:
return LampSetState::PhantomB;
case LampSetState::PhantomB:
return LampSetState::PhantomA;
}
}
}
void propagateLampState(const std::vector<Edges> &graph,
std::vector<LampSetInfo> &nodes, int startNodeId,
LampSetState learnedState) {
std::set<int> visited;
std::stack<std::pair<int, LampSetState>> nodeIds;
nodeIds.push(std::make_pair(startNodeId, learnedState));
int onCount = 0;
while (!nodeIds.empty()) {
std::pair<int, LampSetState> currentNode = nodeIds.top();
nodeIds.pop();
if (visited.find(currentNode.first) != visited.end()) continue;
nodes[currentNode.first].state = currentNode.second;
onCount += ((currentNode.second == LampSetState::On ||
currentNode.second == LampSetState::PhantomA)
? 1
: 0);
visited.insert(currentNode.first);
for (const Edge &e : graph[currentNode.first]) {
if (visited.find(e.nodeId) == visited.end())
nodeIds.push(
std::make_pair(e.nodeId, deducedState(e.cons, currentNode.second)));
}
}
int ownerId = nodes[startNodeId].ownerId;
nodes[ownerId].onColorSize = onCount;
nodes[ownerId].offColorSize = nodes[ownerId].componentSize - onCount;
}
void switchOwner(std::vector<Edges> &graph, std::vector<LampSetInfo> &nodes,
int startNodeId, int newOwner) {
std::set<int> visited;
std::stack<int> nodeIds;
nodeIds.push(startNodeId);
while (!nodeIds.empty()) {
int currentNode = nodeIds.top();
nodeIds.pop();
if (visited.find(currentNode) != visited.end()) continue;
visited.insert(currentNode);
nodes[currentNode].ownerId = newOwner;
for (auto &e : graph[currentNode]) {
if (visited.find(e.nodeId) == visited.end()) nodeIds.push(e.nodeId);
}
}
}
int main() {
int n, k;
long long result = 0;
std::string lamps;
std::vector<LampSetInfo> nodes;
std::cin >> n >> k;
std::cin >> lamps;
std::vector<std::vector<int>> setsForLamp(n);
std::vector<Edges> graph(k, Edges(compareEdges));
for (int i = 0; i < k; i++) {
int c;
nodes.push_back(LampSetInfo(i));
std::cin >> c;
for (int j = 0; j < c; j++) {
int a;
std::cin >> a;
setsForLamp[a - 1].push_back(i);
}
}
for (int i = 0; i < n; i++) {
LampSetState learnedState;
LampConstraint cons;
int startNode;
int a, b, ownerA, ownerB;
switch (setsForLamp[i].size()) {
case 0:
if (lamps[i] != '1')
throw std::runtime_error("Conflicting enforced states of lamps!");
break;
case 1:
startNode = setsForLamp[i][0];
learnedState = (lamps[i] == '1' ? LampSetState::Off : LampSetState::On);
if (!isLampSetStateKnown(nodes[startNode].state)) {
result -= componentOnBestSize(nodes, startNode);
propagateLampState(graph, nodes, startNode, learnedState);
result += componentOnBestSize(nodes, startNode);
} else {
if (learnedState != nodes[startNode].state)
throw std::runtime_error("Conflicting enforced states of lamps!");
}
break;
case 2:
a = setsForLamp[i][0];
b = setsForLamp[i][1];
ownerA = nodes[a].ownerId;
ownerB = nodes[b].ownerId;
cons =
(lamps[i] == '1' ? LampConstraint::Same : LampConstraint::Distinct);
if (nodes[ownerA].componentSize > nodes[ownerB].componentSize) {
std::swap(a, b);
std::swap(ownerA, ownerB);
}
if (ownerA != ownerB) {
result -= componentOnBestSize(nodes, ownerA);
result -= componentOnBestSize(nodes, ownerB);
if (isLampSetStateKnown(nodes[a].state) &&
!isLampSetStateKnown(nodes[b].state)) {
propagateLampState(graph, nodes, b,
deducedState(cons, nodes[a].state));
} else if (isLampSetStateKnown(nodes[b].state) &&
!isLampSetStateKnown(nodes[a].state)) {
propagateLampState(graph, nodes, a,
deducedState(cons, nodes[b].state));
} else if (!isLampSetStateKnown(nodes[b].state) &&
!isLampSetStateKnown(nodes[a].state)) {
propagateLampState(graph, nodes, a,
deducedState(cons, nodes[b].state));
}
nodes[ownerB].onColorSize += nodes[ownerA].onColorSize;
nodes[ownerB].offColorSize += nodes[ownerA].offColorSize;
nodes[ownerB].componentSize += nodes[ownerA].componentSize;
result += componentOnBestSize(nodes, ownerB);
switchOwner(graph, nodes, a, ownerB);
}
graph[a].insert(Edge(b, cons));
graph[b].insert(Edge(a, cons));
break;
default:
throw std::runtime_error("Malformed input data!");
}
std::cout << result << std::endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct perem {
int t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
int n, k, m, c, vas, vvas, cc = 1000000, kl;
string s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
vector<vector<int>> la(n, vector<int>(0));
vector<perem> pr(k);
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
int a = la[i][0];
bool d = s[i] == '1' ? 1 : 0;
for (;; a = pr[a].p) {
d ^= pr[a].q;
if (pr[a].p == -1) break;
}
if (la[i].size() == 1) {
if (!d) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
int b = la[i][1];
for (;; b = pr[b].p) {
d ^= pr[b].q;
if (pr[b].p == -1) break;
}
if (a != b) {
if (!d) {
if (pr[a].l > pr[b].l) swap(a, b);
vas += pr[a].l;
pr[a].q ^= 1;
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
cout << vvas + vas << endl;
vvas += vas;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct DS {
int n;
vector<int> s;
vector<int> count;
DS(int n) : n(n), s(n, -1), count(n, 0) {}
int find(int i) { return s[i] < 0 ? i : (s[i] = find(s[i])); }
int counted(int i) { return count[find(i)]; }
void mark(int i, int x) { count[find(i)] += x; }
int onion(int a, int b) {
a = find(a);
b = find(b);
if (a == b) {
return 0;
}
if (s[a] == s[b]) s[a]--;
if (s[a] <= s[b]) {
s[b] = a;
count[a] += count[b];
} else {
s[a] = b;
count[b] += count[a];
}
return 1;
}
};
int main() {
int n, k;
cin >> n >> k;
vector<int> l(n);
string L;
cin >> L;
for (int i = 0; i < n; i++) {
l[i] = L[i] - '0';
}
vector<vector<int> > s(n);
for (int i = 0; i < k; i++) {
int c;
cin >> c;
while (c--) {
int l;
cin >> l;
l--;
s[l].push_back(i);
}
}
DS ds(2 * k + 1);
for (int i = 0; i < k; i++) ds.mark(i, 1);
int sum = 0;
vector<int> contrib(2 * k + 1, 0);
auto reset = [&](int i) {
sum -= contrib[ds.find(i)];
contrib[ds.find(i)] = 0;
};
auto set = [&](int i, int k) {
contrib[ds.find(i)] = k;
sum += contrib[ds.find(i)];
};
for (int i = 0; i < n; i++) {
if (false) {
cout << i << ":";
for (int p : s[i]) cout << " " << p;
cout << endl;
}
if (s[i].size() == 0) {
} else if (s[i].size() == 1) {
reset(2 * k);
reset(s[i][0] + k);
reset(s[i][0]);
if (l[i] == 1) {
ds.onion(2 * k, s[i][0] + k);
} else {
ds.onion(2 * k, s[i][0]);
}
set(2 * k, ds.counted(2 * k));
} else {
reset(s[i][0]);
reset(s[i][1]);
reset(s[i][0] + k);
reset(s[i][1] + k);
if (l[i] == 1) {
ds.onion(s[i][0], s[i][1]);
ds.onion(s[i][0] + k, s[i][1] + k);
} else {
ds.onion(s[i][0] + k, s[i][1]);
ds.onion(s[i][0], s[i][1] + k);
}
int A = ds.find(s[i][0]);
int B = ds.find(s[i][0] + k);
if (A == ds.find(2 * k)) {
set(A, ds.counted(A));
} else if (B == ds.find(2 * k)) {
set(B, ds.counted(B));
} else if (ds.counted(A) < ds.counted(B)) {
set(A, ds.counted(A));
} else {
set(B, ds.counted(B));
}
}
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int inf = 0x3f3f3f3f;
const int MAXN = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
void file() {}
const int N = 3e5 + 5;
int fat[N * 2], Size[N * 2], n, k;
vector<int> vec[N];
int find(int x) { return fat[x] == x ? x : fat[x] = find(fat[x]); }
int calc(int x) {
int y = (x <= k ? x + k : x - k);
x = find(x);
y = find(y);
if (x == 0 || y == 0) return Size[x + y];
return min(Size[x], Size[y]);
}
void merge(int x, int y) {
x = find(x);
y = find(y);
if (y == 0) swap(x, y);
fat[y] = x;
if (x != 0) Size[x] += Size[y];
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
string str;
cin >> n >> k >> str;
for (int i = 1; i <= k; i++) fat[i] = i, fat[i + k] = i + k, Size[i] = 1;
for (int i = 1; i <= k; i++) {
int tn;
cin >> tn;
for (int j = 0; j < tn; j++) {
int pos;
cin >> pos;
vec[pos].push_back(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) {
int x = vec[i][0];
ans -= calc(x);
if (str[i - 1] == '1')
fat[find(x)] = 0;
else
fat[find(x + k)] = 0;
ans += calc(x);
} else if (vec[i].size() == 2) {
int x = vec[i][0], y = vec[i][1];
if (str[i - 1] == '1') {
if (find(x) != find(y)) {
ans -= calc(x);
ans -= calc(y);
merge(x, y);
merge(x + k, y + k);
ans += calc(x);
}
} else {
if (find(x) != find(y + k)) {
ans -= calc(x);
ans -= calc(y);
merge(x, y + k);
merge(x + k, y);
ans += calc(x);
}
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int lim = 1000 * 1000 + 5;
int nbElem, nbSub;
vector<int> subset[lim];
int side[lim];
int isIn[lim][2];
string ini;
int rep = 0;
int drepr[lim];
int dsz[lim];
int cnt[lim][2];
int dfind(int x) {
if (drepr[x] != x) drepr[x] = dfind(drepr[x]);
return drepr[x];
}
void add(int cc, int s0, int s1) {
cc = dfind(cc);
rep -= min(cnt[cc][0], cnt[cc][1]);
cnt[cc][0] = min(lim, cnt[cc][0] + s0);
cnt[cc][1] = min(lim, cnt[cc][1] + s1);
rep += min(cnt[cc][0], cnt[cc][1]);
}
void dmerge(int a, int b) {
a = dfind(a);
b = dfind(b);
if (a == b) return;
if (dsz[a] < dsz[b]) swap(a, b);
add(a, cnt[b][0], cnt[b][1]);
add(b, -cnt[b][0], -cnt[b][1]);
dsz[a] += dsz[b];
drepr[b] = a;
}
void dfs(int nod) {
cnt[nod][side[nod]] = 1;
for (int elem : subset[nod]) {
if (isIn[elem][1] == -1) continue;
int oth = isIn[elem][0] + isIn[elem][1] - nod;
if (side[oth] == -1) {
side[oth] = side[nod] ^ (ini[elem] == '0');
dfs(oth);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> nbElem >> nbSub;
cin >> ini;
fill(side, side + lim, -1);
iota(drepr, drepr + lim, 0);
fill_n(&isIn[0][0], 2 * lim, -1);
for (int sub = 0; sub < nbSub; ++sub) {
int st;
cin >> st;
subset[sub].resize(st);
for (int pos = 0; pos < st; ++pos) {
int elem;
cin >> elem;
--elem;
subset[sub][pos] = elem;
if (isIn[elem][0] == -1)
isIn[elem][0] = sub;
else
isIn[elem][1] = sub;
}
}
for (int sub = 0; sub < nbSub; ++sub) {
if (side[sub] == -1) {
side[sub] = 0;
dfs(sub);
}
}
for (int elem = 0; elem < nbElem; ++elem) {
int n0 = isIn[elem][0], n1 = isIn[elem][1];
if (n0 != -1 && n1 == -1) {
int destroy = side[n0] ^ (ini[elem] == '0');
if (destroy == 1)
add(n0, 0, lim);
else
add(n0, lim, 0);
} else if (n0 != -1) {
dmerge(n0, n1);
}
cout << rep << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 5;
int pre[N], si[N], num[N / 2], n, m;
bool vis[N];
char s[N];
vector<vector<int> > v(N / 2);
int findd(int x) {
if (pre[x] == x) return x;
pre[x] = findd(pre[x]);
if (vis[x]) vis[pre[x]] = 1;
return pre[x];
}
inline int id(int x) { return x > m ? x - m : x; }
int un(int a, int b) {
int x = findd(a);
int y = findd(b);
if (x == y) return -1;
int aa = id(x);
int bb = id(y);
if (aa < bb) {
pre[y] = x, si[x] += si[y];
if (vis[y]) vis[x] = 1;
return aa;
} else {
pre[x] = y, si[y] += si[x];
if (vis[x]) vis[y] = 1;
return bb;
}
}
int main() {
scanf("%d%d", &n, &m);
scanf("%s", s + 1);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d", &a);
while (a--) {
scanf("%d", &b);
v[b].push_back(i);
}
}
for (int i = 1; i <= m; i++) {
pre[i] = i, si[i] = 1;
pre[i + m] = i + m, si[i + m] = 0;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '0') {
if (v[i].size() == 1) {
int a = findd(v[i][0]);
int b = a > m ? a - m : a + m;
vis[b] = 1;
ans += si[a] - num[id(a)];
num[id(a)] = si[a];
}
if (v[i].size() == 2) {
int a = v[i][0], b = v[i][1];
int sum = num[id(findd(a))] + num[id(findd(b))];
int x = un(a, b + m);
un(b, a + m);
if (x != -1) {
if (vis[x]) {
ans += si[x + m] - sum;
num[x] = si[x + m];
} else if (vis[x + m]) {
ans += si[x] - sum;
num[x] = si[x];
} else {
ans += min(si[x], si[x + m]) - sum;
num[x] = min(si[x], si[x + m]);
}
}
}
} else {
if (v[i].size() == 1) {
int a = findd(v[i][0] + m);
int b = a > m ? a - m : a + m;
vis[b] = 1;
ans += si[a] - num[id(a)];
num[id(a)] = si[a];
}
if (v[i].size() == 2) {
int a = v[i][0], b = v[i][1];
int sum = num[id(findd(a))] + num[id(findd(b))];
int x = un(a, b);
un(b + m, a + m);
if (x != -1) {
if (vis[x]) {
ans += si[x + m] - sum;
num[x] = si[x + m];
} else if (vis[x + m]) {
ans += si[x] - sum;
num[x] = si[x];
} else {
ans += min(si[x], si[x + m]) - sum;
num[x] = min(si[x], si[x + m]);
}
}
}
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int dp[maxn][2], fa[maxn * 2], cnt[maxn * 2], n, k;
char buf[maxn];
int Find(int x) { return x == fa[x] ? x : fa[x] = Find(fa[x]); }
int calc(int x) {
int y;
if (x <= k)
y = x + k;
else
y = x - k;
x = Find(x), y = Find(y);
if (x == 0 || y == 0) return cnt[x + y];
return min(cnt[x], cnt[y]);
}
void Unite(int x, int y) {
x = Find(x), y = Find(y);
if (y == 0) swap(x, y);
fa[y] = x;
if (x) cnt[x] += cnt[y];
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", buf + 1);
for (int i = 1; i <= k; ++i) {
int q, id;
scanf("%d", &q);
while (q--) {
scanf("%d", &id);
if (dp[id][0])
dp[id][1] = i;
else
dp[id][0] = i;
}
fa[i] = i;
fa[i + k] = i + k;
cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (dp[i][1] == 0) {
int x = dp[i][0];
if (x) {
ans -= calc(x);
if (buf[i] == '1')
fa[Find(x + k)] = 0;
else
fa[Find(x)] = 0;
ans += calc(x);
}
} else {
int x = dp[i][0], y = dp[i][1];
if (buf[i] == '1') {
if (Find(x) != Find(y)) {
ans -= calc(x), ans -= calc(y);
Unite(x, y);
Unite(x + k, y + k);
ans += calc(x);
}
} else {
if (Find(x) != Find(y + k)) {
ans -= calc(x), ans -= calc(y);
Unite(x, y + k);
Unite(x + k, y);
ans += calc(x);
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[600005];
int k;
int mx[600005], a[300005], fa[600005];
int find(int x) {
if (fa[x] != x) {
fa[x] = find(fa[x]);
}
return fa[x];
}
void mer(int x, int y) {
int fx = find(x), fy = find(y);
if (fx != fy) {
mx[fx] += mx[fy];
fa[fy] = fx;
}
}
int get(int x) { return min(mx[find(x)], mx[find(x + k)]); }
int main(int argc, char** argv) {
int n;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%1d", &a[i]);
for (int i = 1; i <= 2 * k + 1; i++) {
fa[i] = i;
mx[i] = i > k;
}
mx[2 * k + 1] = 1e8;
for (int i = 1; i <= k; i++) {
int c;
scanf("%d", &c);
while (c--) {
int x;
scanf("%d", &x);
v[x].push_back(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (v[i].size() == 1) {
int f = v[i][0];
if (a[i] == 1) {
ans -= get(f);
mer(f + k, 2 * k + 1);
ans += get(f);
} else {
ans -= get(f);
mer(f, 2 * k + 1);
ans += get(f);
}
}
if (v[i].size() == 2) {
int z = v[i][0], x = v[i][1];
if (a[i] == 1) {
if (find(x) != find(z)) {
ans -= get(x) + get(z);
mer(z + k, x + k);
mer(z, x);
ans += get(z);
}
} else {
if (find(x) != find(z + k)) {
ans -= get(x) + get(z);
mer(z + k, x);
mer(z, x + k);
ans += get(z);
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 10;
const long long inf = 1e9 + 10;
int f[N], vist[N];
char s[N];
long long val[N];
vector<int> vec[N];
int find(int x) {
if (f[x] == x) return x;
f[x] = find(f[x]);
return f[x];
}
void myunion(int x, int y) {
if (x < y) {
f[y] = x;
val[x] += val[y];
} else {
f[x] = y;
val[y] += val[x];
}
}
int main() {
int n, m, i, j, tot, x, y, fx, fy, type, ans = 0;
scanf("%d%d", &n, &m);
scanf("%s", s + 1);
for (i = 1; i <= m; i++) {
scanf("%d", &tot);
for (j = 1; j <= tot; j++) {
scanf("%d", &x);
vec[x].push_back(i);
}
}
for (i = 1; i <= m; i++) {
f[i] = i;
f[i + m] = m + i;
val[i] = 1;
}
for (i = 1; i <= n; i++) {
type = s[i] - '0';
if (vec[i].size() == 1) {
x = vec[i][0];
y = x + m;
fx = find(x);
fy = find(y);
if (vist[fx] || vist[fy]) ans -= min(val[fx], val[fy]);
vist[fx] = vist[fy] = 1;
if (type == 0) {
val[fy] = inf;
ans += val[fx];
} else {
val[fx] = inf;
ans += val[fy];
}
} else if (vec[i].size() == 2) {
x = vec[i][0];
y = vec[i][1];
if (type == 0) {
if (find(x) != find(y + m)) {
if (vist[find(x)]) ans -= min(val[find(x)], val[find(x + m)]);
if (vist[find(y)]) ans -= min(val[find(y)], val[find(y + m)]);
myunion(find(x), find(y + m));
myunion(find(y), find(x + m));
ans += min(val[find(x)], val[find(x + m)]);
}
} else {
if (find(x) != find(y)) {
if (vist[find(x)]) ans -= min(val[find(x)], val[find(x + m)]);
if (vist[find(y)]) ans -= min(val[find(y)], val[find(y + m)]);
myunion(find(x), find(y));
myunion(find(x + m), find(y + m));
ans += min(val[find(x)], val[find(x + m)]);
}
}
vist[find(x)] = vist[find(x + m)] = vist[find(y)] = vist[find(y + m)] = 1;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] ? fa[u] = find(fa[u]) : u; }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += mix(k[i][1]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0], kk + kk + 1);
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1] + kk), uni(k[i][0] + kk, k[i][1]);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0] + kk, kk + kk + 1);
ans += mix(k[i][0]);
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x;
vector<int> vec[300010];
char c[300010];
int fa[300010 << 1], sz[300010 << 1];
int lim[300010 << 1];
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
int main() {
scanf("%d%d%s", &n, &k, c + 1);
for (int i = 1; i <= k; i++) {
scanf("%d", &m);
for (int j = 1; j <= m; j++) {
scanf("%d", &x);
vec[x].push_back(i);
}
}
for (int i = 1; i <= k; i++) {
fa[i * 2 - 1] = i * 2 - 1;
sz[i * 2 - 1] = 1;
fa[i * 2] = i * 2;
sz[i * 2] = 0;
lim[i * 2 - 1] = lim[i * 2] = -1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) {
int x = vec[i][0];
int f1 = find(x * 2 - 1), f0 = find(x * 2);
int s1 = sz[f1], s0 = sz[f0];
if (lim[f1] == -1)
ans -= min(s0, s1);
else
ans -= lim[f1] ? s1 : s0;
lim[f1] = (c[i] == '0');
lim[f0] = lim[f1] ^ 1;
ans += lim[f1] ? s1 : s0;
} else if (vec[i].size() == 2) {
int x = vec[i][0], y = vec[i][1];
int fx1 = find(x * 2 - 1), fx0 = find(x * 2);
int sx1 = sz[fx1], sx0 = sz[fx0];
int fy1 = find(y * 2 - 1), fy0 = find(y * 2);
int sy1 = sz[fy1], sy0 = sz[fy0];
if (fx0 != fy0 && fx0 != fy1) {
if (lim[fx1] == -1)
ans -= min(sx0, sx1);
else
ans -= lim[fx1] ? sx1 : sx0;
if (lim[fy1] == -1)
ans -= min(sy0, sy1);
else
ans -= lim[fy1] ? sy1 : sy0;
if (c[i] == '1') {
fa[fx1] = fy1;
fa[fx0] = fy0;
sz[fy1] += sz[fx1];
sz[fy0] += sz[fx0];
if (lim[fx1] != -1) {
lim[fy1] = lim[fx1];
lim[fy0] = lim[fy1] ^ 1;
}
} else {
fa[fx1] = fy0;
fa[fx0] = fy1;
sz[fy0] += sz[fx1];
sz[fy1] += sz[fx0];
if (lim[fx1] != -1) {
lim[fy0] = lim[fx1];
lim[fy1] = lim[fy0] ^ 1;
}
}
int f1 = find(x * 2 - 1), f0 = find(x * 2);
int s1 = sz[f1], s0 = sz[f0];
if (lim[f1] == -1)
ans += min(s0, s1);
else
ans += lim[f1] ? s1 : s0;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int val[300000 + 100], sum[300000 + 100][2], head[300000 + 100];
int f[300000 + 100];
vector<int> V[300000 + 100];
int n, k;
int ans;
int findd(int x) {
if (f[x] == x) return x;
int F = f[x];
f[x] = findd(f[x]);
val[x] = val[x] ^ val[F];
return f[x];
}
char s[300000 + 100];
void init() {
for (int i = 0; i <= max(n, k); i++) f[i] = i;
for (int i = 1; i <= max(n, k); i++) {
sum[i][0] = 0;
sum[i][1] = 1;
}
memset(head, -1, sizeof(head));
}
int get(int x) {
if (head[x] == -1) return min(sum[x][0], sum[x][1]);
return sum[x][head[x]];
}
void build(int x, int y, int v) {
int X = findd(x);
int Y = findd(y);
if (X != Y) {
ans -= get(X);
ans -= get(Y);
sum[Y][0] += sum[X][v ^ val[x] ^ val[y]];
sum[Y][1] += sum[X][1 ^ v ^ val[x] ^ val[y]];
if (head[X] != -1 && head[Y] == -1) {
head[Y] = v ^ val[x] ^ val[y] ^ head[X];
}
val[X] = val[x] ^ val[y] ^ v;
f[X] = Y;
ans += get(Y);
}
}
void work(int x, int v) {
int X = findd(x);
ans -= get(X);
if (head[X] == -1) head[X] = v ^ val[x];
ans += get(X);
}
int main() {
int T;
cin >> n >> k;
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
scanf("%d", &T);
int cpy = T;
int x;
while (T--) {
scanf("%d", &x);
V[x].push_back(i);
}
}
init();
for (int i = 1; i <= n; i++) {
if (V[i].size() == 1) {
work(V[i][0], 1 ^ (s[i] - '0'));
} else if (V[i].size() == 2) {
build(V[i][0], V[i][1], 1 ^ (s[i] - '0'));
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
string s;
vector<int> a[300001];
int p[1000001];
long long f[1000001];
const int Max = 6e5;
const int T = 3e5;
int root(int u) {
if (u == p[u]) return u;
return p[u] = root(p[u]);
}
void Merge(int u, int v) {
u = root(u);
v = root(v);
int ru = root(u);
int rv = root(v);
p[rv] = ru;
f[ru] += f[rv];
}
int main() {
cin >> n >> k >> s;
s = '.' + s;
for (int i = 1; i <= Max; i++) {
p[i] = i;
f[i] = -1;
}
for (int i = 1; i <= k; i++) {
int len;
cin >> len;
while (len--) {
int x;
cin >> x;
a[x].push_back(i);
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '0') {
if (a[i].size() == 1) {
int u = a[i][0];
if (f[root(u + T)] == -1) {
f[root(u + T)] = 1;
res++;
}
if (f[root(u)] != -1) {
res -= min(f[root(u)], f[root(u + T)]);
f[root(u)] = 1e9;
res += min(f[root(u)], f[root(u + T)]);
}
f[root(u)] = 1e9;
} else if (a[i].size() == 2) {
int u = a[i][0];
int v = a[i][1];
if (f[root(u)] == -1) f[root(u)] = 0;
if (f[root(u + T)] == -1) f[root(u + T)] = 1;
if (f[root(v)] == -1) f[root(v)] = 0;
if (f[root(v + T)] == -1) f[root(v + T)] = 1;
if (root(u) != root(v + T)) {
res -= min(f[root(u)], f[root(u + T)]);
res -= min(f[root(v)], f[root(v + T)]);
Merge(u, v + T);
Merge(u + T, v);
res += min(f[root(u)], f[root(u + T)]);
}
}
} else {
if (a[i].size() == 1) {
int u = a[i][0];
if (f[root(u + T)] != -1) {
res -= min(f[root(u)], f[root(u + T)]);
f[root(u + T)] = 1e9;
res += min(f[root(u)], f[root(u + T)]);
}
if (f[root(u)] == -1) f[root(u)] = 0;
f[root(u + T)] = 1e9;
} else if (a[i].size() == 2) {
int u = a[i][0];
int v = a[i][1];
if (f[root(u)] == -1) f[root(u)] = 0;
if (f[root(u + T)] == -1) f[root(u + T)] = 1;
if (f[root(v)] == -1) f[root(v)] = 0;
if (f[root(v + T)] == -1) f[root(v + T)] = 1;
if (root(u) != root(v)) {
res -= min(f[root(u)], f[root(u + T)]);
res -= min(f[root(v)], f[root(v + T)]);
Merge(u, v);
Merge(u + T, v + T);
res += min(f[root(u)], f[root(u + T)]);
}
}
}
cout << res << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 6E5 + 10;
int n, k, l[N][2];
int fa[N], sc[N];
string s;
int find(int x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
int cal(int x) {
int y = x <= k ? x + k : x - k;
int xx = find(x), yy = find(y);
if (xx == 0 || yy == 0) return sc[xx + yy];
return min(sc[xx], sc[yy]);
}
void merge(int x, int y) {
int xx = find(x), yy = find(y);
if (xx == 0)
fa[yy] = xx, sc[xx] += sc[yy];
else
fa[xx] = yy, sc[yy] += sc[xx];
}
int main() {
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 1; i <= k; i++) fa[i] = i, fa[i + k] = i + k, sc[i + k] = 1;
for (int i = 1, c; i <= k; i++) {
scanf("%d", &c);
for (int j = 0, v; j < c; j++) {
scanf("%d", &v);
if (l[v][0])
l[v][1] = i;
else
l[v][0] = i;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= cal(x);
if (s[i - 1] == '1')
fa[find(x + k)] = 0;
else
fa[find(x)] = 0;
ans += cal(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (find(x) != find(y)) {
ans -= cal(x);
ans -= cal(y);
merge(x, y);
merge(x + k, y + k);
ans += cal(x);
}
} else {
if (find(x) != find(y + k)) {
ans -= cal(x);
ans -= cal(y);
merge(x, y + k);
merge(x + k, y);
ans += cal(x);
}
}
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 10;
const int apsz = 26;
const int INF = 10000007;
const unsigned long long mod = 97;
const int maxm = 10000 + 10;
struct rev {
int c0, c1, tag;
void maintain() {
c0 = min(c0, INF);
c1 = min(c1, INF);
}
};
rev info[maxn];
int dsu[maxn];
pair<int, int> fd(int u) {
if (dsu[u] < 0) return {u, 0};
pair<int, int> tmp = fd(dsu[u]);
info[u].tag ^= tmp.second;
dsu[u] = tmp.first;
return (pair<int, int>){tmp.first, info[u].tag};
}
int st[maxn];
char s[maxn];
int n, k;
vector<int> edge[maxn];
int main(void) {
scanf("%d", &(n)), scanf("%d", &(k));
scanf("%s", s + 1);
for (int i = (1); i <= (n); ++i) st[i] = s[i] - '0';
for (int i = (1); i <= (k); ++i) {
info[i] = (rev){0, 1, 0};
dsu[i] = -1;
int sz;
scanf("%d", &(sz));
for (; sz--;) {
int x;
scanf("%d", &(x));
edge[x].push_back(i);
}
}
long long ans = 0;
for (int i = (1); i <= (n); ++i) {
int co = st[i];
if (edge[i].size() == 1) {
pair<int, int> t = fd(edge[i][0]);
int u = t.first;
ans -= min(info[u].c0, info[u].c1);
if (co == 1) {
if (t.second == 0)
info[u].c1 = INF;
else
info[u].c0 = INF;
} else if (co == 0) {
if (t.second == 0)
info[u].c0 = INF;
else
info[u].c1 = INF;
}
ans += min(info[u].c0, info[u].c1);
} else if (edge[i].size() == 2) {
pair<int, int> x, y;
x = fd(edge[i][0]);
y = fd(edge[i][1]);
if (x.first != y.first) {
if (dsu[x.first] > dsu[y.first]) swap(x, y);
ans -= min(info[x.first].c0, info[x.first].c1);
ans -= min(info[y.first].c0, info[y.first].c1);
if (co == 1) {
if (x.second != y.second) {
info[y.first].tag ^= 1;
swap(info[y.first].c0, info[y.first].c1);
}
} else {
if (x.second == y.second) {
info[y.first].tag ^= 1;
swap(info[y.first].c0, info[y.first].c1);
}
}
info[x.first].c0 += info[y.first].c0;
info[x.first].c1 += info[y.first].c1;
info[x.first].maintain();
ans += min(info[x.first].c0, info[x.first].c1);
dsu[x.first] += dsu[y.first];
dsu[y.first] = x.first;
}
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] == u ? fa[u] : fa[u] = find(fa[u]); }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1, fa[i] = i, fa[i + kk] = i + kk;
fa[kk + kk + 1] = kk + kk + 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += mix(k[i][1]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0], kk + kk + 1);
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1] + kk), uni(k[i][0] + kk, k[i][1]);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0] + kk, kk + kk + 1);
ans += mix(k[i][0]);
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] == u ? fa[u] : fa[u] = find(fa[u]); }
void uni(int a, int b) {
if (a == b) return;
val[b] += val[a];
fa[a] = b;
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1, fa[i] = i, fa[i + kk] = i + kk;
fa[kk + kk + 1] = kk + kk + 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0]), find(k[i][1])),
uni(find(k[i][0] + kk), find(k[i][1] + kk));
ans += min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
} else {
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0]), find(kk + kk + 1));
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0]), find(k[i][1] + kk)),
uni(find(k[i][1]), find(k[i][0] + kk));
ans += min(val[find(k[i][1] + kk)], val[find(k[i][0] + kk)]);
} else {
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0] + kk), find(kk + kk + 1));
ans += val[find(k[i][0])];
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 810000;
int fa[MAXN], val[MAXN], vec[MAXN][3];
int n, k, ans;
char str[MAXN];
int getfa(int x) {
if (fa[x] == x) return x;
return fa[x] = getfa(fa[x]);
}
void merge(int x, int y) {
int p = getfa(x), q = getfa(y);
if (p == q) return;
fa[p] = q;
val[q] += val[p];
}
int getval(int x) { return min(val[getfa(x)], val[getfa(x + k)]); }
int main() {
scanf("%d%d%s", &n, &k, str + 1);
int tc;
for (int i = 1; i <= k; i++) {
scanf("%d", &tc);
int tx;
for (int j = 1; j <= tc; j++) {
scanf("%d", &tx);
vec[tx][++vec[tx][0]] = i;
}
}
for (int i = 1; i <= k; i++) fa[i] = i, val[i] = 0;
for (int i = k + 1; i <= 2 * k; i++) fa[i] = i, val[i] = 1;
fa[k << 1 | 1] = k << 1 | 1;
val[k << 1 | 1] = 1000000;
for (int i = 1; i <= n; i++) {
if (vec[i][0] == 2) {
if (str[i] == '0') {
if (getfa(vec[i][1]) != getfa(vec[i][2] + k)) {
ans -= getval(vec[i][1]) + getval(vec[i][2]);
merge(vec[i][1], vec[i][2] + k);
merge(vec[i][1] + k, vec[i][2]);
ans += getval(vec[i][1]);
}
} else {
if (getfa(vec[i][1]) != getfa(vec[i][2])) {
ans -= getval(vec[i][1]) + getval(vec[i][2]);
merge(vec[i][1] + k, vec[i][2] + k);
merge(vec[i][1], vec[i][2]);
ans += getval(vec[i][1]);
}
}
} else if (vec[i][0] == 1) {
if (str[i] == '0') {
ans -= getval(vec[i][1]);
merge(vec[i][1], k << 1 | 1);
ans += getval(vec[i][1]);
} else {
ans -= getval(vec[i][1]);
merge(vec[i][1] + k, k << 1 | 1);
ans += getval(vec[i][1]);
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 69;
int n, k;
string initial;
int dsu[N];
int sz[N];
int szsame[N];
int parity[N];
int restrict[N];
vector<int> belong[N];
int curr = 0;
int getVal(int u) {
if (restrict[u] == 0) return szsame[u];
if (restrict[u] == 1) return (sz[u] - szsame[u]);
return min(szsame[u], sz[u] - szsame[u]);
}
pair<int, int> find(int u) {
if (dsu[u] != u) {
pair<int, int> res = find(dsu[u]);
dsu[u] = res.first;
if (parity[u])
parity[u] = res.second;
else
parity[u] = res.second ^ 1;
return make_pair(dsu[u], parity[u]);
}
return make_pair(u, 1);
}
int funion(int u, int v, bool same) {
pair<int, int> r1 = find(u);
pair<int, int> r2 = find(v);
if (r1.first == r2.first) return 0;
if (sz[r1.first] < sz[r2.first]) swap(r1, r2);
int init = getVal(r1.first) + getVal(r2.first);
dsu[r2.first] = r1.first;
sz[r1.first] += sz[r2.first];
bool rsame = true;
if (same && r1.second != r2.second) rsame = false;
if (!same && r1.second == r2.second) rsame = false;
if (!rsame) parity[r2.first] = 0;
if (restrict[r2.first] < 2) {
if (rsame)
restrict[r1.first] = restrict[r2.first];
else
restrict[r1.first] = restrict[r2.first] ^ 1;
}
if (rsame)
szsame[r1.first] += szsame[r2.first];
else
szsame[r1.first] += sz[r2.first] - szsame[r2.first];
return getVal(r1.first) - init;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
cin >> initial;
for (int i = 0; i < k; i++) {
int t;
cin >> t;
for (int j = 0; j < t; j++) {
int l;
cin >> l;
l--;
belong[l].push_back(i);
}
dsu[i] = i;
sz[i] = 1;
szsame[i] = 1;
parity[i] = 1;
restrict[i] = 2;
}
for (int i = 0; i < n; i++) {
if (belong[i].size() == 1) {
int u = belong[i][0];
pair<int, int> res = find(u);
int init = getVal(res.first);
if (initial[i] == '0') {
if (res.second)
restrict[res.first] = 0;
else
restrict[res.first] = 1;
} else {
if (res.second)
restrict[res.first] = 1;
else
restrict[res.first] = 0;
}
curr += getVal(res.first) - init;
} else if (belong[i].size() == 2) {
bool same = (initial[i] == '1');
int u = belong[i][0];
int v = belong[i][1];
curr += funion(u, v, same);
}
cout << curr << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long read1() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 3e5 + 10;
int n, k;
vector<int> q[N];
int f[N], val[N], sz[N][2], vis[N], ans;
int Find(int x) {
if (x == f[x]) return x;
Find(f[x]);
val[x] ^= val[f[x]];
f[x] = f[f[x]];
return f[x];
}
int getval(int x) {
if (vis[x] == -1)
return min(sz[x][0], sz[x][1]);
else
return sz[x][vis[x]];
}
void merge(int u, int v, int c) {
Find(u);
Find(v);
if (f[u] != f[v]) {
ans -= getval(f[u]);
ans -= getval(f[v]);
c ^= val[u] ^ val[v];
u = f[u];
v = f[v];
sz[u][0] += sz[v][c];
sz[u][1] += sz[v][1 - c];
if (vis[v] != -1 && vis[u] == -1) vis[u] = vis[v] ^ c;
f[v] = u;
val[v] = c;
ans += getval(u);
}
}
void sure(int u, int c) {
Find(u);
c ^= val[u];
u = f[u];
ans -= getval(u);
if (vis[u] == -1) vis[u] = c;
ans += getval(u);
}
char ch[N];
int main() {
n = read();
k = read();
scanf("%s", ch + 1);
for (int i = 1; i <= k; i++) {
int num = read();
while (num--) {
int x = read();
q[x].push_back(i);
}
}
for (int i = 1; i <= k; i++)
f[i] = i, sz[i][1] = 1, sz[i][0] = 0, vis[i] = -1;
for (int i = 1; i <= n; i++) {
if (q[i].size() == 2)
merge(q[i][0], q[i][1], 1 - (ch[i] - '0'));
else if (q[i].size() != 0)
sure(q[i][0], 1 - (ch[i] - '0'));
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long n, k, pa[600010], ct[600010], siz[600010], ans = 0;
vector<long long> g[300010];
string s;
long long find(long long x) {
if (x == pa[x]) return x;
pa[x] = find(pa[x]);
return pa[x];
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
cin >> s;
for (long long i = 0; i < k; i++) {
long long t;
cin >> t;
for (long long j = 0; j < t; j++) {
long long x;
cin >> x;
--x;
g[x].push_back(i);
}
}
for (long long i = 0; i < k; i++) {
ct[2 * i + 1] = 1;
ct[2 * i] = 0;
pa[2 * i] = 2 * i;
pa[2 * i + 1] = 2 * i + 1;
siz[2 * i + 1] = 1;
siz[2 * i] = 1;
}
for (long long i = 0; i < n; i++) {
long long a, b;
;
if (((long long)g[i].size()) == 2) {
a = g[i][0];
b = g[i][1];
;
;
long long x1 = find(2 * a), y1 = find(b * 2), x2 = find(2 * a + 1),
y2 = find(2 * b + 1);
if (s[i] == '0') swap(x1, x2);
;
;
if (x1 == y1) {
cout << ans << '\n';
continue;
}
ans -= (min(ct[x1], ct[x2]) + min(ct[y1], ct[y2]));
;
if (siz[x1] > siz[y1]) swap(x1, y1), swap(x2, y2);
siz[y1] += siz[x1];
pa[x1] = y1;
ct[y1] += ct[x1];
ct[x1] = 0;
siz[y2] += siz[x2];
pa[x2] = y2;
ct[y2] += ct[x2];
ct[x2] = 0;
ans += min(ct[y1], ct[y2]);
} else {
if (((long long)g[i].size()) == 0) {
cout << ans << '\n';
continue;
}
long long a = g[i][0], x, delx;
if (s[i] == '1')
x = find(2 * a), delx = find(2 * a + 1);
else
x = find(2 * a + 1), delx = find(2 * a);
ans -= min(ct[x], ct[delx]);
;
ct[delx] = 1e10;
ans += ct[x];
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)3e5 + 10;
int par[maxn << 1], num[maxn << 1];
inline void makeSet(int size) {
for (int i = 1; i <= size; i++) {
par[i] = i;
}
}
inline int find(int x) {
int k, j, r;
r = x;
while (r != par[r]) {
r = par[r];
}
k = x;
while (k != r) {
j = par[k];
par[k] = r;
k = j;
}
return r;
}
inline void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
par[x] = y;
num[y] += num[x];
}
inline int calc(int x, int k) { return min(num[find(x)], num[find(x + k)]); }
int belong[maxn][2];
char s[maxn];
int main() {
int n, k, c, tmp;
scanf("%d%d%s", &n, &k, s + 1);
for (int i = 1; i <= k; ++i) {
scanf("%d", &c);
for (int j = 0; j < c; ++j) {
scanf("%d", &tmp);
if (belong[tmp][0]) {
belong[tmp][1] = i;
} else {
belong[tmp][0] = i;
}
}
num[i] = 1;
}
makeSet(k << 1 | 1);
num[k << 1 | 1] = 0x3f3f3f3f;
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (belong[i][1]) {
if (s[i] == '0' && find(belong[i][0]) != find(belong[i][1] + k)) {
ans -= calc(belong[i][0], k) + calc(belong[i][1], k);
unite(belong[i][0], belong[i][1] + k);
unite(belong[i][1], belong[i][0] + k);
ans += calc(belong[i][0], k);
} else if (s[i] == '1' && find(belong[i][0]) != find(belong[i][1])) {
ans -= calc(belong[i][0], k) + calc(belong[i][1], k);
unite(belong[i][0], belong[i][1]);
unite(belong[i][0] + k, belong[i][1] + k);
ans += calc(belong[i][0], k);
}
} else if (belong[i][0]) {
ans -= calc(belong[i][0], k);
if (s[i] == '0') {
unite(belong[i][0] + k, k << 1 | 1);
} else {
unite(belong[i][0], k << 1 | 1);
}
ans += calc(belong[i][0], k);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, inf = 0x3f3f3f3f;
int n, K, m, x, pos[N][2], ans, fa[N], val[N];
char s[N];
int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
void add(int x, int y) {
int fx = getfa(x), fy = getfa(y);
if (fx != fy) fa[fx] = fy, val[fy] += val[fx];
}
int calc(int x) { return min(val[getfa(x)], val[getfa(x + K)]); }
int main() {
cin >> n >> K;
scanf("%s", s + 1);
for (int i = 1; i <= K; i++) {
scanf("%d", &m);
for (int j = 1; j <= m; j++) {
scanf("%d", &x);
if (pos[x][0])
pos[x][1] = i;
else
pos[x][0] = i;
}
}
for (int i = 0; i <= 2 * K + 1; i++) {
fa[i] = i;
if (i > K) val[i] = 1;
}
val[2 * K + 1] = inf;
for (int i = 1; i <= n; i++) {
if (!pos[i][0]) {
printf("%d\n", ans);
continue;
}
if (!pos[i][1]) {
ans -= calc(pos[i][0]);
if (s[i] == '1')
add(pos[i][0] + K, 2 * K + 1);
else
add(pos[i][0], 2 * K + 1);
ans += calc(pos[i][0]);
} else {
int x = pos[i][0], y = pos[i][1];
if (getfa(x) != getfa(y) && getfa(x) != getfa(y + K)) {
ans -= calc(x) + calc(y);
if (s[i] == '1')
add(x, y), add(x + K, y + K);
else
add(x, y + K), add(x + K, y);
ans += calc(x);
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct perem {
long long t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
long long n, k, m, c, vas, cc = 1000000;
vector<long long> vv;
string s;
vector<vector<long long>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<long long>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() == 2) {
long long a = la[i][0], b = la[i][1];
bool b1 = 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
bool b2 = 0;
while (b != -1) {
b2 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
b1 ^= b2;
long long kl = 0;
if ((b1 and s[i] == '1') or (!b1 and s[i] == '0')) {
if (pr[a].l < pr[b].l) {
vas += pr[a].l;
pr[a].q ^= 1;
} else {
vas += pr[b].l;
pr[b].q ^= 1;
}
kl = abs(pr[a].l - pr[b].l);
} else {
kl = min(pr[a].l + pr[b].l, cc);
}
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
} else if (la[i].size() == 1) {
bool b = 0;
int a = la[i][0];
while (a != -1) {
b ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if ((b and s[i] == '1') or (!b and s[i] == '0')) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (long long i : vv) cout << i << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0) {
putchar('-'), write(-x);
} else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const long long N = 3e5 + 5;
long long n, k, SsEeTt[N][3], f[N << 1], sz[N << 1], s[N], ans, oo;
inline long long min(const long long &x, const long long &y) {
return x < y ? x : y;
}
inline long long getf(const long long &x) {
return f[x] == x ? x : f[x] = getf(f[x]);
}
signed main() {
read(n);
oo = read(k);
for (long long i = 1; i <= n; i++) scanf("%1d", &s[i]);
for (long long i = 1, n, x; i <= k; i++) {
read(n);
while (n--) {
read(x);
if (!SsEeTt[x][1])
SsEeTt[x][1] = i;
else
SsEeTt[x][2] = i;
}
}
for (long long i = 1; i <= k; i++) {
f[i * 2 - 1] = i * 2 - 1;
f[i << 1] = i << 1;
sz[i << 1] = 1;
}
for (long long i = 1, fx, fy, gx, gy; i <= n; i++) {
if (SsEeTt[i][2]) {
if (!s[i]) {
fx = getf(SsEeTt[i][1] * 2 - 1), fy = getf(SsEeTt[i][2] << 1);
if (fx == fy) {
write(ans);
puts("");
continue;
}
gx = getf(SsEeTt[i][1] << 1), gy = getf(SsEeTt[i][2] * 2 - 1);
} else {
fx = getf(SsEeTt[i][1] * 2 - 1), fy = getf(SsEeTt[i][2] * 2 - 1);
if (fx == fy) {
write(ans);
puts("");
continue;
}
gx = getf(SsEeTt[i][1] << 1), gy = getf(SsEeTt[i][2] << 1);
}
ans -= min(sz[fx], sz[gx]) + min(sz[fy], sz[gy]);
f[fx] = fy;
f[gx] = gy;
sz[fy] += sz[fx];
sz[gy] += sz[gx];
ans += min(sz[fy], sz[gy]);
} else if (SsEeTt[i][1]) {
long long fx = getf(SsEeTt[i][1] * 2 - 1), fy = getf(SsEeTt[i][1] * 2);
ans -= min(sz[fx], sz[fy]);
if (!s[i])
sz[fx] += oo;
else
sz[fy] += oo;
ans += min(sz[fx], sz[fy]);
}
write(ans);
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] ? fa[u] = find(fa[u]) : u; }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0], kk + kk + 1);
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1] + kk), uni(k[i][0] + kk, k[i][1]);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0] + kk, kk + kk + 1);
ans += mix(k[i][0]);
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300000 + 10;
char s[N];
int par[N], diff[N];
pair<int, int> find(int x) {
if (par[x] == x) return {x, 0};
auto r = find(par[x]);
par[x] = r.first, diff[x] ^= r.second;
return {par[x], diff[x]};
}
int f[N][2], col[N], ans;
int get(int x) {
if (col[x] == -1) return min(f[x][0], f[x][1]);
return f[x][col[x]];
}
vector<int> p[N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
for (int j = 1; j <= x; j++) {
int y;
scanf("%d", &y);
p[y].push_back(i);
}
}
for (int i = 1; i <= k; i++)
par[i] = i, diff[i] = 0, f[i][0] = 0, f[i][1] = 1, col[i] = -1;
for (int i = 1; i <= n; i++) {
if ((int)p[i].size() == 0)
;
else if ((int)p[i].size() == 1) {
int x = p[i][0], y = find(x).first;
ans -= get(y);
col[y] = diff[x] ^ (s[i] == '0');
ans += get(y);
} else {
int x = find(p[i][0]).first, y = find(p[i][1]).first;
if (x != y) {
ans -= get(x), ans -= get(y);
par[x] = y;
diff[x] = (s[i] == '0') ^ diff[p[i][0]] ^ diff[p[i][1]];
f[y][0] += f[x][0 ^ diff[x]], f[y][1] += f[x][1 ^ diff[x]];
if (col[x] != -1) col[y] = col[x] ^ diff[x];
ans += get(y);
}
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int test = 0;
const int MAXN = 300009;
const long long MOD = 119 << 23 | 1;
class {
public:
vector<int> V[MAXN];
int fa[MAXN * 2], cnt[MAXN * 2];
int n, m;
int curset[MAXN * 2], ans;
int findfa(int x) {
if (fa[x] == x) return x;
return fa[x] = findfa(fa[x]);
}
void merge(int x, int y) {
x = findfa(x);
y = findfa(y);
if (x == y) return;
if (x > y) swap(x, y);
fa[y] = x;
cnt[x] += cnt[y];
}
void solve() {
cin >> n >> m;
string s;
cin >> s;
for (int i = 1; i <= m; ++i) {
int c;
cin >> c;
for (int j = 0; j < c; ++j) {
int v;
cin >> v;
V[v].push_back(i);
}
fa[i] = i;
fa[i + m] = i + m;
cnt[i + m] = 1;
}
ans = 0;
for (int i = 1; i <= n; ++i) {
bool on = s[i - 1] == '1';
if (V[i].size() == 1) {
int p = V[i][0];
if (on) {
del(p);
del(p + m);
merge(p + m, 0);
add(p);
} else {
del(p);
del(p + m);
merge(p, 0);
add(p);
}
} else if (V[i].size() == 2) {
int p0 = V[i][0], p1 = V[i][1];
if (on) {
del(p0);
del(p1);
del(p1 + m);
del(p0 + m);
merge(p0, p1);
merge(p0 + m, p1 + m);
add(p0);
} else {
del(p0);
del(p1);
del(p1 + m);
del(p0 + m);
merge(p0, p1 + m);
merge(p0 + m, p1);
add(p0);
}
}
cout << ans << '\n';
}
}
void add(int x) {
int y = x + m;
x = findfa(x);
y = findfa(y);
if (x == 0)
curset[y] = 1, ans += cnt[y];
else if (y == 0)
curset[x] = 1, ans += cnt[x];
else if (cnt[x] > cnt[y])
curset[y] = 1, ans += cnt[y];
else
curset[x] = 1, ans += cnt[x];
}
void del(int x) {
x = findfa(x);
if (curset[x]) {
ans -= cnt[x];
curset[x] = 0;
}
}
} NSPACE;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
NSPACE.solve();
}
|
#include <bits/stdc++.h>
using namespace std;
struct perem {
int t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
int n, k, m, c, vas, cc = 1000000, kl;
vector<int> vv;
string s;
vector<vector<int>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<int>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
int a = la[i][0];
bool b1 = s[i] == '1' ? 1 : 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if (la[i].size() == 1) {
if (!b1) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
int b = la[i][1];
while (b != -1) {
b1 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
if (!b1) {
if (pr[a].l > pr[b].l) swap(a, b);
vas += pr[a].l;
pr[a].q ^= 1;
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (int i : vv) cout << i << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const int INF = 1e9 + 7;
struct node {
int l, r;
node(int _l = 0, int _r = 0) : l(_l), r(_r){};
void operator+=(node x) {
l = min(l + x.l, INF);
r = min(r + x.r, INF);
}
int get() { return min(l, r); }
} val[N];
int root[N], rev[N];
pair<int, int> getRoot(int u) {
if (u == root[u]) {
return make_pair(u, 0);
} else {
pair<int, int> tmp = getRoot(root[u]);
root[u] = tmp.first;
rev[u] ^= tmp.second;
return make_pair(root[u], rev[u]);
}
}
int n, k;
vector<int> adj[N];
string s;
int main() {
cin >> n >> k;
cin >> s;
for (int i = 1; i <= k; i++) {
val[i] = node(1, 0);
root[i] = i;
rev[i] = 0;
int c;
cin >> c;
while (c--) {
int x;
cin >> x;
adj[x].push_back(i);
}
}
int curAns = 0;
for (int i = 1; i <= n; i++) {
int t = (s[i - 1] - '0') ^ 1;
if (adj[i].size() == 1) {
pair<int, int> u = getRoot(adj[i][0]);
curAns -= val[u.first].get();
val[u.first] += node((u.second == t) * INF, (u.second != t) * INF);
curAns += val[u.first].get();
}
if (adj[i].size() == 2) {
pair<int, int> u = getRoot(adj[i][0]);
pair<int, int> v = getRoot(adj[i][1]);
if (u.first != v.first) {
curAns -= val[u.first].get();
curAns -= val[v.first].get();
if (u.first > v.first) swap(u, v);
if (u.second ^ v.second ^ t) {
rev[v.first] = 1;
swap(val[v.first].l, val[v.first].r);
}
root[v.first] = u.first;
val[u.first] += val[v.first];
curAns += val[u.first].get();
}
}
cout << curAns << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] ? fa[u] = find(fa[u]) : u; }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0], kk + kk + 1);
ans += mix(k[i][0]);
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1] + kk), uni(k[i][0] + kk, k[i][1]);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0] + kk, kk + kk + 1);
ans += mix(k[i][0]);
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
template <class V>
int get_p(V& p, int j) {
if (p[j] == j) return j;
if (p[j] < 0) return p[j] = -get_p(p, -p[j]);
return p[j] = get_p(p, p[j]);
}
int get_min(bool a_j, int S_j, bool coa_j, int coS_j) {
if (!coa_j) return S_j;
if (!a_j) return coS_j;
return std::min(S_j, coS_j);
}
void proc() {
int n, k;
std::cin >> n >> k;
std::vector<bool> x(n);
for (int i = 0; i < n; i++) {
char c;
std::cin >> c;
x[i] = c % 2;
}
std::vector<std::vector<int> > J(n);
std::vector<int> p(k + 1);
for (int j = 1; j <= k; j++) {
p[j] = j;
int c;
std::cin >> c;
while (c--) {
int i;
std::cin >> i;
J[i - 1].push_back(j);
}
}
std::vector<int> S(k + 1, 1);
std::vector<int> coS(k + 1, 0);
std::vector<bool> a(k + 1, true);
std::vector<bool> coa(k + 1, true);
int R = 0;
for (int i = 0; i < n; i++) {
if (J[i].size() == 0) {
std::cout << R << std::endl;
continue;
}
int j = J[i][0];
int p_j = get_p(p, j);
int abs_p_j = std::abs(p_j);
bool a_j = a[abs_p_j];
bool coa_j = coa[abs_p_j];
int S_j = S[abs_p_j];
int coS_j = coS[abs_p_j];
if (J[i].size() == 1) {
a[abs_p_j] = a_j & (x[i] ^ (p_j > 0));
coa[abs_p_j] = coa_j & (x[i] ^ (p_j < 0));
int m_0 = get_min(a_j, S_j, coa_j, coS_j);
int m_1 = get_min(a[abs_p_j], S_j, coa[abs_p_j], coS_j);
R += m_1 - m_0;
std::cout << R << std::endl;
continue;
}
int l = J[i][1];
int p_l = get_p(p, l);
int abs_p_l = std::abs(p_l);
bool a_l = a[abs_p_l];
bool coa_l = coa[abs_p_l];
int S_l = S[abs_p_l];
int coS_l = coS[abs_p_l];
if (abs_p_j < abs_p_l) {
std::swap(p_j, p_l);
std::swap(abs_p_j, abs_p_l);
std::swap(a_j, a_l);
std::swap(coa_j, coa_l);
std::swap(S_j, S_l);
std::swap(coS_j, coS_l);
}
a[abs_p_j] = a_j & coa_l ^
(a_j & coa_l ^ a_j & a_l) & (x[i] ^ (p_j > 0) ^ (p_l > 0));
coa[abs_p_j] = coa_j & a_l ^ (coa_j & a_l ^ coa_j & coa_l) &
(x[i] ^ (p_j > 0) ^ (p_l > 0));
int m_0 = get_min(a_j, S_j, coa_j, coS_j);
if (abs_p_j != abs_p_l) {
m_0 += get_min(a_l, S_l, coa_l, coS_l);
bool t = x[i] ^ (p_j > 0) ^ (p_l > 0);
p[abs_p_l] = t ? abs_p_j : -abs_p_j;
S[abs_p_j] += t ? S_l : coS_l;
coS[abs_p_j] += t ? coS_l : S_l;
}
int m_1 = get_min(a[abs_p_j], S[abs_p_j], coa[abs_p_j], coS[abs_p_j]);
R += m_1 - m_0;
std::cout << R << std::endl;
}
}
int main() {
std::cin.tie(0);
std::cin.sync_with_stdio(false);
int t = 1;
while (t--) proc();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct FenwickTree {
int n;
vector<long long> num;
FenwickTree() : n(0) {}
FenwickTree(int _n) {
n = _n;
num.assign(n, 0);
}
void add(int i, int val) {
for (; i < n; i |= i + 1) num[i] += val;
}
long long sum(int i) {
long long ret = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) ret += num[i];
return ret;
}
};
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int>> point(n);
vector<int> speed;
for (int i = 0; i < n; i++) scanf("%d", &point[i].first);
for (int i = 0; i < n; i++) {
scanf("%d", &point[i].second);
speed.push_back(point[i].second);
}
sort(speed.begin(), speed.end());
speed.erase(unique(speed.begin(), speed.end()), speed.end());
sort(point.begin(), point.end());
long long ans = 0;
FenwickTree cnt(n), sumx(n);
for (auto i : point) {
i.second =
lower_bound(speed.begin(), speed.end(), i.second) - speed.begin();
ans += cnt.sum(i.second) * i.first - sumx.sum(i.second);
cnt.add(i.second, 1);
sumx.add(i.second, i.first);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
int v[n];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) cin >> v[i];
map<int, int> mp;
vector<pair<int, int> > vi;
vector<pair<int, int> > vf;
for (int i = 0; i < n; i++) {
vi.push_back({arr[i], v[i]});
vf.push_back({v[i], arr[i]});
}
sort(vi.begin(), vi.end());
sort(vf.begin(), vf.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
int val = vi[i].first;
mp[val] = i;
ans += (2 * i - n + 1) * ((long long)val);
}
for (int i = 0; i < n; i++) {
int val = vf[i].second;
if (mp[val] == i) continue;
ans += (i - mp[val]) * (long long)val;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, T;
pair<int, int> a[200010];
long long getval(vector<long long> &f, int pos) {
pos++;
long long ans = 0;
for (int i = pos; i > 0; i -= (i & -i)) ans += f[i];
return ans;
}
void upd(vector<long long> &f, int pos, int val) {
pos++;
for (int i = pos; i < int(f.size()); i += (i & -i)) f[i] += val;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].first;
for (int i = 0; i < n; i++) cin >> a[i].second;
sort(a, a + n);
vector<int> compress_v;
for (int i = 0; i < n; i++) compress_v.push_back(a[i].second);
sort(compress_v.begin(), compress_v.end());
compress_v.resize(unique(compress_v.begin(), compress_v.end()) -
compress_v.begin());
vector<long long> cnt(compress_v.size() + 1), sum(compress_v.size() + 1);
long long ans = 0;
for (int i = 0; i < n; i++) {
int pos = lower_bound(compress_v.begin(), compress_v.end(), a[i].second) -
compress_v.begin();
ans += getval(cnt, pos) * 1ll * a[i].first - getval(sum, pos);
upd(cnt, pos, 1);
upd(sum, pos, a[i].first);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
class st {
int size;
vector<int> c;
vector<long long> a;
public:
st(int n) {
size = 1;
while (size < n) size *= 2;
c.assign(2 * size, 0);
a.assign(2 * size, 0);
}
void set(int i, long long v, int x, int lx, int rx) {
if (lx + 1 == rx) {
if (v == 0) {
c[x] = 0;
a[x] = 0;
} else {
c[x] = 1;
a[x] = v;
}
return;
}
int m = (lx + rx) / 2;
if (i < m)
set(i, v, 2 * x + 1, lx, m);
else
set(i, v, 2 * x + 2, m, rx);
c[x] = c[2 * x + 1] + c[2 * x + 2];
a[x] = a[2 * x + 1] + a[2 * x + 2];
}
void set(int i, long long v) { set(i, v, 0, 0, size); }
long long g1(int l, int r, int x, int lx, int rx) {
if (l >= rx || r <= lx) return 0;
if (l <= lx && r >= rx) return a[x];
int m = (lx + rx) / 2;
long long s1 = g1(l, r, 2 * x + 1, lx, m);
long long s2 = g1(l, r, 2 * x + 2, m, rx);
return s1 + s2;
}
long long g1(int l, int r) { return g1(l, r, 0, 0, size); }
long long g2(int l, int r, int x, int lx, int rx) {
if (l >= rx || r <= lx) return 0;
if (l <= lx && r >= rx) return c[x];
int m = (lx + rx) / 2;
long long s1 = g2(l, r, 2 * x + 1, lx, m);
long long s2 = g2(l, r, 2 * x + 2, m, rx);
return s1 + s2;
}
long long g2(int l, int r) { return g2(l, r, 0, 0, size); }
};
void solve() {
int n;
cin >> n;
vector<pair<long long, long long>> pts(n);
vector<pair<long long, long long>> pts2(n);
vector<long long> p2v(n);
for (int i = 0; i < n; i++) cin >> pts[i].first;
for (int i = 0; i < n; i++) cin >> pts[i].second;
for (int i = 0; i < n; i++) {
pts2[i].first = pts[i].second;
pts2[i].second = pts[i].first;
}
sort(pts.begin(), pts.end());
sort(pts2.begin(), pts2.end());
for (int i = 0; i < n; i++) p2v[i] = pts2[i].first;
st s(n);
for (int i = 0; i < n; i++) {
s.set(i, pts2[i].second);
}
long long total = 0;
for (int i = 0; i < n; i++) {
int ind = lower_bound(pts2.begin(), pts2.end(),
make_pair(pts[i].second, pts[i].first)) -
pts2.begin();
int ind2 = lower_bound(p2v.begin(), p2v.end(), pts[i].second) - p2v.begin();
s.set(ind, 0);
total += (s.g1(ind2, n) - s.g2(ind2, n) * pts[i].first);
}
cout << total << "\n";
}
int main() {
auto start = high_resolution_clock::now();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
long long t = 1;
for (long long i = 0; i < t; i++) {
solve();
}
auto stop = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(stop - start);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long MOD = 1e+9 + 7;
const long long INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const long long MAXN = 2e+5 + 8;
vector<long long> adj[MAXN];
long long visit[MAXN] = {};
int dx8[] = {0, 1, 1, 1, 0, -1, -1, -1}, dy8[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dx4[] = {0, 1, 0, -1}, dy4[] = {1, 0, -1, 0};
int t = 1;
long long n;
pair<long long, long long> seg[4 * MAXN + 8];
vector<pair<long long, long long> > arr;
vector<long long> v;
void build(long long n, long long st, long long en) {
if (st == en) {
seg[n] = arr[st];
return;
}
long long mid = (st + en) / 2;
build(2 * n, st, mid);
build(2 * n + 1, mid + 1, en);
seg[n].first = seg[2 * n].first + seg[2 * n + 1].first;
seg[n].second = seg[2 * n].second + seg[2 * n + 1].second;
}
void update(long long n, long long st, long long en, long long pos,
long long val1, long long val2) {
if (st == en) {
seg[n].first += val1;
seg[n].second += val2;
return;
}
long long mid = (st + en) / 2;
if (pos <= mid)
update(2 * n, st, mid, pos, val1, val2);
else
update(2 * n + 1, mid + 1, en, pos, val1, val2);
seg[n].first = seg[2 * n].first + seg[2 * n + 1].first;
seg[n].second = seg[2 * n].second + seg[2 * n + 1].second;
}
pair<long long, long long> query(long long n, long long st, long long en,
long long l, long long r) {
if (l <= st && en <= r) return seg[n];
if (st > r || en < l) return {0, 0};
long long mid = (st + en) / 2;
pair<long long, long long> lq = query(2 * n, st, mid, l, r);
pair<long long, long long> rq = query(2 * n + 1, mid + 1, en, l, r);
pair<long long, long long> res;
res.first = lq.first + rq.first;
res.second = lq.second + rq.second;
return res;
}
long long ans = 0;
void MAIN() {
cin >> n;
arr = vector<pair<long long, long long> >(n + 1, {0, 0});
v = vector<long long>(n + 1, 0);
for (long long i = (1); i <= n; i++) cin >> arr[i].first;
for (long long i = (1); i <= n; i++) cin >> arr[i].second;
for (long long i = (1); i <= n; i++) v[i] = arr[i].second;
sort(1 + (arr).begin(), (arr).end());
sort(1 + (v).begin(), (v).end());
for (auto [x, sp] : arr) {
if (x == 0) continue;
long long pos = lower_bound(1 + (v).begin(), (v).end(), sp) - v.begin();
ans += (query(1, 1, n, 1, pos).first * x) - (query(1, 1, n, 1, pos).second);
update(1, 1, n, pos, 1, x);
}
cout << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout << setprecision(10);
;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
;
while (t--) {
MAIN();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mxn = 1e6 + 7;
const long long mod = 1e9 + 7;
const long long inf = 1e18 + 7;
int dx[] = {+1, -1, 0, 0};
int dy[] = {0, 0, -1, +1};
pair<int, int> p[mxn];
map<long long, long long> f, s;
int n;
int a[mxn], ls[mxn];
long long ans;
void upd1(int x, int val) {
while (x <= (int)1e8) {
f[x] += val;
x = (x | (x + 1));
}
}
void upd2(int x) {
while (x <= (int)1e8) {
s[x]++;
x = (x | (x + 1));
}
}
long long sum1(int x) {
long long res = 0;
while (x > 0) {
res += f[x];
x = (x & (x + 1)) - 1;
}
return res;
}
int sum2(int x) {
int res = 0;
while (x > 0) {
res += s[x];
x = (x & (x + 1)) - 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> p[i].second;
ls[i] = p[i].second;
}
sort(p + 1, p + n + 1);
sort(ls + 1, ls + n + 1);
for (int i = 1; i <= n; i++) {
p[i].second = lower_bound(ls + 1, ls + n + 1, p[i].second) - ls;
}
for (int i = 1; i <= n; i++) {
ans += (1LL * p[i].first * sum2(p[i].second)) - sum1(p[i].second);
upd1(p[i].second, p[i].first);
upd2(p[i].second);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
bool prime[10000001];
long long P = 1000000007 - 2;
long long factorial[10000001] = {0};
long long powerFunction(long long x, long long y) {
long long res = 1;
long long p = 1000000007;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void sieveFunction(long long maxLimit) {
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (long long i = 2; maxLimit >= i; i++) {
if (prime[i]) {
for (long long j = 2 * i; maxLimit >= j; j += i) prime[j] = false;
}
}
}
void factorialFunction(long long maxLimit) {
factorial[0] = 1;
for (long long i = 1; i <= maxLimit; i++)
factorial[i] = (factorial[i - 1] * i) % 1000000007;
return;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<pair<long long, long long>> tree[800001];
vector<long long> treesum[800001];
vector<pair<long long, long long>> v;
void build(long long node, long long start, long long end) {
if (start == end) {
vector<pair<long long, long long>> temp;
temp.push_back({v[start].second, v[start].first});
tree[node] = temp;
vector<long long> sum;
long long s = 0;
for (long long i = 0; tree[node].size() > i; i++) {
s += tree[node][i].second;
treesum[node].push_back(s);
}
return;
}
long long mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
long long i = 0, j = 0;
while (i < tree[2 * node].size() && j < tree[2 * node + 1].size()) {
if (tree[2 * node][i] <= tree[2 * node + 1][j]) {
tree[node].push_back(tree[2 * node][i]);
i++;
} else {
tree[node].push_back(tree[2 * node + 1][j]);
j++;
}
}
for (long long k = i; k < tree[2 * node].size(); k++)
tree[node].push_back(tree[2 * node][k]);
for (long long k = j; k < tree[2 * node + 1].size(); k++)
tree[node].push_back(tree[2 * node + 1][k]);
long long s = 0;
for (long long k = 0; tree[node].size() > k; k++) {
s += tree[node][k].second;
treesum[node].push_back(s);
}
}
long long n;
pair<long long, long long> query(long long node, long long start, long long end,
long long x) {
if (start > x && end <= n) {
pair<long long, long long> tem = {v[x].second, INT64_MIN};
long long id = lower_bound(tree[node].begin(), tree[node].end(), tem) -
tree[node].begin();
if (id) {
return {treesum[node].back() - treesum[node][id - 1],
(long long)tree[node].size() - id};
}
return {treesum[node].back(), tree[node].size()};
}
if (end <= x || start > n) {
return {0, 0};
}
long long mid = (start + end) / 2;
pair<long long, long long> t1 = query(2 * node, start, mid, x),
t2 = query(2 * node + 1, mid + 1, end, x);
return {t1.first + t2.first, t1.second + t2.second};
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
long long x[n + 1], s[n + 1];
for (long long i = 1; n >= i; i++) {
cin >> x[i];
}
for (long long i = 1; n >= i; i++) {
cin >> s[i];
}
v.push_back({INT64_MIN, INT64_MIN});
for (long long i = 1; n >= i; i++) {
v.push_back({x[i], s[i]});
}
sort(v.begin(), v.end());
build(1, 1, n);
long long ans = 0;
for (long long i = 1; n >= i; i++) {
long long xx = v[i].first;
pair<long long, long long> temp = query(1, 1, n, i);
temp.first -= xx * temp.second;
ans += temp.first;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = int(1e9) + 7;
const long long int MOD64 = (long long int)(1e18) + 7;
const int INF = 0x7fffffff;
const long long int INF64 = 0x7fffffffffffffff;
using namespace std;
const int maxn = 1e+5;
struct abc {
long long pos;
long long sp;
} ver[maxn * 2 + 5];
int n;
long long speed[maxn * 2 + 5];
long long tree[maxn * 2 + 5][2];
long long lowbit(long long x);
long long _get(long long x, long long which);
void updata(long long x, long long val);
long long lowbit(long long x) { return x & (-x); }
bool cmp(abc a, abc b) { return a.pos < b.pos; }
long long _get(long long x, long long which) {
long long res = 0;
while (x) {
res += tree[x][which];
x -= lowbit(x);
}
return res;
}
void updata(long long x, long long val) {
while (x <= n) {
tree[x][0]++;
tree[x][1] += val;
x += lowbit(x);
}
}
int main() {
memset(tree, 0, sizeof(tree));
memset(speed, 0, sizeof(speed));
cin >> n;
for (int i = 1; i <= n; i++) cin >> ver[i].pos;
for (int i = 1; i <= n; i++) {
cin >> ver[i].sp;
speed[i] = ver[i].sp;
}
sort(ver + 1, ver + 1 + n, cmp);
sort(speed + 1, speed + 1 + n);
long long m = unique(speed + 1, speed + 1 + n) - speed - 1;
long long res = 0;
for (int i = 1; i <= n; i++) {
int x = lower_bound(speed + 1, speed + 1 + m, ver[i].sp) - speed;
res += ver[i].pos * _get(x, 0) - _get(x, 1);
updata(x, ver[i].pos);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, c[200005];
long long ans;
struct t {
long long x, y;
int z;
} a[200005];
int lowbit(int x) { return x & (-x); }
void update(int x) {
for (int i = x; i <= n; i += lowbit(i)) c[i]++;
}
int query(int x) {
int s = 0;
for (int i = x; i >= 1; i -= lowbit(i)) s += c[i];
return s;
}
bool cmp(t x, t y) { return x.y < y.y || x.y == y.y && x.x < y.x; }
bool cmp1(t x, t y) { return x.x < y.x; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i].x);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i].y);
sort(a + 1, a + 1 + n, cmp1);
for (int i = 1; i <= n; i++) a[i].z = i;
sort(a + 1, a + 1 + n, cmp);
memset(c, 0, sizeof(c));
ans = 0;
for (int i = 1; i <= n; i++) {
long long x;
x = query(a[i].z - 1);
ans += a[i].x * x;
update(a[i].z);
}
memset(c, 0, sizeof(c));
for (int i = n; i >= 1; i--) {
long long x = query(n) - query(a[i].z);
ans -= a[i].x * x;
update(a[i].z);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
using namespace std;
const long long N = 1e6 + 5;
const long long M = 1e8;
const long long mod = 1e9 + 7;
const long long INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
long long test = 1, n, a[N], v[N], ct = 1;
vector<long long> sp;
vector<pair<long long, long long> > x;
map<long long, long long> ind;
long long tree[N][2] = {};
void update(int idx, int val, int first) {
idx++;
while (idx <= n + 1) {
tree[idx][first] += val;
idx += idx & (-idx);
}
}
long long query(int idx, int first) {
idx++;
long long sum = 0;
while (idx > 0) {
sum += tree[idx][first];
idx -= idx & (-idx);
}
return sum;
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> v[i], sp.push_back(v[i]);
sort(sp.begin(), sp.end());
for (auto it : sp)
if (ind[it] == 0) ind[it] = ct++;
for (int i = 1; i <= n; i++) v[i] = ind[v[i]], x.push_back({a[i], v[i]});
sort(x.begin(), x.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += query(x[i].second, 0) * x[i].first - query(x[i].second, 1);
update(x[i].second, 1, 0);
update(x[i].second, x[i].first, 1);
}
cout << ans << " "
<< "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout << setprecision(10);
;
for (int i = 1; i <= test; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[200005];
vector<int> g;
struct node {
long long w, num;
} tree[1000005];
void update(int x, long long val, int l, int r, int k = 1) {
if (l == r and l == x) {
tree[k].w++;
tree[k].num += val;
return;
}
int mid = l + r >> 1;
if (x <= mid)
update(x, val, l, mid, k << 1);
else
update(x, val, mid + 1, r, k << 1 | 1);
tree[k].w = tree[k << 1].w + tree[k << 1 | 1].w;
tree[k].num = tree[k << 1].num + tree[k << 1 | 1].num;
}
long long cnt, sum;
void query(int x, int y, int l, int r, int k = 1) {
if (x <= l and y >= r) {
if (tree[k].w) sum += tree[k].num, cnt += tree[k].w;
return;
}
int mid = l + r >> 1;
if (x <= mid) query(x, y, l, mid, k << 1);
if (y > mid) query(x, y, mid + 1, r, k << 1 | 1);
}
map<int, int> id;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
}
for (int i = 1; i <= n; ++i) {
cin >> a[i].second;
g.push_back(a[i].second);
}
sort(a + 1, a + 1 + n);
sort(g.begin(), g.end());
g.erase(unique(g.begin(), g.end()), g.end());
for (int i = 0; i < g.size(); i++) {
id[g[i]] = i;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
sum = cnt = 0;
query(0, id[a[i].second], 0, g.size() - 1);
ans += abs(sum - cnt * a[i].first);
update(id[a[i].second], a[i].first, 0, g.size() - 1);
}
cout << ans << endl;
return 0;
}
|
#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 long long N = 2e5 + 5, MOD = 1e9 + 7;
pair<long long, long long> a[N];
pair<long long, long long> tree[4 * N];
bool compare(pair<long long, long long> p1, pair<long long, long long> p2) {
return p1.first < p2.first;
}
void update(long long node, long long st, long long en, long long ccidx,
long long val, long long cnt) {
if (st == en) {
tree[node].first += val;
tree[node].second += cnt;
return;
}
long long mid = (st + en) / 2;
if (ccidx <= mid)
update(2 * node, st, mid, ccidx, val, cnt);
else
update(2 * node + 1, mid + 1, en, ccidx, val, cnt);
tree[node].first = tree[2 * node].first + tree[2 * node + 1].first;
tree[node].second = tree[2 * node].second + tree[2 * node + 1].second;
}
pair<long long, long long> query(long long node, long long st, long long en,
long long l, long long r) {
if (l > en || r < st) return {0, 0};
if (l <= st && en <= r) return tree[node];
long long mid = (st + en) / 2;
pair<long long, long long> p1 = query(2 * node, st, mid, l, r);
pair<long long, long long> p2 = query(2 * node + 1, mid + 1, en, l, r);
return {p1.first + p2.first, p1.second + p2.second};
}
void solve() {
long long n;
cin >> n;
set<long long> s;
for (long long i = 0; i < n; i++) cin >> a[i].first;
for (long long i = 0; i < n; i++) {
cin >> a[i].second;
s.insert(a[i].second);
}
map<long long, long long> cc;
long long j = 1;
for (auto x : s) {
cc[x] = j;
j++;
}
sort(a, a + n, compare);
pair<long long, long long> tem = {0ll, 0ll};
for (long long i = 0; i < 4 * N; i++) tree[i] = tem;
for (long long i = 0; i < n; i++) {
update(1, 1, j - 1, cc[a[i].second], a[i].first, 1);
}
long long ans = 0;
for (long long i = n - 1; i >= 0; i--) {
update(1, 1, j - 1, cc[a[i].second], -a[i].first, -1);
pair<long long, long long> x = query(1, 1, j - 1, 1, cc[a[i].second]);
ans += abs(x.second * a[i].first - x.first);
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
struct Point {
LL x, v;
bool operator<(const Point &rhs) const {
if (v == rhs.v)
return x < rhs.x;
else
return v < rhs.v;
}
};
Point p[200010];
LL n, x2[200010], idx[200010], c[200010], s[200010];
void update(LL *arr, LL pos, LL val) {
for (LL i = pos; i <= n; i += i & (-i)) arr[i] += val;
}
LL query(LL *arr, LL pos) {
LL res = 0;
for (LL i = pos; i; i -= i & (-i)) res += arr[i];
return res;
}
int main() {
scanf("%lld", &n);
for (LL i = 1; i <= n; i++) scanf("%lld", &p[i].x);
for (LL i = 1; i <= n; i++) scanf("%lld", &p[i].v);
for (LL i = 1; i <= n; i++) idx[i] = i;
sort(p + 1, p + n + 1);
sort(idx + 1, idx + n + 1, [](LL i, LL j) { return p[i].x < p[j].x; });
for (LL i = 1; i <= n;) {
LL j;
for (j = i; j <= n; j++)
if (p[idx[j]].x != p[idx[i]].x)
break;
else
x2[idx[j]] = i;
i = j;
}
LL ans = 0;
for (LL i = 1; i <= n; i++) {
ans += p[i].x * query(c, x2[i]) - query(s, x2[i]);
update(c, x2[i], 1);
update(s, x2[i], p[i].x);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, tot, cnt, v[200001];
long long ans, c1[200001], c2[200001];
struct node {
int x, v;
inline bool operator<(const node &a) const { return x < a.x; }
} s[200001];
inline int read() {
int k = 0, f = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') f = -1;
while (c >= '0' && c <= '9')
k = (k << 1) + (k << 3) + (c ^ 48), c = getchar();
return k * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x / 10) write(x / 10);
putchar(x % 10 + '0');
return;
}
inline void add(int pos, int num, bool op) {
for (; pos <= n; pos += pos & -pos)
if (op)
c1[pos] += num;
else
++c2[pos];
}
inline long long sum(int pos, bool op) {
long long res = 0;
for (; pos; pos -= pos & -pos)
if (op)
res += c1[pos];
else
res += c2[pos];
return res;
}
int main() {
n = read();
for (register int i = 1; i <= n; ++i) s[i].x = read();
for (register int i = 1; i <= n; ++i) s[i].v = read(), v[i] = s[i].v;
sort(v + 1, v + n + 1);
cnt = unique(v + 1, v + n + 1) - v - 1;
for (register int i = 1; i <= n; ++i)
s[i].v = lower_bound(v + 1, v + cnt + 1, s[i].v) - v;
sort(s + 1, s + n + 1);
for (register int i = 1; i <= n; ++i) {
long long sum1 = sum(s[i].v, 1), sum2 = sum(s[i].v, 0);
ans += sum2 * s[i].x - sum1;
add(s[i].v, s[i].x, 1);
add(s[i].v, 1, 0);
}
write(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5;
pair<long long, long long> p[N], a[N];
long long n;
long long fwt[N], cntf[N];
long long len;
void add(long long *b, long long x, long long v) {
while (x <= len) {
b[x] += v;
x += x & -x;
}
}
long long get(long long *b, long long x) {
long long res = 0;
while (x) {
res += b[x];
x -= x & -x;
}
return res;
}
signed main() {
ios::sync_with_stdio(false);
cin >> n;
vector<long long> velo_neg, velo_pos;
for (long long i = 0; i < n; i++) {
cin >> p[i].first;
}
for (long long i = 0; i < n; i++) {
cin >> p[i].second;
}
sort(p, p + n);
vector<long long> velo;
for (long long i = 0; i < n; i++) {
velo.push_back(p[i].second);
}
sort(velo.begin(), velo.end());
velo.erase(unique(velo.begin(), velo.end()), velo.end());
len = velo.size();
long long ans = 0;
long long sumx = 0;
for (long long i = 0; i < n; i++) {
a[i] = p[i];
a[i].second =
lower_bound(velo.begin(), velo.end(), p[i].second) - velo.begin() + 1;
ans += i * p[i].first - sumx;
sumx += p[i].first;
}
for (long long i = 0; i < n; i++) {
if (p[i].second < 0) {
ans -= (get(cntf, len) - get(cntf, a[i].second)) * p[i].first -
(get(fwt, len) - get(fwt, a[i].second));
}
add(fwt, a[i].second, p[i].first);
add(cntf, a[i].second, 1);
}
memset(cntf, 0, sizeof cntf);
memset(fwt, 0, sizeof fwt);
for (long long i = n - 1; i >= 0; i--) {
if (p[i].second > 0) {
ans -=
get(fwt, a[i].second - 1) - get(cntf, a[i].second - 1) * p[i].first;
}
if (p[i].second >= 0) {
add(fwt, a[i].second, p[i].first);
add(cntf, a[i].second, 1);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
long long f[200005], ans, bit[200005], s[200005];
map<long long, long long> m;
long long t, n;
pair<long long, long long> a[200005];
long long get(long long first, long long second) {
long long re = 0, cnt = 0;
for (long long i = second; i > 0; i -= (i & (-i))) {
cnt += bit[i];
re += s[i];
}
return first * cnt - re;
}
void update(long long first, long long second) {
for (long long i = second; i <= n; i += (i & (-i))) {
bit[i]++;
s[i] += first;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i].first;
for (long long i = 1; i <= n; i++) cin >> a[i].second, m[a[i].second] = 0;
long long k = 1;
for (map<long long, long long>::iterator it = m.begin(); it != m.end();
it++, k++)
it->second = k;
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) a[i].second = m[a[i].second];
for (long long i = 1; i <= n; i++) {
ans += get(a[i].first, a[i].second);
update(a[i].first, a[i].second);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
struct dd {
int gt;
int x;
int v;
};
vector<dd> a;
struct Data {
long long sum;
int sl;
};
Data it[200009 * 8];
Data ans;
long long res;
void update(int i, int l, int r, int pos, int data) {
if (l > pos || r < pos) return;
if (l == r) {
it[i].sum = data;
it[i].sl = 1;
return;
}
int mid = (l + r) / 2;
update(i * 2, l, mid, pos, data);
update(i * 2 + 1, mid + 1, r, pos, data);
it[i].sum = it[i * 2].sum + it[i * 2 + 1].sum;
it[i].sl = it[i * 2].sl + it[i * 2 + 1].sl;
}
void find(int i, int l, int r, int u, int v) {
if (l > r) return;
if (r < u || l > v) return;
if (u <= l && r <= v) {
ans.sum = ans.sum + it[i].sum;
ans.sl = ans.sl + it[i].sl;
return;
}
int mid = (l + r) / 2;
find(i * 2, l, mid, u, v);
find(i * 2 + 1, mid + 1, r, u, v);
}
bool cmp(const dd& a, const dd& b) {
if (a.v == b.v) {
return a.x < b.x;
}
return a.v < b.v;
}
bool cmp1(const dd& a, const dd& b) { return a.x < b.x; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
dd tmp;
cin >> tmp.x;
a.push_back(tmp);
}
for (int i = 0; i < n; i++) {
cin >> a[i].v;
}
sort(a.begin(), a.end(), cmp1);
for (int i = 0; i < n; i++) {
a[i].gt = i + 1;
}
sort(a.begin(), a.end(), cmp);
update(1, 1, n, a[n - 1].gt, a[n - 1].x);
for (int i = n - 2; i >= 0; i--) {
long long tmp = a[i].x;
ans.sl = 0;
ans.sum = 0;
find(1, 1, n, a[i].gt + 1, n);
res = res + ans.sum - (tmp * ans.sl);
update(1, 1, n, a[i].gt, a[i].x);
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000010;
const long long mod = 998244353;
const long long inf = 1e9;
const long double eps = 1e-16;
const long double pi = acos(-1);
inline long long rd() {
long long p = 0;
long long f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f *= -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
p = p * 10 + ch - '0';
ch = getchar();
}
return p * f;
}
struct node {
long long x, v;
} a[N];
vector<long long> v;
bool cmp(const node &x, const node &y) { return x.x < y.x; }
long long tr[2][N], n;
void add(long long id, long long x, long long c) {
while (x <= n) {
tr[id][x] += c;
x += ((x) & (-(x)));
}
}
long long qry(long long id, long long x) {
long long s = 0;
while (x >= 1) {
s += tr[id][x];
x -= ((x) & (-(x)));
}
return s;
}
signed main() {
n = rd();
for (long long i = (1); i <= (n); i++) a[i].x = rd();
for (long long i = (1); i <= (n); i++) a[i].v = rd(), v.push_back(a[i].v);
sort(a + 1, a + n + 1, cmp);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (long long i = (1); i <= (n); i++)
a[i].v = lower_bound(v.begin(), v.end(), a[i].v) - v.begin() + 1;
long long ans = 0;
for (long long i = (1); i <= (n); i++) {
ans += qry(0, a[i].v) * a[i].x - qry(1, a[i].v);
add(0, a[i].v, 1);
add(1, a[i].v, a[i].x);
}
return printf("%lld\n", ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
pair<long long, long long> pos[200005];
struct FenwickTree {
vector<long long> bit;
long long n;
FenwickTree(long long n) {
this->n = n;
bit.assign(n, 0);
}
FenwickTree(vector<long long> a) : FenwickTree(a.size()) {
for (size_t i = 0; i < a.size(); i++) add(i, a[i]);
}
long long sum(long long r) {
long long ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
return ret;
}
long long sum(long long l, long long r) { return sum(r) - sum(l - 1); }
void add(long long idx, long long delta) {
for (; idx < n; idx = idx | (idx + 1)) bit[idx] += delta;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
pos[i].first = a;
}
pair<long long, long long> temp[n];
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
temp[i] = {a, i};
}
sort(temp, temp + n);
long long prev = -100000005;
long long cur = -1;
for (long long i = 0; i < n; i++) {
if (temp[i].first != prev) cur++;
pos[temp[i].second].second = cur;
prev = temp[i].first;
}
sort(pos, pos + n);
FenwickTree f1(200005);
FenwickTree f2(200005);
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans -= f1.sum(0, pos[i].second);
ans += f2.sum(0, pos[i].second) * pos[i].first;
f1.add(pos[i].second, pos[i].first);
f2.add(pos[i].second, 1);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long> inverse(vector<long>& perm) {
long n = perm.size();
vector<long> ret(n);
for (long i = 0; i < n; ++i) {
ret[perm[i]] = i;
}
return ret;
}
vector<long> assignPermutation(const vector<long>& uniqs) {
long n = uniqs.size();
vector<pair<long, long>> withIndices(n);
for (long i = 0; i < n; ++i) {
withIndices[i] = {uniqs[i], i};
}
sort(withIndices.begin(), withIndices.end());
vector<long> temp(n);
for (long i = 0; i < n; ++i) {
temp[i] = withIndices[i].second;
}
return inverse(temp);
}
int main() {
long n;
cin >> n;
cin.ignore();
vector<long> x(n);
vector<long> v(n);
vector<pair<long, long>> data(n);
for (long i = 0; i < n; ++i) {
cin >> x[i];
}
cin.ignore();
for (long i = 0; i < n; ++i) {
cin >> v[i];
data[i] = {v[i], x[i]};
}
cin.ignore();
sort(data.begin(), data.end());
vector<long> xtemp(n);
for (long i = 0; i < n; ++i) xtemp[i] = data[i].second;
auto xranks = assignPermutation(xtemp);
sort(x.begin(), x.end());
long long totsum = 0;
for (long i = 0; i < n; ++i) {
totsum += (long long)(i)*x[i];
totsum -= (long long)(n - 1 - i) * x[i];
}
for (long i = 0; i < n; ++i) {
long netleftjumps = i - xranks[i];
totsum += (long long)(netleftjumps)*xtemp[i];
}
cout << totsum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int lowbit(int x) { return x & (-x); }
long long get(vector<long long>& f, int pos) {
long long res = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) res += f[pos];
return res;
}
void upd(vector<long long>& f, int pos, int val) {
for (; pos < int(f.size()); pos |= pos + 1) {
f[pos] += val;
}
}
int main() {
int n;
cin >> n;
vector<pair<int, int>> p(n);
for (auto& pnt : p) cin >> pnt.first;
for (auto& pnt : p) cin >> pnt.second;
sort(p.begin(), p.end());
vector<int> vs;
for (auto& pnt : p) vs.push_back(pnt.second);
sort(vs.begin(), vs.end());
vs.resize(unique(vs.begin(), vs.end()) - vs.begin());
long long ans = 0;
vector<long long> cnt(vs.size()), xs(vs.size());
for (auto& pnt : p) {
int pos = lower_bound(vs.begin(), vs.end(), pnt.second) - vs.begin();
ans += get(cnt, pos) * 1ll * pnt.first - get(xs, pos);
upd(cnt, pos, 1);
upd(xs, pos, pnt.first);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, ans, tree[800002], tree1[800002];
map<long long, long long> mp, mp1;
pair<long long, long long> a[300005];
vector<long long> v;
void inc1(int idx, int val) {
for (int i = idx; i <= n; i += i & (-i)) {
tree[i] += val;
}
}
void inc2(int idx, int val) {
for (int i = idx; i <= n; i += (i & (-i))) {
tree1[i] += val;
}
}
long long sum1(int idx) {
long long pas = 0;
for (int i = idx; i > 0; i -= i & (-i)) {
pas += tree[i];
}
return pas;
}
long long sum2(int idx) {
long long pas = 0;
for (int i = idx; i > 0; i -= i & (-i)) {
pas += tree1[i];
}
return pas;
}
int main() {
std::ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> a[i].second;
if (!mp[a[i].second]) {
v.push_back(a[i].second);
}
mp[a[i].second] = 1;
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
mp1[v[i]] = i + 1;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
ans += sum1(mp1[a[i].second]) * a[i].first - sum2(mp1[a[i].second]);
inc1(mp1[a[i].second], 1);
inc2(mp1[a[i].second], a[i].first);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int l, r;
int cnt = 0;
long long sum = 0;
int left = -1;
int right = -1;
} NIL;
vector<Node> st;
Node merge(Node x, Node y) {
Node z;
z.cnt = x.cnt + y.cnt;
z.sum = x.sum + y.sum;
return z;
}
void add(int u, int x, int v) {
if (not(st[u].l <= v and v <= st[u].r)) return;
if (st[u].l == v and v == st[u].r) {
st[u].cnt += 1;
st[u].sum += x;
return;
}
int m = (st[u].l + st[u].r) >> 1;
if (st[u].left == -1) {
Node x;
x.l = st[u].l, x.r = m;
st[u].left = int(st.size());
st.push_back(x);
}
if (st[u].right == -1) {
Node x;
x.l = m + 1, x.r = st[u].r;
st[u].right = int(st.size());
st.push_back(x);
}
add(st[u].left, x, v);
add(st[u].right, x, v);
Node s = merge(st[st[u].left], st[st[u].right]);
st[u].sum = s.sum;
st[u].cnt = s.cnt;
};
Node gteq(int u, int L, int R) {
if (u == -1 or st[u].r < L or R < st[u].l) return NIL;
if (L <= st[u].l and st[u].r <= R) return st[u];
return merge(gteq(st[u].left, L, R), gteq(st[u].right, L, R));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, int> > p(n);
for (int i = 0; i < n; i++) cin >> p[i].first;
for (int i = 0; i < n; i++) cin >> p[i].second;
sort(begin(p), end(p));
Node root;
root.l = -1e8;
root.r = 1e8;
st.emplace_back(root);
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
Node s = gteq(0, p[i].second, 1e8);
ans += s.sum - 1LL * s.cnt * p[i].first;
add(0, p[i].first, p[i].second);
}
cout << ans << '\n';
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long f1[200005], f2[200005], kc;
pair<long long, long long> a[200005];
bool cmp1(pair<long long, long long> x, pair<long long, long long> y) {
return x.first < y.first;
}
bool cmp2(pair<long long, long long> x, pair<long long, long long> y) {
return x.second < y.second;
}
void update(int id, long long value, long long f[]) {
while (id < 200005) {
f[id] = f[id] + value;
id = id + (id & -id);
};
}
long long rsumq(int x, long long f[]) {
long long sum = 0;
while (x != 0) {
sum += f[x];
x -= (x & -x);
};
return sum;
}
long long rsumq(int x, int y, long long f[]) {
return rsumq(y, f) - (x == 1 ? 0 : rsumq(x - 1, f));
}
void nhap() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].first;
for (int i = 1; i <= n; i++) cin >> a[i].second;
sort(a + 1, a + 1 + n, cmp2);
int cnt = 1;
for (int i = 1; i < n; i++) {
int tmp = a[i].second;
a[i].second = cnt;
if (tmp != a[i + 1].second) cnt++;
}
a[n].second = cnt;
}
void xuly() {
sort(a + 1, a + 1 + n, cmp1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += (rsumq(1, a[i].second, f1) * a[i].first - rsumq(1, a[i].second, f2));
update(a[i].second, 1, f1);
update(a[i].second, a[i].first, f2);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
nhap();
xuly();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
static int MAX_N = 200000, n;
vector<ll> bitx(MAX_N + 1), bit1(MAX_N + 1);
ll sum(int i, vector<ll> &bit) {
ll res = 0;
while (i > 0) {
res += bit.at(i);
i -= i & -i;
}
return res;
}
void add(int i, int x, vector<ll> &bit) {
while (i <= n) {
bit.at(i) += x;
i += i & -i;
}
}
int main() {
cin >> n;
vi x(n);
for (int i = 0; i < (int)(n); i++) cin >> x.at(i);
vi v(n);
for (int i = 0; i < (int)(n); i++) cin >> v.at(i);
vector<pii> p;
for (int i = 0; i < (int)(n); i++) {
pii pi(x.at(i), v.at(i));
p.push_back(pi);
}
sort(p.begin(), p.end());
map<int, int> x2i;
for (int i = 0; i < (int)(n); i++) x2i[p.at(i).first] = i + 1;
sort(p.begin(), p.end(), [](pii p1, pii p2) {
if (p1.second == p2.second)
return p1.first < p2.first;
else
return p1.second < p2.second;
});
ll ans = 0;
for (int j = 0; j < (int)(n); j++) {
int x = p.at(j).first;
int i = x2i.at(x);
ans += x * sum(i - 1, bit1) - sum(i - 1, bitx);
add(i, x, bitx);
add(i, 1, bit1);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void fio() {}
void pti() {
double timeuse = clock() * 1000.0 / CLOCKS_PER_SEC;
cerr << "Timeuse " << timeuse << "ms" << endl;
}
void end() { exit(0); }
namespace io {
const int SIZ = 55;
int que[SIZ], op, qr;
char ch;
template <class I>
inline void gi(I& w) {
ch = getchar(), op = 1, w = 0;
while (!isdigit(ch)) {
if (ch == '-') op = -1;
ch = getchar();
}
while (isdigit(ch)) {
w = w * 10 + ch - '0';
ch = getchar();
}
w *= op;
}
template <typename T, typename... Args>
inline void gi(T& t, Args&... args) {
gi(t);
gi(args...);
}
template <class I>
inline void print(I w) {
qr = 0;
if (!w) putchar('0');
if (w < 0) putchar('-'), w = -w;
while (w) que[++qr] = w % 10 + '0', w /= 10;
while (qr) putchar(que[qr--]);
}
} // namespace io
using io::gi;
using io::print;
const int N = 2e5 + 5;
int n, num;
struct node {
long long a, b;
};
node e[N];
long long c[N], t[N], sum[N];
map<long long, int> g;
int lowbit(int x) { return x & -x; }
void modify(int x, long long z) {
while (x <= n) ++t[x], sum[x] += z, x += lowbit(x);
}
long long query_t(int x) {
long long res = 0;
while (x) res += t[x], x -= lowbit(x);
return res;
}
long long query_sum(int x) {
long long res = 0;
while (x) res += sum[x], x -= lowbit(x);
return res;
}
int main() {
fio();
gi(n);
for (int i = 1; i <= n; ++i) gi(e[i].a);
for (int i = 1; i <= n; ++i) gi(e[i].b), c[i] = e[i].b;
sort(c + 1, c + n + 1);
for (int i = 1; i <= n; ++i)
if (!g[c[i]]) g[c[i]] = ++num;
sort(e + 1, e + n + 1,
[](node x, node y) { return x.a == y.a ? x.b < y.b : x.a < y.a; });
long long ans = 0;
for (int i = 1, j = 1; i <= n; ++i) {
ans += e[i].a * query_t(g[e[i].b]) - query_sum(g[e[i].b]);
while (j <= n && e[j].b == e[i].b && e[j].a == e[i].a)
modify(g[e[j].b], e[j].a), ++j;
}
print(ans);
end();
}
|
#include <bits/stdc++.h>
#pragma optimize("O3")
using namespace std;
const long long MOD = 1e9 + 9;
const long long INF = 1e9 + 7;
const int base = 2e5 + 1;
const long long MAX = 1e15 + 1;
const double EPS = 1e-9;
const double PI = acos(-1.);
const int MAXN = 2 * 1e5 + 47;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
pair<long long, long long> t[MAXN];
map<int, int> ind, vx;
void add(int x, long long val) {
for (int j = x; j < MAXN; j = j | (j + 1)) {
t[j].first += val;
t[j].second++;
}
}
long long get(int x) {
long long res = 0;
for (int j = x; j >= 0; j = (j & (j + 1)) - 1) {
res += t[j].first;
}
return res;
}
long long cnt(int x) {
long long res = 0;
for (int j = x; j >= 0; j = (j & (j + 1)) - 1) {
res += t[j].second;
}
return res;
}
int main() {
int n;
cin >> n;
vector<long long> x(n), v(n);
for (long long i = (0); i < (n); ++i) scanf("%lld", &x[i]);
for (long long i = (0); i < (n); ++i) {
scanf("%lld", &v[i]);
vx[x[i]] = v[i];
}
sort(v.begin(), v.end());
sort(x.begin(), x.end());
long long res = 0;
for (long long i = (0); i < (n); ++i) ind[v[i]] = i;
for (long long i = (0); i < (n); ++i) {
int cur = ind[vx[x[i]]];
res += x[i] * cnt(cur) - get(cur);
add(cur, x[i]);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> final[200001];
void up(long long int i, long long int x, long long int j) {
while (i < 200001) {
j == 0 ? final[i].first += x : final[i].second += x;
i += (i & (-i));
}
}
long long int q(long long int i, long long int j) {
long long int ans = 0;
while (i) {
ans += (j == 0 ? final[i].first : final[i].second);
i -= (i & (-i));
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int a[n];
pair<long long int, long long int> b[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
for (long long int i = 0; i < n; i++) {
cin >> b[i].first;
b[i].second = a[i];
}
sort(b, b + n);
map<long long int, long long int> mapper;
sort(a, a + n);
for (long long int i = 0; i < n; i++) {
mapper[a[i]] = i + 1;
}
long long int ans = 0;
for (auto e : b) {
long long int sp = e.first, pos = e.second;
long long int ind = mapper[pos];
long long int sum = q(ind - 1, 1);
long long int points = q(ind - 1, 0);
ans += pos * points - sum;
up(ind, 1, 0);
up(ind, pos, 1);
}
cout << ans;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int inf = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double eps = 1e-4;
const double pi = acos(-1.0);
void debug() { cerr << '\n'; }
template <typename T, typename... Ts>
void debug(T x, Ts... y) {
cerr << "\033[31m" << x << "\033[0m";
if (sizeof...(y) > 0) cerr << ' ';
debug(y...);
}
template <typename T>
void debug(const T &a, int l, int r, char c) {
for (int i = l; i <= r; ++i)
cerr << "\033[31m" << a[i] << "\033[0m" << (i == r ? '\n' : c);
}
template <typename T>
void debug(vector<T> a) {
for (int i = 0; i < (int)a.size(); ++i)
cerr << "\033[31m" << a[i] << "\033[31m"
<< " \n"[i == ((int)a.size() - 1)];
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long qpow(long long x, long long y) {
long long ans = 1;
for (; y > 0; y >>= 1) {
if (y & 1) ans *= x;
x *= x;
}
return ans;
}
long long qpow(long long x, long long y, int MOD) {
long long ans = 1;
for (; y > 0; y >>= 1) {
if (y & 1) ans = ans * x % MOD;
x = x * x % MOD;
}
return ans;
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, x, y);
long long X = x;
x = y;
y = X - a / b * y;
}
long long inv(long long x, int mod = MOD) { return qpow(x, mod - 2, mod); }
long long m_m(long long a, int mod = MOD) { return (a % mod + mod) % mod; }
const int N = 2e5 + 5;
vector<pair<long long, int>> tr(N + 1);
int tot;
int lsh[N];
void add(int x, int v) {
for (; x <= tot; x += -x & x) tr[x].first += v, ++tr[x].second;
}
pair<long long, int> qy(int x) {
pair<long long, int> ans;
for (; x > 0; x -= -x & x)
ans.first += tr[x].first, ans.second += tr[x].second;
return ans;
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<pair<int, int>> a(n + 1);
for (int i = (1); i < (n + 1); ++i) cin >> a[i].first;
for (int i = (1); i < (n + 1); ++i) {
cin >> a[i].second;
lsh[i] = a[i].second;
}
sort(a.begin(), a.end());
sort(lsh + 1, lsh + n + 1);
tot = unique(lsh + 1, lsh + n + 1) - lsh;
long long ans = 0;
for (int i = (1); i < (n + 1); ++i) {
int j = lower_bound(lsh + 1, lsh + tot, a[i].second) - lsh;
pair<long long, int> t = qy(j);
ans += 1ll * a[i].first * t.second - t.first;
add(j, a[i].first);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int lowbit(int x) { return x & (-x); }
long long getsum(vector<long long> &V, int pos) {
long long ret = 0;
for (; pos; pos -= lowbit(pos)) ret += V[pos];
return ret;
}
void add(vector<long long> &V, int pos, int k) {
for (; pos < (int)V.size(); pos += lowbit(pos)) V[pos] += k;
}
int main() {
int n;
cin >> n;
vector<pair<int, int>> p(n);
for (auto &pnt : p) {
int x;
scanf("%d", &x);
pnt.first = x;
}
for (auto &pnt : p) {
int v;
scanf("%d", &v);
pnt.second = v;
}
sort(p.begin(), p.end());
vector<int> vs{(int)(-1e9)};
for (auto pnt : p) vs.push_back(pnt.second);
sort(vs.begin(), vs.end());
vs.resize(unique(vs.begin(), vs.end()) - vs.begin());
long long ans = 0;
vector<long long> cnt(vs.size()), xs(vs.size());
for (auto pnt : p) {
int pos = lower_bound(vs.begin(), vs.end(), pnt.second) - vs.begin();
ans += getsum(cnt, pos) * pnt.first - getsum(xs, pos);
add(cnt, pos, 1), add(xs, pos, pnt.first);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int x[N];
long long ans;
pair<int, int> a[N];
int main(void) {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].second, x[i] = a[i].second;
for (int i = 0; i < n; i++) cin >> a[i].first;
sort(a, a + n), sort(x, x + n);
for (int i = 0; i < n; i++)
ans += (long long)(lower_bound(x, x + n, a[i].second) - x - n + 1 + i) *
a[i].second;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int b[200005], m;
long long tr[800005][2];
struct node {
int x, v;
bool operator<(const node t) const { return x < t.x; }
} a[200005];
int lsh(long long x) { return lower_bound(b + 1, b + 1 + m, x) - b; }
long long query(int l, int r, int x, int y, int k, int p) {
if (l == x && r == y) return tr[p][k];
int mid = l + r >> 1;
if (y <= mid)
return query(l, mid, x, y, k, p << 1);
else if (x > mid)
return query(mid + 1, r, x, y, k, p << 1 | 1);
else
return query(l, mid, x, mid, k, p << 1) +
query(mid + 1, r, mid + 1, y, k, p << 1 | 1);
}
void update(int l, int r, int x, int y, int p) {
if (l == r) {
tr[p][0]++;
tr[p][1] += y;
return;
}
int mid = l + r >> 1;
if (x <= mid)
update(l, mid, x, y, p << 1);
else
update(mid + 1, r, x, y, p << 1 | 1);
tr[p][0] = tr[p << 1][0] + tr[p << 1 | 1][0];
tr[p][1] = tr[p << 1][1] + tr[p << 1 | 1][1];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
b[i] = a[i].v;
}
sort(b + 1, b + 1 + n);
m = unique(b + 1, b + 1 + n) - b - 1;
sort(a + 1, a + 1 + n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int t = lsh(a[i].v);
ans += query(1, m, 1, t, 0, 1) * a[i].x - query(1, m, 1, t, 1, 1);
update(1, m, t, a[i].x, 1);
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int infinity = 9e18;
pair<long long int, long long int> t1[4 * 200005] = {};
pair<long long int, long long int> t2[4 * 200005] = {};
struct SegmentTree {
void update(pair<long long int, long long int> t[], int v, int tl, int tr,
int pos, int x) {
if (tl == tr) {
t[v].first += x;
t[v].second += 1;
} else {
int tm = (tl + tr) / 2;
if (pos <= tm)
update(t, 2 * v, tl, tm, pos, x);
else
update(t, 2 * v + 1, tm + 1, tr, pos, x);
t[v].first = (t[2 * v].first + t[2 * v + 1].first);
t[v].second = (t[2 * v].second + t[2 * v + 1].second);
}
}
pair<long long int, long long int> query(
pair<long long int, long long int> t[], int v, int tl, int tr, int l,
int r) {
if (l > r) return {0, 0};
if (tl == l && tr == r) {
return t[v];
} else {
int tm = (tl + tr) / 2;
pair<long long int, long long int> left =
query(t, 2 * v, tl, tm, l, min(tm, r));
pair<long long int, long long int> right =
query(t, 2 * v + 1, tm + 1, tr, max(tm + 1, l), r);
pair<long long int, long long int> p;
p.first = left.first + right.first;
p.second = left.second + right.second;
return p;
}
}
};
long long int func(vector<pair<long long int, long long int> > &vp,
pair<long long int, long long int> t[]) {
long long int n = vp.size();
set<long long int> s;
for (auto i : vp) {
s.insert(i.second);
}
long long int speed = 0;
map<long long int, long long int> m;
for (auto i : s) {
m[i] = speed++;
}
for (int i = 0; i < n; i++) {
vp[i].second = m[vp[i].second];
}
SegmentTree st;
long long int total = 0;
for (int i = 0; i < n; i++) {
pair<long long int, long long int> p =
st.query(t, 1, 0, n - 1, 0, vp[i].second);
total = total + (vp[i].first) * p.second - p.first;
st.update(t, 1, 0, n - 1, vp[i].second, vp[i].first);
}
return total;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
vector<pair<long long int, long long int> > vp(n);
for (int i = 0; i < n; i++) {
cin >> vp[i].first;
}
for (int i = 0; i < n; i++) {
cin >> vp[i].second;
}
sort(vp.begin(), vp.end());
vector<pair<long long int, long long int> > pos, neg;
long long int sum = 0;
long long int total = 0;
long long int count = 0;
for (int i = n - 1; i >= 0; i--) {
if (vp[i].second >= 0) {
sum += vp[i].first;
count++;
pos.push_back({vp[i].first, vp[i].second});
} else {
total = total + sum - vp[i].first * count;
neg.push_back({vp[i].first, vp[i].second});
}
}
sort(pos.begin(), pos.end());
sort(neg.begin(), neg.end());
total = total + func(pos, t1) + func(neg, t2);
cout << total;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n;
int b[maxn];
struct node {
int x, v;
} a[maxn];
bool cmp(node q1, node q2) { return q1.v == q2.v ? q1.x < q2.x : q1.v < q2.v; }
struct BIT {
long long c[maxn][2];
void init() { memset(c, 0, sizeof(c)); }
int lowbit(int x) { return x & (-x); }
void update(int k, int x, int y) {
for (int i = k; i <= n; i += lowbit(i)) {
c[i][0] += x;
c[i][1] += y;
}
}
pair<long long, long long> query(int k) {
long long ans1 = 0, ans2 = 0;
for (int i = k; i; i -= lowbit(i)) {
ans1 += c[i][0];
ans2 += c[i][1];
}
return make_pair(ans1, ans2);
}
pair<long long, long long> ask(int l, int r) {
pair<long long, long long> tmp1 = query(r);
pair<long long, long long> tmp2 = query(l - 1);
pair<long long, long long> tmp =
make_pair(tmp1.first - tmp2.first, tmp1.second - tmp2.second);
return tmp;
}
} T[2];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x);
int cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
b[++cnt] = a[i].x;
}
sort(b + 1, b + cnt + 1);
sort(a + 1, a + n + 1, cmp);
cnt = unique(b + 1, b + cnt + 1) - b - 1;
for (int i = 1; i <= n; i++) {
a[i].x = lower_bound(b + 1, b + cnt + 1, a[i].x) - b;
T[1].update(a[i].x, 1, b[a[i].x]);
}
long long ans = 0;
pair<long long, long long> tmp;
for (int i = 1; i <= n; i++) {
T[0].update(a[i].x, 1, b[a[i].x]);
T[1].update(a[i].x, -1, -b[a[i].x]);
tmp = T[0].ask(1, a[i].x);
ans += tmp.first * b[a[i].x] - tmp.second;
tmp = T[1].ask(a[i].x, n);
ans += tmp.second - tmp.first * b[a[i].x];
}
printf("%lld\n", ans / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
pair<int, int> p[maxn];
int n;
long long d[maxn];
long long e[maxn];
void add(long long *c, int i, int k) {
while (i <= n) {
c[i] += k;
i += i & (-i);
}
}
long long sum(long long *c, int i) {
long long res = 0;
while (i > 0) {
res += c[i];
i -= i & (-i);
}
return res;
}
int main() {
cin >> n;
for (int i = 0; i <= n - 1; i++) cin >> p[i].first;
for (int i = 0; i <= n - 1; i++) cin >> p[i].second;
sort(p, p + n);
vector<int> es(n);
for (int i = 0; i <= n - 1; i++) es[i] = p[i].second;
sort(es.begin(), es.end());
long long res = 0;
for (int i = 0; i <= n - 1; i++) {
int pp1 = lower_bound(es.begin(), es.end(), p[i].second) - es.begin() + 1;
int pp2 = upper_bound(es.begin(), es.end(), p[i].second) - es.begin() + 1;
res += sum(d, pp2 - 1) * p[i].first - sum(e, pp2 - 1);
add(d, pp1, 1);
add(e, pp1, p[i].first);
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
int II() {
int q;
scanf("%d", &q);
return q;
}
long long LII() {
long long q;
scanf("%lld", &q);
return q;
}
const long long Mx = 200005;
long long N;
vector<long long> tree[Mx * 4], cum[Mx * 4];
vector<pair<long long, long long> > v(Mx + 1);
void update(long long node, long long b, long long e) {
if (b == e) {
tree[node].push_back(v[b].first);
cum[node].push_back(v[b].first);
return;
}
update((node * 2), b, (b + e) / 2);
update((node * 2) + 1, (b + e) / 2 + 1, e);
for (auto it : tree[(node * 2)]) tree[node].push_back(it);
for (auto it : tree[(node * 2) + 1]) tree[node].push_back(it);
sort(tree[node].begin(), tree[node].end());
cum[node] = tree[node];
for (long long i = cum[node].size() - 2; i >= 0; i--) {
cum[node][i] += cum[node][i + 1];
}
}
long long query(long long node, long long b, long long e, long long l,
long long r, long long val) {
if (r < l) return 0;
if (b > r or e < l) return 0;
if (b >= l and e <= r) {
long long up = upper_bound(tree[node].begin(), tree[node].end(), val) -
tree[node].begin();
if (up == tree[node].size()) return 0;
long long q = tree[node].size() - up;
return cum[node][up] - ((q * val));
}
return query((node * 2), b, (b + e) / 2, l, r, val) +
query((node * 2) + 1, (b + e) / 2 + 1, e, l, r, val);
}
void solve() {
cin >> N;
for (long long i = 1; i <= N; i++) cin >> v[i].first;
for (long long i = 1; i <= N; i++) cin >> v[i].second;
sort(v.begin() + 1, v.begin() + 1 + N,
[](pair<long long, long long> a, pair<long long, long long> b) {
if (a.second == b.second) return a.first < b.first;
return a.second < b.second;
});
update(1, 1, N);
long long ans = 0;
for (long long i = 1; i <= N; i++) {
ans += query(1, 1, N, i + 1, N, v[i].first);
}
cout << ans << endl;
}
int32_t main() {
long long tt;
tt = 1;
long long cas = 1;
while (tt--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using db = double;
using vi = vector<int>;
const int inf = 0x3f3f3f3f;
const db eps = 1e-8;
const int mod = 1e9 + 7;
ll qpow(ll a, ll b) {
ll ret = 1;
while (a) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
int n, m, k;
vector<pii> a;
const int maxn = 2e5 + 7;
struct node {
ll b[maxn];
void update(int i, ll v) {
for (; i < maxn; i += (i & -i)) b[i] += v;
}
ll query(int i) {
ll ret = 0;
for (; i > 0; i -= (i & -i)) ret += b[i];
return ret;
}
} bit1, bit2;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
a.resize(n);
vector<ll> co(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
}
for (int i = 0; i < n; i++) {
cin >> a[i].second;
co[i] = a[i].second;
}
sort(co.begin(), co.end());
sort(a.begin(), a.end());
co.erase(unique(co.begin(), co.end()), co.end());
for (int i = 0; i < n; i++)
a[i].second =
lower_bound(co.begin(), co.end(), a[i].second) - co.begin() + 1;
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += bit2.query(a[i].second) * a[i].first - bit1.query(a[i].second);
bit1.update(a[i].second, a[i].first);
bit2.update(a[i].second, 1);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200010;
const long long N = 200000;
long long n;
struct Node {
long long v, x;
bool operator<(const Node& b) const { return x < b.x; }
} p[maxn];
struct BIT {
long long b[maxn];
inline long long lowbit(long long x) { return x & (-x); }
void update(long long x, long long v) {
for (long long i = x; i <= N; i += lowbit(i)) b[i] += v;
}
long long query(long long x) {
long long ans = 0;
for (long long i = x; i > 0; i -= lowbit(i)) ans += b[i];
return ans;
}
} a, b;
long long tot[maxn], len[maxn];
long long c[maxn], l[maxn];
map<long long, long long> mm;
long long ans;
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> p[i].x;
for (long long i = 1; i <= n; i++) cin >> p[i].v, mm[p[i].v]++;
long long id = 0;
for (map<long long, long long>::iterator it = mm.begin(); it != mm.end();
it++)
it->second = ++id;
for (long long i = 1; i <= n; i++) p[i].v = mm[p[i].v];
sort(p + 1, p + n + 1);
for (long long i = 1; i <= n; i++) {
ans += a.query(p[i].v) * p[i].x - b.query(p[i].v);
a.update(p[i].v, 1);
b.update(p[i].v, p[i].x);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int N = 2e5 + 2;
const int inf = 2e9;
const long long linf = 4e18;
long long val[N], cnt[N];
void upd(int x, long long v) {
int z = 0;
if (v < 0)
z--;
else
z++;
for (; x < N; x += x & (-x)) {
cnt[x] += z;
val[x] += v;
}
}
array<long long, 2> get(int x) {
array<long long, 2> data;
data = {0, 0};
for (; x > 0; x -= x & (-x)) {
data[0] += cnt[x];
data[1] += val[x];
}
return data;
}
array<long long, 2> get2(int x) {
array<long long, 2> a = get(N - 1);
array<long long, 2> b = get(x - 1);
return {a[0] - b[0], a[1] - b[1]};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
int n;
cin >> n;
vector<array<long long, 2>> data(n), v(n);
for (int i = 0; i < n; i++) cin >> data[i][0];
for (int i = 0; i < n; i++) {
cin >> data[i][1];
v[i] = {data[i][1], i};
}
sort(v.begin(), v.end());
int h = 0;
data[v[0][1]][1] = ++h;
for (int i = 1; i < n; i++) {
data[v[i][1]][1] = h;
if (v[i][0] != v[i - 1][0]) data[v[i][1]][1] = ++h;
}
sort(data.begin(), data.end());
for (int i = 0; i < n; i++) {
upd(data[i][1], data[i][0]);
}
long long ans = 0;
for (int i = 0; i < n; i++) {
upd(data[i][1], -data[i][0]);
array<long long, 2> d = get2(data[i][1]);
ans += d[1] - (d[0] * data[i][0]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct fen {
vector<T> fenwick;
long long size;
fen(long long sz) {
size = sz;
fenwick.resize(size);
for (long long i = 0; i < size; i++) fenwick[i] = 0;
}
fen(vector<T> arr) {
size = arr.size();
fenwick.resize(size);
for (long long i = 0; i < size; i++) fenwick[i](0);
for (long long i = 0; i < size; i++) update(i, arr[i]);
}
void add(long long index, T add) {
for (long long k = index; k < size; k |= (~k & -~k)) {
fenwick[k] = fenwick[k] + add;
}
}
void update(long long index, T nval) {
add(index, nval - rangeQuery(index, index));
}
T query(long long to) {
if (to < 0) return 0;
T sum = 0;
for (long long curr = to + 1; curr > 0; curr ^= (curr & -curr)) {
sum = sum + fenwick[curr - 1];
}
return sum;
}
T rangeQuery(long long from, long long to) {
if (from > to) return 0;
if (!from) return query(to);
return query(to) - query(from - 1);
}
void prll() {
for (long long i = 0; i < size; i++) cout << query(i) << " ";
cout << endl;
}
};
const long long sz = 2e5 + 5;
long long n;
pair<long long, long long> xv[sz];
vector<int> tmp;
map<int, int> rkspeed;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) cin >> xv[i].first;
for (long long i = 0; i < n; i++) cin >> xv[i].second;
sort(xv, xv + n);
for (long long i = 0; i < n; i++) tmp.push_back(xv[i].second);
sort(tmp.begin(), tmp.end());
vector<int> t2{tmp[0]};
for (long long i = 1; i < n; i++) {
if (tmp[i] != t2.back()) t2.push_back(tmp[i]);
}
for (long long i = 0; i < t2.size(); i++) rkspeed[t2[i]] = i;
fen<int> fcnt(n);
fen<long long> sums(n);
long long tot = 0;
for (long long i = 0; i < n; i++) {
int mrk = rkspeed[xv[i].second];
long long bamt = fcnt.query(mrk);
tot += bamt * xv[i].first - sums.query(mrk);
fcnt.add(mrk, 1);
sums.add(mrk, xv[i].first);
}
cout << tot;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int get(vector<long long int> &arr, long long int ind,
long long int n) {
long long int ans = 0;
for (; ind > 0; ind -= (ind & (-ind))) ans += arr[ind];
return ans;
}
void upd(vector<long long int> &arr, long long int ind, long long int x,
long long int n) {
for (; ind <= n; ind += (ind & (-ind))) arr[ind] += x;
}
int main() {
long long int n;
cin >> n;
pair<long long int, long long int> arr[n];
for (long long int i = 0; i < n; i++) cin >> arr[i].first;
for (long long int i = 0; i < n; i++) cin >> arr[i].second;
vector<int> vec(n);
for (long long int i = 0; i < n; i++) vec.push_back(arr[i].second);
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
vector<long long int> cnt(vec.size() + 1), cs(vec.size() + 1);
sort(arr, arr + n);
long long int ans = 0;
long long int n1 = vec.size();
for (long long int i = 0; i < n; i++) {
long long int pos =
lower_bound(vec.begin(), vec.end(), arr[i].second) - vec.begin();
ans += get(cnt, pos + 1, n1) * arr[i].first - get(cs, pos + 1, n1);
upd(cnt, pos + 1, 1, n1);
upd(cs, pos + 1, arr[i].first, n1);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
long double pi = acos(-1.0);
const int mod = 1e9 + 7;
using namespace std;
const int N = 2e5 + 5;
vector<long long> F(N), F2(N);
long long sum(int r, vector<long long> &t) {
long long result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
void inc(int i, long long delta, vector<long long> &t) {
for (; i < N; i = (i | (i + 1))) t[i] += delta;
}
long long sum(int l, int r, vector<long long> &t) {
return sum(r, t) - sum(l - 1, t);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(20);
cout.setf(ios::fixed);
int n;
cin >> n;
vector<pair<int, int> > pts(n);
for (int(i) = 0; (i) < n; (i)++) {
cin >> pts[i].first;
}
vector<int> vv;
for (int(i) = 0; (i) < n; (i)++) {
cin >> pts[i].second;
vv.push_back(pts[i].second);
}
sort((vv).begin(), (vv).end());
vv.resize(unique((vv).begin(), (vv).end()) - vv.begin());
for (int(i) = 0; (i) < n; (i)++) {
pts[i].second =
lower_bound((vv).begin(), (vv).end(), pts[i].second) - vv.begin();
}
sort((pts).begin(), (pts).end());
for (int(i) = 0; (i) < n; (i)++) {
inc(pts[i].second, pts[i].first, F);
inc(pts[i].second, 1, F2);
}
long long ans = 0;
for (int(i) = 0; (i) < n; (i)++) {
int v = pts[i].second;
inc(v, -pts[i].first, F);
inc(v, -1, F2);
long long sum1 = sum(v, N - 1, F);
long long cnt = sum(v, N - 1, F2);
ans += sum1 - cnt * (long long)pts[i].first;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
using namespace chrono;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long int advceil(long long int num, long long int den) {
return (num % den == 0 ? num / den : num / den + 1);
}
long long int lstbt(long long int val) {
long long int msk = val & (val - 1);
return log2(val ^ msk);
}
long long int modmul(long long int a, long long int b) {
a %= 1000000007;
b %= 1000000007;
long long int res = 0;
while (b > 0) {
if (b & 1) res = (res + a) % 1000000007;
a = (a * 2) % 1000000007;
b /= 2;
}
return res;
}
long long int modexpo(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = modmul(res, a);
a = modmul(a, a);
b /= 2;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return a == 0 ? b : gcd(b % a, a);
}
vector<long long int> CALCfactor(long long int n) {
vector<long long int> factor(n + 2, 0);
for (long long int i = 4; i <= n; i += 2) factor[i] = 2;
for (long long int j = 3; j <= n; j += 2) {
if (factor[j]) continue;
for (long long int i = 2 * j; i <= n; i += j) factor[i] = j;
}
return factor;
}
vector<long long int> CALCprimeNUM(long long int n) {
vector<long long int> factor = CALCfactor(n);
vector<long long int> primeNUM;
primeNUM.reserve(n + 2);
for (long long int i = 2; i <= n; i++)
if (!factor[i]) primeNUM.push_back(i);
return primeNUM;
}
vector<long long int> CALCprimeFACTOR(long long int n) {
vector<long long int> factor = CALCfactor(n);
vector<long long int> ans;
while (factor[n] != 0) {
ans.push_back(factor[n]);
n /= factor[n];
}
if (n > 1) ans.push_back(n);
return ans;
}
vector<long long int> unique(vector<long long int> x) {
sort(x.begin(), x.end());
set<long long int> s;
vector<long long int> ans;
ans.reserve(x.size());
for (auto elem : x) s.insert(elem);
for (auto elem : s) ans.push_back(elem);
return ans;
}
pair<vector<long long int>, vector<long long int> > getFact(long long int n) {
vector<long long int> fact(n + 1, 1), invfact(n + 1, 1);
for (long long int i = 1; i <= n; i++)
fact[i] = (i * (fact[i - 1])) % 1000000007;
for (long long int i = 1; i <= n; i++)
invfact[i] = (modexpo(i, 1000000007 - 2) * invfact[i - 1]) % 1000000007;
return {fact, invfact};
}
long long int BIT[300001][2] = {};
long long int N;
void update(long long int idx, long long int val, long long int typ) {
for (long long int i = idx; i <= N; i += (i & (-i))) BIT[i][typ] += val;
}
long long int query(long long int idx, long long int typ) {
long long int res = 0;
for (long long int i = idx; i > 0; i -= (i & (-i))) res += BIT[i][typ];
return res;
}
long long int sum(long long int l, long long int r, long long int typ) {
return query(r, typ) - query(l - 1, typ);
}
map<long long int, long long int> fmap;
void solve() {
long long int n;
cin >> n;
vector<pair<long long int, long long int> > arr;
arr.resize(n);
for (long long int i = 0; i < n; i++) cin >> arr[i].first;
for (long long int i = 0; i < n; i++) cin >> arr[i].second;
sort(arr.begin(), arr.end());
vector<long long int> temp;
temp.reserve(n);
for (auto elem : arr) temp.push_back(elem.second);
long long int cnt = 1;
sort(temp.begin(), temp.end());
for (auto elem : temp) {
fmap[elem] = cnt;
cnt++;
}
N = cnt;
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
long long int c1 = sum(1, fmap[arr[i].second], 0);
c1 = (arr[i].first * sum(1, fmap[arr[i].second], 1) - c1);
ans += (c1);
update(fmap[arr[i].second], arr[i].first, 0);
update(fmap[arr[i].second], 1, 1);
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
auto start1 = high_resolution_clock::now();
solve();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
}
|
#include <bits/stdc++.h>
using namespace std;
struct Point {
long long x;
long long v;
};
vector<Point> points;
long long SUM;
void add_pairwise_dist(long long start, long long end) {
int m, i, j;
if (start == end) return;
m = start + (end - start) / 2;
add_pairwise_dist(start, m);
add_pairwise_dist(m + 1, end);
vector<long long> rcumsum(end - start + 2);
for (i = end; i >= start; i--) {
rcumsum[i - start] = rcumsum[i - start + 1] + points[i].x;
}
j = m + 1;
for (i = start; i <= m; i++) {
while (j <= end && points[i].v > points[j].v) j++;
if (j > end) break;
SUM += rcumsum[j - start] - points[i].x * (end - j + 1);
}
vector<Point> temp(end - start + 1);
i = start;
j = m + 1;
for (int k = 0; k < end - start + 1; k++) {
if (i > m) {
temp[k] = points[j++];
} else if (j > end) {
temp[k] = points[i++];
} else if (points[i].v < points[j].v) {
temp[k] = points[i++];
} else {
temp[k] = points[j++];
}
}
for (int k = 0; k < end - start + 1; k++) {
points[start + k] = temp[k];
}
}
int main() {
int n;
cin >> n;
points.resize(n);
for (int i = 0; i < n; i++) cin >> points[i].x;
for (int i = 0; i < n; i++) cin >> points[i].v;
sort(points.begin(), points.end(),
[](const Point &a, Point const &b) { return a.x < b.x; });
add_pairwise_dist(0, n - 1);
cout << SUM << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
int x[N + 5], v[N + 5], _v[N + 5];
pair<int, int> point[N + 5];
template <typename T, int N>
struct Binary_Indexed_Tree {
int n;
T sumv[N + 5];
void init(int _n) {
n = _n;
memset(sumv, 0, (n + 4) * sizeof(T));
}
void build(T A[], int _n) {
init(_n);
for (int i = 1; i <= n; ++i) {
sumv[i] += A[i];
int j = i + (i & -i);
if (j <= n) sumv[j] += sumv[i];
}
}
void add(int p, T k) {
while (p <= n) {
sumv[p] += k;
p += p & -p;
}
}
T sum(int p) {
T res = 0;
while (p) {
res += sumv[p];
p -= p & -p;
}
return res;
}
};
Binary_Indexed_Tree<long long, N> bit, bitr, cbit, cbitr;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", x + i);
for (int i = 1; i <= n; ++i) scanf("%d", v + i);
memcpy(_v, v, sizeof(v));
sort(_v + 1, _v + n + 1);
auto ed = unique(_v + 1, _v + n + 1);
for (int i = 1; i <= n; ++i) {
v[i] = lower_bound(_v + 1, ed, v[i]) - _v;
point[i] = {x[i], v[i]};
}
sort(point + 1, point + n + 1);
bit.init(n);
bitr.init(n);
cbit.init(n);
cbitr.init(n);
for (int i = 1; i <= n; ++i) {
int xi = point[i].first, vi = point[i].second;
bitr.add(vi, xi);
cbitr.add(vi, 1);
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int xi = point[i].first, vi = point[i].second;
bitr.add(vi, -xi);
cbitr.add(vi, -1);
ans += xi * cbit.sum(vi) - bit.sum(vi) + bitr.sum(n) - bitr.sum(vi - 1) -
(cbitr.sum(n) - cbitr.sum(vi - 1)) * xi;
bit.add(vi, xi);
cbit.add(vi, 1);
}
printf("%lld\n", ans / 2);
return 0;
}
|
#include <bits/stdc++.h>
template <class C>
inline void log_c(const C& c) {}
template <class C>
inline int sz(const C& c) {
return static_cast<int>(c.size());
}
using namespace std;
using pii = pair<int, int>;
using num = int64_t;
using pll = pair<num, num>;
const std::string eol = "\n";
using Ft = map<int, pair<int, int64_t>>;
const int max_x = 100000000;
void ft_inc(Ft& ft, int x, const pair<int, int64_t>& p) {
for (; x <= max_x; x |= x + 1) {
ft[x].first += p.first;
ft[x].second += p.second;
}
}
pair<int, int64_t> ft_sum(Ft& ft, int x) {
pair<int, int64_t> res;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res.first += ft[x].first;
res.second += ft[x].second;
}
return res;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<pii> data(n);
for (int k = 0; k < (n); ++k) cin >> data[k].second;
for (int k = 0; k < (n); ++k) cin >> data[k].first;
sort(begin(data), end(data));
Ft ft_slow;
int64_t ans = 0;
for (int k = 0; k < (sz(data)); ++k) {
const auto [v, x] = data[k];
const auto [c_slow, s_slow] = ft_sum(ft_slow, x);
ans += static_cast<int64_t>(x) * c_slow - s_slow;
ft_inc(ft_slow, x, {1, x});
}
cout << ans << eol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, x[N], v[N];
vector<pair<int, int>> p;
long long bit1[N], bit2[N], ans;
void add(int p, int v, long long *bit) {
for (p += 2; p < N; p += p & -p) bit[p] += v;
}
long long query(int p, long long *bit) {
long long r = 0;
for (p += 2; p; p -= p & -p) r += bit[p];
return r;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++) p.push_back({x[i], v[i]});
sort(p.begin(), p.end());
sort(v, v + n);
for (auto &x : p) {
x.second = lower_bound(v, v + n, x.second) - v + 1;
ans += 1ll * x.first * query(x.second, bit1) - query(x.second, bit2);
add(x.second, 1, bit1);
add(x.second, x.first, bit2);
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
void dout() { cerr << '\n'; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << " " << H;
dout(T...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 7;
int n, m, cnt[N];
long long sum[N];
pair<int, int> p[N];
void upd(int x, int y) {
for (; x <= m; x |= (x + 1)) {
cnt[x]++;
sum[x] += y;
}
}
int getnum(int x) {
int res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += cnt[x];
}
return res;
}
long long getsum(int x) {
long long res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += sum[x];
}
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
cin >> n;
vector<int> vec;
for (int i = 1; i <= n; i++) {
cin >> p[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> p[i].second;
vec.push_back(p[i].second);
}
sort((vec).begin(), (vec).end());
map<int, int> ind;
for (int i = 1; i <= n; i++) {
if (!ind.count(vec[i - 1])) {
ind[vec[i - 1]] = ++m;
}
}
for (int i = 1; i <= n; i++) {
p[i].second = ind[p[i].second];
}
sort(p + 1, p + n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += (long long)getnum(p[i].second) * p[i].first - getsum(p[i].second);
upd(p[i].second, p[i].first);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, inf = 1e9;
const long long mod = (long long)1e9 + 7;
set<int> setV;
map<int, int> idV;
pair<int, int> p[N];
int n;
int treenum[N], num;
long long treesum[N], sum;
long long qry(long long tree[], int id) {
long long ans = 0LL;
for (; id; id -= (id & (-id))) ans += tree[id];
return ans;
}
int qry(int tree[], int id) {
int ans = 0LL;
for (; id; id -= (id & (-id))) ans += tree[id];
return ans;
}
int GetNum(int v) { return num - qry(treenum, idV[v] - 1); }
long long GetSum(int v) { return sum - qry(treesum, idV[v] - 1); }
void upd(int tree[], int id, int val) {
for (; id < N; id += (id & -id)) tree[id] += val;
}
void upd(long long tree[], int id, int val) {
for (; id < N; id += (id & -id)) tree[id] += val;
}
void Update(int v, int x) {
upd(treenum, idV[v], +1);
upd(treesum, idV[v], +x);
num++;
sum += x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> p[i].first;
}
for (int i = 1; i <= n; ++i) {
cin >> p[i].second;
setV.insert(p[i].second);
}
sort(p + 1, p + n + 1);
int k = 0;
for (int x : setV) idV[x] = ++k;
num = 0;
sum = 0LL;
long long ans = 0LL;
for (int i = n; i >= 1; --i) {
int m = GetNum(p[i].second);
long long y = GetSum(p[i].second);
ans += y - 1LL * m * p[i].first;
Update(p[i].second, p[i].first);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long mod) {
if (b == 0 || a == 1) {
if (mod == 1)
return 0;
else
return 1;
}
if (b % 2 == 0) {
long long k = powmod(a, b / 2, mod);
return (k * k) % mod;
} else {
long long k = powmod(a, b / 2, mod);
return ((k * k) % mod * a) % mod;
}
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
if (a > b)
return gcd(a % b, b);
else
return gcd(b % a, a);
}
long long prime(long long p) {
for (long long i = 2; i * i <= p; i++) {
if (p % i == 0 && i < p) return i;
}
return 1;
}
long long inv(long long a, long long mod) { return powmod(a, mod - 2, mod); }
long long tree[1000000];
long long sum1(long long v, long long tl, long long tr, long long l,
long long r) {
if (l > r) return 0;
if (l == tl && r == tr) return tree[v];
long long tm = (tl + tr) / 2;
return sum1(2 * v, tl, tm, l, min(r, tm)) +
sum1(2 * v + 1, tm + 1, tr, max(l, tm + 1), r);
}
void update(long long v, long long tl, long long tr, long long pos,
long long new_val) {
if (tl == tr)
tree[v] += new_val;
else {
long long tm = (tl + tr) / 2;
if (pos <= tm)
update(v * 2, tl, tm, pos, new_val);
else
update(v * 2 + 1, tm + 1, tr, pos, new_val);
tree[v] = tree[v * 2] + tree[v * 2 + 1];
}
}
long long tree2[1000000];
long long sum2(long long v, long long tl, long long tr, long long l,
long long r) {
if (l > r) return 0;
if (l == tl && r == tr) return tree2[v];
long long tm = (tl + tr) / 2;
return sum2(2 * v, tl, tm, l, min(r, tm)) +
sum2(2 * v + 1, tm + 1, tr, max(l, tm + 1), r);
}
void update2(long long v, long long tl, long long tr, long long pos,
long long new_val) {
if (tl == tr)
tree2[v] += new_val;
else {
long long tm = (tl + tr) / 2;
if (pos <= tm)
update2(v * 2, tl, tm, pos, new_val);
else
update2(v * 2 + 1, tm + 1, tr, pos, new_val);
tree2[v] = tree2[v * 2] + tree2[v * 2 + 1];
}
}
void solve() {
long long a;
cin >> a;
vector<pair<long long, long long>> m(a);
for (long long i = 0; i < a; i++) cin >> m[i].first;
for (long long i = 0; i < a; i++) cin >> m[i].second;
sort(m.begin(), m.end());
long long ans = 0;
long long sum = 0;
long long col = 0;
vector<long long> copy(a);
for (long long i = 0; i < a; i++) copy[i] = m[i].second;
sort(copy.begin(), copy.end());
map<long long, long long> zamena;
for (long long i = 0; i < a; i++) zamena[copy[i]] = i;
for (long long i = 0; i < a; i++) m[i].second = zamena[m[i].second];
long long cur = 0;
for (long long i = 0; i < a; i++)
if (m[i].second > cur) {
update2(1, 1, 200000, m[i].second, m[i].first);
update(1, 1, 200000, m[i].second, 1);
}
for (long long i = 0; i < a; i++) {
if (m[i].second > cur) {
ans += m[i].first * col - sum;
ans += sum2(1LL, 1LL, 200000LL, m[i].second, 200000LL) -
sum1(1LL, 1LL, 200000LL, m[i].second, 200000LL) * m[i].first;
update(1, 1, 200000, m[i].second, -1);
update2(1, 1, 200000, m[i].second, -m[i].first);
} else {
col++;
sum += m[i].first;
}
}
cout << ans << " ";
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tututu;
tututu = 1;
for (long long qwerty = 0; qwerty < tututu; qwerty++) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int max(long long int a, long long int b) {
if (a > b)
return a;
else
return b;
}
long long int min(long long int a, long long int b) {
if (a < b)
return a;
else
return b;
}
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
int XX[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int YY[] = {-1, 0, 1, -1, 1, -1, 0, 1};
long long int fen1[200005] = {0};
long long int maxi = 200003;
void update1(long long int ind, long long int val) {
for (long long int i = ind; i <= maxi; i += i & -i) fen1[i] += val;
}
long long int sum1(long long int ind) {
long long int s = 0;
for (long long int i = ind; i; i -= i & -i) s += fen1[i];
return s;
}
long long int fen2[200005] = {0};
void update2(long long int ind, long long int val) {
for (long long int i = ind; i <= maxi; i += i & -i) fen2[i] += val;
}
long long int sum2(long long int ind) {
long long int s = 0;
for (long long int i = ind; i; i -= i & -i) s += fen2[i];
return s;
}
void convert(long long int arr[], long long int n) {
long long int temp[n];
memcpy(temp, arr, n * sizeof(long long int));
sort(temp, temp + n);
unordered_map<long long int, long long int> umap;
long long int val = 1;
for (long long int i = 0; i < n; i++) umap[temp[i]] = val++;
for (long long int i = 0; i < n; i++) arr[i] = umap[arr[i]];
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int i, j, n, k, x, v;
cin >> n;
long long int arr1[n];
for (i = 0; i < n; i++) {
cin >> arr1[i];
}
long long int arr2[n];
for (i = 0; i < n; i++) {
cin >> arr2[i];
}
convert(arr2, n);
vector<pair<long long int, long long int> > vec;
for (i = 0; i < n; i++) {
vec.push_back(make_pair(arr1[i], arr2[i]));
}
sort(vec.begin(), vec.end());
long long int ans = 0;
for (i = 0; i < vec.size(); i++) {
x = vec[i].first;
v = vec[i].second;
update1(v, 1);
update2(v, x);
}
for (i = vec.size() - 1; i >= 0; i--) {
x = vec[i].first;
v = vec[i].second;
update1(v, -1);
update2(v, -x);
long long int z = sum2(v);
long long int count = sum1(v);
ans += (x * count - z);
}
cout << ans;
}
|
#include <bits/stdc++.h>
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T lcm(T a, T b) {
return a / __gcd(a, b) * b;
}
const long long mod = 1e9 + 7, oo = 1e12, N = 2e5 + 5;
using namespace std;
long long n, b[N], res, bit1[N], bit2[N];
pair<long long, long long> a[N];
inline long long lowbit(long long x) { return x & -x; }
void update(long long pos, long long val, long long *arr) {
while (pos <= n) {
arr[pos] += val;
pos += lowbit(pos);
}
}
long long get(long long pos, long long *arr) {
long long ret = 0;
while (pos > 0) {
ret += arr[pos];
pos -= lowbit(pos);
}
return ret;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n;
for (__typeof(n - 1) i = (0); i <= (n - 1); ++i) cin >> a[i].first;
for (__typeof(n - 1) i = (0); i <= (n - 1); ++i) {
cin >> a[i].second;
b[i] = a[i].second;
}
sort(b, b + n);
for (__typeof(n - 1) i = (0); i <= (n - 1); ++i)
a[i].second = lower_bound(b, b + n, a[i].second) - b + 1;
sort(a, a + n);
for (__typeof(n - 1) i = (0); i <= (n - 1); ++i) {
long long tmp1 = get(a[i].second, bit1);
long long tmp2 = get(a[i].second, bit2);
res += a[i].first * tmp1 - tmp2;
update(a[i].second, 1, bit1);
update(a[i].second, a[i].first, bit2);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
struct FenwickTree {
vector<long long> bit;
long long n;
vector<long long> cnt;
FenwickTree(long long n) {
this->n = n;
bit.assign(n, 0);
cnt.assign(n, 0);
}
FenwickTree(vector<long long> a) : FenwickTree(a.size()) {
for (size_t i = 0; i < a.size(); i++) add(i, a[i]);
}
pair<long long, long long> sum(long long r) {
long long ret = 0;
long long t = r;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
long long ret2 = 0;
r = t;
for (; r >= 0; r = (r & (r + 1)) - 1) ret2 += cnt[r];
return {ret, ret2};
}
pair<long long, long long> sum(long long l, long long r) {
auto j = sum(r);
auto j2 = sum(l - 1);
return {j.first - j2.first, j.second - j2.second};
}
void add(long long idx, long long delta) {
long long t = idx;
for (; idx < n; idx = idx | (idx + 1)) bit[idx] += delta;
idx = t;
for (; idx < n; idx = idx | (idx + 1)) cnt[idx] += 1;
}
};
FenwickTree ft(1000005);
map<long long, long long> compress;
signed main() {
ios_base::sync_with_stdio(0);
long long TESTS = 1;
while (TESTS--) {
long long n;
cin >> n;
long long x[n];
for (long long i = 0; i < n; i++) cin >> x[i];
long long v[n];
for (long long i = 0; i < n; i++) cin >> v[i];
set<long long> vv;
for (long long i = 0; i < n; i++) {
vv.insert(abs(v[i]));
}
long long i = 0;
for (auto j : vv) {
if (j == 0)
compress[j] = 0;
else {
compress[j] = i + 1;
i++;
}
}
for (long long i = 0; i < n; i++) {
if (v[i] >= 0)
v[i] = compress[v[i]];
else
v[i] = -compress[-v[i]];
}
vector<pair<long long, long long>> ve;
for (long long i = 0; i < n; i++) ve.push_back({x[i], v[i]});
sort((ve).begin(), (ve).end());
for (long long i = 0; i < n; i++) {
x[i] = ve[i].first;
v[i] = ve[i].second;
}
long long left = 0, right = 0;
long long cntl = 0, cntr = 0;
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (v[i] > 0) {
ans += x[i] * cntl - left;
} else if (v[i] < 0) {
cntl++;
left += x[i];
}
}
for (long long i = 0; i < n; i++) {
if (v[i] >= 0) {
ans += ft.sum(0, v[i]).second * x[i] - ft.sum(0, v[i]).first;
ft.add(v[i], x[i]);
}
}
for (long long i = 0; i < 1000005; i++) {
ft.bit[i] = 0;
ft.cnt[i] = 0;
}
for (long long i = 0; i < n; i++) {
if (v[i] <= 0) {
v[i] = -v[i];
ans +=
ft.sum(v[i], 1000000).second * x[i] - ft.sum(v[i], 1000000).first;
ft.add(v[i], x[i]);
}
}
long long sum = 0;
long long cnt = 0;
for (long long i = 0; i < n; i++) {
if (v[i] == 0) {
ans -= cnt * x[i] - sum;
sum += x[i];
cnt++;
}
}
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> o[(int)2e5 + 10];
long long n, ts[(int)2e5 + 10], tc[(int)2e5 + 10];
int main(void) {
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &o[i].second);
}
for (int i = 0; i < n; i++) {
scanf("%lld", &o[i].first);
}
sort(o, o + n);
for (int i = 0; i < n; i++) {
o[i] = {o[i].second, i + 1};
}
sort(o, o + n);
long long ans = 0;
for (int i = n - 1; - 1 < i; i--) {
long long l = o[i].second - 1, r = n, idx = o[i].first;
long long s = 0, c = 0;
while (0 < r) {
s += ts[r];
c += tc[r];
r -= (r & -r);
}
while (0 < l) {
s -= ts[l];
c -= tc[l];
l -= (l & -l);
}
ans += s - c * idx;
int v = o[i].second;
while (v <= n) {
ts[v] += idx;
tc[v]++;
v += (v & -v);
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 7;
int n;
vector<pair<int, int>> p;
vector<int> vv1;
long long get(vector<long long> &f, int pos) {
long long res = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
res += f[pos];
}
return res;
}
void upd(vector<long long> &f, int pos, int val) {
for (; pos < f.size(); pos |= pos + 1) f[pos] += val;
}
int main() {
scanf("%d", &n);
p.resize(n);
for (int i = 0; i < n; i++) scanf("%d", &p[i].first);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i].second);
vv1.push_back(p[i].second);
}
sort(vv1.begin(), vv1.end());
vv1.resize(unique(vv1.begin(), vv1.end()) - vv1.begin());
sort(p.begin(), p.end());
long long ans = 0;
vector<long long> tmpv1(vv1.size()), tmpv2(vv1.size());
for (int i = 0; i < n; i++) {
int pos = lower_bound(vv1.begin(), vv1.end(), p[i].second) - vv1.begin();
ans += get(tmpv1, pos) * 1ll * p[i].first - get(tmpv2, pos);
upd(tmpv1, pos, 1);
upd(tmpv2, pos, p[i].first);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
const int NN = 1e3 + 1;
const long long MOD = 1e9 + 7;
const long long oo = 1e18 + 7;
const int BASE = 10000;
void solve() {
int n;
cin >> n;
vector<int> x(n + 1);
for (int i = 1; i <= n; i++) {
cin >> x[i];
}
vector<int> v(n + 1);
for (int i = 1; i <= n; i++) {
cin >> v[i];
}
vector<int> pos(n + 1);
iota(1 + (pos).begin(), (pos).end(), 1);
sort(1 + (pos).begin(), (pos).end(),
[&](int a, int b) { return x[a] < x[b]; });
vector<int> val = v;
sort(1 + (val).begin(), (val).end());
val.resize(unique((val).begin(), (val).end()) - val.begin());
map<int, int> Pos;
for (int i = 1; i < val.size(); i++) {
Pos[val[i]] = i;
}
vector<pair<long long, long long> > BIT(val.size());
auto update = [&](int pos, int _val) {
for (int i = pos; i < BIT.size(); i += i & -i) {
BIT[i].first += 1LL * _val;
BIT[i].second++;
}
};
auto get = [&](int pos) {
long long res = 0, cnt = 0;
for (int i = pos; i; i -= i & -i) {
res += BIT[i].first;
cnt += BIT[i].second;
}
pair<long long, long long> t = {res, cnt};
return t;
};
long long res = 0;
for (int i = 1; i <= n; i++) {
pair<long long, long long> cur = get(Pos[v[pos[i]]]);
res += x[pos[i]] * cur.second - cur.first;
update(Pos[v[pos[i]]], x[pos[i]]);
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(10);
solve();
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long BIT[515151];
int BIT2[515151];
map<int, int> hs;
void update(int x, int y) {
for (int i = x; i <= 5e5; i += (i & (-i))) BIT[i] += y, BIT2[i]++;
}
long long query(int x) {
long long tmp = 0;
for (int i = x; i >= 1; i -= (i & (-i))) tmp += BIT[i];
return tmp;
}
long long query2(int x) {
int tmp = 0;
for (int i = x; i >= 1; i -= (i & (-i))) tmp += BIT2[i];
return tmp;
}
int main() {
scanf("%d", &n);
int x[n + 5], v[n + 5];
for (int i = 0; i < n; i++) {
scanf("%d", &x[i]);
}
vector<int> tmp;
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
tmp.push_back(v[i]);
}
sort(tmp.begin(), tmp.end());
int idx = 1;
for (auto i : tmp) {
hs[i] = idx;
idx++;
}
for (int i = 0; i < n; i++) {
v[i] = hs[v[i]];
}
vector<pair<int, int> > data;
for (int i = 0; i < n; i++) {
data.push_back(make_pair(x[i], v[i]));
}
sort(data.begin(), data.end());
long long ans = 0;
for (auto i : data) {
long long cnt1 = query(i.second);
long long cnt2 = query2(i.second);
ans += (cnt2 * i.first - cnt1);
update(i.second, i.first);
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200009;
int n, b[N], p[N], tot;
long long c1[N], c2[N];
struct P {
int x, v;
bool operator<(const P &A) const { return x < A.x; }
} a[N];
int lowbit(int x) { return x & (x ^ (x - 1)); }
void add(int x, int k, long long c[]) {
while (x <= tot) {
c[x] += k;
x += lowbit(x);
}
}
long long getsum(int x, long long c[]) {
long long ans = 0;
while (x) {
ans += c[x];
x -= lowbit(x);
}
return ans;
}
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].v);
sort(a + 1, a + 1 + n);
}
void work() {
for (int i = 1; i <= n; i++) p[i] = a[i].v;
sort(p + 1, p + 1 + n);
tot = unique(p + 1, p + 1 + n) - (p + 1);
for (int i = 1; i <= n; i++)
b[i] = lower_bound(p + 1, p + 1 + tot, a[i].v) - p;
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += getsum(b[i], c1) * a[i].x - getsum(b[i], c2);
add(b[i], 1, c1), add(b[i], a[i].x, c2);
}
printf("%lld\n", ans);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
long long positions[maxn], speeds[maxn];
pair<long long, long long> pairs[maxn];
map<long long, long long> m;
bool comp(pair<long long, long long>& a, pair<long long, long long>& b) {
if (a.second == b.second) return a.first < b.first;
return a.second < b.second;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> positions[i];
for (int i = 0; i < n; ++i) cin >> speeds[i];
for (long long i = 0; i < n; ++i) pairs[i] = {positions[i], speeds[i]};
sort(positions, positions + n);
sort(pairs, pairs + n, comp);
long long ans = 0;
for (long long i = 0; i < n; ++i) {
ans += ((2 * i) - n + 1) * positions[i];
m[positions[i]] = i;
}
for (int i = 0; i < n; ++i) ans -= pairs[i].first * (m[pairs[i].first] - i);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> a[200005];
long long sum[1000005], cnt[1000005];
long long querysum(long long pos) {
long long ret = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
ret += sum[pos];
}
return ret;
}
long long querycnt(long long pos) {
long long ret = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
ret += cnt[pos];
}
return ret;
}
void updatesum(long long pos, long long val) {
for (; pos < 1000000; pos |= pos + 1) {
sum[pos] += val;
}
}
void updatecnt(long long pos, long long val) {
for (; pos < 1000000; pos |= pos + 1) {
cnt[pos] += val;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i].first;
for (long long i = 1; i <= n; i++) cin >> a[i].second;
vector<long long> v;
for (long long i = 1; i <= n; i++) {
v.push_back(a[i].second);
}
sort(v.begin(), v.end());
map<long long, long long> num;
for (long long i = 0; i < v.size(); i++) {
num[v[i]] = i;
}
for (long long i = 1; i <= n; i++) {
a[i].second = num[a[i].second];
}
sort(a + 1, a + n + 1);
memset(sum, 0, sizeof(sum));
memset(cnt, 0, sizeof(cnt));
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans += a[i].first * querycnt(a[i].second) - querysum(a[i].second);
updatesum(a[i].second, a[i].first);
updatecnt(a[i].second, 1);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 20;
int n;
pair<int, int> p[N];
struct node {
long long sum, count;
node(long long s = 0, long long c = 0) : sum(s), count(c) {}
} bit[N];
void update(int x, int delta) {
for (; x <= n; x += x & -x) {
auto &[sum, count] = bit[x];
sum += delta;
count++;
}
}
node query(int x) {
auto ans = node();
for (; x > 0; x -= x & -x) {
auto &[sum, count] = bit[x];
ans.sum += sum;
ans.count += count;
}
return ans;
}
int compress(vector<int> &v) {
if (v.empty()) return 0;
vector<int> s = v;
sort(s.begin(), s.end());
s.resize(unique(s.begin(), s.end()) - s.begin());
int mx = 1;
for (int &x : v) {
x = lower_bound(s.begin(), s.end(), x) - s.begin() + 1;
mx = max(mx, x);
}
return mx;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> p[i].first;
for (int i = 0; i < n; i++) cin >> p[i].second;
sort(p, p + n);
vector<int> vec(n);
for (int i = 0; i < n; i++) vec[i] = p[i].second;
compress(vec);
long long ans = 0;
for (int i = 0; i < n; i++) {
auto [sum, cnt] = query(vec[i]);
ans += cnt * p[i].first - sum;
update(vec[i], p[i].first);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long a = 0, b = getchar(), c = 1;
while (!isdigit(b)) c = b == '-' ? -1 : 1, b = getchar();
while (isdigit(b)) a = a * 10 + b - '0', b = getchar();
return a * c;
}
long long n, ans, p[200005];
pair<long long, long long> a[200005];
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i].second = read();
p[i] = a[i].second;
}
for (int i = 1; i <= n; i++) a[i].first = read();
sort(a + 1, a + n + 1);
sort(p + 1, p + n + 1);
for (int i = 1; i <= n; i++)
ans += (lower_bound(p + 1, p + n + 1, a[i].second) - p - n + i - 1) *
a[i].second;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 500;
long long n, t1[N], t2[N];
void upd1(long long val, long long pos) {
while (pos < n) {
t1[pos] += val;
pos = (pos | (pos + 1));
}
}
void upd2(long long val, long long pos) {
while (pos < n) {
t2[pos] += val;
pos = (pos | (pos + 1));
}
}
long long get1(long long pos) {
long long res = 0;
while (pos >= 0) {
res += t1[pos];
pos = (pos & (pos + 1)) - 1;
}
return res;
}
long long get2(long long pos) {
long long res = 0;
while (pos >= 0) {
res += t2[pos];
pos = (pos & (pos + 1)) - 1;
}
return res;
}
int main() {
cin >> n;
vector<pair<long long, long long> > a(n);
vector<long long> comp;
map<long long, long long> new_val;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
}
for (int i = 0; i < n; i++) {
cin >> a[i].second;
comp.push_back(a[i].second);
}
sort(a.begin(), a.end());
sort(comp.begin(), comp.end());
long long k = 0;
new_val[comp[0]] = k;
for (int i = 1; i < comp.size(); i++) {
if (comp[i] != comp[i - 1]) k++;
new_val[comp[i]] = k;
}
for (int i = 0; i < n; i++) {
a[i].second = new_val[a[i].second];
}
long long ans = 0;
for (int i = 0; i < n; i++) {
long long pos = a[i].second;
long long cnt = get1(pos);
long long sum = get2(pos);
ans += ((cnt * a[i].first) - sum);
upd1(1, pos);
upd2(a[i].first, pos);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long int power(long long int x, long long int y) {
long long int ans = 1;
x %= 1000000007;
while (y) {
if (y & 1) ans = (x * ans) % 1000000007;
x = (x * x) % 1000000007;
y >>= 1;
}
return ans;
}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
struct FenwickTree {
vector<long long int> bit;
int n;
FenwickTree(int n) {
this->n = n;
bit.assign(n, 0);
}
FenwickTree(vector<int> a) : FenwickTree(a.size()) {
for (size_t i = 0; i < a.size(); i++) add(i, a[i]);
}
long long int sum(int r) {
long long int ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
return ret;
}
long long int sum(int l, int r) { return sum(r) - sum(l - 1); }
void add(int idx, int delta) {
for (; idx < n; idx = idx | (idx + 1)) bit[idx] += delta;
}
};
void solve() {
long long int n;
cin >> n;
vector<pair<long long int, long long int> > arr(n);
vector<long long int> vel(n);
for (int i = 0; i < n; i++) {
cin >> arr[i].first;
}
for (int i = 0; i < n; i++) {
cin >> arr[i].second;
vel[i] = arr[i].second;
}
sort(arr.begin(), arr.end());
sort(vel.begin(), vel.end());
map<long long int, long long int> mp;
for (int i = 0; i < n; i++) {
long long int in =
lower_bound(vel.begin(), vel.end(), vel[i]) - vel.begin();
mp[vel[i]] = in;
}
long long int ans = 0;
FenwickTree count(n + 10), dist(n + 10);
for (int i = 0; i < n; i++) {
long long int v = mp[arr[i].second];
long long int cnt = count.sum(v);
long long int sum = dist.sum(v);
ans += (cnt * arr[i].first - sum);
count.add(v, 1);
dist.add(v, arr[i].first);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.