蓝桥杯-大臣的旅费 dfs+邻接表

树的直径问题，图中所有最短路径的最大值即为直径，两次dfs即可求出

邻接矩阵

这题可以使用dfs+邻接矩阵来做，不过会导致内存超限只能80分。

import java.util.Scanner;
import java.util.Vector;

public class Main {
	static int n;	// 城市数
	static int node;	// 当前访问节点
	static int[][] map;	// 存放城市图
	static int curWeight = 0;	// 当前路线的权重和，用于比较边权
	static boolean[] visited;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		
		map = new int[n+1][n+1];
		visited = new boolean[n+1];
		for(int i = 0; i<n-1; i++) {
			int u = sc.nextInt();
			int v = sc.nextInt();
			int weight = sc.nextInt();
			map[u][v] = map[v][u] = weight;
		}
		// 从第一个节点开始走
		dfs(1,0);
		curWeight = 0;
		dfs(node,0);
		int res = getCost(curWeight);
		System.out.print(res);
	}
	/**
	 * 
	 * @param start
	 * @param weight	// 权重和
	 */
	private static void dfs(int start, int weight) {
		// TODO Auto-generated method stub
		if(weight>curWeight) {
			curWeight = weight;
			node = start;	// 保存当前权重和最多的节点
		}
		for(int i = 0; i<n; i++) {
			if(!visited[i] && map[start][i]!=0) {
				visited[start]= true;
				visited[i] = true;
				dfs(i,weight+map[start][i]);
				visited[start] = false;
				visited[i] = false;
			}
		}
	}
	//根据千米获得需要的费用
    public static int getCost(int k) {
        int sum=0;
        for (int i = 1; i <=k; i++) {
            sum+=(i+10);
        }
        return sum;
    }
}

邻接表

考虑到本题中涉及的边少，所以可以改用邻接表，这样就不会有内存超限的问题

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Vector;

public class 第四届2013_大臣的旅费_邻接表 {
	static int n;	// 城市数
	static List<Node>[] list;	// 构建邻接表
	static boolean visited;
	static int curWeight,node;	// 当前权重和，当前节点
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		// 构建邻接表
		list = new List[n+1];
		for(int i = 1; i<=n; i++) {
			list[i] = new ArrayList<Node>();
		}
		for(int i = 0; i<n-1; i++) {
			int u = sc.nextInt();
			int v = sc.nextInt();
			int weight = sc.nextInt();
			list[u].add(new Node(v,weight));
			list[v].add(new Node(u,weight));
		}
		dfs(1,1,0);
		dfs(node,node,0);
		System.out.print(getCost(curWeight));
	}
	/**
	 * 
	 * @param from	上一个点
	 * @param cur	当前节点
	 * @param weight	权重和
	 */
	private static void dfs(int from, int cur, int weight) {
		// TODO Auto-generated method stub
		if(visited&&weight>curWeight) {
			curWeight=weight;	// 记录下当前权重和
			node=cur;	// 记录下当前访问的节点
		}
		// 找出邻接表中当前的链表
		List<Node> neighboors = list[cur];
		// 遍历邻接表中当前的链表中的节点
		for(int i =0; i<neighboors.size(); i++) {
			Node neighboor = neighboors.get(i);
			if(neighboor.v==from) continue;
			visited = true;
			dfs(cur, neighboor.v, weight+neighboor.dis);
			visited = false;
		}
		
	}
	//根据千米获得需要的费用
    public static int getCost(int k) {
        int sum=0;
        for (int i = 1; i <=k; i++) {
            sum+=(i+10);
        }
        return sum;
    }
    
	public static class Node{
		int v;
		int dis;
		public Node(int v,int dis) {
			this.v=v;
			this.dis=dis;
		}
	}
}