LCT系列

最新推荐文章于 2019-08-28 22:47:33 发布
最新推荐文章于 2019-08-28 22:47:33 发布
阅读量782 收藏
点赞数
分类专栏： BZOJ 文章标签： Link Cut Trees
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sddyzjh/article/details/42101387
版权

#1:[HNOI2010]弹飞绵羊

这道题是YM了Seter的模板以后过的

后来YM了wangxz神犇的姿势

题意:换父亲,询问点到根路径上的节点数

新技能:用fread刷rank

Code:

#include <cstdio>
using namespace std;
#define N 200001
struct Splay_Tree
{
    Splay_Tree *F, *Ls, *Rs;
    int Size;
}T[N], Empty;
inline void Init(Splay_Tree *x)
{
    x->F = x->Ls = x->Rs = &Empty;
    x->Size = 1;
}
inline Splay_Tree *Update(Splay_Tree *x)
{
    x->Size = 1 + x->Ls->Size + x->Rs->Size;
    return x;
}
inline Splay_Tree *f(Splay_Tree *x)
{
    if (x->F != &Empty)
        return (x->F->Ls == x || x->F->Rs == x) ? x->F : &Empty;
    return x->F;
}
inline Splay_Tree *rot(Splay_Tree * x)
{
    Splay_Tree *fx = f(x), *ffx = f(fx);
    bool c = fx->Rs == x, fc = ffx->Rs == fx;
    if (fx != &Empty)
    {
        x->F = fx->F;
        if (c)
        {
            fx->Rs = x->Ls;
            if (fx->Rs != &Empty)
                fx->Rs->F = fx;
            Update((fx->F = x)->Ls = fx);
        }
        else
        {
            fx->Ls = x->Rs;
            if (fx->Ls != &Empty)
                fx->Ls->F = fx;
            Update((fx->F = x)->Rs = fx);
        }
        if (ffx != &Empty)
        {
            if (fc)
                ffx->Rs = x;
            else
                ffx->Ls = x;
        }
    }
    return x;
}
inline Splay_Tree *Splay(Splay_Tree *x, Splay_Tree *p)
{
    Splay_Tree *fx, *ffx;
    if (x == &Empty)return x;
    for(;(fx = f(x)) != p;rot(x))
        if((ffx = f(fx)) != p)
            rot((ffx->Rs == fx) == (fx->Rs == x) ? fx : x);
    return Update(x);
}
inline Splay_Tree *Access(Splay_Tree *v)//½«vµ½×ܸùÁ¬³ÉÒ»¿ÃSplay 
{
    Splay_Tree *t = &Empty, *y = v;
    while (1)
    {
        Splay(v, &Empty);
        v->Rs = t;
        if (t != &Empty)f(t);
        if (v->F == &Empty)break;
        Update(v);
        t = v;
        v = t->F;
    }
    Splay(y, &Empty);
    return y;
}
char str[1500000], *c = str;
inline void read(int &x)
{
    int opt(1);
    for (;*c > '9' || *c < '0';c++)
        if (*c == '-')
            opt = -1;
    for (x = 0;*c >= '0' && *c <= '9'; ++c)
        x = (x << 3) + (x << 1) + *c - '0';
    x *= opt;
}
int n, m;
int main()
{
    int i, j, k;
    fread(str, 1, 1500000, stdin);
    Empty.F = Empty.Ls = Empty.Rs = 0;
    read(n);
    for (i = 0;i < n; ++i)
        Init(&T[i]);
    for (i = 0;i < n; ++i)
    {
        read(k);
        if (i+k < n)
            T[i].F = (T+i+k);
        else
            T[i].F = &Empty;
    }
    read(m);
    while (m--)
    {
        if (*++c == '1')
        {
            *c++;
            read(j);
            printf("%d\n", Access(T+j)->Ls->Size+1);
        }
        else
        if (*c == '2')
        {
            *c++;
            read(j), read(k);
            Access(T+j)->Ls->F = &Empty;
            f(T[j].Ls);
            T[j].Ls = &Empty;
            Update(&T[j])->F = j + k >= n ? &Empty : T+j+k;
        }
    }
}


