【BZOJ2814】tree

最新推荐文章于 2019-05-13 21:39:50 发布
最新推荐文章于 2019-05-13 21:39:50 发布
阅读量967 收藏
点赞数 1
分类专栏： 随便搞搞 丧心病狂 文章标签： LCT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CreationAugust/article/details/50667406
版权

Description

给出一棵N 个点的树，每个点有两层，每层有权值和颜色（黑白） 。要求支持以下操作。
1. Cover s t color 将s到t的路径上的点的两层的颜色全部置为 color(0 白1 黑)
2. CVal index layer val 将index号点的 layer 层的权值修改为 val
3. CColor index layer color 将 index号点的 layer 层的颜色修改为 color
4. QMax s t 询问s到 t的路径上的白色最大权值和路径的权值（任意白色层为起点，每次只能往相同点不同层或者相邻点同一层上移动，每个点的每一层最多走一次，路径经过的层必须都是白色） ，若 s到 t上的路径没有白点则输出[Bad Request.]
5. QLen s t 询问s到t的路径上的白色最大权值和路径的长度，若 s到 t的路径上没有白点则输出 0
初始树上权值均为 1，颜色均为白色。
N<=5W,Q<=5W,1<=val<=1K,0<=color,layer<=1 所有数据不超过longint范围。 .
对于40%的分数，没有 1，5 号操作，N,Q <= 1K
对于80%的分数，没有 5号操作
Input

第一行一个数 N，接下来N*2-2 个数 s，t，代表 s与t之间有连边。第N+1行一个数 Q，
表示操作数。接下来Q 行每行一个操作。
Output

对于每次 QMax，QLen输出对应答案，用换行符分隔。
Sample Input

6

1 2 2 4 2 5 1 3 3 6

7

CVal 1 0 5

CVal 1 1 3

CColor 1 0 1

CVal 2 0 5

CVal 3 0 3

QMax 5 6

QLen 5 6

Sample Output

17

9
HINT

Source

人生成就,写过最长的码农题
半天写代码,半天调代码
LCT大法好啊,比链剖看着美观多了QwQ

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define MAXN 50010
#define GET (ch >= '0' && ch <= '9')
#define MAXINT 0x3f3f3f3f
using namespace std;
int n,m;
int sta[MAXN],top;
char ch[8];
inline void in(int &x)
{
    char ch = getchar() ; x = 0;
    while (!GET)    ch = getchar();
    while (GET) x = x * 10 + ch - '0' , ch = getchar();
}





//节点颜色 1为白色 0为黑色 





//Data Transmit 
inline void update(int &a,int &b,int c,int d)
{
    if (a < c)  a = c , b = d;
    else    if (a == c && b < d)    b = d;
}





//Define Information Node 
struct treenode
{
    int len1[2][2],len2[2][2];  
    int val1[2][2],val2[2][2];
    int llen[2],rlen[2];
    int lval[2],rval[2];
    int minn[2][2];  
    int size,sum;
    int maxl,maxv;
    treenode()
    {
        for (int i = 0 ; i <= 1 ; i++)  lval[i] = rval[i] = llen[i] = rlen[i] = -MAXINT;
        maxl = maxv = -MAXINT , size = sum = 0;
        for (int i = 0 ; i <= 1 ; i++)  for (int j = 0 ; j <= 1 ; j++)
            len1[i][j] = len2[i][j] = val1[i][j] = val2[i][j] = -MAXINT,
            minn[i][j] = MAXINT;
    }
    //Node Union 
    inline friend treenode operator + (const treenode& a,const treenode& b)
    {
        treenode ret;
        for (int i = 0 ; i <= 1 ; i++)  for (int j = 0 ; j <= 1 ; j++)  //floyed 
        {
            for (int k = 0 ; k <= 1 ; k++)
                update(ret.val1[i][j] , ret.len1[i][j] , a.val1[i][k] + b.val1[k][j] , a.len1[i][k] + b.len1[k][j]),
                update(ret.val2[i][j] , ret.len2[i][j] , a.val2[i][k] + b.val2[k][j] , a.len2[i][k]+b.len2[k][j]),
                update(ret.lval[i] , ret.llen[i] , a.val1[i][k] + b.lval[k] , a.len1[i][k] + b.llen[k]),
                update(ret.rval[j] , ret.rlen[j] , a.rval[k] + b.val2[j][k] , a.rlen[k] + b.len2[k][j]),
                ret.minn[i][j] = min(ret.minn[i][j] , min(a.minn[i][k] , b.minn[k][j]));
            update(ret.lval[i] , ret.llen[i] , a.lval[i] , a.llen[i]);
            update(ret.rval[j] , ret.rlen[j] , b.rval[j] , b.rlen[j]);
        }
        update(ret.maxv , ret.maxl , a.maxv , a.maxl);
        update(ret.maxv , ret.maxl , b.maxv , b.maxl);
        for (int i = 0 ; i <= 1 ; i++)  update(ret.maxv , ret.maxl , a.rval[i] + b.lval[i] , a.rlen[i] + b.llen[i]);
        ret.size = a.size + b.size ; ret.sum = a.sum + b.sum;
        return ret;
    }
};





