树上点对统计poj1741(树的点分治)

给定一棵树,边上有权值,要统计有多少对点路径的权值和<=k

分治算法在树的路径中的应用 这个论文里面有分析。

任意两点的路径,要么过根结点,要么在子树中。如果在子树中,那么只要递归处理就行了。

所以只要统计过根结点的对数。

所以只要算出任意结点到根结点的距离,用dist数组存下来,然后排序dist数组,就可以在O(n)的时间内算出有多少对点满足条件,具体见counts函数

但是counter函数计算时,会把路径都在子树中的情况也给加进来,所以需要再对相应的子树进行counts函数,然后减去。

然后在递归计算路径经过孩子结点的情况。

但是这样子的算法是会退化的,因为树可能是一条链。

所以就需要用到重心了。 因为重心具有的一个性质是删掉重心后,可以使得剩下的分支中,最大的最小。

所以在算出所有经过u的点对之后,递归计算v这个子树时,相当于计算一棵全新的树,所以只要找到这棵树的重心,继续计算就行了。

因为结点数可以每次都减少为原来的一般,所以层数只有logn层, 每层统计时,排序要nlogn,所以总的时间复杂度是n*logn*logn

 #pragma warning(disable:4996)
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <bitset>
#include <algorithm>
#include <iostream>
#include <string>
#include <functional>
const int INF = << ;
typedef __int64 LL;
/*
dist(u,v)为u,v两点路径上所有边的权和
如果dist(u,v)<=k,那么称(a,b)为合法点对
求合法点对的个数
N<=10000, k<=10^9 depth(i) + depth(j) <=k 且belong(i)!=belong(j) 我的问题是? 分治的时候,如何将树两边的点合起来???
*/
const int N = + ;
struct Node
{
int to, next, dis;
}g[N];
int head[N], e;
int n, k, ans;
int size[N];
int mins, total, root;
int dist[N], p;
int vis[N];
int cnt[N];
void addEdge(int u, int v, int dis)
{
g[e].to = v;
g[e].dis = dis;
g[e].next = head[u];
head[u] = e++;
} void dfsRoot(int u, int f)
{
size[u] = ;
int mxs = ;
for (int i = head[u]; i != -; i = g[i].next)
{
int v = g[i].to;
if (v == f || vis[v]) continue;
dfsRoot(v, u);
size[u] += size[v];
mxs = std::max(mxs, size[v]);
}
//下面是找重心的代码
if(mxs < total - size[u])
mxs = total - size[u];
if (mxs < mins)
mins = mxs, root = u;
} void getDis(int u, int f, int dis)
{
dist[p++] = dis;//遍历没有访问过的点,将到根结点的距离存下来
for (int i = head[u]; i != -; i = g[i].next)
{
int v = g[i].to;
if (v == f || vis[v]) continue;
getDis(v, u, dis + g[i].dis);
}
}
int counts(int u, int dis)
{
int ret = ;
p = ;
getDis(u, , dis);//得到dist数组
std::sort(dist, dist + p);//每访问一个重心都要排序一次,所以是n*logn*logn
int l = , r = p - ;
while (l < r)
{
//如果dist[l]+dist[r]<=k ,那么dist[l]+任意的点都是可行的
if (dist[l] + dist[r] <= k)
{
ret += (r - l);
l++;//判断下一个l
}
else//如果这个r不行,那么这个r与谁结合都是不行的
r--;
}
return ret;
} void go(int u)
{
//total存的是子树所有结点
mins = INF, total = size[u] ? size[u] : n;
dfsRoot(u, -);//找到重心
u = root;
vis[u] = true;
cnt[u] = ;
cnt[u] += counts(u, );//统计过这个点的点对
//但是会发生一个错误就是可能统计了位于同一棵子树的点
for (int i = head[u]; i != -; i = g[i].next)
{
int v = g[i].to;
if (vis[v]) continue;
cnt[u] -= counts(v, g[i].dis);//所有要减去位于同一棵子树的点
go(v);
}
}
int main()
{ while(scanf("%d%d", &n, &k),n+k)
{
int u, v, dis;
e = ;
memset(head, -, sizeof(head));
for (int i = ;i < n;++i)
{
scanf("%d%d%d", &u, &v, &dis);
addEdge(u, v, dis); addEdge(v, u, dis);
}
ans = ;
size[] = ;
memset(vis, , sizeof(vis));
go();
for (int i = ;i <= n;++i)
ans += cnt[i];
printf("%d\n", ans);
}
return ;
}
上一篇:201521123027 第七周学习总结


下一篇:java.util.concurrent ThreadPoolExecutor源码分析