#2:[ZJOI2008]树的统计

ZJ爷的标程是LCT

然后写LCT被神犇D:这题写什么LCT

题意:一棵树,点带权,修改点权,询问两点之间路径上最大权值或权值和

可用多种姿势

Update写错一次,Pushdown少加了几个地方......why am I so weak.

Code:

#include <cstdio>
#include <bitset>
#include <queue>
using namespace std;
#define N 30001
bitset<N> vis;
queue<int> Q;
struct node
{
	node *F, *Ls, *Rs;
	int Key, Sum, Reverse, Max;
	inline node *Update()
	{
		Sum = Key + Ls->Sum + Rs->Sum;
		Max = max(Key, max(Ls->Max, Rs->Max));
		return this;
	}
}T[N], Empty;
struct E
{
	int to, next;
}G[N<<1];
int n, m, cnt, point[N];
inline void add(int u, int v)
{
	cnt++, G[cnt] = (E){v, point[u]}, point[u] = cnt;
	cnt++, G[cnt] = (E){u, point[v]}, point[v] = cnt;
}
char str[5000000], *c = str;
inline void Init(node *now, int x)
{
	now->F = now->Ls = now->Rs = &Empty;
	now->Sum = now->Max = now->Key = x;
}
inline node *f(node *now)
{
	if (now->F == &Empty)return now->F;
	if (now->F->Ls == now || now->F->Rs == now)return now->F;
	return &Empty;
}
inline void Pushdown(node *now)
{
	if (now->Reverse)
	{
		now->Reverse ^= 1;
		swap(now->Ls, now->Rs);
		if (now->Ls != &Empty)
			now->Ls->Reverse ^= 1;
		if (now->Rs != &Empty)
			now->Rs->Reverse ^= 1;
	}
}
inline node *rot(node *now)
{
	node *fx = f(now), *ffx = f(fx);
	if (ffx != &Empty)
		Pushdown(ffx);
	if (fx != &Empty)
	{
		Pushdown(fx);
		Pushdown(now);
		now->F = fx->F;
		if (now == fx->Rs)
		{
			fx->Rs = now->Ls;
			if (fx->Rs != &Empty)
				fx->Rs->F = fx;
			((fx->F = now)->Ls = fx)->Update();
		}
		else
		{
			fx->Ls = now->Rs;
			if (fx->Ls != &Empty)
				fx->Ls->F = fx;
			((fx->F = now)->Rs = fx)->Update();
		}
		now->Update();
		if (ffx != &Empty)
		{
			if (fx == ffx->Rs)
				ffx->Rs = now;
			else
				ffx->Ls = now;
			ffx->Update();
		}
	}
	return now;
}
inline node *Splay(node *now, node *tar)
{
	node *fx, *ffx;
	Pushdown(now);
	for (;(fx = f(now)) != tar;rot(now))
		if ((ffx = f(fx)) != tar)
			rot((ffx->Rs == fx) == (fx->Rs == now) ? fx : now);
	return now->Update();
}
inline node *Access(node *now)
{
	node *t = &Empty, *y = now;
	while (now != &Empty)
	{
		Splay(now, &Empty)->Rs = t;
		now->Update();
		now = (t = now)->F;
	}
	return t;
}
inline void Evert(node *now)
{
	Access(now)->Reverse ^= 1;
	Splay(now, &Empty);
}
inline node *Query(int l, int r)
{
	Evert(T+l);
	Access(T+r);
	Splay(T+r, &Empty);
	return T+r;
}
inline void read(int &x)
{
	int opt(1);
	for (;*c > '9' || *c < '0'; ++c)
		if (*c == '-')
			opt = -1;
	for (x = 0;*c >= '0' && *c <= '9'; ++c)
		x = (x << 3) + (x << 1) + *c - '0';
	x *= opt;
}
int main()
{
//	freopen("a.in", "r", stdin);
	int i, j, k;
	Empty.F = Empty.Ls = Empty.Rs = &Empty;
	Empty.Max = -30001;
	fread(str, 1, 5000000, stdin);
	read(n);
	for (i = 1;i < n; ++i)
	{
		read(j), read(k);
		add(j, k);
	}
	for (i = 1;i <= n; ++i)
	{
		read(j);
		Init(T+i, j);
	}
	Q.push(1);
	vis[1] = 1;
	while (!Q.empty())
	{
		j = Q.front();
		Q.pop();
		for (i = point[j];i;i = G[i].next)
		{
			k = G[i].to;
			if (!vis[k])
			{
				vis[k] = 1;
				T[k].F = T+j;
				Q.push(k);
			}
		}
	}
	read(m);
	while (m--)
	{
		if (*++c == 'C')
		{
			read(i), read(j);
			T[i].Key = j;
			(T+i)->Update();
			Access(T+i);
		}
		else
		if (*c == 'Q')
		{
			if (*++c == 'M')
			{
				read(i), read(j);
				printf("%d\n", i == j ? T[i].Key : Query(i, j)->Max);
			}
			else
			if (*c == 'S')
			{
				read(i), read(j);
				printf("%d\n", i == j ? T[i].Key : Query(i, j)->Sum);
			}
		}
	}
	return 0;
}

