暑假集训日记——8.3( 树链剖分+树形DP)

最新推荐文章于 2023-07-07 07:18:42 发布
最新推荐文章于 2023-07-07 07:18:42 发布
阅读量149 收藏
点赞数
分类专栏： 树链刨分 树形DP 暑假集训
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43870114/article/details/98311858
版权

树链剖分：大佬的博客 大神的博客
题目：【模板】树链剖分
学长的板子：

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5+10;
int mod = 1e9+7;
int n, m, r, p;
template<typename T>
struct Heavy_Light_Decomposition{
	//head u的子节点编号，to 子节点， nx 下一子节点的编号
	int head[N], to[N], nx[N], tot, cnt;
	//dep 深度，fa 父亲 ，sz 子树大小 ，son 儿子 ，w权值
	int dep[N], fa[N], sz[N], son[N], w[N];
	//top 重儿子的祖先 ，id 刨分后的编号 ，wt 刨分后的权值
	int top[N], id[N], wt[N];
	//val 维护区间和 ，lz lazy标记
	T val[N<<2], lz[N<<2];
	void init(int n){
		tot = cnt = 0;
		for(int i = 0; i <= n; ++i) head[i] = -1;
	}
	void add(int u, int v){
		to[tot] = v;
		nx[tot] = head[u];
		head[u] = tot++;
	}
	void dfs1(int u,int f){//初始化dep son sz fa，找出重儿子
		dep[u] = dep[f] + 1; fa[u] = f; sz[u] = 1;
		son[u] = 0;
		for(int i = head[u]; ~i; i = nx[i]){
		    int v = to[i];
		    if(v == f) continue;
		    dfs1(v, u);
		    sz[u] += sz[v];
		    if(sz[v] > sz[son[u]]) son[u] = v;
		}
	}
	void dfs2(int u,int topf){//树刨 初始化id wt top
		id[u] = ++cnt;
		wt[cnt] = w[u];
		top[u] = topf;
		if(!son[u]) return;
		dfs2(son[u], topf);
		for(int i = head[u]; ~i; i = nx[i]){
		    int v = to[i];
		    if(v == fa[u] || v == son[u]) continue;
		    dfs2(v, v);
		}
	}
	void pushdown(int rt,int l,int r){
		if(!lz[rt]) return ;
		int mid = (l+r) >> 1;
		lz[rt<<1] += lz[rt]; lz[rt<<1] %= mod;
		lz[rt<<1|1] += lz[rt]; lz[rt<<1|1] %= mod;
		val[rt<<1] += lz[rt] * (mid-l+1) %mod; val[rt<<1] %= mod;
		val[rt<<1|1] += lz[rt] * (r-mid) %mod; val[rt<<1|1] %=mod;
		lz[rt] = 0;
	}
	void pushup(int rt){
		val[rt] = val[rt<<1] + val[rt<<1|1];
		val[rt] %= mod;
	}
	void build(int rt, int l, int r){
		if(l == r){
		    val[rt] = wt[l];
		    val[rt] %= mod;
		    return ;
		}
		int mid = (l+r) >> 1;
		build(rt<<1, l, mid);
		build(rt<<1|1, mid+1, r);
		pushup(rt);
	}
	T query(int rt, int l, int r, int L, int R){
		if(L <= l && R >= r){
		    return val[rt];
		}
		int mid = (l+r) >> 1; T  ans = 0;
		pushdown(rt, l, r);
		if(L <= mid) ans += query(rt<<1, l, mid, L, R), ans %= mod;
		if(R > mid) ans += query(rt<<1|1, mid+1, r, L, R), ans %= mod;
		pushup(rt);
		return ans;
	}
	T queryRange(int l, int r){//查询l，r的最短路路径和
		T ans = 0;
		while(top[l] != top[r]){
		    if(dep[top[l]] < dep[top[r]]) swap(l, r);
		    ans += query(1, 1, n, id[top[l]], id[l]);
		    ans %= mod;
		    l = fa[top[l]];
		}
		if(dep[l]>dep[r]) swap(l, r);
		ans += query(1, 1, n, id[l], id[r]);
		return ans%mod;
	}
	void update(int rt, int l, int r, int L, int R, int x){
		if(L <= l &&R >= r){
		    lz[rt] += x; lz[rt] %=mod;
		    val[rt] += 1LL*x*(r-l+1)%mod;
		    val[rt] %=mod;
		    return ;
		}
		int mid = (l+r)>>1;
		pushdown(rt, l, r);
		if(L <= mid) update(rt<<1, l, mid, L, R, x);
		if(R > mid) update(rt<<1|1, mid+1, r, L, R, x);
		pushup(rt);
	}
	//修改l，r的最短路径的权值
	void updateRange(int l, int r, int x){
		while(top[l] != top[r]){
		    if(dep[top[l]] < dep[top[r]]) swap(l, r);
		    update(1, 1, n, id[top[l]], id[l], x);
		    l = fa[top[l]];
		}
		if(dep[l]>dep[r]) swap(l, r);
		update(1, 1, n, id[l], id[r], x);
	}
	//修改子树权值
	void updateSon(int x,int y){
		update(1, 1, n, id[x], id[x]+sz[x]-1, y);
	}
	//查询子树和
	T querySon(int x){
		return query(1, 1, n, id[x], id[x]+sz[x]-1);
	}
};
Heavy_Light_Decomposition<long long>hld;//模板
int main(){
	//n个点，m次操作，r是根节点，p模
	scanf("%d%d%d%d", &n, &m, &r, &p);
	hld.init(n);
	mod = p;
	for(int i = 1; i <= n; ++i){
		scanf("%d", &hld.w[i]);
	}
	for(int i = 1; i < n; ++i){
		int u, v; scanf("%d%d", &u, &v);
		hld.add(u, v);
		hld.add(v, u);
	}
	hld.dfs1(r, 0);
	hld.dfs2(r, r);
	hld.build(1, 1, n);
	for(int i = 1; i <= m; ++i){
		int id, x, y, z;
		scanf("%d", &id);
		if(id == 1){
			scanf("%d%d%d", &x, &y, &z);
			hld.updateRange(x, y, z);
		}
		else if(id == 2){
			scanf("%d%d", &x, &y);
			printf("%lld\n", hld.queryRange(x, y));
		}
		else if(id == 3){
			scanf("%d%d", &x, &y);
			hld.updateSon(x, y);
		}
		else scanf("%d", &x), printf("%lld\n", hld.querySon(x));
	}
	return 0;
}