//Define LCT 
struct splay
{
    int ch[2],fa,val[2];
    bool flag,cov,col[2];
    treenode w;
}tree[MAXN];





//Get Node 
inline treenode findnode(int x)
{
    treenode ret ; ret.size = 2 ; ret.sum = tree[x].val[0] + tree[x].val[1];
    for (int i = 0 ; i <= 1 ; i++)  for (int j = 0 ; j <= 1 ; j++)  
    {
        ret.minn[i][j] = min(tree[x].val[i] , tree[x].val[j]);
        if (tree[x].col[i] && tree[x].col[j])
        {
            ret.len1[i][j] = ret.len2[i][j] = (i == j ? 1 : 2),
            ret.val1[i][j] = ret.val2[i][j] = (i == j ? tree[x].val[i] : tree[x].val[i] + tree[x].val[j]);
            update(ret.maxv , ret.maxl , ret.val1[i][j] , ret.len1[i][j]),
            update(ret.lval[i] , ret.llen[i] , ret.val1[i][j] , ret.len1[i][j]),
            update(ret.rval[j] , ret.rlen[j] , ret.val2[i][j] , ret.len2[i][j]);
        }
    }
    return ret;
}





//Information Update 
inline void push_up(int x)
{
    if (!x) return;
    tree[x].w = findnode(x);
    if (tree[x].ch[0])  tree[x].w = tree[tree[x].ch[0]].w + tree[x].w;
    if (tree[x].ch[1])  tree[x].w = tree[x].w + tree[tree[x].ch[1]].w;
}
inline void Cover(int x,bool col)
{
    treenode ret;
    tree[x].flag = 1 , tree[x].cov = col;
    tree[x].col[0] = tree[x].col[1] = col;
    if (col)
    {
        if ((tree[x].w.size >> 1) & 1)
        {
            for (int i = 0 ; i <= 1 ; i++)  for (int j = 0 ; j <= 1 ; j++)
                if (i != j)
                    ret.len1[i][j] = ret.len2[i][j] = tree[x].w.size,
                    ret.val1[i][j] = ret.val2[i][j] = tree[x].w.sum;
                else
                    ret.len1[i][j] = ret.len2[i][j] = tree[x].w.size - 1,
                    ret.val1[i][j] = ret.val2[i][j] = tree[x].w.sum - tree[x].w.minn[i][j];
        }
        else
        {
            for (int i = 0 ; i <= 1 ; i++)  for (int j = 0 ; j <= 1 ; j++)
                if (i == j)
                    ret.len1[i][j] = ret.len2[i][j] = tree[x].w.size,
                    ret.val1[i][j] = ret.val2[i][j] = tree[x].w.sum;
                else
                    ret.len1[i][j] = ret.len2[i][j] = tree[x].w.size - 1,
                    ret.val1[i][j] = ret.val2[i][j] = tree[x].w.sum - tree[x].w.minn[i][j];

        }
        ret.maxl = tree[x].w.size ; ret.maxv = tree[x].w.sum;
        for (int i = 0 ; i <= 1 ;i++)
            ret.llen[i] = ret.rlen[i] = tree[x].w.size,
            ret.lval[i] = ret.rval[i] = tree[x].w.sum;
    }
    ret.size = tree[x].w.size ; ret.sum = tree[x].w.sum;
    for (int i = 0 ; i <= 1 ; i++)  for (int j = 0 ; j <= 1 ; j++)  ret.minn[i][j] = tree[x].w.minn[i][j];
    tree[x].w = ret;
}
inline void push_down(int x)
{
    if (!x) return;
    if (tree[x].flag)
    {
        if (tree[x].ch[0])  Cover(tree[x].ch[0] , tree[x].cov);
        if (tree[x].ch[1])  Cover(tree[x].ch[1] , tree[x].cov);
        tree[x].flag = 0 ; tree[x].cov = 0;
    }
}





