POJ 3237.Tree -树链剖分(边权)(边值更新、路径边权最值、区间标记)贴个板子备忘

Tree

Time Limit: 5000MS		Memory Limit: 131072K
Total Submissions: 12247		Accepted: 3151

Description

You are given a tree with N nodes. The tree’s nodes are numbered 1 through N and its edges are numbered 1 through N − 1. Each edge is associated with a weight. Then you are to execute a series of instructions on the tree. The instructions can be one of the following forms:

CHANGE i v	Change the weight of the ith edge to v
NEGATE a b	Negate the weight of every edge on the path from a to b
QUERY a b	Find the maximum weight of edges on the path from a to b

Input

The input contains multiple test cases. The first line of input contains an integer t (t ≤ 20), the number of test cases. Then follow the test cases.

Each test case is preceded by an empty line. The first nonempty line of its contains N (N ≤ 10,000). The next N − 1 lines each contains three integers a, b and c, describing an edge connecting nodes a and b with weight c. The edges are numbered in the order they appear in the input. Below them are the instructions, each sticking to the specification above. A lines with the word “DONE” ends the test case.

Output

For each “QUERY” instruction, output the result on a separate line.

Sample Input

1

3
1 2 1
2 3 2
QUERY 1 2
CHANGE 1 3
QUERY 1 2
DONE

Sample Output

1
3

Source

POJ Monthly--2007.06.03, Lei, Tao

 

 

 

题意就是： 有T组数据 ，给你n个点的树，有三种操作：

 1.CHANGE i v :将第i条边的值改为v   

 2.NEGATE a b :将a点到b点路径上的边权取反      

3.QUERY a b :查询a点到b点路径上最大的边权值，

由于有取反操作，记录最大和最小值 然后取反并交换就可以，用线段树来维护，真香警告。。。

代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<bitset>
#include<cassert>
#include<cctype>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<deque>
#include<iomanip>
#include<list>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<vector>
using namespace std;
typedef long long ll;

const double PI=acos(-1.0);
const double eps=1e-6;
const ll mod=1e9+7;
const int inf=0x3f3f3f3f;
const int maxn=1e4+10;
const int maxm=100+10;
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

int head[maxn],cnt,num,n;

struct Edge{
    int to,next;
}edge[maxn<<1];

void add(int u,int v)//存图(树)
{
    edge[cnt].to=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}

int val[maxn],siz[maxn],dep[maxn],son[maxn];
int top[maxn],tid[maxn],pos[maxn],fa[maxn];

void init()//初始化
{
    memset(head,-1,sizeof(head));
    memset(son,-1,sizeof(son));
    cnt=num=0;
}

///树链剖分部分
void dfs1(int u,int father)//第一遍dfs，可以得到当前节点的父亲节点，当前节点的深度，当前节点的重儿子
{
    //更新dep，fa，siz数组
    siz[u]=1;//保存以u为根的子树节点个数
    fa[u]=father;//保存爸爸
    dep[u]=dep[father]+1;//记录深度
    for(int i=head[u];~i;i=edge[i].next){//遍历所有和当前节点连接的节点
        int v=edge[i].to;
        if(v!=father){//如果连接的是当前节点的父亲节点，则不处理
            dfs1(v,u);
            siz[u]+=siz[v];//直接子树节点相加，当前节点的size加上子节点的size
            if(son[u]==-1||siz[v]>siz[son[u]])//如果没有设置过重节点son或者子节点v的size大于之前记录的重节点son，进行更新
                son[u]=v;//保存重儿子
        }
    }
}

void dfs2(int u,int tp)//将各个重节点连接成重链，轻节点连接成轻链，并且将重链(区间)用数据结构(一般是树状数组或者线段树)来维护，并且为每个节点进行编号，其实就是dfs在执行时的顺序(tid数组)，以及当前节点所在链的起点(top数组)还有当前节点在树中的位置(pos)                                                                                                                                                                                                                                                                                                                                                          )
{
    top[u]=tp;//保存当前节点所在的链的顶端节点，当前节点的起点
    tid[u]=++num;//保存树中每个节点剖分以后的新编号(dfs的执行顺序)
    pos[tid[u]]=u;//保存当前节点在树中的位置，设置dfs序号对应成当前节点
    if(son[u]==-1) return ;//如果当前节点没有处在重链上，则不处理
    dfs2(son[u],tp);//将这条重链上的所有节点都设置成起始的重节点
    for(int i=head[u];~i;i=edge[i].next){//遍历所有和当前节点连接的节点
        int v=edge[i].to;//如果连接节点不是当前节点的重节点并且也不是u的父节点，则将其的top设置成自己，进一步递归
        if(v!=son[u]&&v!=fa[u])
            dfs2(v,v);
    }
}