A - Aragorn’s Story
题解：板子题（awsl，lazy标记忘记初始化了…所以总是不过
用线段树做总是不对…用树状数组做了一遍

#pragma comment(linker, "/STACK:10240000,10240000")
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 1e6+10;
int n, m, r, p;
template<typename T>
struct Heavy_Light_Decomposition{
	//head u的子节点编号，to 子节点， nx 下一子节点的编号
	int head[N], to[N], nx[N], tot, cnt;
	//dep 深度，fa 父亲 ，sz 子树大小 ，son 儿子 ，w权值
	int dep[N], fa[N], sz[N], son[N], w[N];
	//top 重儿子的祖先 ，id 刨分后的编号 ，wt 刨分后的权值
	int top[N], id[N], wt[N],tree[N];
	//val 维护区间和 ，lz lazy标记
	T val[N<<2], lz[N<<2];
	void init(int n){
		tot = cnt = 0;
		for(int i = 0; i <= n; ++i) head[i] = -1;
	}
	void add(int u, int v){
		to[tot] = v;
		nx[tot] = head[u];
		head[u] = tot++;
	}
	void dfs1(int u,int f){//初始化dep son sz fa，找出重儿子
		dep[u] = dep[f] + 1; fa[u] = f; sz[u] = 1;
		son[u] = 0;
		for(int i = head[u]; ~i; i = nx[i]){
		    int v = to[i];
		    if(v == f) continue;
		    dfs1(v, u);
		    sz[u] += sz[v];
		    if(sz[v] > sz[son[u]]) son[u] = v;
		}
	}
	void dfs2(int u,int topf){//树刨 初始化id wt top
		id[u] = ++cnt;
		wt[cnt] = w[u];
		top[u] = topf;
		if(!son[u]) return;
		dfs2(son[u], topf);
		for(int i = head[u]; ~i; i = nx[i]){
		    int v = to[i];
		    if(v == fa[u] || v == son[u]) continue;
		    dfs2(v, v);
		}
	}
	int lowbit(int x)
    {
        return x&(-x);
    }

    void ADD(int p,int v)
    {
        for(int i=p;i<=n;i+=lowbit(i))
            tree[i]+=v;
    }