//LCT Operation 
inline bool is_root(int x)  {   return tree[tree[x].fa].ch[0] != x && tree[tree[x].fa].ch[1] != x;  }
inline void rot(int x)
{
    int y = tree[x].fa,z = tree[y].fa,l,r;
    l = (tree[y].ch[1] == x) ; r = l ^ 1;
    if (!is_root(y))    tree[z].ch[tree[z].ch[1] == y] = x;
    tree[x].fa = z;tree[y].fa = x ; tree[tree[x].ch[r]].fa = y;
    tree[y].ch[l] = tree[x].ch[r] ; tree[x].ch[r] = y;
    push_up(y) ; push_up(x);
}
inline void Splay(int x)
{
    sta[++top] = x;
    for (int i = x ; !is_root(i) ; i = tree[i].fa)  sta[++top] = tree[i].fa;
    while (top) push_down(sta[top--]);
    while (!is_root(x))
    {
        int y = tree[x].fa , z = tree[y].fa;
        if (!is_root(y))
        {
            if ((tree[z].ch[0] == y) ^ (tree[y].ch[0] == x))    rot(x);
            else    rot(y);
        }
        rot(x);
    }
}
inline void access(int x)   {   for (int i = 0 ; x ; i = x , x = tree[x].fa)    Splay(x) , tree[x].ch[1] = i , push_up(x);  }





//Paint Color (Operation No.1)
inline void Set_color(int s,int t,bool col)
{
    access(s);
    for (int x = t , i = 0 ; x ; i = x , x = tree[x].fa)
    {
        Splay(x);
        if (!tree[x].fa)
        {
            tree[x].col[0] = tree[x].col[1] = col;
            if (tree[x].ch[1])  Cover(tree[x].ch[1] , col);
            if (i)  Cover(i , col);
        }
        tree[x].ch[1] = i ; push_up(x);
    }
}






//Node Modify (Operation No.2/3)  
inline void modify_val(int x,int y,int z)   {   Splay(x) ; tree[x].val[y] = z ; push_up(x); }
inline void modify_col(int x,int y,bool z)  {   Splay(x) ; tree[x].col[y] = z ; push_up(x); }






//Query (Operation 4/5) 
inline treenode query(int s,int t)
{
    access(s);
    for (int x = t , i = 0 ; x ; i = x , x = tree[x].fa)
    {
        Splay(x);
        if (!tree[x].fa)
        {
            treenode ret = findnode(x);
            if (tree[x].ch[1])
            {
                treenode tmp = tree[tree[x].ch[1]].w;
                for (int i = 0 ; i <= 1 ; i++)  for (int j = 0 ; j <= 1 ; j++)
                    swap(tmp.len1[i][j] , tmp.len2[i][j]),
                    swap(tmp.val1[i][j] , tmp.val2[i][j]);
                for (int i = 0 ; i <= 1 ; i++)  swap(tmp.llen[i] , tmp.rlen[i]) , swap(tmp.lval[i] , tmp.rval[i]);
                ret = tmp + ret;
            }
            if (i)  ret = ret + tree[i].w;
            return ret;
        }
        tree[x].ch[1] = i ; push_up(x);
    }
}





