【HDU】5571 tree【动态点分治】

最新推荐文章于 2020-09-01 14:27:06 发布
最新推荐文章于 2020-09-01 14:27:06 发布
阅读量1k 收藏
点赞数 1
分类专栏： 树分治
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013368721/article/details/52994047
版权
本文解析了一道关于动态点分治的算法题，通过构建树状结构并使用动态规划来解决复杂查询问题，适用于高级算法竞赛选手学习。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题目链接：【HDU】5571 tree【动态点分治】

题目大意：给一棵 N 节点的树，每个点有点权ai，有 m 次单点点权修改，每次修改以后，输出∑Ni=1∑Nj=1(aixoraj)⋅dis(ai,dj)的值。
题目分析：考虑每一位独立做，就是所有 01 对的对数* 01 对的距离，待修改可用动态树分治维护。每个重心树下每个节点保存所属的重心，所属的重心的哪个儿子的子树，到重心的距离。

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

typedef long long LL ;

#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 30005 ;
const int MAXE = 60005 ;

struct Edge {
    int v , c , n ;
    Edge () {}
    Edge ( int v , int c , int n ) : v ( v ) , c ( c ) , n ( n ) {}
} ;

struct Node {
    int root , f , dep ;
    Node () {}
    Node ( int root , int f , int dep ) : root ( root ) , f ( f ) , dep ( dep ) {}
} ;

Edge E[MAXE] ;
int H[MAXN] , cntE ;
int Q[MAXN] , head , tail ;
vector < Node > G[MAXN] ;
int vis[MAXN] ;
int dep[MAXN] ;
int pre[MAXN] ;
int siz[MAXN] ;

int tree_cnt ;
int pos[MAXN] ;
int val[MAXN] ;
LL dis[MAXN << 1][2] ;
LL num[MAXN << 1][2] ;
LL res[MAXN] ;
int a[MAXN] ;
int n , m ;

void init () {
    cntE = 0 ;
    tree_cnt = 0 ;
    clr ( H , -1 ) ;
    clr ( vis , 0 ) ;
}

void addedge ( int u , int v , int c ) {
    E[cntE] = Edge ( v , c , H[u] ) ;
    H[u] = cntE ++ ;
}

int get_root ( int s ) {
    head = tail = 0 ;
    Q[tail ++] = s ;
    pre[s] = 0 ;
    while ( head != tail ) {
        int u = Q[head ++] ;
        for ( int i = H[u] ; ~i ; i = E[i].n ) {
            int v = E[i].v ;
            if ( vis[v] || v == pre[u] ) continue ;
            pre[v] = u ;
            Q[tail ++] = v ;
        }
    }
    int root = s , root_siz = tail ;
    while ( head ) {
        int u = Q[-- head] , cnt = 0 ;
        siz[u] = 1 ;
        for ( int i = H[u] ; ~i ; i = E[i].n ) {
            int v = E[i].v ;
            if ( vis[v] || v == pre[u] ) continue ;
            siz[u] += siz[v] ;
            if ( cnt < siz[v] ) cnt = siz[v] ;
        }
        cnt = max ( cnt , tail - siz[u] ) ;
        if ( cnt < root_siz ) {
            root_siz = cnt ;
            root = u ;
        }
    }
    return root ;
}

void calc ( int s , int d , int f , int root ) {
    head = tail = 0 ;
    dep[s] = d ;
    pre[s] = 0 ;
    Q[tail ++] = s ;
    while ( head != tail ) {
        int u = Q[head ++] ;
        G[u].push_back ( Node ( root , f , dep[u] ) ) ;
        for ( int i = H[u] ; ~i ; i = E[i].n ) {
            int v = E[i].v ;
            if ( vis[v] || v == pre[u] ) continue ;
            pre[v] = u ;
            dep[v] = dep[u] + E[i].c ;
            Q[tail ++] = v ;
        }
    }
}

void dfs ( int u ) {
    int root = get_root ( u ) ;
    vis[root] = 1 ;
    calc ( root , 0 , 1 , ++ tree_cnt ) ;
    for ( int i = H[root] ; ~i ; i = E[i].n ) {
        if ( !vis[E[i].v] ) calc ( E[i].v , E[i].c , -1 , ++ tree_cnt ) ;
    }
    for ( int i = H[root] ; ~i ; i = E[i].n ) {
        if ( !vis[E[i].v] ) dfs ( E[i].v ) ;
    }
    vis[root] = 0 ;
}