int lazy[maxn<<2],Max[maxn<<2],Min[maxn<<2];

//线段树部分
void Swap(int &x,int &y){int t=x;x=-y;y=-t;}

void pushup(int rt)
{
    Max[rt]=max(Max[rt<<1],Max[rt<<1|1]);
    Min[rt]=min(Min[rt<<1],Min[rt<<1|1]);
}

void pushdown(int rt)
{
    if(lazy[rt]){
        lazy[rt<<1]+=lazy[rt];
        lazy[rt<<1|1]+=lazy[rt];
        if(lazy[rt]&1){ //两个子区间是否取反依靠当前区间的懒惰标记判断,判断奇偶
            Swap(Max[rt<<1],Min[rt<<1]);
            Swap(Max[rt<<1|1],Min[rt<<1|1]);
        }
        lazy[rt]=0;
    }
}

void build(int l,int r,int rt)
{
    lazy[rt]=0;
    if(l==r){
        Max[rt]=Min[rt]=0;
        return ;
    }

    int m=(l+r)>>1;
    build(lson);
    build(rson);
    pushup(rt);
}

void update(int pos,int val,int l,int r,int rt)
{
    if(l==r&&l==pos){
        Max[rt]=val;Min[rt]=val;lazy[rt]=0;
        return ;
    }

    pushdown(rt);
    int m=(l+r)>>1;
    if(pos<=m) update(pos,val,lson);
    else       update(pos,val,rson);
    pushup(rt);
}

void Negate(int L,int R,int l,int r,int rt)//Negate是int tmp=Max,Max=-Min,Min=-tmp
{
    if(L<=l&&r<=R){
        lazy[rt]++;
        Swap(Max[rt],Min[rt]);//这里要马上取反
        return ;
    }

    pushdown(rt);
    int m=(l+r)>>1;
    if(L<=m) Negate(L,R,lson);
    if(R> m) Negate(L,R,rson);
    pushup(rt);
}

int query(int L,int R,int l,int r,int rt)
{
    if(L<=l&&r<=R){
        return Max[rt];
    }

    pushdown(rt);
    int ret=-inf;
    int m=(l+r)>>1;
    if(L<=m) ret=max(ret,query(L,R,lson));
    if(R> m) ret=max(ret,query(L,R,rson));
    pushup(rt);
    return ret;
}

int get_max(int u,int v)
{
    int ans=-1<<30;
    while(top[u]!=top[v]){
        if(dep[top[u]]<dep[top[v]]) swap(u,v);
        ans=max(ans,query(tid[top[u]],tid[u],1,n,1));
        u=fa[top[u]];
    }

    if(dep[v]<dep[u]) swap(u,v);
    ans=max(ans,query(tid[son[u]],tid[v],1,n,1));//这里写捞了，tid[son[u]],写成tid[u],wa了好几天。。。
    printf("%d
",ans);
}

void change(int u,int v)
{
    while(top[u]!=top[v]){
        if(dep[top[u]]<dep[top[v]]) swap(u,v);
        Negate(tid[top[u]],tid[u],1,n,1);
        u=fa[top[u]];
    }

    if(u==v) return ;
    if(dep[v]<dep[u]) swap(u,v);
    Negate(tid[son[u]],tid[v],1,n,1);
}

struct eg{
    int u,v,val;
}eg[maxn];

int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        init();
        for(int i=1;i<n;i++){
            scanf("%d%d%d",&eg[i].u,&eg[i].v,&eg[i].val);
            add(eg[i].u,eg[i].v);//加边
            add(eg[i].v,eg[i].u);//加边
        }
        dfs1(1,0);//第一遍dfs
        dfs2(1,1);//第二遍dfs
        build(1,n,1);
        for(int i=1;i<n;i++){
            if(dep[eg[i].u]<dep[eg[i].v]) swap(eg[i].u,eg[i].v);
            update(tid[eg[i].u],eg[i].val,1,n,1);
        }
        int a,b;
        char op[10];
        while(scanf("%s",op)&&op[0]!='D'){
            scanf("%d%d",&a,&b);
            if(op[0]=='Q'){
                get_max(a,b);
            }
            if(op[0]=='C'){
                update(tid[eg[a].u],b,1,n,1);
            }
            if(op[0]=='N'){
                change(a,b);
            }
        }
    }
}

哈哈哈哈，加油加油。