树链剖分理解&&poj 3237
树链剖分用一句话概括就是：把一棵树剖分为若干条链，然后利用数据结构(树状数组，SBT，Splay，线段树等等)去维护每一
条链，复杂度为O(logn)
假如 一个树就是一条链的话（极限的想想），我们可以用数据结构（线段树，树桩数组）去维护它。
下图 1-6就是一个链树，用树状数组维护
这个性质很好，维护很方便
然后再画个树，咱们强行用树状数组维护
可以发现，树状数组在3节点后产生了增殖，且1-3节点的树状数组里的值 与 （5，7,9）、（4,6,8,10）是共有的。也就是说树根的值
（映射到树状数组中）影响它的子树。
用树状数组强行维护显然是难办的。因为树状数组对标号的要求是连续。
这个感觉暂且保留。
不要着急，来看看这个。
先上个图
咱们先按搜索序来遍历一下，并在搜索过程中进行标号
节点 : 1 2 5 10 6 11 12 3 7 4 8 13 14 9
标号 ：1 2 3 4 5 6 7 8 9 10 11 12 13 14
可以发现：（1）父节点总是比它的子孙节点的标号小（因为搜索先对的当前节点标号，继续搜索当前节点的子树是，标号只增不减）
（2）任意树的子孙节点标号区间是连续的（如树根为2的子树）
等等，揪得马得。通过搜索序标号处理，就把每个子树划分成了一个标号连续的区间。 连续，就可以用树状数组进行区间维护了。
假设已经用树状数组强行维护了
从两个方面考虑：
（1）更新：一个点u的值更新了，我们要修改的区间就是[p[u],p[u]+size[u]] （说明下，p[u]表示点u的搜索标号，size[u]表示根为u的树的节点个数。
之前提过，树根的值影响它的子树，那么映射到树状数组里，就是节点标号连续的区间）。这个需要好好体会下。
（2）查找 假如我们要查找从1到11这条链。对应要整合的树状数组的区间就是[1,2]+[5,6]。可以发现查找的区间是几段区间整合起来的。那么查找的次数=树状数组的查询运算次数*
查找一条链需要整合区间的数量 :log(n)*? 。
其实到这里，我们已经解决了用数据结构维护树的问题。但是查找一条链需要整合区间的数量并不确定。
因为这个受搜索序的影响，那么我们就要找到一种搜索序，使平均下来的
查找一条链需要整合区间的数量尽可能小。
这个时候就引入树链剖分的原理了。
耐心点看看。
那么，树链剖分的第一步当然是对树进行轻重边的划分。
定义size(x)为以x为根的子树节点个数，令v为u的儿子中size值最大的节点，那么(u,v)就是重边，其余边为轻边。
当然，剖分过程分为两次dfs，或者bfs也可以。
如果是两次dfs，那么第一次dfs就是找重边，也就是记录下所有的重边。
然后第二次dfs就是连接重边形成重链，具体过程就是：以根节点为起点，沿着重边向下拓展，拉成重链，不在当前重链上的节
点，都以该节点为起点向下重新拉一条重链。
剖分完毕后，每条重链相当于一段区间，然后用数据结构去维护，把所有重链首尾相接，放到数据结构上，然后维护整体（耐心，这句不理解继续往下看）。
在这里，当然有很多数组，现在我来分别介绍它们的作用：
siz[]数组，用来保存以x为根的子树节点个数
top[]数组，用来保存当前节点的所在链的顶端节点
son[]数组，用来保存重儿子
dep[]数组，用来保存当前节点的深度
fa[]数组，用来保存当前节点的父亲
tid[]数组，用来保存树中每个节点剖分后的新编号
rank[]数组，用来保存当前节点在线段树中的位置
那么，我们现在可以根据描述给出剖分的代码：
第一次dfs：记录所有的重边
void dfs1(int u,int father,int d)
{
dep[u]=d;
fa[u]=father;
siz[u]=1;
for(int i=head[u];~i;i=next[i])
{
int v=to[i];
if(v!=father)
{
dfs1(v,u,d+1);
siz[u]+=siz[v];
if(son[u]==-1||siz[v]>siz[son[u]])
son[u]=v;
}
}
}
第二次dfs：连重边成重链，重儿子优先进行搜索（也就是说重边链接的树优先编号）。
void dfs2(int u,int tp)
{
top[u]=tp;
tid[u]=++tim;
rank[tid[u]]=u;
if(son[u]==-1) return;
dfs2(son[u],tp);
for(int i=head[u];~i;i=next[i])
{
int v=to[i];
if(v!=son[u]&&v!=fa[u])
dfs2(v,v);
}
}
可以发现重链上的标号，TMD居然是连续的。也就是说每条重链就对应的就是一段连续的区间。
当然，关于这个它有两个重要的性质：
(1)轻边(u,v)中，size(v)<=size(u/2)
(2)从根到某一点的路径上，不超过logn条轻边和不超过logn条重路径。
每条重链上标号是连续的，轻边链接的两个节点标号绝对不连续。由性质（2），能推出，每次查找一条链需要整合区间的数量不超过log(n)
那么总的查找效率就(log(n))^2.
引用博客：http://www.2cto.com/kf/201308/240268.html
理解完了，那就来A道题：poj 3237 Tree
Tree
| Time Limit: 5000MS | Memory Limit: 131072K | |
| Total Submissions: 6981 | Accepted: 1913 |
Description
You are given a tree with N nodes. The tree’s nodes are numbered 1 through N and its edges are numbered 1 through N − 1. Each edge is associated with a weight. Then you are to execute a series of instructions on the tree. The instructions can be one of the following forms:
CHANGE i v |
Change the weight of the ith edge to v |
NEGATE a b |
Negate the weight of every edge on the path from a to b |
QUERY a b |
Find the maximum weight of edges on the path from a to b |
Input
The input contains multiple test cases. The first line of input contains an integer t (t ≤ 20), the number of test cases. Then follow the test cases.
Each test case is preceded by an empty line. The first nonempty line of its contains N (N ≤ 10,000). The next N − 1 lines each contains three integers a, b and c, describing an edge connecting nodes a and b with weight c. The edges are numbered in the order they appear in the input. Below them are the instructions, each sticking to the specification above. A lines with the word “DONE” ends the test case.
Output
For each “QUERY” instruction, output the result on a separate line.
Sample Input
1 3 1 2 1 2 3 2 QUERY 1 2 CHANGE 1 3 QUERY 1 2 DONE
Sample Output
1 3
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <vector>
#define INF 0x3f3f3f3f
#define MAX_N 10010
#define find_max(a,b) a>b?a:b
#define find_min(a,b) a>b?b:a
using namespace std;
int n;
struct edge{
int next;
int val;
};
struct num_edge{
int u,v,p;
};
int num=0;//编号变量
int start;//在线段树中的起始
int size[MAX_N];//用来保存以x为根的子树节点个数
int top[MAX_N];//用来保存当前节点的所在链的顶端节点
int son[MAX_N];//用来保存重儿子
int depth[MAX_N];//用来保存当前节点的重链的深度
int fa[MAX_N];//用来保存当前节点的父亲
int tid[MAX_N];//用来保存树中每个节点剖分后的新编号
int rank[MAX_N];//用来保存线段树中各位置对应的节点
int dat[4*MAX_N];//区间最大值线段树数组
int val[MAX_N];//用来保存该点到父亲的边权值
vector<edge> g[MAX_N];//存储节点的边
vector<num_edge> list;//按输入顺序存储边
void dat_change(int,int);
int get_count()
{//对树节点的个数取对数，小数点进位
int count=0;
int t=n;
while(t)
{
t/=2;
++count;
}
return count;
}
void init()
{//初始化
num=0;//标号置0
list.clear();//清空编号
for(int i=0;i<=n;++i)
{//清空边
g[i].clear();
son[i]=-1;
}
start=(1<<get_count())-1;//线段树用
for(int i=0;i<=start*2+1;++i)//把线段树的数组元素置为负无穷
dat[i]=-INF;
}
void add_edge(int u,int v,int p)
{//添边
g[u].push_back((edge){v,p});
g[v].push_back((edge){u,p});
}
void first_dfs(int u,int father)
{//第一深搜，确定每个节点的：重儿子、父亲、值
fa[u]=father;
size[u]=1;
for(int i=0;i<g[u].size();++i)
{
int v=g[u][i].next;
if(v!=father)
{
val[v]=g[u][i].val;
first_dfs(v,u);
size[u]+=size[v];
if(son[u]==-1||size[v]>size[son[u]])//son记录重儿子
son[u]=v;
}
}
}
void second_dfs(int u,int _top)
{//第二次深搜，确定每个节点的：重链顶部、标号、反标号、深度
top[u]=_top;
tid[u]=++num;
dat_change(u,val[u]);
rank[tid[u]]=u;
if(son[u]==-1)
return;
depth[son[u]]=depth[u];
second_dfs(son[u],_top);//优先搜索重儿子
for(int i=0;i<g[u].size();++i)
{//其后再搜索轻儿子
int v=g[u][i].next;
if(v!=son[u]&&v!=fa[u])
{
depth[v]=depth[u]+1;
second_dfs(v,v);
}
}
}
int get_lca(int a,int b)
{//寻找从a到b路径的LCA
int u=depth[a]>=depth[b]?a:b;
int v=depth[a]>=depth[b]?b:a;
while(depth[u]>depth[v])//深度齐平
u=fa[top[u]];
//上溯至同一重链
while(top[u]!=top[v])
{
u=fa[top[u]];
v=fa[top[v]];
}
//在同一重链中，标号是连续的，且标号小的为祖先，所以标号小的肯定为LCA
int lca=tid[u]>tid[v]?v:u;
return lca;
}
void dat_change(int a,int b)
{//线段树上的更新
int ndat=start+tid[a];
dat[ndat]=b;
while(ndat>0)
{
ndat/=2;
dat[ndat]=find_max(dat[ndat*2],dat[ndat*2+1]);
}
}
void change(int i,int val)
{//修改编号为i的边的值
int u=list[i-1].u;
int v=list[i-1].v;
if(fa[u]==v)
dat_change(u,val);
else dat_change(v,val);
list[i-1].p=val;
}
void negate(int a,int b)
{//对a到b路径上的边的值变反并更新
int lca=get_lca(a,b);
while(a!=lca)
{
dat_change(a,-1*dat[start+tid[a]]);
a=fa[a];
}
while(b!=lca)
{
dat_change(b,-1*dat[start+tid[b]]);
b=fa[b];
}
//change(lca,-1*dat[start+tid[lca]]);
}
int dat_query(int a,int b,int l,int r,int k)
{//线段树上的查询
// printf("a:%d b:%d l:%d r:%d k:%d\n",a,b,l,r,k);
//在查询区间外
if(r<a||b<l)
return -INF;
//在查询区间内
if(a<=l&&r<=b)
return dat[k];
else
{//与查询区间有交集
int vl=dat_query(a,b,l,(l+r)/2,2*k);
int vr=dat_query(a,b,(l+r)/2+1,r,2*k+1);
return find_max(vl,vr);
}
}
int query(int a,int b)
{
int res=-INF;
int lca=get_lca(a,b);
// printf("lca:%d\n", lca);
// printf("1\n");
while(top[a]!=top[lca])
{
res=find_max(res,dat_query(tid[top[a]],tid[a],1,start+1,1));
// printf("tid: %d - %d\n", tid[top[a]],tid[a]);
// printf("#tree: %d - %d\n", top[a],a);
a=fa[top[a]];
}
// printf("2\n");
while(top[b]!=top[lca])
{
res=find_max(res,dat_query(tid[top[b]],tid[b],1,start+1,1));
// printf("tid: %d - %d\n", tid[top[b]],tid[b]);
// printf("#tree: %d - %d\n", top[b],b);
b=fa[top[b]];
}
int u=tid[a]>tid[b]?b:a;
int v=tid[a]>tid[b]?a:b;
// printf("3 # u:%d v:%d\n",u,v);
if(u!=v)
{
u=son[u];
res=find_max(res,dat_query(tid[u],tid[v],1,start+1,1));
//printf("tid: %d - %d\n", tid[u],tid[v]);
// printf("#tree: %d - %d\n", u,v);
}
return res;
}
void solve()
{
int root=1;
//进行树链剖分
first_dfs(root,-1);
second_dfs(root,root);
// printf("start:%d \n",start);
// for(int i=1;i<=n;++i)
// {
// printf("size[%d]:%d ",i,size[i] );
// printf("top[%d]:%d ",i, top[i]);
// printf("son[%d]:%d ",i, son[i]);
// printf("fa[%d]:%d ", i,fa[i]);
// printf("tid[%d]:%d ", i,tid[i]);
// printf("val[%d]:%d ", i,val[i]);
// printf("\n");
// }
// for(int i=1;i<=2*start+1;++i)
// printf(" i:%d %d \n",i,dat[i]);
//处理改、查
char str[10];
char choice[4][10]={"QUERY","NEGATE","CHANGE","DONE"};
int a,b;
scanf("%s",str);
while(strcmp(str,choice[3]))
{
scanf("%d %d",&a,&b);
if(!strcmp(str,choice[0]))
printf("%d\n",query(a,b));
else if(!strcmp(str,choice[1]))
negate(a,b);
else if(!strcmp(str,choice[2]))
change(a,b);
scanf("%s",str);
}
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
init();
int u,v,p;
for(int i=0;i<n-1;++i)
{
scanf("%d %d %d",&u,&v,&p);
list.push_back((num_edge){u,v,p});
add_edge(u,v,p);
}
solve();
}
return 0;
}
/*
100
14
1 2 3
1 3 4
1 4 5
2 5 3
2 6 4
3 7 5
4 8 2
4 9 10
5 10 7
6 11 4
6 12 4
8 13 20
13 14 13
*/