主席树 + 树上倍增 ---- codeforces 587C[树上倍增或者主席树]

最新推荐文章于 2022-04-01 13:17:31 发布
最新推荐文章于 2022-04-01 13:17:31 发布
阅读量137 收藏
点赞数
分类专栏： 树上问题 # 可持久化数据结构 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45630722/article/details/109271493
版权

题目链接
给 定 一 棵 n 个 点 的 树 ， 给 定 m 个 人 （ m ≤ n ） 在 哪 个 点 上 的 信 息 ， 每 个 点 可 以 有 任 意 个 人 ； 然 后 给 q 个 询 问 ， 每 次 问 u 到 v 上 的 路 径 有 的 点 上 编 号 最 小 的 k ( k ≤ 10 ) 个 人 （ 没 有 那 么 多 人 就 该 有 多 少 人 输 出 多 少 人 ） 。 给定一棵n个点的树，给定m个人（m≤n）在哪个点上的信息，每个点可以有任意个人；然后给q个询问，每次问u到v上的路径有的点上编号最小的k(k≤10)个人（没有那么多人就该有多少人输出多少人）。 给定一棵n个点的树，给定m个人（m≤n）在哪个点上的信息，每个点可以有任意个人；然后给q个询问，每次问u到v上的路径有的点上编号最小的k(k≤10)个人（没有那么多人就该有多少人输出多少人）。

解法一：树上倍增法：
解题思路：观察那个数据,因为k的大小只有10，那么我们对于每个点就可以暴力求出前k小的数，用倍增的思想： 在 [ l , r ] 区 间 内 部 前 k 小 数 就 是 [ l , l + 2 i − 1 ] 和 [ l + 2 i , r ] 区 间 内 的 第 k 小 值 在[l,r]区间内部前k小数就是[l,l+2^i-1]和[l+2^i,r]区间内的第k小值 在[l,r]区间内部前k小数就是[l,l+2i−1]和[l+2i,r]区间内的第k小值
这里合并有个小技巧：因为每个小区间都是单调的所以我们求第k小的时候我们可以用归并的思想去合并区间的信息

代码

#include<bits/stdc++.h>
#define mid ((l + r) >> 1)
#define Lson rt << 1, l , mid
#define Rson rt << 1|1, mid + 1, r
#define ms(a,al) memset(a,al,sizeof(a))
#define log2(a) log(a)/log(2)
#define _for(i,a,b) for( int i = (a); i < (b); ++i)
#define _rep(i,a,b) for( int i = (a); i <= (b); ++i)
#define for_(i,a,b) for( int i = (a); i >= (b); -- i)
#define rep_(i,a,b) for( int i = (a); i > (b); -- i)
#define lowbit(x) ((-x) & x)
#define IOS std::ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define INF 0x3f3f3f3f
#define LLF 0x3f3f3f3f3f3f3f3f
#define hash Hash
#define next Next
#define pb push_back
#define f first
#define s second
#define y1 Y
using namespace std;
const int N = 4e5 + 10, mod = 1e9 + 7;
const int maxn = 4e5 + 10;
const long double eps = 1e-5;
const int EPS = 500 * 500;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<ll,ll> PLL;
typedef pair<double,double> PDD;
const int BUF=30000000;
char Buf[BUF],*buf=Buf;
template<typename T> void read(T &a)
{
     for(a=0;*buf<48;buf++);
    while(*buf>47) a=a*10+ *buf++ -48;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) 
{
   read(first);
   read(args...);
}
int n, m ,q;
vector<int> G[N];
vector<int> pre[N][30];
int fa[N][20], depth[N];

inline vector<int> Merge(vector<int> a, vector<int> b) {//合并前10小的数
    vector<int> ans;
	int poia = 0, poib = 0; 
    while(ans.size() < 10 && poia < a.size() && poib < b.size()) {
        if(a[poia] < b[poib]) ans.push_back(a[poia ++]);
        else ans.push_back(b[poib ++]);
    }
    while(ans.size() < 10 && poia < a.size()) ans.push_back(a[poia ++]);
    while(ans.size() < 10 && poib < b.size()) ans.push_back(b[poib ++]);
    return ans;
}

