[SDOI2011]消防（贪心，图论，树的直径）

[SDOI2011]消防

题目描述

某个国家有n个城市，这n个城市中任意两个都连通且有唯一一条路径，每条连通两个城市的道路的长度为zi(zi<=1000)。

这个国家的人对火焰有超越宇宙的热情，所以这个国家最兴旺的行业是消防业。由于政府对国民的热情忍无可忍（大量的消防经费开销）可是却又无可奈何（总统竞选的国民支持率），所以只能想尽方法提高消防能力。

现在这个国家的经费足以在一条边长度和不超过s的路径（两端都是城市）上建立消防枢纽，为了尽量提高枢纽的利用率，要求其他所有城市到这条路径的距离的最大值最小。

你受命监管这个项目，你当然需要知道应该把枢纽建立在什么位置上。

输入输出格式

输入格式：

输入包含n行：

第1行，两个正整数n和s，中间用一个空格隔开。其中n为城市的个数，s为路径长度的上界。设结点编号以此为1，2，……，n。

从第2行到第n行，每行给出3个用空格隔开的正整数，依次表示每一条边的两个端点编号和长度。例如，“2 4 7”表示连接结点2与4的边的长度为7。

输出格式：

输出包含一个非负整数，即所有城市到选择的路径的最大值，当然这个最大值必须是所有方案中最小的。

输入输出样例

输入样例#1：

5 2

1 2 5

2 3 2

2 4 4

2 5 3

输出样例#1：

5

输入样例#2：

8 6

1 3 2

2 3 2

3 4 6

4 5 3

4 6 4

4 7 2

7 8 3

输出样例#2：

5

说明

【数据规模和约定】

对于20%的数据，n<=300。

对于50%的数据，n<=3000。

对于100%的数据，n<=300000，边长小等于1000。

貌似自己的思路和别人的不太一样啊？？？

本来只打算拿50%的数据的，结果A？！

这道题先求出树的直径，然后我们从底部开始往上枚举，很显然的一个贪心：固定了一个端点之后，另一端点越远越好。所以我们直接枚举端点，找到它的另一端。

这时候我通过LCA\(O(1)\)来计算距离，就可以把此情况的最大距离用\(O(n)\)处理得到。

加上前面的贪心思想，就愉快地AC了？？？

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
int read()
{
    int x=0,w=1;char ch=getchar();
    while(ch>'9'||ch<'0') {if(ch=='-')w=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*w;
}
int n,s,x,y,z,root,t,l,r,cnt,ans=2000000000,sum;
int head[300010],dis[300010],f[300010][20],deep[300010],vis[300010];
struct node{
    int to,next,v;
}edge[600010];
void add(int x,int y,int z)
{
    cnt++;
    edge[cnt].to=y;
    edge[cnt].next=head[x];
    edge[cnt].v=z;
    head[x]=cnt;
}
int LCA(int x,int y)
{
    if(deep[x]<deep[y]) swap(x,y);
    for(int i=19;i>=0;i--)
    {
        if(deep[f[x][i]]>=deep[y]) x=f[x][i];
    }
    if(x==y) return x;
    for(int i=19;i>=0;i--)
    {
        if(f[x][i]!=f[y][i])
            x=f[x][i],y=f[y][i];
    }
    return f[x][0];
}
void init()
{
    for(int i=1;i<=9;i++)
    {
        for(int j=1;j<=n;j++)
        {
            f[j][i]=f[f[j][i-1]][i-1];
        }
    }
}
void dfs1(int k,int fa)
{
    for(int i=head[k];i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v==fa) continue;
        dis[v]=dis[k]+edge[i].v;
        dfs1(v,k);
    }
}
void dfs2(int k,int fa)
{
    for(int i=head[k];i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v==fa) continue;
        dis[v]=dis[k]+edge[i].v;f[v][0]=k;deep[v]=deep[k]+1;
        dfs2(v,k);
    }
}
int main()
{
    n=read();s=read();
    for(int i=1;i<n;i++)
    {
        x=read();y=read();z=read();
        add(x,y,z);add(y,x,z);
    }
    dfs1(1,0);
    for(int i=1;i<=n;i++)
    {
        if(!root||dis[i]>dis[root]) root=i;
    }
    memset(dis,0,sizeof(dis));
    deep[root]=1;dfs2(root,0);
    for(int i=1;i<=n;i++)
    {
        if(!t||dis[i]>dis[t]) t=i;
    }
    init();
    l=t;r=t;vis[t]=1;
    while(l!=0)
    {
        sum=0;
        if(dis[r]-dis[l]>s)
        {
            vis[r]=0;r=f[r][0];vis[r]=1;
        }
        else
        {
            while(dis[r]-dis[l]<=s&&l!=0) {l=f[l][0];vis[l]=1;}
            int rlca;
            for(int i=1;i<=n;i++)
            {
                if(vis[i]) continue;
                int lca1=LCA(l,i),lca2=LCA(r,i);
                if(deep[lca1]>deep[lca2]) rlca=lca1;
                else rlca=lca2;
                if(deep[rlca]<deep[l])
                {
                    sum=max(sum,dis[l]+dis[i]-2*dis[rlca]);
                }
                else sum=max(sum,dis[i]-dis[rlca]);
            }
            ans=min(ans,sum);
            l=f[l][0];vis[l]=1;
        }
    }
    cout<<ans;
}