两节课重写了一遍,换了一种姿势,快了不少

Code:

#include <cstdio>
#include <queue>
#include <bitset>
using namespace std;
#define N 30001
queue<int> Q;
bitset<N> vis;
struct node
{
	node *F, *S[2];
	int Key, Max, Sum, Reverse;
	inline void Init(int x)
	{
		Key = Max = Sum = x;
		Reverse = 0;
		F = S[0] = S[1] = 0;
	}
	inline void Pushdown()
	{
		if (Reverse)
		{
			Reverse ^= 1;
			swap(S[0], S[1]);
			if (S[0])S[0]->Reverse ^= 1;
			if (S[1])S[1]->Reverse ^= 1;
		}
	}
	inline node *Update()
	{
		Sum = Max = Key;
		if (S[0])Sum += S[0]->Sum, Max = max(Max, S[0]->Max);
		if (S[1])Sum += S[1]->Sum, Max = max(Max, S[1]->Max);
		return this;
	}
	inline node *f()
	{
		if (!F)return 0;
		if (F->S[0] == this || F->S[1] == this)return F;
		return 0;
	}
	inline node *rot()
	{
		node *fx = f(), *ffx = fx ? fx->f() : 0;
		if (ffx)ffx->Pushdown();
		if (fx)
		{
			fx->Pushdown();
			Pushdown();
			bool c = (this == (fx ? fx->S[1] : 0));
			F = fx->F;
			fx->F = this;
			fx->S[c] = S[!c];
			if (S[!c])S[!c]->F = fx;
			fx->Update();
			S[!c] = fx;
			Update();
		}
		if (ffx)
		{
			bool fc = (fx == (ffx ? ffx->S[1] : 0));
			ffx->S[fc] = this;
		}
		return this;
	}
	inline node *Splay()
	{
		Pushdown();
		node *fx, *ffx;
		for (;fx = f();rot())
			if (ffx)(this == fx->S[1] && fx == ffx->S[1]) ? fx->rot() : rot();
		return this;
	}
	inline node *Access()
	{
		node *p = this, *v = 0;
		while (p)
		{
			p->Splay()->S[1] = v;
			p->Update();
			p = (v = p)->F;
		}
		return v;
	}
	inline void Evert()
	{
		Access()->Reverse ^= 1;
		Splay();
	}
}T[N];
inline node *Query(int u, int v)
{
	(T+u)->Evert();
	(T+v)->Access();
	(T+v)->Splay();
	return T+v;
}
struct E
{
	int to, next;
}G[N<<1];
char str[10000000], *c = str;
inline void read(int &x)
{
	int opt(1);
	for (;*c > '9' || *c < '0'; ++c)
		if (*c == '-')
			opt = -1;
	for (x = 0;*c >= '0' && *c <= '9'; ++c)
		x = (x << 3) + (x << 1) + *c - '0';
	x *= opt;
}
int n, m, i, j, k, cnt, point[N];
inline void add(int u, int v)
{
	cnt++, G[cnt] = (E){v, point[u]}, point[u] = cnt;
	cnt++, G[cnt] = (E){u, point[v]}, point[v] = cnt;
}
int main()
{
	freopen("a.in", "r", stdin);
	freopen("a.out", "w", stdout);
	fread(str, 1, 5000000, stdin);
	read(n);
	for (i = 1;i < n; ++i)
	{
		read(j), read(k);
		add(j, k);
	}
	for (i = 1;i <= n; ++i)
	{
		read(j);
		T[i].Init(j);
	}
	Q.push(1);
	vis[1] = 1;
	while (!Q.empty())
	{
		j = Q.front();
		Q.pop();
		for (i = point[j];i;i = G[i].next)
		{
			k = G[i].to;
			if (!vis[k])
			{
				vis[k] = 1;
				T[k].F = &T[j];
				Q.push(k);
			}
		}
	}
	read(m);
	while (m--)
	{
		if (*++c == 'C')
		{
			read(i), read(j);
			T[i].Key = j;
			T[i].Update();
			T[i].Access();
		}
		else
		{
			if (*++c == 'M')
			{
				read(i), read(j);
				printf("%d\n", i == j ? T[i].Key : Query(i, j)->Max);
			}
			else
			{
				read(i), read(j);
				printf("%d\n", i == j ? T[i].Key : Query(i, j)->Sum);
			}
		}
	}
	return 0;
}


