点分治模板

最新推荐文章于 2021-12-16 22:41:43 发布
最新推荐文章于 2021-12-16 22:41:43 发布
阅读量338 收藏
点赞数
分类专栏： 数据结构==点分治
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42576687/article/details/90598107
版权
本文通过POJ1741和BZOJ2152两道题目，详细解释了点分治的思想和解题策略。点分治的核心在于以一个节点为中心，将问题分为不同子树内的点对和同一子树内的点对，利用排序和尺取法减少重复计算。文章还提供了getroot和getd等关键辅助函数的作用，并指出在实现过程中应注意的细节，如防止错误的计数方式和优化时间复杂度。
摘要由CSDN通过智能技术生成

POJ1741
在这里插入图片描述
Sample Input
5 4
1 2 3
1 3 1
1 4 2
3 5 1
0 0

Sample Output
8

点分治裸题。
点分治的主要思想就是：对这个题来讲的话
在这里插入图片描述
我们先随便找一个点 1.既然是分治。可以分为两种情况。
1.点对在1的不同子树内。
2.点对在1的相同子树x内。
同时情况2又是 像这样可以分为两种情况。
我们递归下去每次只计算情况1就好了。
如何计算：可以将以1为根的所有节点的 dep[ ] dfs处理出来。dep[ ]是路径而非深度。
cla(x,now)函数：将这些dep[ ]排序之后 用尺取法两个指针l,r分别从前后扫描。条件是dep[l]+dep[r]。。。我们这样会多计算一些东西。同一颗子树里面dep[u]+dep[v]<=K的点对。但我们这个函数本身计算的就是dep[x]+dep[y]<=K的点对。所以只需要再减去每个子树不合法的情况即可。也就是 cal(edge[i].to,egde[i].len)。看代码就好理解了。