//initialization  
inline void init()
{
    for (int i = 1 ; i <= n ; i++)
    {
        for (int j = 0 ; j <= 1 ; j++)  tree[i].val[j] = tree[i].col[j] = 1;
        tree[i].w = findnode(i);
    }
}





//DFS build Tree 
int Top;
struct edge
{
    int to;
    edge *next;
}e[MAXN<<1],*prev[MAXN];
void insert(int u,int v)    {   e[++Top].to = v ; e[Top].next = prev[u] ; prev[u] = &e[Top];    }
void dfs(int x,int f)
{
    tree[x].fa = f;
    for (edge *i = prev[x] ; i ; i = i->next)
        if (i->to != f) 
        {
            if (!tree[x].ch[1]) tree[x].ch[1] = i->to;
            dfs(i->to , x);
        }
}





//debug
void printnode(treenode x)
{
    for (int i = 0 ; i <= 1 ; i++)  for (int j = 0 ; j <= 1 ; j++)  printf("%d ",x.val1[i][j]);
    for (int i = 0 ; i <= 1 ; i++)  for (int j = 0 ; j <= 1 ; j++)  printf("%d ",x.val2[i][j]);
    printf("\n");
    for (int i = 0 ; i <= 1 ; i++)  for (int j = 0 ; j <= 1 ; j++)  printf("%d ",x.len1[i][j]);
    for (int i = 0 ; i <= 1 ; i++)  for (int j = 0 ; j <= 1 ; j++)  printf("%d ",x.len2[i][j]);
    printf("\n");
    for (int i = 0 ; i <= 1 ; i++)  printf("%d ",x.llen[i]);
    for (int i = 0 ; i <= 1 ; i++)  printf("%d ",x.rlen[i]);
    printf("\n");
    for (int i = 0 ; i <= 1 ; i++)  printf("%d ",x.lval[i]);
    for (int i = 0 ; i <= 1 ; i++)  printf("%d ",x.rval[i]);
    printf("\n");
    for (int i = 0 ; i <= 1 ; i++)  for (int j = 0 ; j <= 1 ; j++)  printf("%d ",x.minn[i][j]);
    printf("\n");
    printf("%d %d %d %d\n",x.size , x.sum , x.maxl , x.maxv);
}
void print(int x)
{
    printf("%d\n" , x);
    printf("%d %d %d %d %d %d %d %d %d\n" , tree[x].ch[0] , tree[x].ch[1] , tree[x].fa , tree[x].val[0] , tree[x].val[1] , tree[x].flag , tree[x].cov , tree[x].col[0] , tree[x].col[1]);
    printnode(tree[x].w);
}






