学习一个树的点分

转载地址 http://www.cnblogs.com/chty/p/5912360.html

【引言】

由于树具有一般的图没有的特点，所以在竞赛中的应用更广。
在一些树上路径问题中，暴力求解时间复杂度过高，往往需要一些更为高效的算法，点分治就是其中之一。

【流程】

1、首先选取一个点，把无根树变成有根树。

　　那么如何选点呢？ ——树型递归
　　因为树是递归定义的，所以我们当然希望递归的层数最小。
　　每次选取的点，要保证与此点相连的结点数最多的连通块的结点数最小，我们把这个点叫做“重心”。
　　那么找到一颗树的重心有以下算法：

　　（1）dfs一次，算出以每个点为根的子树大小。

　　（2）记录以每个结点为根的最大子树的大小。

　　（3）判断：如果以当前结点为根的最大子树大小比当前根更优，更新当前根。

void getroot(int x,int fa)//x表示当前结点，fa表示x的父结点
{
    son[x]=1;F[x]=0;//F数组记录以x为根的最大子树的大小
    for(int i=Link[x];i;i=e[i].next)
        if(e[i].y!=fa&&!vis[e[i].y])//避免陷入死循环
        {
            getroot(e[i].y,x);//得到子结点信息
            son[x]+=son[e[i].y];//计算x结点大小
            F[x]=max(F[x],son[e[i].y]);//更新F数组
        }
    F[x]=max(F[x],sum-son[x]);//sum表示当前树的大小，因为以x为根的情况还要考虑以x的父亲为根的子树大小。
    if(F[x]<F[root])root=x;//更新当前根
}

2、处理联通块中通过根结点的路径。

3、标记根结点（相当于处理过后，将根结点从子树中删除）。

4、递归处理以当前点的儿子为根的每棵子树。

【算法框架】

int solve(int x)
{ 
    vis[x]=1;//将当前点标记
    for(int i=Link[x];i;i=e[i].next)
        if(!vis[e[i].y])  
        {    
            root=0;//初始化根  
            sum=e[i].y;//初始化sum
            getroot(x,0);//找连通块的根
            solve(e[i].y);//递归处理下一个连通块
        }
}
int main()
{
    build();//建树
    sum=f[0]=n;//初始化sum和f[0]
    root=0;//初始化root
    getroot(1,0);//找根
    solve(root);//点分治
}

【例题1】【poj1741】tree

给一颗n个节点的树，每条边上有一个距离v（v<=1000）。定义d(u,v)为u到v的最小距离。给定k值，求有多少点对（u，v）使u到v的距离小于等于k。数据范围：n<=10000,k<2^31

计算答案的方法：这个点延伸出的几棵子树各做一次dfs，记录子树中出现的距离值，对于一棵树的距离值数组，把它排序求一次ans1，再对每棵子树分别求一个自己对自己的ans2，ans1-Σans2即为最后的ans。

参考代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<ctime>
#include<algorithm>
using namespace std;
#define INF 0x7fffffff
struct node{int y,v,next;}e[20010];
int n,len,k,root,sum,ans,Link[10010],f[10010],vis[10010],son[10010],d[10010],deep[10010];
inline int read()
{
    int x=0,f=1;  char ch=getchar();
    while(!isdigit(ch))  {if(ch=='-')  f=-1;  ch=getchar();}
    while(isdigit(ch))  {x=x*10+ch-'0';  ch=getchar();}
    return x*f;
}
void insert(int x,int y,int v)
{
    e[++len].next=Link[x];
    Link[x]=len;
    e[len].v=v;
    e[len].y=y;
}
void getroot(int x,int fa)
{
    son[x]=1;  f[x]=0;
    for(int i=Link[x];i;i=e[i].next)
    {
        if(e[i].y==fa||vis[e[i].y])  continue;
        getroot(e[i].y,x);
        son[x]+=son[e[i].y];
        f[x]=max(f[x],son[e[i].y]);
    }
    f[x]=max(f[x],sum-son[x]);
    if(f[x]<f[root])  root=x;
}
void getdeep(int x,int fa)
{
    deep[++deep[0]]=d[x];
    for(int i=Link[x];i;i=e[i].next)
    {
        if(e[i].y==fa||vis[e[i].y])  continue;
        d[e[i].y]=d[x]+e[i].v;
        getdeep(e[i].y,x);
    }
}
int cal(int x,int v)
{
    d[x]=v;  deep[0]=0;
    getdeep(x,0);
    sort(deep+1,deep+deep[0]+1);
    int l=1,r=deep[0],sum=0;
    while(l<r)
    {
        if(deep[l]+deep[r]<=k)  {sum+=r-l;  l++;}
        else r--;
    }
    return sum;
}
void solve(int x)
{
    ans+=cal(x,0);//计算答案
    vis[x]=1;
    for(int i=Link[x];i;i=e[i].next)
    {
        if(vis[e[i].y])  continue;
        ans-=cal(e[i].y,e[i].v);//计算不符合题意的答案
        sum=son[e[i].y];
        root=0;
        getroot(e[i].y,0);
        solve(root);
    }
}
int main()
{
    freopen("cin.in","r",stdin);
    freopen("cout.out","w",stdout);
    while(1)
    {
        ans=0,root=0,len=0;
        memset(vis,0,sizeof(vis));
        memset(Link,0,sizeof(Link));
        n=read();  k=read();
        if(n==0&&k==0)  break;
        for(int i=1;i<=n-1;i++)
        {
            int x=read(),y=read(),v=read();
            insert(x,y,v);   insert(y,x,v);
        }
        f[0]=INF;  sum=n;
        getroot(1,0);
        solve(root);
        printf("%d\n",ans);
    }
    return 0;
}

