Distance on the tree-南昌邀请赛网络赛 【树链剖分】【主席树】【lca】

最新推荐文章于 2019-05-10 21:04:12 发布
最新推荐文章于 2019-05-10 21:04:12 发布
阅读量617 收藏 1
点赞数 1
分类专栏： 树链刨分 主席树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30358129/article/details/89422672
版权

题目链接：https://nanti.jisuanke.com/t/38229

题目大意：

给一颗树，m次查询ui->vi这条链中边权小于等于ki的边数。

做法一：树链剖分+主席树（这里并不需要进行离散化，但是比赛的时候忘了）

#include <bits/stdc++.h>
#define mid (l+r>>1)
#define lson (o<<1)
#define rson (o<<1|1)
#define all(x) (x).begin(),(x).end()
using namespace std;
const int N = 2e5+1000;
vector<int>nxt[N],len[N];
int fa[N],deep[N],id[N],siz[N],son[N],tot,s[N],top[N],ss[N];
int n,m;
int SIZ;

struct TREE{
    int l,r,x;
}tree[N*20];
int rk[N],Tot,rt[N];
void insert(int &o,int l,int r,int data){
    tree[++Tot] = tree[o];
    o = Tot;
    tree[o].x++;
    if(l==r) return ;
    if(mid>=data) insert(tree[o].l,l,mid,data);
    else insert(tree[o].r,mid+1,r,data);
}
int query(int lo,int ro,int l,int r,int h,int t){
    if(l>=h&&r<=t) return tree[ro].x-tree[lo].x;
    int ans = 0;
    if(mid>=h) ans += query(tree[lo].l,tree[ro].l,l,mid,h,t);
    if(mid<t) ans += query(tree[lo].r,tree[ro].r,mid+1,r,h,t);
    return ans;
}

void dfs(int u,int f) {
    deep[u] = deep[f]+1;
    son[u] = 0;
    siz[u] = 1;
    fa[u] = f;
    for(int i = 0; i < nxt[u].size(); i++) {
        int v = nxt[u][i];
        int w = len[u][i];
        if(v==f) continue;
        s[v] = w;
        dfs(v,u);
        siz[u] += siz[v];
        if(siz[son[u]]<siz[v]) son[u] = v;
    }
}
void dfs2(int u,int t) {
    id[u] = ++tot;
    ss[id[u]] = s[u];
    top[u] = t;
    if(son[u]) dfs2(son[u],t);
    for(auto v:nxt[u]) {
        if(v==fa[u]||v==son[u]) continue;
        dfs2(v,v);
    }
}
int Query(int u,int v,int x) {
    int tu = top[u];
    int tv = top[v];
    int ans = 0;
    while(tu!=tv) {
        if(deep[tu]<deep[tv]) {
            swap(u,v);
            swap(tu,tv);
        }
        ans += query(rt[id[tu]-1],rt[id[u]],1,SIZ,1,x);
        u = fa[tu];
        tu = top[u];
    }
    if(u==v) return ans;
    if(id[u]>id[v]) swap(u,v);
    ans += query(rt[id[u]],rt[id[v]],1,SIZ,1,x);
    return ans;
}

struct Q{
    int u, v, w;
}Q[N];
vector<int> k;
int main() {
    scanf("%d%d",&n,&m);
    for(int i = 1; i < n; i++) {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        nxt[u].push_back(v);
        nxt[v].push_back(u);
        len[u].push_back(w);
        len[v].push_back(w);
        k.push_back(w);
    }
    for(int i = 1; i <= m; i++) {
        int u, v, x;
        scanf("%d%d%d",&Q[i].u,&Q[i].v,&Q[i].w);
        k.push_back(Q[i].w);
    }
    sort(all(k));
    k.erase(unique(all(k)),k.end());
    SIZ = k.size()+10;
    dfs(1,0);
    dfs2(1,1);
    rt[0] = 0;
    tree[0].l = tree[0].r = tree[0].x = 0;
    for(int i = 1; i <= n; i++) {
        rt[i] = rt[i-1];
        int x = lower_bound(all(k),ss[i])-k.begin()+1;
        insert(rt[i],1,SIZ,x);
    }
    for(int i = 1; i <= m; i++) {
        int x = lower_bound(all(k),Q[i].w)-k.begin()+1;
        printf("%d\n",Query(Q[i].u,Q[i].v,x));
    }
    return 0;
}

