I found an interesting problem on https://codeforces.com/problemset/problem/1294/F:
You are given an unweighted tree with $n$ vertices. Recall that a tree is a connected undirected graph without cycles.

Your task is to choose three distinct vertices $a, b, c$ on this tree such that the number of edges which belong to at least one of the simple paths between $a$ and $b$, $b$ and $c$, or $a$ and $c$ is the maximum possible. See the notes section for a better understanding.

The simple path is the path that visits each vertex at most once.


-----Input-----

The first line contains one integer number $n$ ($3 \le n \le 2 \cdot 10^5$) — the number of vertices in the tree. 

Next $n - 1$ lines describe the edges of the tree in form $a_i, b_i$ ($1 \le a_i$, $b_i \le n$, $a_i \ne b_i$). It is guaranteed that given graph is a tree.


-----Output-----

In the first line print one integer $res$ — the maximum number of edges which belong to at least one of the simple paths between $a$ and $b$, $b$ and $c$, or $a$ and $c$.

In the second line print three integers $a, b, c$ such that $1 \le a, b, c \le n$ and $a \ne, b \ne c, a \ne c$.

If there are several answers, you can print any.


-----Example-----
Input
8
1 2
2 3
3 4
4 5
4 6
3 7
3 8

Output
5
1 8 6



-----Note-----

The picture corresponding to the first example (and another one correct answer):

[Image]

If you choose vertices $1, 5, 6$ then the path between $1$ and $5$ consists of edges $(1, 2), (2, 3), (3, 4), (4, 5)$, the path between $1$ and $6$ consists of edges $(1, 2), (2, 3), (3, 4), (4, 6)$ and the path between $5$ and $6$ consists of edges $(4, 5), (4, 6)$. The union of these paths is $(1, 2), (2, 3), (3, 4), (4, 5), (4, 6)$ so the answer is $5$. It can be shown that there is no better answer.

I tried it in Python, but could not do it. Can you solve it?
import sys
from collections import deque
n = int(input())
adj = [[] for _ in range(n)]
for u, v in (list(map(int, l.split())) for l in sys.stdin):
    adj[u-1].append(v-1)
    adj[v-1].append(u-1)

inf = 10**9


def rec(s):
    prev = [-1]*n
    prev[s] = inf
    dq = deque([s])
    last = s

    while dq:
        v = dq.popleft()
        last = v
        for dest in adj[v]:
            if prev[dest] > -1:
                continue
            prev[dest] = v
            dq.append(dest)

    return last, prev


v1, _ = rec(0)
v2, prev = rec(v1)
v = prev[v2]
visited = [0]*n
visited[v] = visited[v1] = visited[v2] = 1
dia = 0
max_e, max_e_i = 0, v

while v != inf:
    dia += 1
    if prev[v] != inf:
        visited[prev[v]] = 1

    stack = [(v, 0)]
    while stack:
        cv, e = stack.pop()
        if max_e < e:
            max_e, max_e_i = e, cv
        e += 1

        for dest in adj[cv]:
            if visited[dest]:
                continue
            visited[dest] = 1
            stack.append((dest, e))

    v = prev[v]

print(dia + max_e)
print(v1+1, v2+1, max_e_i+1)