inline void dfs(int u, int f) {
    fa[u][0] = f;
    for(int i = 1; i <= 17; ++ i)
      fa[u][i] = fa[fa[u][i - 1]][i - 1];
    for(int j = 1; j <= 17; ++ j) {
           pre[u][j] = Merge(pre[u][j - 1],pre[fa[u][j - 1]][j - 1]);
    }
    depth[u] = depth[f] + 1;
    for(auto it : G[u]) {
        if(it == f)continue;
        dfs(it,u);
    }
}


inline int LCA(int u, int v) {
    if(depth[u] > depth[v]) swap(v,u);
    int delta = depth[v] - depth[u];
    for(int i = 0; i <= 17; ++ i)
     if(delta >> i & 1) v = fa[v][i];
    if(u == v) return v;
    for(int i = 17; i >= 0; -- i)
     if(fa[u][i] != fa[v][i])
      u = fa[u][i], v = fa[v][i];
    return fa[u][0];
}

inline vector<int> slove(int u, int v) {
	vector<int> res;
	int delta = depth[u] - depth[v];
	for(int j = 0; j <= 17 && u; ++ j) 
	  if(delta >> j & 1) 
	   res = Merge(res,pre[u][j]), u = fa[u][j];
	return res;
}

int main()
{
   fread(Buf,1,BUF,stdin);
   read(n,m,q);
   for(int i = 0; i < n - 1; ++ i) {
       int l, r;
       read(l,r);
       G[l].push_back(r);
       G[r].push_back(l);
   }
   for(int i = 1; i <= m; ++ i) {
       int x;
       read(x);
       pre[x][0].push_back(i);
   }
   for(int i = 1; i <= n; ++ i) sort(pre[i][0].begin(),pre[i][0].end());
   dfs(1,0);
  while(q --) {
       int u, v, a;
       read(u,v,a);
       int lca = LCA(u,v);
       vector<int> ans, res;
       ans = slove(u,lca);
       res = slove(v,lca);
       res = Merge(ans,res);
       res = Merge(res,pre[lca][0]); //因为LCA还没被计算过
       //..........................................................
	   if(!res.size()) printf("0\n");
       else cout << min((int)res.size(),a) << " ";
       for(int i = 0; i < min(a,(int)res.size()); ++ i) {
           printf("%d",res[i]);
           if(i < min(a,(int)res.size()) - 1) printf(" ");
		   else printf("\n"); 
       }
   }
   return 0;
}

解法2：主席树,因为树上信息具有可加性所以我们可以按照dfs序对这颗树建立一个主席树就是每个点到根节点的路径区间建立主席树，多次插入,那么要求u和v之间的路径信息的话那么就要 [ r o o t , u ] + [ r o o t , v ] − [ r o o t , l c a ] − [ r o o t , f a [ l c a ] ] [root,u]+[root,v]-[root,lca]-[root,fa[lca]] [root,u]+[root,v]−[root,lca]−[root,fa[lca]],这个可以有倍增去维护

代码：

#include<bits/stdc++.h>
#define mid ((l + r) >> 1)
#define Lson rt << 1, l , mid
#define Rson rt << 1|1, mid + 1, r
#define ms(a,al) memset(a,al,sizeof(a))
#define log2(a) log(a)/log(2)
#define _for(i,a,b) for( int i = (a); i < (b); ++i)
#define _rep(i,a,b) for( int i = (a); i <= (b); ++i)
#define for_(i,a,b) for( int i = (a); i >= (b); -- i)
#define rep_(i,a,b) for( int i = (a); i > (b); -- i)
#define lowbit(x) ((-x) & x)
#define IOS std::ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define INF 0x3f3f3f3f
#define LLF 0x3f3f3f3f3f3f3f3f
#define hash Hash
#define next Next
#define pb push_back
#define f first
#define s second
#define y1 Y
using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
const int maxn = 4e5 + 10;
const long double eps = 1e-5;
const int EPS = 500 * 500;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<ll,ll> PLL;
typedef pair<double,double> PDD;
template<typename T> void read(T &x)
{
    x = 0;char ch = getchar();ll f = 1;
    while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
    while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) 
{
   read(first);
   read(args...);
}
int n, m, q, maxv;
//.......................建图
struct Node {
    /* data */
    int to, nxt;
}edge[N];
int head[N], cnt;
vector<int> node[N];