    int SUM(int p)
    {
        int ret=0;
        for(int i=p;i;i-=lowbit(i))
            ret+=tree[i];
        return ret;
    }


    void Change(int u,int v,int K)
    {
        int f1=top[u],f2=top[v];
        while(f1!=f2)
        {
            if(dep[f1]<dep[f2])
            {
                swap(f1,f2);
                swap(u,v);
            }
            ADD(id[f1],K);
            ADD(id[u]+1,-K);
            u=fa[f1];
            f1=top[u];
        }
        if(dep[u]<dep[v]) swap(u,v);
        ADD(id[v],K);
        ADD(id[u]+1,-K);
    }

};
Heavy_Light_Decomposition<int>hld;//模板
int main(){

	while(scanf("%d%d%d", &n, &p, &m)!=EOF)
    {
        r=1;
        hld.init(n);
        for(int i = 1; i <= n; ++i){
            scanf("%d", &hld.w[i]);
        }
        for(int i = 1; i <= p; ++i){
            int u, v; scanf("%d%d", &u, &v);
            hld.add(u, v);
            hld.add(v, u);
        }
        hld.dfs1(r, 0);
        hld.dfs2(r, r);
        memset(hld.tree,0,sizeof(hld.tree));

        for(int i=1;i<=n;i++)
        {
            hld.ADD(hld.id[i],hld.w[i]);
            hld.ADD(hld.id[i]+1,-hld.w[i]);
        }
        for(int i = 1; i <= m; ++i){
            int id, x, y, z;
            char str[5];
            //getchar();
            scanf("%s", str);
            if(str[0] == 'I'){
                scanf("%d%d%d", &x, &y, &z);
                hld.Change(x, y, z);
            }
            else if(str[0] == 'Q'){
                scanf("%d", &x);
                printf("%d\n", hld.SUM(hld.id[x]));
            }
            else if(str[0] == 'D'){
                scanf("%d%d%d", &x, &y, &z);
                hld.Change(x, y, -z);
            }
        }
    }

}

Housewife Wind
题解：树刨，边化点
模板开太大…没有意识到，然后就疯狂的TTTTT，以及不要用 v e c t o r vector vector，慢的要死

#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 2e5+10;
int mod = 1e9+7;
int n, m, r, p;
template<typename T>
struct Heavy_Light_Decomposition{
	//head u的子节点编号，to 子节点， nx 下一子节点的编号
	int head[N], to[N], nx[N], tot, cnt;
	//dep 深度，fa 父亲 ，sz 子树大小 ，son 儿子 ，w权值
	int dep[N], fa[N], sz[N], son[N], w[N];
	//top 重儿子的祖先 ，id 刨分后的编号 ，wt 刨分后的权值
	int top[N], id[N], wt[N];
	//val 维护区间和 ，lz lazy标记
	T val[N<<2], lz[N<<2];
	void init(int n){
		tot = cnt = 0;
		for(int i = 0; i <= n; ++i) head[i] = -1;
	}
	void add(int u, int v){
		to[tot] = v;
		nx[tot] = head[u];
		head[u] = tot++;
	}
	void dfs1(int u,int f){//初始化dep son sz fa，找出重儿子
		dep[u] = dep[f] + 1; fa[u] = f; sz[u] = 1;
		for(int i = head[u]; ~i; i = nx[i]){
		    int v = to[i];
		    if(v == f) continue;
		    dfs1(v, u);
		    sz[u] += sz[v];
		    if(sz[v] > sz[son[u]]) son[u] = v;
		}
	}
	void dfs2(int u,int topf){//树刨 初始化id wt top
		id[u] = ++cnt;
		wt[cnt] = w[u];
		top[u] = topf;
		if(!son[u]) return;
		dfs2(son[u], topf);
		for(int i = head[u]; ~i; i = nx[i]){
		    int v = to[i];
		    if(v == fa[u] || v == son[u]) continue;
		    dfs2(v, v);
		}
	}
	void pushup(int rt){
		val[rt] = val[rt<<1] + val[rt<<1|1];
		val[rt] %= mod;
	}
	void build(int rt, int l, int r){
		if(l == r){
		    val[rt] = wt[l];
		    val[rt] %= mod;
		    return ;
		}
		int mid = (l+r) >> 1;
		build(rt<<1, l, mid);
		build(rt<<1|1, mid+1, r);
		pushup(rt);
	}
	T query(int rt, int l, int r, int L, int R){
		if(L <= l && R >= r){
		    return val[rt];
		}
		int mid = (l+r) >> 1; T  ans = 0;
		//pushdown(rt, l, r);
		if(L <= mid) ans += query(rt<<1, l, mid, L, R), ans %= mod;
		if(R > mid) ans += query(rt<<1|1, mid+1, r, L, R), ans %= mod;
		pushup(rt);
		return ans;
	}
	T queryRange(int l, int r){//查询l，r的最短路路径和
		T ans = 0;
		while(top[l] != top[r]){
		    if(dep[top[l]] < dep[top[r]]) swap(l, r);
		    ans += query(1, 1, n, id[top[l]], id[l]);
		    ans %= mod;
		    l = fa[top[l]];
		}
		/********边化为点***********/
		if(l == r) return ans;///特判不移动
		if(dep[l]>dep[r]) swap(l, r);
		///由于边变成点，改为id[son[l]]
		ans += query(1, 1, n, id[son[l]], id[r]);
		return ans%mod;
	}
	void update(int rt, int l, int r, int L, int R, int x){
		if(L <= l &&R >= r){
		    //lz[rt] += x; lz[rt] %=mod;
		    val[rt] = 1LL*x%mod;
		    val[rt] %=mod;
		    return ;
		}
		int mid = (l+r)>>1;
		//pushdown(rt, l, r);
		if(L <= mid) update(rt<<1, l, mid, L, R, x);
		if(R > mid) update(rt<<1|1, mid+1, r, L, R, x);
		pushup(rt);
	}
	//修改l，r的最短路径的权值
	void updateRange(int l, int r, int x){
		while(top[l] != top[r]){
		    if(dep[top[l]] < dep[top[r]]) swap(l, r);
		    update(1, 1, n, id[top[l]], id[l], x);
		    l = fa[top[l]];
		}
		if(dep[l]>dep[r]) swap(l, r);
		update(1, 1, n, id[l], id[r], x);
	}
};

