2018年3月14日训练日记

这次训练总结是3月12日至3月14日。意识到不能只记得做题了，还有部分比较基础的知识点没有学习。

回顾树的直径 : 

树的直径是指树的最长简单路，即树的最长简单路。
现有结论，从任意一点u出发搜到的最远的点一定是s、t中的一点，然后在从这个最远点开始搜，就可以搜到另一个最长路的端点，即用两遍广搜就可以找出树的最长路。
step1：以树中任意一个结点为源点，进行一次广度优先遍历，找出离源点距离最远的点d
step2：以d为源点，进行一次广度优先遍历，找出离d最远的点，并记录其长度

回顾树的重心：（by pi9nc）

定义：以这个点为根，那么所有的子树（不算整个树自身）的大小都不超过整个树大小的一半。
树的重心的一个的性质：
树中所有点到某个点的距离和中，到重心的距离和是最小的；如果有两个重心，那么他们的距离和一样。
这也是“道路修建”带来的启发。（证明：调整法）
树的重心的另一个性质：
把两个树通过一条边相连得到一个新的树，那么新的树的重心在连接原来两个树的重心的路径上。
这个让“重心”名副其实了。。。（证明：自己想想）
还有一个性质：
把一个树添加或删除一个叶子，那么它的重心最多只移动一条边的距离。
（证明：自己想想）

核心代码：

void DFS(int s)  
{  
    vd[s] = 1;  
    son[s] = 0;  
    int blance = 0;  
    int size = adj[s].size();  
    for (int j = 0;j < size;j++)  
    {  
        int u = adj[s][j];  
        if (vd[u]) continue;  
        DFS(u);  
        son[s] += son[u]+1;  
        blance = max(blance,son[u]+1);  
    }  
    blance = max(blance,n - son[s] - 1);  
    if (blance < asize || blance == asize && s < ans)  
        ans = s,asize = blance;  
} 

树的分治： (by DOLEAM )

分治，指的是分而治之，即将一个问题分割成一些规模较小的相互独立的子问题，以便各个击破。
我们常见的是在一个线性结构上进行分治，而分治算法在树结构上的运用，称之为树的分治算法。
分治往往与高效联系在一起，而树的分治正是一种用来解决树的路径问题的高效算法。
树的点的分治：首先选取一个点将无根树转为有根树，再递归处理每一颗以根结点的儿子为根的子树。
首先我们考虑如何选取点。对于基于点的分治，我们选取一个点，要求将其删去后，结点最多的树的结点个数最小，这个点就是树的重心。
在基于点的分治中每次我们都会将树的结点个数减少一半，因此递归深度最坏是 O(NlogN) 的，在树是一条链的时候达到上界。
对于一棵有根树， 树中满足要求的一个数对所对应的一条路径，必然是以下两种情况之一：
1、经过根节点
2、不经过根节点，也就是说在根节点的一棵子树中
对于情况2，可以递归求解，下面主要来考虑情况1。
设点i的深度为Depth[i]，父亲为Parent[i]。
若i为根，则Belong[i]=-1，若Parent[i]为根，则Belong[i]=i，否则Belong[i]=Belong[Parent[i]]。
这三个量都可以通过一次BFS求得。
我们的目标是要统计：有多少对(i,j)满足i<j，Depth[i]+Depth[j]<=K且Belong[i]<>Belong[j]
如果这样考虑问题会变得比较麻烦，我们可以考虑换一种角度：
设X为满足i<j且Depth[i]+Depth[j]<=K的数对(i,j)的个数
设Y为满足i<j，Depth[i]+Depth[j]<=K且Belong[i]=Belong[j]数对(i,j)的个数
那么我们要统计的量便等于X-Y
求X、Y的过程均可以转化为以下问题：
已知A[1],A[2],...A[m]，求满足i<j且A[i]+A[j]<=K的数对(i,j)的个数
对于这个问题，我们先将A从小到大排序。
设B[i]表示满足A[i]+A[p]<=K的最大的p(若不存在则为0)。我们的任务便转化为求出A所对应的B数组。那么，若B[i]>i，那么i对答案的贡献为B[i]-i。
显然，随着i的增大，B[i]的值是不会增大的。利用这个性质，我们可以在线性的时间内求出B数组，从而得到答案。

综上，设递归最大层数为L，因为每一层的时间复杂度均为“瓶颈”——排序的时间复杂度O(NlogN)，所以总的时间复杂度为O(L*NlogN)

然而，如果遇到极端情况——这棵树是一根链，那么随意分割势必会导致层数达到O(N)级别，对于N=10000的数据是无法承受的。因此，我们在每一棵子树中选择“最优”的点分割。所谓“最优”，是指删除这个点后最大的子树尽量小。这个点可以通过树形DP在O(N)时间内求出，不会增加时间复杂度。这样一来，即使是遇到一根链的情况时，L的值也仅仅是O(logN)的。

简单来说：点分治就是每次找到重心，然后把重心去掉，对分成的每两棵树之间分别统计路径信息（以重心的每个相邻点为根，遍历整棵子树即可得到这个根到每个结点的统计信息），就可以知道包含这个重心的所有路径的信息，然后对于剩下的路径就是在子树里面进行同样的操作了，直到只剩一个点为止（注意这一个点所构成的路径有时也要处理一下）。边分治就是每次找到一条边，使得删掉这条边后分成的两棵子树大小尽可能平均，然后以删掉的边的两端点为根，分别统计根到两棵树中的每个结点的路径信息，最后合并算路径，即可得到包含这条边的所有路径的信息，剩下的路径在两棵树中递归处理。

