树的直径合辑

124. 二叉树中的最大路径和

int maxPath = Integer.MIN_VALUE;

public int maxPathSum(TreeNode root) {
    dfs(root);
    return maxPath;
}

private int dfs(TreeNode root) {
    if (root == null) return 0;
    int leftGain = Math.max(dfs(root.left), 0);
    int rightGain = Math.max(dfs(root.right), 0);
    int currMaxPath = root.val + leftGain + rightGain;
    maxPath = Math.max(maxPath, currMaxPath);
    return root.val + Math.max(leftGain, rightGain);
}

543. 二叉树的直径

int res = 1;

public int diameterOfBinaryTree(TreeNode root) {
    dfs(root);
    return res - 1;
}

public int dfs(TreeNode root) {
    if (root == null) return 0;//如果达到叶子节点的子节点，返回0
    int leftDepth = dfs(root.left);//遍历左子树
    int rightDepth = dfs(root.right);//遍历右子树
    res = Math.max(res, leftDepth + rightDepth + 1);//计算最大直径
    return Math.max(leftDepth, rightDepth) + 1;//返回最大的深度
}

1245.树的直径

public int treeDiameter(int[][] edges) {
    int n = edges.length;
    //建图
    List<List<Integer>> graph = new ArrayList<>();
    for (int i = 0; i <= n; i++) graph.add(new ArrayList<>());
    for (int[] edge : edges) {
        int u = edge[0], v = edge[1];
        graph.get(u).add(v);
        graph.get(v).add(u);
    }
    int res = 0;
    for (int i = 0; i <= n; i++) {
        //最长路径的端点的度一定为1
        if (graph.get(i).size() == 1) {
            res = Math.max(res, dfs(graph, -1, i));
        }
    }
    //直径是边的数量，2个点之间有一条边
    return res - 1;

}

/**
 * @param graph
 * @param prev  前驱节点
 * @param cur   当前节点
 * @return
 */
private int dfs(List<List<Integer>> graph, int prev, int cur) {
    int res = 0;
    for (int ne : graph.get(cur)) {
        if (ne != prev) {//如果不是当前节点，则进入到下一层dfs
            res = Math.max(res, dfs(graph, cur, ne));
        }
    }
    return res + 1;//加上当前节点
}

U81904 【模板】树的直径

• 树形DP模板

/ /树形dp结构伪代码描述
void dfs(节点u){
     for(){   / /循环访问所有u的子节点
     dfs(u的子节点);
     用u的子节点信息更新节点u的信息;
     }
}
//设d[x]为节点x到其子孙节点的最大距离、设f[x]为以x为根结点的一条最长路径的距离。
//即要维护的信息就是d[]，f[]。

题目描述
给定一棵树，树中每条边都有一个权值，

树中两点之间的距离定义为连接两点的路径边权之和。

树中最远的两个节点之间的距离被称为树的直径，连接这两点的路径被称为树的最长链。

现在让你求出树的最长链的距离

输入格式
给定一棵无根树

第一行为一个正整数nn,表示这颗树有n个节点

接下来的n−1行,每行三个正整数u,v,w，表示u,v（u,v<=n）有一条权值为w的边相连

数据保证没有重边或自环

输出格式
输入仅一行，表示树的最长链的距离

输入输出样例
输入 #1复制
6
1 2 1
1 3 2
2 4 3
4 5 1
3 6 2
输出 #1复制
9

static int N = 500010;
static int res = 0;
static List<List<int[]>> adj = new ArrayList<>();
static int[] dist = new int[N];


public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    for (int i = 0; i <= n; i++) adj.add(new ArrayList<>());
    for (int i = 1; i < n; i++) {
        int u = sc.nextInt(), v = sc.nextInt(), w = sc.nextInt();
        adj.get(u).add(new int[]{v, w});
        adj.get(v).add(new int[]{u, w});
    }
    dp(1, 0);
    System.out.println(res);
}


public static void dp(int u, int fa) {
    for (int[] ne : adj.get(u)) {
        int v = ne[0], w = ne[1];
        if (v == fa) continue;
        dp(v, u);
        res = Math.max(res, dist[u] + dist[v] + w);
        dist[u] = Math.max(dist[u], dist[v] + w);
    }
}

1469 · 树上最长路径

证明参考 :链接

描述
给出由n个结点，n-1条边组成的一棵树。求这棵树中距离最远的两个结点之间的距离。
给出三个大小为n-1的数组starts,ends,lens,表示第i条边是从starts[i]连向ends[i]，长度为lens[i]的无向边。

返回的是树上任意两个结点的最远距离，而不是树的深度，注意给定的边是无向边。
题目保证给出的边一定能构成一棵树。

