Jamie and Tree( Codeforces 916E) lca + dfs序建线段树

最新推荐文章于 2020-05-14 11:50:38 发布
最新推荐文章于 2020-05-14 11:50:38 发布
阅读量178 收藏
点赞数
分类专栏： tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011535421/article/details/81746147
版权

改编自：

https://blog.csdn.net/sdut16szq/article/details/79148096 

 http://www.cnblogs.com/KingSann/articles/9441763.html

 

算法：

LCA，DFS序，线段树区间维护

解题思路：

首先考虑不对根进行修改，通过对根与询问节点的相对位置关系分析，通过求LCA实现各个操作。由于每一次操作修改的点不确定，最差情况下暴力修改会达到O(n2n2)，所以自然而然的考虑线段树维护。 
然后我们先做好LCA算法的准备工作，以及通过DFS序建立区间更新的线段树。 
接着分析每一个操作： 
操作1：直接将root标记成x即可。 
操作2：仔细分析根和x，y的可能存在位置关系，可能三种情况，分别分析很容易得出求解方法

仔细想一下，什么时候换了根的树的答案和原树不同？

对于修改操作:

如果lca（u，v）（i.e lca（x，y））是当前root的祖先，那么计算子树和的时候会同时少计算和多计算。

è¿éåå¾çæè¿°

其他情况查询答案和原树相同

è¿éåå¾çæè¿°

è¿éåå¾çæè¿°

对于查询操作，少了一个参数，一样的道理

一种是x是r祖先 那么和原树不同

è¿éåå¾çæè¿°

否则 相同

è¿éåå¾çæè¿°

几个技巧：

a是b的祖先lca《==》（a，b）= a

dfs序：点x为根的字数的所有节点的dfs序是连续的，为first【x】~last【x】，在dfs中实现first和last数组

代码：（cf坏了，过会测）—————— 果然炸了

#include<bits/stdc++.h>
#define ll long long 
using namespace std;
#define dprintf if (debug) printf
#define rep(i, j, k) for (int i=j; i<k; i++)
const int maxn = 1e5+50;
const int debug = 0;
int fa[maxn][24], fr, to, edges[maxn*2], pre[maxn*2], tail[maxn],
	ql, qr, first[maxn], last[maxn], depth[maxn], n, q, a[maxn], luv, luvr, lrv, 
	undo, step, op, x, cnt, root, u, v, f[maxn], lur, lvr;
ll pls, mi, sum[maxn*3], lazy[maxn*3];

