SPOJ 375 (树链剖分+线段树)

 “在一棵树上进行路径的修改、求极值、求和”乍一看只要线段树就能轻松解决,实际上,仅凭线段树是不能搞定它的。我们需要用到一种貌似高级的复杂算法——树链剖分。

    树链,就是树上的路径。剖分,就是把路径分类为重链轻链
    记siz[v]表示以v为根的子树的节点数,dep[v]表示v的深度(根深度为1),top[v]表示v所在的重链的顶端节点,fa[v]表示v的父亲,son[v]表示与v在同一重链上的v的儿子节点(姑且称为重儿子),w[v]表示v与其父亲节点的连边(姑且称为v的父边)在线段树中的位置。只要把这些东西求出来,就能用logn的时间完成原问题中的操作。

    重儿子:siz[u]为v的子节点中siz值最大的,那么u就是v的重儿子。
    轻儿子:v的其它子节点。
    重边:点v与其重儿子的连边。
    轻边:点v与其轻儿子的连边。
    重链:由重边连成的路径。
    轻链:轻边。

    剖分后的树有如下性质:
    性质1:如果(v,u)为轻边,则siz[u] * 2 < siz[v];
    性质2:从根到某一点的路径上轻链、重链的个数都不大于logn。
   

    算法实现:
    我们可以用两个dfs来求出fa、dep、siz、son、top、w。
    dfs_1:把fa、dep、siz、son求出来,比较简单,略过。
    dfs_2:⒈对于v,当son[v]存在(即v不是叶子节点)时,显然有top[son[v]] = top[v]。线段树中,v的重边应当在v的父边的后面,记w[son[v]] = totw+1,totw表示最后加入的一条边在线段树中的位置。此时,为了使一条重链各边在线段树中连续分布,应当进行dfs_2(son[v]);
           ⒉对于v的各个轻儿子u,显然有top[u] = u,并且w[u] = totw+1,进行dfs_2过程。
           这就求出了top和w。
    将树中各边的权值在线段树中更新,建链和建线段树的过程就完成了。

    修改操作:例如将u到v的路径上每条边的权值都加上某值x。
    一般人需要先求LCA,然后慢慢修改u、v到公共祖先的边。而高手就不需要了。
    记f1 = top[u],f2 = top[v]。
    当f1 <> f2时:不妨设dep[f1] >= dep[f2],那么就更新u到f1的父边的权值(logn),并使u = fa[f1]。
    当f1 = f2时:u与v在同一条重链上,若u与v不是同一点,就更新u到v路径上的边的权值(logn),否则修改完成;
    重复上述过程,直到修改完成。

    求和、求极值操作:类似修改操作,但是不更新边权,而是对其求和、求极值。
    就这样,原问题就解决了。鉴于鄙人语言表达能力有限,咱画图来看看:树链剖分

    如右图所示,较粗的为重边,较细的为轻边。节点编号旁边有个红色点的表明该节点是其所在链的顶端节点。边旁的蓝色数字表示该边在线段树中的位置。图中1-4-9-13-14为一条重链。

    当要修改11到10的路径时。
    第一次迭代:u = 11,v = 10,f1 = 2,f2 = 10。此时dep[f1] < dep[f2],因此修改线段树中的5号点,v = 4, f2 = 1;
    第二次迭代:dep[f1] > dep[f2],修改线段树中10--11号点。u = 2,f1 = 2;
    第三次迭代:dep[f1] > dep[f2],修改线段树中9号点。u = 1,f1 = 1;
    第四次迭代:f1 = f2且u = v,修改结束。

**数据规模大时,递归可能会爆栈,而非递归dfs会很麻烦,所以可将两个dfs改为宽搜+循环。即先宽搜求出fa、dep,然后逆序循环求出siz、son,再顺序循环求出top和w。

 



    题目:spoj375、USACO December Contest Gold Divison, "grassplant"。
    **spoj375据说不“缩行”情况下最短的程序是140+行,我的是128行。

    附spoj375程序(C++):

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <string.h>
using namespace std;
const int maxn = 10010;
struct Tedge
{ int b, next; } e[maxn * 2];
int tree[maxn];
int zzz, n, z, edge, root, a, b, c;
int d[maxn][3];
int first[maxn], dep[maxn], w[maxn], fa[maxn], top[maxn], son[maxn], siz[maxn];
char ch[10];

void insert(int a, int b, int c)
{
     e[++edge].b = b;
     e[edge].next = first[a];
     first[a] = edge;
}

void dfs(int v)
{
     siz[v] = 1; son[v] = 0;
     for (int i = first[v]; i > 0; i = e[i].next)
         if (e[i].b != fa[v])
         {
             fa[e[i].b] = v;
             dep[e[i].b] = dep[v]+1;
             dfs(e[i].b);
             if (siz[e[i].b] > siz[son[v]]) son[v] = e[i].b;
             siz[v] += siz[e[i].b];
         }
}

