关于分治的入门专题

最近一直刷bzoj，没有开新专题，所以开了个新专题分治。

主要是刷到几道题要用分治，但不会，所以本蒟蒻决定入个门。

首先先看个qzc大神的论文：《分治算法在树的路径问题中的应用》

然后来到入门题：poj1741，题目大意详见论文。

Orz   lishaozhe1024

我们随便找一点作为根，将无根树转化为有根树

那么树的路径分为两种 ， 一种是经过树根的 ， 另外一种是不经过树根

如果我们有办法求出路径经过树根的有多少对点 ，那么不经过树根的，只要递归子树就行了 ， 这样问题就得到解决了

那么分治 ， 我们先看如何分 ，在最坏的情况下，比如一条链的情况，我们可能要递归 N 次 ， 这样的复杂度肯定不是我们想要的 。

那么如果避免这样的情况 ， 就是在选择根的时候，我们选择这棵树的“重心”，所谓树的重心，就是这个点的所有子树的结点个数的最大值是最小的。

如何求树的重心 ， 先dfs一遍，求出每个结点的子树的结点的最大值dp[i]和以这个结点为根的树的结点总和sum[i]。那么第二次dfs的时候，比较dp[i] 和 sum[root] - sum[i] 的最大值即可。

这样的分治策略 ，最坏情况的递归次数是 logN 的

然后看如何治 ，我们要求的是有多少点对的路径之和小于等于K，并且是经过根节点的。

那么我们先一遍dfs求出每个结点到根节点的距离 ， 放在一个数组中 ， 排完序之后 ， 我们可以 two pointer 求出选两个数，和小于等于K的方案数( 复杂度为O(n) ) 。

这样求得的答案包括了两个顶点都来自同一子树的情况 ， 这样就不经过根节点了， 所以我们要把这些情况减掉

我们只要对各个子树同样求一遍答案，减去即可。

假如排序我们用快排，那么整个算法的复杂度是 O( NlogNlogN )

代码：

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=10010;
const int M=50100;
int n,k;
struct node{
	int x,y,z,next;
}sa[M];int len,first[N];
bool vis[N];
int ans,mi,mx[N],size[N],root,num;
void init()
{
	memset(first,-1,sizeof(first));
	memset(vis,0,sizeof(vis));
	len=0;ans=0;
}
void ins(int x,int y,int z)
{
	len++;
	sa[len].x=x;
	sa[len].y=y;
	sa[len].z=z;
	sa[len].next=first[x];
	first[x]=len;
}
void dfssize(int x,int fa)
{
	mx[x]=0;
	size[x]=1;
	for(int i=first[x];i!=-1;i=sa[i].next)
	{
		int y=sa[i].y;
		if(!vis[y] && y!=fa)
		{
			dfssize(y,x);
			if(size[y]>mx[x]) mx[x]=size[y];
			size[x]+=size[y];
		}
	}
}
void dfsroot(int r,int u,int fa)
{
	if(size[r]-size[u]>mx[u]) mx[u]=size[r]-size[u];
	if(mx[u]<mi) mi=mx[u],root=u;
	for(int i=first[u];i!=-1;i=sa[i].next)
	{
		int y=sa[i].y;
		if(!vis[y]&&y!=fa) dfsroot(r,y,u);
	}
}
int dis[N];
void dfsdis(int x,int d,int fa)
{
	dis[++num]=d;
	for(int i=first[x];i!=-1;i=sa[i].next)
	{
		int y=sa[i].y;
		if(!vis[y]&&y!=fa) dfsdis(y,d+sa[i].z,x);
	}
}
int cale(int u,int d)
{
	int ret=0;
	num=0;
	dfsdis(u,d,0);
	sort(dis+1,dis+1+num);
	int l=1,r=num;
	while(l<r)
	{
		while(dis[l]+dis[r]>k&&l<r) r--;
		ret+=r-l;
		l++;
	}
	return ret;
}
void dfs(int x)
{
	mi=n;
	dfssize(x,0);
	dfsroot(x,x,0);
	ans+=cale(root,0);
	vis[root]=1;
	for(int i=first[root];i!=-1;i=sa[i].next)
	{
		int y=sa[i].y;
		if(!vis[y]) 
		{
			ans-=cale(y,sa[i].z);
		     dfs(y);
		}
	}
}
int main()
{
	while(scanf("%d%d",&n,&k)!=EOF)
	{
		if(!n&&!k) break;//
		init();
		for(int i=1;i<n;i++)
		{
			int u,v,z;
			scanf("%d%d%d",&u,&v,&z);//printf("!");
			ins(u,v,z);
			ins(v,u,z);
		}
		dfs(1);
		
		printf("%d\n",ans);
	}
	return 0;
}

