【树链剖分】 HDOJ 4718 The LCIS on the Tree

#include <iostream>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <climits>
#include <cstdlib>
#include <cmath>
#include <time.h>
#define maxn 100005
#define maxm 200005
#define eps 1e-10
#define mod 1000000007
#define INF 0x3f3f3f3f
#define PI (acos(-1.0))
#define lowbit(x) (x&(-x))
#define mp make_pair
#define ls o<<1
#define rs o<<1 | 1
#define lson o<<1, L, mid
#define rson o<<1 | 1, mid+1, R
//#pragma comment(linker, "/STACK:16777216")
typedef long long LL;
typedef unsigned long long ULL;
//typedef int LL;
using namespace std;
LL qpow(LL a, LL b){LL res=1,base=a;while(b){if(b%2)res=res*base;base=base*base;b/=2;}return res;}
LL powmod(LL a, LL b){LL res=1,base=a;while(b){if(b%2)res=res*base%mod;base=base*base%mod;b/=2;}return res;}
void scanf(int &__x){__x=0;char __ch=getchar();while(__ch==' '||__ch=='\n')__ch=getchar();while(__ch>='0'&&__ch<='9')__x=__x*10+__ch-'0',__ch = getchar();}
LL gcd(LL _a, LL _b){if(!_b) return _a;else return gcd(_b, _a%_b);}
// head

struct Edge
{
int v;
Edge *next;
}E[maxm], *H[maxn], *edges;

int segmax[maxn << 2];
int maxnum[maxn << 2];
int segmin[maxn << 2];
int minnum[maxn << 2];
int lmin[maxn << 2];
int rmin[maxn << 2];
int lmax[maxn << 2];
int rmax[maxn << 2];
int size[maxn];
int son[maxn];
int dep[maxn];
int top[maxn];
int fa[maxn];
int w[maxn];
int val[maxn], val1[maxn];
int z, n, m, ok, res, last;

void addedges(int u, int v)
{
edges->v = v;
edges->next = H[u];
H[u] = edges++;
}

void dfs1(int u)
{
size[u] = 1, son[u] = 0;
for(Edge *e = H[u]; e; e = e->next) {
dep[e->v] = dep[u] + 1;
fa[e->v] = u;
dfs1(e->v);
size[u] += size[e->v];
if(size[son[u]] < size[e->v]) son[u] = e->v;
}
}

void dfs2(int u, int tp)
{
w[u] = ++z, top[u] = tp;
if(son[u]) dfs2(son[u], tp);
for(Edge *e = H[u]; e; e = e->next)
if(e->v != son[u]) dfs2(e->v, e->v);
}

void init(void)
{
z = 0;
edges = E;
memset(H, 0, sizeof H);
memset(son, 0, sizeof son);
}

void read(void)
{
int v, u;
scanf("%d", &n);
for(int i = 1; i <= n; i++) scanf("%d", &val1[i]);
for(v = 2; v <= n; v++) {
scanf("%d", &u);
addedges(u, v);
}
}

void pushup(int o, int L, int R)
{
int mid = (L + R) >> 1;
if(mid - L + 1 == lmax[ls]) {
if(val[mid] < val[mid+1]) lmax[o] = lmax[ls] + lmax[rs];
else lmax[o] = lmax[ls];
}
else lmax[o] = lmax[ls];

if(R - mid == rmax[rs]) {
if(val[mid] < val[mid+1]) rmax[o] = rmax[ls] + rmax[rs];
else rmax[o] = rmax[rs];
}
else rmax[o] = rmax[rs];

segmax[o] = 0;
if(segmax[ls] > segmax[o]) segmax[o] = segmax[ls], maxnum[o] = maxnum[ls];
if(segmax[rs] > segmax[o]) segmax[o] = segmax[rs], maxnum[o] = maxnum[rs];
if(rmax[ls] + lmax[rs] > segmax[o] && val[mid] < val[mid+1])
segmax[o] = rmax[ls] + lmax[rs], maxnum[o] = mid - rmax[ls] + 1;

if(mid - L + 1 == lmin[ls]) {
if(val[mid] > val[mid+1]) lmin[o] = lmin[ls] + lmin[rs];
else lmin[o] = lmin[ls];
}
else lmin[o] = lmin[ls];

if(R - mid == rmin[rs]) {
if(val[mid] > val[mid+1]) rmin[o] = rmin[ls] + rmin[rs];
else rmin[o] = rmin[rs];
}
else rmin[o] = rmin[rs];

segmin[o] = 0;
if(segmin[ls] > segmin[o]) segmin[o] = segmin[ls], minnum[o] = minnum[ls];
if(segmin[rs] > segmin[o]) segmin[o] = segmin[rs], minnum[o] = minnum[rs];
if(rmin[ls] + lmin[rs] > segmin[o] && val[mid] > val[mid+1])
segmin[o] = rmin[ls] + lmin[rs], minnum[o] = mid - rmin[ls] + 1;
}

