动态点分治总结

最新推荐文章于 2024-10-05 20:01:36 发布
最新推荐文章于 2024-10-05 20:01:36 发布
阅读量70 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/xzz_233/p/8301050.html
版权

动态点分治总结

下面是伟大の分割线！
上面是伟大の分割线！

废话

再开一坑。

刷几道题来填。

才刷两题，慢慢补吧。。。。

（这玩意是真的神，调死你

警告：这篇文章中的代码都很丑陋！

下面是伟大の分割线！
上面是伟大の分割线！

思想

前置技能：点分治。

动态点分治就是带修改的点分治。

如果每次单点修改之后重新点分治一遍，被影响到的节点最多\(\log_2n\)个。

然后就有了动态点分治。。。。

点分树

我也不知道这个叫什么反正就是一颗新树。。。

构建方法大概就是点分治solve的时候顺便搞出，它就是solve时的搜索树（？）

可以证明那玩意深度是严格\(\log_2n\)的。

如果修改一个点，只需在对应点分树上修改（暴跳父亲，慢慢修改）

查询也可以暴跳父亲，但有些题不用

下面是伟大の分割线！
上面是伟大の分割线！

例题

cogs2036 捉迷藏

查询最长链。

要维护三种堆= =不看题解写不出= = = = = = = = =

（其实应该是multiset= =但是能用堆来模拟）

首先每个点维护一个堆1，是子树到这个点的距离。（“子树”是点分树，“距离”是原树上的距离）

再维护一个堆2，是所有子树的堆1堆顶

再全局维护一个堆3，是所有点堆2的最大和次大（这里要讨论一下，如果这个点是黑色的，少了的元素用0补上；如果是白色的堆又没有两个元素，就是0）

真•奇丑无比