struct note
{
    int u,v,w;
}h[N];

Heavy_Light_Decomposition<int>hld;//模板
int main(){
	scanf("%d%d%d", &n, &m, &p);
	r=1;
	hld.init(n);
	for(int i = 1; i < n; ++i){
		int u, v,w; scanf("%d%d%d", &u, &v,&w);
		h[i].u=u,h[i].v=v,h[i].w=w;
		hld.add(u, v);
		hld.add(v, u);
	}
	hld.dfs1(r, 0);
	hld.dfs2(r, r);
	hld.build(1, 1, n);
	int xx;
	for(int i=1;i<n;i++){///比较一条边上哪个点的深度大，就把权值加在哪个点上
         if(hld.dep[h[i].u]<hld.dep[h[i].v]) xx=h[i].v;
         else xx=h[i].u;
         hld.updateRange(xx,xx,h[i].w);
     }
	for(int i = 1; i <= m; ++i){
		int id, x, y, z;
		//getchar();
		scanf("%d", &id);
		if(id == 1){
			scanf("%d%d", &x, &y);
			if(hld.dep[h[x].u]<hld.dep[h[x].v]) xx=h[x].v;
            else xx=h[x].u;
            hld.updateRange(xx,xx,y);
		}
		else if(id == 0){
			scanf("%d", &x);
			printf("%d\n", hld.queryRange(x, p));
			p=x;
		}
	}
	return 0;
}

B - Valid Sets
题意：
给定一棵树，任意选定节点，节点间是联通的（也可以是同一个节点），使这些个点的路径上的点中最大值和最小值小于 d d d
题解：树形 d p dp dp
枚举节点作为最大节点，然后遍历它所控制的范围计算符合条件的方案数

#include<bits/stdc++.h>
#define mp make_pair
#define maxn 10000000
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef long double ld;

const int N=1e6+10;
const int MAXN=20010;
const int INF=0x3f3f3f3f;
const double eps=0.0000001;
const ll mod=998244353 ;
int n,m,x,y,k,cnt;

