SPOJ GSS7 Can you answer these queries VII

Can you answer these queries VII

Time Limit: 1000ms
Memory Limit: 262144KB
This problem will be judged on SPOJ. Original ID: GSS7
64-bit integer IO format: %lld Java class name: Main

Given a tree with N ( N<=100000 ) nodes. Each node has a interger value x_i ( |x_i|<=10000 ).

You have to apply Q ( Q<=100000 ) operations:

1. 1 a b : answer the maximum contiguous sum (maybe empty,will always larger than or equal to 0 ) from the path a->b ( inclusive ).

2. 2 a b c : change all value in the path a->b ( inclusive ) to c.

Input

first line consists one interger N.

next line consists N interger x_i.

next N-1 line , each consists two interger u,v , means that node u and node v are connected

next line consists 1 interger Q.

next Q line : 1 a b or 2 a b c .

Output

For each query, output one line the maximum contiguous sum.

Example

Input:
5

-3 -2 1 2 3

1 2

2 3

1 4

4 5

3

1 2 5

2 3 4 2

1 2 5

Output:
5

9

Source

my own problems

解题：LCT

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct arc{
int to,next;
arc(int x = 0,int y = -1){
to = x;
next  = y;
}
}e[maxn<<1];
struct LCT{
int fa[maxn],ch[maxn][2],sz[maxn],parent[maxn];
int key[maxn],ls[maxn],rs[maxn],ms[maxn],sum[maxn];
bool reset[maxn];
inline void pushup(int x){
sz[x] = 1 + sz[ch[x][0]] + sz[ch[x][1]];
sum[x] = key[x] + sum[ch[x][0]] + sum[ch[x][1]];
ls[x] = max(ls[ch[x][0]],sum[ch[x][0]] + key[x] + ls[ch[x][1]]);
rs[x] = max(rs[ch[x][1]],sum[ch[x][1]] + key[x] + rs[ch[x][0]]);
ms[x] = max(ms[ch[x][0]],ms[ch[x][1]]);
ms[x] = max(ms[x],key[x] + rs[ch[x][0]] + ls[ch[x][1]]);
}
inline void set(int x,int val){
if(!x) return;
reset[x] = true;
key[x] = val;
sum[x] = sz[x]*val;
ls[x] = rs[x] = ms[x] = max(0,sum[x]);
}
inline void pushdown(int x){
if(reset[x]){
set(ch[x][0],key[x]);
set(ch[x][1],key[x]);
reset[x] = false;
}
}
void rotate(int x,int kd){
int y = fa[x];
pushdown(y);
pushdown(x);
ch[y][kd^1] = ch[x][kd];
fa[ch[x][kd]] = y;
fa[x] = fa[y];
ch[x][kd] = y;
fa[y] = x;
if(fa[x]) ch[fa[x]][y == ch[fa[x]][1]] = x;
pushup(y);
}
void splay(int x,int goal = 0){
pushdown(x);
int y = x;
while(fa[y]) y = fa[y];
if(x != y){
parent[x] = parent[y];
parent[y] = 0;
while(fa[x] != goal){
pushdown(fa[fa[x]]);
pushdown(fa[x]);
pushdown(x);
if(fa[fa[x]] == goal) rotate(x,x == ch[fa[x]][0]);
else{
int y = fa[x],z = fa[y],s = (ch[z][0] == y);
if(x == ch[y][s]){
rotate(x,s^1);
rotate(x,s);
}else{
rotate(y,s);
rotate(x,s);
}
}
}
pushup(x);
}
}
void access(int x){
for(int y = 0; x; x = parent[x]){
splay(x);
fa[ch[x][1]] = 0;
parent[ch[x][1]] = x;
ch[x][1] = y;
fa[y] = x;
parent[y] = 0;
y = x;
pushup(x);
}
}
void update(int x,int y,int z){
access(y);
for(y = 0; x; x = parent[x]){
splay(x);
if(!parent[x]){
key[x] = z;
set(y,z);
set(ch[x][1],z);
return;
}
fa[ch[x][1]] = 0;
parent[ch[x][1]] = x;
ch[x][1] = y;
fa[y] = x;
parent[y] = 0;
y = x;
pushup(x);
}
}
int query(int x,int y){
access(y);
for(y = 0; x; x = parent[x]){
splay(x);
if(!parent[x]){
int ret = max(ms[y],ms[ch[x][1]]);
ret = max(ret,key[x] + ls[y] + ls[ch[x][1]]);
return ret;
}
fa[ch[x][1]] = 0;
parent[ch[x][1]] = x;
ch[x][1] = y;
fa[y] = x;
parent[y] = 0;
y = x;
pushup(x);
}
}
void init(){
memset(fa,0,sizeof fa);
memset(parent,0,sizeof parent);
memset(reset,false,sizeof reset);
memset(ch,0,sizeof ch);
sz[0] = 0;
}
}lct;
int head[maxn],tot;
void add(int u,int v){
e[tot] = arc(v,head[u]);
head[u] = tot++;
}
void dfs(int u,int fa){
for(int i = head[u]; ~i; i = e[i].next){
if(e[i].to == fa) continue;
lct.parent[e[i].to] = u;
dfs(e[i].to,u);
}
}
int main(){
int n,m,u,v,x,y,z,op;
while(~scanf("%d",&n)){
memset(head,-1,sizeof head);
tot =  0;
lct.init();
for(int i = 1; i <= n; ++i){
lct.sz[i] = 1;
scanf("%d",&lct.key[i]);
lct.sum[i] = lct.key[i];
lct.ls[i] = lct.rs[i] = lct.ms[i] = max(0,lct.key[i]);
}
for(int i = 1; i < n; ++i){
scanf("%d%d",&u,&v);
add(u,v);
add(v,u);
}
dfs(1,1);
scanf("%d",&m);
while(m--){
scanf("%d%d%d",&op,&x,&y);
if(op == 1) printf("%d\n",lct.query(x,y));
else{
scanf("%d\n",&z);
lct.update(x,y,z);
}
}
}
return 0;
}

View Code