算法1：树-当成无向图存储-深搜-宽搜也可(暴力搜索-N^2)

#include<bits/stdc++.h>
using namespace std;
//存储成无向树，正反存储边
const int N = 110, M = N*2;
int h[N], e[M], w[M], ne[M], n, idx;
bool st[N];

void add(int a, int b, int v) {
    w[idx] = v;
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx++;
}
int dfs(int u, int lev) { //返回以u为根节点 所有子节点走到u的距离
    int s = w[u] * lev;
    st[u] = 1; //标记访问了 
    for (int i = h[u]; i != -1; i = ne[i]) {
        int j = e[i];
        if (st[j]) continue;
        s += dfs(j, lev+1);
    }
    return s;
}

int main() {
    memset(h, -1, sizeof h);
    cin >> n;
    for (int i = 1; i <= n; ++ i) {
        int x, l, r;
        cin >> x >> l >> r;
        w[i] = x;
        if (l) {
            add(i, l, x);
            add(l, i, x);
        }
        if (r) {
            add(i, r, x);
            add(r, i, x);
        }
    }
    int res = 1e9;
    for (int i = 1; i <= n; ++ i) { //枚举每个点作为根节点，跑一边深搜
        memset(st, 0, sizeof st);
        res = min(res, dfs(i, 0)); //深搜出每个节点到当前节点花费
    }
    cout << res;
    return 0;
}

算法2：()

#include<bits/stdc++.h>
using namespace std;
//存储成无向树，正反存储边
const int N = 110, M = N*2;
int h[N], w[N];
int e[M], ne[M], n, idx;

void add(int a, int b) {
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx++;
} //传入u节点是从谁走到的，不能走回去
int dfs(int u, int father, int lev) { //返回以u为根节点 所有子节点走到u的距离
    int s = w[u] * lev;
    for (int i = h[u]; i != -1; i = ne[i]) {
        int j = e[i];
        if (j == father) continue; //往回走的 跳过
        s += dfs(j, u, lev+1); //走到j 是从父亲u走到j的
    }
    return s;
}

int main() {
    memset(h, -1, sizeof h);
    cin >> n;
    for (int i = 1; i <= n; ++ i) {
        int x, l, r;
        cin >> x >> l >> r;
        w[i] = x;
        if (l) add(i, l), add(l, i);
        if (r) add(i, r), add(r, i); //要用逗号分开 分号一句话结束
    }
    int res = 1e9;
    for (int i = 1; i <= n; ++ i)  //枚举每个点作为根节点，跑一边深搜
        res = min(res, dfs(i, -1, 0)); //深搜出每个节点到当前节点花费 i的父节点是-1
    cout << res;
    return 0;
}

优化-换根做法： https://www.acwing.com/solution/content/24838/