int d,a[maxn],root;
const int MOD=1e9+7;
vector<int>G[maxn];
long long dfs(int u,int fa)
{
	long long res=1;
	int v;
	for(int i=0;i<(int)G[u].size();i++)
	{
		v=G[u][i];
		if(v==fa)///单向
			continue;
		if(a[v]>a[root])///使得root最大，不需要考虑最小值
			continue;
		if(a[v]==a[root]&&v>root)///避免重复
			continue;
		if(a[root]-a[v]>d)///最小的节点都满足的话其他值都满足
			continue;
		res=res*(dfs(v,u)+1)%MOD;///计算子树的数目
	}
	return res;
}
int main()
{
	ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
	scanf("%d%d",&d,&n);
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	for(int i=1;i<=n-1;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		G[x].push_back(y);
		G[y].push_back(x);
	}
	long long ans=0;
	///枚举每个结点，把每个节点都当作最大节点来进行计算
	for(int i=1;i<=n;i++)
	{
		root=i;
		ans=(ans+dfs(root,-1))%MOD;
	}
	printf("%I64d\n",ans);
	//system("pause");
	return 0;
}

D. Choosing Capital for Treeland
题意：
这道题给出n个节点的树，其中的边是有向边，让你从其中选择一个节点，使得从该节点出发能够到达其他所有节点，中途可以改变边的方向，但需要使改变的次数最少。
题解：树形 d p dp dp
先预处理一个点 u u u，将 u u u 点作为根进行遍历，记录反向的个数 w w w
会发现一个很有趣的规律；
当将其他结点v 作为根时的反向边的个数为 n n n
n = w − 2 ∗ ( u 到 v 路 径 上 的 反 向 边 ) + ( u 到 v 路 径 长 度 ) n=w -2*(u到v路径上的反向边)+ (u到v路径长度) n=w−2∗(u到v路径上的反向边)+(u到v路径长度)
然后找出所有节点的最小值就可以了

#include<bits/stdc++.h>
#define mp make_pair
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef long double ld;

const int N=1e6+10;
const int MAXN=20010;
const int INF=0x3f3f3f3f;
const double eps=0.0000001;
const ll mod=998244353 ;
int n,m,x,y,k,cnt;

struct note
{
    int u,v,w;
}h;

vector<note>E[N];
int dp[N],dep[N],ans[N],pop=INF;

void dfs1(int x,int fa)
{
    dep[x]=dep[fa]+1;
    for(int i=0;i<E[x].size();i++)
    {
        note y;
        y=E[x][i];
        if(y.v==fa) continue;
        if(y.w<0) cnt++;
        dp[y.v]=dp[y.u]+((y.w==-1)?1:0);///被三元符坑了忘记加括号...
        dfs1(y.v,y.u);
    }
}