// It is made by XZZ
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
#include<vector>
#define il inline
#define rg register
#define vd void
#define sta static
typedef long long ll;
using namespace std;
il int gi(){
    rg int x=0,f=1;rg char ch=getchar();
    while(ch<'0'||ch>'9')f=ch=='-'?-1:f,ch=getchar();
    while(ch>='0'&&ch<='9')x=x*10+ch-'0',ch=getchar();
    return x*f;
}
const int maxn=100001; 
#define queue priority_queue
struct Queue{
    queue<int>que,del;
    il int siz(){return que.size()-del.size();}
    il int top(){
        if(siz()<1)return 0;
        while(!del.empty()&&que.top()==del.top())que.pop(),del.pop();
        return que.top();
    }
    il vd pop(int x){del.push(x);}
    il vd push(int x){que.push(x);}
};
int n,q,fir[maxn],dis[maxn<<1],nxt[maxn<<1],col[maxn],dep[maxn],id;
il vd link(int x,int y){nxt[++id]=fir[x],fir[x]=id,dis[id]=y;}
Queue que[maxn],Que[maxn],QUE;
int siz[maxn],f[maxn],rt,vis[maxn],sum,FAQ[maxn];
il vd getrt(int x,int FA){
    f[x]=0;siz[x]=1;
    for(int i=fir[x];i;i=nxt[i]){
        if(vis[dis[i]]||FA==dis[i])continue;
        getrt(dis[i],x);
        siz[x]+=siz[dis[i]];
        f[x]=max(f[x],siz[dis[i]]);
    }
    f[x]=max(f[x],sum-siz[x]);
    if(f[x]<f[rt])rt=x;
}
il vd Getrt(int x,int _sum){sum=_sum,rt=0,f[0]=2e9,getrt(x,-1);}
vector<int>S[maxn];int Root;
il vd solve(int x){
    vis[x]=1;
    for(int i=fir[x];i;i=nxt[i]){
        if(vis[dis[i]])continue;
        Getrt(dis[i],siz[dis[i]]);
        FAQ[rt]=x;S[x].push_back(rt);
        solve(rt);
    }
}
int st[17][maxn];
il vd Getdep(int x,int FA=-1){
    for(int i=fir[x];i;i=nxt[i]){
        if(FA==dis[i])continue;
        dep[dis[i]]=dep[x]+1;
        st[0][dis[i]]=x;
        Getdep(dis[i],x);
    }
}
il int dist(int x,int y){
    int ret=dep[x]+dep[y],cha=dep[x]-dep[y];
    if(dep[x]<dep[y])cha=-cha,swap(x,y);
    for(int i=16;~i;--i)if(cha&(1<<i))x=st[i][x];
    for(int i=16;~i;--i)if(st[i][x]^st[i][y])x=st[i][x],y=st[i][y];
    if(x^y)x=st[0][x];
    return ret-2*dep[x];
}
il vd calc(int x,int FA,int Rt){
    que[Rt].push(dist(x,FAQ[Rt]));
    for(vector<int>::iterator i=S[x].begin();i!=S[x].end();++i){
        if(FA==*i)continue;
        calc(*i,x,Rt);
    }
}
il int Top(int x){
    sta int a,b,ret;
    a=Que[x].top();Que[x].pop(a);
    b=Que[x].top();Que[x].push(a);
    if(col[x])ret=a+b;
    else if(a&&b)ret=a+b;
    else ret=0;
    return ret;
}
il vd Solve(int x){
    calc(x,-1,x);
    for(vector<int>::iterator i=S[x].begin();i!=S[x].end();++i){
        Solve(*i);
        Que[x].push(que[*i].top());
    }
    QUE.push(Top(x));
}
int main(){
    freopen("hide.in","r",stdin);
    freopen("hide.out","w",stdout);
    n=gi();int x,y,tot=n;
    for(rg int i=1;i<=n;++i)col[i]=1;
    for(rg int i=1;i<n;++i)x=gi(),y=gi(),link(x,y),link(y,x);
    Getrt(1,n),Root=rt,solve(rt);
    dep[1]=0,Getdep(1);
    for(rg int i=1;i<17;++i)
        for(rg int j=1;j<=n;++j)
            st[i][j]=st[i-1][st[i-1][j]];
    Solve(Root);
    q=gi();char opt[5];
    while(q--){
        scanf("%s",opt);
        if(opt[0]=='G'){
            if(tot<2)printf("%d\n",tot-1);
            else printf("%d\n",QUE.top());
        }
        else{
            x=gi();y=1;
            for(rg int i=x;i;i=FAQ[i]){
                if(FAQ[i])QUE.pop(Top(FAQ[i]));
                if(FAQ[i])Que[FAQ[i]].pop(que[i].top());
                col[x]?que[i].pop(dist(FAQ[i],x)):que[i].push(dist(FAQ[i],x));
                if(FAQ[i])Que[FAQ[i]].push(que[i].top());
                if(FAQ[i])QUE.push(Top(FAQ[i]));
            }
            QUE.pop(Top(x));
            if(col[x])--tot;else++tot;
            col[x]^=1;
            QUE.push(Top(x));
        }
    }
    return 0;
}

bzoj3730 震波

每个点维护两颗线段树。。。这不看题解咋搞

第一颗存子树对这个点的贡献，下标是子树的点到这个点的距离，存的值是这些点的权值和

第二颗存子树对父亲的贡献，下标是到父亲的距离，存的是这些点的权值和

剩下都看题解写的。。。。。。

// It is made by XZZ
#include<cstdio>
#include<algorithm>
#include<cmath>
#define il inline
#define rg register
#define vd void
#define sta static
using namespace std;
il int gi(){
    rg int x=0,f=1;rg char ch=getchar();
    while(ch<'0'||ch>'9')f=ch=='-'?-1:f,ch=getchar();
    while(ch>='0'&&ch<='9')x=x*10+ch-'0',ch=getchar();
    return x*f;
}
const int maxn=100001,maxm=maxn<<1;
int n,m,lg,val[maxn];
typedef const int& cni;
namespace sgt{
    const int maxd=20000000;
    int index,root1[maxn],root2[maxn],ls[maxd],rs[maxd],sum[maxd];
#define mid ((l+r)>>1)
    il vd update(int&x,int l,int r,cni p,cni k){
        if(!x)x=++index;sum[x]+=k;
        if(l==r)return;
        if(p<=mid)update(ls[x],l,mid,p,k);
        else update(rs[x],mid+1,r,p,k);
    }
    il int query(cni x,int l,int r,cni R){
        if(!sum[x]||R<l)return 0;
        if(r<=R)return sum[x];
        return query(ls[x],l,mid,R)+query(rs[x],mid+1,r,R);
    }
}

