【高级数据结构】[SPOJ QTREE]树链剖分/动态树各一模板

最新推荐文章于 2018-07-04 21:00:32 发布
最新推荐文章于 2018-07-04 21:00:32 发布
阅读量476 收藏
点赞数
分类专栏： 数据结构 图论 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/outer_form/article/details/50128153
版权

题目：
树链剖分：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace  std;
#define MAXN 10024
#define MAXLOG 14
#define INF 0x7fffffff
int n,T,size[MAXN+10],dep[MAXN+10],fa[MAXN+10][MAXLOG+1],wt[MAXN+10]={0,-INF},bl[MAXN+10],length[MAXN+10],id2v[MAXN+10];
int tmax[MAXN*4+10],*ttop,*root[MAXN+10],pos[MAXN+10];
bool f;
struct node{
    int v,wt,pos;
    node *next;
}*adj[MAXN+10],edge[MAXN*2+10],*ecnt;
void addedge(int u,int v,int wt,int pos){
    node *p=++ecnt;
    p->v=v;
    p->wt=wt;
    p->pos=pos;
    p->next=adj[u];
    adj[u]=p;
}
void Read(int &x){
    char c;
    while(c=getchar(),c!=EOF)
        if(c>='0'&&c<='9'){
            x=c-'0';
            while(c=getchar(),c>='0'&&c<='9')
                x=x*10+c-'0';
            ungetc(c,stdin);
            return;
        }
}
void dfs1(int u,int father){
    fa[u][0]=father;
    dep[u]=dep[father]+1;
    size[u]=1;
    for(int i=1;i<=MAXLOG;i++)
        fa[u][i]=fa[fa[u][i-1]][i-1];
    for(node *p=adj[u];p;p=p->next){
        if(p->v!=father){
            id2v[p->pos]=p->v;
            wt[p->v]=p->wt;
            dfs1(p->v,u);
            size[u]+=size[p->v];
        }
    }
}
inline int *NewTree(int len){
    int *ret=ttop;
    ttop+=len*4;
    return ret;
}
void insert(int *tmax,int i,int l,int r,int pos,int wt){
    if(l==r){
        tmax[i]=wt;
        return;
    }
    int mid=(l+r)>>1;
    if(pos<=mid)
        insert(tmax,i<<1,l,mid,pos,wt);
    else
        insert(tmax,(i<<1)+1,mid+1,r,pos,wt);
    tmax[i]=max(tmax[i<<1],tmax[(i<<1)+1]);
}
void dfs2(int u,int len,int father){
    int heavy=0,i;
    for(node *p=adj[u];p;p=p->next)
        if(p->v!=father&&size[p->v]>size[heavy])
            heavy=p->v;
    if(!heavy){
        int tp=u;
        for(i=1;i<len;i++)
            tp=fa[tp][0];
        root[tp]=NewTree(len);
        length[tp]=len;
        for(i=len;i;i--){
            bl[u]=tp;
            pos[u]=i;
            insert(root[tp],1,1,len,i,wt[u]);
            u=fa[u][0];
        }
        return;
    }
    dfs2(heavy,len+1,u);
    for(node *p=adj[u];p;p=p->next){
        if(p->v!=father&&p->v!=heavy)
            dfs2(p->v,1,u);
    }
}
void init(){
    Read(n);
    int i,u,v,wt;
    for(i=1;i<n;i++){
        Read(u),Read(v),Read(wt);
        addedge(u,v,wt,i);
        addedge(v,u,wt,i);
    }
    dfs1(1,0);
    dfs2(1,1,0);
}
int LCA(int a,int b){
    if(dep[a]<dep[b])
        swap(a,b);
    int i;
    for(i=MAXLOG;i>=0;i--)
        if(dep[a]-(1<<i)>=dep[b])
            a=fa[a][i];
    if(a==b)
        return a;
    for(i=MAXLOG;i>=0;i--)
        if(fa[a][i]!=fa[b][i])
            a=fa[a][i],b=fa[b][i];
    return fa[a][0];
}
int find(int *tmax,int i,int l,int r,int ll,int rr){
    if(l>=ll&&r<=rr)
        return tmax[i];
    if(l>rr||r<ll)
        return -INF;
    int mid=(l+r)>>1;
    return max(find(tmax,i<<1,l,mid,ll,rr),find(tmax,(i<<1)+1,mid+1,r,ll,rr));
}
int query(int lca,int a){
    int ret=-INF;
    while(lca!=a){
        if(bl[a]!=bl[lca]){
            ret=max(find(root[bl[a]],1,1,length[bl[a]],1,pos[a]),ret);
            a=fa[bl[a]][0];
        }
        else{
            ret=max(find(root[bl[a]],1,1,length[bl[a]],pos[lca]+1,pos[a]),ret);
            break;
        }
    }
    return ret;
}
void solve(){
    char s[10];
    int lca,a,b;
    while(scanf("%s",s),s[0]!='D'){
        Read(a),Read(b);
        if(s[0]=='Q'){
            lca=LCA(a,b);
            printf("%d\n",max(query(lca,a),query(lca,b)));
        }
        else{
            wt[id2v[a]]=b;
            insert(root[bl[id2v[a]]],1,1,length[bl[id2v[a]]],pos[id2v[a]],b);
        }
    }
}
int main()
{
    Read(T);
    while(T--){
        memset(fa,0,sizeof fa);
        memset(adj,0,sizeof adj);
        memset(tmax,0,sizeof tmax);
        ttop=tmax;
        ecnt=edge;
        init();
        solve();
    }
}

