1. 程式人生 > >洛谷3703 SDOI2017樹點塗色(LCT+線段樹+dfs序)

洛谷3703 SDOI2017樹點塗色(LCT+線段樹+dfs序)

題目連結

又一道好題啊qwqqqq

一開始看這個題,還以為是一個樹剖的什麼毒瘤題目
(不過的確貌似可以用樹剖啊)
qwq這真是一道 L C T LCT 維護顏色的好題

首先,我們來一個一個操作的考慮。

對於操作 1

1 來說,我們是不是就相當於把 1   x 1~x 的路徑,弄成一個獨立的聯通塊?

哎,這個貌似是 a

c c e s s ( x ) access(x) 的操作理念啊QWQ

假設我們用 L C T LCT 維護這棵樹,一開始就全是虛邊,然後對於一次1操作,那麼就相當於一次 a c c e s s access ,那麼權值的定義,也就相當於到1的路徑上要經過多少個不同的 s p l a y splay (也就是輕邊的數目+1)

起初每個點的權值,都是他的 d e e p deep (我們假設根的 d e e p 1 deep是1 ),那麼我們該如何詢問一條路徑上的權值和呢?

QWQ
由於我們的 L C T LCT ,被當做來維護顏色了,所以自然不能通過 s p l i t split 來算,因為會破壞原來的結構。
qwqqq

這時候就需要題解了
通常,我們求樹上路徑的方法一般都是樹上差分。

那麼這個題可以不可以用同樣的方法來做呢?

我們來考慮證明一下(感性理解)

假設當前的兩個點是 x , y x,y ,他們的 L C A LCA 記為 l l

先考慮存在同色的情況

$首先,我們可以知道,l只會和x,y其中一個同色。

