Problem:
サージェント・ライアン

「ライアン軍曹を救え」という指令のもと、アイヅ軍の救出部隊はドイツリーの水上都市で敵軍と激しい戦闘を繰り広げていました。彼らは無事に軍曹と合流しましたが、敵の戦車が多く、救出ヘリを呼べずにいました。そこで、彼らは敵の戦車を混乱させるため、都市にある橋を全て爆破するという作戦を実行することにしました。

作戦はすぐに司令部に伝えられ、救出ヘリの準備が進められました。救出ヘリを飛ばすためには、いつ橋が全て爆破されるかを予測しなければなりません。軍のプログラマであるあなたの任務は、救出部隊が全ての橋の爆破に必要な時間を計算することです。

水上都市は N 個の島で構成されており、島と島との間には橋がかかっています。すべての島はツリー状に繋がっています(下図参照) 。ある島からある島への経路は、一通りだけ存在します。各橋を渡るには、橋ごとに決められた時間がかかり、どちらの方向にもその時間で橋を渡ることが可能です。

救出部隊はボートなど水上を移動する手段を持っていないので島と島の間を移動するには橋を通る他ありません。救出部隊は、その時いる島に隣接している橋のうち、必要なものを一瞬で爆破することができます。救出部隊が全ての橋を爆破するのに必要な最小の時間はいくらでしょうか。ただし、島の中での移動時間は考えません。

島の数、それぞれの橋情報を入力とし、橋を全て爆破するのに必要な最小の時間を出力するプログラムを作成してください。島はそれぞれ 1 から N の番号で表されます。橋は N-1 本あります。橋情報は、その橋が隣接している二つの島の番号(a, b)と、その橋を渡るのに必要な時間 t で構成されます。救出部隊は島番号 1 の島からスタートするものとします。

Input

複数のデータセットの並びが入力として与えられる。入力の終わりはゼロひとつの行で示される。各データセットは以下の形式で与えられる。

N
a1 b1 t1
a2 b2 t2
:
aN-1 bN-1 tN-1

入力はすべて整数で与えられる。1 行目に島の数 N (2 ≤ N ≤ 20) が与えられる。

続く N-1 行に i 番目の橋の情報が与えられる。 ai, bi, ti (1 ≤ ti ≤ 500) は、i 番目の橋を通って島 ai と島 bi の間を時間 ti で移動できることを表す。

データセットの数は 100 を超えない。

Output

データセットごとに、橋を全て爆破するのに必要な最小の時間を1行に出力する。

Sample Input

7
1 2 5
2 3 2
3 4 3
2 5 3
5 6 3
5 7 8
0

Output for the Sample Input

12

Solution in Kotlin (judge verdict: Accepted)

import java.util.*
fun main(args:Array<String>?): Unit {
    while(true){
        val n = readLine()!!.toInt()
        if (n == 0) return
        val nodes = Array(n){Stack<Edge>()}
        repeat(n - 1){
            val (a, b, t) = readLine()!!.trim().split(' ').map(String::toInt)
            nodes[a - 1].push(Edge(b - 1, t))
            nodes[b - 1].push(Edge(a - 1, t))
        }
        println(solve(nodes))
    }
}
fun solve(defaultNode: Array<out Collection<Edge>>): Int {
    val depth = Array(defaultNode.size){-1}
    val queue = LinkedList<Int>()
    depth[0] = 0
    queue.add(0)
    while(queue.isNotEmpty()){
        val current = queue.pop()
        for ((to, _) in defaultNode[current]) if (depth[to] == -1){
            depth[to] = depth[current] + 1
            queue.add(to)
        }
    }
    val memoReturns = Array(defaultNode.size){null as Int?}
    val memoNotReturns = Array(defaultNode.size){null as Int?}
    val nodes = defaultNode.mapIndexed { current, node -> node.filter{depth[it.to] > depth[current] && defaultNode[it.to].size != 1}}
    fun costReturn(current: Int): Int {
        if (memoReturns[current] == null)
            memoReturns[current] = nodes[current].map{costReturn(it.to) + it.time * 2}.sum()
        return memoReturns[current]!!
    }
    fun costNotReturn(current: Int): Int {
        if (memoNotReturns[current] == null) {
            val returns = nodes[current].map { costReturn(it.to) + it.time * 2 }.sum()
            memoNotReturns[current] = nodes[current].map{
                returns - costReturn(it.to) - it.time + costNotReturn(it.to)
            }.min() ?: 0
        }
        return memoNotReturns[current]!!
    }
    costNotReturn(0)
    return costNotReturn(0)
}
data class Edge(val to: Int, val time: Int)