【例题2】【bzoj2152】聪聪可可

聪聪和可可是兄弟俩，他们俩经常为了一些琐事打起来，例如家中只剩下最后一根冰棍而两人都想吃、两个人都想玩儿电脑（可是他们家只有一台电脑）……遇到这种问题，一般情况下石头剪刀布就好了，可是他们已经玩儿腻了这种低智商的游戏。他们的爸爸快被他们的争吵烦死了，所以他发明了一个新游戏：由爸爸在纸上画n个“点”，并用n-1条“边”把这n个“点”恰好连通（其实这就是一棵树）。并且每条“边”上都有一个数。接下来由聪聪和可可分别随即选一个点（当然他们选点时是看不到这棵树的），如果两个点之间所有边上数的和加起来恰好是3的倍数，则判聪聪赢，否则可可赢。聪聪非常爱思考问题，在每次游戏后都会仔细研究这棵树，希望知道对于这张图自己的获胜概率是多少。现请你帮忙求出这个值以验证聪聪的答案是否正确。

计算答案的方法：与上一题类似，在计算路径长度时对3取模，用t[0],t[1],t[2]分别记录模为0、1、2的情况，那么显然答案就是t[1]*t[2]*2+t[0]*t[0]

参考代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<ctime>
#include<algorithm>
using namespace std;
#define MAXN 20010
struct node{int y,v,next;}e[MAXN*2];
int n,len,root,sum,ans,t[5],Link[MAXN],f[MAXN],vis[MAXN],son[MAXN],d[MAXN];
inline int read()
{
    int x=0,f=1;  char ch=getchar();
    while(!isdigit(ch))  {if(ch=='-')  f=-1;  ch=getchar();}
    while(isdigit(ch))  {x=x*10+ch-'0';  ch=getchar();}
    return x*f;
}
int gcd(int a,int b)  {return b==0?a:gcd(b,a%b);}
void insert(int x,int y,int v)
{
    e[++len].next=Link[x];
    Link[x]=len;
    e[len].y=y;
    e[len].v=v;
}
void getroot(int x,int fa)
{
    son[x]=1;  f[x]=0;
    for(int i=Link[x];i;i=e[i].next)
    {
        if(e[i].y==fa||vis[e[i].y])  continue;
        getroot(e[i].y,x);
        son[x]+=son[e[i].y];
        f[x]=max(f[x],son[e[i].y]);
    }
    f[x]=max(f[x],sum-son[x]);
    if(f[x]<f[root])  root=x;
}
void getdeep(int x,int fa)
{
    t[d[x]]++;
    for(int i=Link[x];i;i=e[i].next)
    {
        if(e[i].y==fa||vis[e[i].y])  continue;
        d[e[i].y]=(d[x]+e[i].v)%3;
        getdeep(e[i].y,x);
    }
}
int cal(int x,int v)
{
    t[0]=t[1]=t[2]=0;  d[x]=v;
    getdeep(x,0);
    return t[1]*t[2]*2+t[0]*t[0];
}
void solve(int x)
{
    ans+=cal(x,0);  vis[x]=1;
    for(int i=Link[x];i;i=e[i].next)
    {
        if(vis[e[i].y])  continue;
        ans-=cal(e[i].y,e[i].v);
        root=0;  sum=son[e[i].y];
        getroot(e[i].y,0);
        solve(root);
    }
}
int main()
{
    //freopen("cin.in","r",stdin);
    //freopen("cout.out","w",stdout);
    n=read();
    for(int i=1;i<n;i++)
    {
        int x=read(),y=read(),v=read()%3;
        insert(x,y,v);  insert(y,x,v);
    }
    sum=n;  f[0]=n;
    getroot(1,0);
    solve(root);
    int t=gcd(ans,n*n);
    printf("%d/%d\n",ans/t,n*n/t);
    return 0;
}