int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    scanf("%d", &n);
    for(int i=0;i<n-1;i++)
    {
          int u,v;
          scanf("%d%d",&u,&v);
          h.u=u,h.v=v,h.w=1;
          E[u].push_back(h);
          h.u=v,h.v=u,h.w=-1;
          E[v].push_back(h);
    }
    dep[0]=-1;
    dfs1(1,0);
    ans[1]=cnt;
    pop=min(pop,ans[1]);
    for(int i=2;i<=n;i++)
    {
        ans[i]=ans[1]-2*dp[i]+dep[i];
        pop=min(pop,ans[i]);
        //printf("%d\n",dp[i]);
    }
    printf("%d\n",pop);
    for(int i=1;i<=n;i++)
    {
        if(pop==ans[i])
            printf("%d ",i);
    }




}
THE END GAME
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】树链剖分
Video_game的博客
12-11 1168
树链剖分
树链剖分
andyc_03的博客
04-17 1664
【算法介绍】 树链剖分就是将树分割成多条链，然后利用数据结构（线段树、树状数组等）来维护这些链。 当树的形态不发生改变的时候，我们可以先对其进行链的剖分，每条链就相当于一个序列，操作就可以被拆分成几条完整的链来解决，然后利用一些数据结构加以维护即可。 我们希望通过这样的方式，来达到一些树上修改、计算的目的 【算法流程】 轻重链剖分 概念引入：把一个节点u的所有儿子中size[v]最大的一个作为重儿子，则称(u,v)为重边，u到其余的儿子v'的边(u,v')为轻边。 性质：(u,v)为轻边.
树链剖分（重链剖分）
最新发布
weixin_55851276的博客
07-07 521
一.什么是树链剖分       树剖是通过某些特殊的划分方法，将树上的节点划分到 不同 的链中，并且保证同一条链上的各个节点的 dfs序 连续，这样就可以用 线段树 对每一条链进行维护。从而方便解决 树上单条路径的查询和修改 问题。需注意：在使用树剖时树的形态不可以变化，只能改变路径上节点的信息 。树剖的核心在于 通过特殊的 划分方式 将 树上路径问题 转化为 区间 问题      树剖一般解决的问题： 树
算法自学——树链剖分
MaTF_的博客
08-05 490
树链剖分就是将一棵树划分成若干条链。
NOIP 树链剖分 NOIP 树链剖分
10-30
NOIP 树链剖分 NOIP 树链剖分
第5章 树链剖分 测试数据.rar
12-02
树链剖分是一种高效处理树型结构的算法，尤其在解决与树的边查询和修改有关的问题时，它能提供显著的效率提升。这一技术在信息学奥赛中经常被用到，帮助参赛者快速解决复杂的树形问题。在本章的测试数据中，你将有...
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
树链剖分模板题
05-19
#include #include #include #define N 30003 #define INF 2147483647 using namespace std; int n,f[N][20],dep[N],siz[N],son[N],top[N],tot,pos[N],w[N]; int Max[N*4],Sum[N*4];...vector <int> to[N];...
NOIP树链剖分习题讲解报告
11-01
P2590 [ZJOI2008]树的统计 P3384 【模板】轻重链剖分/树链剖分 P3950 部落冲突 P4092 [HEOI2016/TJOI2016]树 P2146 [NOI2015] 软件包管理器
树链剖分总结
ZhuRanCheng的博客
05-22 587
树链剖分总结
树链剖分（超详细！！！）
anglanjing7414的博客
08-17 1031
一、轻重边剖分的过程 使用两次dfs来实现。剖分过程中要计算如下7个值： father[x]:x在树中的父亲 size[x]:x的子树结点数(子树大小) dep[x]:x在树中的深度 son[x]:x的重儿子，即为重边 top[x]:x所在重路径的顶部结点(深度最小) seg[x]:x在线段树中的位置(下标) rev[x]:线段树中第x个位置对应的树中结点编号，即rev[...
[模版] 树链剖分
HeartWine的博客
10-24 154
树链剖分是解决树上问题的一种常见数据结构，对于树上路径修改及路径信息查询等问题有着较优的复杂度。树链剖分分为两种：重链剖分和长链剖分，通常说的树链剖分指的是重链剖分。 一些名词: 重儿子：每个点的子树中，子树大小(即节点数)最大的子节点（如果有多个节点，任选一个） 轻儿子：除重儿子外的其他子节点 重边：每个节点与其重儿子间的边 轻边：每个节点与其轻儿子间的边 重链：重边连成的链 轻链：轻边连成的链 剖分后的树有一个性质：从根到某一点的路径上轻链、重链的个数都不大于lognlognlogn。 树链剖分就是将树
树链剖分详解
热门推荐
a_forever_dream的博客
07-09 1万+
树链剖分，正如其名，这个算法的主要思想就是 把“树”“剖分”成“链” 那怎么实现以及它的作用是什么呢，以洛谷上的模板题为例子： 已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短...
专题·树链剖分【including 洛谷·【模板】树链剖分
樱狸✨愿携清风归来处
05-03 6332
初见安~~~终于学会了树剖~~~ 【兴奋】当初机房的大佬在学树剖的时候我反复强调过：“学树剖没有前途的！！！” 恩。真香。 一、重链与重儿子 所谓树剖——树链剖分，就是赋予一个链的概念来优化一些或者说是应对一些操作的，所以相应的会有一些专用的概念定义。 一个节点的重儿子，为其更大的一颗子树的根节点。从这个点连向重儿子的边我们称为重边。 这里我们定义子树的大小是取决于节点的数量，而...
树链剖分(初学)
weixin_43823476的博客
09-19 156
首先看一下树链剖分是什么东西： 当我们要同时解决以下两个问题时： 1.求树上两点简单路径上的最大最小值(和） 2.修改树上两点简单路径上的边权(点权) 如果只用单独考虑，那么第一个就是树上差分，第二个是倍增，可是如果同时要有两个操作，那么时间复杂度就会大幅度退化，所以现在要用一个新的方法：树链剖分 它将一棵树剖成了几条链来组成，且每个点最多只会存在一条链上，且只出现一次。那么怎么进行剖分...
模板 补充1
08-08
这篇文档主要涵盖了几个重要的图论和动态规划相关的算法，包括SG打表、树链剖分、树形DP、状态压缩DP以及数论公式的一些补充内容，如素数个数和最大团问题。以下是这些知识点的详细说明： 1. SG打表 (Stable ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值