void addEdge(int fr, int to){
	edges[++cnt] = to;
	pre[cnt] = tail[fr];
	tail[fr] = cnt;
}
void pushdown(int o, int l, int r){
	int mid = l+r>>1;
	sum[o<<1] += lazy[o] * (mid - l + 1);
	sum[o<<1|1] += lazy[o] * (r - mid);
	lazy[o<<1] += lazy[o]; lazy[o<<1|1] += lazy[o];
	lazy[o] = 0;
}
void update(int o, int l, int r){
    //dprintf("update %d %d %d %d %d %d\n", o, l, r, ql, qr, x);
	if (ql<=l && qr>=r){
		sum[o]+=x*(r-l+1);
		lazy[o]+=x;
        //dprintf("sum[%d, %d] = %lld lazy = %lld\n", l, r, sum[o], lazy[o]);
		return;
	}
	pushdown(o, l, r);
	int mid = l+r>>1;
	if (ql <= mid) update(o<<1, l, mid);
	if (qr >= mid+1) update(o<<1|1, mid+1, r);
	sum[o] = sum[o<<1] + sum[o<<1|1];
    //dprintf("sum[%d, %d] = %lld lazy = %lld\n", l, r, sum[o], lazy[o]);
}
ll query(int o, int l, int r){
    //dprintf("query %d %d %d %d %d\n", o, l, r, ql, qr);
	if (ql <= l && qr >= r){
		return sum[o];
	}
	pushdown(o, l, r);
	int mid = l+r>>1;
	ll lsum = 0, rsum = 0; 
	if (ql <= mid) 
		lsum = query(o<<1, l, mid);
	if (qr >= mid+1) 
		rsum = query(o<<1|1, mid+1, r);
	return lsum + rsum;

}
void dfs(int u, int layer){
    //dprintf("dfs %d %d\n", u, layer);
    depth[u] = layer;
    first[u] = ++step;
    f[step] = u;
    for (int i=tail[u]; i; i=pre[i]){
        int to = edges[i];
        if (to != fa[u][0]) {
            fa[to][0] = u;
            dfs(to, layer+1);
        }
    }
    last[u] = step;
}
void makelca(){
    rep(i, 1, n+1){
        rep(j, 1, 23){
            fa[i][j] = fa[fa[i][j-1]][j-1];
        }
    }
}
int lca(int x, int y){
    if (depth[x] < depth[y]) swap(x, y);
    for (int i=22; i>=0; i--){
        if (depth[fa[x][i]] >= depth[y]) x = fa[x][i];
    }
    if (x == y) return x;
    for (int i=22; i>=0; i--){
        if (fa[x][i] != fa[y][i]){
            x = fa[x][i]; y = fa[y][i];
        }
    }
    return fa[x][0];
}
int lst(int son, int father){
    for (int i=22; i>=0; i--){
        if (depth[fa[son][i]] > depth[father]){
            son = fa[son][i];
        }
    }
    return son;
}
int main(){
	scanf("%d%d", &n, &q);
	rep(i, 1, n+1){
		scanf("%d", &a[i]);
	}
	rep(i, 0, n-1){
		scanf("%d%d", &fr, &to);
		addEdge(fr, to);
		addEdge(to, fr);
	}
	dfs(1, 1);

    rep(i, 1, n+1){
        ql = first[i]; qr = first[i]; x = a[i];
		update(1, 1, n);
	}
    dprintf("\n\n\n\n\n");

    makelca();
	rep(i, 0, q){
        dprintf("\n\n\n\n\n");
		scanf("%d", &op);
		if (op == 1){
			scanf("%d", &root);
		}
		else if (op == 2){
			scanf("%d%d%d", &u, &v, &x);
			luv = lca(u, v); luvr = lca(luv, root);
			if (luv == luvr){
                ql = 1; qr = n;
                dprintf("update subtree of 1 x = %d\n", x);
                update(1, 1, n);
                if (depth[luv] < depth[root]){
                    lur = lca(u, root); lvr = lca(v, root);
					if (depth[lur] > depth[lvr]) undo = lst(root, lur);
                    else undo = lst(root, lvr);
					ql = first[undo]; qr = last[undo]; x = -x;
                    dprintf("update subtree of %d x = %d\n", undo, x);
					update(1, 1, n);
				}
			}
			else{
                dprintf("update subtree of %d x = %d\n", luv, x);
				ql = first[luv]; qr = last[luv];
				update(1, 1, n);
			}
		}
		else{
			scanf("%d", &v);
			lrv = lca(root, v);
			if (v == root){
                ql = 1; qr = n;
                printf("%lld\n", query(1, 1, n));
            }
            else if (lrv != v){
				ql = first[v]; qr = last[v];
				printf("%lld\n", query(1, 1, n));
			}
			else {
				ql = 1; qr = n;
				pls = query(1, 1, n);
				undo = lst(root, lrv);
				ql = first[undo]; qr = last[undo];
				mi = query(1, 1, n);
				printf("%lld\n", pls - mi);
			}
		}
	}

}

AC代码：

#include<bits/stdc++.h>
#define ll long long 
using namespace std;
#define dprintf if (debug) printf
#define rep(i, j, k) for (int i=j; i<k; i++)
const int maxn = 1e5+50;
const int debug = 0;
int fa[maxn][24], fr, to, edges[maxn*2], pre[maxn*2], tail[maxn],
	ql, qr, first[maxn], last[maxn], depth[maxn], n, q, a[maxn], luv, luvr, lrv, 
	undo, step, op, x, cnt, root, u, v, f[maxn], lur, lvr;
