BZOJ 1146: [CTSC2008]网络管理Network( 树链剖分 + 树状数组套主席树 )

树链剖分完就成了一道主席树裸题了, 每次树链剖分找出相应区间然后用BIT+(可持久化)权值线段树就可以完成计数. 但是空间问题很严重....在修改时不必要的就不要新建, 直接修改原来的..详见代码. 时间复杂度O(N*log^3(N))

----------------------------------------------------------------------------

#include<cstdio>

#include<cstring>

#include<cctype>

#include<iostream>

#include<algorithm>

 

using namespace std;

 

#define h(v) (lower_bound(H, H + n, v) - H + 1)

 

const int maxn = 80009;

 

inline int read() {

char c = getchar();

for(; !isdigit(c); c = getchar());

int ret = 0;

for(; isdigit(c); c = getchar())

ret = ret * 10 + c - '0';

return ret;

}

 

int N, Q, w[maxn], seq[maxn], H[maxn << 1], n;

int top[maxn], fa[maxn], sz[maxn], ch[maxn], dep[maxn], Top;

int Id[maxn], Idn;

 

struct edge {

int to;

edge* next;

} E[maxn << 1], *Pt = E, *head[maxn];

 

inline void AddEdge(int u, int v) {

Pt->to = v;

Pt->next = head[u];

head[u] = Pt++;

}

 

struct O {

int t, a, b;

inline void Read() {

t = read(), a = read() - 1, b = read();

if(t) b--;

}

} o[maxn];

 

void Init() {

N = read(), Q = read();

for(n = 0; n < N; n++)

H[n] = w[n] = read();

for(int i = 1; i < N; i++) {

int u = read() - 1, v = read() - 1;

AddEdge(u, v);

AddEdge(v, u);

}

for(int i = 0; i < Q; i++) {

o[i].Read();

if(!o[i].t)

H[n++] = o[i].b;

}

sort(H, H + n);

n = unique(H, H + n) - H;

}

 

struct Node {

Node *lc, *rc;

int v;

Node() : v(0) {

}

} pool[5000000], *pt, *Null, *Root[maxn], *V[maxn];

 

void Init_sgt() {

pt = pool;

Null = pt++;

Null->lc = Null->rc = Null;

Null->v = 0;

}

 

int Pos, Val;

 

Node* Modify(Node* t, int l, int r) {

if(t->v + Val == 0)

return Null;

if(t->v == Val) { 

if(l == r) return t;

int m = (l + r) >> 1;

if(Pos <= m) {

t->lc = Modify(t->lc, l, m);

t->rc = Null;

} else {

t->lc = Null;

t->rc = Modify(t->rc, m + 1, r);

}

return t;

} else {

Node* o = pt++;

o->v = t->v + Val;

int m = (l + r) >> 1;

if(Pos <= m) {

o->lc = Modify(t->lc, l, m);

o->rc = t->rc;

} else {

o->lc = t->lc;

o->rc = Modify(t->rc, m + 1, r);

}

return o;

}

}

 

Node* Add(Node* t, int l, int r) {

Node* o = pt++;

o->v = t->v + Val;

if(l != r) {

int m = (l + r) >> 1;

if(Pos <= m) {

o->lc = Add(t->lc, l, m);

o->rc = t->rc;

} else {

o->lc = t->lc;

o->rc = Add(t->rc, m + 1, r);

}

}

return o;

}

 

void DFS(int x) {

sz[x] = 1;

ch[x] = -1;

for(edge* e = head[x]; e; e = e->next) if(e->to != fa[x]) {

dep[e->to] = dep[x] + 1;

fa[e->to] = x;

DFS(e->to);

sz[x] += sz[e->to];

if(ch[x] == -1 || sz[ch[x]] < sz[e->to])

ch[x] = e->to;

}

}

 

void dfs(int x) {

seq[Id[x] = ++Idn] = x;

top[x] = Top;

if(~ch[x]) dfs(ch[x]);

for(edge* e = head[x]; e; e = e->next)

if(e->to != fa[x] && e->to != ch[x]) dfs(Top = e->to);

}

 

void Init_slpf() {

fa[0] = -1;

dep[0] = 0;

DFS(0);

Idn = 0;

dfs(0);

}

 

void Build() {

Init_sgt();

Root[0] = V[0] = Null;

Val = 1;

for(int i = 1; i <= N; i++) {

Pos = h(w[seq[i]]);

Root[i] = Add(Root[i - 1], 1, n);

V[i] = Null;

}

}

 

Node *L[500], *R[500];

 