void build(int o, int L, int R)
{
if(L == R) {
segmax[o] = lmax[o] = rmax[o] = 1;
segmin[o] = lmin[o] = rmin[o] = 1;
maxnum[o] = minnum[o] = L;
return;
}
int mid = (L + R) >> 1;
build(lson);
build(rson);
pushup(o, L, R);
}

int query_max(int o, int L, int R, int ql, int qr)
{
if(ql <= L && qr >= R) return segmax[o];
int mid = (L + R) >> 1;
if(ql <= mid && qr > mid) {
int ans = max(query_max(lson, ql, qr), query_max(rson, ql, qr));
if(val[mid+1] > val[mid]) ans = max(ans, min(qr, mid + lmax[rs]) - max(ql, mid - rmax[ls] + 1) + 1);
return ans;
}
else if(ql <= mid) return query_max(lson, ql, qr);
else return query_max(rson, ql, qr);
}

int query_min(int o, int L, int R, int ql, int qr)
{
if(ql <= L && qr >= R) return segmin[o];
int mid = (L + R) >> 1;
if(ql <= mid && qr > mid) {
int ans = max(query_min(lson, ql, qr), query_min(rson, ql, qr));
if(val[mid+1] < val[mid]) ans = max(ans, min(qr, mid + lmin[rs]) - max(ql, mid - rmin[ls] + 1) + 1);
return ans;
}
else if(ql <= mid) return query_min(lson, ql, qr);
else return query_min(rson, ql, qr);
}

void query_lmax(int o, int L, int R, int ql, int qr)
{
if(ok) return;
if(ql <= L && qr >= R) {
if(last  < val[L]) {
res += lmax[o];
if(lmax[o] != R - L + 1) ok = 1;
last = val[R];
}
else ok = 1;
return;
}
int mid = (L + R) >> 1;
if(ql <= mid) query_lmax(lson, ql, qr);
if(qr > mid) query_lmax(rson, ql, qr);
}

void query_lmin(int o, int L, int R, int ql, int qr)
{
if(ok) return;
if(ql <= L && qr >= R) {
if(last > val[L]) {
res += lmin[o];
if(lmin[o] != R - L + 1) ok = 1;
last = val[R];
}
else ok = 1;
return;
}
int mid = (L + R) >> 1;
if(ql <= mid) query_lmin(lson, ql, qr);
if(qr > mid) query_lmin(rson, ql, qr);
}

void query_rmax(int o, int L, int R, int ql, int qr)
{
if(ok) return;
if(ql <= L && qr >= R) {
if(last > val[R]) {
res += rmax[o];
if(rmax[o] != R - L + 1) ok = 1;
last = val[L];
}
else ok = 1;
return;
}
int mid = (L + R) >> 1;
if(qr > mid) query_rmax(rson, ql, qr);
if(ql <= mid) query_rmax(lson, ql, qr);
}

void query_rmin(int o, int L, int R, int ql, int qr)
{
if(ok) return;
if(ql <= L && qr >= R) {
if(last < val[R]) {
res += rmin[o];
if(rmin[o] != R - L + 1) ok = 1;
last = val[L];
}
else ok = 1;
return;
}
int mid = (L + R) >> 1;
if(qr > mid) query_rmin(rson, ql, qr);
if(ql <= mid) query_rmin(lson, ql, qr);
}

