POJ 1987 Distance Statistics (树的分治)

这次整理模板整理到分治，然后就补了一道分治的题目，练练手：
这题和POJ 1741一样的题。
上次写树的分治，感觉是一种很厉害的数据结构，现在看来，其实是很简单的一种分治思想而已。
为什么每次都要找重心？因为这样每一个小子树的节点数 <=n/2 <script type="math/tex" id="MathJax-Element-104"><=n/2</script>所以递归计算的层数最多是o(logn)，每一层计算合法点对个数，需要dfs一当前子树的所有结点o(n)，计算所有节点到根的距离，然后按距离长度排序o(nlogn)，o(n)计算出合法点对，所以总的复杂度为o(nlognlogn)。但是我们发现写法中的常数非常大。

ps:今天以为有一道题是树的分治，结果想得有点问题，又重新理解了一边树的点分治，原来以为换根不是真正的换根，现在总算明白了，原树是一个无根树，或者有根树在做题是可以转化成有根树，每一次删掉根，再变成若干个无根树。

下面附上代码：

#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#define LL long long
#define FOR(i,x,y)  for(int i = x;i < y;i ++)
#define IFOR(i,x,y) for(int i = x;i > y;i --)

using namespace std;

const int maxn = 1000100;
const int inf = 1<<30;

int head[maxn],edge_cnt;

struct  Edge{
    int u,v,nt;
    LL w;
}edge[maxn<<1];

void addedge(int u,int v,LL w){
    edge[edge_cnt].u = u;
    edge[edge_cnt].v = v;
    edge[edge_cnt].w = w;
    edge[edge_cnt].nt = head[u];
    head[u] = edge_cnt++;
}

bool vis[maxn]; //表明该点有没有被找过
int sz[maxn],ss[maxn];  //子树节点总数，子结点的子数中的最大值
int lt[maxn],lt_cnt;    //该子树内所有子树标号
int n,m;
LL k;

LL d[maxn];
int d_cnt;  //所有子节点到根的距离

int ans;

//找重心
void dfs_lt(int u,int fa){//遍历整个子树
    lt[lt_cnt++] = u;
    sz[u] = 1;
    ss[u] = 0;
    for(int i = head[u];i != -1;i = edge[i].nt){
        int v = edge[i].v;
        if(v == fa || vis[v])   continue;
        dfs_lt(v,u);
        sz[u] += sz[v];
        ss[u] = max(ss[u],sz[v]);
    }
}

int getroot(int u){
    lt_cnt = 0;
    dfs_lt(u,-1);
    int m_sz = inf,rt;
    FOR(i,0,lt_cnt){
        int tem = max(lt_cnt-sz[lt[i]],ss[lt[i]]);
        if(tem < m_sz)  {m_sz = tem;rt = lt[i];}
    }
    return rt;
}

//计算所有结点到根的距离
void dfs_d(int u,int fa,LL dis){
    d[d_cnt++] = dis;
    for(int i = head[u];i != -1;i = edge[i].nt){
        int v = edge[i].v;
        if(v == fa || vis[v])   continue;
        dfs_d(v,u,dis+edge[i].w);
    }
}

//计算点对
int calc(int u,LL dis){
    d_cnt = 0;
    dfs_d(u,-1,dis);
    sort(d,d+d_cnt);
    int L = 0,R = d_cnt-1;
    int res = 0;
    while(L < R){
        while(d[L] + d[R] > k && L < R)  R--;
        res += (R-L);
        L ++;
    }
    return res;
}

//进行分治
void dfs(int u){
    int rt = getroot(u);
    ans += calc(rt,0);
    vis[rt] = true;
    for(int i = head[rt];i != -1;i = edge[i].nt){
        int v = edge[i].v;
        if(vis[v])  continue;
        ans -= calc(v,edge[i].w);
        dfs(v);
    }
}

void init(){
    memset(head,-1,sizeof(head));
    memset(vis,false,sizeof(vis));
    edge_cnt = 0;
    ans = 0;
}

int main()
{
    //freopen("test.in","r",stdin);
    while(~scanf("%d%d",&n,&m)){
        init();
        char str[5];
        FOR(i,0,m){
            int u,v;
            LL w;
            scanf("%d%d%I64d%s",&u,&v,&w,str);
            addedge(u,v,w);
            addedge(v,u,w);
        }
        scanf("%I64d",&k);
        dfs(1);
        printf("%d\n",ans);
    }
    return 0;
}