动态树（LCT）：

#include<cstdio>
#include<algorithm>
#include<cstring>
#define MAXN 10000
using namespace std;
int n,e2id[MAXN+10],T;
void Read(int &x){
    char c;
    while(c=getchar(),c!=EOF)
        if(c>='0'&&c<='9'){
            x=c-'0';
            while(c=getchar(),c>='0'&&c<='9')
                x=x*10+c-'0';
            ungetc(c,stdin);
            return;
        }
}
struct node{
    int val,mx,wt;
    node *ch[2],*fa;
    bool pre;
}splay_tree[MAXN+10];
struct nodedge{
    int v,wt,pos;
    nodedge *next;
}edge[MAXN*2+10],*ecnt=edge,*adj[MAXN+10];
inline void addedge(int u,int v,int wt,int pos){
    nodedge *p=++ecnt;
    p->v=v;
    p->wt=wt;
    p->next=adj[u];
    p->pos=pos;
    adj[u]=p;
}
inline void  init(node *p){
    p->ch[0]=p->ch[1]=0;
    p->pre=0;
}
void dfs(int u,int dep,int fa){
    node *x=&splay_tree[u],*y;
    init(x);
    x->val=dep;
    for(nodedge *p=adj[u];p;p=p->next){
        if(p->v!=fa){
            e2id[p->pos]=p->v;
            y=&splay_tree[p->v];
            y->mx=y->wt=p->wt;
            y->fa=x;
            dfs(p->v,dep+1,u);
        }
    }
}
void read(){
    Read(n);
    int u,v,wt,i;
    for(i=1;i<n;i++){
        Read(u),Read(v),Read(wt);
        addedge(u,v,wt,i);
        addedge(v,u,wt,i);
    }
    init(&splay_tree[1]);
    splay_tree[1].fa=0;
    dfs(1,1,0);
}
inline int Get_max(node *p){
    return p?p->mx:0;
}
inline void update(node *p){
    p->mx=max(p->wt,max(Get_max(p->ch[0]),Get_max(p->ch[1])));
}
void Rotate(node *x,int d){
    node *y=x->fa;
    if(y->fa&&y->pre)
        y->fa->ch[y==y->fa->ch[1]]=x;
    x->fa=y->fa;
    if(x->ch[d])
        x->ch[d]->fa=y;
    y->ch[!d]=x->ch[d];
    x->ch[d]=y;
    y->fa=x;
    swap(x->pre,y->pre);
    update(y);
}
void splay(node *x){
    node *y,*z;
    while(x->pre){
        y=x->fa;
        z=y->fa;
        if(!z||!y->pre){
            if(x==y->ch[0])
                Rotate(x,1);
            else
                Rotate(x,0);
        }
        else{
            if(y==z->ch[0])
                if(x==y->ch[0]){
                    Rotate(y,1);
                    Rotate(x,1);
                }
            else{
                Rotate(x,0);
                Rotate(x,1);
            }
            else
                if(x==y->ch[1]){
                    Rotate(y,0);
                    Rotate(x,0);
                }
                else{
                    Rotate(x,1);
                    Rotate(x,0);
                }
        }
    }
    update(x);
}
void access(int a){
    node *x=&splay_tree[a],*y;
    splay(x);
    if(x->ch[1]){
        x->ch[1]->pre=0;
        x->ch[1]=0;
    }
    update(x);
    while(1){
        y=x->fa;
        if(!y)
            return;
        splay(y);
        if(y->ch[1])
            y->ch[1]->pre=0;
        y->ch[1]=x;
        x->pre=1;
        splay(x);
    }
    splay(x);
}
int query(int a){
    node *x=&splay_tree[a],*y;
    int ans;
    splay(x);
    if(!x->fa)
        return Get_max(x->ch[1]);
    if(x->ch[1]){
        x->ch[1]->pre=0;
        x->ch[1]=0;
    }
    update(x);
    while(1){
        y=x->fa;
        splay(y);
        ans=Get_max(y->ch[1]);
        if(y->ch[1])
            y->ch[1]->pre=0;
        y->ch[1]=x;
        x->pre=1;
        if(!y->fa){
            ans=max(ans,Get_max(x));
            splay(x);
            return ans;
        }
        splay(x);
    }
}
void solve(){
    char s[10];
    int a,b;
    while(scanf("%s",s),s[0]!='D')
        if(s[0]=='Q'){
            Read(a),Read(b);
            access(a);
            printf("%d\n",query(b));
        }
        else{
            Read(a),Read(b);
            access(e2id[a]);
            splay_tree[e2id[a]].wt=b;
            update(&splay_tree[e2id[a]]);
        }
}
int main()
{
    Read(T);
    while(T--){
        memset(adj,0,sizeof adj);
        ecnt=edge;
        read();
        solve();
    }
}
outer_form
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
yolo-java:Java代码-数据结构实现以及Codechef和SPOJ问题的解决方案
06-20
yolo-java Java代码-数据结构实现以及Codechef和SPOJ问题的解决方案
SPOJ-Solutions：解决了我解决的http://www.spoj.com问题的解决方案
02-05
SPOJ解决方案 我已解决的SPOJ问题的解决方案。 仅当您自己尝试过该问题并且无法提出任何解决方案，也可以随意报告任何错误并为该存储库提供解决方案时，才请参考这些解决方案。 我的个人资料链接 会费 分叉仓库并为...
【bzoj3589】动态树【树链剖分】【线段树】
2016gdgzoi471
07-04 597
题目链接 题解 首先，第一个操作就是子树加，直接线段树对应dfn序区间加即可。 第二个操作，我写了个奇怪的东西，单次查询大概是两个log的，常数大上天……其实，这个过程类似于线段覆盖。我们可以维护 setv：该区间是否被完全覆盖 tot：该区间被覆盖的个数。 然后我们在线段树上，对着没覆盖完的节点走一遍。先找到查询的区间，然后遇到完全覆盖的节点和叶子节点返回，完全未覆盖的区间更新答案再...
数据结构---各种树模板
xyjikl
12-23 764
1：Trie 字典树 字典树 又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来节约存储空间，最大限度地减少无谓的字符串比较，查询效率比哈希表高。 它有3个基本性质：根节点不包含字符，除根节点外每一个节点都只包含一个字符。 从
SPOJ QTREE 树链剖分 边上剖分
SolarDomo的博客
09-21 375
题目链接：http://bak2.vjudge.net/problem/13013/origin#include <cstdio> #include <cstring> #include <algorithm> #define sf scanf #define pf printf using namespace std;/** Edge */ const int maxn = 10000 + 50;
SPOJ QTree5 [树链剖分]
lemonoil的博客
07-08 560
感觉之前拿点分治水过心里过意不去，。。。。。mdzz，我还是打了一份树链剖分的code，具体方法与QTree4相同（详见代码），维护线段树的合并时的值。#include<bits/stdc++.h> #define mid ((l+r)>>1) #define pf push_front using namespace std; const int N=1e5+1e2; const int INF=
qtree.rar_数据结构_Visual_C++_
08-12
关于SPOJ 中的qtree问题的一类解法和深入思考
SPOJ.rar_SPOJ
09-19
Online Judge Problem solution VN.SPOJ
SPOJ-Solutions:SPOJ算法问题的解决方案
03-13
SPOJ-Solutions:SPOJ算法问题的解决方案
【NOI2016】网格
LiuJunhao's Blog
02-18 1638
题目描述输入输出样例输入 4 4 2 1 1 4 4 2 3 1 1 2 2 2 2 1 1 2 2 1 1 0样例输出 2 1 0 -1分析我们很容易看出答案只有可能是2,1,0,-1。关于一些表述的解释 我们将蝈蝈所在格子称为障碍，其余格子称为空地。 根据题意，我们可以看做最外围也是一圈障碍，但是我们不去管它，一下所提到的障碍都不包括外围的一圈
【LCT维护最大生成树】[HDU5389]GCD Tree
LiuJunhao's Blog
12-17 1187
题目 分析：由于wt(u,v)=gcd(u,v)，所以我们枚举gcd，而且只尝试连接gcd和它的倍数，也就是我们尝试连接(i,j)，仅当j是i的倍数，至于于为什么，我也不知道。 用LCT维护最大生成树，每次连接一条边时，必定形成一个环，删除这个环中最小边即可。#include<cstdio> #include<algorithm> #include<vector> using namespace
【高斯消元】【图论】[Wc2011][HYSBZ/BZOJ2155]Xor
LiuJunhao's Blog
01-31 885
题目大意找1到n的路径中异或和最大的路径。分析首先，我们考虑这样一个问题：先看另一道题N个点M条边的边带权的无向图，求一个回路使XOR和最大(回路中的路径可以走多次)。另一道题的分析有这样一个结论（从这里到证明结束的所说回路只能走一次） 两个回路的和仍是回路(‘和’ 指 ‘异或和’/‘对称差’) 一个无向连通图G中有且仅有M-N+1个独立回路。 那什么是独立的回路呢，就是一个不能由其他的回
【树DP+LCA】[CQBZOJ2937]避难向导
LiuJunhao's Blog
10-11 842
题目描述 “特大新闻，特大新闻！全国爆发了一种极其可怕的病毒，已经开始在各个城市 中传播开来！全国陷入了巨大的危机！大量居民陷入恐慌，想要逃到其它城市以 避难！经调查显示，该病毒来自于C 市的A 学校的一次非法的……” “哎。”你关上电视，叹了口气。作为A 学校的校长，你一天前为了保命，独自 逃离了A 学校，抛弃了全校师生，包括那个曾经帮你计算并拆除道路的工程师。 你良心受到了巨大的谴责，因此决
【树DP】【基环树】[ZJOI2008][HYSBZ/BZOJ1040]骑士
LiuJunhao's Blog
02-05 841
题目链接分析看穿题目如果一个骑士痛恨另一个骑士，就在两个骑士直接连接一条无向边。题目就是要求图中的最大权值独立集。实现方法如果这道题的图是一棵树(或森林)的话，显然可以用树形动态规划解决。 令f(u)f(u)表示以u为根的子树中的最大权值的独立集，令s(u)=∑v是u的儿子vf(v)s(u)=\sum_v^{v是u的儿子} f(v)，gs(u)=∑v是u的孙子vf(v)gs(u)=\sum_v^{
【图论】[CQBZOJ1362] 苗条的生成树
LiuJunhao's Blog
08-26 836
题目描述：点击此处 解题思路： 构造最小生成树，并计算苗条度，然后不断删最短边，构造最小生成树，计算苗条度，直至图不再连通，输出苗条度。 若一开始就不是一棵树，则输出-1；实现代码：#include<cstdio> #include<cstring> #include<algorithm> using namespace std; #include<climits> #define MAXN
【最小生成树】[USACO 2016 February Contest, Gold]Fenced In
LiuJunhao's Blog
03-12 835
题目大意农夫FJ的奶牛们有空旷恐惧症，所以，FJ打算在他的农场围上篱笆。他的农场是一个矩形区域。左上角的坐标是（0,0），右下角的坐标是（A,B），FJ修建了n(0<=n<=2000)个竖直的篱笆，其横坐标分别为a1,a2,a3,……，an，其中0分析可以轻易地看出这道题是要求最小生成树，处理出连通块之间栅栏的长度然后做最小生成树即可。 但是这样会Time Limited Exceed，尽管算法时
【图论】【最小生成树】[IOI2003]maintain
LiuJunhao's Blog
08-26 823
题目描述：点击此处 解题思路： 在加边的同时对边进行插入排序，当边的数量≥n-1时，进行kruskal，此时每次kruscal的复杂度为O（m），算法的时间复杂度为O(m^2)实现代码#include<cstdio> #include<cstring> #define INF 0x7f7f7f7f #define MAXN 200 #define MAXM 6000 #include<algor
【BFS和DFS的性质】[NOI2013]树的计数
LiuJunhao's Blog
07-07 804
题目描述我们知道一棵有根树可以进行深度优先遍历（DFS）以及广度优先遍历（BFS）来生成这棵树的 DFS 序以及 BFS 序。两棵不同的树的 DFS 序有可能相同，并且它们的 BFS 序也有可能相同，例如下面两棵树的 DFS 序都是 1 2 4 5 3，BFS 序都是 1 2 3 4 5。现给定一个 DFS 序和 BFS 序，我们想要知道，符合条件的有根树中，树的高度的平均值。即，假如共有 KK 棵
p1168线段树解法
最新发布
07-28
- *2* *3* [Spoj 375 Qtree 树链剖分 + 线段树 解法](https://blog.csdn.net/niuox/article/details/8145842)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值