2210 lines
58 KiB
Plaintext
2210 lines
58 KiB
Plaintext
//一维树状数组
|
||
//单点修改 + 单点查询 + 区间修改 + 区间查询 + 区间最值
|
||
int n;
|
||
template<typename T> struct BIT {
|
||
T A[N]; //T B[N]; //区间增减/维护最值
|
||
int lowbit(int x) { return x & -x; }
|
||
void init() { memset(A, 0, sizeof(A)); /*memset(B, 0, sizeof(B));*/ }
|
||
void update(int i, T v) { while (i <= n) { A[i] += v; i += lowbit(i); } }
|
||
T query(int i) { T ret = 0; while (i) { ret += A[i]; i -= lowbit(i); } return ret; }
|
||
T query(int i, int j) { return query(j) - query(i - 1); }
|
||
//区间修改
|
||
T query(int x) {
|
||
if (!x) { return 0; }
|
||
T ret1 = 0, ret2 = 0;
|
||
for (int i = x; i <= n; i += lowbit(i)) { ret1 += A[i]; }
|
||
for (int i = x - 1; i > 0; i -= lowbit(i)) { ret2 += B[i]; }
|
||
return ret1 * x + ret2;
|
||
}
|
||
void update(int x, T v) {
|
||
for (int i = x; i > 0; i -= lowbit(i)) { A[i] += v; }
|
||
for (int i = x; i <= n; i += lowbit(i)) { B[i] += x * v; }
|
||
}
|
||
void update(int i, int j, T v) { update(j, v); if (i > 1) { update(i - 1, -v); } }
|
||
//维护区间最值 O(log^2(n))
|
||
void modify(int x, T v) {
|
||
B[x] = v;
|
||
for (int i = x; i <= n; i += lowbit(i)) {
|
||
A[i] = max(A[i], v);
|
||
for (int j = 1; j < lowbit(i); j <<= 1) {
|
||
A[i] = max(A[i], A[i - j]);
|
||
}
|
||
}
|
||
}
|
||
T query(int l, int r) {
|
||
T ret = B[r];
|
||
while (true) {
|
||
ret = max(ret, B[r]);
|
||
if (l == r) { break; }
|
||
for (r -= 1; r - l >= lowbit(r); r -= lowbit(r)) { ret = max(ret, A[r]); }
|
||
}
|
||
return ret;
|
||
}
|
||
//求区间第K大的下标/值 O(log^2(n))
|
||
int getK(int l, int r, int k) {
|
||
while (l <= r) {
|
||
int mid = l + ((r - l) >> 1);
|
||
if (query(mid) >= k) { r = mid - 1; }
|
||
else { l = mid + 1; }
|
||
}
|
||
return l; //A[l]
|
||
}
|
||
};
|
||
BIT<int> bit;
|
||
//二维树状数组
|
||
//单点修改 + 单点查询 + 区域修改 + 区域查询
|
||
int n, m;
|
||
template<typename T> struct BIT {
|
||
T A[N][N]; //T B[N][N], C[N][N], D[N][N]; //区域求和
|
||
int lowbit(int x) { return x & -x; }
|
||
void init() { memset(A, 0, sizeof(A)); /*memset(B, 0, sizeof(B)); memset(C, 0, sizeof(C)); memset(D, 0, sizeof(D));*/ }
|
||
T get(int x, int y) {
|
||
T ret = 0;
|
||
for (int i = x; i > 0; i -= lowbit(i)) { for (int j = y; j > 0; j -= lowbit(j)) { ret += A[i][j]; } }
|
||
return ret;
|
||
}
|
||
T query(int x, int y) { return get(x, y) - get(x, y - 1) - get(x - 1, y) + get(x - 1, y - 1); }
|
||
void update(int x, int y, T v) {
|
||
for (int i = x; i <= n; i += lowbit(i)) { for (int j = y; j <= m; j += lowbit(j)) { A[i][j] += v; } }
|
||
}
|
||
//区域和[x1][y1]-[x2][y2]
|
||
T query(int x1, int y1, int x2, int y2) {
|
||
return get(x2, y2) - get(x1 - 1, y2) - get(x2, y1 - 1) + get(x1 - 1, y1 - 1);
|
||
}
|
||
//区域增减
|
||
void update(int x, int y, T v, T a[][N]) {
|
||
for (int i = x; i <= n; i += lowbit(i)) { for (int j = y; j <= m; j += lowbit(j)) { a[i][j] += v; } }
|
||
}
|
||
void update(int x1, int y1, int x2, int y2, T v) {
|
||
update(x1, y1, v, A); update(x2 + 1, y1, -v, A);
|
||
update(x1, y2 + 1, -v, A); update(x2 + 1, y2 + 1, v, A);
|
||
update(x1, y1, v * x1, B); update(x2 + 1, y1, -v * (x2 + 1), B);
|
||
update(x1, y2 + 1, -v * x1, B); update(x2 + 1, y2 + 1, v * (x2 + 1), B);
|
||
update(x1, y1, v * y1, C); update(x2 + 1, y1, -v * y1, C);
|
||
update(x1, y2 + 1, -v * (y2 + 1), C); update(x2 + 1, y2 + 1, v * (y2 + 1), C);
|
||
update(x1, y1, v * x1 * y1, D); update(x2 + 1, y1, -v * (x2 + 1) * y1, D);
|
||
update(x1, y2 + 1, -v * x1 * (y2 + 1), D); update(x2 + 1, y2 + 1, v * (x2 + 1) * (y2 + 1), D);
|
||
}
|
||
};
|
||
BIT<int> bit;
|
||
//线段树 单点修改 + 区间查询
|
||
#define lson l,m,rt<<1
|
||
#define rson m+1,r,rt<<1|1
|
||
template<typename T> struct SegmentTree {
|
||
T data[N << 2];
|
||
T calc(const T &x, const T &y)const { return x + y; }
|
||
void push_up(int rt) { data[rt] = calc(data[rt << 1], data[rt << 1 | 1]); }
|
||
void build(int l, int r, int rt) {
|
||
if (l == r) { scanf("%d", &data[rt]); return; }
|
||
int m = (l + r) >> 1;
|
||
build(lson);
|
||
build(rson);
|
||
push_up(rt);
|
||
}
|
||
void update(int p, T val, int l, int r, int rt) {
|
||
if (l == r) { data[rt] += val; return; }
|
||
int m = (l + r) >> 1;
|
||
if (p <= m) { update(p, val, lson); }
|
||
else { update(p, val, rson); }
|
||
push_up(rt);
|
||
}
|
||
T query(int L, int R, int l, int r, int rt) {
|
||
if (L <= l && r <= R) { return data[rt]; }
|
||
int m = (l + r) >> 1; T ret = 0;
|
||
if (L <= m) { ret = calc(ret, query(L, R, lson)); }
|
||
if (m < R) { ret = calc(ret, query(L, R, rson)); }
|
||
return ret;
|
||
}
|
||
};
|
||
SegmentTree<int> st;
|
||
//线段树 区间查询/修改 + 延迟标记
|
||
#define lson l,m,rt<<1
|
||
#define rson m+1,r,rt<<1|1
|
||
template<typename T> struct SegmentTree {
|
||
T data[N << 2], lazy[N << 2];
|
||
T calc(const T &x, const T &y)const { return x + y; }
|
||
void push_up(int rt) { data[rt] = calc(data[rt << 1], data[rt << 1 | 1]); }
|
||
void push_down(int rt, int len) {
|
||
if (lazy[rt]) {
|
||
data[rt << 1] += lazy[rt] * (len - (len >> 1)); lazy[rt << 1] += lazy[rt];
|
||
data[rt << 1 | 1] += lazy[rt] * (len >> 1); lazy[rt << 1 | 1] += lazy[rt];
|
||
lazy[rt] = 0;
|
||
}
|
||
}
|
||
void build(int l, int r, int rt) {
|
||
lazy[rt] = 0;
|
||
if (l == r) { scanf("%d", &data[rt]); return; }
|
||
int m = (l + r) >> 1;
|
||
build(lson);
|
||
build(rson);
|
||
push_up(rt);
|
||
}
|
||
void update(int L, int R, T val, int l, int r, int rt) {
|
||
if (L <= l && r <= R) {
|
||
data[rt] += val * (r - l + 1);
|
||
lazy[rt] += val;
|
||
return;
|
||
}
|
||
push_down(rt, r - l + 1);
|
||
int m = (l + r) >> 1;
|
||
if (L <= m) { update(L, R, val, lson); }
|
||
if (m < R) { update(L, R, val, rson); }
|
||
push_up(rt);
|
||
}
|
||
T query(int L, int R, int l, int r, int rt) {
|
||
if (L <= l && r <= R) { return data[rt]; }
|
||
push_down(rt, r - l + 1);
|
||
int m = (l + r) >> 1; T ret = 0;
|
||
if (L <= m) { ret = calc(ret, query(L, R, lson)); }
|
||
if (m < R) { ret = calc(ret, query(L, R, rson)); }
|
||
return ret;
|
||
}
|
||
};
|
||
SegmentTree<int> st;
|
||
//非递归版线段树 单点修改 + 区间查询
|
||
const int N = ((131072 << 1) + 10); //节点个数->不小于区间长度+2的最小2的正整数次幂*2+10
|
||
#define l(x) ((x)<<1) //x的左儿子
|
||
#define r(x) (((x)<<1)|1) //x的右儿子
|
||
template<typename T> struct zkwSegmentTree {
|
||
int m; //底层节点数
|
||
T sum[N]; //区间和
|
||
void build(int n) {
|
||
for (m = 1; m < n + 2; m <<= 1);
|
||
for (int i = 1; i <= n; i++) { scanf("%d", &sum[m + i]); }
|
||
for (int i = m - 1; i; i--) { sum[i] = sum[l(i)] + sum[r(i)]; }
|
||
}
|
||
void update(int p, T val) {
|
||
for (sum[p += m] += val, p >>= 1; p; p >>= 1) {
|
||
sum[p] = sum[l(p)] + sum[r(p)];
|
||
}
|
||
}
|
||
T query(int l, int r) {
|
||
T ret = 0;
|
||
for (l += m - 1, r += m + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
|
||
if (~l & 1) { ret += sum[l ^ 1]; }
|
||
if (r & 1) { ret += sum[r ^ 1]; }
|
||
}
|
||
return ret;
|
||
}
|
||
};
|
||
zkwSegmentTree<int> st;
|
||
//非递归版线段树 区间查询/修改 + 延迟标记
|
||
const int N = ((131072 << 1) + 10); //节点个数->不小于区间长度+2的最小2的正整数次幂*2+10
|
||
#define l(x) ((x)<<1) //x的左儿子
|
||
#define r(x) (((x)<<1)|1) //x的右儿子
|
||
template<typename T> struct zkwSegmentTree {
|
||
int m, h; //底层节点数 高度
|
||
T sum[N], add[N]; //区间和 延迟标记
|
||
void pushdown(int rt) {
|
||
for (int i = h, p; i; i--) { //自顶向下
|
||
if (add[p = rt >> i]) {
|
||
add[p] >>= 1; //add[p]为节点增加总量, 子节点增加一半
|
||
sum[l(p)] += add[p]; add[l(p)] += add[p];
|
||
sum[r(p)] += add[p]; add[r(p)] += add[p];
|
||
add[p] = 0;
|
||
}
|
||
}
|
||
}
|
||
void build(int n) {
|
||
for (m = 1, h = 0; m < n + 2; m <<= 1, h++);
|
||
for (int i = 1; i <= n; i++) { scanf("%d", &sum[m + i]); }
|
||
for (int i = m - 1; i; i--) { sum[i] = sum[l(i)] + sum[r(i)]; }
|
||
}
|
||
void update(int l, int r, T val) {
|
||
l += m - 1, r += m + 1; int ll = l >> 1, rr = r >> 1;
|
||
for (pushdown(l), pushdown(r); l ^ r ^ 1; l >>= 1, r >>= 1, val <<= 1) {
|
||
if (~l & 1) { sum[l ^ 1] += val; add[l ^ 1] += val; }
|
||
if (r & 1) { sum[r ^ 1] += val; add[r ^ 1] += val; }
|
||
}
|
||
for (; ll; ll >>= 1) { sum[ll] = sum[l(ll)] + sum[r(ll)]; }
|
||
for (; rr; rr >>= 1) { sum[rr] = sum[l(rr)] + sum[r(rr)]; }
|
||
}
|
||
T query(int l, int r) {
|
||
T ret = 0; l += m - 1, r += m + 1;
|
||
for (pushdown(l), pushdown(r); l ^ r ^ 1; l >>= 1, r >>= 1) {
|
||
if (~l & 1) { ret += sum[l ^ 1]; }
|
||
if (r & 1) { ret += sum[r ^ 1]; }
|
||
}
|
||
return ret;
|
||
}
|
||
};
|
||
zkwSegmentTree<int> st;
|
||
//可持久化线段树
|
||
const int N = 100005;
|
||
const int M = 2500005;
|
||
const int INF = 0x3f3f3f3f;
|
||
int n, m, nn; //离散化后大小
|
||
#define lson l,m,ls[rt]
|
||
#define rson m+1,r,rs[rt]
|
||
template<typename T> struct SegmentTree {
|
||
int ls[M], rs[M], root[N], tot; T data[M];
|
||
int new_node() { return ++tot; }
|
||
void build(int l, int r, int &rt) {
|
||
rt = new_node(); data[rt] = 0;
|
||
if (l == r) { return; }
|
||
int m = (l + r) >> 1;
|
||
build(lson);
|
||
build(rson);
|
||
}
|
||
void update(int p, T val, int lst, int l, int r, int &rt) {
|
||
rt = new_node(); ls[rt] = ls[lst]; rs[rt] = rs[lst]; data[rt] = data[lst] + val;
|
||
if (l == r) { return; }
|
||
int m = (l + r) >> 1;
|
||
if (p <= m) { update(p, val, ls[lst], lson); }
|
||
else { update(p, val, rs[lst], rson); }
|
||
}
|
||
//带修改区间第k小
|
||
int tree[N], use[N];
|
||
int lowbit(int x) { return x & -x; }
|
||
void modify(int x, int p, T val) { //x为原数列中的下标, p为值
|
||
for (int i = x; i <= n; i += lowbit(i)) { update(p, val, tree[i], 1, nn, tree[i]); }
|
||
}
|
||
T query(int x) {
|
||
T ret = 0;
|
||
for (int i = x; i; i -= lowbit(i)) { ret += data[ls[use[i]]]; }
|
||
return ret;
|
||
}
|
||
int query(int L, int R, int k, int l, int r) {
|
||
for (int i = L; i; i -= lowbit(i)) { use[i] = tree[i]; }
|
||
for (int i = R; i; i -= lowbit(i)) { use[i] = tree[i]; }
|
||
int lr = root[L], rr = root[R];
|
||
while (l < r) {
|
||
int m = (l + r) >> 1; T tmp = query(R) - query(L) + data[ls[rr]] - data[ls[lr]];
|
||
if (k <= tmp) {
|
||
r = m;
|
||
for (int i = L; i; i -= lowbit(i)) { use[i] = ls[use[i]]; }
|
||
for (int i = R; i; i -= lowbit(i)) { use[i] = ls[use[i]]; }
|
||
lr = ls[lr]; rr = ls[rr];
|
||
} else {
|
||
l = m + 1; k -= tmp;
|
||
for (int i = L; i; i -= lowbit(i)) { use[i] = rs[use[i]]; }
|
||
for (int i = R; i; i -= lowbit(i)) { use[i] = rs[use[i]]; }
|
||
lr = rs[lr]; rr = rs[rr];
|
||
}
|
||
}
|
||
return l;
|
||
}
|
||
};
|
||
SegmentTree<int> st;
|
||
//ZOJ 2112
|
||
int a[N], hs[N], l[N], r[N], k[N];
|
||
char op[N];
|
||
int main() {
|
||
int C = 0, T;
|
||
scanf("%d", &T);
|
||
while (++C <= T) {
|
||
nn = 0;
|
||
scanf("%d%d", &n, &m);
|
||
for (int i = 1; i <= n; i++) {
|
||
scanf("%d", &a[i]); hs[++nn] = a[i];
|
||
}
|
||
for (int i = 0; i < m; i++) {
|
||
scanf(" %c%d%d", &op[i], &l[i], &r[i]);
|
||
switch (op[i]) {
|
||
case 'Q': scanf("%d", &k[i]); break;
|
||
case 'C': hs[++nn] = r[i]; break;
|
||
}
|
||
}
|
||
sort(hs + 1, hs + nn + 1);
|
||
nn = unique(hs + 1, hs + nn + 1) - hs - 1;
|
||
for (int i = 1; i <= n; ++i) {
|
||
a[i] = lower_bound(hs + 1, hs + nn + 1, a[i]) - hs;
|
||
}
|
||
st.tot = 0;
|
||
st.build(1, nn, st.root[0]);
|
||
for (int i = 1; i <= n; i++) {
|
||
st.update(a[i], 1, st.root[i - 1], 1, nn, st.root[i]);
|
||
}
|
||
for (int i = 1; i <= n; i++) { st.tree[i] = st.root[0]; }
|
||
for (int i = 0; i < m; i++) {
|
||
switch (op[i]) {
|
||
case 'Q':
|
||
printf("%d\n", hs[st.query(l[i] - 1, r[i], k[i], 1, nn)]);
|
||
break;
|
||
case 'C':
|
||
st.modify(l[i], a[l[i]], -1);
|
||
a[l[i]] = lower_bound(hs + 1, hs + nn + 1, r[i]) - hs;
|
||
st.modify(l[i], a[l[i]], 1);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//实时开节点的权值线段树 (无需离散化) O(logV)
|
||
const int N = 60005;
|
||
const int M = 2500005;
|
||
const int INF = 0x3f3f3f3f;
|
||
int n, a[N];
|
||
#define lson l,m,ls[rt]
|
||
#define rson m+1,r,rs[rt]
|
||
struct SegmentTree {
|
||
int ls[M], rs[M], cnt[M], root[N], tot;
|
||
void init() {
|
||
tot = 0; memset(cnt, 0, sizeof(cnt)); memset(root, 0, sizeof(root));
|
||
memset(ls, 0, sizeof(ls)); memset(rs, 0, sizeof(rs));
|
||
}
|
||
int new_node() { return ++tot; }
|
||
void update(int p, int val, int l, int r, int &rt) {
|
||
if (!rt) { rt = new_node(); }
|
||
if (l == r) { cnt[rt] += val; return; }
|
||
int m = (l + r) >> 1;
|
||
if (p <= m) { update(p, val, lson); }
|
||
else { update(p, val, rson); }
|
||
cnt[rt] = cnt[ls[rt]] + cnt[rs[rt]];
|
||
}
|
||
int use[N];
|
||
int lowbit(int x) { return x & -x; }
|
||
//单点修改
|
||
void modify(int x, int p, int val) {
|
||
for (int i = x; i <= n; i += lowbit(i)) { update(p, val, 0, INF, root[i]); }
|
||
}
|
||
int query(int x) {
|
||
int ret = 0;
|
||
for (int i = x; i; i -= lowbit(i)) { ret += cnt[ls[use[i]]]; }
|
||
return ret;
|
||
}
|
||
//查询区间第k小
|
||
int query(int L, int R, int k, int l, int r) {
|
||
for (int i = L; i; i -= lowbit(i)) { use[i] = root[i]; }
|
||
for (int i = R; i; i -= lowbit(i)) { use[i] = root[i]; }
|
||
while (l < r) {
|
||
int m = (l + r) >> 1, tmp = query(R) - query(L);
|
||
if (k <= tmp) {
|
||
r = m;
|
||
for (int i = L; i; i -= lowbit(i)) { use[i] = ls[use[i]]; }
|
||
for (int i = R; i; i -= lowbit(i)) { use[i] = ls[use[i]]; }
|
||
} else {
|
||
l = m + 1; k -= tmp;
|
||
for (int i = L; i; i -= lowbit(i)) { use[i] = rs[use[i]]; }
|
||
for (int i = R; i; i -= lowbit(i)) { use[i] = rs[use[i]]; }
|
||
}
|
||
}
|
||
return l;
|
||
}
|
||
} st;
|
||
//BZOJ1901 区间第k小
|
||
int main() {
|
||
int m, l, r, k; char op[5];
|
||
while (~scanf("%d%d", &n, &m)) {
|
||
st.init();
|
||
for (int i = 1; i <= n; ++i) {
|
||
scanf("%d", &a[i]);
|
||
st.modify(i, a[i], 1);
|
||
}
|
||
while (m--) {
|
||
scanf("%s%d%d", op, &l, &r);
|
||
switch (op[0]) {
|
||
case 'Q':
|
||
scanf("%d", &k);
|
||
printf("%d\n", st.query(l - 1, r, k, 0, INF));
|
||
break;
|
||
case 'C':
|
||
st.modify(l, a[l], -1);
|
||
a[l] = r;
|
||
st.modify(l, a[l], 1);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//平衡二叉树 常用操作
|
||
//注意这些操作适用于不允许重复值的平衡二叉树(set而非multiset)
|
||
//对于允许重复值(拥有cnt域)的实现, 只要在一些+1的地方稍作修改(改成cnt[x])即可
|
||
bool find(int v) {
|
||
for (int x = root; x; x = ch[x][key[x] < v]) {
|
||
if (key[x] == v) { return true; }
|
||
}
|
||
return false;
|
||
}
|
||
int getKth(int k) {
|
||
int x = root;
|
||
while (size[ch[x][0]] + 1 != k) {
|
||
if (k < size[ch[x][0]] + 1) { x = ch[x][0]; }
|
||
else { k -= size[ch[x][0]] + 1; x = ch[x][1]; }
|
||
}
|
||
return key[x];
|
||
}
|
||
int getRank(int v) {
|
||
int ret = 0, x = root;
|
||
while (x) {
|
||
if (v < key[x]) { x = ch[x][0]; }
|
||
else { ret += size[ch[x][0]] + 1; x = ch[x][1]; }
|
||
}
|
||
return ret;
|
||
}
|
||
int getPre(int v) {
|
||
int x = root, y = 0;
|
||
while (x) {
|
||
if (v < key[x]) { x = ch[x][0]; }
|
||
else { y = x; x = ch[x][1]; }
|
||
}
|
||
return y;
|
||
}
|
||
int getNext(int v) {
|
||
int x = root, y = 0;
|
||
while (x) {
|
||
if (v > key[x]) { x = ch[x][1]; }
|
||
else { y = x; x = ch[x][0]; }
|
||
}
|
||
return y;
|
||
}
|
||
int getMin() {
|
||
if (size[root] == 0) { return -1; }
|
||
int x = root;
|
||
while (ch[x][0]) { x = ch[x][0]; }
|
||
return x;
|
||
}
|
||
int getMax() {
|
||
if (size[root] == 0) { return -1; }
|
||
int x = root;
|
||
while (ch[x][1]) { x = ch[x][1]; }
|
||
return x;
|
||
}
|
||
//Debug遍历
|
||
void treaval(int x) {
|
||
if (x != 0) {
|
||
treaval(ch[x][0]);
|
||
printf("Node%2d:lson %2d rson %2d size = %2d ,val = %2d\n", x, ch[x][0], ch[x][1], size[x], key[x]);
|
||
treaval(ch[x][1]);
|
||
}
|
||
}
|
||
void debug() {
|
||
printf("root:%d\n", root);
|
||
treaval(root);
|
||
putchar('\n');
|
||
}
|
||
//基于旋转的Treap 允许重复值
|
||
//维护序列的有序性和堆的性质, 依靠堆值的随机化,
|
||
//将树的高度维护在期望下平衡的程度,从而实现了各种操作期望O(logn)的复杂度.
|
||
//它的性价比高在只有两种旋转(而且可以合并地写), 比红黑树和AVL短小
|
||
struct Treap {
|
||
int tot, root;
|
||
int ch[N][2], key[N], pt[N], cnt[N], size[N];
|
||
void init() { tot = root = 0; pt[0] = INF; }
|
||
void push_up(int x) { size[x] = size[ch[x][0]] + size[ch[x][1]] + cnt[x]; }
|
||
void new_node(int &x, int v) {
|
||
x = ++tot;
|
||
ch[x][0] = ch[x][1] = 0;
|
||
size[x] = cnt[x] = 1;
|
||
pt[x] = rand();
|
||
key[x] = v;
|
||
}
|
||
void rotate(int &x, int f) {
|
||
int y = ch[x][f];
|
||
ch[x][f] = ch[y][f ^ 1];
|
||
ch[y][f ^ 1] = x;
|
||
push_up(x);
|
||
push_up(y);
|
||
x = y;
|
||
}
|
||
void insert(int &x, int v) {
|
||
if (!x) { new_node(x, v); return; }
|
||
if (key[x] == v) {
|
||
++cnt[x];
|
||
} else {
|
||
int f = key[x] < v;
|
||
insert(ch[x][f], v);
|
||
if (pt[ch[x][f]] < pt[x]) {
|
||
rotate(x, f);
|
||
}
|
||
}
|
||
push_up(x);
|
||
}
|
||
void erase(int &x, int v) {
|
||
if (!x) { return; }
|
||
if (key[x] == v) {
|
||
if (cnt[x] > 1) {
|
||
--cnt[x];
|
||
} else {
|
||
if (!ch[x][0] && !ch[x][1]) {
|
||
x = 0;
|
||
} else {
|
||
rotate(x, pt[ch[x][0]] > pt[ch[x][1]]);
|
||
erase(x, v);
|
||
}
|
||
}
|
||
} else {
|
||
erase(ch[x][key[x] < v], v);
|
||
}
|
||
push_up(x);
|
||
}
|
||
void insert(int v) { insert(root, v); }
|
||
void erase(int v) { erase(root, v); }
|
||
} treap;
|
||
//Size Balanced Tree 不允许重复值
|
||
//独特的平摊时间O(1)的Maintain操作, 具有仅次于红黑树的优秀的时间效率
|
||
struct SBT {
|
||
int root, tot;
|
||
int ch[N][2], key[N], size[N];
|
||
void init() { tot = root = 0; size[0] = 0; }
|
||
void rotate(int &x, int f) {
|
||
int y = ch[x][f];
|
||
ch[x][f] = ch[y][f ^ 1];
|
||
ch[y][f ^ 1] = x;
|
||
size[y] = size[x];
|
||
size[x] = size[ch[x][0]] + size[ch[x][1]] + 1;
|
||
x = y;
|
||
}
|
||
void maintain(int &x, int f) {
|
||
if (size[ch[ch[x][f]][f]] > size[ch[x][f ^ 1]]) {
|
||
rotate(x, f);
|
||
} else if (size[ch[ch[x][f]][f ^ 1]] > size[ch[x][f ^ 1]]) {
|
||
rotate(ch[x][f], f ^ 1); rotate(x, f);
|
||
} else {
|
||
return;
|
||
}
|
||
maintain(ch[x][0], 0);
|
||
maintain(ch[x][1], 1);
|
||
maintain(x, 0);
|
||
maintain(x, 1);
|
||
}
|
||
void insert(int &x, int v) {
|
||
if (!x) {
|
||
x = ++tot;
|
||
ch[x][0] = ch[x][1] = 0;
|
||
size[x] = 1;
|
||
key[x] = v;
|
||
} else {
|
||
++size[x];
|
||
insert(ch[x][key[x] < v], v);
|
||
maintain(x, key[x] < v);
|
||
}
|
||
}
|
||
int erase(int &x, int v) {
|
||
if (!x) { return 0; }
|
||
--size[x];
|
||
if (key[x] == v || (key[x] > v && !ch[x][0]) || (key[x] < v && !ch[x][1])) {
|
||
int ret = key[x];
|
||
if (ch[x][0] && ch[x][1]) {
|
||
key[x] = erase(ch[x][0], v + 1);
|
||
} else {
|
||
x = ch[x][0] + ch[x][1];
|
||
}
|
||
return ret;
|
||
}
|
||
return erase(ch[x][key[x] < v], v);
|
||
}
|
||
void insert(int v) { insert(root, v); }
|
||
void erase(int v) { erase(root, v); }
|
||
} sbt;
|
||
//Splay
|
||
//可以实现很多其它平衡树无法实现的操作(如区间翻转), 既可以维护集合信息,
|
||
//也可以维护序列信息, 可以用它来做Treap的题, 也可以用它来做线段树的题.
|
||
//更重要的是, Splay可以实现split(将某棵子树从原树中分离)和merge操作(将某棵子树插入另一棵树),
|
||
//这也使得区间插入删除成为可能. 它的美中不足是常数稍大, 约是Treap的1.5～3倍, 线段树的2～5倍.
|
||
//Splay有单旋和双旋两种实现, 其中只有双旋保证了均摊O(logn)的单次操作复杂度,
|
||
//但因为很多人认为zigzag太长不好敲(大多是OI选手有此困扰), 选择了单旋.
|
||
//其实完全可以稍微损失一点常数, 合并成一个rotate函数来完成双旋.
|
||
//此外一个良好的实现通常要在序列一首一尾增加两个哨兵节点, 这样可以减少很多边界特判.
|
||
//有必要进行的扩展性说明是, 对于一棵树, 如果想要维护子树信息, 我们可以用Splay维护这棵树的括号序列(dfs序),
|
||
//这样便可以轻易split出任意子树所属的区间；而用Splay维护dfs序的结构, 就是Euler-Tour Tree.
|
||
//同样的, 如果想要维护链上信息, 可以先树链剖分然后用Splay维护每条重链,
|
||
//根据杨哲在07年国家集训队作业的计算, 因其势能分析得到的复杂度依然是单次操作均摊O(logn)复杂度;
|
||
//而类似的思想做些转化, 就变成了后面会提到的Link-Cut Tree(以下简称LCT).
|
||
//ver.1
|
||
#define keyTree (ch[ch[root][1]][0])
|
||
const int N = 200005;
|
||
const int INF = 0x3f3f3f3f;
|
||
int num[N];
|
||
struct Splay {
|
||
int root, tot1, tot2;
|
||
int ch[N][2], pre[N], size[N];
|
||
int gc[N], que[N];
|
||
int key[N], vmin[N], add[N], rev[N];
|
||
void rotate(int x, int f) {
|
||
int y = pre[x];
|
||
ch[y][f ^ 1] = ch[x][f];
|
||
pre[ch[x][f]] = y;
|
||
pre[x] = pre[y];
|
||
if (pre[x]) {
|
||
ch[pre[y]][ch[pre[y]][1] == y] = x;
|
||
}
|
||
ch[x][f] = y;
|
||
pre[y] = x;
|
||
push_up(y);
|
||
}
|
||
void splay(int x, int goal) {
|
||
push_down(x);
|
||
while (pre[x] != goal) {
|
||
int y = pre[x], z = pre[y];
|
||
if (z == goal) {
|
||
push_down(y);
|
||
push_down(x);
|
||
rotate(x, ch[y][0] == x);
|
||
} else {
|
||
push_down(z);
|
||
push_down(y);
|
||
push_down(x);
|
||
int f = ch[z][0] == y;
|
||
if (ch[y][f] == x) {
|
||
rotate(x, f ^ 1);
|
||
} else {
|
||
rotate(y, f);
|
||
}
|
||
rotate(x, f);
|
||
}
|
||
}
|
||
push_up(x);
|
||
if (goal == 0) {
|
||
root = x;
|
||
}
|
||
}
|
||
void rotate_to(int k, int goal) {
|
||
int x = root;
|
||
push_down(x);
|
||
while (size[ch[x][0]] != k) {
|
||
if (k < size[ch[x][0]]) {
|
||
x = ch[x][0];
|
||
} else {
|
||
k -= size[ch[x][0]] + 1;
|
||
x = ch[x][1];
|
||
}
|
||
push_down(x);
|
||
}
|
||
splay(x, goal);
|
||
}
|
||
void erase(int x) {
|
||
int fa = pre[x], head = 0, tail = 0;
|
||
for (que[tail++] = x; head < tail; ++head) {
|
||
gc[tot2++] = que[head];
|
||
if (ch[que[head]][0]) {
|
||
que[tail++] = ch[que[head]][0];
|
||
}
|
||
if (ch[que[head]][1]) {
|
||
que[tail++] = ch[que[head]][1];
|
||
}
|
||
}
|
||
ch[fa][ch[fa][1] == x] = 0;
|
||
push_up(fa);
|
||
}
|
||
void new_node(int &x, int v, int fa) {
|
||
if (tot2) {
|
||
x = gc[--tot2];
|
||
} else {
|
||
x = ++tot1;
|
||
}
|
||
ch[x][0] = ch[x][1] = 0;
|
||
pre[x] = fa;
|
||
size[x] = 1;
|
||
key[x] = vmin[x] = v;
|
||
add[x] = rev[x] = 0;
|
||
}
|
||
void update_add(int x, int d) {
|
||
if (x) {
|
||
key[x] += d;
|
||
add[x] += d;
|
||
vmin[x] += d;
|
||
}
|
||
}
|
||
void update_rev(int x) {
|
||
if (x) {
|
||
swap(ch[x][0], ch[x][1]);
|
||
rev[x] ^= 1;
|
||
}
|
||
}
|
||
void push_up(int x) {
|
||
size[x] = size[ch[x][0]] + size[ch[x][1]] + 1;
|
||
vmin[x] = min(key[x], min(vmin[ch[x][0]], vmin[ch[x][1]]));
|
||
}
|
||
void push_down(int x) {
|
||
if (add[x]) {
|
||
update_add(ch[x][0], add[x]);
|
||
update_add(ch[x][1], add[x]);
|
||
add[x] = 0;
|
||
}
|
||
if (rev[x]) {
|
||
update_rev(ch[x][0]);
|
||
update_rev(ch[x][1]);
|
||
rev[x] = 0;
|
||
}
|
||
}
|
||
void build(int &x, int l, int r, int f) {
|
||
int m = l + r >> 1;
|
||
new_node(x, num[m], f);
|
||
if (l < m) {
|
||
build(ch[x][0], l, m - 1, x);
|
||
}
|
||
if (r > m) {
|
||
build(ch[x][1], m + 1, r, x);
|
||
}
|
||
push_up(x);
|
||
}
|
||
void init(int n) {
|
||
root = tot1 = tot2 = 0;
|
||
ch[0][0] = ch[0][1] = pre[0] = size[0] = 0;
|
||
add[0] = rev[0] = 0;
|
||
key[0] = vmin[0] = INF;
|
||
new_node(root, -1, 0);
|
||
new_node(ch[root][1], -1, root);
|
||
size[root] = 2;
|
||
for (int i = 1; i <= n; ++i) {
|
||
scanf("%d", &num[i]);
|
||
}
|
||
build(keyTree, 1, n, ch[root][1]);
|
||
push_up(ch[root][1]);
|
||
push_up(root);
|
||
}
|
||
void plus(int l, int r, int v) {
|
||
rotate_to(l - 1, 0);
|
||
rotate_to(r + 1, root);
|
||
update_add(keyTree, v);
|
||
}
|
||
void reverse(int l, int r) {
|
||
rotate_to(l - 1, 0);
|
||
rotate_to(r + 1, root);
|
||
update_rev(keyTree);
|
||
}
|
||
void revolve(int l, int r, int k) {
|
||
k %= r - l + 1;
|
||
if (!k) {
|
||
return;
|
||
}
|
||
rotate_to(r - k, 0);
|
||
rotate_to(r + 1, root);
|
||
int tmp = keyTree;
|
||
keyTree = 0;
|
||
push_up(ch[root][1]);
|
||
push_up(root);
|
||
rotate_to(l - 1, 0);
|
||
rotate_to(l, root);
|
||
keyTree = tmp;
|
||
pre[tmp] = ch[root][1];
|
||
push_up(ch[root][1]);
|
||
push_up(root);
|
||
}
|
||
void insert(int k, int v) {
|
||
rotate_to(k, 0);
|
||
rotate_to(k + 1, root);
|
||
new_node(keyTree, v, ch[root][1]);
|
||
push_up(ch[root][1]);
|
||
push_up(root);
|
||
}
|
||
void del(int k) {
|
||
rotate_to(k - 1, 0);
|
||
rotate_to(k + 1, root);
|
||
erase(keyTree);
|
||
push_up(ch[root][1]);
|
||
push_up(root);
|
||
}
|
||
int query(int l, int r) {
|
||
rotate_to(l - 1, 0);
|
||
rotate_to(r + 1, root);
|
||
return vmin[keyTree];
|
||
}
|
||
} splay;
|
||
int main() {
|
||
int n, m, x, y, v;
|
||
char op[10];
|
||
while (~scanf("%d", &n)) {
|
||
splay.init(n);
|
||
scanf("%d", &m);
|
||
while (m--) {
|
||
scanf("%s", op);
|
||
switch (op[0]) {
|
||
case 'A':
|
||
scanf("%d%d%d", &x, &y, &v);
|
||
splay.plus(x, y, v);
|
||
break;
|
||
case 'R':
|
||
scanf("%d%d", &x, &y);
|
||
if (op[3] == 'E') {
|
||
splay.reverse(x, y);
|
||
} else {
|
||
scanf("%d", &v);
|
||
splay.revolve(x, y, v);
|
||
}
|
||
break;
|
||
case 'I':
|
||
scanf("%d%d", &x, &v);
|
||
splay.insert(x, v);
|
||
break;
|
||
case 'D':
|
||
scanf("%d", &x);
|
||
splay.del(x);
|
||
break;
|
||
case 'M':
|
||
scanf("%d%d", &x, &y);
|
||
printf("%d\n", splay.query(x, y));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//ver.2
|
||
int k1, k2, num[N];
|
||
struct Splay {
|
||
int root, tot, point;
|
||
int ch[N][2], pre[N], size[N];
|
||
int key[N], add[N], rev[N];
|
||
bool isroot(int x) { return !pre[x] || ch[pre[x]][0] != x && ch[pre[x]][1] != x; }
|
||
void rotate(int x) {
|
||
int y = pre[x], f = ch[y][1] == x;
|
||
ch[y][f] = ch[x][f ^ 1];
|
||
pre[ch[y][f]] = y;
|
||
if (!isroot(y)) { ch[pre[y]][ch[pre[y]][1] == y] = x; }
|
||
pre[x] = pre[y];
|
||
ch[x][f ^ 1] = y;
|
||
pre[y] = x;
|
||
push_up(y);
|
||
}
|
||
void splay(int x) {
|
||
push_down(x);
|
||
while (!isroot(x)) {
|
||
int y = pre[x], z = pre[y];
|
||
if (isroot(y)) {
|
||
push_down(y);
|
||
push_down(x);
|
||
rotate(x);
|
||
} else {
|
||
push_down(z);
|
||
push_down(y);
|
||
push_down(x);
|
||
rotate((ch[z][1] == y) == (ch[y][1] == x) ? y : x);
|
||
rotate(x);
|
||
}
|
||
}
|
||
push_up(x);
|
||
}
|
||
void new_node(int &x, int v, int fa) {
|
||
x = ++tot;
|
||
ch[x][0] = ch[x][1] = 0;
|
||
pre[x] = fa;
|
||
size[x] = 1;
|
||
key[x] = v;
|
||
add[x] = rev[x] = 0;
|
||
}
|
||
void update_add(int x, int v) {
|
||
if (x) { key[x] += v; add[x] += v; }
|
||
}
|
||
void update_rev(int x) {
|
||
if (x) { rev[x] ^= 1; swap(ch[x][0], ch[x][1]); }
|
||
}
|
||
void push_down(int x) {
|
||
if (add[x]) {
|
||
update_add(ch[x][0], add[x]);
|
||
update_add(ch[x][1], add[x]);
|
||
add[x] = 0;
|
||
}
|
||
if (rev[x]) {
|
||
update_rev(ch[x][0]);
|
||
update_rev(ch[x][1]);
|
||
rev[x] = 0;
|
||
}
|
||
}
|
||
void push_up(int x) { size[x] = size[ch[x][0]] + size[ch[x][1]] + 1; }
|
||
void build(int &x, int l, int r, int fa) {
|
||
int m = l + r >> 1;
|
||
new_node(x, num[m], fa);
|
||
if (l < m) { build(ch[x][0], l, m - 1, x); }
|
||
if (r > m) { build(ch[x][1], m + 1, r, x); }
|
||
push_up(x);
|
||
}
|
||
void init(int n) {
|
||
root = tot = size[0] = 0;
|
||
for (int i = 1; i <= n; ++i) {
|
||
scanf("%d", &num[i]);
|
||
}
|
||
build(root, 1, n, 0);
|
||
point = 1;
|
||
}
|
||
int find(int rt, int k) {
|
||
int x = rt;
|
||
while (size[ch[x][0]] + 1 != k) {
|
||
push_down(x);
|
||
if (k <= size[ch[x][0]]) {
|
||
x = ch[x][0];
|
||
} else {
|
||
k -= size[ch[x][0]] + 1;
|
||
x = ch[x][1];
|
||
}
|
||
}
|
||
return x;
|
||
}
|
||
void split(int &x, int &y, int sz) {
|
||
if (!sz) { y = x; x = 0; return; }
|
||
y = find(x, sz + 1);
|
||
splay(y);
|
||
x = ch[y][0];
|
||
ch[y][0] = 0;
|
||
push_up(y);
|
||
}
|
||
void split3(int &x, int &y, int &z, int l, int r) {
|
||
split(x, z, r); split(x, y, l - 1);
|
||
}
|
||
void join(int &x, int &y) {
|
||
if (!x || !y) { x |= y; return; }
|
||
x = find(x, size[x]);
|
||
splay(x);
|
||
ch[x][1] = y;
|
||
pre[y] = x;
|
||
push_up(x);
|
||
}
|
||
void join3(int &x, int y, int z) {
|
||
join(y, z); join(x, y);
|
||
}
|
||
void evert() {
|
||
if (point > 1) {
|
||
int x;
|
||
split(root, x, point - 1);
|
||
swap(root, x);
|
||
join(root, x);
|
||
point = 1;
|
||
}
|
||
}
|
||
void plus(int v) {
|
||
evert();
|
||
int x, y;
|
||
split3(root, x, y, point, point + k2 - 1);
|
||
update_add(x, v);
|
||
join3(root, x, y);
|
||
}
|
||
void reverse() {
|
||
evert();
|
||
int x, y;
|
||
split3(root, x, y, point, point + k1 - 1);
|
||
update_rev(x);
|
||
join3(root, x, y);
|
||
}
|
||
void insert(int v) {
|
||
evert();
|
||
int x, y;
|
||
split(root, x, point);
|
||
new_node(y, v, 0);
|
||
join3(root, y, x);
|
||
}
|
||
void erase() {
|
||
evert();
|
||
int x, y;
|
||
split3(root, x, y, point, point);
|
||
join(root, y);
|
||
}
|
||
void move(int tag) {
|
||
switch (tag) {
|
||
case 1:
|
||
if (--point == 0) { point = size[root]; }
|
||
break;
|
||
case 2:
|
||
if (++point == size[root] + 1) { point = 1; }
|
||
break;
|
||
}
|
||
}
|
||
void query() {
|
||
evert();
|
||
int x, y;
|
||
split3(root, x, y, point, point);
|
||
printf("%d\n", key[x]);
|
||
join3(root, x, y);
|
||
}
|
||
} splay;
|
||
//HDU4453
|
||
int main() {
|
||
int n, m, v, cas = 0;
|
||
char op[10];
|
||
while (~scanf("%d%d%d%d", &n, &m, &k1, &k2) && (n || m || k1 || k2)) {
|
||
splay.init(n);
|
||
printf("Case #%d:\n", ++cas);
|
||
while (m--) {
|
||
scanf("%s", op);
|
||
switch (op[0]) {
|
||
case 'a':
|
||
scanf("%d", &v);
|
||
splay.plus(v);
|
||
break;
|
||
case 'r':
|
||
splay.reverse();
|
||
break;
|
||
case 'i':
|
||
scanf("%d", &v);
|
||
splay.insert(v);
|
||
break;
|
||
case 'd':
|
||
splay.erase();
|
||
break;
|
||
case 'm':
|
||
scanf("%d", &v);
|
||
splay.move(v);
|
||
break;
|
||
case 'q':
|
||
splay.query();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//ver.3
|
||
const int N = 500005;
|
||
const int INF = 0x3f3f3f3f;
|
||
int n, q;
|
||
struct Splay {
|
||
int pre[N], ch[N][2], key[N], size[N];
|
||
int root, tot1;
|
||
int sum[N], rev[N], same[N];
|
||
int lx[N], rx[N], mx[N];
|
||
int s[N], tot2; //内存池和容量
|
||
int a[N];
|
||
void NewNode(int &r, int father, int k) {
|
||
if (tot2) { r = s[tot2--]; } //取的时候是tot2--,存的时候就是++tot2
|
||
else { r = ++tot1; }
|
||
pre[r] = father;
|
||
ch[r][0] = ch[r][1] = 0;
|
||
key[r] = k;
|
||
sum[r] = k;
|
||
rev[r] = same[r] = 0;
|
||
lx[r] = rx[r] = mx[r] = k;
|
||
size[r] = 1;
|
||
}
|
||
void Update_Rev(int r) {
|
||
if (!r) { return; }
|
||
swap(ch[r][0], ch[r][1]);
|
||
swap(lx[r], rx[r]);
|
||
rev[r] ^= 1;
|
||
}
|
||
void Update_Same(int r, int v) {
|
||
if (!r) { return; }
|
||
key[r] = v;
|
||
sum[r] = v * size[r];
|
||
lx[r] = rx[r] = mx[r] = max(v, v * size[r]);
|
||
same[r] = 1;
|
||
}
|
||
void push_up(int r) {
|
||
int lson = ch[r][0], rson = ch[r][1];
|
||
size[r] = size[lson] + size[rson] + 1;
|
||
sum[r] = sum[lson] + sum[rson] + key[r];
|
||
lx[r] = max(lx[lson], sum[lson] + key[r] + max(0, lx[rson]));
|
||
rx[r] = max(rx[rson], sum[rson] + key[r] + max(0, rx[lson]));
|
||
mx[r] = max(0, rx[lson]) + key[r] + max(0, lx[rson]);
|
||
mx[r] = max(mx[r], max(mx[lson], mx[rson]));
|
||
}
|
||
void push_down(int r) {
|
||
if (same[r]) {
|
||
Update_Same(ch[r][0], key[r]);
|
||
Update_Same(ch[r][1], key[r]);
|
||
same[r] = 0;
|
||
}
|
||
if (rev[r]) {
|
||
Update_Rev(ch[r][0]);
|
||
Update_Rev(ch[r][1]);
|
||
rev[r] = 0;
|
||
}
|
||
}
|
||
void Build(int &x, int l, int r, int father) {
|
||
if (l > r) { return; }
|
||
int mid = (l + r) / 2;
|
||
NewNode(x, father, a[mid]);
|
||
Build(ch[x][0], l, mid - 1, x);
|
||
Build(ch[x][1], mid + 1, r, x);
|
||
push_up(x);
|
||
}
|
||
void Init() {
|
||
root = tot1 = tot2 = 0;
|
||
ch[root][0] = ch[root][1] = size[root] = pre[root] = 0;
|
||
same[root] = rev[root] = sum[root] = key[root] = 0;
|
||
lx[root] = rx[root] = mx[root] = -INF;
|
||
NewNode(root, 0, -1);
|
||
NewNode(ch[root][1], root, -1);
|
||
for (int i = 0; i < n; i++) {
|
||
scanf("%d", &a[i]);
|
||
}
|
||
Build(ch[ch[root][1]][0], 0, n - 1, ch[root][1]);
|
||
push_up(ch[root][1]);
|
||
push_up(root);
|
||
}
|
||
//旋转,0为左旋, 1为右旋
|
||
void Rotate(int x, int kind) {
|
||
int y = pre[x];
|
||
push_down(y);
|
||
push_down(x);
|
||
ch[y][!kind] = ch[x][kind];
|
||
pre[ch[x][kind]] = y;
|
||
if (pre[y]) { ch[pre[y]][ch[pre[y]][1] == y] = x; }
|
||
pre[x] = pre[y];
|
||
ch[x][kind] = y;
|
||
pre[y] = x;
|
||
push_up(y);
|
||
}
|
||
//Splay调整, 将r结点调整到goal下面
|
||
void Splay(int r, int goal) {
|
||
push_down(r);
|
||
while (pre[r] != goal) {
|
||
if (pre[pre[r]] == goal) {
|
||
push_down(pre[r]);
|
||
push_down(r);
|
||
Rotate(r, ch[pre[r]][0] == r);
|
||
} else {
|
||
push_down(pre[pre[r]]);
|
||
push_down(pre[r]);
|
||
push_down(r);
|
||
int y = pre[r];
|
||
int kind = ch[pre[y]][0] == y;
|
||
if (ch[y][kind] == r) {
|
||
Rotate(r, !kind);
|
||
Rotate(r, kind);
|
||
} else {
|
||
Rotate(y, kind);
|
||
Rotate(r, kind);
|
||
}
|
||
}
|
||
}
|
||
push_up(r);
|
||
if (goal == 0) { root = r; }
|
||
}
|
||
int Get_kth(int r, int k) {
|
||
push_down(r);
|
||
int t = size[ch[r][0]] + 1;
|
||
if (t == k) { return r; }
|
||
if (t > k) { return Get_kth(ch[r][0], k); }
|
||
else { return Get_kth(ch[r][1], k - t); }
|
||
}
|
||
//在第pos个数后面插入tot个数
|
||
void Insert(int pos, int tot) {
|
||
for (int i = 0; i < tot; i++) { scanf("%d", &a[i]); }
|
||
Splay(Get_kth(root, pos + 1), 0);
|
||
Splay(Get_kth(root, pos + 2), root);
|
||
Build(ch[ch[root][1]][0], 0, tot - 1, ch[root][1]);
|
||
push_up(ch[root][1]);
|
||
push_up(root);
|
||
}
|
||
//删除子树
|
||
void erase(int r) {
|
||
if (!r) { return; }
|
||
s[++tot2] = r;
|
||
erase(ch[r][0]);
|
||
erase(ch[r][1]);
|
||
}
|
||
//从第pos个数开始连续删除tot个数
|
||
void Delete(int pos, int tot) {
|
||
Splay(Get_kth(root, pos), 0);
|
||
Splay(Get_kth(root, pos + tot + 1), root);
|
||
erase(ch[ch[root][1]][0]);
|
||
pre[ch[ch[root][1]][0]] = 0;
|
||
ch[ch[root][1]][0] = 0;
|
||
push_up(ch[root][1]);
|
||
push_up(root);
|
||
}
|
||
//将从第pos个数开始的连续的tot个数修改为c
|
||
void Make_Same(int pos, int tot, int c) {
|
||
Splay(Get_kth(root, pos), 0);
|
||
Splay(Get_kth(root, pos + tot + 1), root);
|
||
Update_Same(ch[ch[root][1]][0], c);
|
||
push_up(ch[root][1]);
|
||
push_up(root);
|
||
}
|
||
//将第pos个数开始的连续tot个数进行反转
|
||
void Reverse(int pos, int tot) {
|
||
Splay(Get_kth(root, pos), 0);
|
||
Splay(Get_kth(root, pos + tot + 1), root);
|
||
Update_Rev(ch[ch[root][1]][0]);
|
||
push_up(ch[root][1]);
|
||
push_up(root);
|
||
}
|
||
//得到第pos个数开始的tot个数的和
|
||
int Get_Sum(int pos, int tot) {
|
||
Splay(Get_kth(root, pos), 0);
|
||
Splay(Get_kth(root, pos + tot + 1), root);
|
||
return sum[ch[ch[root][1]][0]];
|
||
}
|
||
//得到第pos个数开始的tot个数中最大的子段和
|
||
int Get_MaxSum(int pos, int tot) {
|
||
Splay(Get_kth(root, pos), 0);
|
||
Splay(Get_kth(root, pos + tot + 1), root);
|
||
return mx[ch[ch[root][1]][0]];
|
||
}
|
||
void InOrder(int r) {
|
||
if (!r) { return; }
|
||
push_down(r);
|
||
InOrder(ch[r][0]);
|
||
printf("%d ", key[r]);
|
||
InOrder(ch[r][1]);
|
||
}
|
||
} splay;
|
||
int main() {
|
||
while (scanf("%d%d", &n, &q) == 2) {
|
||
splay.Init();
|
||
char op[20];
|
||
int x, y, z;
|
||
while (q--) {
|
||
scanf("%s", op);
|
||
if (strcmp(op, "INSERT") == 0) {
|
||
scanf("%d%d", &x, &y);
|
||
splay.Insert(x, y);
|
||
} else if (strcmp(op, "DELETE") == 0) {
|
||
scanf("%d%d", &x, &y);
|
||
splay.Delete(x, y);
|
||
} else if (strcmp(op, "MAKE-SAME") == 0) {
|
||
scanf("%d%d%d", &x, &y, &z);
|
||
splay.Make_Same(x, y, z);
|
||
} else if (strcmp(op, "REVERSE") == 0) {
|
||
scanf("%d%d", &x, &y);
|
||
splay.Reverse(x, y);
|
||
} else if (strcmp(op, "GET-SUM") == 0) {
|
||
scanf("%d%d", &x, &y);
|
||
printf("%d\n", splay.Get_Sum(x, y));
|
||
} else if (strcmp(op, "MAX-SUM") == 0) {
|
||
printf("%d\n", splay.Get_MaxSum(1, splay.size[root] - 2));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//Link-Cut Tree 动态树
|
||
//维护多棵树(森林)的形态, 并在O(logn)的时间复杂度内维护链上信息; 但LCT处理子树信息将会非常麻烦.
|
||
//它的核心操作是access函数, 可以把某个节点到根的路径上所有点按照深度用Splay维护起来,
|
||
//从而结合evert函数(换跟操作)和splay操作可以实现对链的信息维护.
|
||
//LCT几乎可以实现除维护子树信息外以上的所有操作, 同时有着优越的理论复杂度,
|
||
//但实际常数较大, 很多不改变树形态的题用O(logn)的LCT并不比O(log^2n)的树链剖分套线段树更优越
|
||
struct LCT {
|
||
int ch[N][2], pre[N], key[N], rev[N];
|
||
int add[N], vmax[N];
|
||
bool isroot(int x) { return !pre[x] || ch[pre[x]][0] != x && ch[pre[x]][1] != x; }
|
||
void rotate(int x) {
|
||
int y = pre[x], f = ch[y][1] == x;
|
||
ch[y][f] = ch[x][f ^ 1];
|
||
pre[ch[y][f]] = y;
|
||
if (!isroot(y)) { ch[pre[y]][ch[pre[y]][1] == y] = x; }
|
||
pre[x] = pre[y];
|
||
ch[x][f ^ 1] = y;
|
||
pre[y] = x;
|
||
push_up(y);
|
||
}
|
||
void splay(int x) {
|
||
push_down(x);
|
||
while (!isroot(x)) {
|
||
int y = pre[x], z = pre[y];
|
||
if (isroot(y)) {
|
||
push_down(y);
|
||
push_down(x);
|
||
rotate(x);
|
||
} else {
|
||
push_down(z);
|
||
push_down(y);
|
||
push_down(x);
|
||
rotate((ch[z][1] == y) == (ch[y][1] == x) ? y : x);
|
||
rotate(x);
|
||
}
|
||
}
|
||
push_up(x);
|
||
}
|
||
int access(int x) {
|
||
int y = 0;
|
||
for (; x; x = pre[x]) {
|
||
splay(x);
|
||
ch[x][1] = y;
|
||
push_up(x);
|
||
y = x;
|
||
}
|
||
return y;
|
||
}
|
||
void evert(int x) {
|
||
rev[access(x)] ^= 1;
|
||
splay(x);
|
||
}
|
||
void push_up(int x) { vmax[x] = max(max(vmax[ch[x][0]], vmax[ch[x][1]]), key[x]); }
|
||
void push_down(int x) {
|
||
if (add[x]) {
|
||
key[x] += add[x];
|
||
if (ch[x][0]) {
|
||
add[ch[x][0]] += add[x];
|
||
vmax[ch[x][0]] += add[x];
|
||
}
|
||
if (ch[x][1]) {
|
||
add[ch[x][1]] += add[x];
|
||
vmax[ch[x][1]] += add[x];
|
||
}
|
||
add[x] = 0;
|
||
}
|
||
if (rev[x]) {
|
||
if (ch[x][0]) { rev[ch[x][0]] ^= 1; }
|
||
if (ch[x][1]) { rev[ch[x][1]] ^= 1; }
|
||
swap(ch[x][0], ch[x][1]);
|
||
rev[x] = 0;
|
||
}
|
||
}
|
||
int find_root(int x) {
|
||
while (pre[x]) { x = pre[x]; }
|
||
return x;
|
||
}
|
||
//如果u,v不在同一颗子树中,则通过在u,v之间连边的方式,连接这两颗子树
|
||
void link(int u, int v) {
|
||
if (find_root(u) == find_root(v)) { puts("-1"); return; }
|
||
evert(u);
|
||
pre[u] = v;
|
||
}
|
||
//如果u,v在同一颗子树中,且u!=v,则将u视为这颗子树的根以后,切断v与其父亲结点的连接
|
||
void cut(int u, int v) {
|
||
if (u == v || find_root(u) != find_root(v)) { puts("-1"); return; }
|
||
evert(u);
|
||
access(v);
|
||
splay(v);
|
||
pre[ch[v][0]] = 0;
|
||
ch[v][0] = 0;
|
||
push_up(v);
|
||
}
|
||
//如果u,v在同一颗子树中,则将u,v之间路径上所有点的点权增加w
|
||
void update(int u, int v, int w) {
|
||
if (find_root(u) != find_root(v)) { puts("-1"); return; }
|
||
evert(u);
|
||
access(v);
|
||
splay(v);
|
||
add[v] += w;
|
||
vmax[v] += w;
|
||
push_down(v);
|
||
}
|
||
//如果u,v在同一颗子树中, 返回u,v之间路径上点权的最大值
|
||
void query(int u, int v) {
|
||
if (find_root(u) != find_root(v)) { puts("-1"); return; }
|
||
evert(u);
|
||
access(v);
|
||
splay(v);
|
||
printf("%d\n", vmax[v]);
|
||
}
|
||
struct graph {
|
||
int head[N], to[N << 1], next[N << 1];
|
||
int tot;
|
||
void init() { tot = 0; memset(head, 0xff, sizeof(head)); }
|
||
void add(int u, int v) {
|
||
to[tot] = v;
|
||
next[tot] = head[u];
|
||
head[u] = tot++;
|
||
}
|
||
} g;
|
||
void dfs(int u, int fa) {
|
||
for (int i = g.head[u]; ~i; i = g.next[i]) {
|
||
int v = g.to[i];
|
||
if (v != fa) {
|
||
dfs(v, u);
|
||
pre[v] = u;
|
||
}
|
||
}
|
||
}
|
||
void init(int n) {
|
||
int m, x, y;
|
||
g.init();
|
||
for (int i = 1; i < n; ++i) {
|
||
scanf("%d%d", &x, &y);
|
||
g.add(x, y); g.add(y, x);
|
||
}
|
||
memset(ch, 0, sizeof(ch));
|
||
memset(pre, 0, sizeof(pre));
|
||
memset(rev, 0, sizeof(rev));
|
||
memset(add, 0, sizeof(add));
|
||
vmax[0] = 0;
|
||
for (int i = 1; i <= n; ++i) {
|
||
scanf("%d", &key[i]);
|
||
vmax[i] = key[i];
|
||
}
|
||
dfs(1, 0);
|
||
}
|
||
} lct;
|
||
//HDU4010
|
||
int main() {
|
||
int n, q, op, x, y, w;
|
||
while (~scanf("%d", &n)) {
|
||
lct.init(n);
|
||
scanf("%d", &q);
|
||
while (q--) {
|
||
scanf("%d", &op);
|
||
switch (op) {
|
||
case 1:
|
||
scanf("%d%d", &x, &y);
|
||
lct.link(x, y);
|
||
break;
|
||
case 2:
|
||
scanf("%d%d", &x, &y);
|
||
lct.cut(x, y);
|
||
break;
|
||
case 3:
|
||
scanf("%d%d%d", &w, &x, &y);
|
||
lct.update(x, y, w);
|
||
break;
|
||
case 4:
|
||
scanf("%d%d", &x, &y);
|
||
lct.query(x, y);
|
||
break;
|
||
}
|
||
}
|
||
putchar('\n');
|
||
}
|
||
}
|
||
//不基于旋转的Treap
|
||
int num[N];
|
||
struct Treap {
|
||
int tot, root;
|
||
int ch[N][2], pt[N], size[N];
|
||
int key[N], vmin[N], add[N], rev[N];
|
||
void init() { tot = 0; }
|
||
void new_node(int &x, int v) {
|
||
x = ++tot;
|
||
ch[x][0] = ch[x][1] = 0;
|
||
size[x] = 1;
|
||
pt[x] = rand();
|
||
key[x] = vmin[x] = v;
|
||
add[x] = rev[x] = 0;
|
||
}
|
||
void merge(int &p, int x, int y) {
|
||
if (!x || !y) { p = x | y; return; }
|
||
if (pt[x] < pt[y]) {
|
||
push_down(x);
|
||
merge(ch[x][1], ch[x][1], y);
|
||
p = x;
|
||
} else {
|
||
push_down(y);
|
||
merge(ch[y][0], x, ch[y][0]);
|
||
p = y;
|
||
}
|
||
push_up(p);
|
||
}
|
||
void split(int p, int sz, int &x, int &y) {
|
||
if (!sz) { x = 0; y = p; return; }
|
||
push_down(p);
|
||
if (size[ch[p][0]] >= sz) {
|
||
y = p;
|
||
split(ch[p][0], sz, x, ch[y][0]);
|
||
} else {
|
||
x = p;
|
||
split(ch[p][1], sz - size[ch[p][0]] - 1, ch[x][1], y);
|
||
}
|
||
push_up(p);
|
||
}
|
||
void update_add(int x, int v) {
|
||
if (x) { key[x] += v; add[x] += v; vmin[x] += v; }
|
||
}
|
||
void update_rev(int x) {
|
||
if (x) { swap(ch[x][0], ch[x][1]); rev[x] ^= 1; }
|
||
}
|
||
void push_down(int x) {
|
||
if (add[x]) {
|
||
update_add(ch[x][0], add[x]);
|
||
update_add(ch[x][1], add[x]);
|
||
add[x] = 0;
|
||
}
|
||
if (rev[x]) {
|
||
update_rev(ch[x][0]);
|
||
update_rev(ch[x][1]);
|
||
rev[x] = 0;
|
||
}
|
||
}
|
||
void push_up(int x) {
|
||
size[x] = 1;
|
||
vmin[x] = key[x];
|
||
if (ch[x][0]) {
|
||
size[x] += size[ch[x][0]];
|
||
vmin[x] = min(vmin[x], vmin[ch[x][0]]);
|
||
}
|
||
if (ch[x][1]) {
|
||
size[x] += size[ch[x][1]];
|
||
vmin[x] = min(vmin[x], vmin[ch[x][1]]);
|
||
}
|
||
}
|
||
int build(int &x, int l, int r) {
|
||
int m = l + r >> 1;
|
||
new_node(x, num[m]);
|
||
if (l < m) { build(ch[x][0], l, m - 1); }
|
||
if (r > m) { build(ch[x][1], m + 1, r); }
|
||
push_up(x);
|
||
}
|
||
void plus(int l, int r, int v) {
|
||
int x, y;
|
||
split(root, l - 1, root, x);
|
||
split(x, r - l + 1, x, y);
|
||
update_add(x, v);
|
||
merge(x, x, y);
|
||
merge(root, root, x);
|
||
}
|
||
void reverse(int l, int r) {
|
||
int x, y;
|
||
split(root, l - 1, root, x);
|
||
split(x, r - l + 1, x, y);
|
||
update_rev(x);
|
||
merge(x, x, y);
|
||
merge(root, root, x);
|
||
}
|
||
void revolve(int l, int r, int k) {
|
||
int x, y, p, q;
|
||
k %= r - l + 1;
|
||
if (!k) { return; }
|
||
split(root, l - 1, root, x);
|
||
split(x, r - l + 1, x, y);
|
||
split(x, r - l + 1 - k, p, q);
|
||
merge(x, q, p);
|
||
merge(x, x, y);
|
||
merge(root, root, x);
|
||
}
|
||
void insert(int k, int v) {
|
||
int x, y;
|
||
new_node(x, v);
|
||
split(root, k, root, y);
|
||
merge(root, root, x);
|
||
merge(root, root, y);
|
||
}
|
||
void erase(int k) {
|
||
int x, y;
|
||
split(root, k - 1, root, x);
|
||
split(x, 1, x, y);
|
||
merge(root, root, y);
|
||
}
|
||
int query(int l, int r) {
|
||
int x, y, ret;
|
||
split(root, l - 1, root, x);
|
||
split(x, r - l + 1, x, y);
|
||
ret = vmin[x];
|
||
merge(x, x, y);
|
||
merge(root, root, x);
|
||
return ret;
|
||
}
|
||
} treap;
|
||
//POJ3580
|
||
int main() {
|
||
int n, m, x, y, v;
|
||
char op[10];
|
||
while (~scanf("%d", &n)) {
|
||
treap.init();
|
||
for (int i = 1; i <= n; ++i) {
|
||
scanf("%d", &num[i]);
|
||
}
|
||
treap.build(treap.root, 1, n);
|
||
scanf("%d", &m);
|
||
while (m--) {
|
||
scanf("%s", op);
|
||
switch (op[0]) {
|
||
case 'A':
|
||
scanf("%d%d%d", &x, &y, &v);
|
||
treap.plus(x, y, v);
|
||
break;
|
||
case 'R':
|
||
scanf("%d%d", &x, &y);
|
||
if (op[3] == 'E') {
|
||
treap.reverse(x, y);
|
||
} else {
|
||
scanf("%d", &v);
|
||
treap.revolve(x, y, v);
|
||
}
|
||
break;
|
||
case 'I':
|
||
scanf("%d%d", &x, &v);
|
||
treap.insert(x, v);
|
||
break;
|
||
case 'D':
|
||
scanf("%d", &x);
|
||
treap.erase(x);
|
||
break;
|
||
case 'M':
|
||
scanf("%d%d", &x, &y);
|
||
printf("%d\n", treap.query(x, y));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//可持久化Treap
|
||
const int N = 50005;
|
||
const int M = 5000005;
|
||
int root[N], vs, d;
|
||
struct Treap {
|
||
int tot;
|
||
int ch[M][2], size[M];
|
||
char key[M];
|
||
bool hey(int x, int y) { return (ll)rand() * (size[x] + size[y]) < (ll)size[x] * RAND_MAX; }
|
||
void init() { tot = 0; }
|
||
void new_node(int &x, char v) {
|
||
x = ++tot;
|
||
ch[x][0] = ch[x][1] = 0;
|
||
size[x] = 1;
|
||
key[x] = v;
|
||
}
|
||
void copy_node(int &x, int y) {
|
||
if (!y) { x = 0; return; }
|
||
x = ++tot;
|
||
ch[x][0] = ch[y][0];
|
||
ch[x][1] = ch[y][1];
|
||
size[x] = size[y];
|
||
key[x] = key[y];
|
||
}
|
||
void merge(int &p, int x, int y) {
|
||
if (!x || !y) {
|
||
p = 0;
|
||
if (x) { copy_node(p, x); }
|
||
if (y) { copy_node(p, y); }
|
||
return;
|
||
}
|
||
if (hey(x, y)) {
|
||
copy_node(p, x);
|
||
merge(ch[p][1], ch[x][1], y);
|
||
} else {
|
||
copy_node(p, y);
|
||
merge(ch[p][0], x, ch[y][0]);
|
||
}
|
||
push_up(p);
|
||
}
|
||
void split(int p, int sz, int &x, int &y) {
|
||
if (!sz) { x = 0; copy_node(y, p); return; }
|
||
if (size[ch[p][0]] >= sz) {
|
||
copy_node(y, p);
|
||
split(ch[p][0], sz, x, ch[y][0]);
|
||
push_up(y);
|
||
} else {
|
||
copy_node(x, p);
|
||
split(ch[p][1], sz - size[ch[p][0]] - 1, ch[x][1], y);
|
||
push_up(x);
|
||
}
|
||
}
|
||
void push_up(int x) {
|
||
size[x] = 1;
|
||
if (ch[x][0]) { size[x] += size[ch[x][0]]; }
|
||
if (ch[x][1]) { size[x] += size[ch[x][1]]; }
|
||
}
|
||
void build(char str[], int &x, int l, int r) {
|
||
int m = l + r >> 1;
|
||
new_node(x, str[m]);
|
||
if (l < m) { build(str, ch[x][0], l, m - 1); }
|
||
if (r > m) { build(str, ch[x][1], m + 1, r); }
|
||
push_up(x);
|
||
}
|
||
void insert(int k, char str[]) {
|
||
int x, y, z;
|
||
build(str, x, 0, strlen(str) - 1);
|
||
split(root[vs], k, y, z);
|
||
merge(y, y, x);
|
||
merge(root[++vs], y, z);
|
||
}
|
||
void erase(int k, int sz) {
|
||
int x, y, z;
|
||
split(root[vs], k - 1, x, y);
|
||
split(y, sz, y, z);
|
||
merge(root[++vs], x, z);
|
||
}
|
||
void output(int x) {
|
||
if (ch[x][0]) { output(ch[x][0]); }
|
||
putchar(key[x]);
|
||
d += key[x] == 'c';
|
||
if (ch[x][1]) { output(ch[x][1]); }
|
||
}
|
||
void output(int v, int k, int sz) {
|
||
int x, y, z;
|
||
split(root[v], k - 1, x, y);
|
||
split(y, sz, y, z);
|
||
output(y);
|
||
putchar('\n');
|
||
}
|
||
} treap;
|
||
//UVa12538
|
||
int main() {
|
||
int n, op, p, c, v;
|
||
char s[105];
|
||
treap.init();
|
||
vs = d = 0;
|
||
scanf("%d", &n);
|
||
while (n--) {
|
||
scanf("%d", &op);
|
||
switch (op) {
|
||
case 1:
|
||
scanf("%d%s", &p, s);
|
||
treap.insert(p - d, s);
|
||
break;
|
||
case 2:
|
||
scanf("%d%d", &p, &c);
|
||
treap.erase(p - d, c - d);
|
||
break;
|
||
case 3:
|
||
scanf("%d%d%d", &v, &p, &c);
|
||
treap.output(v - d, p - d, c - d);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
//树链剖分
|
||
//轻重链剖分将一棵树划分成至多logn条重链和若干条轻边, 满足每个节点属于一条重链,
|
||
//从而将树上路径修改转化为至多logn次线性修改, 非常利于套用树状数组、线段树等各类数据结构.
|
||
//树链剖分的常数很小, 且因着树链剖分的性质, 我们发现越是退化的树(极端情况下成为一条链),
|
||
//树链剖分的效果越是好(极端情况下甚至是O(1)级的, 因为只有很少的重链),
|
||
//以至于一些不涉及形态修改的树上路径维护题目, 可以用树链剖分套线段树以O(logn^2)的单次操作复杂度水过,
|
||
//且实际表现不输于单次操作O(logn)但常数很大的LCT.
|
||
//常见轻重链剖分的初始化实现是两次dfs的, 但dfs有两个问题,
|
||
//一是递归调用使得时间稍慢, 二是有些题目有爆栈风险; 所以我抄了bfs实现的很好用的交大板.
|
||
//需要稍作说明的是, 对于点权修改直接维护即可, 对于边权修改, 常规做法是选定一个根,
|
||
//将边权下垂到深度更大的节点上; 换言之, 每个点储存的权值是它与它的父节点之间的边权, 根节点上没有权值.
|
||
int top[N]; //top[p]表示编号为p的路径的顶端节点
|
||
int len[N]; //len[p]表示路径p的长度
|
||
int belong[N]; //belong[v]表示节点v所属的路径编号
|
||
int idx[N]; //idx[v]表示节点v在其路径中的编号, 按深度由深到浅依次标号
|
||
int dep[N]; //dep[v]表示节点v的深度
|
||
int fa[N]; //fa[v]表示节点v的父亲节点
|
||
int size[N]; //size[v]表示以节点v为根的子树的节点个数
|
||
int que[N];
|
||
bool vis[N];
|
||
int n, cnt; //n是点数, 标号从1到n
|
||
void split() {
|
||
memset(dep, 0xff, sizeof(dep));
|
||
int l = 0, r = 0;
|
||
que[++r] = 1; dep[1] = 0; fa[1] = -1;
|
||
while (l < r) {
|
||
int u = que[++l];
|
||
vis[u] = false;
|
||
for (int i = g.head[u]; ~i; i = g.next[i]) {
|
||
int v = g.to[i];
|
||
if (!~dep[v]) { que[++r] = v; dep[v] = dep[u] + 1; fa[v] = u; }
|
||
}
|
||
}
|
||
cnt = 0;
|
||
for (int i = n; i > 0; --i) {
|
||
int u = que[i], p = -1;
|
||
size[u] = 1;
|
||
for (int j = g.head[u]; ~j; j = g.next[j]) {
|
||
int v = g.to[j];
|
||
if (vis[v]) {
|
||
size[u] += size[v];
|
||
if (!~p || size[v] > size[p]) { p = v; }
|
||
}
|
||
}
|
||
if (!~p) {
|
||
idx[u] = len[++cnt] = 1;
|
||
belong[u] = cnt;
|
||
top[cnt] = u;
|
||
} else {
|
||
belong[u] = belong[p];
|
||
idx[u] = ++len[belong[u]];
|
||
top[belong[u]] = u;
|
||
}
|
||
vis[u] = true;
|
||
}
|
||
}
|
||
int fi[N], cid[N], rank[N];
|
||
void getcid() {
|
||
fi[1] = 1;
|
||
for (int i = 2; i <= cnt; ++i) { fi[i] = fi[i - 1] + len[i - 1]; }
|
||
for (int i = 1; i <= n; ++i) {
|
||
cid[i] = fi[belong[i]] + len[belong[i]] - idx[i];
|
||
rank[cid[i]] = i;
|
||
}
|
||
}
|
||
// 路径修改和查询依下面修改
|
||
int query(int x, int y) {
|
||
int ret = 0;
|
||
while (belong[x] != belong[y]) {
|
||
if (dep[top[belong[x]]] < dep[top[belong[y]]]) { swap(x, y); }
|
||
ret = max(ret, query(cid[top[belong[x]]], cid[x], 1, n, 1));
|
||
x = fa[top[belong[x]]];
|
||
}
|
||
if (dep[x] > dep[y]) { swap(x, y); }
|
||
ret = max(ret, query(cid[x], cid[y], 1, n, 1));
|
||
/*边权如下
|
||
if(x!=y)
|
||
ret=max(ret,query(cid[x]+1,cid[y],1,n,1));
|
||
*/
|
||
return ret;
|
||
}
|
||
//第一次dfs和倍增LCA的dfs部分几乎一致; 所以稍作修改就可以无缝衔接LCA.
|
||
//第二次dfs对节点的新位置进行了标号(对应bfs的getcid函数),
|
||
//我们可以发现无论它以怎样的顺序进行dfs(先dfs重儿子再dfs其它子节点), 得到的依旧是这棵树的一个dfs序.
|
||
//换句话说, 这里处理出的剖分标号, 同时也是dfs序标号.
|
||
//我们知道每棵子树的节点在dfs序中都是连续的一段,
|
||
//这样我们就可以同时维护树上路径信息(剖分部分复杂度O(logn))和子树信息(剖分部分复杂度O(1))了.
|
||
//BZOJ3083 树链剖分套线段树
|
||
const int N = 100005;
|
||
const int maxd = 18;
|
||
const int INF = 0x7fffffff;
|
||
struct graph {
|
||
int head[N], tot;
|
||
int to[N << 1], next[N << 1];
|
||
void init() {
|
||
tot = 0; memset(head, 0xff, sizeof(head));
|
||
}
|
||
void add(int u, int v) {
|
||
to[tot] = v; next[tot] = head[u]; head[u] = tot++;
|
||
}
|
||
} g;
|
||
int top[N], son[N];
|
||
int dep[N], fa[N][maxd], size[N];
|
||
int cid[N], rank[N], cnt;
|
||
void dfs1(int u) {
|
||
size[u] = 1; son[u] = -1;
|
||
for (int i = 1; i < maxd; ++i) { fa[u][i] = fa[fa[u][i - 1]][i - 1]; }
|
||
for (int i = g.head[u]; ~i; i = g.next[i]) {
|
||
int v = g.to[i];
|
||
if (v != fa[u][0]) {
|
||
dep[v] = dep[u] + 1; fa[v][0] = u;
|
||
dfs1(v);
|
||
size[u] += size[v];
|
||
if (!~son[u] || size[v] > size[son[u]]) { son[u] = v; }
|
||
}
|
||
}
|
||
}
|
||
void dfs2(int u, int tp) {
|
||
top[u] = tp; cid[u] = ++cnt; rank[cid[u]] = u;
|
||
if (~son[u]) { dfs2(son[u], tp); }
|
||
for (int i = g.head[u]; ~i; i = g.next[i]) {
|
||
int v = g.to[i];
|
||
if (v != son[u] && v != fa[u][0]) { dfs2(v, v); }
|
||
}
|
||
}
|
||
void split() {
|
||
dfs1(1); cnt = 0; dfs2(1, 1);
|
||
}
|
||
int lca(int u, int v) {
|
||
if (dep[u] < dep[v]) { swap(u, v); }
|
||
int k = dep[u] - dep[v];
|
||
for (int i = 0; i < maxd; ++i) {
|
||
if ((1 << i)&k) { u = fa[u][i]; }
|
||
}
|
||
if (u == v) { return u; }
|
||
for (int i = maxd - 1; i >= 0; --i) {
|
||
if (fa[u][i] != fa[v][i]) { u = fa[u][i]; v = fa[v][i]; }
|
||
}
|
||
return fa[u][0];
|
||
}
|
||
int n, root, a[N];
|
||
#define lson l,m,rt<<1
|
||
#define rson m+1,r,rt<<1|1
|
||
int vmin[N << 2], col[N << 2];
|
||
void push_up(int rt) {
|
||
vmin[rt] = min(vmin[rt << 1], vmin[rt << 1 | 1]);
|
||
}
|
||
void push_down(int rt) {
|
||
if (col[rt]) {
|
||
col[rt << 1] = col[rt << 1 | 1] = vmin[rt << 1] = vmin[rt << 1 | 1] = col[rt];
|
||
col[rt] = 0;
|
||
}
|
||
}
|
||
void build(int l, int r, int rt) {
|
||
col[rt] = 0;
|
||
if (l == r) { vmin[rt] = a[rank[l]]; return; }
|
||
int m = l + r >> 1;
|
||
build(lson);
|
||
build(rson);
|
||
push_up(rt);
|
||
}
|
||
void update(int L, int R, int val, int l, int r, int rt) {
|
||
if (L <= l && r <= R) { col[rt] = vmin[rt] = val; return; }
|
||
push_down(rt);
|
||
int m = l + r >> 1;
|
||
if (L <= m) { update(L, R, val, lson); }
|
||
if (m < R) { update(L, R, val, rson); }
|
||
push_up(rt);
|
||
}
|
||
int query(int L, int R, int l, int r, int rt) {
|
||
if (L <= l && r <= R) { return vmin[rt]; }
|
||
push_down(rt);
|
||
int m = l + r >> 1;
|
||
int ret = INF;
|
||
if (L <= m) { ret = min(ret, query(L, R, lson)); }
|
||
if (m < R) { ret = min(ret, query(L, R, rson)); }
|
||
return ret;
|
||
}
|
||
void modify(int x, int y, int d) {
|
||
while (top[x] != top[y]) {
|
||
if (dep[top[x]] < dep[top[y]]) { swap(x, y); }
|
||
update(cid[top[x]], cid[x], d, 1, n, 1);
|
||
x = fa[top[x]][0];
|
||
}
|
||
if (dep[x] > dep[y]) { swap(x, y); }
|
||
update(cid[x], cid[y], d, 1, n, 1);
|
||
}
|
||
int query(int rt) {
|
||
if (rt == root) { return query(1, n, 1, n, 1); }
|
||
int pre = lca(root, rt);
|
||
if (pre != rt) { return query(cid[rt], cid[rt] + size[rt] - 1, 1, n, 1); }
|
||
int depth = dep[root] - dep[rt] - 1, tmp = root;
|
||
for (int i = maxd - 1; i >= 0; --i) {
|
||
if (depth & (1 << i)) { tmp = fa[tmp][i]; }
|
||
}
|
||
return min(query(1, cid[tmp] - 1, 1, n, 1), query(cid[tmp] + size[tmp], n, 1, n, 1));
|
||
}
|
||
int main() {
|
||
int m, u, v, opt, id;
|
||
while (~scanf("%d%d", &n, &m)) {
|
||
g.init();
|
||
for (int i = 1; i < n; ++i) {
|
||
scanf("%d%d", &u, &v);
|
||
g.add(u, v); g.add(v, u);
|
||
}
|
||
for (int i = 1; i <= n; ++i) {
|
||
scanf("%d", &a[i]);
|
||
}
|
||
split();
|
||
build(1, n, 1);
|
||
scanf("%d", &root);
|
||
while (m--) {
|
||
scanf("%d", &opt);
|
||
switch (opt) {
|
||
case 1: scanf("%d", &root); break;
|
||
case 2: scanf("%d%d%d", &u, &v, &id); modify(u, v, id); break;
|
||
case 3: scanf("%d", &id); printf("%d\n", query(id)); break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//KD-Tree
|
||
//用来维护多维第K近点对距离一类的信息.
|
||
//在每一维上依次用一个超平面进行空间划分, 将点集比较均匀地分割在各个区域内,
|
||
//结构上则是一棵二叉树, 且与线段树的形态和构造方法都有些类似.
|
||
//经过改造的KD-Tree一般可以做到O(logn)的单点插入, 以及O(n^(1-1/D))的询问操作, 其中D是维数, 可见维数越大KD-Tree越慢
|
||
//询问距离一个点的前K近点一般需要用一个优先队列进行询问时的维护
|
||
//HDU4347 O(n) 不支持点的插入和删除
|
||
const int N = 50005;
|
||
const int INF = ~0U >> 1;
|
||
const int DIM = 5;
|
||
#define lson l,m-1,dep+1
|
||
#define rson m+1,r,dep+1
|
||
int cur, K;
|
||
struct point {
|
||
int x[DIM];
|
||
bool operator<(const point &oth)const { return x[cur] < oth.x[cur]; }
|
||
void output() {
|
||
for (int i = 0; i < K; ++i) {
|
||
printf("%d%c", x[i], i < K - 1 ? ' ' : '\n');
|
||
}
|
||
}
|
||
} vec[N], origin[N], pt, ans[10];
|
||
inline int sqr(int x) { return x * x; }
|
||
int dist(const point &a, const point &b) {
|
||
int ret = 0;
|
||
for (int i = 0; i < K; ++i) { ret += sqr(a.x[i] - b.x[i]); }
|
||
return ret;
|
||
}
|
||
void build(int l, int r, int dep = 0) {
|
||
if (l >= r) { return; }
|
||
int m = l + r >> 1;
|
||
cur = dep % K;
|
||
nth_element(vec + l, vec + m, vec + r + 1);
|
||
build(lson);
|
||
build(rson);
|
||
}
|
||
priority_queue<pair<int, point>> pq;
|
||
void query(const point &x, int k, int l, int r, int dep = 0) {
|
||
if (l > r) { return; }
|
||
int m = l + r >> 1, cur = dep % K;
|
||
pair<int, point> tmp(dist(x, vec[m]), vec[m]);
|
||
if (pq.size() < k) {
|
||
pq.push(tmp);
|
||
} else if (pq.top().first > tmp.first) {
|
||
pq.pop(); pq.push(tmp);
|
||
}
|
||
if (x.x[cur] < vec[m].x[cur]) {
|
||
query(x, k, lson);
|
||
if (pq.top().first > sqr(x.x[cur] - vec[m].x[cur])) { query(x, k, rson); }
|
||
} else {
|
||
query(x, k, rson);
|
||
if (pq.top().first > sqr(x.x[cur] - vec[m].x[cur])) { query(x, k, lson); }
|
||
}
|
||
}
|
||
int main() {
|
||
int n, t, m;
|
||
while (~scanf("%d%d", &n, &K)) {
|
||
for (int i = 1; i <= n; ++i) {
|
||
for (int j = 0; j < K; ++j) {
|
||
scanf("%d", &origin[i].x[j]);
|
||
}
|
||
vec[i] = origin[i];
|
||
}
|
||
build(1, n);
|
||
scanf("%d", &t);
|
||
while (t--) {
|
||
for (int i = 0; i < K; ++i) {
|
||
scanf("%d", &pt.x[i]);
|
||
}
|
||
scanf("%d", &m);
|
||
query(pt, m, 1, n);
|
||
for (int i = 0; i < m; ++i) {
|
||
ans[i] = pq.top().second; pq.pop();
|
||
}
|
||
printf("the closest %d points are:\n", m);
|
||
for (int i = m - 1; i >= 0; --i) { ans[i].output(); }
|
||
}
|
||
}
|
||
}
|
||
//支持点的插入和删除
|
||
#define lson kdt[rt].ls,dep+1
|
||
#define rson kdt[rt].rs,dep+1
|
||
struct kdnode {
|
||
int ls, rs, x[DIM]; bool flag; //删点标记
|
||
} kdt[N];
|
||
inline ll sqr(int x) { return (ll)x * x; }
|
||
ll dist(const kdnode &a, const kdnode &b) {
|
||
ll ret = 0;
|
||
for (int i = 0; i < DIM; ++i) { ret += sqr(a.x[i] - b.x[i]); }
|
||
return ret;
|
||
}
|
||
int root, tot;
|
||
void init() { tot = 0; root = -1; }
|
||
int add(int pt[]) {
|
||
kdt[tot].flag = false;
|
||
kdt[tot].ls = kdt[tot].rs = -1;
|
||
for (int i = 0; i < DIM; ++i) { kdt[tot].x[i] = pt[i]; }
|
||
return tot++;
|
||
}
|
||
void insert(int pt[], int rt, int dep = 0) {
|
||
dep %= DIM;
|
||
if (pt[dep] < kdt[rt].x[dep]) {
|
||
if (!~kdt[rt].ls) { kdt[rt].ls = add(pt); }
|
||
else { insert(pt, lson); }
|
||
} else {
|
||
if (!~kdt[rt].rs) { kdt[rt].rs = add(pt); }
|
||
else { insert(pt, rson); }
|
||
}
|
||
}
|
||
//求最近点距离
|
||
ll query(const kdnode &pt, int rt, int dep = 0) {
|
||
if (!~rt) { return INF; }
|
||
dep %= DIM;
|
||
ll ret = INF, tmp = sqr(kdt[rt].x[dep] - pt.x[dep]);
|
||
if (!kdt[rt].flag) { ret = dist(kdt[rt], pt); }
|
||
if (pt.x[dep] <= kdt[rt].x[dep]) {
|
||
ret = min(ret, query(pt, lson));
|
||
if (tmp < ret) { ret = min(ret, query(pt, rson)); }
|
||
}
|
||
if (pt.x[dep] >= kdt[rt].x[dep]) {
|
||
ret = min(ret, query(pt, rson));
|
||
if (tmp < ret) { ret = min(ret, query(pt, lson)); }
|
||
}
|
||
return ret;
|
||
}
|
||
//查询区间内有多少个点
|
||
int query(int pt1[], int pt2[], int rt, int dep = 0) {
|
||
if (!~rt) { return 0; }
|
||
dep %= DIM;
|
||
int ret = 0, cur;
|
||
for (cur = 0; cur < DIM; ++cur) {
|
||
if (kdt[rt].x[cur] < pt1[cur] || kdt[rt].x[cur] > pt2[cur]) { break; }
|
||
}
|
||
if (cur == DIM) { ++ret; }
|
||
if (pt2[dep] < kdt[rt].x[dep]) {
|
||
ret += query(pt1, pt2, lson);
|
||
} else if (pt1[dep] >= kdt[rt].x[dep]) {
|
||
ret += query(pt1, pt2, rson);
|
||
} else {
|
||
ret += query(pt1, pt2, lson);
|
||
ret += query(pt1, pt2, rson);
|
||
}
|
||
return ret;
|
||
}
|
||
//划分树
|
||
int part[20][N]; //表示每层每个位置的值
|
||
int sorted[N]; //已经排序好的数
|
||
int tol[20][N]; //tol[p][i] 表示第i层从1到i有数分入左边
|
||
void build(int l, int r, int dep) {
|
||
if (l == r) { return; }
|
||
int m = l + r >> 1, cnt = m - l + 1; //表示等于中间值而且被分入左边的个数
|
||
for (int i = l; i <= r; ++i) {
|
||
if (part[dep][i] < sorted[m]) { --cnt; }
|
||
}
|
||
int lpos = l, rpos = m + 1;
|
||
for (int i = l; i <= r; ++i) {
|
||
if (part[dep][i] < sorted[m]) {
|
||
part[dep + 1][lpos++] = part[dep][i];
|
||
} else if (part[dep][i] == sorted[m] && cnt > 0) {
|
||
part[dep + 1][lpos++] = part[dep][i];
|
||
--cnt;
|
||
} else {
|
||
part[dep + 1][rpos++] = part[dep][i];
|
||
}
|
||
tol[dep][i] = tol[dep][l - 1] + lpos - l;
|
||
}
|
||
build(l, m, dep + 1);
|
||
build(m + 1, r, dep + 1);
|
||
}
|
||
//离线查询区间第k大的数, [L, R]是要查询的小区间, [l, r]是大区间
|
||
int query(int L, int R, int k, int l, int r, int dep) {
|
||
if (L == R) { return part[dep][L]; }
|
||
int m = l + r >> 1, cnt = tol[dep][R] - tol[dep][L - 1];
|
||
if (cnt >= k) {
|
||
int tl = l + tol[dep][L - 1] - tol[dep][l - 1], tr = tl + cnt - 1;
|
||
return query(tl, tr, k, l, m, dep + 1);
|
||
} else {
|
||
int tr = R + tol[dep][r] - tol[dep][R], tl = tr - (R - L - cnt);
|
||
return query(tl, tr, k - cnt, m + 1, r, dep + 1);
|
||
}
|
||
}
|
||
//左偏树
|
||
//可并堆的一种实现, 可以在O(logn)的时间内实现堆的push、pop和两个堆的合并操作, 以及O(1)时间的取堆顶操作
|
||
int val[N], ls[N], rs[N], dep[N], fa[N];
|
||
void init(int n) {
|
||
for (int i = 1; i <= n; ++i) {
|
||
scanf("%d", &val[i]); ls[i] = rs[i] = dep[i] = 0; fa[i] = i;
|
||
}
|
||
}
|
||
int find(int x) { return x == fa[x] ? x : fa[x] = findfa(fa[x]); }
|
||
int merge(int x, int y) {
|
||
if (!x || !y) { return x | y; }
|
||
if (val[x] < val[y]) { swap(x, y); }
|
||
rs[x] = merge(rs[x], y); fa[rs[x]] = x;
|
||
if (dep[ls[x]] < dep[rs[x]]) { swap(ls[x], rs[x]); }
|
||
dep[x] = dep[rs[x]] + 1;
|
||
return x;
|
||
}
|
||
int push(int x, int y) { return merge(x, y); }
|
||
int pop(int x) {
|
||
int a = ls[x], b = rs[x];
|
||
ls[x] = rs[x] = dep[x] = 0;
|
||
fa[x] = x; fa[a] = a; fa[b] = b;
|
||
return merge(a, b);
|
||
}
|
||
//POJ 2201
|
||
int main() {
|
||
int n, m, x, y;
|
||
while (~scanf("%d", &n)) {
|
||
init(n);
|
||
scanf("%d", &m);
|
||
while (m--) {
|
||
scanf("%d%d", &x, &y);
|
||
int a = find(x), b = find(y);
|
||
if (a == b) {
|
||
puts("-1");
|
||
} else {
|
||
val[a] >>= 1; val[b] >>= 1;
|
||
a = push(pop(a), a); b = push(pop(b), b);
|
||
printf("%d\n", val[merge(a, b)]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//笛卡尔树
|
||
//考虑一个键值对的序列, 当键与键, 值与值之间互不相同时, 它们可以唯一地构成这样一棵二叉树：
|
||
//key在中序遍历时呈升序, 满足二叉查找树性质; 父节点的value大于子节点的value, 满足堆的性质.
|
||
//一个键值对序列的笛卡儿树可以O(n)时间内构造出来
|
||
//POJ2201
|
||
const int N = 50005;
|
||
int idx[N], n;
|
||
struct Cartesian_Tree {
|
||
int root, key[N], val[N], ch[N][2], pre[N];
|
||
void init() {
|
||
for (int i = 1; i <= n; ++i) {
|
||
scanf("%d%d", &key[i], &val[i]);
|
||
ch[i][0] = ch[i][1] = pre[i] = 0;
|
||
}
|
||
}
|
||
void build() {
|
||
static int st[N];
|
||
int top = -1;
|
||
for (int i = 1; i <= n; ++i) {
|
||
int k = top;
|
||
while (k >= 0 && val[st[k]] > val[idx[i]]) {
|
||
--k;
|
||
}
|
||
if (~k) {
|
||
pre[idx[i]] = st[k];
|
||
ch[st[k]][1] = idx[i];
|
||
}
|
||
if (k < top) {
|
||
pre[st[k + 1]] = idx[i];
|
||
ch[idx[i]][0] = st[k + 1];
|
||
}
|
||
st[++k] = idx[i];
|
||
top = k;
|
||
}
|
||
root = st[0];
|
||
}
|
||
} ct;
|
||
bool cmp(int x, int y) {
|
||
return ct.key[x] < ct.key[y];
|
||
}
|
||
int main() {
|
||
while (~scanf("%d", &n)) {
|
||
ct.init();
|
||
for (int i = 1; i <= n; ++i) { idx[i] = i; }
|
||
sort(idx + 1, idx + n + 1, cmp);
|
||
ct.build();
|
||
puts("YES");
|
||
for (int i = 1; i <= n; ++i) {
|
||
printf("%d %d %d\n", ct.pre[i], ct.ch[i][0], ct.ch[i][1]);
|
||
}
|
||
}
|
||
}
|