-----------------------------------------------------------------更新线--------------------2019.8.3----------------------------------------------

因为看到评论有人问离散化，所以在这里稍微解释一下为什么这题不需要离散化。

首先我们要清楚主席树的空间复杂度，在一般情况下主席树是一颗可持久化的权值线段树，

假如给一个长度为N的数组，数组元素的大小在[1,MAX]之间，你需要查询 [L,R] 内小于等于K的元素有多少个。

 

显然主席树会执行N次insert操作，最坏情况下每一次insert操作会开辟一条新的链。

我们考虑这条链的长度，如果我们不离散化的话，主席树的根节点所维护的左右端点就是[1,MAX]，这条链延伸log(MAX)的长度就到了叶子节点，因为每向下一层，所维护的区间长度就会减少一半。

主席树的空间复杂度为O(N*log(MAX)）， 单次查询的时间复杂度为O(log(MAX))

 

假如我们进行了离散化，那么离散化后的数值大小将在[1,N]以内，即离散化后MAX = N。

依然按上面的步骤分析复杂度，得主席树的空间复杂度为O(N*log(N)）， 单次查询的时间复杂度为O(log(N))

而在本题中log(N) = log(1e5) <= 20 , log(MAX) = log(1e9) <= 32 , 因为都是log级别所以两者相差不大，所以我们并不需要离散化。

下面附上没有离散化AC的代码

#include <bits/stdc++.h>
#define mid (l+r>>1)
#define lson (o<<1)
#define rson (o<<1|1)
#define all(x) (x).begin(),(x).end()
using namespace std;
const int N = 2e5+1000;
vector<int>nxt[N],len[N];
int fa[N],deep[N],id[N],siz[N],son[N],tot,s[N],top[N],ss[N];
int n,m;
int SIZ;
 
struct TREE{
    int l,r,x;
}tree[N*40];
int rk[N],Tot,rt[N];
void insert(int &o,int l,int r,int data){
    tree[++Tot] = tree[o];
    o = Tot;
    tree[o].x++;
    if(l==r) return ;
    if(mid>=data) insert(tree[o].l,l,mid,data);
    else insert(tree[o].r,mid+1,r,data);
}
int query(int lo,int ro,int l,int r,int h,int t){
    if(l>=h&&r<=t) return tree[ro].x-tree[lo].x;
    int ans = 0;
    if(mid>=h) ans += query(tree[lo].l,tree[ro].l,l,mid,h,t);
    if(mid<t) ans += query(tree[lo].r,tree[ro].r,mid+1,r,h,t);
    return ans;
}
 
void dfs(int u,int f) {
    deep[u] = deep[f]+1;
    son[u] = 0;
    siz[u] = 1;
    fa[u] = f;
    for(int i = 0; i < nxt[u].size(); i++) {
        int v = nxt[u][i];
        int w = len[u][i];
        if(v==f) continue;
        s[v] = w;
        dfs(v,u);
        siz[u] += siz[v];
        if(siz[son[u]]<siz[v]) son[u] = v;
    }
}
void dfs2(int u,int t) {
    id[u] = ++tot;
    ss[id[u]] = s[u];
    top[u] = t;
    if(son[u]) dfs2(son[u],t);
    for(auto v:nxt[u]) {
        if(v==fa[u]||v==son[u]) continue;
        dfs2(v,v);
    }
}
int Query(int u,int v,int x) {
    int tu = top[u];
    int tv = top[v];
    int ans = 0;
    while(tu!=tv) {
        if(deep[tu]<deep[tv]) {
            swap(u,v);
            swap(tu,tv);
        }
        ans += query(rt[id[tu]-1],rt[id[u]],1,SIZ,1,x);
        u = fa[tu];
        tu = top[u];
    }
    if(u==v) return ans;
    if(id[u]>id[v]) swap(u,v);
    ans += query(rt[id[u]],rt[id[v]],1,SIZ,1,x);
    return ans;
}
 
struct Q{
    int u, v, w;
}Q[N];
vector<int> k;
int main() {
    scanf("%d%d",&n,&m);
    for(int i = 1; i < n; i++) {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w); //这里我让权值全部加了1，因为我的旧代码里的左端点是从1开始的，就不再修改了。
        w++;                                       
        nxt[u].push_back(v);
        nxt[v].push_back(u);
        len[u].push_back(w);
        len[v].push_back(w);
    }
    for(int i = 1; i <= m; i++) {
        int u, v, x;
        scanf("%d%d%d",&Q[i].u,&Q[i].v,&Q[i].w);
        Q[i].w++;
    }
    SIZ = 1e9+10;   //右端点直接设为最大值
    dfs(1,0);
    dfs2(1,1);
    rt[0] = 0;
    tree[0].l = tree[0].r = tree[0].x = 0;
    for(int i = 1; i <= n; i++) {
        rt[i] = rt[i-1];
        insert(rt[i],1,SIZ,ss[i]);
    }
    for(int i = 1; i <= m; i++) 
        printf("%d\n",Query(Q[i].u,Q[i].v,Q[i].w));
    return 0;
}

--------------------------------------更新结束线---------------------------------2019.8.3------------------------------------------

做法二：按照dfs顺序在树上直接建主席树

#include <bits/stdc++.h>
#define mid (l+r>>1)
#define lson (o<<1)
#define rson (o<<1|1)
#define all(x) (x).begin(),(x).end()
using namespace std;
const int N = 2e5+1000;
vector<int>nxt[N],len[N],k;
int fa[N][20],deep[N],tot;
int n,m;
int SIZ=1e9;

struct TREE{
    int l,r,x;
}tree[N*20];
int rk[N],Tot,rt[N];
void insert(int &o,int l,int r,int data){
    tree[++Tot] = tree[o];
    o = Tot;
    tree[o].x++;
    if(l==r) return ;
    if(mid>=data) insert(tree[o].l,l,mid,data);
    else insert(tree[o].r,mid+1,r,data);
}
int query(int lo,int ro,int l,int r,int h,int t){
    if(l>=h&&r<=t) return tree[ro].x-tree[lo].x;
    int ans = 0;
    if(mid>=h) ans += query(tree[lo].l,tree[ro].l,l,mid,h,t);
    if(mid<t) ans += query(tree[lo].r,tree[ro].r,mid+1,r,h,t);
    return ans;
}
void dfs(int u, int f, int d) {
    deep[u] = d;
    fa[u][0] = f;
    int siz = nxt[u].size();
    for(int i = 0; i < siz; i++) {
        int v = nxt[u][i];
        int w = len[u][i];
        if(v == f) continue;
        rt[v] = rt[u];
        insert(rt[v],0,SIZ,w);
        dfs(v, u, d+1);
    }
}
void init(int n) {
    for(int j = 1; j <= 19; j++)
        for(int i = 1; i <= n; i++)
            fa[i][j] = fa[fa[i][j-1]][j-1];
}
int lca(int u, int v){
    if(deep[u] < deep[v]) swap(u, v);
    int diff = deep[u] - deep[v];
    for(int i = 19; i >= 0; i--)
        if(diff>>i&1)
            u = fa[u][i];
    if(u == v) return u;
    for(int i = 19; i >= 0; i--)
        if(fa[u][i] != fa[v][i]) {
            u = fa[u][i];
            v = fa[v][i];
        }
    return fa[u][0];
}

int Query(int u,int v,int x) {
    int uv = lca(u,v);
    return query(rt[uv],rt[u],0,SIZ,0,x) + query(rt[uv],rt[v],0,SIZ,0,x);
}
struct Q{
    int u, v, w;
}Q[N];
int main() {
    scanf("%d%d",&n,&m);
    for(int i = 1; i < n; i++) {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        nxt[u].push_back(v);
        nxt[v].push_back(u);
        len[u].push_back(w);
        len[v].push_back(w);
    }
    rt[0] = 0;
    tree[0].l = tree[0].r = tree[0].x = 0;
    dfs(1,0,1);
    init(n);
    for(int i = 1; i <= m; i++) {
        int u, v, x;
        scanf("%d%d%d",&u,&v,&x);
        printf("%d\n",Query(u,v,x));
    }
    return 0;
}

做法三：离线，树链剖分，排序加边，树状数组维护。

lixuwei2333
关注
专栏目录
对LCA、树上倍增、树链剖分（重链剖分&长链剖分）和LCT（Link-Cut Tree）的学习
路人黑的纸巾
10-18 1万+
一篇从浅到深探究一些树上算法的博客
HDU 4718 The LCIS on the Tree (树链剖分 + 线段树区间合并)
每一次AC都是一种感动
08-01 894
题意： 给出一棵树，树上的每个点有权值，m次询问从u到v两点路径上最大的LCIS值是多少 分析： 熟练剖分解决两点路径的移动问题 关键还是在于线段树的区间合并和爬树时的区间方向问题 我是这么处理这个过程的，对于每个区间，记录每个区间的 Lval（左端点值）,Rva（右端点值），LL（以左端点为起点的下降最大LCIS值）,LR（以左端点为起点的上升最大LCIS值）,RL（同上）,RR（同上
南昌邀请赛网络赛K.MORE XOR（数学推导）
FLY_WHITE的博客
04-20 669
南昌邀请赛网络赛K.MORE XOR（数学推导） 题目大意 定义函数f(l,r)f(l,r)f(l,r)为⊕ai(i∈[l,r])⊕a_i(i\in [l,r])⊕ai​(i∈[l,r])，函数g(l,r)g(l,r)g(l,r)为⊕f(x,y)(x,y∈[l,r])⊕f(x,y)(x,y\in [l,r])⊕f(x,y)(x,y∈[l,r])，函数w(l,r)w(l,r)w(l,r)为⊕g(x,...
【2019年ICPC南昌网络赛】Distance on the tree【DFS+线段树合并（可持久化线段树）】
既然弱小，就只顾变强就是了
04-25 417
题目链接 DSM(Data Structure Master) once learned about tree when he was preparing for NOIP(National Olympiad in Informatics in Provinces) in Senior High School. So when in Data Structure Class in College...
南昌网络赛 Distance on the tree 主席树+树上倍增+离散化
还我笑颜
04-20 880
题目链接：https://nanti.jisuanke.com/t/38229 题意：给出一个n个点，有边权的树，求两点路径上边权小于等于k的边的数量 题解：先离散化下，用主席树维护下从上到下的边权，倍增求下LCA，最后查询下即可 #include<bits/stdc++.h> using namespace std; const int N=1e5+10; struct no...
2019南昌邀请赛网络赛 J. Distance on the tree
binarycopycode
04-21 483
最基本的离线询问，然后跑数据结构。 此题因为是求边的数量，但是我的树链剖分模板是给点加值和求和求最大值，于是我们在树上每条边中间加一个点，那么这个点的权值就是边的权值。 对边排序，对询问排序，k从小到大处理询问，每次把当前询问小的边加到线段树的点里面，然后求路径上有多少个满足条件的边就是树链剖分后线段树idx[u]到idx[v]的权值和了。 队友状态不好，丢给我这个只写过一道模板题树链剖分的...
2019 icpc南昌邀请赛网络赛 J - Distance on the tree
c3po
04-21 469
DSM(Data Structure Master) once learned about tree when he was preparing for NOIP(National Olympiad in Informatics in Provinces) in Senior High School. So when in Data Structure Class in College, he i...
NOIP 树链剖分 NOIP 树链剖分
10-30
### NOIP 树链剖分知识点详解 #### 一、树链剖分的相关概念 **剖分目的**：树链剖分的主要目的是为了更高效地处理树状结构上的路径信息维护问题，例如路径上的权值更新或查询等操作。通过树链剖分，可以将这些操作...
第5章 树链剖分 测试数据.rar
12-02
树链剖分是一种高效处理树型结构的算法，尤其在解决与树的边查询和修改有关的问题时，它能提供显著的效率提升。这一技术在信息学奥赛中经常被用到，帮助参赛者快速解决复杂的树形问题。在本章的测试数据中，你将有...
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
2019 ICPC南昌邀请赛比赛 J Distance on the tree(树链剖分上建可持续化线段树)
柳予欣的三味书屋~
04-22 1137
DSM(Data Structure Master) once learned about tree when he was preparing for NOIP(National Olympiad in Informatics in Provinces) in Senior High School. So when in Data Structure Class in College, he i...
2019南昌邀请赛网络赛
兜率工的博客
04-21 643
A. PERFECT NUMBER PROBLEM 这题没什么要说的。 #include<bits/stdc++.h> using namespace std; int main(){ cout<<6<<endl; cout<<28<<endl; cout<<496<<endl...
南昌邀请赛网络赛 J. Distance on the tree （树链剖分+主席树 查询路径边权第k大）
1999
04-21 221
DSM(Data Structure Master) once learned about tree when he was preparing for NOIP(National Olympiad in Informatics in Provinces) in Senior High School. So when in Data Structure Class in College, he i...
南昌邀请赛网络赛 G. tsy's number（莫比乌斯反演+线性筛）
残阳止水
04-26 668
题目链接： tsy's number 题意： 求 (mod ) 思路： 原式 = 设 设 原式 = 设T = id ，将 i 的求和变为 T 的求和： 原式 = ：这个是与的迪利克雷卷积，并且g(x)与f(x)均为积性函数，因此该函数也为积性函数，可通过线性筛O(n)求解。 处理上述积性函数前缀和，对原式前半部分的...
南昌邀请赛网络赛 Distance on the tree (主席树+动态倍增LCA)
满月照亮的路
05-10 171
题目链接:https://nanti.jisuanke.com/t/38229 考研ing,题解比较随意 题目大意 给定一棵树,有边权,每次查询问u,v路径上权值不大于k的个数是多少. 题目分析 主席树,每个点记录是所有祖先节点记录的前缀和,那么对于主席树来讲前后关系就明显了. 再套个动态倍增LCA,就可以做了.详见代码 #include<bits/stdc++...
Distance on the tree（19南昌网络赛）
七九河开的博客
04-22 128
题目 https://nanti.jisuanke.com/t/38229 思路 1 主席树+LCA #include <bits/stdc++.h> using namespace std; const int maxn = 200005; struct edge { int v,w; edge(int _v,int _w) { v...
南昌网络赛-Coloring Game
Lydia_r的博客
04-22 346
题意：2*N网格，从左上走到右下，8个方向可以移动，总共有多少种方法？ 第一列和最后一列：每列有2中可能； 中间列：每列有3中可能； //color game #include <stdio.h> const long long mod=1e9+7; long long QuickPow(long long a,long long n){ long long ...
南昌网络赛 Coloring Game 思维
还我笑颜
04-20 431
题目链接：https://nanti.jisuanke.com/t/38227 题意：2*n的方格，可以走8个方向，从左上走到右下，走的地方变成黑色，问形成的图形的种类有多少 题解：第一列和最后一列有两种选择，剩下的格子要不要，每一列有3中选择，要哪个和都要，结果就是4*3^n-2 #include<bits/stdc++.h> using namespace std; typ...
2019 南昌邀请赛 Distance on the tree
Chalemagne的博客
04-28 166
2019 南昌邀请赛 Distance on the tree 主席树+lca #include <iostream> #include <cstdio> #include <algorithm> #include <cstring> #include <vector> using namespace std; typedef long ...
NOIP树链剖分详解与实现
"NOIP树链剖分是用于优化树形结构数据的处理效率的一种算法，常用于解决涉及树路径信息维护的问题。该算法的主要目标是将一棵树划分为若干条链，每条链的数据结构可以高效地进行操作，使得在树上进行查询或更新操作...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值