ll pls, mi, sum[maxn*3], lazy[maxn*3];


void addEdge(int fr, int to){
	edges[++cnt] = to;
	pre[cnt] = tail[fr];
	tail[fr] = cnt;
}
void pushdown(int o, int l, int r){
	int mid = l+r>>1;
	sum[o<<1] += lazy[o] * (mid - l + 1);
	sum[o<<1|1] += lazy[o] * (r - mid);
	lazy[o<<1] += lazy[o]; lazy[o<<1|1] += lazy[o];
	lazy[o] = 0;
}
void update(int o, int l, int r){
    //dprintf("update %d %d %d %d %d %d\n", o, l, r, ql, qr, x);
	if (ql<=l && qr>=r){
		sum[o]+=(ll) x*(r-l+1); ///呵呵
		lazy[o]+=x;
        //dprintf("sum[%d, %d] = %lld lazy = %lld\n", l, r, sum[o], lazy[o]);
		return;
	}
	pushdown(o, l, r);
	int mid = l+r>>1;
	if (ql <= mid) update(o<<1, l, mid);
	if (qr >= mid+1) update(o<<1|1, mid+1, r);
	sum[o] = sum[o<<1] + sum[o<<1|1];
    //dprintf("sum[%d, %d] = %lld lazy = %lld\n", l, r, sum[o], lazy[o]);
}
ll query(int o, int l, int r){
    //dprintf("query %d %d %d %d %d\n", o, l, r, ql, qr);
	if (ql <= l && qr >= r){
		return sum[o];
	}
	pushdown(o, l, r);
	int mid = l+r>>1;
	ll lsum = 0, rsum = 0; 
	if (ql <= mid) 
		lsum = query(o<<1, l, mid);
	if (qr >= mid+1) 
		rsum = query(o<<1|1, mid+1, r);
	return lsum + rsum;

}
void dfs(int u, int layer){
    //dprintf("dfs %d %d\n", u, layer);
    depth[u] = layer;
    first[u] = ++step;
    f[step] = u;
    for (int i=tail[u]; i; i=pre[i]){
        int to = edges[i];
        if (to != fa[u][0]) {
            fa[to][0] = u;
            dfs(to, layer+1);
        }
    }
    last[u] = step;
}
void makelca(){
    rep(j, 1, 23){
        rep(i, 1, n+1){
            fa[i][j] = fa[fa[i][j-1]][j-1];
        }
    }
}
int lca(int x, int y){
    if (depth[x] < depth[y]) swap(x, y);
    for (int i=22; i>=0; i--){
        if (depth[fa[x][i]] >= depth[y]) x = fa[x][i];
    }
    if (x == y) return x;
    for (int i=22; i>=0; i--){
        if (fa[x][i] != fa[y][i]){
            x = fa[x][i]; y = fa[y][i];
        }
    }
    return fa[x][0];
}
int lst(int son, int father){
    for (int i=22; i>=0; i--){
        if (depth[fa[son][i]] > depth[father]){
            son = fa[son][i];
        }
    }
    return son;
}
int main(){
	scanf("%d%d", &n, &q);
	rep(i, 1, n+1){
		scanf("%d", &a[i]);
	}
	rep(i, 0, n-1){
		scanf("%d%d", &fr, &to);
		addEdge(fr, to);
		addEdge(to, fr);
	}
	dfs(1, 1);

    rep(i, 1, n+1){
        ql = first[i]; qr = first[i]; x = a[i];
		update(1, 1, n);
	}
    dprintf("\n\n\n\n\n");

    makelca();
	rep(i, 0, q){
        dprintf("\n\n\n\n\n");
		scanf("%d", &op);
		if (op == 1){
			scanf("%d", &root);
		}
		else if (op == 2){
			scanf("%d%d%d", &u, &v, &x);
			luv = lca(u, v); luvr = lca(luv, root);
            dprintf("luv = %d luvr = %d\n", luv, luvr);
			if (luv == luvr){
                ql = 1; qr = n;
                dprintf("update subtree of 1 x = %d\n", x);
                update(1, 1, n);
                lur = lca(u, root); lvr = lca(v, root);
                if (lur != root && lvr != root){
                    dprintf("lur = %d lvr = %d\n", lur, lvr);
					undo = lur == luvr? lvr : lur;
                    undo = lst(root, undo);
                    ql = first[undo]; qr = last[undo]; x = -x;
                    dprintf("update subtree of %d x = %d\n", undo, x);
					update(1, 1, n);
				}
			}
			else{
                dprintf("update subtree of %d x = %d\n", luv, x);
				ql = first[luv]; qr = last[luv];
				update(1, 1, n);
			}
		}
		else{
			scanf("%d", &v);
			lrv = lca(root, v);
			if (v == root){
                ql = 1; qr = n;
                printf("%lld\n", query(1, 1, n));
            }
            else if (lrv != v){
				ql = first[v]; qr = last[v];
				printf("%lld\n", query(1, 1, n));
			}
			else {
				ql = 1; qr = n;
				pls = query(1, 1, n);
				undo = lst(root, lrv);
				ql = first[undo]; qr = last[undo];
				mi = query(1, 1, n);
				printf("%lld\n", pls - mi);
			}
		}
	}

}

 

