HDU 4003

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <memory.h>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <iostream>
#include <sstream>

using namespace std;

const int maxn = 10005;

int n, s, k;
int dp[maxn][11];
vector< pair<int, int> > G[maxn];

void init() {
    int i;
    for (i = 1; i <= n; i++)
        G[i].clear();
    memset(dp, -1, sizeof(dp));
}

void dfs(int x, int p) {
    int i, j, k, y, v;
    
    if (p != -1 && G[x].size() == 1 ||
        p == -1 && G[x].size() == 0) {
        for (i = 0; i <= 10; i++)
            dp[x][i] = 0;
        return;
    }
    for (i = 0; i < G[x].size(); i++) {
        y = G[x][i].first;
        v = G[x][i].second;
        if (p == y) continue;
        dfs(y, x);
        for (k = 10; k >= 0; k--) {
            if (dp[x][k] == -1) {
                if (k) dp[x][k] = dp[y][k] + k * v;
                else dp[x][k] = dp[y][k] + 2 * v;
                for (j = 1; j <= k; j++) {
                    if (dp[x][k] > dp[y][j] + j * v)
                        dp[x][k] = dp[y][j] + j * v;
                }
            } else {
                dp[x][k] += dp[y][0] + 2 * v;
                for (j = 1; j <= k; j++) {
                    if (dp[x][k] > dp[x][k-j] + dp[y][j] + j * v)
                        dp[x][k] = dp[x][k-j] + dp[y][j] + j * v;
                }
            }
        }
    }
}

int main() {
    int i, x, y, v;
    while (scanf("%d %d %d", &n, &s, &k) != EOF) {
        init();
        for (i = 1; i < n; i++) {
            scanf("%d %d %d", &x, &y, &v);
            G[x].push_back(make_pair(y, v));
            G[y].push_back(make_pair(x, v));
        }
        dfs(s, -1);
        printf("%d\n", dp[s][k]);
    }
    return 0;
}