bzoj3999 TJOI2015旅游

http://www.elijahqi.win/archives/777
题目描述

为了提高智商，ZJY准备去往一个新世界去旅游。这个世界的城市布局像一棵树。每两座城市之间只有一条路径可

以互达。每座城市都有一种宝石，有一定的价格。ZJY为了赚取最高利益，她会选择从A城市买入再转手卖到B城市

。由于ZJY买宝石时经常卖萌，因而凡是ZJY路过的城市，这座城市的宝石价格会上涨。让我们来算算ZJY旅游完之

后能够赚取的最大利润。（如a城市宝石价格为v，则ZJY出售价格也为v）

输入输出格式

输入格式：

第一行输入一个正整数N，表示城市个数。

接下来一行输入N个正整数表示每座城市宝石的最初价格p，每个宝石的初始价格不超过100。

第三行开始连续输入N-1行，每行有两个数字x和y。表示x城市和y城市有一条路径。城市编号从1开始。

下一行输入一个整数Q，表示询问次数。

接下来Q行，每行输入三个正整数a,b,v，表示ZJY从a旅游到b，城市宝石上涨v。

1≤ N≤50000， 1≤Q ≤50000

输出格式：

对于每次询问，输出ZJY可能获得的最大利润，如果亏本则输出0。

输入输出样例

输入样例#1：

3

1 2 3

1 2

2 3

2

1 2 100

1 3 100
输出样例#1：

1

1
树链剖分，感觉蛮有难度，考场上也不好写 注意树的节点数应该是4*N

现在bzoj时限排在第一页 qwq怕是很快被神犇虐，求轻虐

首先我们不妨把问题简化一下，将树形图简化为一维的，那么我们可以光明正大使用线段树维护

http://www.elijahqi.win/2017/09/09/codeves-3304-%e6%b0%b4%e6%9e%9c%e5%a7%90%e9%80%9b%e6%b0%b4%e6%9e%9c%e8%a1%97%e2%85%a0/

上面这道题大家可以看一看 也有讲解

然后对于树上的操作，我们选择树链剖分降低复杂度

树链剖分dfs1我们做的是把所有的轻重儿子划分出来，如果是fa则continue;

dfs2是针对我们已经划分好的给予标记

我们首先先给重儿子标记，if (son[x]) dfs2(son[x],top);

这样的话保证了重儿子的标号是连续的同时也保证了我们在线段树上的查询是连续的

另外搜索的时候记录w数组，这是一个坑点，下面建立线段树会说

建立完重儿子开始建立轻儿子，轻儿子的每个顶都是自己，重儿子就是连续一串的顶

注意搜索轻儿子的时候因为是双向边，要判断下是否是父亲或者是否是重儿子（之前搜索过）

接下来就是建立线段树，我想这个不用多赘述了

强调一下对于建立线段树时初值的给法

我一开始给的是tree[x].max=tree[x].min=a[id[l]];

这是一种错误的给法，我们思考一下我们线段树和真正树的映射关系

我们其实像树上莫队类似我们线段树应该是我们根据深搜序来确定的

我们id里储存的相当于我们根据普通的序列去找深搜序列

然而线段树的初值是要根据深搜序寻找普通序列

然后最后查找答案的时候要注意方向性