inline void add(int from, int to) {
    edge[cnt] = (Node){to,head[from]};
    head[from] = cnt ++;
}
//.....................主席树
struct Tree {
    int lson, rson, cnt;
}tr[N * 40];
int root[N];
int idx = 0;

inline int build(int l, int r) {
    int now = ++ idx;
    if(l == r) return now;
    tr[now].lson = build(l,mid), tr[now].rson = build(mid+1,r);
    return now;
}

inline int insert(int pre, int l, int r, int k) {
    int poi = ++ idx;
    tr[poi] = tr[pre];
    if(l == r) {
        tr[poi].cnt ++;
        return poi;
    }   
    if(k <= mid) tr[poi].lson = insert(tr[pre].lson,l,mid,k);
    else tr[poi].rson = insert(tr[pre].rson,mid+1,r,k);
    tr[poi].cnt = tr[tr[poi].lson].cnt + tr[tr[poi].rson].cnt;
    return poi;
}

inline int query(int lpoi, int rpoi, int lcapoi, int falcapoi, int l, int r, int k) {
    if(l == r) 
        return l;
    int Eps = tr[tr[lpoi].lson].cnt + tr[tr[rpoi].lson].cnt - tr[tr[lcapoi].lson].cnt - tr[tr[falcapoi].lson].cnt;
    if(k <= Eps) return query(tr[lpoi].lson,tr[rpoi].lson,tr[lcapoi].lson,tr[falcapoi].lson,l,mid,k);
    else return query(tr[lpoi].rson,tr[rpoi].rson,tr[lcapoi].rson,tr[falcapoi].rson,mid+1,r,k-Eps);
}

//...................倍增求LCA