void build_tree(int v, int tp)
{
     w[v] = ++ z; top[v] = tp;
     if (son[v] != 0) build_tree(son[v], top[v]);
     for (int i = first[v]; i > 0; i = e[i].next)
         if (e[i].b != son[v] && e[i].b != fa[v])
             build_tree(e[i].b, e[i].b);
}

void update(int root, int lo, int hi, int loc, int x)
{
     if (loc > hi || lo > loc) return;
     if (lo == hi)
     { tree[root] = x; return; }
     int mid = (lo + hi) / 2, ls = root * 2, rs = ls + 1;
     update(ls, lo, mid, loc, x);
     update(rs, mid+1, hi, loc, x);
     tree[root] = max(tree[ls], tree[rs]);
}

int maxi(int root, int lo, int hi, int l, int r)
{
     if (l > hi || r < lo) return 0;
     if (l <= lo && hi <= r) return tree[root];
     int mid = (lo + hi) / 2, ls = root * 2, rs = ls + 1;
     return max(maxi(ls, lo, mid, l, r), maxi(rs, mid+1, hi, l, r));
}

inline int find(int va, int vb)
{
     int f1 = top[va], f2 = top[vb], tmp = 0;
     while (f1 != f2)
     {
           if (dep[f1] < dep[f2])
           { swap(f1, f2); swap(va, vb); }
           tmp = max(tmp, maxi(1, 1, z, w[f1], w[va]));
           va = fa[f1]; f1 = top[va];
     }
     if (va == vb) return tmp;
     if (dep[va] > dep[vb]) swap(va, vb);
     return max(tmp, maxi(1, 1, z, w[son[va]], w[vb]));  //
}

void init()
{
     scanf("%d", &n);
     root = (n + 1) / 2;
     fa[root] = z = dep[root] = edge = 0;
     memset(siz, 0, sizeof(siz));
     memset(first, 0, sizeof(first));
     memset(tree, 0, sizeof(tree));
     for (int i = 1; i < n; i++)
     {
         scanf("%d%d%d", &a, &b, &c);
         d[i][0] = a; d[i][1] = b; d[i][2] = c;
         insert(a, b, c);
         insert(b, a, c);
     }
     dfs(root);
     build_tree(root, root);    //
     for (int i = 1; i < n; i++)
     {
         if (dep[d[i][0]] > dep[d[i][1]]) swap(d[i][0], d[i][1]);
         update(1, 1, z, w[d[i][1]], d[i][2]);
     }
}

inline void read()
{
     ch[0] = ' ';
     while (ch[0] < 'C' || ch[0] > 'Q') scanf("%s", &ch);
}

void work()
{
     for (read(); ch[0] != 'D'; read())
     {
         scanf("%d%d", &a, &b);
         if (ch[0] == 'Q') printf("%d\n", find(a, b));
                      else update(1, 1, z, w[d[a][1]], b);
     }
}

int main()
{
    for (scanf("%d", &zzz); zzz > 0; zzz--)
    {
        init();
        work();
    }
    return 0;
}


 

SPOJ 375 (树链剖分+线段树)

分类: 数据结构 字典树-线段树-划分树   82人阅读  评论(0)  收藏  举报

题意:一棵包含N 个结点的树,每条边都有一个权值,要求模拟两种操作:(1)改变某条边的权值,(2)询问U,V 之间的路径中权值最大的边。

思路:最近比赛总是看到有树链剖分的题目,就看了论文,做了这题,思路论文上讲的很清楚了,好长时间没写线段树了,错了好几遍。对树进行轻重边路径剖分。对于询问操作,我们可以分别处理两个点到其最近公共祖先的路径。路径可以分解成最多O(log N)条轻边和O(log N)条重路径,那么只需考虑如何维护这两种对象。对于轻边,我们直接处理即可。而对于重路径,我们只需用线段树来维护。




