大臣的旅费（java）-蓝桥杯

问题描述

很久以前，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的路费。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	public static int max;
	public static int n;
	public static int[][] a;//存储树每一条边的长度
	public static int sum=0;
	public static void main(String[] args)
	{
		Scanner input=new Scanner(System.in);
		n=input.nextInt();
		a=new int[n+1][n+1];
		for(int i=0;i<n+1;i++)//二维数组赋初始值
		{
			Arrays.fill(a[i], -1);
			a[i][i]=0;
		}
		for(int i=1;i<n;i++)//将树每一条边的值存入
		{
			 int p=input.nextInt();
			 int q=input.nextInt();
			 a[p][q]=a[q][p]=input.nextInt();
		}
		input.close();
		for(int i=1;i<=n;i++)
		{
			for(int j=i+1;j<=n;j++)//开始遍历寻找最长路径
			{
				dfs(i,i,j);
			}
		}
		int price=(10+max+11)*max/2;
		System.out.println(price);
	}
	
	public static void dfs(int start,int next,int end)//路径开始点，邻点，结束点
	{
		if(next==end)//当邻点等于结束点时结束遍历
		{
			sum+=a[start][end];
			if(sum>max)max=sum;
			return;
		}
		else
		{
			sum+=a[start][next];
			for(int i=1;i<=n;i++)
			{
				if(i!=start&&i!=next&&a[next][i]!=-1)
				{
					dfs(next,i,end);
					sum-=a[next][i];
				}
			}
		}
	}
}

运行结果：

最后一个数据据说为10000，这种解法太多次遍历，时间复杂度和空间复杂度太大，一下子就超时了。后来百度了好久，采用深度优先遍历求树的直径，原理如下：

树的直径为树中所有最短路径长度中的最大值。求树的直径有如下解法：    

      step1：以树的任一结点为起始，进行搜索（DFS），寻找到长度最长的路径，即最远的点，记为s；

      step2：以s结点为起始点，再进行一次搜索（DFS），寻找到最长路径，此时路径记为s-t，即为树的最大直径

这道题实际上是求树中最远的两个点，可以使用两遍深度优先遍历解决。第一遍从1号点开始，找到距1号点最远的点s，如果有多个任取一个即可。第二遍从2号点开始，找到距s最远的点t，则s-t就是树的直径。

代码如下：

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	public static int max;
	public static int n;
	public static int[][] a;
	public static int sum=0;
	
	static int s=0;
	static int[] vis;
	public static void main(String[] args)
	{
		Scanner input=new Scanner(System.in);
		n=input.nextInt();
		a=new int[n+1][n+1];
		vis=new int[n+1];//记录是否访问过
		for(int i=0;i<n+1;i++)
		{
			Arrays.fill(a[i], -1);
			a[i][i]=0;
		}
		for(int i=1;i<n;i++)
		{
			 int p=input.nextInt();
			 int q=input.nextInt();
			 a[p][q]=a[q][p]=input.nextInt();
		}
		input.close();
		vis[1]=1;//从第一个结点开始搜索，即第一个结点已经被访问过了，标记为1
		dfs(1);//开始从第一个结点搜索
		Arrays.fill(vis, 0);//第一遍DFS结束，得到最远的点s，将所有访问记录清空
		vis[s]=1;//把s点标记

		dfs(s);//从s点开始第二遍DFS
		int price=(10+max+11)*max/2;//计算最后的旅费
		System.out.println(price);
	}
	
	
	public static void dfs(int start)
	{
		if(sum>max)
		{
			max=sum;
			s=start;//记录最远的点		
		}		
		for(int i=1;i<=n;i++)
		{
			if(vis[i]==0&&a[start][i]!=-1)//点i没有被访问过且点start与i存在路径
			{
				vis[i]=1;
				sum+=a[start][i];
				dfs(i);//替换起始点
				sum-=a[start][i];//回溯，拿起要放下
				vis[i]=0;
			}
		}
		return;
	}
}

运行结果：

虽然比之前的做法，时间复杂度小了好多，但最后一个依旧还是超时了。

网上百度说用邻接矩阵可以解决超时的问题，没有试过，有大神可以解答一下吗？