namespace Divide{
    int fir[maxn],dis[maxm],nxt[maxm],id,rt;
    il vd link(cni x,cni y){nxt[++id]=fir[x],fir[x]=id,dis[id]=y;}
    namespace SLPF{
        int dep[maxn],fa[maxn],siz[maxn],top[maxn],son[maxn];
        il vd DFS(cni x){
            siz[x]=1;
            for(int i=fir[x];i;i=nxt[i])
                if(dis[i]^fa[x]){
                    dep[dis[i]]=dep[x]+1,fa[dis[i]]=x;
                    DFS(dis[i]);
                    siz[x]+=siz[dis[i]];
                    if(siz[dis[i]]>siz[son[x]])son[x]=dis[i];
                }
        }
        il vd DFS2(cni x,cni tp){
            top[x]=tp;
            if(son[x])DFS2(son[x],tp);
            for(int i=fir[x];i;i=nxt[i])
                if((dis[i]^fa[x])&&(dis[i]^son[x]))
                    DFS2(dis[i],dis[i]);
        }
        il int dist(int x,int y){
            int ret=dep[x]+dep[y];
            while(top[x]^top[y])
                if(dep[top[x]]>dep[top[y]])x=fa[top[x]];
                else y=fa[top[y]];
            if(dep[y]<dep[x])x=y;
            return ret-dep[x]*2;
        }
    }
    namespace DFZ{
        int f[maxn],siz[maxn],FAQ[maxn],sum,vis[maxn];
        il vd getrt(cni x,cni FA){
            f[x]=0,siz[x]=1;
            for(int i=fir[x];i;i=nxt[i]){
                if(FA==dis[i]||vis[dis[i]])continue;
                getrt(dis[i],x);
                siz[x]+=siz[dis[i]],f[x]=max(f[x],siz[dis[i]]);
            }
            f[x]=max(f[x],sum-siz[x]);
            if(f[x]<f[rt])rt=x;
        }
        il vd Getrt(cni x,cni _sum){f[0]=2e9,sum=_sum,rt=0,getrt(x,-1);}
        il vd Build(int x){
            vis[x]=1;
            for(int i=fir[x];i;i=nxt[i]){
                if(vis[dis[i]])continue;
                Getrt(dis[i],siz[dis[i]]);
                FAQ[rt]=x;Build(rt);
            }
        }
    }
    il int Query(int x,int k){
        int ret=sgt::query(sgt::root1[x],1,n,k+1),yyb=0;
        for(int i=x;DFZ::FAQ[i];i=DFZ::FAQ[i]){
            yyb=SLPF::dist(x,DFZ::FAQ[i]);
            ret+=sgt::query(sgt::root1[DFZ::FAQ[i]],1,n,k-yyb+1);
            ret-=sgt::query(sgt::root2[i],1,n,k-yyb+1);
        }
        return ret;
    }
    il vd Update(int x,int y){
        sgt::update(sgt::root1[x],1,n,1,y);int yyb=0;
        for(int i=x;DFZ::FAQ[i];i=DFZ::FAQ[i]){
            yyb=SLPF::dist(x,DFZ::FAQ[i]);
            sgt::update(sgt::root1[DFZ::FAQ[i]],1,n,yyb+1,y);
            sgt::update(sgt::root2[i],1,n,yyb+1,y);
        }
    }
    il vd Prepare(){
        DFZ::Getrt(1,n);
        SLPF::DFS(1),SLPF::DFS2(1,1);
        DFZ::Build(rt);
        for(rg int i=1;i<=n;++i)Update(i,val[i]);
    }
}
int main(){
#ifdef xzz
    freopen("orz.in","r",stdin);
    freopen("orz.out","w",stdout);
#endif
    int opt,u,v,lst=0;
    n=gi(),m=gi();lg=log2(n);
    for(rg int i=1;i<=n;++i)val[i]=gi();
    for(rg int i=1;i<n;++i)u=gi(),v=gi(),Divide::link(u,v),Divide::link(v,u);
    Divide::Prepare();      
    while(m--){
        opt=gi(),u=gi(),v=gi();
#ifdef ONLINE_JUDGE
        u^=lst,v^=lst;
#endif
        if(opt==0)lst=Divide::Query(u,v),printf("%d\n",lst);
        else Divide::Update(u,v-val[u]),val[u]=v;
    }
    return 0;
}

