很久以前，T王国空前繁荣。为了更好地管理国家，王国修建了大量的快速路，用于连接首都和王国内的各大城市。
为节省经费，T国的大臣们经过思考，制定了一套优秀的修建方案，使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。
J是T国重要大臣，他巡查于各大城市之间，体察民情。所以，从一个城市马不停蹄地到另一个城市成了J最常做的事情。他有一个钱袋，用于存放往来城市间的路费。
聪明的J发现，如果不在某个城市停下来修整，在连续行进过程中，他所花的路费与他已走过的距离有关，在走第xx千米到第x+1x+1千米这一千米中（xx是整数），他花费的路费是x+10x+10这么多。也就是说走11千米花费1111，走22千米要花费2323。
J大臣想知道：他从某一个城市出发，中间不休息，到达另一个城市，所有可能花费的路费中最多是多少呢？
这个题本弱鸡写了很久，这是第一次接触到树的直径这个概念
树的直径就是树中任意两点间最远的距离（有时也称为最长链）
树的直径的两种求解方法（1）树形dp（2）两次dfs（bfs）
这里我们就需要知道树的两个性质
（1）从任意一点出发，这个点的最长链跟次长链的和就是这个树的直径
具体可参考
这里
（2）从任意一点出发，通过搜索找到一个最远距离的点，那么这个点绝对是树的直径的一个端点
为什么说第一次找到的点一定是端点
有了这2个知识点就可以做这个题了
首先我先介绍bfs的代码（dfs在JAVA中容易爆栈，所以大家如果是用JAVA最好多用BFS）
package lan4A_C;
import java.io.*;
import java.util.*;
public class TestJ {
static int MAX = 10010;
static int n;
static int p[]; //存每个点的一条边的编号
static int u[]; //边的起点
static int v[]; //边的终点
static int w[]; //边的权值
static int next[]; // 下一条边编号
static int dist[]; // 到每一个的距离
static boolean vis[]; // 点是否访问过
static int get(int x){ // 路径转费用
int t = 10;
int sum = 0;
for(int i = 1;i <= x;i++){
sum += i+t;
}
return sum;
}
static int id = 1;
static void add(int a,int b,int x){
u[id] = a;
v[id] = b;
w[id] = x;
next[id] = p[a];
p[a] = id++;
}
static void bfs(int k){
Queue<Integer> q = new LinkedList<Integer>();
q.add(k);
Arrays.fill(vis, false);
vis[k] = true;
dist[k] = 0;
while(!q.isEmpty()){
int t = q.poll();
for(int i = p[t];i != -1;i = next[i]){ // 找到这个点的第一条边编号
if(vis[v[i]])
continue;
dist[v[i]] = dist[t]+w[i]; // k点到v[i]点的距离
q.add(v[i]);
vis[v[i]] = true; // 这个终点已经算过了
}
}
}
public static void main(String[] args) throws IOException{
StreamTokenizer re = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
PrintWriter pr = new PrintWriter(new OutputStreamWriter(System.out));
re.nextToken(); n = (int)re.nval;
p = new int[MAX]; u = new int[MAX*2]; v = new int[MAX*2]; w = new int[MAX*2]; next = new int[MAX*2];
vis = new boolean[MAX]; dist = new int[MAX];
Arrays.fill(p,-1);
Arrays.fill(next,-1);
for(int i = 1;i < n;i++){
re.nextToken();int a = (int)re.nval;
re.nextToken();int b = (int)re.nval;
re.nextToken();int x = (int)re.nval;
add(a,b,x);
add(b,a,x);
}
bfs(1);
int k = 1;
for(int i = 2;i <= n;i++)
if(dist[i] > dist[k])
k = i; // 最远距离 第一个端点
// System.out.println(k);
bfs(k);
int t = dist[1];
for(int i = 1;i <= n;i++)
if(dist[i] > t)
t = dist[i];
// System.out.println(t);
long ans = get(t);
pr.println(ans);
pr.flush();
}
}
下面是DP的代码
package lan4A_C;
import java.io.*;
import java.util.Arrays;
public class TestJDP {
static int MAX = 10010;
static int n;
static int p[]; //存每个点的一条边的编号
static int u[]; //边的起点
static int v[]; //边的终点
static int w[]; //边的权值
static int next[]; // 下一条边编号
static int d[] = new int[MAX];
static boolean vis[] = new boolean[MAX];
static int ans = 0;
static int id = 0;
static void add(int a,int b,int x){
u[id] = a;
v[id] = b;
w[id] = x;
next[id] = p[a];
p[a] = id++;
}
static int get(int x){
int t = 10;
int sum = 0;
for(int i = 1;i <= x;i++){
sum += i+t;
}
return sum;
}
static void dp(int x){
vis[x] = true;
for(int i = p[x];i != -1;i = next[i]){
int y = v[i];
if(vis[y])
continue;
dp(y); // 先计算儿子结点的最长链
// ans每次都为最长链加次长链的结果
// d[x]表示从x结点出发的最长链，而如果我们之前找到的一个方向的
//最长链，现在发现这个点从另外一个儿子结点出去，那边还有更长的最
//长链，我们就把另外那条链当做最长链 d[x]+d[y]+w[w] 表示的是当
//前已知的最长链加上从另外一个儿子结点出发的最长链，取最大值，这
//个值则必然是最大值
ans = Math.max(ans, d[x]+d[y]+w[i]);
d[x] = Math.max(d[x], d[y]+w[i]); // d[x]每次都为最长链
}
}
public static void main(String[] args) throws IOException{
StreamTokenizer re = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
PrintWriter pr = new PrintWriter(new OutputStreamWriter(System.out));
re.nextToken(); n = (int)re.nval;
p = new int[MAX]; u = new int[MAX*2]; v = new int[MAX*2]; w = new int[MAX*2]; next = new int[MAX*2];
Arrays.fill(p, -1);
Arrays.fill(next, -1);
Arrays.fill(vis, false);
for(int i = 1;i < n;i++){
re.nextToken();int a = (int)re.nval;
re.nextToken();int b = (int)re.nval;
re.nextToken();int x = (int)re.nval;
add(a,b,x);
add(b,a,x);
}
dp(1);
pr.println(get(ans));
pr.flush();
}
}
可能看到这里会有人有点懵，邻接表如果用数组实现？？？自己没了解过看着非常的陌生。 因为本弱鸡正是如此
下面给大家介绍一下邻接表用数组的实现
注意：数组实现邻接表边的编号非常重要
（1）我们用u，v，w 3个数组来存放边的3个信息（起点，终点，权值）
（2）我们用p数组来存放每个顶点的第一条边的编号，用next数组来存放如果有的顶点有超过1条边，next数组就会起到作用了
下面来具体描述一下
比如我们有5个点
1 2 3 4 5
我们有4条边 编号为
1 2 3 4
1：2-3 8
2：3-4 5
3：2-1 3
暂且就3条边吧 太懒了不想写了
读入第一条边时：
u[1] = 2 v[1] = 3 w[1] = 8 p[2] = 1 大家应该清楚了 边信息数组里面的下标都是边的编号，所以这个东西大家要分清楚 我们每次找遍都是根据边的编号来找的 而p数组则是找到这个点对应的边时哪一条
读入第二条边时：
u[2] = 3 v[2] = 4 w[2] = 5 p[3] = 2
读入第三条边时：
u[3] = 2 v[3] = 1 w[3] = 3 p[2] = 3（这里大家注意点到，如果我们这样读入的话我们就会丢失第2个点第一条边的信息，所以这里我们引入next数组）
我们这样读入
u[3] = 2，v[3] = 1，w[3] = 3 ，next[3] = p[2] (next[3] = 1)，p[2] = 3
我们把之前这个点对应的上一条边存在next数组中
当我们找的时候我们就会这样找
p[2] :找到第一条边 然后next[p[2]] 就会找到第二条边啦
如果本弱鸡还是没有解释清楚，大家可以参考下面链接
这里这里