void Work() {

int Ln, Rn;

for(int i = 0; i < Q; i++) {

if(o[i].t) {

int x = o[i].a, y = o[i].b, size = 0;

Ln = Rn = 0;

for(; top[x] != top[y]; x = fa[top[x]]) {

if(dep[top[x]] < dep[top[y]]) swap(x, y);

size += dep[x] - dep[top[x]] + 1;

L[Ln++] = Root[Id[top[x]] - 1];

R[Rn++] = Root[Id[x]];

for(int l = Id[top[x]] - 1; l; l -= l & -l)

L[Ln++] = V[l];

for(int r = Id[x]; r; r -= r & -r)

R[Rn++] = V[r];

}

if(dep[x] > dep[y]) swap(x, y);

size += dep[y] - dep[x] + 1;

L[Ln++] = Root[Id[x] - 1];

R[Rn++] = Root[Id[y]];

for(int l = Id[x] - 1; l; l -= l & -l)

L[Ln++] = V[l];

for(int r = Id[y]; r; r -= r & -r)

R[Rn++] = V[r];

if(size < o[i].t) {

puts("invalid request!");

continue;

} else 

o[i].t = size - o[i].t + 1;

int l = 1, r = n;

while(l < r) {

int m = (l + r) >> 1, cnt = 0;

for(int j = 0; j < Ln; j++)

cnt -= L[j]->lc->v;

for(int j = 0; j < Rn; j++)

cnt += R[j]->lc->v;

if(cnt >= o[i].t) {

for(int j = 0; j < Ln; j++)

L[j] = L[j]->lc;

for(int j = 0; j < Rn; j++)

R[j] = R[j]->lc;

r = m;

} else {

o[i].t -= cnt;

for(int j = 0; j < Ln; j++)

L[j] = L[j]->rc;

for(int j = 0; j < Rn; j++)

R[j] = R[j]->rc;

l = m + 1;

}

}

printf("%d\n", H[l - 1]);

} else {

Pos = h(w[seq[Id[o[i].a]]]), Val = -1;

for(int x = Id[o[i].a]; x <= N; x += x & -x)

V[x] = Add(V[x], 1, n);

Pos = h(w[seq[Id[o[i].a]]] = o[i].b), Val = 1;

for(int x = Id[o[i].a]; x <= N; x += x & -x)

V[x] = Add(V[x], 1, n);

}

}

}

 

int main() {

Init();

Init_slpf();

Build();

Work();

return 0;

}

----------------------------------------------------------------------------

1146: [CTSC2008]网络管理Network

Time Limit: 50 Sec  Memory Limit: 162 MB
Submit: 2943  Solved: 859
[Submit][Status][Discuss]

Description

M公司是一个非常庞大的跨国公司，在许多国家都设有它的下属分支机构或部门。为了让分布在世界各地的N个部门之间协同工作，公司搭建了一个连接整个公司的通信网络。该网络的结构由N个路由器和N-1条高速光缆组成。每个部门都有一个专属的路由器，部门局域网内的所有机器都联向这个路由器，然后再通过这个通信子网与其他部门进行通信联络。该网络结构保证网络中的任意两个路由器之间都存在一条直接或间接路径以进行通信。 高速光缆的数据传输速度非常快，以至于利用光缆传输的延迟时间可以忽略。但是由于路由器老化，在这些路由器上进行数据交换会带来很大的延迟。而两个路由器之间的通信延迟时间则与这两个路由器通信路径上所有路由器中最大的交换延迟时间有关。作为M公司网络部门的一名实习员工，现在要求你编写一个简单的程序来监视公司的网络状况。该程序能够随时更新网络状况的变化信息（路由器数据交换延迟时间的变化），并且根据询问给出两个路由器通信路径上延迟第k大的路由器的延迟时间。【任务】 你的程序从输入文件中读入N个路由器和N-1条光缆的连接信息，每个路由器初始的数据交换延迟时间Ti，以及Q条询问（或状态改变）的信息。并依次处理这Q条询问信息，它们可能是： 1. 由于更新了设备，或者设备出现新的故障，使得某个路由器的数据交换延迟时间发生了变化。 2. 查询某两个路由器a和b之间的路径上延迟第k大的路由器的延迟时间。

Input

第一行为两个整数N和Q，分别表示路由器总数和询问的总数。第二行有N个整数，第i个数表示编号为i的路由器初始的数据延迟时间Ti。紧接着N-1行，每行包含两个整数x和y。表示有一条光缆连接路由器x和路由器y。紧接着是Q行，每行三个整数k、a、b。如果k=0，则表示路由器a的状态发生了变化，它的数据交换延迟时间由Ta变为b。如果k>0，则表示询问a到b的路径上所经过的所有路由器（包括a和b）中延迟第k大的路由器的延迟时间。注意a可以等于b，此时路径上只有一个路由器。

Output

对于每一个第二种询问（k>0），输出一行。包含一个整数为相应的延迟时间。如果路径上的路由器不足k个，则输出信息“invalid request!”（全部小写不包含引号，两个单词之间有一个空格）。

Sample Input

5 5
5 1 2 3 4
3 1
2 1
4 3
5 3
2 4 5
0 1 2
2 2 3
2 1 4
3 3 5

Sample Output

3
2
2
invalid request!

HINT

10% 测试数据满足N<=8000,Q<=3000,

40% 测试数据满足所有询问中1<=K<=5 。即路由器的延迟时间不会发生变化。

100% 测试数据满足N,Q<=80000,任意一个路由器在任何时刻都满足延迟时间小于10^8。对于所有询问满足0<=K<=N 。

Source