hdu5296（倍增lca）

对于这道题，虽然题中有个求最小值，但它不是需要进行选择边的那种题，如果给定确定的点，把这些点连到一起，使得任意两点可达，那么只有一种方法（当然，去除掉多余的边，即叶子节点和根节点都必须在集合中）。所以可以每次加边时，只要找到一种方法，把它加入到已有树中就可以了，并且只有一种方法（当然，还是要去掉多余的边）。

至于根据dfs序找，假设要加入x这个点：

1)集合中有dfs序大于x的，并且也有小于x的，假设dfs序大于x的那个点是x的子节点，根据公式，可以的出，花费为0，余现实情况相符。

2）同1)中找出的两个点，只不过dfs序大于x的那个点不是x的子节点，那么此时必然离x最近的某个祖先节点虽然没在集合中，但是也己经在那个前几步生成的树当中，此时，只要把x到这个祖父节点的距离找出来，就是最小花费。根据公式所求，符合现实情况。

3)如果集合中不同时存在dfs序大于x的，和dfs序小于x的，假设，选出的此时集合中dfs序最大和最小的点，都是x的子节点，根据公式所求，符合现实要求。

4)选点同3，只是选出的两个点都是dfs序小于x的，那么如果此时这两个点的最近公共祖先是x的祖先节点，按照公式所求，符合现实要求，如果不是，按照公式所求，符合现实要求。

5)选点同3，只是选出的两个点都是dfs序大于x的，并且都不是x的子节点，同4

6)选点同3，只是选出的两个点都是dfs序大于x的，一个是x的子节点，一个不是x的子节点，按照公式所求，符合现实要求。

至于那道题，怎么正着推出这道题的解，现在只能把它当做一个结论来记了。

假设节点要连接到一个链中，链的定点(x,y)，那么u连接到x的距离是dfn[u] + dfn[x] - 2dfn[ lca(u,x) ] ;

u连接到y的距离dfn[u] + dfn[y] - 2dfn[ lca(u,x) ] :

x连接到y的距离dfn[x] + dfn[y] - 2dfn[ lca(x,y) ] :

u连接到x-y这个链的距离 = (u到y+u到x-x到y)/2

迭代器讲解链接：http://www.cnblogs.com/yc_sunniwell/archive/2010/06/25/1764934.html

代码参考链接：http://www.bubuko.com/infodetail-988787.html

set的链接：http://baike.baidu.com/link?url=Uxof9XTaQURDJ9H8vSaVz4Cs8SOqee2kHyj37CBr2GrLzj-IqYGI5PGyBonm5C_oRWeBBbBbzfGDdlByuw1owK

用的是倍增lca。

（听说今天学校其余食堂就开门了，一共7个食堂，假期就开了4个，但是关的那三个中偏偏又两个常去的，开的这4个中虽然有两个个平常会去的，但是其中有一个，经常吃的窗口关了，所以这个暑假的食堂好凄惨！

）

2015.8.31:

这道题也是刚做不久，回忆了一下过程，还沥沥在目！

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<set>
using namespace std;
#define N 100010
#define M 20

int deep
,dis
;
int vis
;
int head
,to[2*N],nextedge[2*N],wedge[2*N];
int dfsxv
,dfsxf
;
int fadp
[M];
set<int> s;
set<int>::iterator iter;
int cou;
int time;

void add(int a,int b,int c){
to[cou]=b;nextedge[cou]=head[a];wedge[cou]=c;head[a]=cou++;
}

void dfs(int u,int fa){
dfsxv[u]=++time;
dfsxf[time]=u;

for(int i=head[u];i!=-1;i=nextedge[i]){
int v=to[i];

if(v==fa){
continue;
}
else{
deep[v]=deep[u]+1;
dis[v]=dis[u]+wedge[i];
fadp[v][0]=u;
for(int j=1;(1<<j)<deep[v];j++){
fadp[v][j]=fadp[fadp[v][j-1]][j-1];
}
dfs(v,u);
}
}

return;
}

int lca(int a,int b){
if(deep[a]<deep[b]){
swap(a,b);
}

int tempi;
for(tempi=0;(1<<tempi)<deep[a];tempi++);
tempi--;
for(int i=tempi;i>=0;i--){//使得合理答案永远在(a,a+2*tempi-1)的范围内
if(deep[fadp[a][i]]>=deep[b]){
a=fadp[a][i];
}
}

if(a==b){
return a;
}
for(tempi=0;(1<<tempi)<deep[a];tempi++);
tempi--;
for(int i=tempi;i>=0;i--){//是的合理答案，一直在(a+1,a+2*tempi)的范围内
if(fadp[a][i]!=fadp[b][i]){
a=fadp[a][i];
b=fadp[b][i];
}
}

return fadp[a][0];//尝试：在上面的循环中去掉i=0.->不能去掉i=0
}

int solve(int u){
if(s.size()==0){
return 0;
}
else{
int x,y;
iter=s.lower_bound(dfsxv[u]);
if(iter==s.end()||iter==s.begin()){
x=dfsxf[*s.begin()];//注意*
y=dfsxf[*s.rbegin()];
}
else{
x=dfsxf[*iter];
iter--;
y=dfsxf[*iter];
}
return dis[u]+dis[lca(x,y)]-dis[lca(u,x)]-dis[lca(u,y)];
}
}

int main(){
int t;
int n,q;
int a,b,c;

scanf("%d",&t);
for(int cas=1;cas<=t;cas++){
scanf("%d%d",&n,&q);

memset(head,-1,sizeof(head));
cou=0;
for(int i=1;i<n;i++){
scanf("%d%d%d",&a,&b,&c);
add(a,b,c);
add(b,a,c);
}

memset(fadp,0,sizeof(fadp));//要是0，而不是1
deep[0]=-1;
deep[1]=1;
dis[1]=0;
time=0;
dfs(1,-1);

memset(vis,0,sizeof(vis));
s.clear();//如果用容器什么的，也要考虑清理
int ans=0;
printf("Case #%d:\n",cas);
for(int i=0;i<q;i++){
scanf("%d%d",&a,&b);
if(a==1){
if(!vis[b]){
vis[b]=1;
ans+=solve(b);
s.insert(dfsxv[b]);
}
}
else if(a==2){
if(vis[b]){
vis[b]=0;
s.erase(dfsxv[b]);
ans-=solve(b);
}
}

printf("%d\n",ans);
}
}

return 0;
}