[POJ1741]Tree（点分治）

题目描述

传送门

题解

点分治板子题。
可以证明，一棵n个节点的树中一定存在一个点使得去掉这个点之后所有的子树大小<=n/2。并且树的重心一定是最优的。
于是每次找到树的重心然后把树拆分开，每一层遍历所有的节点，我们就可以得到一个 O(nlogn) 的算法。
每一次遍历统计所有点的深度，两点之间的距离暂且记为深度之和。将路径分成两类来考虑，一类是通过树根的，一类是不通过树根的。不通过树根的可以递归计算，通过树根的路径数=所有合法的点对数-在根的同一个儿子的子树里的合法的点对数。于是在计算树根的时候加上个数，在计算根的儿子的时候减去就行了。
那么问题又变成了有若干点，每个点有个深度，求深度和<=k的点对数。其实比较简单，将深度排序了之后用两个指针l和r统计一下就行了。时间复杂度 O(nlogn) 。
那么整个算法的复杂度为 O(nlog2n) 。

代码

#include
#include
#include
#include
using namespace std;
#define N 10005
#define INF 2000000000

int n,k,x,y,z,root,sum,ans;
int tot,point[N],nxt[N*2],v[N*2],c[N*2];
int size[N],big[N],d[N],deep[N];
bool vis[N];

inline void clear()
{
    root=ans=sum=0;
    tot=0; memset(point,0,sizeof(point)); memset(nxt,0,sizeof(nxt)); memset(v,0,sizeof(v)); memset(c,0,sizeof(c));
    memset(size,0,sizeof(size)); memset(big,0,sizeof(big)); memset(d,0,sizeof(d)); memset(deep,0,sizeof(deep));
    memset(vis,0,sizeof(vis));
}
void addedge(int x,int y,int z)
{
    ++tot; nxt[tot]=point[x]; point[x]=tot; v[tot]=y; c[tot]=z;
    ++tot; nxt[tot]=point[y]; point[y]=tot; v[tot]=x; c[tot]=z;
}
void getroot(int x,int fa)
{
    size[x]=1; big[x]=0;
    for (int i=point[x];i;i=nxt[i])
        if (v[i]!=fa&&!vis[v[i]])
        {
            getroot(v[i],x);
            size[x]+=size[v[i]];
            big[x]=max(big[x],size[v[i]]);
        }
    big[x]=max(big[x],sum-size[x]);
    if (big[x]void getdeep(int x,int fa)
{
    deep[++deep[0]]=d[x];
    for (int i=point[x];i;i=nxt[i])
        if (v[i]!=fa&&!vis[v[i]])
        {
            d[v[i]]=d[x]+c[i];
            getdeep(v[i],x);
        }
}
int calc(int x,int now)
{
    d[x]=now; deep[0]=0;
    getdeep(x,0);
    sort(deep+1,deep+deep[0]+1);
    int t=0;
    for (int l=1,r=deep[0];lif (deep[l]+deep[r]<=k)
            t+=r-l,l++;
        else r--;
    }
    return t;
}
void dfs(int x)
{
    ans+=calc(x,0);
    vis[x]=true;
    for (int i=point[x];i;i=nxt[i])
        if (!vis[v[i]])
        {
            ans-=calc(v[i],c[i]);
            sum=size[v[i]];
            root=0;
            getroot(v[i],0);
            dfs(root);
        }
}

int main()
{
    while (~scanf("%d%d",&n,&k))
    {
        if (!n&&!k) break;
        clear();
        for (int i=1;iscanf("%d%d%d",&x,&y,&z);
            addedge(x,y,z);
        }
        sum=n; big[0]=INF; root=0;
        getroot(1,0);
        dfs(root);
        printf("%d\n",ans);
    }
}

总结

①点分治可以用来解决树上的路径问题，转换为两个点的深度之和。