void solve () {
    int u , v , c ;
    init () ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        scanf ( "%d" , &a[i] ) ;
        a[i] <<= 1 ;
        G[i].clear () ;
    }
    for ( int i = 1 ; i < n ; ++ i ) {
        scanf ( "%d%d%d" , &u , &v , &c ) ;
        addedge ( u , v , c ) ;
        addedge ( v , u , c ) ;
    }
    scanf ( "%d" , &m ) ;
    for ( int i = 1 ; i <= m ; ++ i ) {
        scanf ( "%d%d" , &pos[i] , &val[i] ) ;
        val[i] <<= 1 ;
        res[i] = 0 ;
    }
    dfs ( 1 ) ;
    for ( int o = 0 ; o < 14 ; ++ o ) {
        for ( int i = 1 ; i <= tree_cnt ; ++ i ) {
            dis[i][0] = dis[i][1] = 0 ;
            num[i][0] = num[i][1] = 0 ;
        }
        LL ans = 0 ;
        for ( int i = 1 ; i <= n ; ++ i ) {
            int v = ( a[i] >>= 1 ) & 1 ;
            for ( int j = 0 ; j < G[i].size () ; ++ j ) {
                Node x = G[i][j] ;
                ans += x.f * ( x.dep * num[x.root][v ^ 1] + dis[x.root][v ^ 1] ) ;
                dis[x.root][v] += x.dep ;
                num[x.root][v] ++ ;
            }
        }
        for ( int i = 1 ; i <= m ; ++ i ) {
            int v1 = a[pos[i]] & 1 ;
            int v2 = ( val[i] >>= 1 ) & 1 ;
            if( v1 != v2 ) {
                for ( int j = 0 ; j < G[pos[i]].size () ; ++ j ) {
                    Node x = G[pos[i]][j] ;
                    ans -= x.f * ( x.dep * num[x.root][v1 ^ 1] + dis[x.root][v1 ^ 1] ) ;
                    dis[x.root][v1] -= x.dep ;
                    num[x.root][v1] -- ;
                    ans += x.f * ( x.dep * num[x.root][v2 ^ 1] + dis[x.root][v2 ^ 1] ) ;
                    dis[x.root][v2] += x.dep ;
                    num[x.root][v2] ++ ;
                }
                a[pos[i]] ^= v1 ^ v2 ;
            }
            res[i] += ans * ( 1 << o ) ;
        }
    }
    for ( int i = 1 ; i <= m ; ++ i ) {
        printf ( "%lld\n" , res[i] ) ;
    }
}

int main () {
    while ( ~scanf ( "%d" , &n ) ) solve () ;  
    return 0 ;
}

压缩后代码：

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

typedef long long LL;

#define clr(a,x) memset(a,x,sizeof a)

const int MAXN=30005;
const int MAXE=60005;

struct Edge{
    int v,c,n;
    Edge(){}
    Edge(int v,int c,int n):v(v),c(c),n(n){}
};

struct Node{
    int rt,f,dep;
    Node(){}
    Node(int rt,int f,int dep):rt(rt),f(f),dep(dep){}
};