int solve(int a, int b)
{
int f1 = top[a], f2 = top[b];
int ans = 0, lasta = a, lastb = b;
int prea = 0, preb = 0;
int lminv, rminv, lmaxv, rmaxv;
while(f1 != f2) {
if(dep[f1] < dep[f2]) {
ans = max(ans, query_max(1, 1, n, w[f2], w[b]));
ok = res = 0, last = val[w[b]] + 1;
query_rmax(1, 1, n, w[f2], w[b]);
rmaxv = res;
ok = res = 0, last = val[w[f2]] - 1;
query_lmax(1, 1, n, w[f2], w[b]);
lmaxv = res;
if(val[w[lastb]] > val[w[b]]) ans = max(ans, preb + rmaxv);
if(rmaxv == w[b] - w[f2] + 1 && val[w[b]] < val[w[lastb]]) preb = rmaxv + preb;
else preb = lmaxv;
lastb = f2;
b = fa[f2], f2 = top[b];
}
else {
ans = max(ans, query_min(1, 1, n, w[f1], w[a]));
ok = res = 0, last = val[w[a]] - 1;
query_rmin(1, 1, n, w[f1], w[a]);
rminv = res;
ok = res = 0, last = val[w[f1]] + 1;
query_lmin(1, 1, n, w[f1], w[a]);
lminv = res;
if(val[w[lasta]] < val[w[a]]) ans = max(ans, prea + rminv);
if(rminv == w[a] - w[f1] + 1 && val[w[a]] > val[w[lasta]]) prea = rminv + prea;
else prea = lminv;
lasta = f1;
a = fa[f1], f1 = top[a];
}
}
if(a == b) {
if(lasta == a) {
if(prea == 0) prea = 1;
if(val[w[a]] < val[w[lastb]]) ans = max(ans, prea + preb);
}
else if(lastb == b) {
if(preb == 0) preb = 1;
if(val[w[b]] > val[w[lasta]]) ans = max(ans, prea + preb);
}
else {
if(val[w[a]] > val[w[lasta]]) ans = max(ans, prea+1);
if(val[w[a]] < val[w[lastb]]) ans = max(ans, preb+1);
if(val[w[a]] > val[w[lasta]] && val[w[a]] < val[w[lastb]]) ans = max(ans, prea + preb + 1);
}
return ans;
}
if(a != b) {
if(dep[a] < dep[b]) {
ans = max(ans, query_max(1, 1, n, w[a], w[b]));
ok = res = 0, last = val[w[a]] - 1;
query_lmax(1, 1, n, w[a], w[b]);
lmaxv = res;
ok = res = 0, last = val[w[b]] + 1;
query_rmax(1, 1, n, w[a], w[b]);
rmaxv = res;
if(val[w[lastb]] > val[w[b]]) ans = max(ans, preb + rmaxv);
if(rmaxv == w[b] - w[a] + 1 && val[w[b]] < val[w[lastb]]) preb = rmaxv + preb;
else preb = lmaxv;
lastb = a;
b = a;
}
else {
ans = max(ans, query_min(1, 1, n, w[b], w[a]));
ok = res = 0, last = val[w[b]] + 1;
query_lmin(1, 1, n, w[b], w[a]);
lminv = res;
ok = res = 0, last = val[w[a]] - 1;
query_rmin(1, 1, n, w[b], w[a]);
rminv = res;
if(val[w[lasta]] < val[w[a]]) ans = max(ans, prea + rminv);
if(rminv == w[a] - w[b] + 1 && val[w[a]] > val[w[lasta]]) prea = rminv + prea;
else prea = lminv;
lasta = b;
a = b;
}
}
if(a == lasta) {
if(preb == 0) preb = 1;
if(val[w[lastb]] > val[w[b]]) ans = max(ans, prea + preb);
}
else if(b == lastb) {
if(prea == 0) prea = 1;
if(val[w[lasta]] < val[w[a]]) ans = max(ans, prea + preb);
}
else {

}

return ans;
}
void work(void)
{
fa[1] = 1;
dfs1(1);
dfs2(1, 1);
for(int i = 1; i <= n; i++) val[w[i]] = val1[i];
build(1, 1, n);
int a, b;
scanf("%d", &m);
while(m--) {
scanf("%d%d", &a, &b);
if(a == b) {
printf("1\n");
continue;
}
printf("%d\n", solve(a, b));
}
}

int main(void)
{
int _, __;
while(scanf("%d", &_)!=EOF) {
__ = 0;
while(_--) {
init();
read();
printf("Case #%d:\n", ++__);
work();
if(_) printf("\n");
}
}

return 0;
}