【例题3】【bzoj2599】Race

给一棵树,每条边有权.求一条路径,权值和等于K,且边的数量最小.数据范围：N<=200000, K<=1000000

我的做法：开一个100W的数组t,t[i]表示权值为i的路径最少边数
　　　　　找到重心分成若干子树后， 得出一棵子树的所有点到根的权值和x，到根a条边，用t[k-x]+a更新答案，全部查询完后
　　　　 然后再用所有a更新t[x]
　　　　 这样可以保证不出现点分治中的不合法情况
　　　　 把一棵树的所有子树搞完后再遍历所有子树恢复T数组，如果用memset应该会比较慢

参考代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<ctime>
#include<algorithm>
using namespace std;
#define MAXN 200100
#define INF 1000000000
struct node{int y,next,v;}e[MAXN*2];
int n,m,len,root,sum,ans,Link[MAXN],son[MAXN],vis[MAXN],t[MAXN*5],dis[MAXN],d[MAXN],f[MAXN];
char buf[1<<15],*fs,*ft;
inline char getc()  {return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin)),fs==ft)?0:*fs++;}
inline int read()
{
    int x=0,f=1;  char ch=getc();
    while(!isdigit(ch))  {if(ch=='-')  f=-1;  ch=getc();}
    while(isdigit(ch))  {x=x*10+ch-'0';  ch=getc();}
    return x*f;
}
void insert(int x,int y,int v){e[++len].next=Link[x];  Link[x]=len;  e[len].y=y;  e[len].v=v;}
void getroot(int x,int fa)
{
    int ff=1;   son[x]=1;
    for(int i=Link[x];i;i=e[i].next)
        if(e[i].y!=fa&&!vis[e[i].y])
        {
            getroot(e[i].y,x);
            son[x]+=son[e[i].y];
            if(son[e[i].y]>sum/2)  ff=0;
        }
    if(sum-son[x]>sum/2)  ff=0;
    if(ff)  root=x;
}
/*void getroot(int x,int fa)
{
    son[x]=1;f[x]=0;
    for(int i=Link[x];i;i=e[i].next)
        if(e[i].y!=fa&&!vis[e[i].y])    
        {
            getroot(e[i].y,x);
            son[x]+=son[e[i].y];
            f[x]=max(f[x],son[e[i].y]);
        }
    f[x]=max(f[x],sum-son[x]);
    if(f[x]<f[root])root=x;
}*/
void cal(int x,int fa)
{
    if(dis[x]<=m)  ans=min(ans,d[x]+t[m-dis[x]]);
    for(int i=Link[x];i;i=e[i].next)
        if(e[i].y!=fa&&!vis[e[i].y])
        {
            d[e[i].y]=d[x]+1;
            dis[e[i].y]=dis[x]+e[i].v;
            cal(e[i].y,x);
        }
}
void add(int x,int fa,int flag)
{
    if(dis[x]<=m)  
    {
        if(flag)  t[dis[x]]=min(t[dis[x]],d[x]);
        else t[dis[x]]=INF;
    }
    for(int i=Link[x];i;i=e[i].next)
        if(e[i].y!=fa&&!vis[e[i].y])
            add(e[i].y,x,flag);
}
void work(int x)
{
    vis[x]=1;  t[0]=0;
    for(int i=Link[x];i;i=e[i].next)
        if(!vis[e[i].y])
        {
            d[e[i].y]=1;  dis[e[i].y]=e[i].v;
            cal(e[i].y,0);
            add(e[i].y,0,1);
        }
    for(int i=Link[x];i;i=e[i].next)
        if(!vis[e[i].y])  add(e[i].y,0,0);    
    for(int i=Link[x];i;i=e[i].next)
        if(!vis[e[i].y])
        {
            sum=son[e[i].y];  root=0;
            getroot(e[i].y,0);
            work(e[i].y);
        }
}
int main()
{
    //freopen("cin.in","r",stdin);
    //freopen("cout.out","w",stdout);
    n=read();  m=read();
    for(int i=1;i<=m;i++)t[i]=n;
    for(int i=1;i<n;i++)
    {
        int x=read(),y=read(),v=read();
        x++;  y++;
        insert(x,y,v);  insert(y,x,v);
    }
    sum=ans=f[0]=n;
    getroot(1,0);
    work(root);
    if(ans==n)  printf("-1\n");
    else printf("%d\n",ans);
    return 0;
}

【例题4】【bzoj3697】采药人的路径