顯然 v a l [ x ] v a l [ l ] val[x]-val[l] 表示去掉LCA的這個點, x l x`l 路徑上的顏色個數,然後 v a l [ y ] v a l [ l ] val[y]-val[l] 同理。

而總的路徑條數,顯然等於兩個式子相加,然後再加上 L C A LCA 的顏色(因為 L C A LCA 的顏色被減去了兩次)。

正好就是我們樹上差分的式子
v a l [ x ] + v a l [ y ] 2 v a l [ L C A ( x , y ) ] + 1 val[x]+val[y]-2*val[LCA(x,y)] +1

那麼我們現在就剩下最後一個問題了。

怎麼維護修改和子樹 m a x max 呢??
QWQ

既然沒有修改,而且樹的形態還是固定的。

那就可以直接線段樹維護 d f s dfs 序啊!

那麼對於三操作就相當於子樹求max

而對於子樹的 v a l val 的修改,我們可以發現,只有在每個 a c c e s s access 的時候,才會產生修改的影響(因為存在輕重邊的切換),直接對應的+1,-1就行

但是有一個要注意的問題就是

!!!!我們修改的時候,要找到當前splay裡面深度最小的點,把他和他的子樹修改,這樣才能起到整個子樹都修改的效果

直接上程式碼


// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#define mk makr_pair
#define ll long long

using namespace std;

inline int read()
{
  int x=0,f=1;char ch=getchar();
  while (!isdigit(ch)) {if (ch=='-') f=-1;ch=getchar();}
  while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
  return x*f;
}

const int maxn = 2e5+1e2;
const int maxm = 2*maxn;


int point[maxn],nxt[maxm],to[maxm];
int cnt,n,m;
int dfn[maxn],size[maxn],deep[maxn];
int add[4*maxn],g[4*maxn];
int f[maxn][21];
int ch[maxn][3];
int rev[maxn],fa[maxn];
int back[maxn];
int tot;

void addedge(int x,int y)
{
	nxt[++cnt]=point[x];
	to[cnt]=y;
	point[x]=cnt;
}

void up(int root)
{
  g[root]=max(g[2*root],g[2*root+1]);	
}

void build(int root,int l,int r)
{
	if (l==r)
	{
		g[root]=deep[back[l]];
		return;
	}
	int mid = l+r >> 1;
	build(2*root,l,mid);
	build(2*root+1,mid+1,r);
	up(root);
}

void pushdown(int root,int l,int r)
{
	if (add[root])
	{
		add[root*2]+=add[root];
		add[2*root+1]+=add[root];
		g[2*root]+=add[root];
		g[2*root+1]+=add[root];
		add[root]=0;
	}
}

void update(int root,int l,int r,int x,int y,int p)
{
	if (x>y) return;
	if (x<=l && r<=y)
	{
		g[root]+=p;
		add[root]+=p;
		return;
	}
	pushdown(root,l,r);
	int mid = l+r >> 1;
	if (x<=mid) update(2*root,l,mid,x,y,p);
	if (y>mid) update(2*root+1,mid+1,r,x,y,p);
	up(root);
}

int query(int root,int l,int r,int x,int y)
{
	if (x>y) return 0;
	if (x<=l && r<=y)
	{
		return g[root];
	}
	pushdown(root,l,r);
	int ans=0;
	int mid = l+r >> 1;
	if (x<=mid) ans=max(ans,query(2*root,l,mid,x,y));
	if (y>mid) ans=max(ans,query(2*root+1,mid+1,r,x,y));
	return ans;
}

void dfs(int x,int faa,int dep)
{
	deep[x]=dep;
	dfn[x]=++tot;
	back[tot]=x;
	size[x]=1;
	for (int i=point[x];i;i=nxt[i])
	{
		int p = to[i];
		if (p==faa) continue;
		fa[p]=x;
		f[p][0]=x;
		dfs(p,x,dep+1);
		size[x]+=size[p];
	}
}

void init()
{
	for (int j=1;j<=20;j++)
	  for (int i=1;i<=n;i++)
	    f[i][j]=f[f[i][j-1]][j-1];
}

int go_up(int x,int d)
{
	for(int i=0;i<=20;i++)
	{
		if ((1<<i) & d) x=f[x][i];
	}
	return x;
} 

int lca(int x,int y)
{
	if (deep[x]>deep[y]) x=go_up(x,deep[x]-deep[y]);
	else y=go_up(y,deep[y]-deep[x]);
	if (x==y) return x;
	for (int i=20;i>=0;i--)
	{
		if (f[x][i]!=f[y][i])
		{
			x=f[x][i];
			y=f[y][i];
		}
	}
	return f[x][0];
}

int son(int x)
{
	if (ch[fa[x]][0]==x) return 0;
	else return 1;
}

bool notroot(int x)
{
	return ch[fa[x]][0]==x || ch[fa[x]][1]==x;
}

void rotate(int x)
{
	int y=fa[x],z=fa[y];
	int b=son(x),c=son(y);
	if (notroot(y)) ch[z][c]=x;
	fa[x]=z;
	ch[y][b]=ch[x][!b];
	fa[ch[x][!b]]=y;
	ch[x][!b]=y;
	fa[y]=x;
}  

void splay(int x)
{
   while (notroot(x))
   {
   	 int y = fa[x],z=fa[y];
   	 int b=son(x),c=son(y);
   	 if(notroot(y))
   	 {
   	 	if (b==c) rotate(y);
   	 	else rotate(x);
	 }
	 rotate(x);
   }
}

int findroot(int x)
{
	while (ch[x][
            
           

相關推薦

3703 SDOI2017LCT+線段+dfs

題目連結 又一道好題啊qwqqqq 一開始看這個題,還以為是一個樹剖的什麼毒瘤題目 (不過的確貌似可以用樹剖啊) qwq這真是一道 L C

[Bzoj4817] [Sdoi2017] LCT神題

可能 維護 題目 problem through text 其中 覆蓋 int 4817: [Sdoi2017]樹點塗色 Time Limit: 10 Sec Memory Limit: 128 MBSubmit: 629 Solved: 371[Sub

BZOJ 4817: [Sdoi2017]

prepare new 來看 rep next 結果 wap tchar end 二次聯通門 : BZOJ 4817: [Sdoi2017]樹點塗色 /* BZOJ 4817: [Sdoi2017]樹點塗色 考場上打的暴力

【BZOJ4817】[Sdoi2017] LCT+線段

sum urn using sof 兩個 如果 std bsp char 【BZOJ4817】[Sdoi2017]樹點塗色 Description Bob有一棵n個點的有根樹,其中1號點是根節點。Bob在每個點上塗了顏色,並且每個點上的顏色不同。定義一條路徑的權值是

BZOJ.4817.[SDOI2017](LCT DFS 線段)

HP date amp num 貢獻 pla AR name log 題目鏈接 1.2裸樹剖,但是3.每個點的答案val很不好維護。。 如果我們把同種顏色的點劃分到同一連通塊中,那麽向根染色的過程就是Access()! 最初所有點間都是虛邊,相同顏色點用實邊相連。一條邊由實

bzoj4817: [Sdoi2017]

algorithm 根路徑 ini scanf tree AC lct dfs rdf 題目鏈接 bzoj4817: [Sdoi2017]樹點塗色 題解 數據結構.....大概很容易看出是道lct 然後棄療 操作1很想lct裏面的access操作 那麽對於操作2 設F[i]

[Libre][SDOI2017]

hang tin += http != 表示 塗色 include 進行 鏈接 (蒟蒻只能夠想到 3 操作可以用樹剖線段樹維護ORZ) 對於每個 1 操作 , 都會覆蓋當前節點到根節點的所有顏色 , 且新顏色對所有經過操作節點的路徑都有貢獻。 所以我們維護所有邊的兩邊顏色是

【bzoj4817】[Sdoi2017]&&bzoj3779-重組病毒

dfs序 dfs 顏色 bzoj3779 我們 style 病毒 bzoj tro 題解: 兩道幾乎差不多的題(所以說當年sdoi考了道原題) 都是將樹上一段改為新顏色詢問顏色數目 可以把改成新顏色這個操作看成access操作 然後通過線段樹+dfs序來維護 另外

【題解】SDOI2017

我們 lin 由於 加減 build 分別是 include flag 貢獻   LCT強強!以前總是覺得LCT非常的難懂(當然現在也是的),但實際上它真的是很厲害的一種東西。它是一種動態的鏈剖分結構,其實就是對於剖分出來的重鏈使用LCT去進行維護。cut 與 link 兩

SDOI2017第一輪 BZOJ4816: [Sdoi2017]數字表格 BZOJ4817: [Sdoi2017] BZOJ4818: [Sdoi2017]序列計數 BZOJ4819: [Sdoi2017]新生舞會 BZOJ4820: [Sdoi2017]硬幣遊戲 BZOJ4821: [Sd

本蒟蒻表示終於$AC$了$SDOI2017\text{第一輪}$! 興奮! 附上各個題的題解: $DAT1$: $T1$: BZOJ4816: [Sdoi2017]數字表格 $T2$: BZOJ4817: [Sdoi2017]樹點塗色 $T3$: BZOJ4818: [Sdoi2017]序列

LCT+剖+線段--bzoj4817: [Sdoi2017]

傳送門 和bzoj3379有異曲同工之妙 也是用樹剖+線段樹的思想維護 d f s

BZOJ4817[Sdoi2017]

傳送門 sdoi是真的舒服QAQ 比較神奇的資料結構上樹題233 我們觀察這個題的性質 發現將一條到1的路徑染色很像LCT的access操作 我們不妨將相同顏色的點放在一個splay裡面 然後access的時候 一條重邊變成輕邊的時候其實是 子樹內ans +1 可以理解成原來它和它上

BZOJ4817: [Sdoi2017](LCT)

Description Bob有一棵n個點的有根樹,其中1號點是根節點。Bob在每個點上塗了顏色,並且每個點上的顏色不同。定義一條路 徑的權值是:這條路徑上的點(包括起點和終點)共有多少種不同的顏色。Bob可能會進行這幾種操作: 1 x: 把點x到根節點

BZOJ 4817 [SDOI2017] (LCT+線段維護dfs)

題目大意:略 塗色方式明顯符合$LCT$裡$access$操作的性質,相同顏色的節點在一條深度遞增的鏈上 用$LCT$維護一個樹上集合就好 因為它維護了樹上集合,所以它別的啥都幹不了了 發現樹是靜態的,可以用$dfs$序搞搞 把問題當成樹上節點塗色會很麻煩 但只有相鄰的不同顏色節點才會對答案產生影

SDOI2017

題目描述 題解: SDOI SD題。 LCT維護線段樹, 線段樹維護dfs序。 由於每次修改只是從根到x,我們可以將它理解為LCT的access操作。 然後輕重鏈資訊發生變化時,線上段樹上改一下就好了。 LCTaccess板子敲錯導致自己做自己爺爺。 程式碼: #include<

[SDOI2017]

down num continue break lct left std using tdi 題意 有操作: 1 $x$ 把點 $x$ 到根節點的路徑上所有的點染上一種沒有用過的新顏色。 2 $x$ $y$ 求 $x$ 到 $y$ 的路徑的權值。

【LG3703】[SDOI2017]

!= next int iostream problem 。。 struct show swa 【LG3703】[SDOI2017]樹點塗色 題面 洛谷 題解 更博辣,更博辣!!! 泥萌不覺得在過年的時候更博很不吉利嗎 一次只能染根到\(x\),且染的顏色未出現過 這句

P3703 [SDOI2017]

find == lin 區間 segment void getch update ttr P3703 [SDOI2017]樹點塗色 鏈接 分析:   首先對於詢問,感覺是線段樹維護dfs序,每個點記錄到根的顏色個數。第二問差分,第三問區間取max。   那麽考慮修改

Luogu P3703 [SDOI2017]

opera esp rotate acc file clu head dfs序 復雜度分析 比較有趣的綜合樹上問題,刷LCT題單時做的但是發現後面LCT只是起了輔助作用233 首先我們分析每一個操作,\(1\)的定義就讓我們聯想到了access,我們回憶一下LCT的性質:

luogu3703 [SDOI2017](線段+鏈剖分+動態)

你會 bool vector root 動態樹 說我 scan 很難 第一個 link 你谷的第一篇題解沒用寫LCT,然後沒觀察懂,但是自己YY了一種不用LCT的做法 我們考慮對於每個點,維護一個fa,代表以1為根時候這個點的父親 再維護一個bel,由於一個顏色相同的段一定