经典例题：POJ 1741 TREE

题意：给你一棵TREE,以及这棵树上边的距离。问有多少对点它们两者间的距离小于等于K。

 

我们知道一条路径要么过根结点，要么在一棵子树中，这启发了我们可以使用分治算法。

只要先求出经过根结点的路径数，再递归的求经过所有子结点的路径数即可。

下面来分析如何处理路径过根结点的情况。 

我们先用一次搜索求出根的所有子结点到根的距离并将其放入一个数组中，复杂度O(n)。

将这个距离数组排序，复杂度O(nlogn)。

这样就将问题转化为了，求一个数组A中，和小于等于K的元素对个数有多少。

由于数组有序，对于区间[L,R]，易知若A[L]+A[R]>K，那么区间内没有满足条件的元素对。若A[L]+A[R]<=K，则以L为左端点的点对数有R-L个。

我们从1开始枚举L，当前R不满足条件，就令R-1，否则统计以L为左端点的点对数，令L-1。

用一个线性扫描的扫描可以解决，复杂度O(n)。

最终我们得到了所有子结点到根的距离和小于等于K的点对数。

然而这个并不是最终解，因为我们要求的是经过根的路径，而从一个子树到达根结点又回到同一个子树的路径是不能被计入统计的，所以我们要把多余的点对从结果中减去。

我们只要对每一个子树，求出同一个子树中的结点到根结点又回到子树的路径和小于等于K的点对数，然后从答案中减去即可。 即对于在同一个子树中的节点，在搜大树的时候先不做任何处理。在搜子树的时候减去即可。

大佬的AC代码：

#include<iostream>  
#include<cstdio>  
#include<string>  
#include<cstring>  
#include<vector>  
#include<cmath>  
#include<queue>  
#include<stack>  
#include<map>  
#include<set>  
#include<algorithm>  
using namespace std;  
const int maxn=10010;  
int N,K;  
int ans,root,Max;  
struct node  
{  
    int v,next,w;  
}edge[maxn*2];  
int head[maxn],tot;  
int size[maxn];//树的大小  
int maxv[maxn];//最大孩子节点的size  
int vis[maxn];  
int dis[maxn];  
int num;  
void init()  
{  
    tot=0;  
    ans=0;  
    memset(head,-1,sizeof(head));  
    memset(vis,0,sizeof(vis));  
}  
void add_edge(int u,int v,int w)  
{  
    edge[tot].v=v;  
    edge[tot].w=w;  
    edge[tot].next=head[u];  
    head[u]=tot++;  
}  
//处理子树的大小  
void dfssize(int u,int f)  
{  
    size[u]=1;  
    maxv[u]=0;  
    for(int i=head[u];i!=-1;i=edge[i].next)  
    {  
        int v=edge[i].v;  
        if(v==f||vis[v])continue;  
        dfssize(v,u);  
        size[u]+=size[v];  
        if(size[v]>maxv[u])maxv[u]=size[v];  
    }  
}  
//找重心  
void dfsroot(int r,int u,int f)  
{  
    if(size[r]-size[u]>maxv[u])//size[r]-size[u]是u上面部分的树的尺寸，跟u的最大孩子比，找到最大孩子的最小差值节点  
        maxv[u]=size[r]-size[u];  
    if(maxv[u]<Max)Max=maxv[u],root=u;  
    for(int i=head[u];i!=-1;i=edge[i].next)  
    {  
        int v=edge[i].v;  
        if(v==f||vis[v])continue;  
        dfsroot(r,v,u);  
    }  
}  
//求每个点离重心的距离  
void dfsdis(int u,int d,int f)  
{  
    dis[num++]=d;  
    for(int i=head[u];i!=-1;i=edge[i].next)  
    {  
        int v=edge[i].v;  
        if(v!=f&&!vis[v])  
            dfsdis(v,d+edge[i].w,u);  
    }  
}  
//计算以u为根的子树中有多少点对的距离小于等于K  
int calc(int u,int d)  
{  
    int ret=0;  
    num=0;  
    dfsdis(u,d,0);  
    sort(dis,dis+num);  
    int i=0,j=num-1;  
    while(i<j)  
    {  
        while(dis[i]+dis[j]>K&&i<j)j--;  
        ret+=j-i;  
        i++;  
    }  
    return ret;  
}  
void dfs(int u)  
{  
    Max=N;  
    dfssize(u,0);  
    dfsroot(u,u,0);  
    ans+=calc(root,0);  
    vis[root]=1;  
    for(int i=head[root];i!=-1;i=edge[i].next)  
    {  
        int v=edge[i].v;  
        if(!vis[v])  
        {  
            ans-=calc(v,edge[i].w);  
            dfs(v);  
        }  
    }  
}  
int main()  
{  
    while(scanf("%d%d",&N,&K)!=EOF)  
    {  
        if(!N&&!K)break;  
        int u,v,w;  
        init();  
        for(int i=1;i<N;i++)  
        {  
            scanf("%d%d%d",&u,&v,&w);  
            add_edge(u,v,w);  
            add_edge(v,u,w);  
        }  
  
        dfs(1);  
        printf("%d\n",ans);  
    }  
    return 0;  
} 

至于LCA，只是在一些零碎的时间看了一些博客资料，这几天会做一下总结。

 

 

 

 

 

 

 

 

 

向伟人 史蒂芬·霍金 致敬。

我们没有任何理由不努力。