三级头不怕通
关注
专栏目录
Codeforces 916E(思维+dfs序+线段树+LCA)
weixin_30758821的博客
07-29 113
题面 传送门 题目大意:给定初始根节点为1的树,有3种操作 1.把根节点更换为r 2.将包含u,v的节点的最小子树(即lca(u,v)的子树)所有节点的值+x 3.查询v及其子树的值之和 分析 看到批量修改子树,我们想到将树上操作转化为区间操作 通过DFS序我们可以实现这一点. 对于每个节点x,我们记录它在前序遍历中的位置l[x]...
codeforces 916E
qq_18869763的博客
01-23 262
dfs序+线段树+LCA。 难点：更换树的根节点后，如何用线段树更新一子树和查询一子树。  更新时：  如果当前的根节点不在要修改的子树中时，直接成段更新区间即可。  若当前的根节点在要修改的子树中时，有两种情况: 先更新【1~n】整个区间的值 ①（root既不是u的祖先也不是v的祖先）时，多修改了一部分，把多修改的那部分该回来，即u,v节点中包含root节点的那颗子树。 ②（与①条
Jamie and Tree codeforces 916E
Spy97的博客
04-06 290
题目大意：给出一棵树以及每个结点的权值，初始时根为1。有3种操作：一是将根换为x；二是给出两个节点u,v，把包含这两个点的最小子树中每个节点权值加上x；三是查询以u为根的权值和。题解：不考虑换根时，需要的算法是裸的模板线段树+dfs序+LCA，考虑到换根，我们不必真的换，只需要对操作2和3进行分类讨论。对于第一种操作，直接将根换一下即可。对于第二种操作，设t为（u，v）的LCA，分为两大种情况，一...
Jamie and Tree( Codeforces 916E)
sdut16szq的博客
01-24 479
题意: 给出一个有n个点以及n-1条边的树，进行3个操作： 1. 将x变成整个树的根 2. 将以x，y相对于根的最近公共祖先的为根的那棵子树的所有根节点加上z. 3. 查询以x为根的子树的所有节点的和 算法： LCA，DFS序，线段树区间维护 解题思路： 首先考虑不对根进行修改，通过对根与询问节点的相对位置关系分析，通过求LCA实现各个操作。由于每一次操作修改的点不确定，
codeforces E. Jamie and Tree LCA+dfs序+线段树
SUNSET
01-28 255
题解： 写起来还稍微有点麻烦。 dfs序+线段树可以维护子树的整体修改和查询。 因此，这道题我们要往子树上靠。 我们首先从1号点进行dfs遍历，顺便求出点的dfs序和深度，然后我们采用倍增的思想，可以预处理出每个点的祖先是谁。然后可以在O(log(n))" role="presentation" style="position: relative;">O(log(n))O(lo
Chan Jamie - Learn SQL in One Day and Learn It Well
02-26
本书"Jamie Chan - Learn SQL in One Day and Learn It Well"旨在帮助初学者快速掌握SQL，并深入理解其核心概念。通过使用MySQL，一个免费且广泛应用的数据库管理系统，作者Jamie Chan将复杂的SQL概念以简单易懂的...
w2_git-branching-practice-sell-and-jamie:由GitHub Classroom创建的w2_git-branching-practice-sell-and-jamie
04-08
分支运动 ... 对于此任务，我们希望您： 第一个人： 克隆此仓库 创建第一个分支并命名为“ bugFix1” 查找错误并修复 添加，提交和推送更改 创建拉取请求 一对一起检查错误 ...交换到第二个人，第二个人将重复上述步骤...
Mastering Unity Shaders and Effects
09-05
Leverage the power of Unity 5 compatible shaders to create a variety of realistic surfaces Create amazing visual effects for your Unity 5.x games by blending advanced post-processing techniques and ...
JAMIE-开源
04-26
**JAMIE 开源项目详解** JAMIE，全称为“JAva Mud实施引擎”，是一个专为构建纯文本、基于telnet的MUD（多用户地下城）服务器而设计的开源软件。MUD是一种在线的多玩家游戏，玩家通过文本界面进行交互，探索虚拟...
CodeForces - 343D Water Tree （DFS序+线段树）
不二君
10-06 192
题目链接 题意：现在有一棵以1为根节点的树，每个节点有一个水池，现在有三种操作。 操作一：将v节点灌满水，然后他的所有子节点也将灌满水。 操作二：将v节点的水抽干，然后他的所有父节点的水也将被抽干。 操作三：查询某一个节点是否有水。 题解：这个题看数据肯定暴力不可行，现在我们先DFS序将树结构转化成线性结构，然后对子节点的操作就直接转化成了线段树的区间操作，现在灌满水的操作已经解决了。但...
Codeforces E. Company（线段树+lca）
qq_41818939的博客
05-14 1493
题目链接 题目大意： 给定一棵树，每个顶点都有一个序号，然后询问输入l,r，则需要在[l,r]的顶点中选择一个删掉，求其余顶点的lca，要使这个lca深度最大，输出删除的顶点，及lca的深度。 解题思路： 有一个前置知识：区间的lca是区间中dfs序的in数组中最小和最大的两个顶点的lca。（简易证明：区间[l…r]，dfs序为进入的时间戳,out为离开的时间戳，设u是in中最小的顶点，v是in中最大的顶点，设r的lca(u,v)，则in[r]≤\le≤ in[u] && out[r] ≥\
CodeForce 916E Jamie and Tree（线段树+分类讨论）
alpc_qleonardo
04-16 434
大致题意：给你一棵树，每个节点上面有一个权值。然后有三种询问：1、换根；2、把点x、y在现有树情况下的LCA的子树的所有点权增加一个值；3、求某个节点在现有树情况下的点权和。 很显然的一个线段树经典题目，首先求所有点的dfs序，然后根据dfs序建立线段树，可以动态维护子树的权值和。但是这题的关键在于换根。因为换根之后树的形态发生了改变，对应的子树情况也会发生改变，不能简单的用初始情况下的dfs序。但是我们显然也不能真的去换根。 我们现在重新考虑一下换根之后，对于2和3操作
CodeForces 916D Jamie and To-do List (主席树+map)
满月照亮的路
03-20 236
题目链接:http://codeforces.com/problemset/problem/916/D 题目大意 给定四种操作， 第一种：设定字符串的优先级，若该字符串事先没有出现过， 则添加上去，否则修改。 第二种：删除操作，删除指定的字符串 第三种：返回操作，回退k个操作， 第四种：查询指定字符串，其有多少个字符串的优先级小于它。 题目分析 看到时间回退操作不难想到可持久化， ...
CF916D Jamie and To-do List 主席树 留坑
u011535421的博客
08-17 461
https://www.luogu.org/problemnew/solution/CF916D D. Jamie and To-do List time limit per test 2 seconds memory limit per test 512 megabytes input standard input output standard output Why I ...
Physical Education Lessons（【CodeForces】915 E）
sdut16szq的博客
01-19 473
【题意】n个点q个询问，对于每一个询问，输入l，r，k，如果k是1，代表[l, r]全变成0， k是2就将[l, r]全变成1。 【题解】一眼看去，肯定是维护区间的线段树，然后连范围都没看到。写完以后发现不对，n是1e9，然后想到离散化处理以后用线段树。解法：将点i与点i+1之间的区间大小赋予点i，即点i的权值为点i与点i+1之间的区间大小。然后就可以随便线段树乱写了。注意数据范围，这里好像超了
codeforces_916B
沉醉不知归路
01-20 617
题意：给定n，n是由一系列数的和组成，这些数是2^a,2^b,2^c。。。。最多有k个，你的目的是让a,b,c….中最大的数最小，如果这样的数列有多个，输出字典序最大的那个。 思路：二进制之所以唯一是因为它的每一个二进制位都只能使用一次，比如23=2^4+2^2+2^1+2^0，二进制在每位都使用一次且保证最大的数最小的情况下，去唯一的表示了一个数，那么我们假设每个二进制位能用无数多次，那么每个
Imbalance Value of a Tree （CodeForces 915F）
sdut16szq的博客
01-20 504
题意： 给出一个有n个点的带权值的树，求所有点两两之间的所有路径所经过的最大值与最小值的差。 算法： 并查集 解题思路： 没怎么做过这种类型的题，首先考虑每一个点对答案做出的贡献，可以求出所有最大值的和以及所有最小值的和。这里介绍一下怎么求所有最大值的和，首先我们有一个完整的树，首先考虑权值最大的那个点，肯定是和他相连的并且两两相互独立的几坨点的个数两两相乘后乘以这个点权（这里有点求解的
c#实现俄罗斯方块，面向对象实现
最新发布
09-15
俄罗斯方块（Tetris）是一款经典的益智游戏，由俄罗斯程序员阿列克谢·帕基特诺夫于1984年开发。游戏的主要目标是通过旋转和移动不同形状的方块（称为“砖块”或“Tetrominoes”），将它们填充到屏幕底部的水平行中。当一行被完全填满时，该行会消失，玩家将获得积分。 游戏特点： 砖块形状：游戏中有七种不同形状的砖块，每种砖块由四个方块组成。 下落机制：砖块从屏幕顶部逐渐下落，玩家需要快速做出决策。 得分系统：消除的行越多，得分越高，连续消除多行会获得额外分数。 难度递增：随着游戏进行，砖块下落的速度会逐渐加快，增加了游戏的挑战性。 文化影响： 俄罗斯方块不仅在游戏界取得了巨大的成功，还成为了流行文化的一部分，影响了许多后续的游戏设计。它的简单性和上瘾性使其成为了历史上最畅销的电子游戏之一。 版本与平台： 自发布以来，俄罗斯方块已经在多个平台上推出，包括家用游戏机、电脑、手机等，形成了众多不同的版本和变种。
精通MVC3：Jamie Munro的20个编程食谱
"20 Recipes for Programming MVC 3是Jamie Munro撰写的一本书，专注于Microsoft的MVC（Model-View-Controller）框架的第三个版本。这本书提供了20个具体的方法和实践，帮助开发者在实际项目中有效地应用MVC 3技术。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值