Edge E[MAXE];
int H[MAXN],cntE;
int Q[MAXN],head,tail;
vector<Node>G[MAXN];
int vis[MAXN],dep[MAXN],pre[MAXN],siz[MAXN],cnt[MAXN],pos[MAXN],val[MAXN],tcnt;
LL dis[MAXN<<1][2],num[MAXN<<1][2],res[MAXN];
int a[MAXN],n,m;
void init(){
    cntE=tcnt=0;
    clr(H,-1),clr(vis,0);
}
void addedge(int u,int v,int c){
    E[cntE]=Edge(v,c,H[u]);
    H[u]=cntE++;
}
int get_rt(int s){
    int u,v,i,rt=s,l=0,r=0;
    for(l=pre[Q[0]=s]=0,r=1;l!=r;){
        for(v=E[i=H[u=Q[l++]]].v;~i;v=E[i=E[i].n].v)if(!vis[v]&&v!=pre[u]){
            pre[Q[r++]=v]=u;
            siz[v]=1,cnt[v]=0;
        }
    }
    for(int sz=r,u=Q[l-1];l--;u=Q[l-1]){
        siz[pre[u]]+=siz[u];
        if(cnt[pre[u]]<siz[u])cnt[pre[u]]=siz[u];
        cnt[u]=max(cnt[u],r-siz[u]);
        if(cnt[u]<sz)sz=cnt[u],rt=u;
    }
    return rt;
}
void calc(int s,int d,int f,int rt){
    int l,r,u,v,i;
    for(l=r=pre[s]=0,dep[Q[r++]=s]=d;l!=r;){
        G[Q[l]].push_back(Node(rt,f,dep[Q[l]]));
        for(v=E[i=H[u=Q[l++]]].v;~i;v=E[i=E[i].n].v){
            if(!vis[v]&&v!=pre[u])dep[v]=dep[pre[Q[r++]=v]=u]+E[i].c;
        }
    }
}
void dfs(int u){
    int rt=get_rt(u);
    vis[rt]=1;
    calc(rt,0,1,++tcnt);
    for(int i=H[rt];~i;i=E[i].n)if(!vis[E[i].v])calc(E[i].v,E[i].c,-1,++tcnt);
    for(int i=H[rt];~i;i=E[i].n)if(!vis[E[i].v])dfs(E[i].v);
    vis[rt]=0;
}
void solve(){
    int u,v,c;
    init();
    for(int i=1;i<=n;G[i].clear(),a[i]<<=1,++i)scanf("%d",&a[i]);
    for(int i=1;i<n;++i){
        scanf("%d%d%d",&u,&v,&c);
        addedge(u,v,c);
        addedge(v,u,c);
    }
    scanf("%d",&m);
    for(int i=1;i<=m;val[i]<<=1,res[i]=0,++i)scanf("%d%d",&pos[i],&val[i]);
    dfs(1);
    for(int o=0;o<14;++o){
        for(int i=1;i<=tcnt;++i){
            dis[i][0]=dis[i][1]=0;
            num[i][0]=num[i][1]=0;
        }
        LL ans=0;
        for(int i=1;i<=n;++i){
            int v=(a[i]>>=1)&1;
            for(int j=0;j<G[i].size();++j){
                Node x=G[i][j];
                ans+=x.f*(x.dep*num[x.rt][v^1]+dis[x.rt][v^1]);
                dis[x.rt][v]+=x.dep;
                num[x.rt][v]++;
            }
        }
        for(int i=1;i<=m;++i){
            int v1=a[pos[i]]&1;
            int v2=(val[i]>>=1)&1;
            if(v1!=v2){
                for(int j=0;j<G[pos[i]].size();++j){
                    Node x=G[pos[i]][j];
                    ans-=x.f*(x.dep*num[x.rt][v1^1]+dis[x.rt][v1^1]);
                    dis[x.rt][v1]-=x.dep;
                    num[x.rt][v1]--;
                    ans+=x.f*(x.dep*num[x.rt][v2^1]+dis[x.rt][v2^1]);
                    dis[x.rt][v2]+=x.dep;
                    num[x.rt][v2]++;
                }
                a[pos[i]]^=v1^v2;
            }
            res[i]+=ans*(1<<o);
        }
    }
    for(int i=1;i<=m;++i){
        printf("%lld\n",res[i]);
    }
}
int main(){
    while(~scanf("%d",&n))solve();
    return 0;
}
动态点分治详解
tylon2006的博客
12-07 495
动态点分治大意：利用没有树结构修改的性质预处理重心树优化时间 其实就是很暴力的思想，因为树的结构不变，所以每一次找到的重心都一样，可以用一次点分树预处理一下点分治的重心，再连接相邻的重心便是点分树。 前置知识：点分治 见另一篇blog： 算法： 好像就没什么了，上面就是全过程 详细一点的分析： 找到当前子树重心x 深搜x的每一个儿子的子树，找到每一棵子树的重心y（两个重心的话随便取一个） 对...
hdu 4871 Shortest-path tree(最短路+点分治)
绝望的乐园
07-24 1589
题意：给出一个n个点，m条边的图，先求最短路，使得
hdu-5571 tree
140142
11-23 1178
题意： 给出一个n个结点的树，有点权a[x]和边权val(x,y)； 现有m次修改某个点的点权； 求每次操作后它所有结点对(x,y)之间的(a[x] xor a[y])*dis(x,y)； 其中dis(x,y)指两点间距离； n 题解： 感觉上周的BC好奇怪啊。。。A上来就高精度没模板打个卵，B题SB题； 写完AB感觉药丸于是果断去看D，仔细一看卧槽。。。于是颓了一个小时C
hdu 5571 tree （动态点分治）
clover_hxy的博客
04-21 472
题目描述传送门题目大意：给出一棵n个节点的树，每个点有一个权值aia_i,一个点对(i,j)i<j(i,j) i<j的贡献为(ai xor aj)∗dis(i,j)(a_i \space xor \space a_j)*dis(i,j)，求每次修改一个节点后树中所有点对的贡献和。题解带修改的路径问题很适合用动态点分治来做。 这道题如果我们直接考虑ai xor aja_i \space xor \
动态点分治
weixin_33843409的博客
02-24 293
大概就是把点分树建出来，维护每个点的信息和全局信息。 修改的时候考虑一个点对它点分树祖先的影响。 树上与距离有关的问题，考虑动态点分治。 例题： 洛谷P2056 捉迷藏 带修树上最远黑色点对。 这道题难点根本不在动态点分治，完全在于堆(们)好吧！！！我被这三种堆虐的死去活来，然后又T飞...换了O(1)lca才过。 1 struct PQ { 2 std::pr...
【点分治总结】
ＡＴＯＤ
05-13 5531
点分治教程：例题 给定一棵带权树，显然共有N*(N-1)/2条边，问：第k小的边边长多长？ N<=10000.题解： 这道题直接上手做实在是太难了，需要逐步拆分。 首先，问题是第k小的边的边长，这个问题不好解，但是转换一下问题，二分第k小的边长T，然后判断这棵树中<=T的路径有多少条，这个能稍微好做一下，至少变成了一个统计性问题。 二分后题目变成： 给定一棵带权树，显然共有N*(N-1)
hdu题目分类
12-16
从给定的信息来看，这是一份关于杭州电子科技大学（简称杭电）在线编程平台HDU Online Judge（简称HDOJ）的题目分类列表。这份列表为新手提供了按类别刷题的指南，帮助他们系统地提升算法和编程能力。下面，我们将...
2020 Multi-University Training Contest 2---- HDU--6770、Dynamic Convex Hull （离线、分治）
_Griefs
09-01 401
题目连接 题面： 题意： 有一个四次函数的集合 fi(x)=(x−ai)4+bif_i(x)=(x-a_i)^4+b_ifi​(x)=(x−ai​)4+bi​。 有以下三种操作 （1）111 aaa bbb ，往集合中添加新的四次函数 fn+1=(x−a)4+bf_{n+1}=(x-a)^4+bfn+1​=(x−a)4+b，然后n=n+1n=n+1n=n+1 （2）222 ttt ，从集合中删除 ft(x)f_t(x)ft​(x) （3）333 xxx ，在当前集合中询问 fi(x)f_i(x)fi
HDU题目分类大全【大集合】
欢迎来到扣子不会飞的博客！
03-18 3810
基础题： 1000、1001、1004、1005、1008、1012、1013、1014、1017、1019、1021、1028、1029、 1032、1037、1040、1048、1056、1058、1061、1070、1076、1089、1090、1091、1092、1093、 1094、1095、1096、1097、1098、1106、1108、1157、1163、1164、1170、...
HDU - 6104 Influence 动态点分治
weixin_30266885的博客
09-18 120
HDU - 6104 非常恶心的一道题， 维护的东西和幻想乡战略游戏差不多， 不过不同的是它的边权会变， 并且一个操作的贡献不会因为边权的改变而改变， 我们先考虑改变边权的时候不改变d1, d2数组， 那么在query进行u 和 fa[u]合并的时候， 那个边权会多加东西， 我们考虑改变边权的时候把多加的减掉就ok了， 也就是多维护一个del 的 树状数组。 #pragm...
动态点分治题表
weixin_30951389的博客
01-26 97
bzoj1095:[ZJOI2007]Hide 捉迷藏 板子+堆/setbzoj3924:[Zjoi2015]幻想乡战略游戏 板子bzoj4012:[HNOI2015]开店 板子bzoj3435:[Wc2014]紫荆花之恋 板子+替罪羊思想 转载于:https://www.cnblogs.com/TSHugh/p/8357975.html...
【Luogu3676】小清新数据结构题（动态点分治）
小蒟蒻yyb的博客
07-16 275
题面 洛谷 题解 先扯远点，这题我第一次看的时候觉得是一个树链剖分+线段树维护。 做法大概是这样： 我们先以任意一个点为根，把当前点看成是一棵有根树。比方说以111为根。 那么，在询问以ppp为根的时候的答案，我们看看哪些子树发生了变化。 发现真正会产生变化的只有1..p1..p1..p这条链上的所有点，其它点的贡献和以111为根时的贡献是一样的。 考虑这条链上的所有点的贡献变...
hdu5571 tree
YHaX的博客
05-31 370
动态点分治
图论：动态点分治
weixin_30514745的博客
09-10 131
一般如果需要大规模处理树上路径，点分治是一个不错的选择 在解决树上路径满足某种属性的数量统计方面有着很大的作用 点分治的核心抄dalao的两句话： 1.对于端点是自己子树上的任意一条路径，它要么经过自己，要么在自己的某个子树中 2.获取树的重心来把树的深度从O（n）变到O（logn） 然后稍微说一说动态点分治，在原来点分治的基础上，添加一个fa数组 我们相当于通过fa数组重建...
HDU ACM教程系列之动态规划深度解析
- **知识点一：HDU的含义**：HDU指的是杭州电子科技大学（Hangzhou Dianzi University）的英文缩写。杭州电子科技大学是一所以电子信息学科为特色，以工为主，经、管、文、法、理、教等多学科协调发展的高校，其ACM...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值