hdu 5052 Yaoge’s maximum profit

最新推荐文章于 2018-08-31 15:49:28 发布

程天天

最新推荐文章于 2018-08-31 15:49:28 发布

阅读量821

点赞数

文章标签：树链剖分

本文链接：https://blog.csdn.net/u014076176/article/details/39613439

版权

树链剖分专栏收录该内容

2 篇文章 0 订阅

订阅专栏

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5052

题目描述：输入一棵树，带点权，然后有一些询问， a b c，表示从a走到b，你可以在某个节点处买东西，花费为该点的点权，你在后面的点的位置可以卖出去，收益是该点的点权，询问你能获得的最大收益。然后将a 到 b，路径上的所有点加上权值c

解题思路：kuangbin大神题解是LCT，弱渣只会树链剖分，想想还是能做的。。。只是代码有点长。o s-h-i-t...

由于树的形态是不会改变的所以一开始就没有往LCT方面想。。。。（其实想到也做不出来。。。都是泪。。。）

然后线段树维护，区间的最大值max_val，最小值min_val，从左往右的最大收益down，从右往左的最大收益up，然后就是套一个树链剖分的模板，搞一搞，就可以了

代码实在有点长，建议先想好了再敲键盘。。。不然，只能悲剧。。。

//#pragma comment(linker,"/STACK:102400000,102400000")
#include<stdio.h>
#include<iostream>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<string>
#define ll long long
#define db double
#define PB push_back
#define lson k<<1
#define rson k<<1|1
using namespace std;

const int N = 100005;
const int INF = 1000000000;
const int M = N << 1;

int num, head[N], to[M], next[M], nedge;

void init()
{
    memset(head, -1, sizeof(head));
    nedge = 0, num = 0;
}

void add(int a, int b)
{
    to[nedge] = b, next[nedge] = head[a], head[a] = nedge++;
}

int son[N], tol[N], dep[N], fa[N];
void get_son_dep(int k, int dp)
{
    tol[k] = 1, son[k] = 0, dep[k] = dp;
    for(int i = head[k]; i >= 0; i = next[i])
    {
        if(to[i] != fa[k])
        {
            fa[to[i]] = k;
            get_son_dep(to[i], dp + 1);
            tol[k] += tol[to[i]];
            if(tol[to[i]] > tol[son[k]]) son[k] = to[i];
        }
    }
}

int w[N], top[N];
void build(int k, int rt)
{
    w[k] = ++num, top[k] = rt;
    if(son[k] != 0) build(son[k], rt);
    for(int i = head[k]; i >= 0; i = next[i])
    {
        if(to[i] != fa[k] && to[i] != son[k])
        {
            build(to[i], to[i]);
        }
    }
}

struct node
{
    int l, r;
    int max_val, min_val, up, down, lz;
} tr[N << 2];

void push_up(int k)
{
    tr[k].max_val = max(tr[lson].max_val, tr[rson].max_val);
    tr[k].min_val = min(tr[lson].min_val, tr[rson].min_val);
    tr[k].down = max(tr[rson].max_val - tr[lson].min_val, max(tr[lson].down, tr[rson].down));
    tr[k].up=max(tr[lson].max_val-tr[rson].min_val,max(tr[lson].up,tr[rson].up));
}

int pt[N];
int v[N];
void build_tr(int k, int l, int r)
{
    tr[k].l = l, tr[k].r = r;
    tr[k].lz = 0;
    if(l < r)
    {
        int mid = (l + r) >> 1;
        build_tr(lson, l, mid);
        build_tr(rson, mid + 1, r);
        push_up(k);
    }
    else tr[k].max_val = tr[k].min_val = v[pt[l]], tr[k].up=tr[k].down = 0;
}

void push_down(int k)
{
    if(tr[k].lz)
    {
        tr[lson].lz += tr[k].lz, tr[rson].lz += tr[k].lz;
        tr[lson].max_val += tr[k].lz, tr[rson].max_val += tr[k].lz;
        tr[lson].min_val += tr[k].lz, tr[rson].min_val += tr[k].lz;
        tr[k].lz = 0;
    }
}

void add(int k,int l,int r,int val)
{
    if(tr[k].l==l&&tr[k].r==r)
    {
        tr[k].lz+=val;
        tr[k].max_val+=val;
        tr[k].min_val+=val;
        return;
    }
    push_down(k);
    int mid=(tr[k].l+tr[k].r)>>1;
    if(r<=mid) add(lson,l,r,val);
    else if(l>mid) add(rson,l,r,val);
    else add(lson,l,mid,val),add(rson,mid+1,r,val);
    push_up(k);
}

