## 题目描述

In one well-known algorithm of finding the $k$-th order statistics we should divide all elements into groups of five consecutive elements and find the median of each five. A median is called the middle element of a sorted array (it’s the third largest element for a group of five). To increase the algorithm’s performance speed on a modern video card, you should be able to find a sum of medians in each five of the array.
A sum of medians of a sorted $k$-element set $S={a_1, a_2, \ldots, a_k}$, where $a_1 \lt a_2 \lt a_3 \lt \cdots \lt a_k$, will be understood by as $\sum_{i \bmod 5=3} a_i$.
The $\bmod$ operator stands for taking the remainder, that is $x \bmod y$ stands for the remainder of dividing $x$ by $y$.
To organize exercise testing quickly calculating the sum of medians for a changing set was needed.

## 代码1

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
long long n, x;
string o;
struct treap {
int tot, root;
struct node_type {
int child[2], rank;
long long val, size, mod[5];
} node[100001];
void update(int t) {
node[t].size = node[node[t].child[0]].size + node[node[t].child[1]].size + 1;
for (int i = 0; i < 5; ++i)
node[t].mod[i] = node[node[t].child[0]].mod[i] + node[node[t].child[1]].mod[(i + 99999 - node[node[t].child[0]].size) % 5];
node[t].mod[(node[node[t].child[0]].size + 1) % 5] += node[t].val;
}
void rotate(int &t, int dire) {
int p = node[t].child[!dire];
node[t].child[!dire] = node[p].child[dire], node[p].child[dire] = t;
update(t), update(p), t = p;
}
void insert(int &t, long long val) {
if (!t) {
t = ++tot, node[t].rank = ((rand() & ((1 << 16) - 1)) << 10) ^ rand(), node[t].val = node[t].mod[1] = val, node[t].size = 1;
return;
}
++node[t].size;
if (val < node[t].val) {
insert(node[t].child[0], val);
if (node[node[t].child[0]].rank > node[t].rank) rotate(t, 1);
} else {
insert(node[t].child[1], val);
if (node[node[t].child[1]].rank > node[t].rank) rotate(t, 0);
}
update(t);
}
void remove(int &t, long long val) {
if (!node[t].child[0] && !node[t].child[1]) { t = 0; return; }
if (val == node[t].val) {
if (node[node[t].child[0]].rank > node[node[t].child[1]].rank) rotate(t, 1);
else rotate(t, 0);
}
if (val < node[t].val) remove(node[t].child[0], val);
else remove(node[t].child[1], val);
update(t);
}
long long query() { return node[root].mod[3]; }
} tree;
int main()
{
srand(time(NULL));
cin >> n;
while (n--) {
cin >> o;
if (o[0] == 'a') { cin >> x; tree.insert(tree.root, x); }
else if (o[0] == 'd') { cin >> x; tree.remove(tree.root, x); }
else cout << tree.query() << endl;
}
return 0;
}


## 题目描述

Give a tree with $n$ vertices, each edge has a length (positive integer less than $1001$).
Define $dist(u, v)= \text{The min distance between node} \; u \; \text{and} \; v$.
Give an integer $k$, for every pair $(u, v)$ of vertices is called valid if and only if $dist(u, v)$ not exceed $k$.
Write a program that will count how many pairs which are valid for a given tree.

## 算法分析

$$dist_{u, v} \le k \text{且路径经过} x \Leftrightarrow dist_{u, x} + dist_{x, v} \le k \text{且} u \text{和} v \text{在不同子树中}$$

## 代码

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;
struct edge {
int v, w, nxt;
} e[20001];
struct treap {
int tot, root;
struct node_type {
int val, cnt, size, rank, child[2];
} a[10001];
void init() { tot = root = 0; }
void update(int t) { a[t].size = a[a[t].child[0]].size + a[a[t].child[1]].size + a[t].cnt; }
void turn(int &t, int dire) {
int p = a[t].child[!dire];
a[t].child[!dire] = a[p].child[dire], a[p].child[dire] = t;
update(t), update(p), t = p;
}
void insert(int &t, int val) {
if (!t) {
t = ++tot, a[t].rank = rand(), a[t].cnt = a[t].size = 1, a[t].val = val;
a[t].child[0] = a[t].child[1] = 0;
return;
}
++a[t].size;
if (val == a[t].val) ++a[t].cnt;
else if (val < a[t].val) {
insert(a[t].child[0], val);
if (a[a[t].child[0]].rank < a[t].rank) turn(t, 1);
} else {
insert(a[t].child[1], val);
if (a[a[t].child[1]].rank < a[t].rank) turn(t, 0);
}
}
int query(int t, int val) {
if (!t) return 0;
if (val == a[t].val) return a[a[t].child[0]].size;
else if (val < a[t].val) return query(a[t].child[0], val);
else return a[a[t].child[0]].size + a[t].cnt + query(a[t].child[1], val);
}
} tree;
long long n, k, nume, root, tot, ans, h[10001], size[10001], f[10001], val[10001];
bool vis[10001];
void add_edge(int u, int v, int w) {
e[++nume].v = v, e[nume].w = w, e[nume].nxt = h[u], h[u] = nume;
e[++nume].v = u, e[nume].w = w, e[nume].nxt = h[v], h[v] = nume;
}
void get_root(int t, int fa) {
size[t] = 1, f[t] = 0;
for (int i = h[t]; i; i = e[i].nxt) {
if (!vis[e[i].v] && e[i].v != fa) {
get_root(e[i].v, t);
size[t] += size[e[i].v];
f[t] = max(f[t], size[e[i].v]);
}
}
f[t] = max(f[t], tot - size[t]);
if (f[t] < f[root]) root = t;
}
void get_dist(int t, int fa, int flag) {
if (!flag) tree.insert(tree.root, val[t]);
else ans += tree.query(tree.root, k - val[t] + 1);
for (int i = h[t]; i; i = e[i].nxt) {
if (!vis[e[i].v] && e[i].v != fa) {
val[e[i].v] = val[t] + e[i].w;
get_dist(e[i].v, t, flag);
}
}
}
void solve(int t) {
vis[t] = true;
tree.init(), tree.insert(tree.root, 0);
for (int i = h[t]; i; i = e[i].nxt) {
if (!vis[e[i].v]) {
val[e[i].v] = e[i].w;
get_dist(e[i].v, t, 1);
get_dist(e[i].v, t, 0);
}
}
for (int i = h[t]; i; i = e[i].nxt) {
if (!vis[e[i].v]) {
root = 0, tot = size[e[i].v];
get_root(e[i].v, t);
solve(root);
}
}
}
int main()
{
while (scanf("%lld%lld", &n, &k)) {
if (!n) break;
memset(vis, 0, sizeof(vis));
memset(h, 0, sizeof(h));
ans = nume = 0;
for (int i = 1; i < n; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
}
tot = f[0] = n, root = 0;
get_root(1, 0);
solve(root);
printf("%lld\n", ans);
}
return 0;
}


## 题目描述

There is a pile of $N$ books on the table. Two types of operations are performed over this pile:

• a book is added to the top of the pile,
• top $K$ books are rotated. If there are less than $K$ books on the table, the whole pile is rotated.

First operation is denoted as $ADD(S)$ where $S$ is the name of the book, and the second operations is denoted as $ROTATE$.
The maximum number of books is no more than $40000$. All book names are non-empty sequences of no more than $3$ capital Latin letters. The names of the books can be non-unique.