text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
template <class T>
T sqr(T a) {
return a * a;
}
struct node {
int x;
long long key, sum;
node *left, *right;
};
typedef node *pnode;
node pool[110000];
int pc;
pnode h[5];
pnode lh[5];
pnode rh[5];
void update(pnode t) {
if (t)
t->sum =
t->key + (t->left ? t->left->sum : 0) + (t->right ? t->right->sum : 0);
}
pnode merge(pnode t1, pnode t2) {
if (!t1) return t2;
if (!t2) return t1;
if (t1->x < t2->x) {
t1->right = merge(t1->right, t2);
update(t1);
return t1;
} else {
t2->left = merge(t1, t2->left);
update(t2);
return t2;
}
}
void split(pnode t, pnode &l, pnode &r, int key) {
if (!t)
l = r = 0;
else if (key < t->key) {
split(t->left, l, t->left, key);
r = t;
} else {
split(t->right, t->right, r, key);
l = t;
}
update(t);
}
void add(pnode &t, pnode pp) {
if (!t)
t = pp;
else if (pp->x > t->x)
add(pp->key < t->key ? t->left : t->right, pp);
else {
split(t, pp->left, pp->right, pp->key);
t = pp;
}
update(t);
}
void remove(pnode &t, int key) {
if (!t) return;
if (t->key != key)
remove(key < t->key ? t->left : t->right, key);
else
t = merge(t->left, t->right);
update(t);
}
long long getmax(pnode t) {
return t->right ? max(t->key, getmax(t->right)) : t->key;
}
int main() {
int q;
cin >> q;
pnode p;
for (int i = 0; i < q; i++) {
string scmd;
cin >> scmd;
if (scmd == "add") {
int arg;
cin >> arg;
int mi = 4, mv = -1;
for (int i = 0; i < 5; i++) {
split(h[i], lh[i], rh[i], arg);
if (lh[i]) {
int cur = getmax(lh[i]);
if (cur > mv) {
mi = i;
mv = cur;
}
}
}
for (int i = 0; i < 5; i++)
h[(i + 1) % 5] = merge(lh[(i + 1) % 5], rh[i]);
pnode pp = &pool[pc++];
pp->key = arg;
pp->x = rand();
pp->sum = arg;
add(h[(mi + 1) % 5], pp);
} else if (scmd == "del") {
int arg;
cin >> arg;
for (int i = 0; i < 5; i++) remove(h[i], arg);
for (int i = 0; i < 5; i++) split(h[i], lh[i], rh[i], arg);
for (int i = 0; i < 5; i++) h[i] = merge(lh[i], rh[(i + 1) % 5]);
} else {
if (h[2])
cout << h[2]->sum << endl;
else
cout << 0 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7, inv2 = (MOD + 1) / 2;
long double eps = 1e-6;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
long double pi = acos(-1.0L);
struct node {
int s;
long long a[5];
} t[100000 + 10 << 2];
struct Q {
int op, x;
} q[100000 + 10];
int c[100000 + 10], n, m, n1;
char s[100000 + 10];
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
long long readll() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
void pushup(int p) {
t[p].s = t[p << 1].s + t[p << 1 | 1].s;
for (int i = (int)0; i <= (int)4; i++)
t[p].a[i] =
t[p << 1].a[i] + t[p << 1 | 1].a[((i - t[p << 1].s) % 5 + 5) % 5];
}
void update(int l, int r, int x, int v, int op, int p) {
if (l == r) {
t[p].s += op;
t[p].a[0] += v;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
update(l, mid, x, v, op, p << 1);
else
update(mid + 1, r, x, v, op, p << 1 | 1);
pushup(p);
}
void init() {
m = read();
n1 = 0;
for (int i = (int)1; i <= (int)m; i++) {
scanf("%s", s + 1);
if (s[1] == 'a') {
int x = read();
c[++n1] = x;
q[i].op = 1;
q[i].x = x;
}
if (s[1] == 'd') {
int x = read();
c[++n1] = x;
q[i].op = -1;
q[i].x = x;
}
if (s[1] == 's') q[i].op = 0;
}
}
void solve() {
sort(c + 1, c + n1 + 1);
int n = unique(c + 1, c + n1 + 1) - c;
for (int i = (int)1; i <= (int)m; i++) {
if (q[i].op) {
int x = lower_bound(c + 1, c + n + 1, q[i].x) - c;
update(1, n, x, q[i].x * q[i].op, q[i].op, 1);
} else
printf("%I64d\n", t[1].a[2]);
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ii {
string cz;
int x, id;
} cz[1000005];
bool cmp1(ii a, ii b) {
if (a.x < b.x) return 1;
if (a.x > b.x) return 0;
return a.cz < b.cz;
}
bool cmp2(ii a, ii b) { return a.id < b.id; }
int n, cnt, zhi[1000005], sz[1000005], i;
long long sum[1000005][5], ans;
map<int, int> mp;
void update(int id, int le, int ri, int pos, int add) {
sz[id] += add;
if (le == pos && ri == pos) {
sum[id][1] += add * zhi[pos];
return;
}
if (pos > (le + ri) / 2)
update(id * 2 + 1, (le + ri) / 2 + 1, ri, pos, add);
else
update(id * 2, le, (le + ri) / 2, pos, add);
int i;
for (i = 0; i < 5; i++) {
sum[id][i] =
sum[id * 2][i] + sum[id * 2 + 1][((i - sz[id * 2] % 5) + 5) % 5];
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> cz[i].cz;
if (cz[i].cz[0] == 's')
cz[i].x = 0;
else
cin >> cz[i].x;
cz[i].id = i;
}
sort(cz + 1, cz + n + 1, cmp1);
cnt = 1;
for (i = 1; i <= n; i++) {
if (cz[i].cz[0] == 'a') {
if (!mp[cz[i].x]) mp[cz[i].x] = cnt++;
zhi[mp[cz[i].x]] = cz[i].x;
cz[i].x = mp[cz[i].x];
} else if (cz[i].cz[0] == 'd') {
cz[i].x = mp[cz[i].x];
}
}
sort(cz + 1, cz + n + 1, cmp2);
for (i = 1; i <= n; i++) {
if (cz[i].cz[0] == 'a')
update(1, 1, cnt, cz[i].x, 1);
else if (cz[i].cz[0] == 'd')
update(1, 1, cnt, cz[i].x, -1);
else
cout << sum[1][3] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = (1LL << 60);
const double pi = acos(-1);
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
inline void pcas(int ca) { printf("Case %d: ", ca); }
const int maxn = 1e5 + 10;
int n, x;
char ch[5];
vector<int> v;
int main() {
scanf("%d", &n);
while (n--) {
scanf("%s", ch);
if (ch[0] == 's') {
int sz = v.size();
long long ans = 0;
for (int i = 2; i < sz; i += 5) {
ans += v[i];
}
printf("%lld\n", ans);
} else {
if (ch[0] == 'a') {
scanf("%d", &x);
v.insert(lower_bound(v.begin(), v.end(), x), x);
} else {
scanf("%d", &x);
v.erase(lower_bound(v.begin(), v.end(), x));
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int x;
char f[10];
vector<int> v;
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%s", f);
if (f[0] == 'a') {
scanf("%d", &x);
v.insert(lower_bound(v.begin(), v.end(), x), x);
} else if (f[0] == 'd') {
scanf("%d", &x);
v.erase(lower_bound(v.begin(), v.end(), x));
} else {
long long sum = 0;
for (int i = 2; i < (int)v.size(); i += 5) {
sum += v[i];
}
printf("%I64d\n", sum);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int maxn = 5005;
const int maxm = 200005;
int Read() {
int x = 0, t = 1;
char c = getchar();
if (c == '-') {
t = -1;
c = getchar();
}
while (c > '9' || c < '0') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return t * x;
}
int n;
vector<int> v;
int main() {
ios_base::sync_with_stdio(false);
int i, j, x;
string t;
cin >> n;
for (i = 0; i < n; i++) {
cin >> t;
if (t == "add") {
cin >> x;
v.insert(lower_bound(v.begin(), v.end(), x), x);
} else if (t == "del") {
cin >> x;
v.erase(lower_bound(v.begin(), v.end(), x));
} else if (t == "sum") {
long long ans = 0;
for (j = 2; j < v.size(); j += 5) ans += v[j];
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long sum[5];
int num;
};
int n, i, j;
int en;
int vale[100005];
int val[100005];
node tree[300005];
long long answer;
char in[100005][10];
void init(int numnode, int treefrom, int treeto) {
int ii;
tree[numnode].num = 0;
for (ii = 0; ii < 5; ii++) {
tree[numnode].sum[ii] = 0;
}
if (treefrom == treeto) return;
int treemid = (treefrom + treeto) / 2;
init(numnode * 2, treefrom, treemid);
init(numnode * 2 + 1, treemid + 1, treeto);
return;
}
void update1(int numnode, int treefrom, int treeto, int pos) {
if (treefrom == treeto) {
tree[numnode].num = 1;
tree[numnode].sum[0] = vale[pos];
return;
} else {
int treemid = (treefrom + treeto) / 2;
if (treemid >= pos) {
update1(numnode * 2, treefrom, treemid, pos);
} else {
update1(numnode * 2 + 1, treemid + 1, treeto, pos);
}
tree[numnode].num = tree[numnode * 2].num + tree[numnode * 2 + 1].num;
int ii;
for (ii = 0; ii < 5; ii++) {
tree[numnode].sum[(tree[numnode * 2].num + ii) % 5] =
tree[numnode * 2].sum[(tree[numnode * 2].num + ii) % 5] +
tree[numnode * 2 + 1].sum[ii];
}
return;
}
}
void update2(int numnode, int treefrom, int treeto, int pos) {
if (treefrom == treeto) {
tree[numnode].num = 0;
tree[numnode].sum[0] = 0;
return;
} else {
int treemid = (treefrom + treeto) / 2;
if (treemid >= pos) {
update2(numnode * 2, treefrom, treemid, pos);
} else {
update2(numnode * 2 + 1, treemid + 1, treeto, pos);
}
tree[numnode].num = tree[numnode * 2].num + tree[numnode * 2 + 1].num;
int ii;
for (ii = 0; ii < 5; ii++) {
tree[numnode].sum[(tree[numnode * 2].num + ii) % 5] =
tree[numnode * 2].sum[(tree[numnode * 2].num + ii) % 5] +
tree[numnode * 2 + 1].sum[ii];
}
return;
}
}
int main() {
scanf("%d", &n);
en = 0;
for (i = 0; i < n; i++) {
scanf("%s", in[i]);
if (in[i][0] == 'a' || in[i][0] == 'd') {
scanf("%d", &val[i]);
vale[en] = val[i];
en++;
}
}
sort(vale, vale + en);
init(1, 0, en);
for (i = 0; i < n; i++) {
if (in[i][0] == 'a') {
update1(1, 0, en, lower_bound(vale, vale + en, val[i]) - vale);
} else if (in[i][0] == 'd') {
update2(1, 0, en, lower_bound(vale, vale + en, val[i]) - vale);
} else {
cout << tree[1].sum[2];
cout << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 300;
long long sum[1000][10];
vector<long long> vec, v[1000];
long long n, ind;
void ok(long long x) {
for (long long i = 0; i < 5; i++) sum[x][i] = 0;
for (long long i = 0; i < v[x].size(); i++) sum[x][i % 5] += v[x][i];
}
void relax() {
vec.clear();
for (long long i = 0; i < ind; i++) {
for (long long j = 0; j < v[i].size(); j++) vec.push_back(v[i][j]);
v[i].clear();
}
ind = 0;
for (long long i = 0; i < vec.size(); i++) {
v[ind].push_back(vec[i]);
if (v[ind].size() >= MAXN) ind++;
}
ind++;
for (long long i = 0; i < ind; i++) ok(i);
}
int main() {
cin >> n;
ind = 1;
for (long long q = 0; q < n; q++) {
string s;
cin >> s;
long long x;
if (s == "add") {
cin >> x;
long long i = 0;
while (i < ind - 1 && v[i].back() < x) i++;
v[i].push_back(x);
long long j = v[i].size() - 1;
while (j > 0 && v[i][j] < v[i][j - 1]) {
swap(v[i][j], v[i][j - 1]);
j--;
}
if (v[i].size() >= 2 * MAXN)
relax();
else
ok(i);
} else if (s == "del") {
cin >> x;
long long i = 0;
while (v[i].back() < x) i++;
for (long long j = 0; j < v[i].size() - 1; j++)
if (v[i][j] >= x) v[i][j] = v[i][j + 1];
v[i].pop_back();
if (v[i].size() == 0 && i < ind - 1)
relax();
else
ok(i);
} else {
long long ans = 0, t = 2;
for (long long i = 0; i < ind; i++) {
ans += sum[i][t];
t = (t - (v[i].size() % 5) + 5) % 5;
}
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct treap {
treap *l, *r;
const int h;
int k, size;
long long sum;
treap(int k) : l(NULL), r(NULL), h(rand()), k(k), sum(0), size(0) { upd(); }
static long long psum(treap *p) { return p ? p->sum : 0; }
static int psize(treap *p) { return p ? p->size : 0; }
void upd() {
sum = psum(l) + psum(r) + k;
size = psize(l) + psize(r) + 1;
}
~treap() {
delete l;
delete r;
}
};
struct t_pair {
treap *l, *r;
t_pair(treap *l = NULL, treap *r = NULL) : l(l), r(r) {}
};
treap *merge(treap *l, treap *r) {
if (!l || !r) return l ? l : r;
if (l->h > r->h) {
l->r = merge(l->r, r);
l->upd();
return l;
} else {
r->l = merge(l, r->l);
r->upd();
return r;
}
}
t_pair split(treap *p, int k) {
if (!p) return t_pair();
if (p->k > k) {
t_pair t = split(p->l, k);
p->l = t.r;
p->upd();
t.r = p;
return t;
} else {
t_pair t = split(p->r, k);
p->r = t.l;
p->upd();
t.l = p;
return t;
}
}
treap *rem(treap *p, int k) {
if (!p)
return NULL;
else if (p->k > k)
p->l = rem(p->l, k), p->upd();
else if (p->k < k)
p->r = rem(p->r, k), p->upd();
else {
treap *t = p;
p = merge(p->l, p->r);
t->l = t->r = NULL;
delete t;
}
return p;
}
int main() {
int _, tmp;
cin >> _;
char op[10];
treap *tree[5];
t_pair t[5];
memset(tree, 0, sizeof(tree));
while (_--) {
scanf("%s", op);
if (op[0] == 'a') {
int pos(1);
scanf("%d", &tmp);
for (int i(0); i != 5; ++i) {
t[i] = split(tree[i], tmp);
pos += treap::psize(t[i].l);
}
for (int i(0); i != 5; ++i) {
if (pos % 5 == i) t[i].l = merge(t[i].l, new treap(tmp));
tree[i] = merge(t[i].l, t[(i + 4) % 5].r);
}
} else if (op[0] == 'd') {
int pos(0);
scanf("%d", &tmp);
for (int i(0); i != 5; ++i) {
t[i] = split(tree[i], tmp);
pos += treap::psize(t[i].l);
}
for (int i(0); i != 5; ++i) {
if (pos % 5 == i) t[i].l = rem(t[i].l, tmp);
tree[i] = merge(t[i].l, t[(i + 1) % 5].r);
}
} else if (op[0] == 's')
cout << treap::psum(tree[3]) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 131072;
void read(int &k) {
char x = getchar();
k = 0;
while (x < '0' || x > '9') x = getchar();
while (x >= '0' && x <= '9') {
k = k * 10 - 48 + x;
x = getchar();
}
}
int n, b[100010], len, pos;
char s[10];
struct qry {
int tp, num;
} a[100010];
struct node {
long long ans[5];
int siz;
};
node join(node a, node b) {
node ret;
ret.siz = a.siz + b.siz;
int ad = a.siz % 5;
for (int i = 0; i < 5; i++) ret.ans[i] = a.ans[i] + b.ans[(5 + i - ad) % 5];
return ret;
}
struct STree {
node c[262145];
void clear() { memset(c, 0, sizeof c); }
void ins(int L, int R, int pos, int now) {
if (L == R) {
c[now].siz++;
c[now].ans[0] = b[pos];
return;
}
int t = (L + R) >> 1;
if (pos > t)
ins(t + 1, R, pos, now * 2 + 1);
else
ins(L, t, pos, now * 2);
c[now] = join(c[now * 2], c[now * 2 + 1]);
}
void del(int L, int R, int pos, int now) {
if (L == R) {
c[now].siz--;
c[now].ans[0] = 0;
return;
}
int t = (L + R) >> 1;
if (pos > t)
del(t + 1, R, pos, now * 2 + 1);
else
del(L, t, pos, now * 2);
c[now] = join(c[now * 2], c[now * 2 + 1]);
}
} xds;
int main() {
while (scanf("%d", &n) > 0) {
len = 0;
xds.clear();
for (int i = 1; i <= n; i++) {
scanf("%s", s);
if (s[0] == 'a')
a[i].tp = 1, scanf("%d", &a[i].num), b[++len] = a[i].num;
else if (s[0] == 's')
a[i].tp = 2;
else if (s[0] == 'd')
a[i].tp = 3, scanf("%d", &a[i].num), b[++len] = a[i].num;
}
sort(b + 1, b + len + 1);
len = unique(b + 1, b + len + 1) - b - 1;
for (int i = 1; i <= n; i++) {
if (a[i].tp == 1) {
pos = lower_bound(b + 1, b + len + 1, a[i].num) - b;
xds.ins(1, len, pos, 1);
} else if (a[i].tp == 2) {
cout << xds.c[1].ans[2] << endl;
} else {
pos = lower_bound(b + 1, b + len + 1, a[i].num) - b;
xds.del(1, len, pos, 1);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000000;
struct Node {
int amount;
long long sum[5];
Node() {
amount = 0;
for (int i = (0); i <= (4); i++) sum[i] = 0;
}
};
const int RIGHT = 131072;
const int SIZE = 263000;
int N, Orig[100005], V[100005];
map<int, int> M;
Node Tree[SIZE];
set<int> S;
string T[100005];
void update(int x, int add, int n, int a, int b) {
if (a > x || b < x) return;
if (a == b) {
if (add) {
Tree[n].amount = 1;
Tree[n].sum[0] = Orig[x];
} else {
Tree[n].amount = 0;
Tree[n].sum[0] = 0;
}
return;
}
int mid = (a + b) / 2;
update(x, add, 2 * n, a, mid);
update(x, add, 2 * n + 1, mid + 1, b);
Tree[n].amount = Tree[2 * n].amount + Tree[2 * n + 1].amount;
for (int i = (0); i <= (4); i++) {
int next_mod = (500000 + i - Tree[2 * n].amount) % 5;
Tree[n].sum[i] = Tree[2 * n].sum[i] + Tree[2 * n + 1].sum[next_mod];
}
}
int main() {
cin >> N;
for (int i = (1); i <= (N); i++) {
cin >> T[i];
if (T[i] != "sum") cin >> V[i];
}
for (int i = (1); i <= (N); i++)
if (T[i] != "sum") S.insert(V[i]);
int c = 0;
for (int k : S) {
M[k] = ++c;
Orig[c] = k;
}
for (int i = (1); i <= (N); i++) {
if (T[i] == "sum")
cout << Tree[1].sum[2] << "\n";
else {
if (T[i] == "add")
update(M[V[i]], 1, 1, 1, RIGHT);
else
update(M[V[i]], 0, 1, 1, RIGHT);
getchar();
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
const long long N = 1e5 + 100;
long long val[N], num, m = 150, blo;
pair<long long, long long> ope[N];
vector<long long> ve;
void myinit() {
cin >> n;
for (long long i = 1; i <= n; i++) {
string ss;
cin >> ss;
if (ss == "add") {
ope[i].first = 1;
cin >> ope[i].second;
ve.push_back(ope[i].second);
} else if (ss == "del") {
ope[i].first = 2;
cin >> ope[i].second;
} else
ope[i].first = 3;
}
sort(ve.begin(), ve.end());
ve.erase(unique(ve.begin(), ve.end()), ve.end());
num = ve.size(), blo = m == 0 ? 0 : ((num - 1) / m + 1);
for (long long i = 1; i <= n; i++)
if (ope[i].first != 3) {
long long tmp = ope[i].second;
ope[i].second =
lower_bound(ve.begin(), ve.end(), ope[i].second) - ve.begin() + 1;
val[ope[i].second] = tmp;
}
}
long long sum[N][5];
set<long long> second[N];
void add(long long x) {
long long p = (x - 1) / m + 1;
long long s = 0;
for (long long i = 1; i <= p - 1; i++) s = (s + second[i].size()) % 5;
second[p].insert(x);
memset(sum[p], 0, sizeof(sum[p]));
long long t = (s + 1) % 5;
for (set<long long>::iterator it = second[p].begin(); it != second[p].end();
it++, t = (t + 1) % 5) {
sum[p][t] += val[*it];
}
for (long long i = p + 1; i <= blo; i++) {
long long tmp = sum[i][4];
for (long long j = 4; j >= 1; j--) sum[i][j] = sum[i][j - 1];
sum[i][0] = tmp;
}
}
void dele(long long x) {
long long p = (x - 1) / m + 1;
long long s = 0;
for (long long i = 1; i <= p - 1; i++) s = (s + second[i].size()) % 5;
second[p].erase(x);
memset(sum[p], 0, sizeof(sum[p]));
long long t = (s + 1) % 5;
for (set<long long>::iterator it = second[p].begin(); it != second[p].end();
it++, t = (t + 1) % 5) {
sum[p][t] += val[*it];
}
for (long long i = p + 1; i <= blo; i++) {
long long tmp = sum[i][0];
for (long long j = 0; j <= 3; j++) sum[i][j] = sum[i][j + 1];
sum[i][4] = tmp;
}
}
signed main() {
myinit();
for (long long i = 1; i <= n; i++) {
if (ope[i].first == 1)
add(ope[i].second);
else if (ope[i].first == 2)
dele(ope[i].second);
else {
long long s = 0;
for (long long j = 1; j <= blo; j++) s += sum[j][3];
cout << s << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 111;
int op[123456], val[123456], b[123456];
vector<int> x;
vector<int>::iterator it;
long long sum[333][5];
int k[333], sumk;
map<int, int> ma;
char s[5];
int main(void) {
int i, j, n;
int no, ni;
long long res;
scanf("%d", &n);
x.clear();
for (i = 0; i < n; i++) {
scanf(" %s", s);
if (s[0] == 'a')
op[i] = 1;
else if (s[0] == 'd')
op[i] = 2;
else
op[i] = 3;
if (op[i] < 3) {
scanf("%d", &val[i]);
x.push_back(val[i]);
}
}
sort(x.begin(), x.end());
it = unique(x.begin(), x.end());
x.resize(it - x.begin());
for (i = 0; i < x.size(); i++) ma[x[i]] = i;
memset(sum, 0, sizeof(sum));
memset(k, 0, sizeof(k));
memset(b, 0, sizeof(b));
for (i = 0; i < n; i++) {
if (op[i] == 1) {
b[ma[val[i]]]++;
no = ma[val[i]] / 320;
k[no]++;
for (j = 0; j < 5; j++) sum[no][j] = 0;
j = 0;
for (ni = 0; ni < 320; ni++) {
if (b[no * 320 + ni]) {
sum[no][j] = sum[no][j] + x[no * 320 + ni];
j++;
if (j == 5) j = 0;
}
}
} else if (op[i] == 2) {
b[ma[val[i]]]--;
no = ma[val[i]] / 320;
k[no]--;
for (j = 0; j < 5; j++) sum[no][j] = 0;
j = 0;
for (ni = 0; ni < 320; ni++) {
if (b[no * 320 + ni]) {
sum[no][j] = sum[no][j] + x[no * 320 + ni];
j++;
if (j == 5) j = 0;
}
}
} else if (op[i] == 3) {
res = 0;
sumk = 2;
for (no = 0; no < 320; no++) {
res += sum[no][4 - sumk % 5];
sumk += k[no];
}
printf("%I64d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Fastio {
struct Reader {
char endch;
Reader() { endch = '\0'; }
Reader& operator>>(char& ch) {
ch = getchar();
while (ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t') ch = getchar();
return *this;
}
template <typename Int>
Reader& operator>>(Int& d) {
bool flag = 0;
endch = getchar();
while ((!isdigit(endch)) && endch != '-' && endch != EOF) endch = getchar();
if (endch == '-') flag = 1, endch = getchar();
d = endch & 15;
while (isdigit(endch = getchar())) d = (d << 3) + (d << 1) + (endch & 15);
if (flag) d = -d;
return *this;
}
template <typename T>
inline T get() {
T Val;
(*this) >> Val;
return Val;
}
} read;
struct Writer {
Writer& operator<<(const char* ch) {
while (*ch) putchar(*(ch++));
return *this;
}
Writer& operator<<(const char ch) {
putchar(ch);
return *this;
}
template <typename Int>
Writer& operator<<(Int x) {
static char buffer[33];
static int top = 0;
if (!x) {
putchar('0');
return *this;
}
if (x < 0) putchar('-'), x = -x;
while (x) {
buffer[++top] = '0' | (x % 10);
x /= 10;
}
while (top) putchar(buffer[top--]);
return *this;
}
} write;
} // namespace Fastio
using namespace Fastio;
char get_op() {
static char buffer[4];
scanf("%s", buffer);
return buffer[0];
}
const int N = 1e5 + 7;
struct segtree_node {
int ls, rs;
int siz;
long long val[5];
void clear() {
ls = rs = siz = 0;
memset(val, 0, sizeof(val));
}
} tr[N << 5];
void pushup(int u) {
tr[u].siz = tr[tr[u].ls].siz + tr[tr[u].rs].siz;
int shift = 5 - tr[tr[u].ls].siz % 5;
for (int i = 0; i < 5; ++i)
tr[u].val[i] = tr[tr[u].ls].val[i] + tr[tr[u].rs].val[(i + shift) % 5];
}
class MemoryPool {
private:
int pool_stack[N << 3], stack_top, unused_node;
public:
MemoryPool() : stack_top(0), unused_node(0) {}
void recycle(int node) {
pool_stack[++stack_top] = node;
tr[node].clear();
}
int get() { return stack_top ? pool_stack[stack_top--] : ++unused_node; }
} pool;
class segment_tree {
private:
int root;
void BASE_insert_or_modify(int& u, int l, int r, int pos) {
if (!u) u = pool.get();
if (l == r) {
tr[u].siz = 1;
tr[u].val[1] = pos;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
BASE_insert_or_modify(tr[u].ls, l, mid, pos);
else
BASE_insert_or_modify(tr[u].rs, mid + 1, r, pos);
pushup(u);
}
void BASE_erase(int& u, int l, int r, int pos) {
if (l == r) {
pool.recycle(u);
u = 0;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
BASE_erase(tr[u].ls, l, mid, pos);
else
BASE_erase(tr[u].rs, mid + 1, r, pos);
if (!tr[u].ls && !tr[u].rs) {
pool.recycle(u);
u = 0;
} else
pushup(u);
}
public:
segment_tree() : root(0) {}
void insert(int pos) { BASE_insert_or_modify(root, 1, 1e9, pos); }
void modify(int pos) { BASE_insert_or_modify(root, 1, 1e9, pos); }
void erase(int pos) { BASE_erase(root, 1, 1e9, pos); }
long long query_sum() { return tr[root].val[3]; }
} segt;
int n;
signed main() {
read >> n;
while (n--) {
switch (get_op()) {
case 'a':
segt.insert(read.get<int>());
break;
case 'd':
segt.erase(read.get<int>());
break;
case 's':
write << segt.query_sum() << '\n';
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int pre[MAXN], ch[MAXN][2], key[MAXN], ss[MAXN], sz[MAXN];
long long dp[MAXN][5];
int tot1, tot2;
int root;
vector<int> buf;
void push_down(int r) {
if (!r) return;
}
void push_up(int x) {
int l = ch[x][0], r = ch[x][1];
sz[x] = sz[l] + sz[r] + 1;
int lsz = sz[l] + 1;
for (int i = 0; i < 5; i++) {
dp[x][i] = dp[l][i];
}
dp[x][(sz[l]) % 5] += key[x];
if (r) {
for (int i = 0; i < 5; i++) {
dp[x][(i + lsz) % 5] += dp[r][i];
}
}
}
void rotate(int x, int d) {
const int y = pre[x];
ch[y][!d] = ch[x][d];
if (ch[x][d]) pre[ch[x][d]] = y;
pre[x] = pre[y];
if (ch[pre[y]][0] == y)
ch[pre[x]][0] = x;
else if (ch[pre[y]][1] == y)
ch[pre[x]][1] = x;
pre[y] = x;
ch[x][d] = y;
push_up(y);
}
bool _splay_parent(int x, int &y, int goal) {
return (y = pre[x]) != goal && (ch[y][0] == x || ch[y][1] == x);
}
void splay(int x, int goal) {
if (goal == 0) root = x;
if (!x) return;
for (int y, z; _splay_parent(x, y, goal);) {
if (_splay_parent(y, z, goal)) {
int d = y == ch[z][0];
if (x == ch[y][d])
rotate(x, d ^ 1), rotate(x, d);
else
rotate(y, d), rotate(x, d);
} else {
rotate(x, x == ch[y][0]);
break;
}
}
push_up(x);
}
int newnode(int x, int fa) {
int r;
tot1++;
r = tot1;
ch[r][0] = ch[r][1] = 0;
key[r] = dp[r][0] = x;
pre[r] = fa;
for (int i = 1; i < 5; i++) dp[r][i] = 0;
push_up(r);
return r;
}
void insert(int cur, int x) {
if (key[cur] > x) {
if (ch[cur][0]) {
insert(ch[cur][0], x);
} else {
ch[cur][0] = newnode(x, cur);
}
} else {
if (ch[cur][1]) {
insert(ch[cur][1], x);
} else {
ch[cur][1] = newnode(x, cur);
}
}
push_up(cur);
}
void remove(int cur, int x) {
if (key[cur] == x) {
if (ch[cur][0]) {
int r = ch[cur][0];
pre[r] = pre[cur];
if (pre[cur]) {
int fa = pre[cur];
ch[fa][ch[fa][1] == cur] = r;
}
while (ch[r][1]) r = ch[r][1];
if (ch[cur][1]) {
pre[ch[cur][1]] = r;
ch[r][1] = ch[cur][1];
}
splay(r, 0);
} else if (ch[cur][1]) {
int r = ch[cur][1];
if (pre[cur]) {
int fa = pre[cur];
ch[fa][ch[fa][1] == cur] = r;
}
pre[r] = pre[cur];
splay(r, 0);
} else {
if (pre[cur]) {
int fa = pre[cur];
ch[fa][ch[fa][1] == cur] = 0;
}
splay(pre[cur], 0);
}
return;
} else if (key[cur] < x) {
remove(ch[cur][1], x);
} else {
remove(ch[cur][0], x);
}
}
void dfs(int r) {
if (r) {
dfs(ch[r][0]);
buf.push_back(key[r]);
dfs(ch[r][1]);
}
}
int rebuild(int x, int L, int R) {
if (R < L) return 0;
int mid = (L + R) >> 1;
int ret = newnode(buf[mid], x);
ch[ret][0] = rebuild(ret, L, mid - 1);
ch[ret][1] = rebuild(ret, mid + 1, R);
push_up(ret);
return ret;
}
int main() {
ios::sync_with_stdio(0);
int t;
scanf("%d", &t);
char op[10];
int x;
int opt = 0;
while (t--) {
scanf("%s", op);
if (op[0] == 's') {
cout << dp[root][2] << endl;
} else if (op[0] == 'a') {
scanf("%d", &x);
if (root == 0)
root = newnode(x, root);
else
insert(root, x);
opt++;
if (opt % 417 == 0 && root) {
buf.clear();
dfs(root);
root = 0;
tot1 = 0;
root = rebuild(0, 0, (int)buf.size() - 1);
}
} else {
scanf("%d", &x);
remove(root, x);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int n, t;
char s[10];
scanf("%d", &n);
while (n--) {
scanf("%s", s);
if (s[0] == 's') {
long long ans = 0;
for (int i = 2; i < v.size(); i += 5) ans += v[i];
printf("%I64d\n", ans);
} else {
scanf("%d", &t);
if (s[0] == 'a')
v.insert(lower_bound(v.begin(), v.end(), t), t);
else
v.erase(lower_bound(v.begin(), v.end(), t));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int inp[100005][2];
class Node {
public:
int cnt;
long long sum[5];
};
Node seg[1000005];
void init(int x, int L, int R) {
seg[x].cnt = 0;
for (int i = 0; i < 5; i++) seg[x].sum[i] = 0;
}
inline void merge(int x) {
seg[x].cnt = seg[x * 2].cnt + seg[x * 2 + 1].cnt;
int m = seg[x * 2].cnt % 5;
for (int i = 0; i < 5; i++)
seg[x].sum[i] = seg[x * 2].sum[i] + seg[x * 2 + 1].sum[(i + 5 - m) % 5];
}
void goinsert(int x, int L, int R, int p, int v) {
if (L == R) {
seg[x].sum[0] = (long long)v;
seg[x].cnt = 1;
return;
} else {
int M = (L + R) / 2;
if (p <= M)
goinsert(x * 2, L, M, p, v);
else
goinsert(x * 2 + 1, M + 1, R, p, v);
merge(x);
}
}
void godelete(int x, int L, int R, int p) {
if (L == R) {
seg[x].sum[0] = 0;
seg[x].cnt = 0;
return;
} else {
int M = (L + R) / 2;
if (p <= M)
godelete(x * 2, L, M, p);
else
godelete(x * 2 + 1, M + 1, R, p);
merge(x);
}
}
int main(void) {
int n;
scanf("%d", &n);
map<int, int> v2x;
int i;
for (i = 0; i < n; i++) {
char s[100];
scanf("%s", s);
if (s[0] != 's') {
scanf("%d", &inp[i][1]);
v2x[inp[i][1]] = 1;
}
if (s[0] == 'a')
inp[i][0] = 1;
else if (s[0] == 'd')
inp[i][0] = 2;
else
inp[i][0] = 3;
}
int m = 0;
for (map<int, int>::iterator it = v2x.begin(); it != v2x.end(); it++) {
(it->second) = ++m;
}
init(1, 1, m);
for (i = 0; i < n; i++) {
if (inp[i][0] == 1)
goinsert(1, 1, m, v2x[inp[i][1]], inp[i][1]);
else if (inp[i][0] == 2)
godelete(1, 1, m, v2x[inp[i][1]]);
else
cout << seg[1].sum[2] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, sz, cnt;
int a[1000], b[1000];
long long sum[1000][5];
int str[1000];
int q[100010][2];
pair<int, int> num[100010];
bool mark[100010];
int bs(int x) {
int l = 0, r = n - 1;
while (l < r) {
int mid = (l + r) / 2;
if (num[mid].first >= x)
r = mid;
else
l = mid + 1;
}
return l;
}
void inc(int idx) {
for (int i = idx; i < cnt; i++) {
str[i]++;
if (str[i] == 5) str[i] = 0;
long long t = sum[i][4];
for (int j = 4; j > 0; j--) sum[i][j] = sum[i][j - 1];
sum[i][0] = t;
}
}
void dec(int idx) {
for (int i = idx; i < cnt; i++) {
str[i]--;
if (str[i] == -1) str[i] = 4;
long long t = sum[i][0];
for (int j = 0; j < 4; j++) sum[i][j] = sum[i][j + 1];
sum[i][4] = t;
}
}
void setSum(int idx) {
for (int i = 0; i < 5; i++) sum[idx][i] = 0;
int p = str[idx];
for (int i = a[idx]; i <= b[idx]; i++) {
if (!mark[i]) continue;
sum[idx][p] += num[i].first;
p++;
if (p == 5) p = 0;
}
}
int main() {
char s[10];
while (cin >> m) {
n = 0;
memset(mark, false, sizeof mark);
memset(sum, 0, sizeof sum);
memset(str, 0, sizeof str);
for (int i = 0; i < m; i++) {
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d", &q[i][1]);
q[i][0] = 0;
num[n++] = pair<int, int>(q[i][1], n);
}
if (s[0] == 'd') {
scanf("%d", &q[i][1]);
q[i][0] = 1;
}
if (s[0] == 's') q[i][0] = 2;
}
sort(num, num + n);
sz = (int)sqrt(5. * n);
cnt = 0;
int p = 0;
while (p < n) {
a[cnt] = p;
b[cnt] = min(n - 1, p + sz - 1);
p = b[cnt++] + 1;
}
for (int Q = 0; Q < m; Q++) {
if (q[Q][0] == 0) {
int idx = bs(q[Q][1]);
mark[idx] = true;
setSum(idx / sz);
inc(idx / sz + 1);
}
if (q[Q][0] == 1) {
int idx = bs(q[Q][1]);
mark[idx] = false;
setSum(idx / sz);
dec(idx / sz + 1);
}
if (q[Q][0] == 2) {
long long res = 0;
for (int i = 0; i < cnt; i++) res += sum[i][2];
cout << res << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
vector<int> a;
int main() {
int n = read();
for (int i = (1); i <= (n); i++) {
char ch[10];
scanf("%s", ch);
int x;
if (ch[0] != 's') x = read();
if (ch[0] == 'a')
a.insert(lower_bound(a.begin(), a.end(), x), x);
else if (ch[0] == 'd')
a.erase(lower_bound(a.begin(), a.end(), x));
else {
long long ans = 0;
for (int j = 2; j < a.size(); j += 5) ans += a[j];
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const double pi = 3.1415926535897932, eps = 1e-6;
void chmax(int &x, int y) {
if (x < y) x = y;
}
void chmin(int &x, int y) {
if (x > y) x = y;
}
int B = 333;
int n, top = 101000, cnt;
string s[100005];
int val[300005], ex[300005];
long long sum[444][5];
int num[444], rea[100005];
map<int, int> mp;
void calc(int x) {
int lb = x * B, rb = (x + 1) * B;
int now_cnt = 0;
for (int(i) = (0); (i) <= (4); (i)++) sum[x][i] = 0;
num[x] = 0;
for (int(i) = (lb); (i) < (rb); (i)++) {
if (ex[i]) {
sum[x][now_cnt % 5] += rea[i];
now_cnt++;
}
}
num[x] = now_cnt;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int(i) = (1); (i) <= (n); (i)++) {
cin >> s[i];
if (s[i] != "sum") {
cin >> val[i];
mp[val[i]] = 0;
}
}
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); it++) {
rea[cnt] = it->first;
it->second = cnt++;
}
for (int(i) = (1); (i) <= (n); (i)++) {
if (s[i] == "sum") {
int Top = top / B + 1;
int now_cnt = 0;
long long ans = 0;
for (int(i) = (0); (i) <= (Top); (i)++) {
ans += sum[i][(2 - now_cnt + 555555555) % 5];
now_cnt += num[i];
}
cout << ans << '\n';
} else {
val[i] = mp[val[i]];
if (s[i] == "add") {
int v = val[i];
ex[v] = 1;
int at = v / B;
calc(at);
} else {
int v = val[i];
ex[v] = 0;
int at = v / B;
calc(at);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int n;
cin >> n;
while (n--) {
char str[10];
scanf("%s", str);
if (str[0] == 'a') {
int val;
scanf("%d", &val);
v.insert(lower_bound(v.begin(), v.end(), val), val);
} else if (str[0] == 'd') {
int val;
scanf("%d", &val);
v.erase(lower_bound(v.begin(), v.end(), val));
} else {
long long sum = 0;
for (int i = 2; i < v.size(); i += 5) {
sum += v[i];
}
printf("%I64d\n", sum);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> seq[505], all;
long long n, m, i, j, b, b2, sum[505][5], x[100005], ans, cnt;
string op[100005];
void rest(int x) {
memset(sum[x], 0, sizeof(sum[x]));
int cnt = 0;
for (__typeof((seq[x]).begin()) it = (seq[x]).begin(); it != (seq[x]).end();
it++) {
sum[x][cnt] += all[*it];
(cnt += 1) %= 5;
}
}
int main() {
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
scanf(" ");
{
char ss[3];
scanf("%s", ss);
(op[i]) = ss;
};
if (op[i] == "sum")
x[i] = -1;
else {
scanf("%I64d", &x[i]);
all.push_back(x[i]);
}
}
sort(all.begin(), all.end());
all.resize(unique(all.begin(), all.end()) - all.begin());
b = sqrt((long long)all.size()) + 1;
b2 = ((long long)all.size() - 1) / b;
for (i = 1; i <= n; i++) {
if (op[i] == "sum") {
ans = cnt = 0;
for (j = 0; j <= b2; j++) {
ans += sum[j][((2 - cnt) % 5 + 5) % 5];
cnt += seq[j].size();
}
printf("%I64d\n", ans);
}
x[i] = lower_bound(all.begin(), all.end(), x[i]) - all.begin();
if (op[i] == "add") {
seq[x[i] / b].insert(
upper_bound(seq[x[i] / b].begin(), seq[x[i] / b].end(), x[i]), x[i]);
rest(x[i] / b);
}
if (op[i] == "del") {
seq[x[i] / b].erase(
lower_bound(seq[x[i] / b].begin(), seq[x[i] / b].end(), x[i]));
rest(x[i] / b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-12;
const int maxn = 100000 + 123;
int n;
string type[maxn];
int a[maxn];
void ReadData() {
cin >> n;
memset(a, -1, sizeof(a));
for (int i = 1; i <= n; i++) {
cin >> type[i];
if (type[i] == "add" || type[i] == "del") {
cin >> a[i];
}
}
}
int m = 0, val[maxn];
int to[maxn];
void InitRR() {
map<int, int> RR;
for (int i = 1; i <= n; i++)
if (a[i] != -1) RR[a[i]];
int cnt = 0;
for (map<int, int>::iterator it = RR.begin(); it != RR.end(); ++it)
it->second = ++cnt, to[it->second] = it->first;
for (int i = 1; i <= n; i++) a[i] = RR[a[i]];
for (int i = 1; i <= n; i++)
if (a[i]) val[++m] = a[i];
}
int l[maxn * 4], h[maxn * 4];
long long it[maxn * 4][5];
int leaf[maxn];
int Size[maxn * 4];
void Build(const int x, const int low, const int high) {
l[x] = low;
h[x] = high;
if (low == high) {
leaf[low] = x;
} else {
int mid = (low + high) >> 1;
Build((x << 1), low, mid);
Build(((x << 1) | 1), mid + 1, high);
}
}
void Combine(int x) {
for (int j = 0; j < 5; j++) it[x][j] = it[(x << 1)][j];
for (int j = 0; j < 5; j++)
it[x][(Size[(x << 1)] + j) % 5] += it[((x << 1) | 1)][j];
Size[x] = Size[(x << 1)] + Size[((x << 1) | 1)];
}
void Update(int pos, int val) {
int x = leaf[pos];
if (val == 1) {
it[x][1] = to[pos];
Size[x] = 1;
} else {
it[x][1] = 0;
Size[x] = 0;
}
while (true) {
x >>= 1;
if (!x) break;
Combine(x);
}
}
void Process() {
InitRR();
if (m >= 1) Build(1, 1, m);
for (int i = 1; i <= n; i++) {
if (type[i] == "add") {
Update(a[i], 1);
} else if (type[i] == "del") {
Update(a[i], -1);
} else {
cout << it[1][3] << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ReadData();
Process();
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
class Splay {
private:
struct nd {
long long s[5];
int v;
nd *c[2], *p;
int sz;
nd(int x, nd* n = 0) {
s[0] = s[1] = s[2] = s[3] = s[4] = 0;
s[0] = v = x;
sz = 1;
c[0] = c[1] = p = n;
}
void U() {
sz = c[0]->sz + c[1]->sz + 1;
s[0] = s[1] = s[2] = s[3] = s[4] = 0;
for (int i = 0; i < 5; i++) s[i] += c[0]->s[i];
for (int i = 0; i < 5; i++) s[(i + c[0]->sz + 1) % 5] += c[1]->s[i];
s[(c[0]->sz) % 5] += v;
}
void D() {}
void sc(nd* x, bool t) { c[t] = x, x->p = this; }
bool d() { return p->c[1] == this; }
void out() {
printf("%lld %lld %lld %lld %lld\n", s[0], s[1], s[2], s[3], s[4]);
}
} * h, *u;
void rt(nd* x) {
nd* y = x->p;
bool d = x->d();
y->D(), x->D();
y->sc(x->c[!d], d), y->p->sc(x, y->d()), x->sc(y, !d);
y->U();
if (y == h) h = x;
}
void spl(nd* x, nd* y) {
x->D();
while (x->p != y)
if (x->p->p == y)
rt(x);
else
(x->d() == x->p->d()) ? (rt(x->p), rt(x)) : (rt(x), rt(x));
x->U();
}
nd* slt(int x) {
int r;
nd* p = h;
while (1) {
p->D(), r = p->c[0]->sz;
if (r == x) return p;
p = p->c[r < x];
if (x > r) x -= r + 1;
}
}
nd* get(int l, int r) {
spl(slt(l), u), spl(slt(r), h);
return h->c[1]->c[0];
}
int rnk(nd* x, int y) {
if (x == u) return 0;
if (x->v < y) return x->c[0]->sz + 1 + rnk(x->c[1], y);
return rnk(x->c[0], y);
}
public:
Splay() {
u = new nd(0);
u->sz = 0;
h = new nd(0, u);
nd* r = new nd(0, u);
h->sc(r, 1);
u->v = h->v = -inf;
r->v = inf;
spl(r, u);
}
void add(int x) {
int s = rnk(h, x) - 1;
get(s, s + 1);
nd* p = new nd(x, u);
h->c[1]->sc(p, 0);
spl(p, u);
}
void del(int x) {
int s = rnk(h, x);
get(s - 1, s + 1);
h->c[1]->sc(u, 0);
spl(h->c[1], u);
}
long long ask() { return get(0, h->sz - 2 + 1)->s[2]; }
} T;
int main() {
int _;
scanf("%d", &_);
while (_--) {
char s[10];
int x;
scanf("%s%d", s, &x);
if (s[0] == 'a')
T.add(x);
else if (s[0] == 'd')
T.del(x);
else if (s[0] == 's')
printf("%I64d\n", T.ask());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct S {
char op[5];
int x, id;
} e[100005];
bool cmpval(S a, S b) {
if (a.x == b.x) return a.op[0] < b.op[0];
return a.x < b.x;
}
bool cmpid(S a, S b) { return a.id < b.id; }
int n, cnt, val[100005], num[400005];
long long sum[400005][5];
void build(int idx, int s, int e) {
if (s != e) {
int mid = (s + e) >> 1;
build(idx << 1, s, mid);
build(idx << 1 | 1, mid + 1, e);
}
num[idx] = 0;
for (int i = 0; i < 5; i++) sum[idx][i] = 0;
}
void update(int idx, int s, int e, int pos, int flag) {
num[idx] += flag;
if (s == e) {
sum[idx][1] += val[s] * flag;
return;
}
int mid = (s + e) >> 1;
if (pos <= mid)
update(idx << 1, s, mid, pos, flag);
else
update(idx << 1 | 1, mid + 1, e, pos, flag);
for (int i = 0; i < 5; i++)
sum[idx][i] =
sum[idx << 1][i] + sum[idx << 1 | 1][i - num[idx << 1] % 5 >= 0
? i - num[idx << 1] % 5
: i - num[idx << 1] % 5 + 5];
}
long long query(int idx, int s, int e, int mod) {
return sum[idx << 1][mod] +
sum[idx << 1 | 1]
[mod - num[idx << 1] % 5 >= 0 ? mod - num[idx << 1] % 5
: mod - num[idx << 1] % 5 + 5];
}
int main() {
int i;
long long ans;
while (~scanf("%d", &n)) {
map<int, int> mp;
for (i = 0; i < n; i++) {
scanf("%s", e[i].op);
if (e[i].op[0] == 's')
e[i].x = 0;
else
scanf("%d", &e[i].x);
e[i].id = i;
}
sort(e, e + n, cmpval);
cnt = 1;
for (i = 0; i < n; i++) {
if (e[i].op[0] == 'a') {
if (!mp[e[i].x]) mp[e[i].x] = cnt++;
val[mp[e[i].x]] = e[i].x;
e[i].x = mp[e[i].x];
} else if (e[i].op[0] == 'd') {
e[i].x = mp[e[i].x];
}
}
sort(e, e + n, cmpid);
cnt--;
if (!cnt) {
for (i = 0; i < n; i++) {
if (e[i].op[0] == 's') {
printf("0\n");
}
}
continue;
}
build(1, 1, cnt);
for (i = 0; i < n; i++) {
if (e[i].op[0] == 'a')
update(1, 1, cnt, e[i].x, 1);
else if (e[i].op[0] == 'd')
update(1, 1, cnt, e[i].x, -1);
else
printf("%I64d\n", query(1, 1, n, 3));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int q, n, type[100100], opr[100100], nu;
vector<int> val;
char str[10];
long long dat[401100][5];
int cnt[401100];
void merge(int a, int b, int c) {
cnt[a] = cnt[b] + cnt[c];
for (int i = 0; i < 5; i++) dat[a][i] = dat[b][i];
for (int i = 0; i < 5; i++) dat[a][(i + cnt[b]) % 5] += dat[c][i];
}
void add_val(int num) {
int idx = num + nu;
cnt[idx] = 1;
dat[idx][0] = val[num];
for (; idx >>= 1; idx) merge(idx, ((idx << 1) | 0), ((idx << 1) | 1));
}
void del_val(int num) {
int idx = num + nu;
cnt[idx] = 0;
dat[idx][0] = 0;
for (; idx >>= 1; idx) merge(idx, ((idx << 1) | 0), ((idx << 1) | 1));
}
int main() {
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%s", str);
if (str[0] == 'a') {
type[i] = 0;
scanf("%d", opr + i);
val.push_back(opr[i]);
}
if (str[0] == 'd') {
type[i] = 1;
scanf("%d", opr + i);
}
if (str[0] == 's') type[i] = 2;
}
sort(val.begin(), val.end());
val.erase(unique(val.begin(), val.end()), val.end());
int n = val.size();
nu = 1;
while (nu < (n + 5)) nu *= 2;
for (int i = 1; i <= q; i++) {
if (type[i] == 2) continue;
opr[i] = lower_bound(val.begin(), val.end(), opr[i]) - val.begin();
}
for (int i = 1; i <= q; i++) {
if (type[i] == 0) add_val(opr[i]);
if (type[i] == 1) del_val(opr[i]);
if (type[i] == 2) printf("%lld\n", dat[1][2]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int n;
char inp[10];
int main() {
scanf("%d", &n);
int xb, x, x2;
for (xb = 0; xb < n; xb++) {
scanf("%s", inp);
if (inp[0] == 'a') {
scanf("%d", &x);
a.insert(lower_bound(a.begin(), a.end(), x), x);
} else if (inp[0] == 'd') {
scanf("%d", &x);
a.erase(lower_bound(a.begin(), a.end(), x));
} else {
long long res = 0;
for (x2 = 2; x2 < a.size(); x2 += 5) res += (long long)a[x2];
printf("%I64d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, tmp;
int v[100005];
int R[4 * 100005];
long long T[7][4 * 100005];
char s[100005][4];
map<int, int> M;
void upd(int x, int y, int l, int r, int node) {
if (l == r) {
R[node] = !R[node];
T[1][node] = R[node] * y;
return;
}
if (x <= (l + r) / 2)
upd(x, y, l, (l + r) / 2, node * 2);
else
upd(x, y, (l + r) / 2 + 1, r, node * 2 + 1);
R[node] = R[node * 2] + R[node * 2 + 1];
int k = R[node * 2] % 5;
for (int i = 0; i < 5; i++)
T[i][node] = T[i][node * 2] + T[(5 - k + i) % 5][node * 2 + 1];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i]);
if (s[i][0] != 's') scanf("%d", &v[i]), M[v[i]] = 1;
}
for (auto i : M) M[i.first] = ++tmp;
for (int i = 1; i <= n; i++) {
if (s[i][0] != 's')
upd(M[v[i]], v[i], 1, tmp, 1);
else
printf("%lld\n", T[3][1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int n;
int main() {
scanf("%d", &n);
while (n--) {
int x;
char op[3];
scanf("%s", op);
if (op[0] == 'a') {
scanf("%d", &x);
v.insert(lower_bound(v.begin(), v.end(), x), x);
}
if (op[0] == 'd') {
int x;
scanf("%d", &x);
v.erase(lower_bound(v.begin(), v.end(), x));
}
if (op[0] == 's') {
long long ans = 0;
for (int i = 2; i < v.size(); i += 5) ans += v[i];
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sum[2 * (1 << 17)][5];
int cnt[2 * (1 << 17)];
vector<pair<int, int> > query;
char buf[10];
map<int, int> mp;
int N, pm[100010];
void func(int x) {
int i;
int l = 2 * x, r = 2 * x + 1;
cnt[x] = cnt[l] + cnt[r];
for ((i) = 0; (i) < (int)(5); (i)++)
sum[x][i] = sum[l][i] + sum[r][(i - cnt[l] % 5 + 5) % 5];
}
int main(void) {
int Q, i, j, x;
scanf("%d", &Q);
for ((i) = 0; (i) < (int)(Q); (i)++) {
scanf("%s", buf);
if (buf[0] == 's') {
query.push_back(make_pair(2, 0));
} else {
scanf("%d", &x);
query.push_back(make_pair(((buf[0] == 'a') ? 0 : 1), x));
mp[x] = 0;
}
}
for (__typeof((mp).begin()) itr = (mp).begin(); itr != (mp).end(); itr++) {
(itr->second) = N;
pm[N] = (itr->first);
N++;
}
for ((i) = 0; (i) < (int)(Q); (i)++) {
int type = query[i].first, x = query[i].second;
if (type == 2) {
printf("%I64d\n", sum[1][2]);
} else {
int id = (1 << 17) + mp[x];
cnt[id] = 1 - type;
sum[id][0] = (1 - type) * x;
for (j = id / 2; j >= 1; j /= 2) func(j);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[10];
vector<int> V;
class op {
public:
int type;
int value;
void input() {
scanf("%s", str);
if (strcmp(str, "add") == 0) {
type = 0;
} else if (strcmp(str, "del") == 0) {
type = 1;
} else {
type = 2;
return;
}
scanf("%d", &value);
V.push_back(value);
}
} node[100005];
class Node {
public:
int l, r;
int cnt;
long long mod[5];
} seg[100005 << 2];
void build(int i, int l, int r) {
seg[i].l = l;
seg[i].r = r;
seg[i].cnt = 0;
for (int j = 0; j < 5; j++) seg[i].mod[j] = 0;
if (l != r) {
int mid = (l + r) >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
}
}
void updata(int i, int pos, int value) {
seg[i].cnt += value;
if (seg[i].l == seg[i].r) {
if (seg[i].cnt == 0)
seg[i].mod[1] = 0;
else {
seg[i].mod[1] = V[pos - 1];
}
return;
}
int mid = (seg[i].l + seg[i].r) >> 1;
if (pos <= mid) {
updata(i << 1, pos, value);
} else {
updata(i << 1 | 1, pos, value);
}
for (int j = 0; j < 5; j++) {
seg[i].mod[j] = seg[i << 1].mod[j];
}
for (int j = 0; j < 5; j++) {
seg[i].mod[(j + seg[i << 1].cnt) % 5] += seg[i << 1 | 1].mod[j];
}
}
int main() {
int N;
while (~scanf("%d", &N)) {
int sc = 0;
V.clear();
for (int i = 0; i < N; i++) {
node[i].input();
}
sort(V.begin(), V.end());
V.erase(unique(V.begin(), V.end()), V.end());
if (V.size() == 0) {
cout << 0 << endl;
continue;
}
build(1, 1, V.size());
for (int i = 0; i < N; i++) {
int pos = lower_bound(V.begin(), V.end(), node[i].value) - V.begin() + 1;
if (node[i].type == 0) {
updata(1, pos, 1);
} else if (node[i].type == 1) {
updata(1, pos, -1);
} else {
cout << seg[1].mod[3] << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct ST {
int l, r, cnt;
long long sum[5];
ST() {
l = r = cnt = 0;
for (int i = 0; i < 5; i++) sum[i] = 0;
}
};
struct Query {
char type[40];
long long x;
};
const int MAXN = 1e5 + 20;
int n, xp = 0;
Query qs[MAXN];
long long xs[MAXN];
map<long long, long long> rem;
ST t[MAXN * 8];
void st_build(int u, int l, int r) {
t[u].l = l;
t[u].r = r;
for (int i = 0; i < 5; i++) t[u].sum[i] = 0;
t[u].cnt = 0;
if (l == r) return;
st_build((u * 2), l, ((l + r) / 2));
st_build((u * 2 + 1), ((l + r) / 2) + 1, r);
}
void st_pushup(int u) {
for (int i = 0; i < 5; i++)
t[u].sum[i] = t[(u * 2)].sum[i] +
t[(u * 2 + 1)].sum[((i - t[(u * 2)].cnt % 5) % 5 + 5) % 5];
}
void st_add(int u, int i, int v) {
t[u].cnt += v;
if (t[u].l == t[u].r) {
t[u].sum[0] = (v + 1) / 2 * xs[i - 1];
return;
}
if (i <= (t[u].l + t[u].r) / 2)
st_add((u * 2), i, v);
else
st_add((u * 2 + 1), i, v);
st_pushup(u);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", qs[i].type);
if (qs[i].type[0] != 's') {
scanf("%lld", &qs[i].x);
xs[xp++] = qs[i].x;
}
}
sort(xs, xs + xp);
int uniq = unique(xs, xs + xp) - xs;
for (int i = 0; i < uniq; i++) rem[xs[i]] = i + 1;
st_build(1, 1, uniq + 1);
for (int i = 0; i < n; i++) {
if (qs[i].type[0] == 'a') {
st_add(1, rem[qs[i].x], 1);
} else if (qs[i].type[0] == 'd') {
st_add(1, rem[qs[i].x], -1);
} else {
printf("%lld\n", t[1].sum[2]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int ans, cnt;
struct Node {
Node *Left = NULL, *Right = NULL;
int value, fix, sz = 1;
long long sum[5] = {};
};
typedef Node *PNode;
PNode root = NULL;
inline int gts(PNode &cur) {
if (cur == NULL) return 0;
return cur->sz;
}
Node nodes[111111];
inline void Init(PNode &cur) {
if (cur) {
cur->sz = gts(cur->Left) + gts(cur->Right) + 1;
int t = 0;
if (cur->Left) {
for (int i = 0; i < 5; ++i) cur->sum[i] = cur->Left->sum[i];
t = cur->Left->sz % 5;
} else {
for (int i = 0; i < 5; ++i) cur->sum[i] = 0;
}
cur->sum[t] += cur->value;
t++;
t %= 5;
if (cur->Right) {
for (int i = 0; i < 5; ++i) {
int T = i + t;
T %= 5;
cur->sum[T] += cur->Right->sum[i];
}
}
}
}
inline void make(PNode a, PNode b, PNode &c) {
if (!b or !a) {
c = b ? b : a;
return;
}
if (a->fix > b->fix) {
make(a->Right, b, a->Right);
c = a;
} else {
make(a, b->Left, b->Left);
c = b;
}
Init(c);
}
inline void split(PNode t, PNode &a, PNode &b, int f) {
if (!t) {
a = b = NULL;
return;
}
if (f < t->value) {
split(t->Left, a, t->Left, f);
b = t;
} else {
split(t->Right, t->Right, b, f);
a = t;
}
Init(t);
}
inline void Insert(int val) {
PNode a, b, c;
split(root, a, c, val);
nodes[cnt].value = val;
nodes[cnt].fix = rand();
b = nodes + cnt++;
Init(b);
make(a, b, root);
make(root, c, root);
}
inline void Delete(PNode &cur, int val) {
if (cur->value == val) {
make(cur->Left, cur->Right, cur);
} else if (val < cur->value) {
Delete(cur->Left, val);
} else
Delete(cur->Right, val);
Init(cur);
}
inline int Find_Min(PNode cur) {
while (cur->Left) cur = cur->Left;
return cur->value;
}
inline int Find_Max(PNode cur) {
while (cur->Right) cur = cur->Right;
return cur->value;
}
int main() {
ios_base::sync_with_stdio(false);
int n, x, y, i, count = 0;
string s;
cin >> n;
for (i = 0; i < n; ++i) {
cin >> s;
if (s == "add") {
cin >> x;
count++;
Insert(x);
} else if (s == "del") {
cin >> x;
count--;
Delete(root, x);
} else {
if (!count)
printf("%d\n", 0);
else
printf("%I64d\n", root->sum[2]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int n;
int main() {
scanf("%d", &n);
while (n--) {
int x;
char op[3];
scanf("%s", op);
if (op[0] == 'a') {
scanf("%d", &x);
v.insert(lower_bound(v.begin(), v.end(), x), x);
} else if (op[0] == 'd') {
int x;
scanf("%d", &x);
v.erase(lower_bound(v.begin(), v.end(), x));
} else {
long long ans = 0;
for (int i = 2; i < v.size(); i += 5) ans += v[i];
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> seq;
int n, m, i, j, x;
string op;
long long ans;
int main() {
scanf("%d", &n);
while (n--) {
scanf(" ");
{
char ss[3];
scanf("%s", ss);
(op) = ss;
};
if (op == "add") {
scanf("%d", &x);
seq.insert(upper_bound(seq.begin(), seq.end(), x), x);
}
if (op == "del") {
scanf("%d", &x);
seq.erase(lower_bound(seq.begin(), seq.end(), x));
}
if (op == "sum") {
ans = 0;
for (i = 2; i < seq.size(); i += 5) ans += seq[i];
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Type>
struct SizeBalanceTree {
int root, sz, SZ[100010], LC[100010], RC[100010];
long long SUM[100010][5];
Type K[100010];
inline void Insert(Type key) { Insert(root, key); }
inline void Delete(Type key) { Delete(root, key); }
inline void Clear() { sz = root = 0; }
inline long long Eval() { return SUM[root][2]; }
void Insert(int &root, Type key) {
if (!root) {
root = ++sz;
K[root] = SUM[root][0] = key, SZ[root] = 1;
LC[root] = RC[root] = 0;
for (int i = 1; i < 5; i++) SUM[root][i] = 0;
return;
}
SZ[root]++;
if (key < K[root]) {
Insert(LC[root], key);
} else {
Insert(RC[root], key);
}
maintain(root, !(key < K[root]));
PushUp(root);
}
Type Delete(int &root, Type key) {
SZ[root]--;
Type ret = K[root];
if (K[root] == key || key < K[root] && !LC[root] ||
K[root] < key && !RC[root]) {
if (!LC[root] || !RC[root])
root = LC[root] + RC[root];
else
K[root] = Delete(LC[root], K[root] + 1);
} else if (key < K[root])
ret = Delete(LC[root], key);
else
ret = Delete(RC[root], key);
PushUp(root);
return ret;
}
inline void PushUp(int root) {
for (int i = 0; i < 5; i++) SUM[root][i] = SUM[LC[root]][i];
SUM[root][SZ[LC[root]] % 5] += K[root];
for (int i = 0; i < 5; i++)
SUM[root][(i + SZ[LC[root]] + 1) % 5] += SUM[RC[root]][i];
}
inline void LeftRotate(int &root) {
int temp = RC[root];
RC[root] = LC[temp];
LC[temp] = root;
SZ[temp] = SZ[root];
SZ[root] = 1 + SZ[LC[root]] + SZ[RC[root]];
PushUp(root), PushUp(temp);
root = temp;
}
inline void RightRotate(int &root) {
int temp = LC[root];
LC[root] = RC[temp];
RC[temp] = root;
SZ[temp] = SZ[root];
SZ[root] = 1 + SZ[LC[root]] + SZ[RC[root]];
PushUp(root), PushUp(temp);
root = temp;
}
void maintain(int &root, bool flag) {
if (root == 0) return;
if (!flag) {
if (SZ[LC[LC[root]]] > SZ[RC[root]]) {
RightRotate(root);
} else if (SZ[RC[LC[root]]] > SZ[RC[root]]) {
LeftRotate(LC[root]);
RightRotate(root);
} else {
return;
}
} else {
if (SZ[RC[RC[root]]] > SZ[LC[root]]) {
LeftRotate(root);
} else if (SZ[LC[RC[root]]] > SZ[LC[root]]) {
RightRotate(RC[root]);
LeftRotate(root);
} else {
return;
}
}
maintain(LC[root], false);
maintain(RC[root], true);
maintain(root, false);
maintain(root, true);
}
};
SizeBalanceTree<int> SBT;
int main(int argc, const char *argv[]) {
int n;
while (scanf("%d", &n) != EOF) {
SBT.Clear();
for (int i = 0; i < n; i++) {
char s[10];
scanf("%s", s);
if (s[0] == 's')
printf("%I64d\n", SBT.Eval());
else {
int x;
scanf("%d", &x);
if (s[0] == 'a')
SBT.Insert(x);
else
SBT.Delete(x);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
struct node {
int lc, rc;
long long s[5];
int cnt;
} t[N * 40];
int rt = 0, siz = 0;
void pushup(int x) {
int lc = t[x].lc, rc = t[x].rc, ls = t[lc].cnt;
for (int i = 0; i < 5; i++) t[x].s[i] = t[lc].s[i];
for (int i = 0; i < 5; i++) t[x].s[(i + ls) % 5] += t[rc].s[i];
t[x].cnt = t[lc].cnt + t[rc].cnt;
}
void insert(int &x, int l, int r, int p, int v) {
if (!x) x = ++siz;
if (l == r) {
t[x].cnt += v;
t[x].s[1] += 1ll * l * v;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
insert(t[x].lc, l, mid, p, v);
else
insert(t[x].rc, mid + 1, r, p, v);
pushup(x);
}
int main() {
char s[23];
int _;
for (scanf("%d", &_); _; _--) {
scanf("%s", s);
if (s[0] == 's')
printf("%lld\n", t[rt].s[3]);
else {
int d = s[0] == 'd' ? -1 : 1, v;
scanf("%d", &v);
insert(rt, 1, 1e9, v, d);
}
}
return 0;
}
|
#include <bits/stdc++.h>
constexpr int MAXN = 1e5 + 5;
using namespace std;
int tot, n, cnt;
unordered_map<int, int> Map;
vector<int> vec;
vector<pair<string, int>> opt;
string s;
inline void discretization() {
sort(vec.begin(), vec.end());
cnt = unique(vec.begin(), vec.end()) - vec.begin();
for (int i = 0; i < cnt; i++) Map[vec[i]] = i;
}
struct Node {
Node *lson, *rson;
int cnt, l, r;
long long sum[5];
} Tree[MAXN << 1];
inline Node *newNode(Node *&root) { return root = &Tree[++tot]; }
inline void update(Node *root) {
root->cnt = root->lson->cnt + root->rson->cnt;
for (int i = 0; i < 5; i++)
root->sum[i] = root->lson->sum[i] +
root->rson->sum[((i - root->lson->cnt) % 5 + 5) % 5];
}
inline void build(int L, int R, Node *root) {
root->l = L, root->r = R;
if (L == R) return;
int mid = (L + R) >> 1;
build(L, mid, newNode(root->lson)), build(mid + 1, R, newNode(root->rson));
}
inline void modify(int pos, int val, Node *root) {
if (root->l == pos && root->r == pos) {
root->cnt += val, root->sum[1] += val * vec[pos];
return;
}
int mid = (root->l + root->r) >> 1;
if (pos <= mid) modify(pos, val, root->lson);
if (pos > mid) modify(pos, val, root->rson);
update(root);
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1, x; i <= n; i++) {
cin >> s;
if (s == "add")
cin >> x, opt.push_back({s, x}), vec.push_back(x);
else if (s == "del")
cin >> x, opt.push_back({s, x});
else
opt.push_back({s, 0});
}
discretization(), build(0, cnt, Tree);
for (auto i : opt) {
if (i.first == "add")
modify(Map[i.second], 1, Tree);
else if (i.first == "del")
modify(Map[i.second], -1, Tree);
else
cout << Tree->sum[3] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <class T>
void pvp(T a, T b) {
for (T i = a; i != b; ++i)
cout << "(" << i->first << ", " << i->second << ") ";
cout << endl;
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int in_c() {
int c;
for (; (c = getchar()) <= ' ';) {
if (!~c) throw ~0;
}
return c;
}
int in() {
int x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -in();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
long long In() {
long long x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -In();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
int Q, N;
int XS[100010];
int QX[100010], QY[100010];
char QT[100010][6];
int segn;
int cnt[400010];
long long sum[400010][5];
void merge(int a, int b, int c) {
cnt[a] = cnt[b] + cnt[c];
for (int i = 0; i < 5; i++) sum[a][i] = 0;
for (int i = 0; i < 5; i++)
sum[a][i] = sum[b][i] + sum[c][(i - cnt[b] % 5 + 5) % 5];
return;
}
void add(int a) {
a += segn;
cnt[a] = 1;
sum[a][0] = XS[a - segn];
for (; a >>= 1;) merge(a, a << 1 | 0, a << 1 | 1);
}
void del(int a) {
a += segn;
cnt[a] = 0;
sum[a][0] = 0;
for (; a >>= 1;) merge(a, a << 1 | 0, a << 1 | 1);
}
int main() {
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
scanf("%s", &QT[i]);
if (!strcmp(QT[i], "add"))
QX[i] = in(), XS[N++] = QX[i];
else if (!strcmp(QT[i], "del"))
QX[i] = in(), XS[N++] = QX[i];
else
QX[i] = QY[i] = -1;
}
sort(XS, XS + N);
N = (unique(XS, XS + N) - XS);
segn = 1;
while (segn < N + 5) segn <<= 1;
for (int i = 0; i < Q; i++)
if (~QX[i]) {
QY[i] = lower_bound(XS, XS + N, QX[i]) - XS;
}
for (int i = 0; i < Q; i++) {
if (!strcmp(QT[i], "add"))
add(QY[i]);
else if (!strcmp(QT[i], "del"))
del(QY[i]);
else
printf("%I64d\n", sum[1][2]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100 * 1000 + 5;
int Q;
map<int, int> POS;
struct range {
int s, e;
long long siz;
long long mod[5];
range(int s = -1, int e = -1) : s(s), e(e) {
memset(mod, 0, sizeof mod);
siz = 0;
}
} t[1 << 18];
inline void build(int x) {
if (t[x].e <= t[x].s) return;
int mid = (t[x].s + t[x].e) / 2;
int l = (x << 1);
int r = l + 1;
t[l] = range(t[x].s, mid);
t[r] = range(mid + 1, t[x].e);
build(l);
build(r);
}
inline void add(int root, int pos, int val) {
range &now = t[root];
now.siz++;
if (now.s == now.e) {
now.mod[1] = val;
return;
}
int l = (root << 1), r = (root << 1) + 1;
if (pos <= t[l].e)
add(l, pos, val);
else
add(r, pos, val);
for (int i = 0; i < 5; i++) {
int tmp = (i - t[l].siz) % 5;
tmp = (tmp + 5) % 5;
now.mod[i] = t[l].mod[i] + t[r].mod[tmp];
}
}
inline void del(int root, int pos, int val) {
range &now = t[root];
now.siz--;
if (now.s == now.e) {
now.mod[1] = 0;
return;
}
int l = (root << 1), r = (root << 1) + 1;
if (pos <= t[l].e)
del(l, pos, val);
else
del(r, pos, val);
for (int i = 0; i < 5; i++) {
int tmp = (i - t[l].siz) % 5;
tmp = (tmp + 5) % 5;
now.mod[i] = t[l].mod[i] + t[r].mod[tmp];
}
}
int main() {
scanf("%d", &Q);
vector<pair<int, int> > qq;
vector<int> num;
for (int i = 1; i <= Q; i++) {
char test[5];
scanf("%s", test);
if (test[0] == 'a') {
int tmp;
scanf("%d", &tmp);
qq.push_back(pair<int, int>(0, tmp));
num.push_back(tmp);
} else if (test[0] == 'd') {
int tmp;
scanf("%d", &tmp);
qq.push_back(pair<int, int>(1, tmp));
} else
qq.push_back(pair<int, int>(2, -1));
}
sort(num.begin(), num.end());
int uni = 0;
for (int i = 0; i < (int)num.size(); i++) {
if (POS[num[i]] == 0) POS[num[i]] = ++uni;
}
t[1] = range(1, uni);
build(1);
for (int i = 0; i < (int)qq.size(); i++) {
if (qq[i].first == 0)
add(1, POS[qq[i].second], qq[i].second);
else if (qq[i].first == 1)
del(1, POS[qq[i].second], qq[i].second);
else
printf("%I64d\n", t[1].mod[3]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const double pi = 3.1415926535897932, eps = 1e-6;
int cnt[262200];
long long sum[262200][5];
void chan(int x) {
int i, l = x << 1, r = (x << 1) + 1;
cnt[x] = cnt[l] + cnt[r];
for (int(i) = (0); (i) <= (4); (i)++)
sum[x][i] = sum[l][i] + sum[r][(i - cnt[l] % 5 + 5) % 5];
}
int n, a[100005];
vector<pair<int, int> > v;
vector<int> num;
int main() {
cin >> n;
for (int(i) = (1); (i) <= (n); (i)++) {
string com;
int g;
cin >> com;
if (com[0] != 's') {
cin >> g;
}
v.push_back(make_pair(com[0] == 's' ? inf : g, com[0]));
if (com[0] != 's') num.push_back(g);
}
sort(num.begin(), num.end());
int s = unique(num.begin(), num.end()) - num.begin();
for (int(i) = (1); (i) <= (n); (i)++) {
pair<int, int> now = v[i - 1];
if (now.second == 's')
cout << sum[1][2] << endl;
else {
int typ = now.second == 'a' ? 0 : 1,
id = (1 << 17) +
(lower_bound(num.begin(), num.begin() + s, now.first) -
num.begin());
cnt[id] = 1 - typ;
sum[id][0] = (1 - typ) * now.first;
for (int j = id >> 1; j; j >>= 1) chan(j);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s[0] == 's') {
long long ret = 0;
for (int i = 2; i < v.size(); i += 5) ret += v[i];
cout << ret << endl;
} else {
int x;
cin >> x;
if (s[0] == 'a')
v.insert(lower_bound(v.begin(), v.end(), x), x);
else
v.erase(lower_bound(v.begin(), v.end(), x));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int n, x;
char s[3];
int main() {
cin >> n;
while (n--) {
cin >> s;
if (s[0] == 'a') {
cin >> x;
v.insert(lower_bound(v.begin(), v.end(), x), x);
}
if (s[0] == 'd') {
cin >> x;
v.erase(lower_bound(v.begin(), v.end(), x));
}
if (s[0] == 's') {
long long ans = 0;
for (int i = 2; i < v.size(); i += 5) {
ans += v[i];
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 15;
int type[N], x[N];
long long tree[N * 4][5];
int lazy[N * 4];
int cc[N];
void pupdate(int ind, int add) {
while (ind < N) cc[ind] += add, ind += ind & (-ind);
}
int pquery(int ind) {
int ret = 0;
while (ind) ret += cc[ind], ind = ind & (ind - 1);
return ret;
}
void push(int pos, int l, int r) {
lazy[pos] %= 5;
if (lazy[pos] != 0) {
long long temp[5];
for (int i = 0; i < 5; ++i) {
int nind = (i + lazy[pos] + 5) % 5;
temp[nind] = tree[pos][i];
}
for (int i = 0; i < 5; ++i) tree[pos][i] = temp[i];
if (l != r) {
lazy[pos * 2] += lazy[pos], lazy[pos * 2 + 1] += lazy[pos];
}
lazy[pos] = 0;
}
}
void update(int pos, int l, int r, int ql, int qr, int d) {
push(pos, l, r);
if (r < ql || qr < l) return;
if (ql <= l && r <= qr) {
lazy[pos] = d;
push(pos, l, r);
return;
}
int mid = (l + r) / 2;
update(pos * 2, l, mid, ql, qr, d);
update(pos * 2 + 1, mid + 1, r, ql, qr, d);
for (int i = 0; i < 5; ++i)
tree[pos][i] = tree[pos * 2][i] + tree[pos * 2 + 1][i];
}
void add(int pos, int l, int r, int ind, int b, int val) {
push(pos, l, r);
if (ind < l || r < ind) return;
if (l == r) {
tree[pos][b] += val;
return;
}
int mid = (l + r) / 2;
add(pos * 2, l, mid, ind, b, val);
add(pos * 2 + 1, mid + 1, r, ind, b, val);
for (int i = 0; i < 5; ++i)
tree[pos][i] = tree[pos * 2 + 1][i] + tree[pos * 2][i];
}
int main() {
char s[50];
int n;
cin >> n;
map<int, int> Hash;
int pos = 1;
for (int i = 0; i < n; ++i) {
scanf("%s", s);
if (s[0] == 'a') {
type[i] = 0;
scanf("%d", &x[i]);
Hash[x[i]];
} else if (s[0] == 'd') {
type[i] = 1;
scanf("%d", &x[i]);
Hash[x[i]];
} else {
type[i] = 2;
}
}
for (auto it = Hash.begin(); it != Hash.end(); ++it) {
it->second = pos++;
}
--pos;
for (int i = 0; i < n; ++i) {
if (type[i] == 0) {
int ind = Hash[x[i]];
pupdate(ind, 1);
int num = pquery(ind);
if (ind + 1 <= pos) update(1, 1, pos, ind + 1, pos, 1);
add(1, 1, pos, ind, num % 5, x[i]);
} else if (type[i] == 1) {
int ind = Hash[x[i]];
int num = pquery(ind);
add(1, 1, pos, ind, num % 5, -x[i]);
if (ind + 1 <= pos) update(1, 1, pos, ind + 1, pos, -1);
pupdate(ind, -1);
} else {
printf("%lld\n", tree[1][3]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
FILE *in = stdin;
class node {
public:
long long sum[5], hnode;
node() {
sum[0] = sum[1] = sum[2] = sum[3] = sum[4] = hnode = 0;
return;
}
node(int x) {
for (int q = 0; q < 5; q++) {
sum[q] = 0;
}
sum[0] = x;
hnode = 1;
return;
}
};
node merge(node a, node b) {
node c;
c.hnode = a.hnode + b.hnode;
int left = a.hnode % 5;
for (int q = 0; q < 5; q++) {
c.sum[q] = a.sum[q] + b.sum[(5 - left + q) % 5];
}
return c;
}
class segment_tree {
public:
node tree[4 * 100000];
segment_tree() {
for (int q = 0; q < 4 * 100000; q++) {
tree[q] = node();
}
return;
}
void add(int i, int l, int r, int x, int v, int typ) {
if (l == r) {
if (typ == 0) {
tree[i] = node(v);
} else {
tree[i] = node();
}
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
add(i * 2, l, mid, x, v, typ);
else
add(i * 2 + 1, mid + 1, r, x, v, typ);
tree[i] = merge(tree[i * 2], tree[i * 2 + 1]);
return;
}
long long sum() { return tree[1].sum[2]; }
};
int N, a[100000][2];
set<int> heap;
segment_tree seg;
map<int, int> ind;
int main() {
fscanf(in, "%d", &N);
for (int q = 0; q < N; q++) {
char qq[22];
int x;
fscanf(in, "%s", qq);
if (qq[0] == 's') {
a[q][0] = -1;
} else {
fscanf(in, "%d", &x);
if (qq[0] == 'a')
a[q][0] = 0;
else
a[q][0] = 1;
a[q][1] = x;
heap.insert(x);
}
}
int cind = 0;
for (set<int>::iterator it = heap.begin(); it != heap.end(); it++) {
ind[*it] = cind;
cind++;
}
for (int q = 0; q < N; q++) {
if (a[q][0] == -1) {
printf("%I64d\n", seg.sum());
} else {
seg.add(1, 0, cind - 1, ind[a[q][1]], a[q][1], a[q][0]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
typedef struct item* pitem;
struct item {
int prior, cnt;
long long value, f;
pitem l, r;
};
int cnt(pitem it) { return it ? it->cnt : 0; }
long long f(pitem it) { return it ? it->f : 0; }
void upd_cnt(pitem it) {
if (it) {
it->cnt = cnt(it->l) + cnt(it->r) + 1;
it->f = f(it->l) + f(it->r) + it->value;
}
}
void merge(pitem& t, pitem l, pitem r) {
if (!l || !r)
t = l ? l : r;
else if (l->prior > r->prior)
merge(l->r, l->r, r), t = l;
else
merge(r->l, l, r->l), t = r;
upd_cnt(t);
}
void split1(pitem t, pitem& l, pitem& r, int key, int add = 0) {
if (!t) return void(l = r = 0);
int cur_key = t->value;
if (key <= cur_key)
split1(t->l, l, t->l, key, add), r = t;
else
split1(t->r, t->r, r, key, add + 1 + cnt(t->l)), l = t;
upd_cnt(t);
}
void split(pitem t, pitem& l, pitem& r, int key, int add = 0) {
if (!t) return void(l = r = 0);
int cur_key = add + cnt(t->l);
if (key <= cur_key)
split(t->l, l, t->l, key, add), r = t;
else
split(t->r, t->r, r, key, add + 1 + cnt(t->l)), l = t;
upd_cnt(t);
}
void output(pitem t) {
if (!t) return;
output(t->l);
printf("%d ", t->value);
output(t->r);
}
int r(pitem t) {
if (!t) return 0;
return t->cnt - 1;
}
pitem T[5], T1[5], T2[5], T3[5];
int n, x;
char C[120];
int main() {
cout.flags(ios::fixed);
cout.precision(2);
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%s", C);
if (C[0] == 's') {
long long ret = 0;
if (T[2]) ret = T[2]->f;
printf("%I64d\n", ret);
}
if (C[0] == 'a') {
scanf("%d", &x);
long long ind = 0, bst = 1000000000;
for (int j = 0; j < 5; j++) {
split1(T[j], T1[j], T3[j], x);
split(T1[j], T1[j], T2[j], r(T1[j]));
if (T2[j]) {
if (abs(x - T2[j]->value) < bst) {
bst = abs(x - T2[j]->value);
ind = j + 1;
if (ind == 5) ind = 0;
}
}
}
pitem q = new item;
q->prior = (rand() % 10000) * 10000 + rand() % 10000;
q->l = NULL;
q->r = NULL;
q->cnt = 1;
q->value = x;
q->f = x;
merge(T2[ind], T2[ind], q);
for (int j = 0; j < 5; j++) {
merge(T[j], T1[j], T2[j]);
}
for (int j = 0; j < 5; j++) {
merge(T[j], T[j], T3[(j + 4) % 5]);
}
}
if (C[0] == 'd') {
scanf("%d", &x);
long long ind = 0, bst = 1000000000;
for (int j = 0; j < 5; j++) {
split1(T[j], T1[j], T3[j], x + 1);
split(T1[j], T1[j], T2[j], r(T1[j]));
if (T2[j]) {
if (abs(x - T2[j]->value) < bst) {
bst = abs(x - T2[j]->value);
ind = j;
}
}
}
T2[ind] = NULL;
for (int j = 0; j < 5; j++) {
merge(T[j], T1[j], T2[j]);
}
for (int j = 0; j < 5; j++) {
merge(T[j], T[j], T3[(j + 1) % 5]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long n, sum[500][5], sz[500], t = 500, st[500], ed[500], a[100010], mx;
vector<pair<long long, long long> > que;
vector<long long> v;
int main() {
cin >> n;
string s;
long long x;
for (int i = 0; i < n; i++) {
cin >> s;
if (s[0] != 's') {
scanf("%I64d", &x);
if (s[0] == 'a')
v.push_back(x), que.push_back(make_pair(0, x));
else
que.push_back(make_pair(1, x));
} else
que.push_back(make_pair(2, 0));
}
sort(v.begin(), v.end());
for (int i = 0; i < 495; i++) st[i] = -1;
for (int i = 0; i < v.size(); i++) {
if (st[i / t] == -1) st[i / t] = i;
ed[i / t] = i;
}
mx = ((int)v.size() - 1) / t;
for (int i = 0; i < n; i++) {
if (que[i].first == 0) {
long long pos =
lower_bound(v.begin(), v.end(), que[i].second) - v.begin(),
num = pos / t, cur = 0;
a[pos] = que[i].second;
sz[num]++;
for (int j = 0; j < 5; j++) sum[num][j] = 0;
for (int j = st[num]; j <= ed[num]; j++) {
if (a[j] > 0) {
sum[num][cur] += a[j];
cur = (cur + 1) % 5;
}
}
} else if (que[i].first == 1) {
long long pos =
lower_bound(v.begin(), v.end(), que[i].second) - v.begin(),
num = pos / t, cur = 0;
a[pos] = 0;
sz[num]--;
for (int j = 0; j < 5; j++) sum[num][j] = 0;
for (int j = st[num]; j <= ed[num]; j++) {
if (a[j] > 0) {
sum[num][cur] += a[j];
cur = (cur + 1) % 5;
}
}
} else {
long long cur = 0, ans = 0;
for (int i = 0; i < mx + 1; i++) {
ans += sum[i][(2 - cur % 5 + 5) % 5];
cur += sz[i];
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int x;
int size;
long long sum[5];
Node *left, *right;
Node *fa;
Node() {}
Node(int _x, Node *f = NULL, Node *l = NULL, Node *r = NULL) {
x = x, left = l, right = r, fa = f;
}
int lsize() { return left == NULL ? 0 : left->size; }
int rsize() { return right == NULL ? 0 : right->size; }
void pushup() {
memset(sum, 0, sizeof(sum));
if (left != NULL) {
for (int i = 0; i < 5; i++) {
sum[i] += left->sum[i];
}
}
sum[(lsize() + 1) % 5] += x;
if (right != NULL) {
for (int i = 0; i < 5; i++) {
sum[(i + lsize() + 1) % 5] += right->sum[i];
}
}
size = lsize() + rsize() + 1;
}
} *T = NULL;
void rotate(Node *x) {
if (x->fa == NULL) return;
Node *p = x->fa;
if (p->left == x) {
p->left = x->right;
if (x->right) x->right->fa = p;
if (p->fa) {
if (p->fa->left == p)
p->fa->left = x;
else
p->fa->right = x;
}
x->fa = p->fa, x->right = p, p->fa = x;
} else {
p->right = x->left;
if (x->left) x->left->fa = p;
if (p->fa) {
if (p->fa->left == p)
p->fa->left = x;
else
p->fa->right = x;
}
x->fa = p->fa, x->left = p, p->fa = x;
}
p->pushup(), x->pushup();
}
void print(Node *T, string s) {
if (T == NULL) {
cout << s << "NULL" << endl;
return;
}
cout << s << "x:" << T->x << endl;
cout << s << "size:" << T->size << endl;
cout << s << "sum:";
for (int i = 0; i < 5; i++) {
cout << T->sum[i] << " ";
}
cout << endl;
cout << s << "left:" << endl;
print(T->left, s + " ");
cout << s << "right:" << endl;
print(T->right, s + " ");
}
Node *splay(Node *x) {
while (x->fa) {
Node *p = x->fa;
int pd = p->left == x;
if (p->fa) rotate((p->fa->left == p) == pd ? p : x);
rotate(x);
}
return T = x;
}
Node *Insert(Node *T, Node *p, int v) {
if (T == NULL) {
T = new Node();
T->x = v, T->left = T->right = NULL, T->fa = p;
if (p) {
if (v < p->x)
p->left = T;
else
p->right = T;
}
T->pushup();
return T;
}
Node *res;
if (v < T->x)
res = Insert(T->left, T, v);
else
res = Insert(T->right, T, v);
T->pushup();
return res;
}
Node *Find(Node *T, int v) {
if (v == T->x) return T;
if (v < T->x)
return Find(T->left, v);
else
return Find(T->right, v);
}
void add(int v) {
Node *x = Insert(T, NULL, v);
if (!T) T = x;
splay(x);
}
void del(int v) {
Node *x = Find(T, v);
splay(x);
if (!x->left && !x->right) {
delete x;
T = NULL;
} else if (!x->left) {
T = x->right;
T->fa = NULL;
delete x;
} else if (!x->right) {
T = x->left;
T->fa = NULL;
delete x;
} else {
Node *p = T->left;
T->left = p->fa = NULL;
T = T->right, T->fa = NULL;
Node *now = T;
while (now->left != NULL) now = now->left;
splay(now);
T->left = p, p->fa = T;
T->pushup();
delete x;
}
}
int main() {
int n;
scanf("%d", &n);
while (n--) {
char buf[5];
scanf("%s", buf);
if (buf[0] == 'a') {
int x;
scanf("%d", &x);
add(x);
} else if (buf[0] == 'd') {
int x;
scanf("%d", &x);
del(x);
} else
printf("%I64d\n", T == NULL ? 0 : T->sum[3]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s[0] == 's') {
long long ret = 0;
for (int i = 2; i < v.size(); i += 5) ret += v[i];
cout << ret << endl;
} else {
int x;
cin >> x;
if (s[0] == 'a')
v.insert(lower_bound(v.begin(), v.end(), x), x);
else
v.erase(lower_bound(v.begin(), v.end(), x));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
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 ^ 48);
ch = getchar();
}
return x * f;
}
const long long N = 100010;
struct ask {
long long opt, x;
} a[N];
char s[20];
long long n, lsh[N], len, q, d[N << 2][5], f[N << 2];
inline long long getid(long long x) {
return lower_bound(lsh + 1, lsh + q + 1, x) - lsh;
}
inline void pushup(long long p) {
long long ls = p << 1, rs = p << 1 | 1;
f[p] = (f[ls] + f[rs]) % 5;
for (long long i = 0; i < 5; ++i)
d[p][i] = d[ls][i] + d[rs][((i - f[ls]) % 5 + 5) % 5];
}
inline void change(long long p, long long l, long long r, long long x,
long long y) {
if (l == r && r == x) {
if (y == 0)
d[p][1] += lsh[x], f[p] = (f[p] + 1) % 5;
else
d[p][1] -= lsh[x], f[p] = (f[p] + 4) % 5;
return;
}
long long mid = l + r >> 1, ls = p << 1, rs = p << 1 | 1;
if (x <= mid)
change(ls, l, mid, x, y);
else
change(rs, mid + 1, r, x, y);
pushup(p);
}
signed main() {
n = read();
for (long long i = 1; i <= n; ++i) {
scanf("%s", s);
if (s[0] == 'a') lsh[++len] = (a[i].x = read()), a[i].opt = 0;
if (s[0] == 'd') lsh[++len] = (a[i].x = read()), a[i].opt = 1;
if (s[0] == 's') a[i].opt = 2;
}
sort(lsh + 1, lsh + len + 1);
q = unique(lsh + 1, lsh + len + 1) - lsh - 1;
for (long long i = 1; i <= n; ++i)
if (a[i].opt <= 1) a[i].x = getid(a[i].x);
for (long long i = 1; i <= n; ++i) {
long long opt = a[i].opt, x = a[i].x;
if (opt <= 1)
change(1, 1, n, x, opt);
else
printf("%lld\n", q ? d[1][3] : 0);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sq(const T& x) {
return x * x;
}
const int INF = 2147483647;
struct Node {
vector<int> a;
long long s[5];
Node() { update(); }
int size() const { return a.size(); }
void insert(int x) {
a.insert(upper_bound(a.begin(), a.end(), x), x);
update();
}
void erase(int x) {
a.erase(lower_bound(a.begin(), a.end(), x));
update();
}
void update() {
memset(s, 0, sizeof s);
for (size_t i = 0; i < a.size(); ++i) s[i % 5] += a[i];
}
};
struct Kiwi {
list<Node> li;
int size;
Kiwi() : size(0) {}
void insert(int x) {
++size;
auto it = li.begin();
for (; it != li.end(); ++it) {
auto nx = it;
++nx;
int right_bound = (nx == li.end()) ? INF : nx->a[0];
if (x <= right_bound) break;
}
if (it == li.end()) it = li.insert(it, Node());
it->insert(x);
if (sq(it->size()) >= size * 4) {
int gap = sqrt(size + 0.5);
Node node;
node.a.assign(it->a.begin() + gap, it->a.end());
node.update();
it->a.erase(it->a.begin() + gap, it->a.end());
it->update();
li.insert(++it, node);
}
}
void erase(int x) {
--size;
auto it = li.begin();
while (x > it->a.back()) ++it;
it->erase(x);
if (it->size() == 0) {
li.erase(it);
} else if (it != li.begin()) {
auto pv = it;
--pv;
if (sq(pv->size() + it->size()) <= size) {
copy(it->a.begin(), it->a.end(), back_inserter(pv->a));
pv->update();
li.erase(it);
}
}
}
long long sum() const {
long long ret = 0;
int p = 2;
for (auto it = li.begin(); it != li.end(); ++it) {
ret += it->s[p];
p = ((p - (int)it->a.size()) % 5 + 5) % 5;
}
return ret;
}
};
void york() {
int m;
Kiwi b;
char s[32];
scanf("%d", &m);
while (m--) {
scanf("%s", s);
if (s[0] == 's') {
printf("%I64d\n", b.sum());
} else if (s[0] == 'a') {
int t;
scanf("%d", &t);
b.insert(t);
} else {
int t;
scanf("%d", &t);
b.erase(t);
}
}
}
int main() {
york();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool compare(long long int i, long long int j) { return i < j; }
template <typename T>
T gcd(T a, T b);
template <typename T>
T modpow(T number, T power, T mod_value);
struct Information {
deque<long long int> dq, sum;
Information() {
dq.clear();
sum.resize(5, 0);
}
};
const long long int maxN = 2e5;
const long long int maxB = 320;
const long long int INF = 1e14;
long long int current_total;
Information block[maxB];
long long int get_block(long long int n) { return n / maxB; }
void add(long long int num) {
long long int bl = -1;
for (bl = 0; bl < (maxB); bl++) {
if ((block[bl].dq.size() < maxB) || (block[bl].dq.back() > num)) break;
}
if (block[bl].dq.size() < maxB) {
block[bl].dq.push_back(num);
long long int i = block[bl].dq.size() - 1;
for (; i > 0; i--) {
if (block[bl].dq[i] < block[bl].dq[i - 1])
swap(block[bl].dq[i], block[bl].dq[i - 1]);
else
break;
}
block[bl].sum.clear();
block[bl].sum.resize(5, 0);
for (i = 0; i < (block[bl].dq.size()); i++)
block[bl].sum[i % 5] += block[bl].dq[i];
} else {
block[bl].dq.push_back(num);
long long int i = block[bl].dq.size() - 1;
for (; i > 0; i--) {
if (block[bl].dq[i] < block[bl].dq[i - 1])
swap(block[bl].dq[i], block[bl].dq[i - 1]);
else
break;
}
long long int extra = block[bl].dq.back();
block[bl].dq.pop_back();
block[bl].sum.clear();
block[bl].sum.resize(5, 0);
for (i = 0; i < (block[bl].dq.size()); i++)
block[bl].sum[i % 5] += block[bl].dq[i];
for (++bl; bl < maxB; ++bl) {
block[bl].dq.push_front(extra);
long long int bck = block[bl].sum.back();
block[bl].sum.pop_back();
block[bl].sum.push_front(bck);
block[bl].sum[0] += extra;
if (block[bl].dq.size() > maxB) {
extra = block[bl].dq.back();
block[bl].dq.pop_back();
block[bl].sum[0] -= extra;
} else
break;
}
}
}
void del(long long int num) {
long long int bl = -1;
for (bl = 0; bl < (maxB); bl++) {
if (block[bl].dq.back() >= num) break;
}
assert(bl >= 0 && bl < maxB);
if (block[bl + 1].dq.size() == 0) {
long long int i;
for (i = 0;; i++) {
if (block[bl].dq[i] == num) break;
}
for (++i; i < block[bl].dq.size(); i++) {
swap(block[bl].dq[i], block[bl].dq[i - 1]);
}
block[bl].dq.pop_back();
block[bl].sum.clear();
block[bl].sum.resize(5, 0);
for (i = 0; i < (block[bl].dq.size()); i++)
block[bl].sum[i % 5] += block[bl].dq[i];
} else {
long long int extra = block[bl + 1].dq.front();
block[bl + 1].dq.pop_front();
long long int i;
for (i = 0;; i++) {
if (block[bl].dq[i] == num) break;
}
for (++i; i < block[bl].dq.size(); i++) {
swap(block[bl].dq[i], block[bl].dq[i - 1]);
}
block[bl].dq.pop_back();
block[bl].dq.push_back(extra);
block[bl].sum.clear();
block[bl].sum.resize(5, 0);
for (i = 0; i < (block[bl].dq.size()); i++)
block[bl].sum[i % 5] += block[bl].dq[i];
for (++bl; bl < maxB; ++bl) {
block[bl].sum[0] -= extra;
long long int frnt = block[bl].sum.front();
block[bl].sum.pop_front();
block[bl].sum.push_back(frnt);
if (!block[bl + 1].dq.empty()) {
extra = block[bl + 1].dq.front();
block[bl + 1].dq.pop_front();
block[bl].dq.push_back(extra);
block[bl].sum[4] += extra;
} else
break;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int number_of_test_case = 1, test_case;
for (test_case = 1; test_case <= number_of_test_case; test_case++) {
long long int i, j, value, n;
string op;
cin >> n;
current_total = 0;
for (i = 0; i < (n); i++) {
cin >> op;
if (op == "add") {
cin >> value;
add(value);
current_total++;
} else if (op == "del") {
cin >> value;
del(value);
current_total--;
} else if (op == "sum") {
long long int total_block = get_block(current_total) + 1;
long long int sum = 0;
for (j = 0; j < (total_block); j++) sum += block[j].sum[2];
cout << sum << "\n";
}
}
}
return 0;
}
template <typename T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
T modpow(T number, T power, T mod_value) {
if (power == 0) return 1 % mod_value;
long long int u = modpow(number, power / 2, mod_value);
u = (u * u) % mod_value;
if (power % 2 == 1) u = (u * number) % mod_value;
return u;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int v, r, siz;
node* ch[2];
long long sum[5];
void maintain() {
int pre = 0;
int s = 1;
if (ch[0] != NULL) s += ch[0]->siz;
pre = s;
if (ch[1] != NULL) s += ch[1]->siz;
siz = s;
memset(sum, 0, sizeof(sum));
sum[(pre % 5)] = v;
for (int i = 0; i < 5; i++) {
if (ch[0] != NULL) sum[i] += ch[0]->sum[i];
if (ch[1] != NULL) sum[(pre + i) % 5] += ch[1]->sum[i];
}
}
node(int x) {
this->v = x;
this->r = rand();
this->siz = 1;
this->ch[0] = this->ch[1] = NULL;
memset(sum, 0, sizeof(sum));
this->sum[1] = x;
}
int cmp(int x) {
if (x == v) return -1;
return x < v ? 0 : 1;
}
};
node* rt;
void rotate(node*& o, int d) {
node* k = o->ch[d ^ 1];
o->ch[d ^ 1] = k->ch[d];
k->ch[d] = o;
o->maintain();
k->maintain();
o = k;
}
void Insert(node*& o, int v) {
if (o == NULL) {
o = new node(v);
return;
} else {
int d = v < o->v ? 0 : 1;
Insert(o->ch[d], v);
if (o->ch[d]->r > o->r) rotate(o, d ^ 1);
if (o != NULL) o->maintain();
}
}
void Remove(node*& o, int v) {
int d = o->cmp(v);
if (d == -1) {
if (o->ch[0] != NULL && o->ch[1] != NULL) {
int d2 = o->ch[0]->r > o->ch[1]->r ? 1 : 0;
rotate(o, d2);
Remove(o->ch[d2], v);
if (o != NULL) o->maintain();
} else if (o->ch[0] != NULL)
o = o->ch[0];
else
o = o->ch[1];
} else {
Remove(o->ch[d], v);
if (o != NULL) o->maintain();
}
}
int kth(node*& o, int k) {
if (k == 0 || o == NULL || o->siz < k)
return -1;
else {
int s = o->ch[0] == NULL ? 0 : o->ch[0]->siz;
if (k == s + 1)
return o->v;
else if (k <= s)
return kth(o->ch[0], k);
else
return kth(o->ch[1], k - s - 1);
}
}
void print(node*& o) {
if (o == NULL) return;
if (o->ch[0] != NULL) print(o->ch[0]);
printf("v=%d r=%d siz=%d || ", o->v, o->r, o->siz);
if (o->ch[1] != NULL) print(o->ch[1]);
}
string Coms[] = {"add", "del", "sum"};
int n;
int main() {
scanf("%d", &n);
string com;
int x;
for (int i = 0; i < n; i++) {
cin >> com;
if (com == Coms[0]) {
scanf("%d", &x);
Insert(rt, x);
} else if (com == Coms[1]) {
scanf("%d", &x);
Remove(rt, x);
} else {
if (rt == NULL)
printf("0\n");
else {
printf("%lld\n", rt->sum[3]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <class T>
void pvp(T a, T b) {
for (T i = a; i != b; ++i)
cout << "(" << i->first << ", " << i->second << ") ";
cout << endl;
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int in_c() {
int c;
for (; (c = getchar()) <= ' ';) {
if (!~c) throw ~0;
}
return c;
}
int in() {
int x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -in();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
long long In() {
long long x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -In();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
const int F = 5;
int Q, N;
char QT[100010][6];
long long QX[100010];
int QY[100010];
long long xs[100010];
int segn;
int cnt[400010];
long long sum[400010][6];
void merge(int a, int b, int c) {
cnt[a] = cnt[b] + cnt[c];
int f, g;
for (f = 0; f < F; ++f) {
sum[a][f] = sum[b][f];
}
g = cnt[b] % F;
for (f = 0; f < F; ++f) {
sum[a][(f + g) % F] += sum[c][f];
}
}
void add(int a) {
a += segn;
cnt[a] = 1;
sum[a][0] = xs[a - segn];
for (; a >>= 1;) {
merge(a, a << 1 | 0, a << 1 | 1);
}
}
void del(int a) {
a += segn;
cnt[a] = 0;
sum[a][0] = 0;
for (; a >>= 1;) {
merge(a, a << 1 | 0, a << 1 | 1);
}
}
int main() {
int q;
for (; ~scanf("%d", &Q);) {
N = 0;
for (q = 0; q < Q; ++q) {
scanf("%s", QT[q]);
if (!strcmp(QT[q], "add")) {
QX[q] = in();
xs[N++] = QX[q];
} else if (!strcmp(QT[q], "del")) {
QX[q] = in();
xs[N++] = QX[q];
} else {
QX[q] = QY[q] = -1;
}
}
sort(xs, xs + N);
N = unique(xs, xs + N) - xs;
for (q = 0; q < Q; ++q)
if (~QX[q]) {
QY[q] = lower_bound(xs, xs + N, QX[q]) - xs;
}
for (segn = 1; segn < N + 5; segn <<= 1)
;
memset(cnt, 0, sizeof(cnt));
memset(sum, 0, sizeof(sum));
for (q = 0; q < Q; ++q) {
if (!strcmp(QT[q], "add")) {
add(QY[q]);
} else if (!strcmp(QT[q], "del")) {
del(QY[q]);
} else {
cout << sum[1][2] << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> vec;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
string con;
int num;
cin >> con;
if (con[0] == 'a') {
cin >> num;
vec.insert(lower_bound(vec.begin(), vec.end(), num), num);
} else if (con[0] == 'd') {
cin >> num;
vec.erase(lower_bound(vec.begin(), vec.end(), num));
} else {
long long ans = 0;
for (int k = 2; k < vec.size(); k += 5) {
ans += vec[k];
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char cmd[5];
vector<int> v;
long long sum() {
long long s = 0;
for (int i = 2; i < v.size(); i += 5) {
s += v[i];
}
return s;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", cmd);
if (*cmd == 's') {
printf("%I64d\n", sum());
} else {
int k;
scanf("%d", &k);
if (*cmd == 'a')
v.insert(lower_bound(v.begin(), v.end(), k), k);
else
v.erase(lower_bound(v.begin(), v.end(), k));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int flag;
char op[MAXN][10];
long long mod[MAXN << 2][5], sum[MAXN << 2];
int a[MAXN], b[MAXN];
void push_up(int rt) {
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
for (int i = 0; i < 5; i++)
mod[rt][i] =
mod[rt << 1][i] + mod[rt << 1 | 1][((i - sum[rt << 1]) % 5 + 5) % 5];
}
void update(int pos, int add, int l, int r, int rt) {
if (l == r) {
sum[rt] = flag;
mod[rt][1] = flag * add;
return;
}
int m = (l + r) >> 1;
if (pos <= m)
update(pos, add, l, m, rt << 1);
else
update(pos, add, m + 1, r, rt << 1 | 1);
push_up(rt);
}
int main() {
int n, m = 0;
cin >> n;
memset(mod, 0, sizeof(mod));
memset(sum, 0, sizeof(sum));
for (int i = 0; i < n; i++) {
scanf("%s", op[i]);
if (op[i][0] != 's') {
scanf("%d", &a[i]);
b[m++] = a[i];
}
}
sort(b, b + m);
m = unique(b, b + m) - b;
for (int i = 0; i < n; i++) {
if (op[i][0] == 's') {
cout << mod[1][3] << endl;
continue;
}
if (op[i][0] == 'a')
flag = 1;
else
flag = 0;
int pos = lower_bound(b, b + m, a[i]) - b + 1;
update(pos, a[i], 1, n, 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sq(const T& x) {
return x * x;
}
const int INF = 2147483647;
struct Node {
vector<int> a;
long long s[5];
Node() { update(); }
int size() const { return a.size(); }
void insert(int x) {
a.insert(upper_bound(a.begin(), a.end(), x), x);
update();
}
void erase(int x) {
a.erase(lower_bound(a.begin(), a.end(), x));
update();
}
void update() {
memset(s, 0, sizeof s);
for (size_t i = 0; i < a.size(); ++i) s[i % 5] += a[i];
}
};
struct Kiwi {
list<Node> li;
int size;
Kiwi() : size(0) {}
void insert(int x) {
++size;
auto it = li.begin();
for (; it != li.end(); ++it) {
auto nx = it;
++nx;
int right_bound = (nx == li.end()) ? INF : nx->a[0];
if (x <= right_bound) break;
}
if (it == li.end()) it = li.insert(it, Node());
it->insert(x);
if (sq(it->size()) >= size * 4) {
int gap = sqrt(size + 0.5);
Node node;
node.a.assign(it->a.begin() + gap, it->a.end());
node.update();
it->a.erase(it->a.begin() + gap, it->a.end());
it->update();
li.insert(++it, node);
}
}
void erase(int x) {
--size;
auto it = li.begin();
while (x > it->a.back()) ++it;
it->erase(x);
if (it->size() == 0) {
li.erase(it);
} else if (it != li.begin()) {
auto pv = it;
--pv;
if (sq(pv->size() + it->size()) <= size * 1.333333) {
copy(it->a.begin(), it->a.end(), back_inserter(pv->a));
pv->update();
li.erase(it);
}
}
}
long long sum() const {
long long ret = 0;
int p = 2;
for (auto it = li.begin(); it != li.end(); ++it) {
ret += it->s[p];
p = ((p - (int)it->a.size()) % 5 + 5) % 5;
}
return ret;
}
};
void york() {
int m;
Kiwi b;
char s[32];
scanf("%d", &m);
while (m--) {
scanf("%s", s);
if (s[0] == 's') {
printf("%I64d\n", b.sum());
} else if (s[0] == 'a') {
int t;
scanf("%d", &t);
b.insert(t);
} else {
int t;
scanf("%d", &t);
b.erase(t);
}
}
}
int main() {
york();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
template <typename T>
T Max(T a, T b) {
return a > b ? a : b;
}
template <typename T>
T Min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
T Abs(T A) {
return A > 0 ? A : -1 * A;
}
template <typename T>
void Swap(T &a, T &b) {
T tmp = a;
a = b;
b = tmp;
}
const long long LINF = 0x3FFFFFFFFFFFFFFLL;
const int INF = 0X3FFFFFFF;
const int MAXN = 1e5 + 5;
long long sum[MAXN << 2][5];
int cnt[MAXN << 2];
char opt[MAXN][5];
int a[MAXN], c[MAXN];
inline void PushUp(int rt) {
for (int i = 0; i < 5; i++)
sum[rt][i] =
sum[rt << 1][i] + sum[rt << 1 | 1][((i - cnt[rt << 1]) % 5 + 5) % 5];
}
void Build(int l, int r, int rt) {
cnt[rt] = 0;
fill(sum[rt], sum[rt] + 5, 0);
if (l == r) return;
int m = (l + r) >> 1;
Build(l, m, rt << 1);
Build(m + 1, r, rt << 1 | 1);
}
void update(int pos, int val, int col, int l, int r, int rt) {
if (col)
cnt[rt]++;
else
cnt[rt]--;
if (l == r) {
sum[rt][0] = (long long)col * val;
return;
}
int m = (l + r) >> 1;
if (pos <= m)
update(pos, val, col, l, m, rt << 1);
else
update(pos, val, col, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
int main() {
int n;
while (~scanf("%d", &n)) {
int id = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", opt[i]);
if (opt[i][0] != 's') {
scanf("%d", c + i);
a[id++] = c[i];
}
}
sort(a, a + id);
int num = unique(a, a + id) - a;
if (num)
Build(1, num, 1);
else
sum[1][2] = 0;
for (int i = 1; i <= n; i++) {
int pos = lower_bound(a, a + num, c[i]) - a + 1;
if (opt[i][0] == 'a')
update(pos, c[i], 1, 1, num, 1);
else if (opt[i][0] == 'd') {
if (cnt[1]) update(pos, c[i], 0, 1, num, 1);
} else {
if (cnt[1] == 0) sum[1][2] = 0;
printf("%I64d\n", sum[1][2]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 5;
const int maxn = 1e5 + 5;
int N, M, pos[maxn], v[maxn];
map<long long, int> G;
int lc[maxn << 2], rc[maxn << 2], c[maxn << 2];
long long s[maxn << 2][6];
inline void maintain(int u, int d) {
c[u] += d;
memset(s[u], 0, sizeof(s[u]));
s[u][0] = (c[u] ? pos[lc[u]] : 0);
}
inline void pushup(int u) {
int t = c[((u) << 1)] % mod;
c[u] = c[((u) << 1)] + c[(((u) << 1) | 1)];
for (int i = 0; i < mod; i++)
s[u][i] = s[((u) << 1)][i] + s[(((u) << 1) | 1)][(i + mod - t) % mod];
}
void build(int u, int l, int r) {
lc[u] = l;
rc[u] = r;
c[u] = 0;
memset(s[u], 0, sizeof(s[u]));
if (l == r) return;
int mid = (l + r) / 2;
build(((u) << 1), l, mid);
build((((u) << 1) | 1), mid + 1, r);
pushup(u);
}
void modify(int u, int x, int d) {
if (lc[u] == x && rc[u] == x) {
maintain(u, d);
return;
}
int mid = (lc[u] + rc[u]) / 2;
if (x <= mid)
modify(((u) << 1), x, d);
else
modify((((u) << 1) | 1), x, d);
pushup(u);
}
struct OP {
int p, k, id;
OP(int k = 0, int p = 0, int id = 0) {
this->k = k;
this->p = p;
this->id = id;
}
friend bool operator<(const OP& a, const OP& b) {
if (a.k == 0) return false;
if (b.k == 0) return true;
if (a.p != b.p) return a.p < b.p;
return a.id < b.id;
}
};
inline bool cmp(const OP& a, const OP& b) { return a.id < b.id; }
vector<OP> vec;
void init() {
scanf("%d", &N);
char op[5];
int x;
for (int i = 1; i <= N; i++) {
scanf("%s", op);
if (op[0] == 's')
vec.push_back(OP(0, 0, i));
else {
scanf("%d", &x);
vec.push_back(OP(op[0] == 'a' ? 1 : -1, x, i));
}
}
M = 1;
sort(vec.begin(), vec.end());
for (int i = 0; i < N; i++) {
if (vec[i].k < 0) continue;
if (vec[i].k == 0) break;
pos[M] = vec[i].p;
vec[i].p = M++;
}
build(1, 1, M);
}
void solve() {
sort(vec.begin(), vec.end(), cmp);
for (int i = 0; i < N; i++) {
if (vec[i].k == 0)
printf("%lld\n", s[1][2]);
else if (vec[i].k == -1) {
int tmp = vec[i].p;
v[G[tmp]] = 0;
modify(1, G[tmp], -1);
if (G[tmp] <= N && v[G[tmp] + 1] && pos[G[tmp]] == pos[G[tmp] + 1])
G[tmp]++;
else
G[tmp] = 0;
} else {
int tmp = pos[vec[i].p];
v[vec[i].p] = 1;
modify(1, vec[i].p, 1);
if (G[tmp] == 0) G[tmp] = vec[i].p;
}
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1024 * 1024;
long long n;
char op[128];
long long nums[maxn];
long long cnt = 0;
char Op[maxn] = {};
long long data_[maxn] = {};
struct node {
long long move;
long long mods[5];
long long l, r;
node *L, *R;
} pool[maxn << 1], *g[maxn];
node *root = &pool[++cnt];
void new_node(node *&p, int l, int r) {
if (!p) {
p = &pool[++cnt];
p->l = l;
p->r = r;
}
}
void add_(long long l, long long r, long long pos, node *&p, long long num,
long long add) {
new_node(p, l, r);
if (l == r) {
p->mods[1] += num * add;
p->move += add;
return;
}
if (pos <= (l + r) >> 1)
add_(l, (l + r) >> 1, pos, p->L, num, add);
else
add_(1 + (l + r) >> 1, r, pos, p->R, num, add);
new_node(p->L, l, (l + r) >> 1);
new_node(p->R, 1 + (l + r) >> 1, r);
p->move = p->L->move + p->R->move;
for (long long i = 0; i < 5; i++)
p->mods[i] = p->L->mods[i] + p->R->mods[((i - p->L->move) % 5 + 5) % 5];
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> op;
Op[i] = op[0];
if (op[0] != 's') {
cin >> nums[i];
data_[i] = nums[i];
}
}
sort(nums + 1, nums + n + 1);
long long o = unique(nums + 1, nums + n + 1) - nums - 1;
for (long long i = 1; i <= n; i++)
data_[i] = lower_bound(nums + 1, nums + o + 1, data_[i]) - nums;
for (long long i = 1; i <= n; i++)
if (Op[i] == 's')
cout << root->mods[3] << endl;
else if (Op[i] == 'a')
add_(1, n, data_[i], root, nums[data_[i]], 1);
else
add_(1, n, data_[i], root, nums[data_[i]], -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<char, int> ev[100000];
vector<int> mp;
int sz, ii[100001], z[400100];
struct d {
long long x[5];
d() {}
inline void rt(int of) {
long long t[5];
int k = of % 5;
if (k < 0) k += 5;
for (int i = 0; i < 5; ++i) {
t[k] = x[i];
if (++k == 5) k = 0;
}
for (int i = 0; i < 5; ++i) x[i] = t[i];
}
inline d operator+(const d &o) const {
d t;
for (int i = 0; i < 5; ++i) t.x[i] = x[i] + o.x[i];
return t;
}
} s[400100];
inline int gti(int i) {
int an = 0;
while (i) an += ii[i], i ^= i & -i;
return an;
}
inline void adi(int i, int x) {
while (i <= sz) ii[i] += x, i += i & -i;
}
inline void sl(int id, int of) {
s[id].rt(of);
z[id] += of;
}
inline void wa(int id) {
if (z[id]) {
sl(id << 1, z[id]);
sl(id << 1 | 1, z[id]);
z[id] = 0;
}
}
void ad(int i, int x, int c, int id = 1, int l = 1, int r = sz + 1) {
if (l + 1 == r) {
s[id].x[c] += x;
return;
}
wa(id);
int m = l + r >> 1, a = id << 1, b = id << 1 | 1;
if (i < m)
ad(i, x, c, a, l, m);
else
ad(i, x, c, b, m, r);
s[id] = s[a] + s[b];
}
void rt(int of, int x, int y = sz + 1, int id = 1, int l = 1, int r = sz + 1) {
if (x >= r || y <= l) return;
if (l >= x && r <= y) {
sl(id, of);
return;
}
wa(id);
int m = l + r >> 1, a = id << 1, b = id << 1 | 1;
rt(of, x, y, a, l, m);
rt(of, x, y, b, m, r);
s[id] = s[a] + s[b];
}
int main() {
int n;
scanf("%d", &n);
char in[5];
for (int i = 0; i < n; ++i) {
scanf("%s", in);
if (in[0] == 's') continue;
int t;
scanf("%d", &t);
if (in[0] == 'a')
ev[i] = make_pair(1, t);
else
ev[i] = make_pair(2, t);
mp.push_back(t);
}
sort(mp.begin(), mp.end());
sz = unique(mp.begin(), mp.end()) - mp.begin();
mp.resize(sz);
for (int i = 0; i < n; ++i) {
if (ev[i].first) {
int of = ev[i].first == 2 ? -1 : 1;
int x = lower_bound(mp.begin(), mp.end(), ev[i].second) - mp.begin() + 1;
int z = gti(x - 1);
adi(x, of);
if (of == 1) {
rt(of, x + 1);
ad(x, ev[i].second, z % 5);
} else {
ad(x, -ev[i].second, z % 5);
rt(of, x + 1);
}
} else
printf("%lld\n", s[1].x[2]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Tree {
int l, r;
int size;
Tree *L, *R;
long long sum[5];
Tree() {
for (int i = 0; i < 5; i++) sum[i] = 0;
size = 0;
}
void update() {
int offset = L->size % 5;
for (int i = 0; i < 5; i++) {
sum[i] = L->sum[i] + R->sum[(i + 5 - offset) % 5];
}
size = L->size + R->size;
}
Tree(int _l, int _r);
void change(int x, int op);
}* null = new Tree;
Tree::Tree(int a, int b) {
l = a;
r = b;
for (int i = 0; i < 5; i++) sum[0] = 0;
size = 0;
L = R = null;
}
void Tree::change(int x, int op) {
if (l + 1 == r) {
for (int i = 0; i < 5; i++) sum[i] = 0;
if (op == 1) {
sum[0] = x;
}
size = op;
return;
}
int m = (l + r) >> 1;
if (x < m) {
if (L == null) {
L = new Tree(l, m);
}
L->change(x, op);
} else {
if (R == null) {
R = new Tree(m, r);
}
R->change(x, op);
}
update();
}
Tree* root = new Tree(0, int(1e9) + 1);
int main() {
int q;
scanf("%d", &q);
while (q--) {
char buf[100];
int x;
scanf("%*c%s", buf);
if (buf[0] == 'a') {
scanf("%d", &x);
root->change(x, 1);
} else if (buf[0] == 'd') {
scanf("%d", &x);
root->change(x, 0);
} else {
cout << root->sum[2] << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long double EPS = 1e-6;
const int BL = 5;
const int N = 100010;
int size = 0;
vector<int> a;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
while (n--) {
string op;
cin >> op;
if (op == "add") {
int x;
cin >> x;
a.insert(lower_bound(a.begin(), a.end(), x), x);
} else if (op == "del") {
int x;
cin >> x;
a.erase(lower_bound(a.begin(), a.end(), x));
} else if (op == "sum") {
long long ans = 0;
for (int i = 2; i < (int)a.size(); i += 5) ans += a[i];
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sq(const T& x) {
return x * x;
}
const int INF = 2147483647;
struct Node {
vector<int> a;
long long s[5];
Node() { update(); }
int size() const { return a.size(); }
void insert(int x) {
a.insert(upper_bound(a.begin(), a.end(), x), x);
update();
}
void erase(int x) {
a.erase(lower_bound(a.begin(), a.end(), x));
update();
}
void update() {
memset(s, 0, sizeof s);
for (size_t i = 0; i < a.size(); ++i) s[i % 5] += a[i];
}
};
struct Kiwi {
list<Node> li;
int size;
Kiwi() : size(0) {}
void insert(int x) {
++size;
auto it = li.begin();
for (; it != li.end(); ++it) {
auto nx = it;
++nx;
int right_bound = (nx == li.end()) ? INF : nx->a[0];
if (x <= right_bound) break;
}
if (it == li.end()) it = li.insert(it, Node());
it->insert(x);
if (sq(it->size()) >= max(size * 4, 64)) {
int gap = sqrt(size + 0.5);
Node node;
node.a.assign(it->a.begin() + gap, it->a.end());
node.update();
it->a.erase(it->a.begin() + gap, it->a.end());
it->update();
li.insert(++it, node);
}
}
void erase(int x) {
--size;
auto it = li.begin();
while (x > it->a.back()) ++it;
it->erase(x);
if (it->size() == 0) {
li.erase(it);
} else if (it != li.begin()) {
auto pv = it;
--pv;
if (sq(pv->size() + it->size()) <= size) {
copy(it->a.begin(), it->a.end(), back_inserter(pv->a));
pv->update();
li.erase(it);
}
}
}
long long sum() const {
long long ret = 0;
int p = 2;
for (auto it = li.begin(); it != li.end(); ++it) {
ret += it->s[p];
p = ((p - (int)it->a.size()) % 5 + 5) % 5;
}
return ret;
}
};
void york() {
int m;
Kiwi b;
char s[32];
scanf("%d", &m);
while (m--) {
scanf("%s", s);
if (s[0] == 's') {
printf("%I64d\n", b.sum());
} else if (s[0] == 'a') {
int t;
scanf("%d", &t);
b.insert(t);
} else {
int t;
scanf("%d", &t);
b.erase(t);
}
}
}
int main() {
york();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x;
string s;
pair<string, int> W[100021];
vector<int> V;
map<int, int> M;
int ilosc[262163];
long long D[262163][5];
void Dzewo(int p, string c, int x) {
p += 131071;
if (c == "add") {
D[p][0] = x;
ilosc[p] = 1;
while (p > 1) {
p /= 2;
ilosc[p]++;
for (int i = 0; i < 5; i++)
D[p][i] = D[p * 2][i] + D[p * 2 + 1][((i - ilosc[p * 2]) % 5 + 5) % 5];
}
} else {
D[p][0] = 0;
ilosc[p] = 0;
while (p > 1) {
p /= 2;
ilosc[p]--;
for (int i = 0; i < 5; i++)
D[p][i] = D[p * 2][i] + D[p * 2 + 1][((i - ilosc[p * 2]) % 5 + 5) % 5];
}
}
}
int main() {
V.push_back(-1);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
if (s == "add") {
scanf("%i", &x);
W[i] = {"add", x};
V.push_back(x);
}
if (s == "del") {
scanf("%i", &x);
W[i] = {"del", x};
}
}
sort(V.begin(), V.end());
int l = 0;
for (int i = 1; i < V.size(); i++) {
if (V[i] != V[i - 1]) {
l++;
M[V[i]] = l;
}
}
for (int i = 0; i < n; i++) {
if (W[i].first == "add" || W[i].first == "del") {
Dzewo(M[W[i].second], W[i].first, W[i].second);
} else {
printf("%lld \n", D[1][2]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int cnt;
long long sum[6];
};
node seg[4 * 100000];
struct info {
string str;
int num;
};
info data[100000 + 20];
map<int, int> m;
vector<int> v;
string s;
void insert(int idx, int st, int ed, int pos, int val) {
if (st == ed) {
if (val < 0)
seg[idx].cnt = 0;
else
seg[idx].cnt = 1;
seg[idx].sum[1] += val;
return;
}
int lft, rgt, mid, tmp1, tmp2, var, i;
mid = (st + ed) / 2;
lft = 2 * idx;
rgt = lft + 1;
if (pos <= mid)
insert(lft, st, mid, pos, val);
else if (pos > mid)
insert(rgt, mid + 1, ed, pos, val);
seg[idx].cnt = seg[lft].cnt + seg[rgt].cnt;
tmp1 = seg[lft].cnt;
tmp2 = seg[rgt].cnt;
for (i = 1; i <= 5; i++) seg[idx].sum[i] = 0;
for (i = 1; i <= 5; i++) {
var = i % 5;
if (var == 0) var = 5;
seg[idx].sum[var] += seg[lft].sum[i];
}
for (i = 1; i <= 5; i++) {
var = (tmp1 + i) % 5;
if (var == 0) var = 5;
seg[idx].sum[var] += seg[rgt].sum[i];
}
}
int main() {
int t, k, i, val, pos, sz;
cin >> t;
m.clear();
v.clear();
for (k = 1; k <= t; k++) {
s.clear();
cin >> s;
data[k].str = s;
if (s == "sum") {
data[k].num = 0;
continue;
}
cin >> val;
if (s == "add") v.push_back(val);
data[k].num = val;
}
sort(v.begin(), v.end());
sz = v.size();
for (i = 0; i < sz; i++) m[v[i]] = i + 1;
for (i = 1; i <= t; i++) {
s.clear();
s = data[i].str;
val = data[i].num;
pos = m[val];
if (s == "add")
insert(1, 1, sz, pos, val);
else if (s == "del")
insert(1, 1, sz, pos, -val);
else if (s == "sum")
cout << seg[1].sum[3] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > qrs;
long long int sum[5][320], ans;
int num[320];
bool exist[200005];
vector<int> f;
int input(int n) {
int i, j, k, l = 0, m;
char str[10];
string s;
map<int, int> M;
for (i = 1; i <= n; i++) {
scanf("%s", str);
s = str;
if (s == "sum") {
k = 0;
m = -1;
} else {
scanf("%d", &m);
if (s == "add")
k = 1;
else
k = 2;
if (!M[m]) {
M[m] = ++l;
f.push_back(m);
}
}
qrs.push_back(make_pair(k, m));
}
sort(f.begin(), f.end());
M.clear();
for (i = 0; i < f.size(); i++) M[f[i]] = i + 1;
for (i = 0; i < qrs.size(); i++) {
if (qrs[i].first) qrs[i].second = M[qrs[i].second] - 1;
}
return l;
}
void add(int k, int m, int l) {
int i, j, x, y, z;
j = k / l;
for (i = 0, x = 0; i < j; i++) x += num[i];
exist[k] = 1;
for (i = 0; i < 5; i++) sum[i][j] = 0;
x = x % 5;
for (i = j * l; i < (j + 1) * l && i < m; i++) {
if (exist[i]) {
if (x >= 5) x -= 5;
sum[x][j] += f[i];
x++;
}
}
num[j]++;
for (i = j + 1; i < l; i++) {
long long int temp = sum[4][i];
for (x = 4; x > 0; x--) sum[x][i] = sum[x - 1][i];
sum[0][i] = temp;
}
return;
}
void del(int k, int m, int l) {
int i, j, x, y, z;
j = k / l;
for (i = 0, x = 0; i < j; i++) x += num[i];
exist[k] = 0;
for (i = 0; i < 5; i++) sum[i][j] = 0;
x = x % 5;
for (i = j * l; i < (j + 1) * l && i < m; i++) {
if (exist[i]) {
if (x >= 5) x -= 5;
sum[x][j] += f[i];
x++;
}
}
num[j]--;
for (i = j + 1; i < l; i++) {
long long int temp = sum[0][i];
for (x = 1; x < 5; x++) sum[x - 1][i] = sum[x][i];
sum[4][i] = temp;
}
return;
}
long long int get_sum(int l) {
long long int ret = 0;
for (int i = 0; i < l; i++) ret += sum[2][i];
return ret;
}
int main() {
int i, j, k, l, m, n;
long long int ans;
scanf("%d", &n);
m = input(n);
l = (int)sqrt(m + .0) + 1;
for (i = 0; i < n; i++) {
if (qrs[i].first == 1)
add(qrs[i].second, m, l);
else if (qrs[i].first == 2)
del(qrs[i].second, m, l);
else
printf("%lld\n", get_sum(l));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> q;
vector<int>::iterator it;
int n;
int main() {
char op[5];
int a;
while (scanf("%d", &n) != EOF) {
q.clear();
for (int i = 0; i < n; i++) {
scanf("%s", op);
if (op[0] == 'a') {
scanf("%d", &a);
it = lower_bound(q.begin(), q.end(), a);
q.insert(it, a);
} else if (op[0] == 'd') {
scanf("%d", &a);
it = lower_bound(q.begin(), q.end(), a);
q.erase(it);
} else {
long long ans = 0;
for (it = q.begin() + 2; it < q.end(); it += 5) {
ans += *it;
}
printf("%I64d\n", ans);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, Q;
const int maxn = (1 << 17);
pair<int, int> q[maxn];
map<int, int> mp;
long long sum[4 * maxn][5];
int cnt[4 * maxn];
void update(int v) {
cnt[v] = cnt[v * 2] + cnt[v * 2 + 1];
for (int i = 0; i < 5; i++)
sum[v][i] = sum[v * 2][i] + sum[v * 2 + 1][(i - cnt[v * 2] % 5 + 5) % 5];
return;
}
int main() {
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
string s;
cin >> s;
if (s[0] == 's') {
q[i].first = 2, q[i].second = 0;
continue;
}
int x;
scanf("%d", &x);
if (s[0] == 'a')
q[i] = make_pair(0, x);
else if (s[0] == 'd')
q[i] = make_pair(1, x);
mp[x] = 0;
}
n = 0;
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); it++)
it->second = n++;
for (int i = 0; i < Q; i++) {
if (q[i].first == 2)
cout << sum[1][2] << endl;
else {
int pos = maxn + mp[q[i].second];
cnt[pos] = 1 - q[i].first;
sum[pos][0] = cnt[pos] * (long long)q[i].second;
while (pos > 1) {
pos /= 2;
update(pos);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pli = pair<ll, int>;
const int INF = 0x3f3f3f3f, N = 2e5 + 5;
const ll LINF = 1e18 + 5;
int n, a[N], b[N], p[N];
char op[5];
struct seg {
int l, r, sz;
ll sum[5];
} t[N << 2];
void pushup(int p) {
t[p].sz = (t[p << 1].sz + t[p << 1 | 1].sz) % 5;
for (int i = 0; i < 5; i++)
t[p].sum[i] =
(t[p << 1].sum[i] + t[p << 1 | 1].sum[(i - t[p << 1].sz + 5) % 5]);
}
void build(int p, int l, int r) {
t[p].l = l, t[p].r = r;
if (l == r) return;
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
}
void modify(int p, int x, int v) {
int l = t[p].l, r = t[p].r;
if (l == r) {
t[p].sz += (v > 0 ? 1 : -1);
t[p].sum[0] += v;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
modify(p << 1, x, v);
else
modify(p << 1 | 1, x, v);
pushup(p);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
build(1, 1, n);
int tot = 0;
for (int i = 1; i <= n; i++) {
cin >> op;
if (op[0] == 'a') {
cin >> a[i];
b[++tot] = a[i];
p[i] = a[i];
} else if (op[0] == 'd') {
cin >> a[i];
b[++tot] = a[i];
p[i] = -a[i];
}
}
sort(b + 1, b + tot + 1);
tot = unique(b + 1, b + tot + 1) - b - 1;
for (int i = 1; i <= n; i++)
if (a[i]) a[i] = lower_bound(b + 1, b + tot + 1, a[i]) - b;
for (int i = 1; i <= n; i++) {
if (a[i])
modify(1, a[i], p[i]);
else
cout << t[1].sum[2] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int size = 1, key, prior;
long long sum[5] = {0, 0, 0, 0, 0};
node *left = NULL, *right = NULL;
node() {
memset(this, 0, sizeof *this);
size = 1;
}
node(const int& k, const int& p) {
memset(this, 0, sizeof *this);
size = 1;
key = k;
prior = p;
}
void update() {
int cur = 0;
memset(sum, 0, sizeof sum);
if (left) {
cur = left->size;
for (int i = 0; i < 5; i++) sum[i] = left->sum[i];
}
sum[cur++ % 5] += key;
if (right) {
for (int i = 0; i < 5; i++) sum[(i + cur) % 5] += right->sum[i];
cur += right->size;
}
size = cur;
}
};
node* root;
void merge(node* left, node* right, node*& root = ::root) {
if (!left || !right) {
root = left ? left : right;
} else if (left->prior < right->prior) {
merge(left, right->left, right->left);
root = right;
} else {
merge(left->right, right, left->right);
root = left;
}
if (root) root->update();
}
void split(node*& left, node*& right, const int& key, node* root = ::root) {
if (!root) return void(left = right = NULL);
if (key < root->key) {
split(left, root->left, key, root->left);
right = root;
} else {
split(root->right, right, key, root->right);
left = root;
}
if (root) root->update();
}
void add(const int& key, const int& p) {
node *l, *r, *m = new node(key, p);
split(l, r, key);
merge(l, m);
merge(root, r);
}
node* find(const int& key, node* cur = ::root) {
if (!cur) return NULL;
if (cur->key == key) return cur;
if (cur->key < key) return find(key, cur->left);
return find(key, cur->right);
}
void del(const int& key, node*& cur = root) {
if (!cur) return;
if (cur->key == key)
merge(cur->left, cur->right, cur);
else if (cur->key < key)
del(key, cur->right);
else
del(key, cur->left);
if (cur) cur->update();
}
namespace _Orz_ascchrvalstr_ {
int main() {
srand(1731624);
int n, x;
char str[5];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", str);
if (str[0] == 'a') {
scanf("%d", &x);
add(x, rand());
} else if (str[0] == 'd') {
scanf("%d", &x);
del(x);
} else {
cout << (root ? root->sum[2] : 0) << '\n';
}
}
return 0;
}
} // namespace _Orz_ascchrvalstr_
int main() { return _Orz_ascchrvalstr_::main(); }
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 40;
const int inf = 0x3fffffff;
void read(int &x) {
char ch;
bool flag = 0;
for (ch = getchar(); !isdigit(ch) && ((flag |= (ch == '-')) || 1);
ch = getchar())
;
for (x = 0; isdigit(ch); x = (x << 1) + (x << 3) + ch - 48, ch = getchar())
;
x *= 1 - 2 * flag;
}
long long n;
long long tree[maxn << 2][11];
struct inof {
long long val;
char s[7];
} p[maxn];
long long t1;
long long val[maxn];
int get(int tmp) { return lower_bound(val, val + t1, tmp) - val + 1; }
long long siz[maxn << 2];
void pushup(int rt) {
siz[rt] = siz[rt * 2] + siz[rt * 2 + 1];
for (int i = 0; i < 5; i++) {
long long k = (siz[rt << 1] + i) % 5;
tree[rt][k] = tree[rt << 1][k] + tree[rt << 1 | 1][i];
}
}
void update(long long l, long long r, long long rt, long long temp,
long long tmp, long long fuck) {
if (l > temp || r < temp) return;
if (l == r) {
siz[rt] += tmp;
tree[rt][1] += fuck;
return;
}
long long mid = (l + r) / 2;
update(l, mid, rt * 2, temp, tmp, fuck);
update(mid + 1, r, rt * 2 + 1, temp, tmp, fuck);
pushup(rt);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].s;
if (p[i].s[0] != 's') cin >> p[i].val;
if (p[i].s[0] == 'a') val[t1++] = p[i].val;
}
sort(val, val + t1);
for (int i = 0; i < n; i++) {
if (p[i].s[0] == 'a') {
update(1, t1, 1, get(p[i].val), 1, p[i].val);
} else if (p[i].s[0] == 'd')
update(1, t1, 1, get(p[i].val), -1, -p[i].val);
else {
printf("%lld\n", tree[1][3]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 50005;
const int inf = 0x3f3f3f3f;
const long long INF = 1000000000000000000ll;
const long long mod = 998244353;
const double pi = acos(-1.0);
const double eps = 1e-6;
vector<int> rec;
struct OP {
char str[4];
int num;
void get() {
scanf("%s", str);
if (str[0] == 'a' || str[0] == 'd') {
scanf("%d", &num);
}
}
} op[N];
struct node {
int l, r, cnt;
long long num[5];
int nt;
void init() {
memset(num, 0, sizeof(num));
cnt = 0;
}
node() {}
node(int l, int r, int nt) {
this->l = l;
this->r = r;
this->nt = nt;
}
void Equal(node tmp) {
for (int i = 0; i < 5; i++) {
num[i] = tmp.num[i];
}
nt = tmp.nt;
cnt = tmp.cnt;
}
};
struct segTree {
node tree[N * 4];
void build(int l, int r, int id) {
tree[id] = node(l, r, 1);
tree[id].init();
if (l == r) return;
int mid = ((l + r) >> 1);
build(l, mid, (id << 1));
build(mid + 1, r, (id << 1 | 1));
}
void pushUp(int id) {
tree[id].Equal(tree[(id << 1)]);
int nt = tree[(id << 1)].nt;
for (int i = 1, j = nt, cnt = 1; cnt <= 5;
i = (i + 1) % 5, j = (j + 1) % 5, cnt++) {
if (tree[(id << 1 | 1)].num[i] == 0) break;
tree[id].num[j] += tree[(id << 1 | 1)].num[i];
}
tree[id].cnt += tree[(id << 1 | 1)].cnt;
tree[id].nt = (tree[id].nt + tree[(id << 1 | 1)].cnt) % 5;
}
void update(int id, int pos, int val) {
int l = tree[id].l, r = tree[id].r;
if (l == r) {
tree[id].num[1] += val;
if (val > 0)
tree[id].nt++, tree[id].cnt++;
else
tree[id].nt--, tree[id].cnt--;
return;
}
int mid = ((l + r) >> 1);
if (pos <= mid)
update((id << 1), pos, val);
else
update((id << 1 | 1), pos, val);
pushUp(id);
}
} segT;
map<int, int> mp;
void discre() {
sort(rec.begin(), rec.end());
int siz = rec.size();
for (int i = 0; i < siz; i++) {
mp.insert(pair<int, int>(rec[i], i));
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
op[i].get();
if (op[i].str[0] == 'a') rec.push_back(op[i].num);
}
discre();
if (rec.size() == 0) {
printf("0\n");
return 0;
}
segT.build(0, rec.size() - 1, 1);
for (int i = 1; i <= n; i++) {
if (op[i].str[0] == 'a') {
segT.update(1, mp[op[i].num], op[i].num);
} else if (op[i].str[0] == 'd') {
segT.update(1, mp[op[i].num], -op[i].num);
} else {
printf("%lld\n", segT.tree[1].num[3]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100003;
const int OP_LEN = 4;
int n, x;
char op[OP_LEN];
struct node {
int x, size;
node *fa, *lc, *rc;
long long sum[5];
node() {}
node(int X) : x(X), size(1), fa(NULL), lc(NULL), rc(NULL) {
memset(sum, 0, sizeof sum);
sum[0] = X;
}
} T[MaxN];
int T_tot;
node* root;
inline node* newnode() { return T + (T_tot++); }
inline void update(node* x) {
register int p = 0;
x->size = 0;
for (register int i = 0; i < 5; ++i) x->sum[i] = 0;
if (x->lc != NULL) {
for (register int i = 0; i < 5; ++i) x->sum[i] += x->lc->sum[i];
p = x->lc->size % 5;
x->size += x->lc->size;
}
x->sum[p] += x->x;
x->size++;
p = (p + 1) % 5;
if (x->rc != NULL) {
for (register int i = 0; i < 5; ++i) x->sum[(i + p) % 5] += x->rc->sum[i];
x->size += x->rc->size;
}
}
inline void left_rotate(node* x) {
node* r = x->rc;
x->rc = r->lc;
if (r->lc != NULL) r->lc->fa = x;
r->fa = x->fa;
if (x->fa != NULL) {
if (x == x->fa->lc)
x->fa->lc = r;
else
x->fa->rc = r;
} else {
root = r;
}
r->lc = x;
x->fa = r;
update(x);
update(x->fa);
}
inline void right_rotate(node* x) {
node* l = x->lc;
x->lc = l->rc;
if (l->rc != NULL) l->rc->fa = x;
l->fa = x->fa;
if (x->fa != NULL) {
if (x == x->fa->lc)
x->fa->lc = l;
else
x->fa->rc = l;
} else {
root = l;
}
l->rc = x;
x->fa = l;
update(x);
update(x->fa);
}
inline void splay(node* x) {
while (x->fa != NULL) {
if (x->fa->fa == NULL) {
if (x == x->fa->lc)
right_rotate(x->fa);
else
left_rotate(x->fa);
} else if (x == x->fa->lc && x->fa == x->fa->fa->lc) {
right_rotate(x->fa->fa);
right_rotate(x->fa);
} else if (x == x->fa->rc && x->fa == x->fa->fa->rc) {
left_rotate(x->fa->fa);
left_rotate(x->fa);
} else if (x == x->fa->lc && x->fa == x->fa->fa->rc) {
right_rotate(x->fa);
left_rotate(x->fa);
} else {
left_rotate(x->fa);
right_rotate(x->fa);
}
}
}
void dfs(const node* root) {
printf("T[%d]:x:%d fa:%d lc:%d rc:%d\n", root - T, root->x,
(root->fa == NULL ? -1 : root->fa - T),
(root->lc == NULL ? -1 : root->lc - T),
(root->rc == NULL ? -1 : root->rc - T));
printf("sum:");
for (register int i = 0; i < 5; ++i) printf("%I64d ", root->sum[i]);
putchar('\n');
if (root->lc != NULL) dfs(root->lc);
if (root->rc != NULL) dfs(root->rc);
}
node* insert_recursive(node* p, const int& key) {
if (key < p->x) {
if (p->lc == NULL) {
p->lc = newnode();
p->lc->fa = p;
p->lc->x = key;
update(p->lc);
update(p);
return p->lc;
} else {
node* ret = insert_recursive(p->lc, key);
if (ret != NULL) update(p);
return ret;
}
} else if (key > p->x) {
if (p->rc == NULL) {
p->rc = newnode();
p->rc->fa = p;
p->rc->x = key;
update(p->rc);
update(p);
return p->rc;
} else {
node* ret = insert_recursive(p->rc, key);
if (ret != NULL) update(p);
return ret;
}
} else {
return NULL;
}
}
inline void add(const int& key) {
if (root == NULL) {
root = newnode();
root->x = key;
update(root);
return;
}
node* p = insert_recursive(root, key);
if (p == NULL) return;
splay(p);
root = p;
}
inline node* find(const int& key) {
node* p = root;
while (p != NULL) {
if (key == p->x) return p;
if (key < p->x)
p = p->lc;
else
p = p->rc;
}
return p;
}
inline void del(const int& key) {
node* p = find(key);
if (p == NULL) return;
splay(p);
root = p;
if (root->size == 1) {
root = NULL;
return;
}
if (p->lc == NULL) {
p->rc->fa = NULL;
root = p->rc;
} else if (p->rc == NULL) {
p->lc->fa = NULL;
root = p->lc;
} else {
node* t = p->lc;
p->lc->fa = NULL;
while (t->rc != NULL) t = t->rc;
splay(t);
p->rc->fa = t;
t->rc = p->rc;
update(t);
root = t;
}
}
int main() {
scanf("%d", &n);
for (int I = 1; I <= n; ++I) {
scanf("%s", op);
if (!strncmp(op, "add", 3)) {
scanf("%d", &x);
add(x);
} else if (!strncmp(op, "del", 3)) {
scanf("%d", &x);
del(x);
} else if (!strncmp(op, "sum", 3)) {
if (root == NULL)
puts("0");
else
printf("%I64d\n", root->sum[2]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
namespace segment_tree {
struct Node {
long long a[5];
int sum;
inline void print() {
for (int i = (0); i <= (4); i++) printf("%I64d ", a[i]);
printf("%d \n", sum);
}
} q[400010];
int root;
inline void update(int o, int y) {
if (y > 0)
q[o] = (Node){y, 0, 0, 0, 0, 1};
else
q[o] = (Node){0, 0, 0, 0, 0, 0};
}
inline void pushup(int o) {
int l = q[2 * o].sum;
for (int i = (0); i <= (4); i++)
q[o].a[i] = q[2 * o].a[i] + q[2 * o + 1].a[((i - l) % 5 + 5) % 5];
q[o].sum = q[2 * o].sum + q[2 * o + 1].sum;
}
inline void add(int l, int r, int o, int x, int y) {
if (l == r) {
update(o, y);
return;
}
int mid = (l + r) / 2;
if (x <= mid)
add(l, mid, 2 * o, x, y);
else
add(mid + 1, r, 2 * o + 1, x, y);
pushup(o);
}
} // namespace segment_tree
struct ops {
int op, x, y;
} a[400010];
pair<int, int> b[400010];
int cnt;
int len;
int main() {
using namespace segment_tree;
root = 1;
int n = read();
char op[10];
for (int i = (1); i <= (n); i++) {
scanf("%s", op);
if (op[0] == 'a') {
int x = read();
a[i] = (ops){1, x, 0};
b[++cnt] = make_pair(x, i);
} else if (op[0] == 'd') {
int x = read();
a[i] = (ops){2, x, 0};
b[++cnt] = make_pair(x, i);
} else {
a[i] = (ops){3, 0, 0};
}
}
sort(b + 1, b + cnt + 1);
for (int i = (1); i <= (cnt); i++) {
if (b[i].first != b[i - 1].first) len++;
a[b[i].second].y = len;
}
for (int i = (1); i <= (n); i++) {
if (a[i].op == 1) {
add(1, len, 1, a[i].y, a[i].x);
} else if (a[i].op == 2) {
add(1, len, 1, a[i].y, -a[i].x);
} else {
printf("%I64d\n", q[1].a[2]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, f = 0;
register char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ '0'), c = getchar();
return f ? -x : x;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 1e5 + 10;
string op;
int n, x;
long long sum;
vector<int> ans;
bool flag;
signed main() {
ios::sync_with_stdio(0);
cin >> n;
for (register int i = 1; i <= n; ++i) {
cin >> op;
if (op[0] == 'a')
cin >> x, ans.insert(lower_bound(ans.begin(), ans.end(), x), x);
else if (op[0] == 'd')
cin >> x, ans.erase(lower_bound(ans.begin(), ans.end(), x));
else {
if (flag) {
cout << sum << '\n';
continue;
}
sum = 0;
for (register int i = 2; i < ans.size(); i += 5) sum += ans[i];
cout << sum << '\n';
flag = 1;
continue;
}
flag = 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5;
int n, m;
int seg[MAXN * 8];
long long modSum[5][MAXN * 8];
set<int> ord;
set<int>::iterator it;
unordered_map<int, int> comp;
int discomp[MAXN];
long long sum;
queue<pair<char, int> > fila;
void update(int pos, int ini, int fim, int id, int val);
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
char type[5];
int aux = 0;
scanf(" %s", type);
if (type[0] != 's') scanf("%d", &aux);
if (aux != 0) ord.insert(aux);
fila.push(make_pair(type[0], aux));
}
for (it = ord.begin(); it != ord.end(); it++) {
comp[*it] = ++m;
discomp[m] = *it;
}
for (int i = 0; i < n; i++) {
char type = fila.front().first;
int aux = comp[fila.front().second];
fila.pop();
if (type == 'a') update(1, 1, m, aux, 1);
if (type == 'd') update(1, 1, m, aux, -1);
if (type == 's') printf("%lld\n", modSum[3][1]);
}
}
void update(int pos, int ini, int fim, int id, int val) {
if (ini > id || fim < id) return;
if (ini == fim) {
seg[pos] += val;
modSum[1][pos] += val * discomp[ini];
return;
}
int mid = ini + ((fim - ini) >> 1), e = (pos << 1), d = e | 1;
update(e, ini, mid, id, val);
update(d, mid + 1, fim, id, val);
seg[pos] = seg[e] + seg[d];
for (int i = 5; i < 10; i++)
modSum[i - 5][pos] = modSum[i - 5][e] + modSum[(i - (seg[e]) % 5) % 5][d];
return;
}
|
#include <bits/stdc++.h>
using namespace std;
char Str[100005][5];
struct node {
int cnt;
long long sum[5];
} Tree[100005 * 4];
int key[100005];
int Rec[100005];
void build(int r, int ll, int rr) {
Tree[r].cnt = 0;
memset(Tree[r].sum, 0, sizeof(Tree[r].sum));
if (ll == rr) {
return;
}
int mid = (ll + rr) >> 1;
build(r << 1, ll, mid);
build(r << 1 | 1, mid + 1, rr);
}
void update(int r, int ll, int rr, int pos, int f) {
if (ll == rr) {
if (f == -1) {
Tree[r].cnt = 0;
Tree[r].sum[1] = 0;
} else {
Tree[r].cnt = 1;
Tree[r].sum[1] = key[pos - 1];
}
return;
}
int mid = (ll + rr) >> 1;
if (pos <= mid)
update(r << 1, ll, mid, pos, f);
else
update(r << 1 | 1, mid + 1, rr, pos, f);
int offset = Tree[r << 1].cnt;
for (int i = 0; i < 5; ++i) {
Tree[r].sum[i] =
Tree[r << 1].sum[i] + Tree[r << 1 | 1].sum[((i - offset) % 5 + 5) % 5];
}
Tree[r].cnt = Tree[r << 1].cnt + Tree[r << 1 | 1].cnt;
}
int main() {
int n;
scanf("%d", &n);
int tot = 0;
for (int i = 0; i < n; ++i) {
scanf("%s", Str[i]);
if (Str[i][0] != 's') {
int x;
scanf("%d", &x);
key[tot++] = x;
Rec[i] = x;
}
}
sort(key, key + tot);
tot = unique(key, key + tot) - key;
if (tot) build(1, 1, tot);
for (int i = 0; i < n; ++i) {
if (Str[i][0] == 's') {
printf("%I64d\n", Tree[1].sum[3]);
} else {
int pos = lower_bound(key, key + tot, Rec[i]) - key;
pos++;
if (Str[i][0] == 'a') {
update(1, 1, tot, pos, 1);
} else {
update(1, 1, tot, pos, -1);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxk = 1005;
string mul(string a, string b) {
int res[Maxk];
memset(res, 0, sizeof(res));
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
for (int i = 0; i < a.length(); i++) {
for (int j = 0; j < b.length(); j++) {
res[i + j] += (a[i] - '0') * (b[j] - '0');
}
}
for (int i = 0; i < Maxk; i++) {
if (res[i] >= 10) {
res[i + 1] += (res[i] / 10);
res[i] %= 10;
}
}
string ret;
bool flag = false;
for (int i = Maxk - 1; i >= 0; i--) {
if (flag || res[i]) {
flag = true;
ret = ret + (char)(res[i] + '0');
}
}
if (ret == "") ret = "0";
return ret;
}
string add(string a, string b) {
if (a.length() < b.length()) swap(a, b);
while (a.length() != b.length()) {
b = '0' + b;
}
for (int i = a.length() - 1; i >= 0; i--) {
a[i] += (b[i] - '0');
if (a[i] > '9' && i) {
a[i] -= 10;
a[i - 1]++;
}
}
if (a[0] > '9') {
a[0] -= 10;
a = '1' + a;
}
return a;
}
const int Maxn = 100005;
int tot;
struct node {
long long val, fix;
long long sum[5];
int siz;
node *l, *r;
node() {
l = NULL, r = NULL;
memset(sum, 0, sizeof(sum));
val = 0, fix = 0;
}
int lsize() { return (l) ? l->siz : 0; }
int rsize() { return (r) ? r->siz : 0; }
};
node* root;
void Update(node* p) {
if (!p) return;
p->siz = p->lsize() + p->rsize() + 1;
for (int i = 0; i < 5; i++) p->sum[i] = 0;
int tmp = 0;
if (p->l) {
for (int i = 0; i < 5; i++) p->sum[i] += p->l->sum[i];
tmp = p->lsize() % 5;
}
p->sum[tmp] += p->val;
tmp++;
tmp %= 5;
if (p->r) {
for (int i = 0; i < 5; i++) p->sum[(i + tmp) % 5] += p->r->sum[i];
}
}
node Node[Maxn];
void treap_merge(node* l, node* r, node*& res) {
if (!l || !r) {
if (l)
res = l;
else
res = r;
} else if (l->fix > r->fix) {
treap_merge(l, r->l, r->l);
res = r;
} else {
treap_merge(l->r, r, l->r);
res = l;
}
Update(res);
return;
}
void treap_split(node* p, node*& l, node*& r, int k) {
if (!p) {
l = NULL, r = NULL;
return;
} else if (p->val > k) {
treap_split(p->l, l, p->l, k);
r = p;
} else {
treap_split(p->r, p->r, r, k);
l = p;
}
Update(p);
}
void treap_ins(int val) {
node *l, *r, *k;
treap_split(root, l, r, val);
k = &Node[tot++];
k->fix = rand();
k->val = val;
Update(k);
treap_merge(l, k, root);
treap_merge(root, r, root);
}
void treap_del(node*& p, int val) {
if (p->val == val) {
treap_merge(p->l, p->r, p);
} else if (p->val < val) {
treap_del(p->r, val);
} else {
treap_del(p->l, val);
}
Update(p);
}
char op[5];
int main() {
srand(20160116);
root = NULL;
int n;
scanf("%d\n", &n);
for (int i = 0; i < n; i++) {
scanf("%s", op);
if (op[0] == 'a') {
int x;
scanf("%d\n", &x);
treap_ins(x);
} else if (op[0] == 'd') {
int x;
scanf("%d\n", &x);
treap_del(root, x);
} else {
if (!root)
printf("0\n");
else
printf("%I64d\n", root->sum[2]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct treap {
int key;
int prior;
long long sum;
int cnt;
treap *l, *r;
treap(int key)
: key(key), prior(rand()), sum(key), cnt(1), l(NULL), r(NULL) {}
};
typedef treap* pt;
const int MAX_T = 5;
pt t[MAX_T], tl[MAX_T], tr[MAX_T];
pt root;
int cnt(pt t) {
if (t)
return t->cnt;
else
return 0;
}
long long sum(pt t) {
if (t)
return t->sum;
else
return 0;
}
void upd(pt& t) {
if (t) {
t->sum = sum(t->l) + 1LL * t->key + sum(t->r);
t->cnt = cnt(t->l) + 1 + cnt(t->r);
}
}
void merge(pt& t, pt l, pt r) {
if (!l)
t = r;
else if (!r)
t = l;
else if (l->prior < r->prior) {
merge(l->r, l->r, r);
t = l;
} else {
merge(r->l, l, r->l);
t = r;
}
upd(t);
}
void split(pt t, pt& l, pt& r, int key) {
if (!t)
l = r = NULL;
else if (t->key < key) {
split(t->r, t->r, r, key);
l = t;
} else {
split(t->l, l, t->l, key);
r = t;
}
upd(l);
upd(r);
}
void add(int x) {
pt nt = new treap(x);
int pos = 1;
for (int i = 0; i < 5; ++i) {
split(t[i], tl[i], tr[i], x);
pos += cnt(tl[i]);
}
merge(tl[pos % 5], tl[pos % 5], nt);
for (int i = 0; i < 5; ++i) merge(t[i], tl[i], tr[(i - 1 + 5) % 5]);
}
void del(int x) {
pt trash;
for (int i = 0; i < 5; ++i) {
split(t[i], tl[i], tr[i], x);
split(tr[i], trash, tr[i], x + 1);
}
for (int i = 0; i < 5; ++i) merge(t[i], tl[i], tr[(i + 1) % 5]);
}
long long sum() { return sum(t[3]); }
const int MAX_S = 5;
char s[MAX_S];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < 5; ++i) t[i] = tl[i] = tr[i] = NULL;
for (int i = 0; i < n; ++i) {
scanf("%s", s);
if (s[0] == 'a') {
int x;
scanf("%d", &x);
add(x);
} else if (s[0] == 'd') {
int x;
scanf("%d", &x);
del(x);
} else {
printf("%I64d\n", sum());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, root[5], cnt, bin[100100], tp;
struct treap {
int lson, rson, val, rd, sz;
long long sum;
} t[100100];
int newnode(int val) {
int x = (tp ? bin[tp--] : ++cnt);
t[x].lson = t[x].rson = 0, t[x].sum = t[x].val = val,
t[x].rd = rand() * rand(), t[x].sz = 1;
return x;
}
void pushup(int x) {
t[x].sum = t[x].val, t[x].sz = 1;
if (t[x].lson) t[x].sum += t[t[x].lson].sum, t[x].sz += t[t[x].lson].sz;
if (t[x].rson) t[x].sum += t[t[x].rson].sum, t[x].sz += t[t[x].rson].sz;
}
void split(int x, int k, int &u, int &v) {
if (!x) {
u = v = 0;
return;
}
if (t[x].val <= k)
u = x, split(t[x].rson, k, t[x].rson, v);
else
v = x, split(t[x].lson, k, u, t[x].lson);
pushup(x);
}
int merge(int x, int y) {
if (!x || !y) return x + y;
if (t[x].rd < t[y].rd) {
t[x].rson = merge(t[x].rson, y), pushup(x);
return x;
} else {
t[y].lson = merge(x, t[y].lson), pushup(y);
return y;
}
}
int main() {
srand(19260817);
scanf("%d", &n);
for (int i = 1, x; i <= n; i++) {
char s[10];
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d", &x);
int u[5], v[5], sz = 1;
for (int i = 0; i < 5; i++)
split(root[i], x, u[i], v[i]), sz += t[u[i]].sz, root[i] = u[i];
x = newnode(x);
root[sz % 5] = merge(root[sz % 5], x);
for (int i = 0; i < 5; i++) root[i] = merge(root[i], v[(i + 4) % 5]);
}
if (s[0] == 'd') {
scanf("%d", &x);
int u[5], v[5], w[5];
for (int i = 0; i < 5; i++)
split(root[i], x, u[i], v[i]), split(u[i], x - 1, root[i], w[i]);
for (int i = 0; i < 5; i++) root[i] = merge(root[i], v[(i + 1) % 5]);
}
if (s[0] == 's') printf("%lld\n", t[root[3]].sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int num[100010];
map<int, int> ind;
long long sum[320][5];
int op[100010];
set<int> all[320];
void update(int c, int s) {
int k = ind[abs(c)];
int i = k / s;
if (c > 0)
all[i].insert(c);
else
all[i].erase(-c);
for (int t = 0; t < 5; t++) sum[i][t] = 0;
int t = 0;
for (__typeof((all[i]).begin()) it = (all[i]).begin(); it != (all[i]).end();
it++) {
sum[i][t] += *it;
t++;
if (t >= 5) t -= 5;
}
}
long long get() {
int s = (int)sqrt(n);
int t = 2;
long long res = 0;
for (int i = 0; i * i < n; i++) {
res += sum[i][t];
t -= all[i].size() % 5;
if (t < 0) t += 5;
}
return res;
}
int main() {
while (scanf("%d", &n) != EOF) {
int m = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s[0] == 'a') {
int c;
cin >> c;
op[i] = c;
num[m++] = c;
} else if (s[0] == 'd') {
int c;
cin >> c;
op[i] = -c;
num[m++] = c;
} else {
op[i] = 0;
}
}
sort(num, num + m);
int tmp = 0;
for (int i = 0; i < m; i++) {
if (i == 0 || num[i] != num[i - 1]) num[tmp++] = num[i];
}
m = tmp;
for (int i = 0; i < m; i++) ind[num[i]] = i;
int s = (int)sqrt(n);
for (int i = 0; i * i < n; i++) {
all[i].clear();
for (int j = 0; j < 5; j++) sum[i][j] = 0;
}
for (int i = 0; i < n; i++) {
if (op[i] != 0) {
update(op[i], s);
} else {
printf("%I64d\n", get());
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 100 * 1000 + 100;
map<long long, long long> mp1;
set<long long> st;
string s[maxn];
long long a[maxn], b[maxn], mp2[maxn];
long long f[maxn][5], sum[maxn];
long long q, n, sq;
int main() {
cin >> q;
for (long long i = 0; i < q; i++) {
cin >> s[i];
if (s[i][0] != 's') {
cin >> a[i];
st.insert(a[i]);
}
}
n = st.size();
sq = int(sqrt(n));
for (long long i = 0; i < n; i++) {
long long r = *st.begin();
st.erase(st.begin());
mp2[i] = r;
mp1[r] = i;
}
for (long long i = 0; i < q; i++) a[i] = mp1[a[i]];
for (long long i = 0; i < q; i++) {
if (s[i][0] == 's') {
long long p = 0, ans = 0;
for (long long j = 0; j < sq + 2; j++) {
ans += f[j][((p + 2) % 5 + 5) % 5];
p -= sum[j];
}
cout << ans << endl;
} else if (s[i][0] == 'd') {
long long t = a[i] / sq, p = 0;
if (b[a[i]] == 1)
sum[t]--;
else
continue;
b[a[i]] = 0;
for (long long j = 0; j < 5; j++) f[t][j] = 0;
for (long long j = t * sq; j < min((t + 1) * sq, n); j++)
if (b[j] == 1) {
f[t][p] += mp2[j];
p = (p + 1) % 5;
}
} else {
long long t = a[i] / sq, p = 0;
if (b[a[i]] == 0)
sum[t]++;
else
continue;
b[a[i]] = 1;
for (long long j = 0; j < 5; j++) f[t][j] = 0;
for (long long j = t * sq; j < min((t + 1) * sq, n); j++)
if (b[j] == 1) {
f[t][p] += mp2[j];
p = (p + 1) % 5;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 9;
vector<int> v;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
int x;
cin >> s;
if (s == "add") {
cin >> x;
v.insert(lower_bound(v.begin(), v.end(), x), x);
} else if (s == "del") {
cin >> x;
v.erase(lower_bound(v.begin(), v.end(), x));
} else {
long long ret = 0;
for (int i = 2; i < v.size(); i += 5) ret += v[i];
cout << ret << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x[100005], y[100005], c[100005 * 4], p, q, m;
long long t[100005 * 4][5];
char o[100005][4];
void upd(int d, int l, int r) {
c[d] += m * 2 - 1;
if (l == r) {
t[d][0] = m * y[q - 1];
return;
}
if ((l + r >> 1) < q)
upd(((d << 1) | 1), (l + r >> 1) + 1, r);
else
upd((d << 1), l, (l + r >> 1));
for (int i = (0); i < (5); i++)
t[d][i] = t[(d << 1)][i] + t[((d << 1) | 1)][(i - c[(d << 1)] % 5 + 5) % 5];
}
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) {
scanf("%s", o[i]);
if (o[i][0] == 'a' || o[i][0] == 'd') scanf("%d", &x[i]), y[p++] = x[i];
}
sort(y, y + p);
p = unique(y, y + p) - y;
for (int i = (0); i < (n); i++) {
q = lower_bound(y, y + p, x[i]) - y + 1;
if (o[i][0] == 'a')
m = 1, upd(1, 1, p);
else if (o[i][0] == 'd')
m = 0, upd(1, 1, p);
else
printf("%I64d\n", t[1][2]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX / 3;
const double eps = 1e-8;
const long long LINF = 1e17;
const double DINF = 1e60;
const int maxn = 1e5 + 10;
vector<int> num;
char buf[1024], cmd[maxn];
int val[maxn], knum, cnt[maxn << 2], n;
long long sum[maxn << 2][5];
int getID(int v) {
return lower_bound(num.begin(), num.end(), v) - num.begin() + 1;
}
void pushup(int rt, int l, int r) {
int lc = rt << 1, rc = rt << 1 | 1;
cnt[rt] = cnt[lc] + cnt[rc];
for (int i = 0; i < 5; i++) sum[rt][i] = sum[lc][i];
for (int i = 0; i < 5; i++) sum[rt][(i + cnt[lc]) % 5] += sum[rc][i];
}
void update(int rt, int l, int r, int pos, int tar) {
int mid = (l + r) >> 1;
if (l == r) {
sum[rt][1] = num[pos - 1] * tar;
cnt[rt] = tar;
} else {
if (pos <= mid)
update(rt << 1, l, mid, pos, tar);
else
update(rt << 1 | 1, mid + 1, r, pos, tar);
pushup(rt, l, r);
}
}
int main() {
while (~scanf("%d", &n)) {
num.clear();
for (int i = 1; i <= n; i++) {
scanf("%s", buf);
cmd[i] = buf[0];
if (cmd[i] != 's') {
scanf("%d", &val[i]);
num.push_back(val[i]);
}
}
memset(sum, 0, sizeof(sum));
memset(cnt, 0, sizeof(cnt));
sort(num.begin(), num.end());
num.erase(unique(num.begin(), num.end()), num.end());
knum = num.size();
for (int i = 1; i <= n; i++) {
if (cmd[i] == 'a')
update(1, 1, knum, getID(val[i]), 1);
else if (cmd[i] == 'd')
update(1, 1, knum, getID(val[i]), 0);
else
printf("%I64d\n", sum[1][3]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > consulta;
vector<long long int> valores;
vector<long long int> nuevo;
map<long long int, long long int> mapa;
long long int proceso() {
sort((valores).begin(), (valores).end());
long long int ant;
if (valores.size() > 0) ant = valores[0], nuevo.push_back(ant);
for (long long int x : valores) {
if (x > ant) nuevo.push_back(x);
ant = x;
}
long long int i = 0;
for (long long int x : nuevo) {
mapa[x] = i++;
}
return i;
}
struct st {
long long int n;
vector<long long int> arbol[5];
vector<long long int> cant;
void add(long long int p, long long int ini, long long int fin,
long long int pos, long long int val) {
if (ini > fin || pos > fin || pos < ini) return;
if (ini == fin) {
cant[p] = 1;
for (long long int i = (long long int)(0); i < (long long int)(5); i++) {
arbol[i][p] = (i == 2) ? val : 0;
}
return;
}
long long int mid = (ini + fin) / 2;
add(p << 1, ini, mid, pos, val);
add(p << 1 | 1, mid + 1, fin, pos, val);
cant[p] = cant[p << 1] + cant[p << 1 | 1];
for (long long int i = (long long int)(0); i < (long long int)(5); i++) {
arbol[i][p] =
arbol[i][p << 1] + arbol[(i + cant[p << 1]) % 5][p << 1 | 1];
}
}
void delet(long long int p, long long int ini, long long int fin,
long long int pos, long long int val) {
if (ini > fin || pos > fin || pos < ini) return;
if (ini == fin) {
cant[p] = 0;
for (long long int i = (long long int)(0); i < (long long int)(5); i++) {
arbol[i][p] = 0;
}
return;
}
long long int mid = (ini + fin) / 2;
delet(p << 1, ini, mid, pos, val);
delet(p << 1 | 1, mid + 1, fin, pos, val);
cant[p] = cant[p << 1] + cant[p << 1 | 1];
for (long long int i = (long long int)(0); i < (long long int)(5); i++) {
arbol[i][p] =
arbol[i][p << 1] + arbol[(i + cant[p << 1]) % 5][p << 1 | 1];
}
}
void solve() {
for (long long int i = (long long int)(0);
i < (long long int)(consulta.size()); i++) {
if (consulta[i].first == 0) {
if (n)
printf("%lld\n", arbol[0][1]);
else
puts("0");
} else if (consulta[i].first == 1) {
add(1, 0, n - 1, mapa[consulta[i].second], consulta[i].second);
} else if (consulta[i].first == 2) {
delet(1, 0, n - 1, mapa[consulta[i].second], consulta[i].second);
}
}
}
void ini(long long int _n) {
n = _n;
for (long long int i = (long long int)(0); i < (long long int)(5); i++)
arbol[i].assign(4 * n, 0);
cant.assign(4 * n, 0);
}
};
int main() {
long long int q;
scanf("%lld", &q);
char s[30];
long long int x;
for (long long int i = (long long int)(0); i < (long long int)(q); i++) {
scanf(" ");
scanf("%s", s);
if (s[0] == 'a') {
scanf("%lld", &x);
consulta.push_back(make_pair(1, x));
valores.push_back(x);
} else if (s[0] == 'd') {
scanf("%lld", &x);
consulta.push_back(make_pair(2, x));
valores.push_back(x);
} else if (s[0] == 's') {
consulta.push_back(make_pair(0, x));
}
}
long long int tam = proceso();
st tree;
tree.ini(tam);
tree.solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Task {
char order;
int x, val;
};
struct Ttree {
int tot;
long long val[5];
};
const int maxn = 100007;
int n;
Task ask[maxn];
Ttree tree[maxn * 4];
map<int, int> X;
void init() {
char s[7];
for (int i = 1; i <= n; i++) {
scanf("%s", s);
if (s[0] != 's') {
int x;
scanf("%d", &x);
ask[i].val = x;
}
ask[i].order = s[0];
}
X.clear();
for (int i = 1; i <= n; i++)
if (ask[i].order != 's') X[ask[i].val];
int total = 0;
for (map<int, int>::iterator it = X.begin(); it != X.end(); it++)
it->second = ++total;
for (int i = 1; i <= n; i++)
if (ask[i].order != 's') ask[i].x = X[ask[i].val];
}
void build(int mark, int L, int R) {
tree[mark].tot = 0;
for (int i = 0; i < 5; i++) tree[mark].val[i] = 0;
if (L == R) return;
int mid = (L + R) / 2;
build(mark * 2, L, mid);
build(mark * 2 + 1, mid + 1, R);
}
void update(Ttree &mid, Ttree L, Ttree R) {
for (int i = 0; i < 5; i++) mid.val[i] = L.val[i];
for (int i = 0; i < 5; i++) mid.val[(i + L.tot) % 5] += R.val[i];
mid.tot = L.tot + R.tot;
}
void insert(int mark, int L, int R, int x, int val, int order) {
if (L == R) {
if (order == 1) {
tree[mark].tot += order;
tree[mark].val[tree[mark].tot % 5] += order * val;
} else {
tree[mark].val[tree[mark].tot % 5] += order * val;
tree[mark].tot += order;
}
return;
}
int mid = (L + R) / 2;
if (x <= mid)
insert(mark * 2, L, mid, x, val, order);
else
insert(mark * 2 + 1, mid + 1, R, x, val, order);
update(tree[mark], tree[mark * 2], tree[mark * 2 + 1]);
}
void work() {
init();
build(1, 1, n);
for (int i = 1; i <= n; i++)
if (ask[i].order == 'a')
insert(1, 1, n, ask[i].x, ask[i].val, 1);
else if (ask[i].order == 'd')
insert(1, 1, n, ask[i].x, ask[i].val, -1);
else
cout << tree[1].val[3] << endl;
}
int main() {
while (scanf("%d", &n) != EOF) work();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 5, block = 400;
inline long long read() {
char c = getchar();
long long t = 0, f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
t = (t << 3) + (t << 1) + (c ^ 48);
c = getchar();
}
return t * f;
}
long long m, num[maxn], sz[maxn], op[maxn], n, pos[maxn], mrk[maxn],
sum[maxn][5];
map<long long, long long> mp;
inline void modify(long long x, long long y, long long z) {
mrk[x] = y * z;
long long k = 0, b = (x - 1) / block + 1;
sz[b] += z ? 1 : -1;
for (long long i = 0; i < 5; i++) {
sum[b][i] = 0;
}
for (long long i = (b - 1) * block + 1; i <= b * (block); i++) {
if (mrk[i]) {
sum[b][k % 5] += mrk[i];
k++;
}
}
}
inline long long query() {
long long ans = 0;
long long b = (n - 1) / block + 1, tot = 0;
for (long long i = 1; i <= b; i++) {
ans = ans + sum[i][(7 - tot) % 5];
tot = (tot + sz[i]) % 5;
}
return ans;
}
signed main() {
m = read();
for (long long i = 1; i <= m; i++) {
string s;
cin >> s;
if (s[0] == 'a') {
op[i] = 1;
num[i] = read();
mp[num[i]] = 1;
} else if (s[0] == 'd') {
op[i] = 2;
num[i] = read();
}
}
for (map<long long, long long>::iterator it = mp.begin(); it != mp.end();
it++) {
mp[(*it).first] = ++n;
}
for (long long i = 1; i <= m; i++) {
if (num[i]) pos[i] = mp[num[i]];
}
for (long long i = 1; i <= m; i++) {
if (op[i] == 1) {
modify(pos[i], num[i], 1);
} else if (op[i] == 2) {
modify(pos[i], 0, 0);
} else {
cout << query() << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class IO {
static const int bufSize = 1 << 18;
char inBuf[bufSize], outBuf[bufSize];
char *ip1 = inBuf, *ip2 = inBuf;
int goodReadBit = 0, op1 = -1, op2 = bufSize - 1;
template <typename T>
__inline__ __attribute__((always_inline)) void __RI(T& x) {
int ch = gc(), neg = 1;
x = 0;
for (; !(isdigit(ch) || ch == '-' || ch == EOF); ch = gc())
;
if (ch == EOF) {
goodReadBit = 0;
return;
}
if (ch == '-') neg = -1, ch = gc();
for (; isdigit(ch); ch = gc()) x = x * 10 + (ch - 48) * neg;
}
template <typename T>
__inline__ __attribute__((always_inline)) void __RC(T& x) {
unsigned char ch;
while (isspace(ch = gc()))
;
x = ch;
}
__inline__ __attribute__((always_inline)) void __RS(string& x) {
char ch;
x.clear();
for (ch = gc(); isspace(ch); ch = gc())
;
if (ch == EOF) {
goodReadBit = 0;
return;
}
for (; !isspace(ch); ch = gc()) x.push_back(ch);
}
public:
__inline__ __attribute__((always_inline)) int gc() {
return ip1 == ip2 && (ip2 = (ip1 = inBuf) + fread(inBuf, 1, bufSize, stdin),
ip1 == ip2)
? EOF
: *ip1++;
}
__inline__ __attribute__((always_inline)) IO& R(char& x) {
__RC(x);
return (*this);
}
__inline__ __attribute__((always_inline)) IO& R(unsigned char& x) {
__RC(x);
return (*this);
}
__inline__ __attribute__((always_inline)) IO& R(string& x) {
__RS(x);
return (*this);
}
template <typename T1, typename T2>
__inline__ __attribute__((always_inline)) IO& R(pair<T1, T2>& x) {
R(x.first), R(x.second);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& R(vector<T>& x) {
for (auto& i : x) R(i);
return (*this);
}
template <typename T, typename... Args>
__inline__ __attribute__((always_inline)) IO& RA(T* a, int n) {
for (int i = 0; i < n; ++i) R(a[i]);
return (*this);
}
template <typename T, typename... Args>
__inline__ __attribute__((always_inline)) IO& R(T& x, Args&... args) {
R(x), R(args...);
return (*this);
}
template <typename T, typename... Args>
__inline__ __attribute__((always_inline)) IO& RA(T* a, int n, Args... args) {
for (int i = 0; i < n; ++i) RA(a[i], args...);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& R(T& x) {
static_assert(is_integral<T>::value, "Unsupported types");
if (is_integral<T>::value) __RI(x);
return (*this);
}
private:
char space = ' ';
template <typename T>
__inline__ __attribute__((always_inline)) void __WI(T x) {
static char buf[64];
static int len = -1;
if (x >= 0) {
do {
buf[++len] = x % 10 + 48, x /= 10;
} while (x);
} else {
pc('-');
do {
buf[++len] = -(x % 10) + 48, x /= 10;
} while (x);
}
while (len >= 0) {
pc(buf[len]), --len;
}
}
public:
__inline__ __attribute__((always_inline)) void pc(const char& x) {
if (op1 == op2) flush();
outBuf[++op1] = x;
}
__inline__ __attribute__((always_inline)) void flush() {
fwrite(outBuf, 1, op1 + 1, stdout), op1 = -1;
}
__inline__ __attribute__((always_inline)) IO& W(const char& x) {
pc(x);
return (*this);
}
__inline__ __attribute__((always_inline)) IO& W(const char* x) {
while (*x != '\0') pc(*(x++));
return (*this);
}
__inline__ __attribute__((always_inline)) IO& W(const string& x) {
W(x.c_str());
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& W(const vector<T>& x) {
for (auto& i : x) WS(i);
WL();
return (*this);
}
__inline__ __attribute__((always_inline)) IO& WL() {
W('\n');
return (*this);
}
template <typename T1, typename T2>
__inline__ __attribute__((always_inline)) IO& W(pair<T1, T2>& x) {
WS(x.first), W(x.second);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& WL(const T& x) {
W(x), W('\n');
return (*this);
}
__inline__ __attribute__((always_inline)) IO& WS() {
W(' ');
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& WS(const T& x) {
W(x), W(space);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& WA(T* a, int n) {
for (int i = 0; i < n; i++) WS(a[i]);
WL();
return (*this);
}
template <typename T, typename... Args>
__inline__ __attribute__((always_inline)) IO& W(const T& x,
const Args&... args) {
W(x), W(space), W(args...);
return (*this);
}
template <typename... Args>
__inline__ __attribute__((always_inline)) IO& WL(const Args&... args) {
W(args...), W('\n');
return (*this);
}
template <typename T, typename... Args>
__inline__ __attribute__((always_inline)) IO& WA(T* a, int n, Args... args) {
for (int i = 0; i < n; i++) WA(a[i], args...);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& W(const T& x) {
static_assert(is_integral<T>::value, "Unsupported types");
if (is_integral<T>::value) __WI(x);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& operator>>(T& x) {
R(x);
return (*this);
}
template <typename T>
__inline__ __attribute__((always_inline)) IO& operator<<(const T& x) {
W(x);
return (*this);
}
IO() {}
} io;
void EXIT(int code) { io.flush(), exit(code); }
const int8_t INFC = 0x3f;
const int16_t INFS = 0x3f3f;
const int32_t INF = 0x3f3f3f3f;
const int64_t INFL = 0x3f3f3f3f3f3f3f3fLL;
vector<pair<string, int> > ops;
map<int, int> fmap;
unordered_map<int, int> rmap;
struct SegmentTree {
struct Node {
int64_t sum[5];
int cnt = 0;
};
static const int MAXN = 1 << 20;
Node data[MAXN];
int N;
void init(int n) {
N = 1;
while (N < n) N <<= 1;
}
void add(int x) {
int k = x + N - 1;
data[k].cnt = 1;
data[k].sum[0] = rmap[x];
while (k) {
k = (k - 1) >> 1;
data[k].cnt = data[(k << 1) + 1].cnt + data[(k << 1) + 2].cnt;
for (int i = 0; i < 5; i++)
data[k].sum[i] =
data[(k << 1) + 1].sum[i] +
data[(k << 1) + 2].sum[(i - data[(k << 1) + 1].cnt % 5 + 5) % 5];
}
}
void del(int x) {
int k = x + N - 1;
data[k].cnt = 0;
data[k].sum[0] = 0;
while (k) {
k = (k - 1) >> 1;
data[k].cnt = data[(k << 1) + 1].cnt + data[(k << 1) + 2].cnt;
for (int i = 0; i < 5; i++)
data[k].sum[i] =
data[(k << 1) + 1].sum[i] +
data[(k << 1) + 2].sum[(i - data[(k << 1) + 1].cnt % 5 + 5) % 5];
}
}
} segmentTree;
int main() {
int q;
io >> q;
ops.resize(q);
for (auto& [k, v] : ops) {
io >> k;
if (k[0] != 's') io >> v, fmap[v] = 1;
}
segmentTree.init(fmap.size());
int key = 0;
for (auto& [k, v] : fmap) key++, v = key, rmap[key] = k;
for (auto& [k, v] : ops)
if (k[0] != 's') v = fmap[v];
for (auto [k, v] : ops) {
if (k[0] == 's')
io.WL(segmentTree.data[0].sum[2]);
else if (k[0] == 'a')
segmentTree.add(v);
else if (k[0] == 'd')
segmentTree.del(v);
}
EXIT(0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long LINF = 2e16;
const int magic = 348;
const int MOD = 998244353;
const double eps = 1e-10;
const double pi = acos(-1);
inline int getint() {
bool f;
char ch;
int res;
while (!isdigit(ch = getchar()) && ch != '-') {
}
if (ch == '-')
f = false, res = 0;
else
f = true, res = ch - '0';
while (isdigit(ch = getchar())) res = res * 10 + ch - '0';
return f ? res : -res;
}
const int MAXN = 1e5;
int root[10];
pair<int, int> tmp[10];
namespace Treap {
struct node {
int left, right, val, priority;
long long sum;
int sz;
} tree[MAXN * 2];
int tot = 0;
inline void pushup(int cur) {
tree[cur].sum =
tree[tree[cur].left].sum + tree[tree[cur].right].sum + tree[cur].val;
tree[cur].sz = tree[tree[cur].left].sz + tree[tree[cur].right].sz + 1;
}
inline int Create(int left, int right, int val, int priority) {
++tot;
tree[tot].left = left;
tree[tot].right = right;
tree[tot].val = val;
tree[tot].priority = priority;
pushup(tot);
return tot;
}
inline pair<int, int> split(int root, int val) {
if (!root) return make_pair(0, 0);
if (tree[root].val < val) {
pair<int, int> splitted = split(tree[root].right, val);
tree[root].right = splitted.first;
pushup(root);
return make_pair(root, splitted.second);
} else {
pair<int, int> splitted = split(tree[root].left, val);
tree[root].left = splitted.second;
pushup(root);
return make_pair(splitted.first, root);
}
}
inline pair<int, int> split2(int root, int k) {
if (!root) return make_pair(0, 0);
int leftsz = tree[tree[root].left].sz + 1;
if (k >= leftsz) {
pair<int, int> splitted = split2(tree[root].right, k - leftsz);
tree[root].right = splitted.first;
pushup(root);
return make_pair(root, splitted.second);
} else {
pair<int, int> splitted = split2(tree[root].left, k);
tree[root].left = splitted.second;
pushup(root);
return make_pair(splitted.first, root);
}
}
inline int merge(int root1, int root2) {
if (!root1 || !root2) return root1 + root2;
if (tree[root1].priority <= tree[root2].priority) {
tree[root1].right = merge(tree[root1].right, root2);
pushup(root1);
return root1;
} else {
tree[root2].left = merge(root1, tree[root2].left);
pushup(root2);
return root2;
}
}
inline bool find(int root, int first) {
if (!root) return false;
if (tree[root].val == first) return true;
if (first < tree[root].val)
return find(tree[root].left, first);
else
return find(tree[root].right, first);
}
} // namespace Treap
int main() {
int first, i, pos, q = getint();
char op[5];
while (q--) {
scanf("%s", op + 1);
if (op[1] == 'a') {
first = getint();
for (i = 0; i <= 4; i++) tmp[i] = Treap::split(root[i], first);
pos = 1;
for (i = 0; i <= 4; i++) pos += Treap::tree[tmp[i].first].sz;
pos %= 5;
tmp[pos].first =
Treap::merge(tmp[pos].first, Treap::Create(0, 0, first, rand()));
for (i = 0; i <= 4; i++)
root[(i + 1) % 5] = Treap::merge(tmp[(i + 1) % 5].first, tmp[i].second);
}
if (op[1] == 'd') {
first = getint();
for (i = 0; i <= 4; i++)
if (Treap::find(root[i], first)) {
pos = i;
break;
}
for (i = 0; i <= 4; i++) tmp[i] = Treap::split(root[i], first);
tmp[pos].second = Treap::split2(tmp[pos].second, 1).second;
for (i = 0; i <= 4; i++)
root[i] = Treap::merge(tmp[i].first, tmp[(i + 1) % 5].second);
}
if (op[1] == 's') printf("%lld\n", Treap::tree[root[3]].sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 1e5 + 10, M = 0, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int casenum, casei;
int n;
char s[5];
int x;
int b[N];
int g;
pair<int, int> q[N];
int num[1 << 18];
long long sum[1 << 18][5];
void build(int o, int l, int r) {
num[o] = 0;
memset(sum[o], 0, sizeof(sum[o]));
if (l == r) return;
int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
}
void pushup(int o) {
num[o] = num[o << 1] + num[o << 1 | 1];
int nm = 5 - num[o << 1] % 5;
for (int i = 0; i < 5; ++i)
sum[o][i] = sum[o << 1][i] + sum[o << 1 | 1][(i + nm) % 5];
}
int P, V;
void add(int o, int l, int r) {
if (l == r) {
num[o] += V;
sum[o][1] += b[l] * V;
return;
}
int mid = (l + r) >> 1;
P <= mid ? add(o << 1, l, mid) : add(o << 1 | 1, mid + 1, r);
pushup(o);
}
int main() {
while (~scanf("%d", &n)) {
g = 0;
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d", &x);
q[i] = make_pair(1, x);
b[++g] = x;
} else if (s[0] == 'd') {
scanf("%d", &x);
q[i] = make_pair(2, x);
b[++g] = x;
} else
q[i] = make_pair(3, 0);
}
sort(b + 1, b + g + 1);
g = unique(b + 1, b + g + 1) - b - 1;
if (g == 0) g = 1;
build(1, 1, g);
for (int i = 1; i <= n; ++i) {
if (q[i].first == 1) {
P = lower_bound(b + 1, b + g + 1, q[i].second) - b;
V = 1;
add(1, 1, g);
} else if (q[i].first == 2) {
P = lower_bound(b + 1, b + g + 1, q[i].second) - b;
V = -1;
add(1, 1, g);
} else
printf("%lld\n", sum[1][3]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
struct node {
int l, r;
long long cnt[5];
int p;
} src[MAXN * 4 + 10];
int n, od[MAXN + 10], s_len;
long long inf[MAXN + 10], SP[MAXN + 10];
void Build(int u, int l, int r) {
src[u].l = l, src[u].r = r;
src[u].p = 4;
if (l >= r) return;
int mid = (l + r) >> 1;
Build(u * 2, l, mid);
Build(u * 2 + 1, mid + 1, r);
}
int ID(int num) { return lower_bound(SP, SP + s_len, num) - SP + 1; }
void Init() {
sort(SP, SP + s_len);
s_len = unique(SP, SP + s_len) - SP;
}
void Read() {
char ord[10];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", ord);
if (ord[0] == 's') {
od[i] = 1;
continue;
} else if (ord[0] == 'a')
od[i] = 2;
else
od[i] = 3;
scanf("%I64d", &inf[i]);
SP[s_len++] = inf[i];
}
}
void Ref(int u) {
src[u].p = (src[u * 2].p + src[u * 2 + 1].p + 1) % 5;
for (int i = 0; i < 5; i++)
src[u].cnt[i] =
src[u * 2].cnt[i] + src[u * 2 + 1].cnt[(i - src[u * 2].p + 4) % 5];
}
void Insert(int u, int id, long long val, long long le) {
if (src[u].l == src[u].r) {
if (le < 0) src[u].cnt[src[u].p] -= val;
src[u].p = (src[u].p + le + 5) % 5;
if (le > 0) src[u].cnt[src[u].p] += val;
} else {
int mid = (src[u].l + src[u].r) >> 1;
if (id <= mid)
Insert(u * 2, id, val, le);
else
Insert(u * 2 + 1, id, val, le);
Ref(u);
}
}
int main() {
Read();
Init();
Build(1, 1, s_len);
for (int i = 0; i < n; i++) {
if (od[i] == 1)
printf("%I64d\n", src[1].cnt[2]);
else if (od[i] == 2)
Insert(1, ID(inf[i]), inf[i], 1LL);
else
Insert(1, ID(inf[i]), inf[i], -1LL);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
struct node {
int lc, rc;
long long s[5];
int cnt;
} t[N * 40];
int rt = 0, siz = 0;
void pushup(int x) {
int lc = t[x].lc, rc = t[x].rc, ls = t[lc].cnt;
for (int i = 0; i < 5; i++) t[x].s[i] = t[lc].s[i];
for (int i = 0; i < 5; i++) t[x].s[(i + ls) % 5] += t[rc].s[i];
t[x].cnt = t[lc].cnt + t[rc].cnt;
}
void ins(int &x, int l, int r, int p, int v) {
if (!x) x = ++siz;
if (l == r) {
t[x].cnt += v;
t[x].s[1] += 1ll * l * v;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
ins(t[x].lc, l, mid, p, v);
else
ins(t[x].rc, mid + 1, r, p, v);
pushup(x);
}
int main() {
char s[23];
int _;
for (scanf("%d", &_); _; _--) {
scanf("%s", s);
if (s[0] == 's')
printf("%lld\n", t[rt].s[3]);
else {
int d = s[0] == 'd' ? -1 : 1, v;
scanf("%d", &v);
ins(rt, 1, 1e9, v, d);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 Rand(time(NULL));
namespace Treap {
struct tnode {
int key, siz;
long long sum[5];
unsigned int fix;
tnode *lson, *rson;
tnode(int x = 0) {
key = x, siz = 1, sum[0] = x;
fix = Rand();
lson = rson = nullptr;
sum[1] = sum[2] = sum[3] = sum[4] = 0;
}
~tnode() {
if (lson) delete lson;
if (rson) delete rson;
}
int lsiz() { return lson ? lson->siz : 0; }
int rsiz() { return rson ? rson->siz : 0; }
void maintain() {
siz = lsiz() + rsiz() + 1;
for (int i = 0; i < (int)(5); ++i) sum[i] = 0;
if (lson)
for (int i = 0; i < (int)(5); ++i) sum[i] = lson->sum[i];
if (rson)
for (int i = 0; i < (int)(5); ++i)
sum[(lsiz() + 1 + i) % 5] += rson->sum[i];
sum[lsiz() % 5] += key;
}
};
tnode* tre;
void init() {
if (tre) delete tre;
tre = nullptr;
}
void leftRotate(tnode*& cur) {
tnode* t = cur->rson;
cur->rson = t->lson;
t->lson = cur;
cur = t;
t = cur->lson;
t->maintain(), cur->maintain();
}
void rightRotate(tnode*& cur) {
tnode* t = cur->lson;
cur->lson = t->rson;
t->rson = cur;
cur = t;
t = cur->rson;
t->maintain(), cur->maintain();
}
void insert(tnode*& cur, int val) {
if (!cur) {
cur = new tnode(val);
return;
}
cur->siz++;
if (val < cur->key) {
insert(cur->lson, val);
if (cur->lson->fix < cur->fix) rightRotate(cur);
} else {
insert(cur->rson, val);
if (cur->rson->fix < cur->fix) leftRotate(cur);
}
cur->maintain();
}
void remove(tnode*& cur, int val) {
cur->siz--;
if (val == cur->key) {
if (!cur->lson || !cur->rson) {
tnode* t = cur;
if (!cur->lson)
cur = cur->rson, t->rson = nullptr;
else
cur = cur->lson, t->lson = nullptr;
delete t;
return;
} else {
cur->siz++;
if (cur->lson->fix < cur->rson->fix)
rightRotate(cur), remove(cur->rson, val);
else
leftRotate(cur), remove(cur->lson, val);
cur->siz--;
}
} else if (val < cur->key)
remove(cur->lson, val);
else
remove(cur->rson, val);
cur->maintain();
}
} // namespace Treap
int N;
int main() {
scanf("%d", &N);
Treap::init();
for (int i = 0; i < (int)(N); ++i) {
string s;
int x;
cin >> s;
if (s[0] == 'a') {
scanf("%d", &x);
Treap::insert(Treap::tre, x);
}
if (s[0] == 'd') {
scanf("%d", &x);
Treap::remove(Treap::tre, x);
}
if (s[0] == 's') printf("%lld\n", Treap::tre ? Treap::tre->sum[2] : 0);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int num;
char as[10];
} op[100005];
int a[100005];
int len;
int flag1;
int flag2;
int flag3;
struct Pode {
long long sum[6];
int cnt;
} tree[100005 << 2];
int binsearch(int x) {
int l = 0;
int r = len - 1;
while (l <= r) {
int m = (l + r) >> 1;
if (a[m] >= x)
r = m - 1;
else
l = m + 1;
}
return l;
}
void Update(int l, int r, int rt) {
tree[rt].cnt += flag3;
if (l == r) {
tree[rt].sum[1] = flag2;
return;
}
int m = (l + r) >> 1;
if (flag1 <= m)
Update(l, m, rt << 1);
else
Update(m + 1, r, rt << 1 | 1);
for (int i = 0; i < 5; i++) {
tree[rt].sum[i] =
tree[rt << 1].sum[i] +
tree[rt << 1 | 1].sum[(5 - tree[rt << 1].cnt % 5 + i) % 5];
}
}
int main() {
int n;
int i, j, k;
while (~scanf("%d", &n)) {
len = 0;
memset(tree, 0, sizeof(tree));
for (i = 0; i < n; i++) {
scanf("%s", op[i].as);
if (op[i].as[0] != 's') {
scanf("%d", &op[i].num);
a[++len] = op[i].num;
}
}
sort(a + 1, a + len + 1);
len = unique(a + 1, a + len + 1) - a - 1;
for (i = 0; i < n; i++) {
if (op[i].as[0] == 'a') {
flag1 = binsearch(op[i].num);
flag2 = op[i].num;
flag3 = 1;
Update(1, len, 1);
} else if (op[i].as[0] == 'd') {
flag1 = binsearch(op[i].num);
flag2 = 0;
flag3 = -1;
Update(1, len, 1);
} else
printf("%lld\n", tree[1].sum[3]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, j, sum[1 << 19][15], sz[1 << 19], cnt;
map<long long, long long> mp, zhi;
struct ii {
long long num, id;
string zl;
} zl[100005];
bool cmp1(ii a, ii b) {
if (a.num < b.num) return 1;
if (a.num > b.num) return 0;
return a.zl < b.zl;
}
bool cmp2(ii a, ii b) { return a.id < b.id; }
void update(long long x) {
long long i;
sz[x] = sz[x * 2] + sz[x * 2 + 1];
for (i = 0; i <= 4; i++) {
sum[x][i] = sum[x * 2][i];
}
for (i = 0; i <= 4; i++) {
sum[x][i] += sum[x * 2 + 1][((i - sz[x * 2]) % 5 + 5) % 5];
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (i = 1; i <= n; i++) {
zl[i].id = i;
cin >> zl[i].zl;
if (zl[i].zl != "sum") cin >> zl[i].num;
}
sort(zl + 1, zl + n + 1, cmp1);
cnt = 1;
for (i = 1; i <= n; i++) {
if (zl[i].zl == "add") {
if (!mp[zl[i].num]) mp[zl[i].num] = cnt++;
zhi[mp[zl[i].num]] = zl[i].num;
zl[i].num = mp[zl[i].num];
} else if (zl[i].zl == "del") {
zl[i].num = mp[zl[i].num];
}
}
sort(zl + 1, zl + n + 1, cmp2);
for (i = 1; i <= n; i++) {
if (zl[i].zl == "add") {
j = (1 << 18) + zl[i].num;
sz[j] = 1;
sum[j][0] = zhi[zl[i].num];
j /= 2;
while (j) {
update(j);
j /= 2;
}
}
if (zl[i].zl == "del") {
j = (1 << 18) + zl[i].num;
sz[j] = 0;
sum[j][0] = 0;
j /= 2;
while (j) {
update(j);
j /= 2;
}
}
if (zl[i].zl == "sum") {
cout << sum[1][2] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x;
vector<int> v;
int main() {
cin >> n;
while (n--) {
string s;
cin >> s;
if (s[0] == 's') {
long long r = 0;
for (int i = 2; i < v.size(); i += 5) r += v[i];
cout << r << endl;
} else {
cin >> x;
if (s[0] == 'a')
v.insert(lower_bound(v.begin(), v.end(), x), x);
else
v.erase(lower_bound(v.begin(), v.end(), x));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
vector<long long> v;
string s;
int type[100100];
long long num[100100];
long long dat[400100][5];
int cnt[400100];
int branches;
void combine(int a, int b, int c) {
cnt[a] = cnt[b] + cnt[c];
for (int i = 0; i < 5; i++) dat[a][i] = dat[b][i];
int g = cnt[b] % 5;
for (int i = 0; i < 5; i++) dat[a][(i + g) % 5] += dat[c][i];
}
void ac_the_problem(int pos) {
if (type[pos] == 2) {
cout << dat[1][2] << endl;
return;
}
int val = num[pos] + branches;
cnt[val] = (1 - type[pos]);
dat[val][0] = (1 - type[pos]) * (v[val - branches]);
for (; val >>= 1;) {
combine(val, (val << 1) | 0, (val << 1) | 1);
}
}
int main() {
cin >> q;
for (int i = 0; i < q; i++) {
cin >> s;
if (s == "add") {
type[i] = 0;
cin >> num[i];
v.push_back(num[i]);
} else if (s == "del") {
type[i] = 1;
cin >> num[i];
} else {
type[i] = 2;
}
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
n = v.size();
for (int i = 0; i < q; i++) {
if (num[i]) num[i] = lower_bound(v.begin(), v.end(), num[i]) - v.begin();
}
branches = 1;
while (branches < n + 5) branches *= 2;
for (int i = 0; i < q; i++) {
ac_the_problem(i);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.