int maxval,minval,pfct;   //-INF INF 0
pair<int,int> query(int k,int l,int r,bool fl)
{
    if(tr[k].l==l&&tr[k].r==r)
    {
        maxval=max(maxval,tr[k].max_val);
        minval=min(minval,tr[k].min_val);
        if(fl) pfct=max(pfct,tr[k].up);
        else pfct=max(pfct,tr[k].down);
        return make_pair(tr[k].max_val,tr[k].min_val);
    }
    push_down(k);
    int mid=(tr[k].l+tr[k].r)>>1;
    if(r<=mid) return query(lson,l,r,fl);
    else if(l>mid) return query(rson,l,r,fl);
    else
    {
        pair<int,int> t1=query(lson,l,mid,fl);
        pair<int,int> t2=query(rson,mid+1,r,fl);
        if(fl) pfct=max(pfct,t1.first-t2.second);
        else pfct=max(pfct,t2.first-t1.second);
        return make_pair(max(t1.first,t2.first),min(t1.second,t2.second));
    }
}

struct P
{
    int max_val, min_val, pfct, id;
    bool operator < (const P &t) const
    {
        return id < t.id;
    }
} seq[1000];
int mval[1000];
int lseq;
int find_ans(int a, int b, int val)
{
    lseq = 0;
    int tpa = top[a], tpb = top[b];
    int la = 0, lb = INF;
    while(tpa != tpb)
    {
        maxval = -INF, minval = INF, pfct = 0;
        if(dep[tpa] < dep[tpb])
        {
            query(1, w[tpb], w[b],false);
            add(1, w[tpb], w[b], val);
            b = fa[tpb], tpb = top[b];
            seq[lseq].id = lb--;
        }
        else
        {
            query(1, w[tpa], w[a],true);
            add(1, w[tpa], w[a], val);
            a = fa[tpa], tpa = top[a];
            seq[lseq].id = la++;
        }
        seq[lseq].max_val = maxval, seq[lseq].min_val = minval, seq[lseq].pfct = pfct;
        lseq++;
    }
//    if(a!=b){
        maxval = -INF, minval = INF, pfct = 0;
        if(dep[a] < dep[b])
        {
            query(1, w[a], w[b],false);  //
            add(1, w[a], w[b], val);  //
            b = fa[tpb], tpb = top[b];
            seq[lseq].id = lb--;
        }
        else
        {
            query(1, w[b], w[a],true);  //
            add(1, w[b], w[a], val);  //
            a = fa[tpa], tpa = top[a];
            seq[lseq].id = la++;
        }
        seq[lseq].max_val = maxval, seq[lseq].min_val = minval, seq[lseq].pfct = pfct;
        lseq++;
//    }
    sort(seq,seq+lseq);
//    for(int i=0;i<lseq;i++) printf("%d %d\n",seq[i].max_val,seq[i].min_val);
    int res=0;
    mval[lseq]=0;
    for(int i=lseq-1;i>=0;i--)
    {
        mval[i]=max(mval[i+1],seq[i].max_val);
        res=max(res,seq[i].pfct);
    }
    int mival=INF;
    for(int i=0;i<lseq-1;i++)
    {
        mival=min(mival,seq[i].min_val);
        res=max(res,mval[i+1]-mival);
    }
    return res;
}

void getint(int &x)
{
    char c = getchar();
    bool sg = false;
    while(!(c >= '0' && c <= '9' || c == '-')) c = getchar();
    if(c == '-') sg = true;
    x = c - '0';
    while((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
    sg&&(x = -x);
}

int main()
{
#ifdef PKWV
    freopen("in.in", "r", stdin);
#endif // PKWV
    int T, cas = 1;
    getint(T);
    while(T--)
    {
        int n;
        getint(n);
        for(int i=1;i<=n;i++) getint(v[i]);
        init();
        for(int i=1;i<n;i++)
        {
            int a,b;
            getint(a),getint(b);
            add(a,b),add(b,a);
        }
        int rt=n/2+1;
        fa[rt]=0;
        get_son_dep(rt,0);
        build(rt,rt);
        for(int i=1;i<=n;i++) pt[w[i]]=i;
        build_tr(1,1,num);
        int Q;
        scanf("%d",&Q);
        while(Q--)
        {
            int a,b,c;
            getint(a),getint(b),getint(c);
            printf("%d\n",find_ans(a,b,c));
        }
    }
    return 0;
}