大臣的旅费 Apare_xzc 求树的直径 蓝桥杯

大臣的旅费

题目：

问题描述
很久以前，T王国空前繁荣。为了更好地管理国家，王国修建了大量的快速路，用于连接首都和王国内的各大城市。

为节省经费，T国的大臣们经过思考，制定了一套优秀的修建方案，使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。

J是T国重要大臣，他巡查于各大城市之间，体察民情。所以，从一个城市马不停蹄地到另一个城市成了J最常做的事情。他有一个钱袋，用于存放往来城市间的路费。

聪明的J发现，如果不在某个城市停下来修整，在连续行进过程中，他所花的路费与他已走过的距离有关，在走第x千米到第x+1千米这一千米中（x是整数），他花费的路费是x+10这么多。也就是说走1千米花费11，走2千米要花费23。

J大臣想知道：他从某一个城市出发，中间不休息，到达另一个城市，所有可能花费的路费中最多是多少呢？

输入格式
输入的第一行包含一个整数n，表示包括首都在内的T王国的城市数

城市从1开始依次编号，1号城市为首都。

接下来n-1行，描述T国的高速路（T国的高速路一定是n-1条）

每行三个整数Pi, Qi, Di，表示城市Pi和城市Qi之间有一条高速路，长度为Di千米。

输出格式
输出一个整数，表示大臣J最多花费的路费是多少。

样例输入1
5
1 2 2
1 3 1
2 4 5
2 5 4
样例输出1
135
输出格式
大臣J从城市4到城市5要花费135的路费。

数据范围：

####   题目没有明说，我就当n<=1E6了

先上一个不正确的思路：

我一看树，最值，马上开心地写了一发最喜欢的LCA:找一个度大于1的点当根节点, 求出到根节点距离最远的两个点，然后认为这两个点的距离就是答案(显然有问题)

---

50分的代码 & 我好久没写过的LCA

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6+100;
int a[maxn];
int deep[maxn*2];
int first[maxn];
int father[maxn];
int degree[maxn];
struct Node{
    int to;
    long long d;
    int Next;
}node[maxn];
int tot;
int head[maxn];
void addEdge(int from,int to,long long d)
{
    node[tot].to = to;
    node[tot].d = d;
    node[tot].Next = head[from];
    head[from] = tot++;
}
void initEdge()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}
bool vis[maxn];
int record[maxn*2];
long long disToRoot[maxn*2];
int cnt;

void dfs(int x,int dep,long long disxto1)
{
    record[++cnt] = x;
    deep[cnt] = dep;
    disToRoot[x] = disxto1;
   // if(vis[x]) return;
    first[x] = cnt;

    for(int i=head[x];i!=-1;i=node[i].Next)
    {
        int to = node[i].to;
        if(vis[to]) continue;
        vis[x] = true;
        father[to] = x;
        dfs(to,dep+1,disxto1+node[i].d);
        record[++cnt] = x;
        deep[cnt] = dep;
    }

}
int ST[maxn][20];
void RMQ(int m)
{
    int n = 2*m-1;
    for(int i=1;i<=n;++i)
        ST[i][0] = i;
    for(int j=1;(1<<j)<=n;++j)
    {
        for(int i=1;i+(1<<j)-1<=n;++i)
        {
            int a = ST[i][j-1], b = ST[i+(1<<(j-1))][j-1];
            ST[i][j] = deep[a]>deep[b]?b:a;
        }
    }
}
int query(int xx,int yy) ///query the LCA of x and y`
{
    int x = first[xx],y=first[yy];
    if(x>y) swap(x,y);
    int j = 0;
    while((1<<j)<=y-x+1) ++j;
    --j;
    int a = ST[x][j], b = ST[y-(1<<j)+1][j];
    int id = deep[a]>deep[b]?b:a;
    return record[id];
}
int main()
{
    int n,x,y;
    long long d;
    int ca = 0;
    while(cin>>n)
    {
        if(ca++)
        {
            memset(degree,0,sizeof(degree));
            memset(vis,false,sizeof(vis));
        }
        initEdge();
        long long sum = 0;
        for(int i=1;i<n;++i)
        {
            scanf("%d%d%lld",&x,&y,&d);
            sum += d;
            addEdge(x,y,d);
            addEdge(y,x,d);
            ++degree[x],++degree[y];
        }
        int root = 0;
        for(int i=1;i<=n;++i)
        {
            if(degree[i]>1)
            {
                root = i;break;
            }
        }
        if(root==0)
        {
            printf("%lld
",(sum+21)*sum/2);
            continue;
        }
        father[root] = root;
        vis[root] = true;
        dfs(root,1,0);
        RMQ(n);
        int x1 = 1;
        for(int i=2;i<=n;++i)
        {
            if(disToRoot[i]>disToRoot[x1]) x1 = i;
        }
        int x2 = 0;
        for(int i=1;i<=n;++i)
        {
            if(i==x1) continue;
            if(disToRoot[i]>disToRoot[x2]) x2 = i;
        }
        int lca = query(x1,x2);
        long long totDis = disToRoot[x1]+disToRoot[x2]-disToRoot[lca]*2;
        long long ans = (totDis+21)*totDis/2;
        printf("%lld
",ans);
    }
    return 0;
}

这个问题其实叫做求：树的直径

结论：从书上的任意一点出发，距离这个点最远的节点一定在最长路径上

用反证法即可证明

我百度到这个结论，觉得很巧妙，而且不难理解，如果最远的节点不在最长路径上，那么最长路径必然不是最长的…

所以从任意一点出发，dfs遍历这棵树，找到离这个点最远的一个点x，那么这个点一定是最长路径的一个端点，再从x做一次dfs即可，具体实现见代码

//姓名	试题名称	   提交时间     代码长度  语言 评测结果 评分 CPU使用 内存使用 
//许智超	大臣的旅费  11-15 16:48  1.242KB	 C++	正确  100  15ms	 43.93MB
#include <bits/stdc++.h>
using namespace std;
const int maxn  =1e6+100;
int tot;
struct Node{
    int to,Next;
    long long d;
}node[maxn*2];
int head[maxn];
bool vis[maxn];
long long Dis[maxn];
void initEdge()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}
void addedge(int from,int to,long long d)
{
    node[tot].to = to;
    node[tot].d = d;
    node[tot].Next = head[from];
    head[from] = tot++;
}
long long MaxDis;
int farest;
void dfs(int x,long long d)
{
    vis[x] = true;
    Dis[x] = d;
    if(d>MaxDis) MaxDis = d, farest = x;
    for(int i=head[x];i!=-1;i=node[i].Next)
    {
        int to = node[i].to;
        if(vis[to]) continue;
        dfs(to,d+node[i].d);
    }
}
int main()
{
    /// random chose a point A, the point which is farest from A will be one the longest rath
    int n,x,y;
    long long d;
    while(cin>>n)
    {
        initEdge();
        for(int i=1;i<n;++i)
        {
            scanf("%d%d%lld",&x,&y,&d);
            addedge(x,y,d);
            addedge(y,x,d);
        }
        memset(vis,false,sizeof(vis));
        MaxDis = 0;
        farest = 0;
        dfs(1,0);
        int one = farest;
        memset(vis,false,sizeof(vis));
        dfs(one,0);
        printf("%lld
",(MaxDis+21)*MaxDis/2);
    }

    return 0;
}