[cpp]  view plain copy
  1. #include<stdio.h>  
  2. #include <iostream>  
  3. #include <string.h>  
  4. using namespace std;  
  5. const int N=210000;  
  6. const int inf=0x3fffffff;  
  7. int son[N],father[N],sz[N],head[N],num,ti[N],idx,dep[N],top[N];  
  8. struct edge  
  9. {  
  10.     int ed,next;  
  11. }e[N*3];  
  12. struct Edge  
  13. {  
  14.     int x,y,w;  
  15. }E[N*2];  
  16. int max(int a,int b)  
  17. {  
  18.     if(a>b)return a;  
  19.     return b;  
  20. }  
  21. void addedge(int x,int y)  
  22. {  
  23.     e[num].ed=y;e[num].next=head[x];head[x]=num++;  
  24.     e[num].ed=x;e[num].next=head[y];head[y]=num++;  
  25. }  
  26. //****************************树链部分***********************  
  27. //siz[u]u的子节点个数  
  28. //top[u]u所在链顶点  
  29. //father[u]表示u的父节点  
  30. //son[u]与u在同重链上的儿子节点  
  31. //ti[u]表示u与其父亲节点的连边,在线段树中的位置  
  32. void dfs_find(int u,int fa)  
  33. {  
  34.     int i,v;  
  35.     sz[u]=1;dep[u]=dep[fa]+1;son[u]=0;father[u]=fa;  
  36.     for(i=head[u];i!=-1;i=e[i].next)  
  37.     {  
  38.         v=e[i].ed;  
  39.         if(v==fa)continue;  
  40.         dfs_find(v,u);  
  41.         sz[u]+=sz[v];  
  42.         if(sz[son[u]]<sz[v])son[u]=v;  
  43.     }  
  44. }  
  45. void dfs_time(int u,int fa)  
  46. {  
  47.     int i,v;  
  48.     ti[u]=idx++;  
  49.     top[u]=fa;  
  50.     if(son[u]!=0)dfs_time(son[u],top[u]);  
  51.     for(i=head[u];i!=-1;i=e[i].next)  
  52.     {  
  53.         v=e[i].ed;  
  54.         if(v==father[u]||v==son[u])continue;  
  55.         dfs_time(e[i].ed,e[i].ed);//该链的顶点就是该点  
  56.     }  
  57. }  
  58. //***************************线段树部分*************************  
  59. struct tree  
  60. {  
  61.     int L,R,w;  
  62. }T[N<<2];  
  63. void buildTree(int L,int R,int id)  
  64. {  
  65.     T[id].L=L;T[id].R=R;T[id].w=-inf;  
  66.     if(L==R) return;       
  67.     int mid=(L+R)>>1;  
  68.     buildTree(L,mid,id*2);  
  69.     buildTree(mid+1,R,id*2+1);  
  70. }  
  71. void update(int id,int cp,int w)  
  72. {  
  73.     if(T[id].L==T[id].R)  
  74.     {T[id].w=w;return;}  
  75.     int mid=(T[id].L+T[id].R)>>1;  
  76.     if(mid>=cp)update(id*2,cp,w);  
  77.     else update(id*2+1,cp,w);  
  78.     T[id].w=max(T[id*2].w,T[id*2+1].w);  
  79. }  
  80. int query(int L,int R,int id)  
  81. {  
  82.     if(T[id].R==R&&T[id].L==L)  
  83.         return T[id].w;  
  84.     int mid=(T[id].R+T[id].L)>>1;  
  85.     if(mid>=R)return query(L,R,id*2);  
  86.     else if(mid<L)return query(L,R,id*2+1);  
  87.     else    return max(query(L,mid,id*2),query(mid+1,R,id*2+1));  
  88. }  
  89. int lca(int x,int y)  
  90. {  
  91.     int ans=-inf;  
  92.     while(top[x]!=top[y])  
  93.     {  
  94.         if(dep[top[x]]<dep[top[y]])swap(x,y);  
  95.         ans=max(ans,query(ti[top[x]],ti[x],1));//x到所在链的顶点所有边的最大值  
  96.         x=father[top[x]];//x所在链的顶点的父节点,转到另一条链上  
  97.     }  
  98.     if(dep[x]>dep[y])swap(x,y);  
  99.     if(x!=y)  
  100.         ans=max(ans,query(ti[x]+1,ti[y],1));//ti[x]指的是x与其父亲的边,所以+1  
  101.     return ans;  
  102. }  
  103. int main()  
  104. {  
  105.     int i,n,t,x,y,w;  
  106.     char str[100];  
  107.     scanf("%d",&t);  
  108.     while(t--)  
  109.     {  
  110.         memset(head,-1,sizeof(head));  
  111.         num=0;  
  112.         scanf("%d",&n);  
  113.         for(i=1;i<n;i++)  
  114.         {  
  115.             scanf("%d%d%d",&E[i].x,&E[i].y,&E[i].w);  
  116.             addedge(E[i].x,E[i].y);  
  117.         }  
  118.         dep[1]=0;sz[0]=0;idx=1;  
  119.         dfs_find(1,1);  
  120.         dfs_time(1,1);  
  121.         buildTree(2,n,1);  
  122.         for(i=1;i<n;i++)  
  123.         {  
  124.             if(dep[E[i].x]<dep[E[i].y])  
  125.                 swap(E[i].x,E[i].y);  
  126.             update(1,ti[E[i].x],E[i].w);  
  127.         }  
  128.         while(true)  
  129.         {  
  130.             scanf("%s",str);  
  131.             if(str[0]=='D')break;  
  132.             else if(str[0]=='Q')  
  133.             {  
  134.                 scanf("%d%d",&x,&y);  
  135.                 printf("%d\n",lca(x,y));  
  136.             }  
  137.             else if(str[0]=='C')  
  138.             {  
  139.                 scanf("%d%d",&i,&w);  
  140.                 update(1,ti[E[i].x],w);  
  141.             }  
  142.         }  
  143.         printf("\n");  
  144.     }  
  145.     return 0;  
  146. }  

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值