La idea principal del tema: Dado que un árbol tiene 1 ≤ n ≤105 Nodos, cada nodo tiene un peso 1 ≤aI≤105 , Por el nodo que busca la configuración de una
diferencia no cae la subcadena más larga de pesos consecutivos, y los valores máximos y mínimos de la cadena Dyo fF≤ D , 1 ≤ D ≤105 , Número de muestras T≤ 10 .
Idea: Es más conveniente dividir y conquistar con árboles. Considere los dos casos en los que esta ruta pasa por la raíz y no pasa por la raíz; si no pasa por la raíz, la encontrará en su subárbol.
Después de pasar por la raíz, primero debe mantener una cadena ascendente ( cuanto más lejos de la raíz, menor será el valor), y luego en la cadena descendente Cada vez que llegue a la cadena ascendente, puede obtener dos puntos.
En la cuerda ascendente, si De p [ u ] ≥ de p [ v ] && v a l[ u ] ≥ v a l[ v ] , Entonces u no será peor que v en ningún momento, luego v se puede eliminar.
Otra explicacion
int nCase = 0;
const int maxn = 1e5 + 123;
int n, D;
vector<int> G[maxn], nodes;
bool del[maxn];
int size[maxn], maxBranch[maxn];
int val[maxn];
int ans;
/*找到每棵树的中心根*/
void dfs(int u,int f) {
size[u] = 1, maxBranch[u] = 0;
for (int v : G[u]) {
if (v != f && !del[v]) {
dfs(v, u);
size[u] += size[v];
maxBranch[u] = max(maxBranch[u], size[v]);
}
}
nodes.push_back(u);
}
int findRoot(int u) {
nodes.clear();
dfs(u, -1);
int rt = u;
for (int v : nodes) {
maxBranch[v] = max(maxBranch[v], size[u] - size[v]);
if (maxBranch[v] < maxBranch[rt]) {
rt = v;
}
}
return rt;
}
map<int, int> up;
/*更新up值,如果dep[u] >= dep[v] && val[u] >= val[v],
那么v在任何时候都不会比u优*/
void updata(int v, int len) {
auto x = up.lower_bound(v);
if (x != up.end() && x->second >= len) return ;
auto ed = up.upper_bound(v);
auto it = map<int, int> :: reverse_iterator(ed);/*反着找*/
while(it != up.rend() && it->second <= len) it++;
up.erase(it.base(), ed);
up[v] = len;
}
void dfs_up(int u,int f,int depth) {
updata(val[u], depth);
for (int v : G[u])
if (!del[v] && v != f && val[v] <= val[u]) dfs_up(v, u, depth + 1);
}
void dfs_down(int u,int f,int depth) {
auto it = up.lower_bound(val[u] - D);
if (it != up.end()) ans = max(ans, it->second + depth + 1);
for (int v : G[u]) {
if (!del[v] && v != f && val[v] >= val[u]) dfs_down(v, u, depth + 1);
}
}
void _work(int u,vector<int>& son) {
up.clear();
up[val[u]] = 0;
for (int v : son) {
if (val[v] >= val[u]) dfs_down(v, u, 1);
if (val[v] <= val[u]) dfs_up(v, u, 1);
}
}
void work(int u) {
vector<int> son;
for (int v : G[u])
if (!del[v]) son.push_back(v);
_work(u, son);
/*反转一次继续找,因为对于以v为根的子树求的上升值是其前面的子树形成的结果*/
/*还有可能是其后面的子树更优,所以要反转继续找*/
reverse(ALL(son));
_work(u, son);
}
void solve(int u) {
u = findRoot(u);
vector<int> son;
work(u);
del[u] = true;
for (int v : G[u])
if (!del[v]) solve(v);
}
int main(int argc, const char * argv[])
{
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
// ios::sync_with_stdio(false);
// cout.sync_with_stdio(false);
// cin.sync_with_stdio(false);
int kase;cin >> kase;
while(kase--) {
cin >> n >> D;
Rep(i, 1, n) G[i].clear();
memset(del + 1, false, n * sizeof (bool));
Rep(i, 1, n) scanf("%d", &val[i]);
int u, v;
Rep(i, 1, n - 1) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
ans = 1;
solve(1);
printf("Case #%d: %d\n", ++nCase, ans);
}
// showtime;
return 0;
}