int main()
{
    in(n) ; int u,v,w ; init() ;
    for (int i = 1 ; i < n ; i++)   in(u) , in(v) , insert(u , v) , insert(v , u);
    dfs(1 , 0);
    for (int i = 1 ; i <= n ; i++)  if (!tree[i].ch[1]) Splay(i);
    for (in(m) ; m ; m--)
    {
        scanf("%s",ch);
        if (ch[1] == 'o')   in(u) , in(v) , in(w) , Set_color(u , v , w ^ 1);
        if (ch[1] == 'V')   in(u) , in(v) , in(w) , modify_val(u , v , w);
        if (ch[1] == 'C')   in(u) , in(v) , in(w) , modify_col(u , v , w ^ 1);
        if (ch[1] == 'M')
        {
            in(u) , in(v) ; treenode ans = query(u , v);
            if (ans.maxv < 0)   puts("Bad Request.");
            else    printf("%d\n" , ans.maxv);
        }
        if (ch[1] == 'L')
        {
            in(u) , in(v) ; treenode ans = query(u , v);
            printf("%d\n" , max(ans.maxl , 0));
        }
    }
}
CreationAugust
关注
专栏目录
[鬼畜 树链剖分 线段树] BZOJ 2814 tree
雯舞
09-04 608
类似最大子段和去搞 可以把两头看成各有两个接口 然后随意维护十几个值搞搞搞 打了一中午 调了一晚上 发现看错题 改了改 调到睡觉 心累 #include #include #include #include using namespace std; typedef long long ll; inline char nc(){ static char buf[100000],*
BZOJ2631: tree link-cut-tree
zzzzzfy的博客
04-12 523
%lyh 一A 我脑残。。拍了半天 发现昨天脑子迷糊转错了。。 #include #include #include #include #define LL unsigned int using namespace std; const int N=110000,P=51061; int tr[N][2],fa[N],n,m, size[N],q[N],top,rev[N]; LL sum[N
BZOJ2654 Tree
ETO的博客
07-13 163
2654: treeTime Limit: 30 Sec  Memory Limit: 512 MBSubmit: 3077  Solved: 1293[Submit][Status][Discuss]Description给你一个无向带权连通图，每条边是黑色或白色。让你求一棵最小权的恰好有need条白色边的生成树。题目保证有解。Input第一行V,E,need分别表示点数，边数和需要的白色边数。...
bzoj2654 tree
Elijahqi
05-04 152
http://www.elijahqi.win/archives/1130 Description 给你一个无向带权连通图，每条边是黑色或白色。让你求一棵最小权的恰好有need条白色边的生成树。 题目保证有解。 Input 第一行V,E,need分别表示点数，边数和需要的白色边数。 接下来E行,每行s,t,c,col表示这边的端点(点从0开始标号)，边权，颜色(0白色1黑色)。 O...
[BZOJ2654] tree
slongle的专栏
02-22 812
传送门http://www.lydsy.com/JudgeOnline/problem.php?id=2654题目大意给定一些分为黑白两种的边,询问满足包含t条白边的最小生成树题解ORZ cls 如果我们想尽可能的多的白边我们要将白边权值加一个很大的负数 如果我们想尽可能的少的白边我们要将白边权值加一个很大的正数 这个是满足二分的性质的~ 所以二分加的权值求最小生成树 注意排序时权值相同白
bzoj2631 tree
AaronPolaris
07-04 1990
LCT模板题，然而写起来还是很爽
bzoj 5111 Tree
Demon_Rieman的博客
05-13 233
description 给一棵nnn个结点的树，每个结点有一个正整数权值。要求选出一个结点的集合，满足： 1.这个集合包含111号结点 2.这个集合在树上是一个连通块。 即，设这个集合为SSS，则树上存在∣S∣−1|S|-1∣S∣−1条边，这些边连接的结点都属于SSS。 记一个集合的权值为该集合内所有结点的权值和。 求权值第kkk小的集合的权值。 solution 明显二合一。那么我们现在有两个问...
bzoj1468 Tree*
anheku1562的博客
12-10 107
bzoj1468 Tree 题意： 给你一棵TREE,以及这棵树上边的距离.问有多少对点它们两者间的距离小于等于K 题解： 点分治：先建树，然后分两步 1、计算当前点所在子树中符合条件的点对 2、在当前点的子树中选一个点作为根节点，递归这些根结点 如何求当前点所在子树中符合条件的点对数呢？ 先通过dfs求出从当前节点到所在子树各节点的距离，然后用排序+两头计算...
BZOJ1468 - Tree
VisJiao的博客
01-18 273
点分治第一题
BZOJ 2654 tree 详解（最小生成树 kruskal 二分）
w4149
07-05 631
BZOJ 2654 treeDescription 　　给你一个无向带权连通图，每条边是黑色或白色。让你求一棵最小权的恰好有need条白色边的生成树。 　　题目保证有解。Input 　　第一行V,E,need分别表示点数，边数和需要的白色边数。 　　接下来E行 　　每行s,t,c,col表示这边的端点(点从0开始标号)，边权，颜色(0白色1黑色)。Output 　　一行表示所求生成树的边
bzoj 2631 Tree [Link-Cut Tree]
C'est la vie.
08-19 417
2631: treeTime Limit: 30 Sec Memory Limit: 128 MB Submit: 3569 Solved: 1191Description　一棵n个点的树，每个点的初始权值为1。对于这棵树有q个操作，每个操作为以下四种操作之一： + u v c：将u到v的路径上的点的权值都加上自然数c； - u1 v1 u2 v2：将树中原有的边(u1,v1)删除，加入一
算法学习之：动态树（link-cut-tree）及bzoj3282Tree例题详解
maxtir的博客
09-09 2603
算法学习之：动态树（link-cut-tree，下文简称lct） 前言： 经过大神对lct的各种狂吹之后，作为蒟蒻一只的我就来学习lct了，%了几份博客之后，大概明白了lct是怎么做。发现其实lct好像并没有想想中的那么难。当然lct的最低门槛是splay，其次当然就是树链剖分。当然理论上来说树链剖分不看的话lct其实可学，但是可能光是理解就要好久。所以想学lct的小伙伴们还是先去学学spla
BZOJ 1977 Tree 次小生成树 （kruskal st表 倍增lca）
w4149
07-10 428
1977: [BeiJing2010组队]次小生成树 TreeTime Limit: 10 Sec Memory Limit: 512 MB Submit: 3121 Solved: 791 [Submit][Status][Discuss] Description小 C 最近学了很多最小生成树的算法，Prim 算法、Kurskal 算法、消圈算法等等。 正当小 C 洋洋得意之时，小 P
BZOJ3754 Tree（最小方差生成树）
Michael_GLF的博客
02-16 278
传送门 【题目分析】 先说说自己在考场上YY出来的错误解法，但可以过后面几个数据密度大的点。 将所有边按权值存入各自的vector中，然后一个一个的枚举，因为要标准差最小所以边权要尽可能的集中所以记录两个指针，优先跳差值小的一边。 因为到最后边数上万，但边权小于等于100，所以可能一个集合就差不多能将整个图覆盖，所以靠着这个方法过了最后6个点。 然而这个很容易找反例，所以咕了。 观察标...
【高大上の连载】TA神犇的日常[弃坑,停更]
CreationAugust is 14 years old forever
05-25 7488
这是一本以日记为形式的文学作品,主要记载TA神犇的日常生活以及神犇语录. 我于2.15-5-25决定开始创作.本作品采用不定期更新的形式,欢迎随时随地来收看直播,更加欢迎来orzTA神犇,如: …………..&………………………….. ..****…&&………………………….. …..*…..&..&……+++…………………. …..*….&&&&.+……+…rrrrr….zzzz……..
【矩阵与行列式】矩阵和行列式学习笔记
CreationAugust is 14 years old forever
06-05 5448
开始从ToDoList里挑东西来杀. 感觉矩阵和行列式这两个跟很多东西都有关而且接触最少 所以先从它们开始补>w< P.S.看了很多资料,他们对矩阵和行列式这些东西的介绍都很丧病…我会尽量用通俗的语言来写我的笔记= =如果您不喜欢这种风格QAQ那我也没办法了请隔壁看别人的吧—————————线割分是我>w<——————————————–什么是矩阵?矩阵是n*m个数在n*m这个二维区域内的一个排
【北大先修课】计算概论(A)题库全代码
CreationAugust is 14 years old forever
04-17 5104
题目很水就是全都是坑真是丧心病狂啊 把代码留下造福后来人QωQ结构体与链表练习生日相同2.0#include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<algorithm> #define MAXN 200 using namespace std; struct st { int m,d;
【SDOI2014】【BZOJ3534】重建
CreationAugust is 14 years old forever
08-26 4326
DescriptionT国有N个城市，用若干双向道路连接。一对城市之间至多存在一条道路。 在一次洪水之后，一些道路受损无法通行。虽然已经有人开始调查道路的损毁情况，但直到现在几乎没有消息传回。 辛运的是，此前T国政府调查过每条道路的强度，现在他们希望只利用这些信息估计灾情。具体地，给定每条道路在洪水后仍能通行的概率，请计算仍能通行的道路恰有N-1条，且能联通所有城市的概率。Inp
bzoj.org俄罗斯方块
最新发布
05-06
bzoj.org是一个在线的编程题库，其中包含了很多经典算法问题和实际应用中的编程问题。其中包括了很多有趣的游戏算法问题，比如Puzzle，Tetris等。 而bzoj.org俄罗斯方块就是在该平台上的一个经典的俄罗斯方块游戏。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值