bzoj4372 烁烁的游戏

我™放弃了。。。

哪天想起来了再补吧

// It is made by XZZ
#include<cstdio>
#include<algorithm>
#define il inline
#define rg register
#define vd void
#define sta static
typedef long long ll;
il int gi(){
    rg int x=0,f=1;rg char ch=getchar();
    while(ch<'0'||ch>'9')f=ch=='-'?-1:f,ch=getchar();
    while(ch>='0'&&ch<='9')x=x*10+ch-'0',ch=getchar();
    return x*f;
}
const int maxn=maxm;
typedef const int& ci;
int n,m;
namespace sgt{
    int maxd=2e7;
    int ls[maxd],rs[maxd],sum[maxd],idx;
#define mid ((l+r)>>1)
    il vd update(int&x,int l,int r,ci p,ci k){
        if(!x)x=++idx;sum[x]+=k;
        if(l==r)return;
        if(mid<p)update(rs[x],mid+1,r,p,k);
        else update(ls[x],l,mid,p,k);
    }
    il int query(ci x,int l,int r,ci L,ci R){
        if(!sum[x]||R<l||r<L)return 0;
        if(L<=l&&r<=R)return sum[x];
        return query(ls[x],l,mid,L,R)+query(rs[x],mid+1,r,L,R);
    }
#undef mid
}
namespace Tree{
    int fir[maxn],nxt[maxn<<1],dis[maxn<<1],idx;
    il vd link(ci x,ci y){nxt[++id]=fir[x],fir[x]=id,dis[id]=y;}
    namespace SLPF{
        int root[maxn],root2[maxn],siz[maxn],dep[maxn],fa[maxn],son[maxn],top[maxn];
        il vd dfs(ci x){
            siz[x]=1;
            for(int i=fir[x];i;i=nxt[i]){
                if(fa[x]==i)continue;
                fa[dis[i]]=x;
                dep[dis[i]]=dep[x]+1;
                dfs(dis[i]);
                if(siz[dis[i]]>siz[son[x]])son[x]=dis[i];
            }
        }
        il vd dfs2(ci x,ci tp){
            top[x]=tp;
            if(son[x])dfs2(son[x],tp);
            for(int i=fir[x];i;i=nxt[i]){
                if(fa[x]==i||son[x]==i)continue;
                dfs2(dis[i],dis[i]);
            }
        }
        il int dist(int x,int y){
            int ret=dep[x]+dep[y];
            while(top[x]^top[y])
                if(dep[top[x]]>dep[top[y]])x=fa[top[x]];
                else y=fa[top[y]];
            if(dep[x]>dep[y])x=y;
            return ret-dep[x]*2;
        }
    }namespace DFZ{
        int siz[maxn],f[maxn],rt,sum;bool vis[maxn];
        il vd getrt(ci x,ci FA){
            siz[x]=1,f[x]=0;
            for(int i=fir[x];i;i=nxt[i]){
                if(FA==dis[i]||vis[dis[i]])continue;
                getrt(dis[i],x);
                siz[x]+=siz[dis[i]];
                f[x]=max(f[x],siz[dis[i]]);
            }
            f[x]=max(f[x],sum-siz[dis[i]]);
            if(f[x]<f[rt])rt=x;
        }
        il vd Getrt(ci x,ci _sum){f[0]=2e9,rt=0,sum=_sum,getrt(x,-1);}
        il vd build(ci x){
            vis[x]=1;
            for(int i=fir[x];i;i=nxt[i]){
                if(vis[dis[i]])continue;
                Getrt(dis[i],siz[dis[i]]);
                FAQ[rt]=x;
                build(rt);
            }
        }
    }
    il vd prepare(){
        int u,v;
        for(rg int i=1;i<n;++i)u=gi(),v=gi(),link(u,v),link(v,u);
        DFZ::Getrt(1,n),DFZ::build(DFZ::rt);
        SLPF::dfs(1),SLPF::dfs2(1);
    }
    il vd Update(int x,int d,int w){
        sgt::update(root[x],1,n,d+1,w);
        for(rg int i=FAQ[x];FAQ[i];i=FAQ[i]){
            int dst=SLPF::dist(x,FAQ[i]);
            sgt::update(sgt::root[FAQ[i]],1,n,1,w);
            sgt::update(sgt::root2[i],1,n,1,w);
            sgt::update(sgt::root[FAQ[i]],1,n,dst+2,-w);
            sgt::update(sgt::root2[i],1,n,dst+2,-w);
        }
    }
    il int Query(int x){
        int ret=sgt::query(root[x],);
    }
}
int main(){
    freopen("orz.in","r",stdin);
    freopen("orz.out","w",stdout);
    n=gi(),m=gi();
    
    return 0;
}