证明可知，随便找着一个点记为root，当root为当前树的中心。时间复杂度较低。getroot(x,fa)函数用来找一个树的重心。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<iostream>
#define foru(i,a,b) for(int i=a;i<=b;++i)
#define m(a,b) memset(a,b,sizeof a)
#define en '\n'
using namespace std;
typedef long long ll;
const int N=1e4+5,M=1e5+5,INF=0x3f3f3f3f;
template<class T>void rd(T &x)
{
    x=0;int f=0;char ch=getchar();
    while(ch<'0'||ch>'9')  {f|=(ch=='-');ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    x=f?-x:x;
    return;
}
struct Edge{int to,len,nex;}edge[N<<1];
int head[N],tot;
void add(int from,int to,int len)
{
    edge[++tot]=(Edge){to,len,head[from]};head[from]=tot;
    edge[++tot]=(Edge){from,len,head[to]};head[to]=tot;
}
ll ans=0;
int root,sum;
int sz[N],mx[N],vis[N];//sz[i]以i为根的子树节点总个数 mx[i]是以i为根的几叉树最大的儿子节点数目 vis[]标记这个节点是否当过root
void getroot(int x,int fa)//查找树的重心
{
    sz[x]=1,mx[x]=0;
    for(int i=head[x];i;i=edge[i].nex)
    {
        int y=edge[i].to;
        if(vis[y]||y==fa) continue;
        getroot(y,x);
        sz[x]+=sz[y];
        mx[x]=max(mx[x],sz[y]);
    }
    mx[x]=max(mx[x],sum-sz[x]);//我觉着这个应该是x通往fa的那一条子树的大小.
    if(mx[x]<mx[root]) root=x;//更新root是谁
}
int d[N],dep[N];
void getd(int x,int fa)
{
    d[++d[0]]=dep[x];
    for(int i=head[x];i;i=edge[i].nex)
    {
        int y=edge[i].to;
        if(vis[y]||y==fa) continue;
        dep[y]=dep[x]+edge[i].len;
        getd(y,x);
    }
}
int K;
int cal(int x,int now)
{
    dep[x]=now,d[0]=0;//d[0]是用来记数的,看这个子树内共有多少节点.
    getd(x,-1);
    sort(d+1,d+d[0]+1);
    int res=0,l=1,r=d[0];
    while(l<r)//尺取法
    {
        if(d[l]+d[r]>K) r--;
        else res+=r-l,l++;
    }
    return res;
}
void work(int x)
{
    ans+=cal(x,0);//cal(x,now)会处理以x为根的树 横跨根的点对.(但是我们会多算上不合法的点对)
                  //比如同在x的一颗子树内,但是计算的路径并不是按LCA来的 而是为dep[u]+dep[v].就需要把这种情况舍去.
    vis[x]=1;//标记这个节点已经用过.
    for(int i=head[x];i;i=edge[i].nex)
    {
        int y=edge[i].to;
        if(vis[y]) continue;
        ans-=cal(y,edge[i].len);//就是这样舍去.
        sum=sz[y],root=0;//sum=sz[y]就是为了查找y无法通往他的fa那个子树
        getroot(y,-1);
        work(root);//对每个子树进行分治
    }
}
int main()
{
    int n;
    while(rd(n),rd(K),n)
    {
        m(head,0),tot=0;
        foru(i,1,n-1)
        {
            int u,v,w;rd(u),rd(v),rd(w);
            add(u,v,w);
        }
        m(vis,0),root=0,ans=0,sum=n,mx[0]=INF;
        getroot(1,-1);
        work(root);
        printf("%lld\n",ans);
    }
}

P3806 【模板】点分治1
在这里插入图片描述
输入样例#1：
2 1
1 2 2
2

输出样例#1：
AYE

对于100%的数据n<=10000,m<=100,c<=10000,K<=10000000

**注意：**这里用尺取法就需要注意了。。。。。我是傻逼。。。
直接 ans[d[i]+d[j]]+=val.这样也行。每次i,j循环是从[1,d[0]]。每次d[0]需要重新算 不能按sz[x]。因为work函数里面第二个cal时 会被别的getrroot改变。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<iostream>
#define foru(i,a,b) for(int i=a;i<=b;++i)
#define m(a,b) memset(a,b,sizeof a)
#define en '\n'
using namespace std;
typedef long long ll;
const int N=1e4+5,M=1e7+5,INF=0x3f3f3f3f;
template<class T>void rd(T &x)
{
    x=0;int f=0;char ch=getchar();
    while(ch<'0'||ch>'9')  {f|=(ch=='-');ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    x=f?-x:x;
    return;
}
struct Edge{int to,len,nex;}edge[N<<1];
int head[N],tot;
void add(int from,int to,int len)
{
    edge[++tot]=(Edge){to,len,head[from]};head[from]=tot;
    edge[++tot]=(Edge){from,len,head[to]};head[to]=tot;
}
int root,sum;
int sz[N],mx[N],vis[N];
void getroot(int x,int fa)
{
    sz[x]=1,mx[x]=0;
    for(int i=head[x];i;i=edge[i].nex)
    {
        int y=edge[i].to;
        if(vis[y]||y==fa) continue;
        getroot(y,x);
        sz[x]+=sz[y];
        mx[x]=max(mx[x],sz[y]);
    }
    mx[x]=max(mx[x],sum-sz[x]);
    if(mx[x]<mx[root]) root=x;
}
int d[N],dep[N];
void getd(int x,int fa)
{
    d[++d[0]]=dep[x];
    for(int i=head[x];i;i=edge[i].nex)
    {
        int y=edge[i].to;
        if(vis[y]||y==fa) continue;
        dep[y]=dep[x]+edge[i].len;
        getd(y,x);
    }
}
int ans[M];
int cal(int x,int now,int val)
{
    dep[x]=now,d[0]=0;
    getd(x,-1);
    foru(i,1,d[0])
        foru(j,1,d[0])
            if(i!=j) ans[d[i]+d[j]]+=val;
}
void work(int x)
{
    cal(x,0,1);
    vis[x]=1;
    for(int i=head[x];i;i=edge[i].nex)
    {
        int y=edge[i].to;
        if(vis[y]) continue;
        cal(y,edge[i].len,-1);
        sum=sz[y],root=0;
        getroot(y,-1);
        work(root);
    }
}
int main()
{
    int n,m;rd(n),rd(m);
    foru(i,1,n-1)
    {
        int u,v,w;rd(u),rd(v),rd(w);
        add(u,v,w);
    }
    root=0,mx[0]=INF,sum=n;
    getroot(1,-1);
    work(root);
    foru(i,1,m)
    {
        int x;rd(x);
        puts(ans[x]?"AYE":"NAY");
    }
}

BZOJ 2152
在这里插入图片描述
Sample Input
5
1 2 1
1 3 2
1 4 1
2 5 3

Sample Output
13/25

【样例说明】13组点对分别是(1,1) (2,2) (2,3) (2,5) (3,2) (3,3) (3,4) (3,5) (4,3) (4,4) (5,2) (5,3) (5,5)。

【数据规模】对于100%的数据，n<=20000。

思路：统计是否为3的倍数时。我竟然要两次for循环。。我是吃屎了吗
直接统计t[0],t[1],t[2]。代表所求子树中dep[x]%3的节点数。
getd(x,fa)函数dfs时：t[dep[x]]++即可。
然后每次cal的答案就是 t[0]* t[0]+2* t[1]* [2];

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#define m(a,b) memset(a,b,sizeof a)
using namespace std;
typedef long long ll;
const int N=2e4+5,INF=0x3f3f3f3f;
struct Edge{int to,len,nex;}edge[N<<1];
int head[N],tot;
inline void add(int from,int to,int len){
    edge[++tot]=(Edge){to,len,head[from]};head[from]=tot;
    edge[++tot]=(Edge){from,len,head[to]};head[to]=tot;
}
int root,sum;
int sz[N],mx[N],vis[N];
inline void getroot(int x,int fa){
    sz[x]=1,mx[x]=0;
    for(int i=head[x];i;i=edge[i].nex){
        int y=edge[i].to;
        if(vis[y]||y==fa) continue;
        getroot(y,x),sz[x]+=sz[y];
        mx[x]=max(mx[x],sz[y]);
    }
    mx[x]=max(mx[x],sum-sz[x]);
    if(mx[x]<mx[root]) root=x;
}
int dep[N],t[3];
inline void getd(int x,int fa){
    t[dep[x]]++;
    for(int i=head[x];i;i=edge[i].nex){
        int y=edge[i].to;
        if(vis[y]||y==fa) continue;
        dep[y]=(dep[x]+edge[i].len)%3,getd(y,x);
    }
}
inline int cal(int x,int now){
    dep[x]=now,t[0]=t[1]=t[2]=0;
    getd(x,-1);
    return t[0]*t[0]+t[1]*t[2]*2;
}
ll ans;
inline void work(int x){
    ans+=cal(x,0),vis[x]=1;
    for(int i=head[x];i;i=edge[i].nex)
    {
        int y=edge[i].to;
        if(vis[y]) continue;
        ans-=cal(y,edge[i].len);
        sum=sz[y],root=0;
        getroot(y,-1),work(root);
    }
}
ll gcd(ll a,ll b){
    return (!b)?a:gcd(b,a%b);
}
int main()
{
    int n;scanf("%d",&n);
    for(int i=1,u,v,w;i<=n-1;++i)
        scanf("%d%d%d",&u,&v,&w),w%=3,add(u,v,w);
    root=0,mx[0]=INF,sum=n;
    getroot(1,-1),work(root);
    ll c=gcd(ans,(ll)n*n);
    printf("%lld/%lld\n",ans/c,(ll)n*n/c);
}
Helium_wild
关注
专栏目录
点分治 模板题
CutieDeng的博客
08-22 386
题目描述 给定一棵有n个点的树 询问树上距离为k的点对是否存在。 输入输出格式 输入格式： n,m 接下来n-1条边a,b,c描述a到b有一条长度为c的路径 接下来m行每行询问一个K 输出格式： 对于每个K每行输出一个答案，存在输出“AYE”,否则输出”NAY”(不包含引号) 输入输出样例 输入样例1： 2 1 1 2 ...
点分治 模板
weixin_34204722的博客
11-12 66
poj 1741 1.选取一个点，把无根树变成有根树。通过树形dp的方式选择。用son记录点的子树大小，用F算出最大的子树，当F[x]<F[root]时，更换root. 2.再次通过dfs处理树上的deep和距离。 3.处理连通块中通过根节点的路径。减去同一子树内部的路径。 4.递归。 #include <cstdio> #include <cstring> #inc...
点分治_点分治模板_
10-02
点分治模板通常包括了基本的点分治操作，如Find、Union等，以及优化策略，如路径压缩和按秩合并，以提高算法的效率。 点分治的基本思想是将复杂的问题分解为若干个独立的部分，通过解决这些小问题来推导出原问题的...
P4149-(求一条边数最少的权值和为K的简单路径权 的边数 点分治模板)
qq_42576687的博客
05-29 509
题目 输入样例#1： 4 3 0 1 1 1 2 2 1 3 4 输出样例#1： 2 n≤200000,K≤1000000 日你
点分治解析
zjy_code的博客
12-16 412
前言 最近碰见了淀粉质。想系统学学，虽然也学不懂。 算法概述 首先明确用途：在大规模处理树上路径的问题时，可以考虑淀粉质 淀粉质（点分治 的主要思想继承了分治的思想，相当于每一次拆开了一棵树（子树），然后不断重复操作，因此，点分治优化的思路就来自于选取的树根的最大深度最小 引理 树的重心 关于树的重心，贴个oiwiki 这里我们应用的性质即为性质第一条 首先考虑为什么需要树的重心，我们每次分裂出子树，假设子树退化成链，结合线段树的思想，我们知道应该选取尽量到各个........
点分治学习笔记
llmmkk的尘歌壶
06-03 113
点分治： 前言： 我太菜了。 前置需要： 分治思想 树的重心 心 用途： 点分治用于静态树上统计路径一类的问题。 如查询边带边权的树上是否存在长度为 kkk 的点对等。 算法： 由于只有统计路径的操作，所以这棵树的根是任意取的，先假设树根为1。 那么对于所有路径，只有 经过树根。（图中红色） 不经过树根。（图中蓝色） 对于情况1，我们当然可以从根遍历整棵树，从而根据每个节点到根的距离等数据得出1的答案。 对于情况2，发现不经过树根的路径必然在根节点的某一棵子树内，所以可以递归树根的每一
点分治-模板
xizi_ghq的博客
10-02 106
可能一步步克服恐惧的过程就是成功，所以只管面对恐惧，不思考结果， 24分钟敲模板，这是点分治第一次敲的这么顺利，纪念一下。 洛谷：2634.求距离是三的倍数的点对数 //点分治模板，找有多少点的距离是3的倍数 #include<bits/stdc++.h> using namespace std; #define ll long long const int M=2e4+5; ...
点分治 模板 + 详解
拾月冰海的小书屋
02-21 389
动态点分治学了以后会在后面 update 的啦~ 好久没颓 blog 了 今天来写一发 最近几个月就学了这一个东西啊 =-= 好了 进入正题 舌尖上的淀粉质 Q1：点分治是什么？ A1：就是像分治一样把树上的点咔擦成几个小树，然后继续咔擦下去处理问题啦 像你把西兰花掰开一样 Q2：点分治能用来干什么？ A2：据我所知，点分治通常是用来找树上所有路径和一个不可告人的数字之间的关系=-=...
点分治
weixin_30836759的博客
05-21 53
考虑以下问题： 给你一棵树，有边权，一条路径合法当它的边权和 \(=k\) ，求合法的路径有多少条。 \((n,k\le 2*10^5,\text{Time Limit=3s})\) 暴力 \(O(n^2)\) ，即对于每一个点dfs它的子树，把边权装桶。 考虑如何优化。 假设树是随机生成的。那么我们的暴力还是没有任何好转 。 但是这是不可能的！ 所以，我们本来是选它的子节点继续统计，现在改成选它...
点分治学习/模板（5道例题）
平凡人Kalzn的博客
10-01 740
感谢b站up大佬：不分解的AgOH。 点分治用于树上的大规模路径操作、统计。它的灵活性高，适用范围广。很多树形dp也可以用点分治搞。其实，树分治中，还有一个边分治，不过没有点分治常用。 基本步骤： 第一步 找树的重心。我们重心为根节点，然后按题目的不同情况统计树各个点到根节点的路径信息。 第二步 递归至每一个子树，重复第一步，直到分割至叶子节点。 非常简洁。 下面看一看具体的实现： 找重心函数： ...
分治算法：从折半搜索到排序策略
这个过程通常表现为分治算法的经典模板： 1. 分解（Divide）：将原始问题划分为若干个规模相等或相近的子问题。例如，在排序问题中，可能将数组对半切分。 2. 解决（Conquer）：递归地解决子问题。如果子问题规模...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值