orz qzc

论文的第二题一脸懵逼，看了题解还是一脸懵逼。（我能怎么办，我也很绝望啊！）

于是强行理解了一波，觉得自己理解的太垃圾，所不写出来了，等我做多几道分治题再写。

奉上一个膜了N多神牛的代码：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=201000;
int n, k, head[MAXN], cnt, root, min1, ans;
int F[MAXN];
int G[MAXN];
int size[MAXN],color[MAXN],vis[MAXN],num[MAXN];
struct node
{
        int u,v,w,next;
}edge[MAXN<<1];
struct N
{
        int v, num, w;
}T[MAXN];
bool cmp(N x, N y)
{
        return x.num<y.num;
}
void add(int u, int v, int w)
{
        edge[cnt].v=v;
        edge[cnt].w=w;
        edge[cnt].next=head[u];
        head[u]=cnt++;
}
void init()
{
        memset(head,-1,sizeof(head));
        memset(color,0,sizeof(color));
        memset(vis,0,sizeof(vis));
        cnt=0;
}
void dfsroot(int u, int fa, int s)
{
        int i, max1=-1;
        for(i=head[u];i!=-1;i=edge[i].next){
                int v=edge[i].v;
                if(v==fa||vis[v]) continue ;
                dfsroot(v,u,s);
                max1=max(max1,size[v]);
        }
        max1=max(max1,s-size[u]);
        if(min1>max1){
                min1=max1;
                root=u;
        }
}
void dfssize(int u, int fa)
{
        size[u]=1;
        for(int i=head[u];i!=-1;i=edge[i].next){
                int v=edge[i].v;
                if(v==fa||vis[v]) continue ;
                dfssize(v,u);
                size[u]+=size[v];
        }
}
void getnum(int u, int fa)
{
        num[u]=color[u];
        for(int i=head[u];i!=-1;i=edge[i].next){
                int v=edge[i].v;
                if(v==fa||vis[v]) continue ;
                getnum(v,u);
                num[u]=max(num[u],num[v]+color[u]);
        }
}
void getG(int u, int fa, int dep, int val)
{
        G[dep]=max(G[dep],val);
        for(int i=head[u];i!=-1;i=edge[i].next){
                int v=edge[i].v;
                if(v==fa||vis[v]) continue ;
                getG(v,u,dep+color[v],val+edge[i].w);
        }
}
void dfs(int u)
{
        vis[u]=1;
        int i, j;
        for(i=head[u];i!=-1;i=edge[i].next){
                int v=edge[i].v;
                if(vis[v]) continue ;
                dfssize(v,-1);
                min1=INF;
                dfsroot(v,-1,size[v]);
                dfs(root);
        }
        int tot=0;
        for(i=head[u];i!=-1;i=edge[i].next){
                int v=edge[i].v;
                if(vis[v]) continue ;
                getnum(v,-1);
                T[tot].v=v;
                T[tot].num=num[v];
                T[tot].w=edge[i].w;
                tot++;
        }
        sort(T,T+tot,cmp);
        int lim=k-color[u];
        for(i=0;i<=T[tot-1].num;i++) F[i]=-INF;
        for(i=0;i<tot;i++){
                for(j=0;j<=T[i].num;j++) G[j]=-INF;
                getG(T[i].v,u,color[T[i].v],T[i].w);
                if(i){
                        for(j=0;j<=T[i].num&&j<=lim;j++){
                                int tmp=min(lim-j,T[i-1].num);
                                if(F[tmp]==-INF) continue ;
                                ans=max(ans,F[tmp]+G[j]);
                        }
                }
                for(j=0;j<=T[i].num&&j<=lim;j++){
                        F[j]=max(F[j],G[j]);
                        if(j) F[j]=max(F[j],F[j-1]);
                        ans=max(ans,F[j]);
                        
                }
        }
        vis[u]=0;
}
int main()
{
        int m, i, u, v, w, x;
        while(scanf("%d%d%d",&n,&k,&m)!=EOF){
                init();
                for(i=0;i<m;i++){
                        scanf("%d",&x);
                        color[x]=1;
                }
                for(i=1;i<n;i++){
                        scanf("%d%d%d",&u,&v,&w);
                        add(u,v,w);
                        add(v,u,w);
                }
                ans=0;
                dfssize(1,-1);
                min1=INF;
                dfsroot(1,-1,n);
                dfs(root);
                printf("%d\n",ans);
        }
        return 0;
}