题意：一棵树，每个结点有个初始的权值，点的权值代表在该点的鸡肉的价格。
对于一个询问X, Y, V。
找到X到Y的路径，可以选择在路径上一个点I买鸡肉，然后在点J卖掉，要求J必须在I之后访问。那么你就可以赚取差价，问最大差价是多少。然后这条路径上的点的权值全部增加V。
这么裸的树链剖分，我特么T到比赛结束有木有啊！！！！
结束了再看看代码发现有个地方木有赋值，赋了值就AC了有木有啊！！！！
深呼吸。。。冷静。。。
这道题，首先考虑一条链的版本，我们用线段树来维护，先从区间合并来考虑。
对于当前结点，那么结点的最优值肯定来自于左孩子和右孩子的最优值，以及区间合并的最优值。
区间合并的时候，我们肯定是在左孩子的区间买，在右孩子的区间卖，最大差值肯定是右孩子的最大值-左孩子的最小值。
区间合并搞定了。更新操作也很容易，加个懒惰标记，由于区间内全部加上V值，对于区间内的差价是没有影响的，所以直接累加到标记上就可以。
那么来到这题，变成多条链的合并。我们会发现，如果是从X到Y的方向，求解方法同上。但是如果我们是Y到X的方向，我们应该反过来，即最大差值=左孩子的最大值-右孩子的最小值。
是不是跟HDU4718很像？
所以线段树的结点定义是这样嘀：
struct TreeNode{
int l, r;//左右边界
int Max;//区间里的最大权值
int Min;//区间里的最小权值
int inc;//区间里右边减去左边的最大差值
int des;//区间里左边减去右边的最大差值
int lazy;//懒惰标记
int lch, rch;//左右孩子
};
另外，对于询问，由于询问跟更新的区间是一样的，可以在查询的结束的时候，顺便把该区间更新了。
区间合并的代码，cur, lchd, rchd的定义可参考完整代码里面的宏定义：
void maintain(int o){
cur.Max = max(lchd.Max, rchd.Max);
cur.Min = min(lchd.Min, rchd.Min);
cur.inc = max(rchd.Max-lchd.Min, max(lchd.inc, rchd.inc));
cur.des = max(lchd.Max-rchd.Min, max(lchd.des, rchd.des));
}#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
#define lson tr[o].lch
#define rson tr[o].rch
#define lchd tr[tr[o].lch]
#define rchd tr[tr[o].rch]
#define cur tr[o]
#define pb push_back
const int N = 50010;
vector<int> V[N];
vector<int> G[N];
int T, n, q, path_cnt, node_cnt;
int father[N];
int belong[N];
int top[N];
int size[N];
int rank[N];
int path_size[N];
int path_top[N];
int path_dep[N];
int weight[N];
int tree[N];
struct TreeNode{
int l, r, Max, Min, inc, des, lazy;
int lch, rch;
};
TreeNode tr[N*10];
void dfs(int x, int fa, int dep){
int M = 0;
int key = -1;
size[x] = 1;
for(int i=0; i<G[x].size(); i++){
int j = G[x][i];
if(j==fa) continue;
father[j] = x;
dfs(j, x, dep+1);
size[x] += size[j];
if(size[j]>M){
M = size[j];
key = j;
}
}
belong[x] = 0;
for(int i=0; i<G[x].size(); i++){
int j = G[x][i];
if(j==fa) continue;
if(j==key){
belong[x] = belong[j];
rank[x] = rank[j]+1;
}
else{
int v = belong[j];
path_size[v] = rank[j];
path_top[v] = j;
path_dep[v] = dep;
}
}
if(belong[x]==0){
belong[x] = ++path_cnt;
rank[x] = 1;
V[path_cnt].clear();
}
V[belong[x]].pb(x);
}
void maintain(int o){
cur.Max = max(lchd.Max, rchd.Max);
cur.Min = min(lchd.Min, rchd.Min);
cur.inc = max(rchd.Max-lchd.Min, max(lchd.inc, rchd.inc));
cur.des = max(lchd.Max-rchd.Min, max(lchd.des, rchd.des));
}
void update(int o, int ll, int rr, int v);
void pushdown(int o){
if(cur.lazy){
int m = (cur.l+cur.r)>>1;
update(lson, cur.l, m, cur.lazy);
update(rson, m+1, cur.r, cur.lazy);
cur.lazy = 0;
}
}
void build(int path, int o, int ll, int rr){
cur.l=ll; cur.r=rr;
cur.lazy = 0;
if(ll<rr){
int m = (ll+rr)>>1;
lson = ++node_cnt;
build(path, lson, ll, m);
rson = ++node_cnt;
build(path, rson, m+1, rr);
maintain(o);
}
else{
cur.Max = cur.Min = weight[V[path][ll-1]];
cur.inc = cur.des = 0;
}
}
inline int Merge(int &Max, int &Min, int &Max1, int &Min1, bool f){
int res = f?(Max-Min1):(Max1-Min);
if(Max1>Max) Max = Max1;
if(Min1<Min) Min = Min1;
return res;
}
void update(int o, int ll, int rr, int v){
if(cur.l==ll && cur.r==rr){
cur.Max += v;
cur.Min += v;
cur.lazy += v;
return;
}
int m = (cur.l+cur.r)>>1;
pushdown(o);
int res, Max1, Min1;
if(rr<=m) update(lson, ll, rr, v);
else if(ll>m) update(rson, ll, rr, v);
else{
update(lson, ll, m, v);
update(rson, m+1, rr, v);
}
maintain(o);
}
int query(int o, int ll, int rr, int v, bool f, int &Max, int &Min){
if(cur.l==ll && cur.r==rr){
Max = cur.Max;
Min = cur.Min;
cur.Max += v;
cur.Min += v;
cur.lazy += v;
return f?cur.des:cur.inc;
}
int m = (cur.l+cur.r)>>1;
pushdown(o);
int res, Max1, Min1;
if(rr<=m){
res = query(lson, ll, rr, v, f, Max, Min);
}
else if(ll>m){
res = query(rson, ll, rr, v, f, Max, Min);
}
else{
int v1 = query(lson, ll, m, v, f, Max, Min);
int v2 = query(rson, m+1, rr, v, f, Max1, Min1);
int v3 = Merge(Max, Min, Max1, Min1, f);
res = v1>v2?v1:v2;
if(v3>res) res = v3;
}
maintain(o);
return res;
}
void init(){
path_cnt = node_cnt = 0;
dfs(1, 0, 1);
father[1] = 0;
path_dep[belong[1]] = 0;//这句话忘写就不能AC呀！！！！
path_size[belong[1]] = rank[1];
for(int i=1; i<=path_cnt; i++){
tree[i] = ++node_cnt;
build(i, tree[i], 1, path_size[i]);
}
}
int Q(int a, int b, int c){
int x = belong[a];
int y = belong[b];
bool mk1=0, mk2=0;
int Max1, Max2, Min1, Min2, Max, Min;
int ans = 0, tmp;
while(x!=y){
if(path_dep[x]>path_dep[y]){
tmp = query(tree[x], rank[a], path_size[x], c, 0, Max, Min);
if(tmp>ans) ans = tmp;
if(mk1){
tmp = Merge(Max1, Min1, Max, Min, 0);
if(tmp>ans) ans = tmp;
}
else{
Max1 = Max;
Min1 = Min;
mk1 = 1;
}
a = father[path_top[x]];
x = belong[a];
}
else{
tmp = query(tree[y], rank[b], path_size[y], c, 1, Max, Min);
if(tmp>ans) ans = tmp;
if(mk2){
tmp = Merge(Max2, Min2, Max, Min, 1);
if(tmp>ans) ans = tmp;
}
else{
Max2 = Max;
Min2 = Min;
mk2 = 1;
}
b = father[path_top[y]];
y = belong[b];
}
}
if(rank[a]>rank[b]){
tmp = query(tree[x], rank[b], rank[a], c, 1, Max, Min);
}
else{
tmp = query(tree[x], rank[a], rank[b], c, 0, Max, Min);
}
if(tmp>ans) ans = tmp;
if(mk1){
tmp = Merge(Max1, Min1, Max, Min, 0);
if(tmp>ans) ans = tmp;
}
else{
Max1 = Max;
Min1 = Min;
}
//printf("%d %d %d %d\n", Max1, Min1, Max2, Min2);
if(mk2){
tmp = Merge(Max1, Min1, Max2, Min2, 0);
if(tmp>ans) ans = tmp;
}
return ans;
}
int main(){
//freopen("K.txt", "r", stdin);
int size = 32 << 20;
char *p = (char*)malloc(size) + size;
__asm__("movl %0, %%esp\n" :: "r"(p));
scanf("%d", &T);
for(int t=1; t<=T; t++){
scanf("%d", &n);
for(int i=1; i<=n; i++){
G[i].clear();
scanf("%d", weight+i);
}
int a, b, c;
for(int i=1; i<n; i++){
scanf("%d %d", &a, &b);
G[a].pb(b);
G[b].pb(a);
}
init();
scanf("%d", &q);
while(q--){
scanf("%d %d %d", &a, &b, &c);
printf("%d\n", Q(a, b, c));
}
}
return 0;
}
191
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