void solve(int x,int y,int v){
node1 ansl,ansr;
while (tp[x]!=tp[y]){
if(dep[tp[x]]>dep[tp[y]]){
ansl=update1(ansl,query(root,id[tp[x]],id[x],v));
x=fa[tp[x]];
}else{
ansr=update1(query(root,id[tp[y]],id[y],v),ansr);
y=fa[tp[y]];
}
}
swap(ansl.ans,ansl.ans1);
if (id[x]

#include<cstdio>
#include<algorithm>
#define N 55000
#define inf 0x7fffffff
using namespace std;
inline int read(){
    int x=0;char ch=getchar();
    while (ch<'0'||ch>'9') ch=getchar();
    while (ch<='9'&&ch>='0'){x=x*10+ch-'0';ch=getchar();}
    return x;
}
struct node{
    int y,next;
}data[N<<1];
struct node1{
    int max,min,ans,ans1;
    node1(){
        ans=ans1=max=0;min=inf;
    }
};
struct node2{
    int l,r,left,right,max,min,ans,ans1,lazy;
}tree[N<<2];
int size[N],id[N],fa[N],son[N],tp[N],a[N],dep[N],h[N],cnt,root,n,num,m,w[N];
void dfs1(int x){
    size[x]=1;
    for (int i=h[x];i;i=data[i].next){
        int y=data[i].y;
        if(fa[x]==y) continue;
        dep[y]=dep[x]+1;fa[y]=x;dfs1(y);size[x]+=size[y];
        if (size[y]>size[son[x]]) son[x]=y;
    }
}
void dfs2(int x,int top){
    id[x]=++cnt;tp[x]=top;w[cnt]=a[x];
    if (son[x]) dfs2(son[x],top);
    for (int i=h[x];i;i=data[i].next){
        int y=data[i].y;
        if (y==fa[x]||y==son[x]) continue;
        dfs2(y,y);
    }
}
inline void update(int x){
    int l=tree[x].left,r=tree[x].right;
    tree[x].ans=max(tree[r].max-tree[l].min,max(tree[l].ans,tree[r].ans));
    tree[x].ans1=max(tree[l].max-tree[r].min,max(tree[l].ans1,tree[r].ans1));
    tree[x].min=min(tree[l].min,tree[r].min);
    tree[x].max=max(tree[l].max,tree[r].max);

}
void print(int x){
    if (tree[x].left) print(tree[x].left);
    printf("%d %d %d %d %d %d %d\n",tree[x].l,tree[x].r,tree[x].max,tree[x].min,tree[x].ans,tree[x].ans1,tree[x].lazy);
    if (tree[x].right) print(tree[x].right);
}
void build(int &x,int l,int r){
    x=++cnt;tree[x].l=l;tree[x].r=r;
    if(l==r){
        tree[x].min=tree[x].max=w[l];
        tree[x].ans=tree[x].ans1=0;return;
    }
    int mid=l+r>>1;
    build(tree[x].left,l,mid);build(tree[x].right,mid+1,r);
    update(x);
}
inline node1 update1(node1 tmp1,node1 tmp2){
    node1 ans1;
    ans1.ans=max(tmp2.max-tmp1.min,max(tmp1.ans,tmp2.ans));
    ans1.ans1=max(tmp1.max-tmp2.min,max(tmp1.ans1,tmp2.ans1));
    ans1.min=min(tmp1.min,tmp2.min);
    ans1.max=max(tmp1.max,tmp2.max);
    return ans1;
}
void pushdown(int x){
    if (!tree[x].lazy) return;
    int l=tree[x].left,r=tree[x].right;
    int lazy=tree[x].lazy;
    tree[l].lazy+=lazy;tree[r].lazy+=lazy;
    tree[l].max+=lazy;tree[r].max+=lazy;
    tree[l].min+=lazy;tree[r].min+=lazy;
    tree[x].lazy=0;
}
node1 query(int rt,int l,int r,int v){
    if(l<=tree[rt].l&&r>=tree[rt].r){
        tree[rt].lazy+=v;tree[rt].max+=v;tree[rt].min+=v;
        node1 tmp;tmp.max=tree[rt].max;tmp.min=tree[rt].min;tmp.ans=tree[rt].ans;tmp.ans1=tree[rt].ans1;
        return tmp;
    }
    int mid=(tree[rt].l+tree[rt].r)>>1;
    node1 tmp1;node1 tmp2;pushdown(rt);
    if (l<=mid) tmp1=query(tree[rt].left,l,r,v);
    if (r>mid) tmp2=query(tree[rt].right,l,r,v);
    update(rt);
    return update1(tmp1,tmp2);
}
inline void swap(int &x,int &y){
    x^=y;y^=x;x^=y;
}
void solve(int x,int y,int v){
    node1 ansl,ansr;
    while (tp[x]!=tp[y]){
        if(dep[tp[x]]>dep[tp[y]]){
            ansl=update1(query(root,id[tp[x]],id[x],v),ansl);
            x=fa[tp[x]];
        }else{
            ansr=update1(query(root,id[tp[y]],id[y],v),ansr);
            y=fa[tp[y]];
        }
    }
    swap(ansl.ans,ansl.ans1);
    if (id[x]<id[y]){
        ansl=update1(ansl,query(root,id[x],id[y],v));
        ansl=update1(ansl,ansr);    
    }else{
        node1 tmpp=query(root,id[y],id[x],v);
        swap(tmpp.ans,tmpp.ans1);
        ansr=update1(tmpp,ansr);
        ansl=update1(ansl,ansr);
    }    
    printf("%d\n",ansl.ans);
//    printf("sdfsdf\n");
    //print(root);
}
int main(){
    //freopen("bzoj3999.in","r",stdin);
//    freopen("bzoj3999.out","w",stdout);
    n=read();
    for (int i=1;i<=n;++i) a[i]=read();
    for (int i=1;i<n;++i){
        int x=read(),y=read();
        data[++num].y=y;data[num].next=h[x];h[x]=num;
        data[++num].y=x;data[num].next=h[y];h[y]=num;
    }dep[1]=1;
    dfs1(1);dfs2(1,1);
    //for (int i=1;i<=n;++i) printf("%d ",id[i]);printf("\n");
    build(root,1,n);//print(root);
    m=read();
    for (int i=1;i<=m;++i){
        int x=read(),y=read(),z=read();
        solve(x,y,z);
    }
    return 0;
}