import sys


def solve() -> None:
    """迭代后序遍历树，自底向上算 down 与 best"""
    data = sys.stdin.buffer.read().split()
    if not data:
        return
    it = iter(data)
    n = int(next(it))

    adj = [[] for _ in range(n + 1)]
    for _ in range(n - 1):
        u = int(next(it)); v = int(next(it)); w = int(next(it))
        adj[u].append((v, w))
        adj[v].append((u, w))

    # 以 1 为根，迭代建出 BFS 序（避免深链递归爆栈）
    parent = [0] * (n + 1)
    parent[1] = -1
    order = [1]
    for u in order:
        for v, _ in adj[u]:
            if v != parent[u]:
                parent[v] = u
                order.append(v)

    down = [0] * (n + 1)   # 向下一条链再回来
    best = [0] * (n + 1)   # 进入 u 后能拿到的最大值

    for u in reversed(order):
        # 先取孩子里最大的两个「探路」收益（留一个给别人，别和主链抢边）
        first = second = 0
        first_child = 0
        for v, w in adj[u]:
            if parent[v] != u:
                continue
            d = w + down[v]
            if d > first:
                second, first, first_child = first, d, v
            elif d > second:
                second = d

        down[u] = first
        cur = first                       # 探一次路就停在 u
        for v, w in adj[u]:
            if parent[v] != u:
                continue
            other = second if v == first_child else first
            cand = w + best[v] + other    # 主链走 v，再挂上最好的那个分支
            if cand > cur:
                cur = cand
        best[u] = cur

    sys.stdout.write(str(best[1]) + "\n")


if __name__ == "__main__":
    solve()

示例推演

以题面样例为例，树是

      1
   1/ |2  \3
   2  3    4

叶子 2、3、4 没有孩子，所以 down[2] = down[3] = down[4] = 0，
best[2] = best[3] = best[4] = 0。

到 1 号点，先算三个孩子的探路收益 $d_c = w(1,c) + down[c]$ ：

孩子 $c$	$w(1,c)$	$d_c$
2	1	1
3	2	2
4	3	3

最大值 first = 3（孩子 4），次大值 second = 2（孩子 3），所以
down[1] = 3。接着枚举主链往哪儿走：

主链走	主链收益	支链收益	合计
不走（停在 1）	0	3	3
孩子 2	$1 + best[2] = 1$	3	4
孩子 3	$2 + best[3] = 2$	3	5
孩子 4	$3 + best[4] = 3$	2	5

best[1] = 5，输出 5。对应的走法就是题面说明里的 1 → 4 → 1 → 3：
先下支链去 4（拿 3，再回来），主链再走到 3（拿 2）。

再看一个「支链挂在主链中间」的例子：边为 1-2(1)、2-3(50)、2-4(50)、1-5(2)。

节点	`down`	`best`	说明
3、4、5	0	0	叶子
2	50	100	主链走 3、支链挂 4（或反过来）
1	$1 + 50 = 51$	103	主链走 2，1 上挂支链 5

最优走法是 1 → 5 → 1 → 2 → 3 → 2 → 4，拿到 $2 + 1 + 50 + 50 = 103$ 。

复杂度分析

解法	时间复杂度	空间复杂度	说明
枚举所有走法	指数级	指数级	走法数量随点数爆炸，不可行
树形 DP（本文）	$O(n)$	$O(n)$	每个点只统计一次孩子，另加两次遍历

$n \le 10^5$ ， $O(n)$ 的两次遍历（建父节点、倒序转移）在 Python 里也是毫秒级。

易错点总结

1. 以为能走遍所有边

「每个点最多两次」是很紧的限制。以 1 为中心、三条边权为 1、2、3 的菊花图为
例，走 1→2→1→3→1→4 会让 1 号点出现三次，不合法；最多只能拿最大的两条边。

2. 主链和支链抢同一条边

主链走孩子 $c$ 的时候， $u$ 上的支链不能再挂到 $c$ 上，否则 $u$ 到 $c$
这条边被算两次（其实也只拿得到一件物品）。所以要用「最大值 + 次大值」，
而不是「最大值 × 2」。

3. 递归写 DFS 爆栈

$n = 10^5$ 且树是一条链时，递归深度就是 $10^5$ 。要么
sys.setrecursionlimit(10**6)，要么像本文这样先迭代求出遍历顺序，
再倒序做转移。

4. `down` 的下界忘了取 0

叶子节点的 down 必须是 0（原地不动），而不是负无穷。写 -inf 又忘了
在 max 里补 0，叶子就会算出负数。

5. 权值范围

$w \le 10^9$ 、 $n \le 10^5$ ，答案最大约 $10^{14}$ ，超出 32 位整数范围。
Python 的 int 天然没问题；换成 C++ 要用 long long。

扩展思考

把「每个点最多走两次」改成「最多走 $k$ 次」，则每个点可以挂 $k-1$ 条支链，
只需把「最大值 + 次大值」换成「前 $k-1$ 大的 $d_c$ 」之和，复杂度仍然是
$O(n \log n)$ （排序）或 $O(nk)$ 。
如果要求最后必须回到 1 号点，那么根节点也只剩一次「回来」的机会，
整条路线只能是「一条向下的链 + 原路返回」，答案退化成 down[1]。
如果边权允许为负，max(0, ...) 的写法自动就对了：不划算的边不去走。
把「边上有物品」换成「点上有物品」，DP 结构几乎不变，只是计价值的位置
从边换到点，需要额外注意每个点的物品只算一次。