【蓝桥杯】大臣的旅费

大臣的旅费

很久以前，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最多花费的路费是多少。
样例输入

5
1 2 2
1 3 1
2 4 5
2 5 4

样例输出

135

样例说明
大臣J从城市4到城市5要花费135的路费。

分析：

• 问题可以转化为求一棵树中任意两个结点之间最长的距离
• 由于是正边权，所以这两个结点一定是叶子结点
• 整体算法： $dfs$
• 旅费和距离是一个简单映射，可以用一个函数最后解决
• 由题意可知，旅费是一个等差数列的前 $n$ 项求和，其通项公式为 $$11+12+\cdots +(11+n-1)=\frac{n^2+21n}{2}$$
• 但是注意不能在输入数据的时候就把距离转为旅费，之后用旅费直接相加，因为距离和旅费并不是线性关系，不能简单转化，因为$$\frac{n_1^2+21n_1}{2}+\frac{n_2^2+21n_2}{2}\ne \frac{(n_1+n_2{)}^2+21(n_1+n_2)}{2}$$
• 所以我们只需要先用距离算，最后一步才把距离转为旅费即可

解法1（暴力解，不能过题，但可以得大部分分）

• 以每个结点为起始结点，算出任意两点的距离，取最大值

代码如下

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

//图论问题最基本的是存图，这里采用邻接表的方式存图
//pair的含义为<终点，距离>
vector<vector<pair<int, int> > > way;
vector<bool> vis;//是否被访问
int n;//n个结点
int max_dis;//以某个结点为起点的最大距离
int tmp_ans;//所有结点最大距离的最大距离，即max{max_dis}

//计算旅费的函数
int fee(int n) { return (n * n + 21 * n) >> 1; }

void init() {
    scanf("%d", &n);
    way.resize(n + 1);
    vis.resize(n + 1, false);
    int a = 0, b = 0, c = 0;
    for (int i = 1; i < n; i++) {
        scanf("%d%d%d", &a, &b, &c);
        way[a].push_back(make_pair(b, c));
        way[b].push_back(make_pair(a, c));
    }
}

//这里的dfs有些特殊，与起点结点相邻的结点遍历完之后自动就退出了，所以不需要递归出口
//fe:距离
void dfs(int start, int fe) {
    for (int i = 0; i < (int)way[start].size(); i++) {
        if (!vis[way[start][i].first]) {
            vis[way[start][i].first] = true;
            dfs(way[start][i].first, fe + way[start][i].second);
            vis[way[start][i].first] = false;//dfs框架，但是这道题这一行可以省略
        }
    }
    max_dis = max(max_dis, fe);//自然退出，退出时更新最大距离
}

void solve() {
    for (int i = 1; i <= n; i++) {
    //遍历每一个结点，求最大距离
        max_dis = 0;
        fill(vis.begin(), vis.end(), false);
        vis[i] = true;
        dfs(i, 0);
        tmp_ans = max(max_dis, tmp_ans);//求所有结点的最大距离的最大值
    }
    printf("%d\n", fee(tmp_ans));//距离转旅费
}

int main(void) {
    init();
    solve();
    return 0;
}

解法2(可以过题的解)

• 求树的直径
• $dfs$

求树的直径算法：

• 以一个结点为起点，找出与这个结点距离最远的结点，记为结点 $k_1$
• 以结点 $k_1$ 为起点，找出与其距离最远的结点，记为结点 $k_2$
• 则 $k_1$ 和 $k_2$ 之间的距离即为树的直径

代码如下

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

vector<vector<pair<int, int> > > way;
vector<bool> vis;
int n;
int max_dis;
int pos;//记录第一个点的位置

int fee(int n) { return (n * n + 21 * n) >> 1; }

void init() {
    scanf("%d", &n);
    way.resize(n + 1);
    vis.resize(n + 1, false);
    int a = 0, b = 0, c = 0;
    for (int i = 1; i < n; i++) {
        scanf("%d%d%d", &a, &b, &c);
        way[a].push_back(make_pair(b, c));
        way[b].push_back(make_pair(a, c));
    }
}

void dfs(int start, int fe) {
    for (int i = 0; i < (int)way[start].size(); i++) {
        if (!vis[way[start][i].first]) {
            vis[way[start][i].first] = true;
            dfs(way[start][i].first, fe + way[start][i].second);
            vis[way[start][i].first] = false;
        }
    }
    //自然退出时不是单纯地更新最大距离，而还要记录结点位置
    if (fe > max_dis) {
        max_dis = fe;
        pos = start;
    }
}

void solve() {
//那么就只需两遍dfs即可，复杂度从O(n)变成O(1)，直接降了一阶！
    //第一次dfs，vis和max_dis是已经初始化了的
    vis[1] = true;
    dfs(1, 0);
    //此时pos中已经有了第一个结点
    
    //先初始化，再dfs
    max_dis = 0;
    fill(vis.begin(), vis.end(), false);
    vis[pos] = true;
    dfs(pos, 0);

	//此时max_dis中存储的即为最大距离，再转为旅费即可
    printf("%d\n", fee(max_dis));
}

int main(void) {
    init();
    solve();
    return 0;
}