采药人的药田是一个树状结构，每条路径上都种植着同种药材。
采药人以自己对药材独到的见解，对每种药材进行了分类。大致分为两类，一种是阴性的，一种是阳性的。
采药人每天都要进行采药活动。他选择的路径是很有讲究的，他认为阴阳平衡是很重要的，所以他走的一定是两种药材数目相等的路径。采药工作是很辛苦的，所以他希望他选出的路径中有一个可以作为休息站的节点（不包括起点和终点），满足起点到休息站和休息站到终点的路径也是阴阳平衡的。他想知道他一共可以选择多少种不同的路径。

来自出题人hta的题解：
本题可以考虑树的点分治。问题就变成求过根满足条件的路径数。
路径上的休息站一定是在起点到根的路径上，或者根到终点的路径上。
如何判断一条从根出发的路径是否包含休息站？只要在dfs中记录下这条路径的和x，同时用个标志数组判断这条路径是否存在前缀和为x的节点。
这样我们枚举根节点的每个子树。用f[i][0…1]，g[i][0…1]分别表示前面几个子树以及当前子树和为i的路径数目，0和1用于区分路径上是否存在前缀和为i的节点。那么当前子树的贡献就是f[0][0] * g[0][0] + Σf [i][0] * g [-i][1] + f[i][1] * g[-i][0] + f[i][1] * g[-i][1]，其中i的范围[-d,d]，d为当前子树的深度。

参考代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<ctime>
#include<algorithm>
using namespace std;
#define MAXN 200100
struct node{int y,next,v;}e[MAXN];
int n,len,sum,root,mxdeep,Link[MAXN],son[MAXN],deep[MAXN],vis[MAXN],dis[MAXN],t[MAXN],F[MAXN];
long long ans,f[MAXN][2],g[MAXN][2];
inline int read()
{
    int x=0,f=1;  char ch=getchar();
    while(!isdigit(ch))  {if(ch=='-')  f=-1;  ch=getchar();}
    while(isdigit(ch))  {x=x*10+ch-'0';  ch=getchar();}
    return x*f;
}
void insert(int x,int y,int v) {e[++len].next=Link[x]; Link[x]=len; e[len].y=y; e[len].v=v;}
void getroot(int x,int fa)
{
    son[x]=1;F[x]=0;
    for(int i=Link[x];i;i=e[i].next)
        if(e[i].y!=fa&&!vis[e[i].y])
        {
            getroot(e[i].y,x);
            son[x]+=son[e[i].y];
            F[x]=max(F[x],son[e[i].y]);
        }
    F[x]=max(F[x],sum-son[x]);
    if(F[x]<F[root])root=x;
}
void dfs(int x,int fa)
{
    mxdeep=max(mxdeep,deep[x]);
    if(t[dis[x]])  f[dis[x]][1]++;
    else f[dis[x]][0]++;
    t[dis[x]]++;
    for(int i=Link[x];i;i=e[i].next)
        if(!vis[e[i].y]&&e[i].y!=fa)
        {
            dis[e[i].y]=dis[x]+e[i].v;
            deep[e[i].y]=deep[x]+1;
            dfs(e[i].y,x);
        }
    t[dis[x]]--;
}
void work(int x)
{
    g[n][0]=1;  vis[x]=1;  int mx=0;
    for(int i=Link[x];i;i=e[i].next)
        if(!vis[e[i].y])
        {
            dis[e[i].y]=n+e[i].v;  deep[e[i].y]=1;
            mxdeep=1;  dfs(e[i].y,0);  mx=max(mx,mxdeep);
            ans+=(g[n][0]-1)*f[n][0];
            for(int j=-mxdeep;j<=mxdeep;j++)
                ans+=g[n-j][1]*f[n+j][1]+g[n-j][0]*f[n+j][1]+g[n-j][1]*f[n+j][0];
            for(int j=n-mxdeep;j<=n+mxdeep;j++)
            {
                g[j][0]+=f[j][0];
                g[j][1]+=f[j][1];
                f[j][0]=f[j][1]=0;
            }
        }
    for(int i=n-mx;i<=n+mx;i++)
        g[i][0]=g[i][1]=0;
    for(int i=Link[x];i;i=e[i].next)
        if(!vis[e[i].y])
        {
            root=0;
            sum=son[e[i].y];
            getroot(e[i].y,0);
            work(root);
        }
}
int main()
{
    //freopen("cin.in","r",stdin);
    //freopen("cout.out","w",stdout);
    n=read();
    for(int i=1;i<n;i++)
    {
        int x=read(),y=read(),v=read();
        if(!v)  v=-1;
        insert(x,y,v);  insert(y,x,v);
    }
    sum=F[0]=n;
    getroot(1,0);
    work(root);
    printf("%lld\n",ans);
    return 0;
}