蓝桥杯 试题J：大臣的旅费

很久以前，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]] 就会找到第二条边啦
如果本弱鸡还是没有解释清楚，大家可以参考下面链接
这里这里