转载于:https://www.cnblogs.com/xzz_233/p/8301050.html

weixin_30849591
关注
bzoj1095【ZJOI2007】捉迷藏 （动态点分治总结）
hhz6830975的博客
04-12 237
动态点分治，就是在普通点分治的基础上，把每一层重心与上一层的重心连起来，形成一颗点分树，然后在每个点维护该点作重心时管辖的子树的信息。修改某个点时就从点分树中该点的位置开始，一路向它的父亲更新，因为点分树深度lognlognlogn，所以一次最多修改lognlognlogn个点。 本题要求最远一对黑点的距离，因此用堆维护距离： C堆：在点分树每个结点u维护以u为根的子树内各个黑点到u管辖子树的...
点分治总结
DJ的博客
12-01 161
动态点分治
分治算法总结
qq_31267769的博客
03-26 1086
分治算法 动态规划与分治的区别是动态规划子问题有重叠而分治子问题相互独立 分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。即一种分目标完成程序算法，简单问题可用二分法完成。（来自度娘） 一、概念 分而治之，将问题划分为更小的问题，直到最后子问题可以简单到直接求解，再将子问题合并为原问题...
题解 动态点分治
weixin_30911809的博客
09-21 114
题面 动态点分治 问题描述 CJK 是一个喜欢数据结构的同学。一天他看到 BZOJ 4012 这一题。“这似乎可以用动态点分治做。”，他想。然而他并不会动态点分治，因此他拿着这一题去问 XXX。然而 XXX 跟他说：“你呀，毕竟图样图森破，上台拿衣服！连基础都没学好，就想学这些高端的东西！来，我这里有一题，如果你能把这道题秒掉，我才能教你动态点分治！”于是 CJK 打开题目。题目很短，只...
动态规划和分治区别?
weixin_47230102的博客
07-14 712
动态规划和分治区别： 动态规划算法：它通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。 分治法：若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已
cdq分治总结
andyc_03的博客
01-21 335
cdq分治总结！
分治，动态规划，贪心总结
DAY DAY UP！
05-13 122
分治，动态规划，贪心总结 分治： Top-Down 动态规划： Down-Top 贪心：Top-Down
动态规划算法总结
Juwenile的博客
06-07 2530
介绍动态规划算法，并于递归算法、递推算法进行比较，介绍0-1背包，完全背包算法以及空间优化
动态规划与分治学习总结
Aldnoah
03-22 3555
6.1 二分查找二分查找半开区间, 左闭右开 例如：[1,5) [5,10)package 分治与动态规划; public class 二分查找 { public static void main(String[] args) { int[] arr = { 1, 2, 3, 4, 5 }; System.out.println(f(arr, 5)); } private st...
数据结构与算法-五大常用算法总结（分治法，回溯法，分治限界法，贪心算法，动态规划法），算法数据结构
04-07
本文主要总结了五大常用算法，包括分治法、回溯法、分治限界法、贪心算法以及动态规划法。 1. 分治法（Recurrence and Divide-Conquer） 分治法是一种将大问题分解为小问题进行解决的策略。它适用于可以分解成独立...
暴力、递归与分治、动态规划、贪心算法、回溯经典习题
03-13
暴力、递归与分治、动态规划、贪心算法和回溯是算法设计中常见的几种思路和方法,经典习题是帮助我们更好掌握这些算法思想的重要途径。以下是对这些经典习题的详细说明: 1. 暴力解法习题 暴力解法往往是最直观、最...
点分树/动态点分治
hipamp的博客
04-13 374
前言 点分治是一种树上分治算法，常用于处理和路径相关的统计，或者是树上满足某种条件的点对数量。 在点分治的基础上，构造一棵支持修改的树，就成了点分树。 算法理解 点分治的核心是按照重心来划分连通块，我们在递归的时候，将上一层的重心作为这一层的重心的父亲，就成了点分树。容易知道，这棵树的树高是 O(logn)O(logn)O(logn) 的，因为总共只会有 O(logn)O(logn)O(logn) 层。下面盗用 辰星凌大佬的图 来看看点分树长什么样子。 如图，上面是原树，下面是点分树。可以看到，点分树和原
点分治解析
zjy_code的博客
12-16 420
前言 最近碰见了淀粉质。想系统学学，虽然也学不懂。 算法概述 首先明确用途：在大规模处理树上路径的问题时，可以考虑淀粉质 淀粉质（点分治 的主要思想继承了分治的思想，相当于每一次拆开了一棵树（子树），然后不断重复操作，因此，点分治优化的思路就来自于选取的树根的最大深度最小 引理 树的重心 关于树的重心，贴个oiwiki 这里我们应用的性质即为性质第一条 首先考虑为什么需要树的重心，我们每次分裂出子树，假设子树退化成链，结合线段树的思想，我们知道应该选取尽量到各个........
二分查找、分治、动态规划、KMP、贪心总结
wdg0809的博客
07-13 91
二分查找算法（包括二分递归查找和二分不递归查找） package com.algorithm.binarysearch.binarysearchnorecur; import java.lang.reflect.Array; import java.util.ArrayList; public class BinarySearchNoRecur { public static void main(String[] args) { int[] arr = {1, 3, 8, 10,
【LeetCode】每日一题 2024_10_5 完成旅途的最少时间（二分答案）
Locky136的博客
10-05 413
【LeetCode】每日一题 2024_10_5 完成旅途的最少时间（二分答案）
编程题 7-14 求整数段和【PAT】
绯樱殇雪的博客
09-30 958
编程题 7-14 求整数段和
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Mopes__的博客
10-01 415
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
数据结构篇（绪论）
最新发布
wlcass zhengge blog
10-05 436
字符类型：char布尔类型：boolean数值类型：byte、short、int、long、float、double。如果系统自定义的数据类型不够，可以自定义数据类型。例如：Person、Animal、. . .算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令。算法代表着用系统的方法描述解决问题的策略机制。
动态点分治：树形结构的修改与查询优化
总结来说，动态树分治是一种在处理树形数据时的高效解决方案，它结合了分治的思想，通过动态维护和分治根的层次结构，实现了对数据操作的快速响应和高效处理。理解并掌握这种技术对于解决实际问题中的复杂计算任务至...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值