1≤n≤1∗10^5
 
1 10^31≤lens[i]≤1∗10^3  
样例
Example 1:

Input：n=5,starts=[0,0,2,2],ends=[1,2,3,4],lens=[1,2,5,6]
Output：11
解释:
(3→2→4)这条路径长度为`1`，当然(4→2→3)也是一样的。
Example 2:

Input：n=5,starts=[0,0,2,2],ends=[1,2,3,4],lens=[5,2,5,6]
Output：13
解释:
(1→0→2→4)这条路径长度为`1`，当然(4→2→0→1)也是一样的。

class Node {
    int val;
    Map<Node, Integer> neighbors;

    public Node(int val) {
        this.val = val;
        this.neighbors = new HashMap<>();
    }
}


class Pair implements Comparable<Pair> {
    int val;
    Node node;

    public Pair(int val, Node node) {
        this.val = val;
        this.node = node;
    }

    @Override
    public int compareTo(Pair other) {
        return this.val - other.val;
    }
}


public int longestPath(int n, int[] starts, int[] ends, int[] lens) {
    Map<Integer, Node> graph = new HashMap<>();
    for (int i = 0; i < starts.length; i++) {
        int u = starts[i], v = ends[i], w = lens[i];
        graph.putIfAbsent(u, new Node(u));
        Node uNode = graph.get(u);
        graph.putIfAbsent(v, new Node(v));
        Node vNode = graph.get(v);
        graph.get(u).neighbors.put(vNode, w);
        graph.get(v).neighbors.put(uNode, w);
    }
    Node root = graph.get(0);
    Pair pair = bfs(n, root);
    return bfs(n, pair.node).val;
}

private Pair bfs(int n, Node root) {
    Pair res = new Pair(-1, null);
    boolean[] vis = new boolean[n];
    vis[root.val] = true;
    PriorityQueue<Pair> pq = new PriorityQueue<>();
    pq.offer(new Pair(0, root));
    while (!pq.isEmpty()) {
        Pair cur = pq.poll();
        res = cur;
        for (Map.Entry<Node, Integer> e : cur.node.neighbors.entrySet()) {
            if (vis[e.getKey().val]) continue;
            vis[e.getKey().val] = true;
            pq.offer(new Pair(cur.val + e.getValue(), e.getKey()));
        }
    }
    return res;
}

291 · 第二直径

        public long getSecondDiameter(int[][] edges) {
            int n = edges.length + 1;
            Map<Integer, Map<Integer, Integer>> graph = buildGraph(n, edges);
            //找到第一直径的两个端点
            long[][] oneEnd = bfs(graph, 0);
            long[][] twoEnd = bfs(graph, (int) oneEnd[0][0]);
            //第二直径的两个端点只能从oneEnd 和 twoEnd这个两个第一直径的端点出发
            long[][] xEnd = bfs(graph, (int) oneEnd[0][0]);
            long[][] yEnd = bfs(graph, (int) twoEnd[0][0]);
            return Math.max(xEnd[1][1], yEnd[1][1]);
        }


        //
        private long[][] bfs(Map<Integer, Map<Integer, Integer>> graph, int start) {
            Queue<Integer> q = new ArrayDeque<>();
            Map<Integer, Long> dist = new HashMap<>();
            q.offer(start);
            dist.put(start, 0L);
            //两个端点的距离，和端点
            long distOne = 0, nodeOne = -1;
            long distTwo = 0, nodeTwo = -1;
            while (!q.isEmpty()) {
                int cur = q.poll();
                for (Map.Entry<Integer, Integer> ne : graph.get(cur).entrySet()) {
                    int next = ne.getKey(), len = ne.getValue();
                    if (dist.containsKey(next)) continue;
                    dist.put(next, dist.get(cur) + len);
                    q.offer(next);
                    //更新第一个距离的端点，和第二个距离的端点
                    if (dist.get(next) > distOne) {
                        distTwo = distOne;
                        nodeTwo = nodeOne;
                        distOne = dist.get(next);
                        nodeOne = next;
                    } else if (dist.get(next) > distTwo) {
                        distTwo = dist.get(next);
                        nodeTwo = next;
                    }
                }
            }
            return new long[][]{{nodeOne, distOne}, {nodeTwo, distTwo}};
        }


        private Map<Integer, Map<Integer, Integer>> buildGraph(int n, int[][] edges) {
            Map<Integer, Map<Integer, Integer>> graph = new HashMap<>();
            for (int i = 0; i < n; i++) graph.put(i, new HashMap<>());
            for (int[] edge : edges) {
                graph.get(edge[0]).put(edge[1], edge[2]);
                graph.get(edge[1]).put(edge[0], edge[2]);
            }
            return graph;
        }