树上的点对

【题意】

给定一棵边带权的无根树，求树上距离不超过k的无序互异点对的个数。

【解法】

树分治练手题……

三种分治，点分治，边分治，链分治，都可以。

点分治应该也不难写，然而懒得写平衡树了，就用的相对好想好写的边分治。(因为感觉点分治需要用平衡树……)

点分治是选重心当根节点，然后统计经过根节点的路径数。边分治则是直接找一个切断后能使两边的树尽量平衡的边，统计经过边的路径数。

具体写的时候把两边的距离分别扔到两个vector里，然后二分即可。或者直接根据单调性线性扫描。

统计路径的时候如果线性扫描的话，那么复杂度是O(nlogn)，好像比点分治的O(nlog²n)快一些。然而由于常数限制，实际上还是很慢的。

最坏情况下递归深度会达到O(n)(比如菊花形的树)，所以要通过插入白点的方式改进最坏复杂度。通过在点到儿子的路径上插入白点来把每个点的儿子个数降到<=2，这样每个点的度数均不超过3，递归的最大深度为O(logn)。

由于建成的树形似线段树，所以树的规模最多扩大一倍，只是常数问题。总复杂度还是O(nlogn)。

第一次写树分治，写的比较丑……凑合看吧。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
const int maxn=50010;
struct edge{
    int to,w,prev;
    bool vis;
}e[maxn<<1];
void predfs(int,int);//预处理，添白点
void addedge(int,int,int);
void solve(int);
void dfs(int,int);//算size
void dfs1(int,int,int&);//找用来分治的边
void dfs2(int,int,int,vector<int>&);//算距离
int n,k,last[maxn],len,size[maxn],siz,tmp,ans,du[maxn],x,y,z;
bool white[maxn]={false};
vector<int>a,b;
vector<pair<int,int> >G[maxn];
int main(){
#define MINE
#ifdef MINE
    freopen("poj1741_tree.in","r",stdin);
    freopen("poj1741_tree.out","w",stdout);
#endif
    while(scanf("%d%d",&n,&k)==2&&n&&k){
        memset(last,-1,sizeof(last));
        memset(white,0,sizeof(white));
        memset(du,0,sizeof(du));
        for(int i=1;i<=20000;i++)G[i].clear();
        len=0;
        for(int i=1;i<n;i++){
            scanf("%d%d%d",&x,&y,&z);
            G[x].push_back(make_pair(y,z));
            G[y].push_back(make_pair(x,z));
        }
        ans=0;
        predfs(1,0);
        solve(1);
        printf("%d\n",ans);
    }
#ifndef MINE
    printf("\n--------------------DONE--------------------\n");
    for(;;);
#endif
    return 0;
}
void predfs(int x,int p){
    int cnt=G[x].size();
    for(int i=0;i<cnt;i++)if(G[x][i].first!=p)predfs(G[x][i].first,x);
    queue<pair<int,int> >q;
    for(int i=0;i<cnt;i++)if(G[x][i].first!=p)q.push(G[x][i]);
    cnt=q.size();
    while(cnt>2){
        pair<int,int>a=q.front();q.pop();
        pair<int,int>b=q.front();q.pop();
        int y=++n;
        white[y]=true;
        addedge(y,a.first,a.second);
        addedge(a.first,y,a.second);
        addedge(y,b.first,b.second);
        addedge(b.first,y,b.second);
        q.push(make_pair(y,0));
        cnt--;
    }
    while(!q.empty()){
        addedge(x,q.front().first,q.front().second);
        addedge(q.front().first,x,q.front().second);
        q.pop();
    }
}
void addedge(int x,int y,int z){
    e[len].to=y;
    e[len].w=z;
    e[len].prev=last[x];
    last[x]=len++;
}
void solve(int x){
    tmp=~(1<<31);
    int id=-1;
    dfs(x,0);
    siz=size[x];
    dfs1(x,0,id);
    if(id==-1)return;
    e[id].vis=e[id^1].vis=true;
    solve(e[id].to);
    solve(e[id^1].to);
    a.clear();
    b.clear();
    dfs2(e[id].to,0,0,a);
    dfs2(e[id^1].to,0,0,b);
    sort(a.begin(),a.end());
    sort(b.begin(),b.end());
    int cnta=a.size(),cntb=b.size();
    for(int i=0,j=cntb-1;i<cnta;i++){
        while(~j&&k-a[i]-e[id].w<b[j])j--;
        ans+=j+1;
    }
    e[id].vis=e[id^1].vis=false;
}
void dfs(int x,int p){
    size[x]=1;
    for(int i=last[x];i!=-1;i=e[i].prev)if(e[i].to!=p&&!e[i].vis){
        dfs(e[i].to,x);
        size[x]+=size[e[i].to];
    }
}
void dfs1(int x,int p,int &id){
    for(int i=last[x];i!=-1;i=e[i].prev)if(e[i].to!=p&&!e[i].vis){
        if(abs(size[e[i].to]-(siz-size[e[i].to]))<tmp){
            id=i;
            tmp=abs(size[e[i].to]-(siz-size[e[i].to]));
        }
        dfs1(e[i].to,x,id);
    }
}
void dfs2(int x,int p,int d,vector<int>&a){
    if(!white[x])a.push_back(d);
    for(int i=last[x];i!=-1;i=e[i].prev)if(e[i].to!=p&&!e[i].vis)dfs2(e[i].to,x,d+e[i].w,a);
}

【后记】

第一道树分治，就这样献给边分治了……

看好多神犇用的都是点分治，感觉自己真奇葩……

 

尽头和开端，总有一个在等你。