sddyzjh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
U2000 Web LCT 用户指南-(V100R005C00_01).
05-23
U2000 Web LCT 用户指南-(V100R005C00_01).
浅谈LCT
RainbowCrown_CGH's blog
08-19 623
动态树之LCT(link-cut tree)讲解前言　　动态树是一类要求维护森林的连通性的题的总称，这类问题要求维护某个点到根的某些数据，支持树的切分，合并，以及对子树的某些操作。其中解决这一问题的某些简化版（不包括对子树的操作）的基础数据结构就是LCT(link-cut tree)。　　LCT的大体思想类似于树链剖分中的轻重链剖分，轻重链剖分是处理出重链来，由于重链的定义和树链剖分是处理静态树所限
LCT教程
weixin_30338461的博客
12-19 241
lct是一种动态树,用来维护一些动态加边删边的操作的东西.他主要用到几个操作,其实这个算法和树链刨分有点像,但是不能用线段树简单维护,所以我们要用多棵平衡树来维护树上的一个个子树,然后就进行一些很秀的操作.详情见这个博客:FlashHu 这个博客讲的是真的好,特别适合新手看,而且特别细节,(特别带劲).现在我就可以上代码: 模板: #include <iostream> #...
bzoj3651 网络通信（LCT）
Coco_T的博客
11-28 516
Description有一个由M 条电缆连接的 N 个站点组成的网络。为了防止垄断，由 C 个公司控制所有的电缆，规定任何公司不能控制连接同一个站点的两条以上的电缆（可以控制两条）。同时规定，每个公司不能有多余的电缆，所谓的多余，是指属于同一个公司的电缆不能形成环。 在运作过程中，不同公司之间会进行电缆买卖。请你写一个程序判断买卖是否合法。 Input输入第一行有4个由空格隔开的整数 N，M，C和
LCT细节注意
PhilipsWeng的专栏
11-15 814
LCT的题目中经常会遇到旋根操作，那么就要打一个翻转标记，这样就会引起很多问题。Splay的双旋Splay必须要处理好标记下传的问题，不然由于双旋的特殊性很容易造成问题。一种比较方便的操作方式是在Splay(u)之前先把u的所有父亲的标记都下传。void Splay(int u) { int top = 0; for(int i = u;i;i = T[i].
lct-ui:LCT v4 用户界面
06-03
LCT UI 是一个专为 LCT（可能是某个软件或系统的缩写）设计的用户界面，特别提到了这是 v4 版本，意味着它是该系列的第四次重大更新。用户界面是任何软件与用户交互的关键部分，通常包括各种图形元素、布局、色彩...
微功耗高精度数字位移传感模块LCT-9723使用说明书.pdf
10-04
在使用LCT-9723系列传感器时，需要注意连接电源和信号输出端口，确保正确接线，例如LCT-9723A的管脚标识为：1负极、2正极、3地线、4输出信号、5探头1、6和7为空、8探头2。而LCT-9723B和LCT-9723C则配备有预接的三芯...
模拟技术中的LTC2208系列16位、最高速度达130Msps的高速ADC
12-04
LTC2208系列是凌特特公司(Linear Technology Corporation)推出的一款高性能模拟到数字转换器（ADC），专门设计用于低噪声信号采集应用。这款16位高速ADC的最高速度达到130兆样本每秒（Msps），使得它在高速数据采集...
MHDD命令[归类].pdf
10-11
19. **CX**：针对昆腾CX和LCT系列硬盘的特定命令，帮助解决这些硬盘的特殊问题。 这些命令在软件开发和硬盘维护中非常实用，能帮助诊断和修复硬盘故障，确保数据安全。正确理解和使用这些命令对于系统管理员和IT...
MHDD修硬盘方法详解[归类].pdf
10-11
- **Cx**：用于检查昆腾CX和LCT系列硬盘的稳定性。 - **Erase**：快速擦除。 - **Ibme**：显示IBM硬盘的tlists表。 - **Fujlst**：显示富士通硬盘的tlists表。 **优点分析：** - **精细扫描**：MHDD的F4扫描功能能...
LCT学习笔记
weixin_30662109的博客
07-03 80
Link-Cut Tree 是用于维护由一组有根树组成的森林的数据结构，Link-Cut Tree 的基本操作复杂度为均摊 \(O(log2n)\),具体的定义和时间复杂度的证明可以移步《QTREE 解法的一些研究》，这里主要介绍它的基本操作的具体实现。 定义 struct node *null; //定义一个虚拟空节点 struct node { node *fa, *c[2]...
cannot find -l****问题的解决办法
热门推荐
江前云后的专栏
07-17 7万+
在ubuntu下编译C或cpp文件时，可能会出现找不到链接库的问题，其形式为：cannot find -l****这里的**一般是指的链接库，比如，刚刚装好opencv，按照网上教程一步步编译好了，最后按照教程想要编译一下/example/c下的例子试试，结果执行了./build_all.sh后，爆出一堆上面这种错误，比如,我在自己电脑上出现的错误就是找不到以下库cannot find -lcuda
史上最详尽的LCT讲解
薇小薇
11-23 6988
终于填完了这个天坑！
Lct系列小结
袋鼠与蒟蒻
07-02 1039
  这个东西欠了很久了(博客也停了很久了) 这篇博文不负责讲解Lct的基础知识（太麻烦）所以有需要的同学可以看这里 PART 1  我们首先给一个模板 struct Splay{     int F,s[2],rev;     int val,sum;     inline void NewNode(int fa,int x){         F=fa; s[0]=s[1]=rev=...
解决C++编译时报错：ld: cannot find -lxxx方法
赶路人儿
08-28 6万+
编译程序有时会遇到“ld: cannot find -lxxx”的错误，就是链接器说找不到xxx库。一般先使用如下命令查找系统中是否存在xxx库而ld程序未找到(以zlib为例)： $ ld -lzlib --verbose 输出如下信息： ==================================== attempt to open /usr/x86_64-linux-gnu...
[SDOI2010]猪国杀
emmmm
11-27 1433
Au爷faebdc:"神犇来做猪国杀吧,我自己做太蛋疼了" 蒟蒻:"好吧" Au爷faebdc“我过了” 蒟蒻:"......" Au爷faebdc:"我rank1了" 蒟蒻:"......" 两天后 蒟蒻:"我过了" Au爷faebdc:"......" --------------------------------------------------------------
动态树与LCT：区间操作与链上维护
LCT是一种强大的工具，结合树链剖分和动态Splay树的特性，有效地解决了动态树问题中的一系列复杂操作，尤其是在支持频繁插入、删除和查询的场景下，它的效率至关重要。学习和理解LCT背后的原理和概念对于解决此类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值