int fa[N][20], depth[N];
inline void dfs(int u, int f) {
     if(node[u].size()) 
     {
         root[u] = insert(root[f],1,maxv+1,node[u][0]);
         for(int i = 1; i < node[u].size(); ++ i)
         root[u] = insert(root[u],1,maxv+1,node[u][i]);
     }
     else root[u] = root[f];
     fa[u][0] = f; depth[u] = depth[f] + 1;
     for(int i = 1; i <= 17; ++ i)
       fa[u][i] = fa[fa[u][i - 1]][i - 1];
     for(int i = head[u]; ~i; i = edge[i].nxt) {
         int v = edge[i].to;
         if(v == f) continue;
         dfs(v,u);
     }
}
//.....................................
inline int LCA(int u, int v) {
    if(depth[u] > depth[v]) swap(v,u);
    int delta = depth[v] - depth[u];
    for(int i = 0; i <= 17; ++ i)
     if(delta >> i & 1) v = fa[v][i];
    if(u == v) return v;
    for(int i = 17; i >= 0; -- i)
     if(fa[u][i] != fa[v][i])
      u = fa[u][i], v = fa[v][i];
    return fa[u][0];
}
//.......................................
inline void debug(int rt, int l, int r) {
    cout << tr[tr[rt].lson].cnt << " ";
    cout << tr[tr[rt].rson].cnt << "\n";
    cout << l << " " << r << endl;
    cout << "-------------" << endl;
    if(l == r)  
    {
        if(tr[rt].cnt) 
          cout << l << " debug" << endl;
        return;
    }
    debug(tr[rt].lson,l,mid);
    debug(tr[rt].rson,mid+1,r);
}
//.......................................
int ans[N], poi;
//.......................................
int main() {
   ms(head,-1);
   read(n,m,q);
   maxv = max(n,m);
   for(int i = 0; i < n - 1; ++ i) {
       int l, r;
       read(l,r);
       add(l,r), add(r,l);
   } 
   for(int i = 1; i <= m; ++ i)
   {
       int x;
       read(x);
       node[x].push_back(i);
   }
   root[0] = build(1,maxv+1);
   dfs(1,0);
   while(q --) {
       int u,v,a;
       read(u,v,a);
       int lca = LCA(u,v);
       for(int i = 1; i <= min(a,m); ++ i) 
       {
           int tmp = query(root[u],root[v],root[lca],root[fa[lca][0]],1,maxv+1,i);
           if(tmp > maxv) continue;
           ans[poi ++] = tmp;
       }
       printf("%d ",poi);
       if(poi == 0) puts("");
       for(int i = 0; i < poi; ++ i) 
       printf("%d%c",ans[i]," \n"[i == poi - 1]);
       poi = 0;
   }
   return 0;
}
黑夜和白天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
简析树上倍增
u013455437的博客
06-06 257
树上倍增，可在树的某条链上随深度具有某种单调的性质时进行查找，使时间复杂度从暴力查找的O(N)O(N)O(N)变为O(log⁡N)O(\log N)O(logN)。 树上倍增需要构建数组f[N][⌈log⁡N⌉]f[N][\left \lceil \log N \right \rceil ]f[N][⌈logN⌉]，其中f[n][i]f[n][i]f[n][i]代表的是从结点nnn向根节点方向走2i2^i2i步到达的结点。 很显然，f[n][0]f[n][0]f[n][0]即结点nnn的父节点，在建图时即可
树上倍增法
实践求真知
09-05 1008
最近公共祖先
树上倍增的写法和应用（详细讲解，新手秒懂）
热门推荐
Saramanda的博客
02-10 1万+
最近做了一些树上的练习题，发现倍增真的是一种处理树上问题的神奇、方便的方法。 我以前一直打树链剖分打得多，但是学了倍增之后就再也不想打树链剖分了（当然有些题目不得不打）。 倍增比起树链剖分，代码短，容易查错，时空复杂度也优很多（nlogn），只是功能有些欠缺。 倍增的思想是二进制。         首先开一个n×logn的数组，比如fa[n][logn],其中fa[i][j]表示i
【Codeforces 932D】 Tree | 树上倍增
一只酷酷光儿的博客
12-02 235
题目链接：https://codeforces.com/contest/932/problem/D 题目大意： 起初是一个点，对于这个点要进行q次操作 1操作：1 x y 新增一个节点，它的父节点x，它的权值是num[y] 2操作：2 x y 询问以x开头的，满足所有点在x到根节点的路径上，并且权值单调不减，并且总权值小于等于x的最长路径长度 题目思路： 这个题类似：原题 首先可以确定是一个树，因为每个节点只有一个父亲节点 所以可以在树上进行倍增维护这个信息 f[i][j] 代表 i 到
codeforces 932D. Tree(树上倍增)
the best 的博客
07-28 134
题意： 给出一个初始点只有1的树，权值为0，有两种操作： 1.1.1. 往树中加入一个节点 2.查询从某个节点起，往祖先方向能找到的最长非降子序列。要求：权值和不能超过xxx ,并且后一个点是前一个点的祖先，且必须是最近的，权值≥\geq≥ 前一个点的祖先。 操作强制在线。 题解： 像这种往祖先方向查询的操作，可以考虑倍增法。 设dp[i][j]dp[i][j]dp[i][j]​ 表示节点iii 向上找长度为2j2^j2j 的非降子序列后所处的位置 设sum[i][j]sum[i][j]sum[i][j]
PDF-CodeForces-Problems:PDF文件中的CodeForces问题
05-12
PDF-CodeForces问题 PDF文件中的CodeForces问题 利用CodeForces提取在这个库中的文件 ，文件夹名代表来自CodeForces网址contests`的ID，每个文件夹包含比赛的问题。 有关CodeForces竞赛的疯狂事实 CodeForces上有937...
Codeforces-Solution
05-03
Codeforces解决方案
codeforces-solutions:解决Codeforce问题的方法-Codeforces旅程
03-31
Codeforces解决方案
bad-apple-cf:坏苹果！！ 在Codeforces活动图上
05-15
坏苹果cf 玩 在您的活动图上，因为为什么不这样。 获取用户脚本管理器，例如 ， ， 或其他。 通过访问其原始Github URL（即来安装脚本bad_apple_cf.user.js 。 Codeforces现在变得更加有趣。 这。
CodeForces_1348EF – Phoenix and Memory 贪心+线段树找区间最小值
01-03
这题如果没有输出2个解就很简单。 是个之前做过的类型： 把所有限制按R排序， 然后每次取出R最小的，然后从...我们枚举i，只需要找到任意一个j满足上式，就可以交换i,j然后输出。 我们可以先把所有的Lj存到以 posj为区
树上倍增法求最近公共祖先LCA
FlushHip
02-26 866
LCA，最近公共祖先，这个东西有很多作用，因此，如何高效求出LCA就成了一个热点的讨论话题。下面所有的讨论都以图中这棵树为例子。先来了解下什么是倍增吧，倍增其实就是二分的逆向，二分是逐渐缩小范围，而倍增是成倍扩大。这里的倍增借用二进制来表达更容易理解；
树上倍增
Black__wing的博客
01-16 1729
对于在树上查找某点的祖先，如果简单的查找时间复杂度是o(n)，那么，我们可以通过倍增算法优化这个时间复杂度，将每次跳一个点变成，每次跳2的i次方个点，也就是倍增优化这个过程，将时间复杂度变为o(logn)。 如何进行倍增？ 首先我们需要进行一遍dfs初始化，处理出每个点的深度。根据深度，初始化fa[now][i]，fa数组存的是now节点的2得i次方倍祖先。 这样处理完成后，我们来看树上倍增...
02 最近公共祖先（LCA）树上倍增法（附代码实现模板）
q2090988808的博客
04-01 1101
最近公共祖先（LCA） 最近公共祖先解决的问题 给定一颗有根树，若节点z即是节点x的祖先，也是节点y的祖先，则称z是x，y的公共祖先。 在x，y的所有公共祖先中，深度最大（距离根节点的距离最远的）的一个称为x，y的最近公共祖先，记作LCA(x,y)。 LCA(x,y)是x到根的路径与y到根的路径的交会点。它也是x与y之间的路径上深度最小的节点。求最近公共祖先的方法通常有以下三种。 方法1 向上标记法 从 x 向上走到根节点，并标记所有经过的节点。 从y向上从到根节点，当第一次遇到已经标记的节点时，就找到了
树上倍增求LCA
OIER成长之路
07-24 1253
树上倍增求LCA
codeforces 587C(树上的倍增算法)
playwfun的专栏
11-09 1285
分析： 同LCA相似的思路，维护st[ i ][ j ] 代表从节点i往上（不包含i）走2^j个节点前十个最小值集合，这样一直倍增着往上走秩序logn次集合合并即可。 #include #define fst first #define snd second #define ALL(a) a.begin(), a.end() #define clr(a, x) memset(a, x, s
Codeforces 587C【树上倍增】
ONE MORE TRY
08-12 572
题意： 求树上两点路径中的前 a(<=10) 小的点权值。 思路： 类似LCA倍增算法来存储 i -> 2^j 路上的 前(<=10)小个 的点权值。 然后要写一个权值合并>>> 具体求 u->v 的话，就是先分别计算 {u->LCA} 和 {v->(LCA-1)} (减1是LCA会重叠), 然后再合并，输出答案。#include<iostream> #include<cstdio> #i
CodeForces - 932D Tree(树上倍增，好题)
Falcon的博客
01-23 409
题目链接：点击查看 题目大意：给出一棵树，初始时只有一个节点1，权值为0，后续有 n 个操作，每次操作分为两种情况： 1 u val：向树中插入一个新的节点，其父节点为 u ，权值为 val 2 u val：询问以节点 u 为起点的最长不下降子序列的长度，这里规定的最长不下降子序列需要满足以下几个条件： 以 u 为起点，每次的路线必须都是当前节点的父节点 序列中的权值和小于等于 val...
与图论的邂逅08:树上倍增
weixin_34133829的博客
05-19 190
什么是树上倍增？ 顾名思义，就是在树上成倍地增长，可以用于解决一些静态树的查询问题。 放出例题：给定一棵根节点为1的n个节点的树，并给出树上两个点u,v，求它们的最近公共祖先。 我们可以预处理出每个点的父亲节点fa和深度dep，然后选择u,v中深度较大者不断地往父亲节点走，当u,v深度相同时判断：u,v是否为同一个点。如果是，那么答案就是u或者v；否则，u,v同时向着各自的父亲节点走，当两个点的...
CodeForces - 982C 树形DP
最新发布
07-25
引用\[1\]中提到了一种树形动态规划的方法来解决CodeForces - 982C问题。在这个问题中，subtree指的是子连通块，而不是子树。为了使cnt_white - cnt_black尽可能大，可以使用两次树形动态规划来求解。第一次是自底...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值