点分治
来看一道题
给定一棵有n个点的树
询问树上距离为k的点对是否存在。
对于30%的数据n<=100
对于60%的数据n<=1000,m<=50
对于100%的数据n<=10000,m<=100,c<=1000,K<=10000000
首先来看一下30%的点(不要说太简单了，有时候暴力很有用)
但事实上好水啊
不是dfs的题吗？这是在你不会任何数据结构的情况下你能做的点，只需要枚举所有点对，在算出他们之间的距离，用一个标记数组将这个距离赋为1，询问的时候就直接判断距离是否为1就可以了。这样就好了，对于蒟蒻来说，会这个就可以了,但是如果你不满足这点分，继续往下看，这里就不提供代码了。
对于60%的点。
这个只要你会一点数据结构(lca)就够就可以做了，如果你不会，戳这 如果你会，这就简单了,首先预处理出每一个点到根节点的距离dis。在枚举所有点对，他们之间的距离就是dis[a]+dis[b]-2*dis[lca(a,b)];用一个标记数组将这个距离赋为1，询问的时候就直接判断距离是否为1。开氧气(O2)可以获得70分。
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
int cnt=0,fa[500000],siz[500000],son[500000],dep[500000],top[500000],dfs[500000],head[500000],dis[500001];
struct node {
int to,next,v;
} a[1000001];
void add(int x,int y,int c) {
a[++cnt].to=y;
a[cnt].next=head[x];
a[cnt].v=c;
head[x]=cnt;
}
void dfs1(int u,int f,int depth) {
fa[u]=f;
siz[u]=1;
dep[u]=depth;
for(int i=head[u]; i; i=a[i].next) {
int v=a[i].to;
if(v==f)
continue;
dis[v]=dis[u]+a[i].v;
dfs1(v,u,depth+1);
siz[u]+=siz[v];
if(siz[v]>siz[son[u]]||son[u]==0)
son[u]=v;
}
}
int js;
void dfs2(int u,int t) {
top[u]=t;
if(son[u])
dfs2(son[u],t);
for(int i=head[u]; i; i=a[i].next) {
int v=a[i].to;
if(v!=fa[u]&&v!=son[u])
dfs2(v,v);
}
}
int lca(int x,int y) {
while(top[x]!=top[y]) {
if(dep[top[x]]<dep[top[y]])
swap(x,y);
x=fa[top[x]];
}
return dep[x]<dep[y]?x:y;
}
int bj[1000001];
int main() {
int n,m,s,x,y,v,k;
scanf("%d%d",&n,&m);
for(int i=1; i<n; i++)
scanf("%d%d%d",&x,&y,&v),add(x,y,v),add(y,x,v);
dfs1(1,0,1);
dfs2(1,1);
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n;j++)
bj[dis[i]+dis[j]-2*dis[lca(i,j)]]=1;
for(int i=1;i<=m;i++)
scanf("%d",&k),bj[k]?printf("AYE\n"):printf("NAY\n");
}
对于100%
就要用到点分治了，现在来开始正式讲一讲点分治。
假设现在k为5。我们可以发现，对于一个根节点，有两种情况会有答案，一种是在他的子树中，另一种是从一个节点到另一个节点并且穿过他。如对于根节点1,有(1,6),(1,4)，而对于根节点2(是对于子树的根节点)，有(4,5)满足条件。
会有两种情况满足条件，那么怎么处理?分点?太麻烦了，其实可以把这两种条件看为一种条件。
- 如果答案穿过他，分成两条路径，以上图中的(4,5)说，可以看成(2,4)+(2,5)
- 如果答案在他的子树中，则可以看成从他的一个子节点到他本身，穿过自己，到达他自己。以(1,4)来说，可以看成(1,4)+(1,1,)。自己到自己的距离为0。
那么根节点是什么呢？不同的根节点效率会不同
对于这张图当以1为更节点的时候我们要递归四层,而以3为根节点话只要递归两层。所以要正确选好根节点。那么什么是最好的根节点呢？重心。
重心
什么是重心？三角形内三条中线交点？
但是这里的重心不是数学中的概念。
树的重心也叫树的质心。找到一个点,其所有的子树中最大的子树节点数最少,那么这个点就是这棵树的重心,删去重心后，生成的多棵树尽可能平衡。
上面来自百度百科
实际上重心可以用一句话说明:其所有的子树中最大的子树节点数最少
那么怎么求重心呢？只要一个树形dp就可以了，接下来直接上代码，相信应该都能理解吧
在上代码之前先申明一写变量定义
int n,k;
int ans[10000001];/*储存答案*/
int dis[N];/*从当前节点i到枚举当前树的根节点父亲的距离*/(这里随便理解一下吧，我这么说是为了后面的容斥)
int f[N];/*当以i为根节点时最大子树大小*/
int vis[N];/*i节点是否被当根使用过*/
int siz[N];/*以i节点为根时,其子树(包括本身)的节点个数*/
int root;/*根节点*/
int sum;/*这棵当前递归的这棵树的大小*/
void findroot(int k,int fa) {
f[k]=0,siz[k]=1;
for(int i=head[k]; i; i=a[i].next) {
int v=a[i].to;
if(vis[v]||v==fa)
continue;
findroot(v,k);
siz[k]+=siz[v];
f[k]=max(f[k],siz[v]);
}
f[k]=max(f[k],sum-siz[k]);
if(f[k]<f[root])
root=k;
}
对于f[k]=max(f[k],sum-siz[k]);这里有很多人不知道什么意思，我下面来讲一下
继续用上面的图
假设你已经递归到了节点2，你的儿子有1,4,5(这是一个无根树)。但是你的递归并不会算1节点，所以需要这一段话来判断他的包含他"父亲"的子树大小是否时最大的。
当找到重心以后就可以找出每个点与重心的距离.在统计答案就可以了
看看这一题是如何判的
void calc(int x){
tot=0;
b[++tot]=(node1){0,x,x};
for(int i=head[x];i;i=a[i].next){
int v=a[i].to;
if(vis[v]) continue;
dfs(v,x,v,a[i].v);
}
sort(b+1,b+1+tot,cmp);
for(int i=1;i<=m;i++){
if(ans[i]) continue;
int l=1,r=tot;
while(l<r){
if(b[l].dis+b[r].dis>q[i]) r--;
else if(b[l].dis+b[r].dis<q[i]) l++;
else if(b[l].l==b[r].l){
if(b[r].dis==b[r-1].dis) r--;
else l++;
}
else {
ans[i]=1;
break;
}
}
}
}
但是对于统计答案要注意一点的就是路径会重复算。上图中如果k=7那么对于(1,4),(1,5)这也是个答案,但是这并不是个答案.路径(1,2)被算了两次.所以我们要将重复的路径去掉就可以了
那么怎么去掉呢?只要每次在递归的时候对于儿子节点,将所有儿子节点的子树满足条件的删掉就可以了,也就是dis和为k,注意这里的dis算的是所有子节点到这个儿子节点父亲的距离.
void devide(int k) {
vis[k]=1;
calc(k,0,1);
for(int i=head[k]; i; i=a[i].next) {
int v=a[i].to;
if(vis[v])
continue;
calc(v,a[i].v,-1);//就是这一段话
root=0,sum=siz[v];
findroot(v,0);
devide(root);
}
}
接下来上代码
#include<bits/stdc++.h>
#define rg register
#define file(x) freopen(x".in","r",stdin);freopen(x".out","w",stdout);
using namespace std;
const int N=10010;
int read(){
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9') f=(c=='-')?-1:1,c=getchar();
while(c>='0'&&c<='9') x=x*10+c-48,c=getchar();
return f*x;
}
struct node{
int to,next,v;
}a[N<<1];
int head[N],cnt,siz[N],Max[N],root,sum,vis[N],q[N];
void add(int x,int y,int v){
a[++cnt].next=head[x];
head[x]=cnt;
a[cnt].to=y;
a[cnt].v=v;
}
void getroot(int x,int fa){
siz[x]=1,Max[x]=0;
for(int i=head[x];i;i=a[i].next){
int v=a[i].to;
if(v==fa||vis[v]) continue;
getroot(v,x);
siz[x]+=siz[v];
Max[x]=max(Max[x],siz[v]);
}
Max[x]=max(Max[x],sum-siz[x]);
if(Max[x]<Max[root]) root=x;
}
struct node1{
int dis,l,r;
}b[N];
int tot,n,m,ans[N];
void dfs(int x,int fa,int l,int v){
b[++tot]=(node1){v,l,x};
for(int i=head[x];i;i=a[i].next){
int V=a[i].to;
if(vis[V]||V==fa) continue;
dfs(V,x,l,v+a[i].v);
}
}
bool cmp(const node1 &a, const node1 & b){
return a.dis<b.dis;
}
void calc(int x){
tot=0;
b[++tot]=(node1){0,x,x};
for(int i=head[x];i;i=a[i].next){
int v=a[i].to;
if(vis[v]) continue;
dfs(v,x,v,a[i].v);
}
sort(b+1,b+1+tot,cmp);
for(int i=1;i<=m;i++){
if(ans[i]) continue;
int l=1,r=tot;
while(l<r){
if(b[l].dis+b[r].dis>q[i]) r--;
else if(b[l].dis+b[r].dis<q[i]) l++;
else if(b[l].l==b[r].l){
if(b[r].dis==b[r-1].dis) r--;
else l++;
}
else {
ans[i]=1;
break;
}
}
}
}
void divide(int x){
vis[x]=1;
calc(x);
for(int i=head[x];i;i=a[i].next){
int v=a[i].to;
if(vis[v]) continue;
root=0,sum=siz[v];
getroot(v,x);
divide(root);
}
}
main(){
n=read(),m=read();
int x,y,z;
for(int i=1;i<n;i++)
x=read(),y=read(),z=read(),add(x,y,z),add(y,x,z);
for(int i=1;i<=m;i++)
q[i]=read();
sum=Max[0]=n;
getroot(1,0);
divide(root);
for(int i=1;i<=m;i++)
cout<<(ans[i]?"AYE":"NAY")<<"\n";
}
