árbol codiciosos dp +
En la medida de lo posible bajo comprar, vender caro
Establecer una buena regla de transferencia muy bien
La memoria a largo
dp [i] [1] nodo número I o uno de sus hijos el precio de compra más bajo consideración // depender de peajes
dp [0] nodo número [i] i o uno de sus hijos el precio de venta más alto para ser considerado peaje //
#include <iostream>
# include <cstring>
# include <algoritmo>
#include <vector>
using namespace std;
typedef largo largo ll;
struct nodo {
int p;
ll len;
Node (int a, ll b): p (a), Len (b) {}
};
const int maxN = 2E5 + 7;
vector <Node> G [maxN];
int n;
add vacío (int x, int y, ll len) {
G [x] .push_back (Node (y, len));
}
ll dp [maxN] [4]; // 1 comprar más pequeños, mayor venta 0
ll ans = 0;
int DFS (int x, int hace) {
for (int i = 0; i <G [x] .size (); i ++) {
int p = G [x] [i] .p;
ll ln = G [x] [i] .LEN;
si (p == fa) continuar;
dfs (p, x);
dp [x] [1] = min (dp [x] [1], dp [p] [1] + ln);
dp [x] [0] = max (dp [x] [0], dp [p] [0] - ln);
}
año = max (años dp [x] [0] - DP [x] [1]);
return 0;
}
int main () {
t int;
scanf ( "% d", & t);
while (t--) {
año = 0;
scanf ( "% d", y n);
for (int i = 0; i <= n; i ++) {
G [i] .clear ();
}
Int ser, y;
ll len;
for (int i = 1; i <= n; i ++) {
scanf ( "% LLD", y dp [i] [0]);
dp [i] [1] = dp [i] [0];
}
for (int i = 1; i <n; i ++) {
scanf ( "% d% d% LLD", y ser, y en, y LEN);
añadir (ser, y, s);
añadir (y, BE, s);
}
dfs (1, -1);
printf ( "% LLD \ n", ans);
}
return 0;
}