class Solution:
    def treeDiameter(self, edges):
        from collections import defaultdict, deque

        # Build the adjacency list
        graph = defaultdict(list)
        for u, v in edges:
            graph[u].append(v)
            graph[v].append(u)

        # Helper: BFS to find the farthest node and its distance from a start node
        def bfs(start):
            visited = set()
            queue = deque([(start, 0)])
            visited.add(start)
            farthest_node = start
            max_dist = 0
            while queue:
                node, dist = queue.popleft()
                if dist > max_dist:
                    max_dist = dist
                    farthest_node = node
                for neighbor in graph[node]:
                    if neighbor not in visited:
                        visited.add(neighbor)
                        queue.append((neighbor, dist + 1))
            return farthest_node, max_dist

        # 1st BFS from any node (say 0) to find the farthest node
        u, _ = bfs(0)
        # 2nd BFS from u to find the farthest node from u (this is the diameter)
        v, diameter = bfs(u)
        return diameter
      

class Solution {
public:
    int treeDiameter(vector<vector<int>>& edges) {
        int n = edges.size() + 1;
        vector<vector<int>> graph(n);
        for (auto& e : edges) {
            graph[e[0]].push_back(e[1]);
            graph[e[1]].push_back(e[0]);
        }
        
        // Helper: BFS to find farthest node and distance
        auto bfs = [&](int start) {
            vector<bool> visited(n, false);
            queue<pair<int, int>> q;
            q.push({start, 0});
            visited[start] = true;
            int far_node = start, max_dist = 0;
            while (!q.empty()) {
                auto [node, dist] = q.front(); q.pop();
                if (dist > max_dist) {
                    max_dist = dist;
                    far_node = node;
                }
                for (int nei : graph[node]) {
                    if (!visited[nei]) {
                        visited[nei] = true;
                        q.push({nei, dist + 1});
                    }
                }
            }
            return make_pair(far_node, max_dist);
        };
        
        auto [u, _] = bfs(0);
        auto [v, diameter] = bfs(u);
        return diameter;
    }
};
      

import java.util.*;

class Solution {
    public int treeDiameter(int[][] edges) {
        int n = edges.length + 1;
        List<List<Integer>> graph = new ArrayList<>();
        for (int i = 0; i < n; i++) graph.add(new ArrayList<>());
        for (int[] e : edges) {
            graph.get(e[0]).add(e[1]);
            graph.get(e[1]).add(e[0]);
        }
        // Helper: BFS to find farthest node and distance
        class Pair {
            int node, dist;
            Pair(int n, int d) { node = n; dist = d; }
        }
        Pair bfs(int start) {
            boolean[] visited = new boolean[n];
            Queue<Pair> queue = new LinkedList<>();
            queue.offer(new Pair(start, 0));
            visited[start] = true;
            int farNode = start, maxDist = 0;
            while (!queue.isEmpty()) {
                Pair p = queue.poll();
                if (p.dist > maxDist) {
                    maxDist = p.dist;
                    farNode = p.node;
                }
                for (int nei : graph.get(p.node)) {
                    if (!visited[nei]) {
                        visited[nei] = true;
                        queue.offer(new Pair(nei, p.dist + 1));
                    }
                }
            }
            return new Pair(farNode, maxDist);
        }
        Pair u = bfs(0);
        Pair v = bfs(u.node);
        return v.dist;
    }
}
      

var treeDiameter = function(edges) {
    // Build adjacency list
    const graph = {};
    for (const [u, v] of edges) {
        if (!(u in graph)) graph[u] = [];
        if (!(v in graph)) graph[v] = [];
        graph[u].push(v);
        graph[v].push(u);
    }

    // Helper: BFS to find farthest node and its distance
    function bfs(start) {
        const visited = new Set();
        let queue = [[start, 0]];
        visited.add(start);
        let farthest = start, maxDist = 0;
        while (queue.length) {
            const [node, dist] = queue.shift();
            if (dist > maxDist) {
                maxDist = dist;
                farthest = node;
            }
            for (const nei of graph[node]) {
                if (!visited.has(nei)) {
                    visited.add(nei);
                    queue.push([nei, dist + 1]);
                }
            }
        }
        return [farthest, maxDist];
    }

    // 1st BFS from any node (say 0)
    const [u, _] = bfs(0);
    // 2nd BFS from u to find diameter
    const [v, diameter] = bfs(u);
    return diameter;
};