BZOJ2599:[IOI2011]Race(点分治)

Description

给一棵树,每条边有权.求一条简单路径,权值和等于K,且边的数量最小.N <= 200000, K <= 1000000

Input

第一行 两个整数 n, k
第二..n行 每行三个整数 表示一条无向边的两端和权值 (注意点的编号从0开始)

Output

一个整数 表示最小边数量 如果不存在这样的路径 输出-1

Sample Input

4 3
0 1 1
1 2 2
1 3 4

Sample Output

2

Solution

开一个100W的数组t，t[i]表示到当前处理的树的根距离为i的最小边数
对于点x，我们要统计经过x的路径的话
就分别统计x的每颗子树，在统计一颗子树的时候用t[i]更新答案
并在每统计完一颗子树后更新t数组
↑这样是为了防止统计答案的时候两个点在同一子树里

Code

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #define N (200000+100)
 using namespace std;
 struct node
 {
     int to,next,len;
 }edge[N*];
 int n,k,sum,root,ans,INF;
 int head[N],num_edge;
 int depth[N],d[N],size[N],maxn[N];
 int dis[N],t[N*];
 bool vis[N];

 void add(int u,int v,int l)
 {
     edge[++num_edge].to=v;
     edge[num_edge].len=l;
     edge[num_edge].next=head[u];
     head[u]=num_edge;
 }

 void Get_root(int x,int fa)
 {
     size[x]=; maxn[x]=;
     for (int i=head[x];i!=;i=edge[i].next)
         if (edge[i].to!=fa && !vis[edge[i].to])
         {
             Get_root(edge[i].to,x);
             size[x]+=size[edge[i].to];
             maxn[x]=max(maxn[x],size[edge[i].to]);
         }
     maxn[x]=max(maxn[x],sum-size[x]);
     if (maxn[x]<maxn[root]) root=x;
 }

 void Calc(int x,int fa)
 {
     if (dis[x]<=k) ans=min(ans,depth[x]+t[k-dis[x]]);
     for (int i=head[x];i!=;i=edge[i].next)
         if (!vis[edge[i].to] && edge[i].to!=fa)
         {
             dis[edge[i].to]=dis[x]+edge[i].len;
             depth[edge[i].to]=depth[x]+;
             Calc(edge[i].to,x);
         }
 }

 void Reset(int x,int fa,int flag)
 {
     if (dis[x]<=k)
     {
         if (flag) t[dis[x]]=min(t[dis[x]],depth[x]);
         else t[dis[x]]=INF;
     }
     for (int i=head[x];i!=;i=edge[i].next)
         if (edge[i].to!=fa && !vis[edge[i].to])
             Reset(edge[i].to,x,flag);
 }

 void Solve(int x)
 {
     vis[x]=true; t[]=;
     for (int i=head[x];i!=;i=edge[i].next)
         if (!vis[edge[i].to])
         {
             depth[edge[i].to]=;
             dis[edge[i].to]=edge[i].len;
             Calc(edge[i].to,);
             Reset(edge[i].to,,);
         }
     for (int i=head[x];i!=;i=edge[i].next)
         if (!vis[edge[i].to])
             Reset(edge[i].to,,);
     for (int i=head[x];i!=;i=edge[i].next)
         if (!vis[edge[i].to])
         {
             sum=size[edge[i].to];
             root=;
             Get_root(edge[i].to,);
             Solve(root);
         }

 }

 int main()
 {
     int u,v,l;
     memset(t,0x3f,sizeof(t));
     memset(&INF,0x3f,sizeof(INF));
     scanf("%d%d",&n,&k);
     for (int i=;i<=n-;++i)
     {
         scanf("%d%d%d",&u,&v,&l);
         u++; v++;
         add(u,v,l); add(v,u,l);
     }
     ans=sum=maxn[]=n;
     Get_root(,);
     Solve(root);
     printf("%d",ans==n?-:ans);
 }