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*2];
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*5];
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]=1; maxn[x]=0;
    for (int i=head[x];i!=0;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!=0;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]+1;
            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!=0;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[0]=0;
    for (int i=head[x];i!=0;i=edge[i].next)
        if (!vis[edge[i].to])
        {
            depth[edge[i].to]=1;
            dis[edge[i].to]=edge[i].len;
            Calc(edge[i].to,0);
            Reset(edge[i].to,0,1);
        }
    for (int i=head[x];i!=0;i=edge[i].next) 
        if (!vis[edge[i].to])
            Reset(edge[i].to,0,0);
    for (int i=head[x];i!=0;i=edge[i].next)
        if (!vis[edge[i].to])
        {
            sum=size[edge[i].to];
            root=0;
            Get_root(edge[i].to,0);
            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=1;i<=n-1;++i)
    {
        scanf("%d%d%d",&u,&v,&l);
        u++; v++;
        add(u,v,l); add(v,u,l);
    }
    ans=sum=maxn[0]=n;
    Get_root(1,0);
    Solve(root);
    printf("%d",ans==n?-1:ans);
}