Thụ liên mổ phân

Thụ liên mổ phân tư tưởng cập có thể giải quyết vấn đề

Thụ liên mổ phân dùng cho đem thụ phân cách thành bao nhiêu điều liên hình thức, lấy giữ gìn trên cây đường nhỏ tin tức.

Cụ thể tới nói, đem chỉnh cây mổ chia làm bao nhiêu điều liên, sử nó tổ hợp thành tuyến tính kết cấu, sau đó dùng mặt khác số liệu kết cấu giữ gìn tin tức.

Thụ liên mổ phân( thụ mổ / liên mổ ) có bao nhiêu loại hình thức, nhưTrọng liên mổ phân,Trường liên mổ phânCùng dùng cho Link/cut Tree mổ phân ( có khi bị gọi “Thật liên mổ phân” ), đại đa số dưới tình huống ( không có đặc biệt thuyết minh khi ), “Thụ liên mổ phân” đều chỉ “Trọng liên mổ phân”.

Trọng liên mổ phân có thể đem trên cây tùy ý một cái đường nhỏ phân chia thành không vượt quaĐiều liên tục liên, mỗi điều liên thượng điểm chiều sâu lẫn nhau không giống nhau ( tức là tự đế hướng về phía trước một cái liên, liên thượng sở hữu điểm LCA vì liên một cái điểm cuối ).

Trọng liên mổ phân còn có thể bảo đảm phân chia ra mỗi điều liên thượng tiết điểm DFS tự liên tục, bởi vậy có thể phương tiện mà dùng một ít giữ gìn danh sách số liệu kết cấu ( như đoạn thẳng thụ ) tới giữ gìn trên cây đường nhỏ tin tức.

Như:

1. Sửa chữaTrên cây hai điểm chi gian đường nhỏ thượngSở hữu điểm giá trị.
2. Tuần traTrên cây hai điểm chi gian đường nhỏ thượngTiết điểm quyền giá trịCùng / cực trị / cái khác ( ở danh sách thượng có thể dùng số liệu kết cấu giữ gìn, dễ bề xác nhập tin tức ).

Trừ bỏ phối hợp số liệu kết cấu tới giữ gìn trên cây đường nhỏ tin tức, thụ mổ còn có thể dùng để( thả hằng số nhỏ lại ) mà cầu LCA. Ở nào đó đề mục trung, còn có thể lợi dụng này tính chất tới linh hoạt mà vận dụng thụ mổ.

Trọng liên mổ phân

Chúng ta cấp ra một ít định nghĩa:

Định nghĩaHạt cơ bản tiết điểmTỏ vẻ này tử tiết điểm trúng tử thụ lớn nhất tử giao điểm. Nếu có bao nhiêu vóc dáng thụ lớn nhất tử giao điểm, lấy thứ nhất. Nếu không có tử tiết điểm, liền vô hạt cơ bản tiết điểm.

Định nghĩaNhẹ tử tiết điểmTỏ vẻ còn thừa sở hữu tử giao điểm.

Từ cái này giao điểm đến hạt cơ bản tiết điểm biên vìTrọng biên.

Đến mặt khác nhẹ tử tiết điểm biên vìNhẹ biên.

Bao nhiêu điều đầu đuôi hàm tiếp trọng biên cấu thànhTrọng liên.

Đem lạc đơn giao điểm cũng làm như trọng liên, như vậy chỉnh cây đã bị mổ phân thành bao nhiêu điều trọng liên.

Như đồ:

Thực hiện

Thụ mổ thực hiện phân hai cái DFS quá trình. Ngụy số hiệu như sau:

Cái thứ nhất DFS ký lục mỗi cái giao điểm phụ tiết điểm ( father ), chiều sâu ( deep ), tử thụ lớn nhỏ ( size ), hạt cơ bản tiết điểm ( hson ).

Cái thứ hai DFS ký lục nơi liên liên đỉnh ( top, ứng khởi động lại vì giao điểm bản thân ), trọng biên ưu tiên biến cuối cùng DFS tự ( dfn ), DFS tự đối ứng tiết điểm đánh số ( rank ).

Dưới vì số hiệu thực hiện.

Chúng ta trước cấp ra một ít định nghĩa:

• Tỏ vẻ tiết điểmỞ trên cây phụ thân.
• Tỏ vẻ tiết điểmỞ trên cây chiều sâu.
• Tỏ vẻ tiết điểmTử thụ tiết điểm cái số.
• Tỏ vẻ tiết điểmTrọng nhi tử.
• Tỏ vẻ tiết điểmNơiTrọng liênĐỉnh chóp tiết điểm ( chiều sâu nhỏ nhất ).
• Tỏ vẻ tiết điểmDFS tự,Cũng là này tại tuyến đoạn thụ trung đánh số.
• Tỏ vẻ DFS tự sở đối ứng tiết điểm đánh số, có.

Chúng ta tiến hành hai lần DFS dự xử lý ra này đó giá trị, trong đó lần đầu tiên DFS cầu ra,,,,Lần thứ hai DFS cầu ra,,.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

voiddfs1(into){
son[o]=-1;
siz[o]=1;
for(intj=h[o];j;j=nxt[j])
if(!dep[p[j]]){
dep[p[j]]=dep[o]+1;
fa[p[j]]=o;
dfs1(p[j]);
siz[o]+=siz[p[j]];
if(son[o]==-1||siz[p[j]]>siz[son[o]])son[o]=p[j];
}
}

voiddfs2(into,intt){
top[o]=t;
cnt++;
dfn[o]=cnt;
rnk[cnt]=o;
if(son[o]==-1)return;
dfs2(son[o],t);// ưu tiên đối trọng nhi tử tiến hành DFS, có thể bảo đảm cùng điều trọng liên thượng điểm DFS tự liên tục
for(intj=h[o];j;j=nxt[j])
if(p[j]!=son[o]&&p[j]!=fa[o])dfs2(p[j],p[j]);
}

Trọng liên mổ phân tính chất

Trên cây mỗi cái tiết điểm đều thuộc về thả thuộc loại với một cái trọng liên.

Trọng liên mở đầu giao điểm không nhất định là hạt cơ bản tiết điểm ( bởi vì trọng biên là đối với mỗi một cái giao điểm đều có định nghĩa ).

Sở hữu trọng liên đem chỉnh câyHoàn toàn mổ phân.

Ở mổ tiến hành cùng lúcTrọng biên ưu tiên biến lịch,Cuối cùng thụ DFS tự thượng, trọng liên nội DFS tự là liên tục. Ấn DFN bài tự sau danh sách tức vì mổ phân sau liên.

Một viên tử thụ nội DFS tự là liên tục.

Có thể phát hiện, khi chúng ta xuống phía dưới trải qua một cáiNhẹ biênKhi, nơi tử thụ lớn nhỏ ít nhất sẽ trừ lấy nhị.

Bởi vậy, đối với trên cây tùy ý một cái đường nhỏ, đem nó tách ra thành từLCAPhân biệt hướng hai bên đi xuống dưới, phân biệt nhiều nhất điThứ, bởi vậy, trên cây mỗi con đường kính đều có thể bị tách ra thành không vượt quaĐiều trọng liên.

Thường thấy ứng dụng

Đường nhỏ thượng giữ gìn

Dùng thụ liên mổ phân cầu trên cây hai điểm đường nhỏ quyền giá trị cùng, ngụy số hiệu như sau:

Liên thượng DFS tự là liên tục, có thể sử dụng đoạn thẳng thụ, thụ trạng số tổ giữ gìn.

Mỗi lần lựa chọn chiều sâu trọng đại liên hướng lên trên nhảy, thẳng đến hai điểm ở cùng điều liên thượng.

Đồng dạng nhảy liên kết cấu áp dụng với giữ gìn, thống kê đường nhỏ thượng mặt khác tin tức.

Tử thụ giữ gìn

Có khi sẽ yêu cầu, giữ gìn tử trên cây tin tức, thí dụ như đem lấyLàm gốc tử thụ sở hữu giao điểm quyền giá trị gia tăng.

Ở DFS tìm tòi thời điểm, tử thụ trung giao điểm DFS tự là liên tục.

Mỗi một cái giao điểm ký lục bottom tỏ vẻ nơi tử thụ liên tục khu gian phía cuối giao điểm.

Như vậy liền cầm thụ tin tức chuyển hóa vì liên tục một đoạn khu gian tin tức.

Cầu gần nhất công cộng tổ tiên

Không ngừng hướng về phía trước nhảy trọng liên, đương nhảy đến cùng điều trọng liên thượng khi, chiều sâu nhỏ lại giao điểm tức vì LCA.

Hướng về phía trước nhảy trọng liên khi yêu cầu trước nhảy nơi trọng liên đỉnh chiều sâu trọng đại cái kia.

Tham khảo số hiệu:

1
2
3
4
5
6
7
8
9

intlca(intu,intv){
while(top[u]!=top[v]){
if(dep[top[u]]>dep[top[v]])
u=fa[top[u]];
else
v=fa[top[v]];
}
returndep[u]>dep[v]?v:u;
}

Ví dụ mẫu

“ZJOI2008” thụ thống kê

Đề mục đại ý

Đối một cây cóCái tiết điểm, tiết điểm mang quyền giá trị trạng thái tĩnh thụ, tiến hành ba loại thao tác cộngThứ:

1. Sửa chữa đơn cái tiết điểm quyền giá trị;
2. Tuần traĐếnĐường nhỏ thượng lớn nhất quyền giá trị;
3. Tuần traĐếnĐường nhỏ thượng quyền giá trị chi cùng.

Bảo đảm,.

Giải pháp

Căn cứ đề mặt cùng với trở lên tính chất, ngươi đoạn thẳng thụ yêu cầu giữ gìn ba loại thao tác:

1. Đơn điểm sửa chữa;
2. Khu gian tuần tra cực đại;
3. Khu gian tuần tra cùng.

Đơn điểm sửa chữa thực dễ dàng thực hiện.

Bởi vì tử thụ DFS tự liên tục ( vô luận hay không thụ mổ đều là như thế ), sửa chữa một cái tiết điểm tử thụ chỉ dùng sửa chữa một đoạn này liên tục DFS tự khu gian.

Vấn đề là như thế nào sửa chữa / tuần tra hai cái tiết điểm chi gian đường nhỏ.

Suy xét chúng ta là như thế nào dùngTăng gấp bội pháp cầu giải LCA.Đầu tiên chúng taĐem hai cái tiết điểm nhắc tới cùng độ cao, sau đó đem hai cái tiết điểm cùng nhau hướng về phía trước nhảy.Đối với thụ liên mổ phân cũng có thể sử dụng như vậy tư tưởng.

Ở hướng về phía trước nhảy trong quá trình, nếu trước mặt tiết điểm ở trọng liên thượng, hướng về phía trước nhảy đến trọng liên đỉnh, nếu trước mặt tiết điểm không ở trọng liên thượng, hướng về phía trước nhảy một cái tiết điểm. Như thế thẳng đến hai tiết điểm tương đồng. Ven đường đổi mới / tuần tra khu gian tin tức.

Đối với mỗi cái dò hỏi, nhiều nhất trải quaĐiều trọng liên, mỗi điều trọng liên thượng tuyến đoạn thụ phức tạp độ vì,Bởi vậy tổng thời gian phức tạp độ vì.Trên thực tế trọng liên cái số rất khó đạt tới( có thể dùng hoàn toàn nhị xoa thụ tạp mãn ), cho nên thụ mổ ở trong tình huống bình thường hằng số nhỏ lại.

Cấp ra một loại số hiệu thực hiện:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// st là đoạn thẳng thụ kết cấu thể
intquerymax(intx,inty){
intret=-inf,fx=top[x],fy=top[y];
while(fx!=fy){
if(dep[fx]>=dep[fy])
ret=max(ret,st.query1(1,1,n,dfn[fx],dfn[x])),x=fa[fx];
else
ret=max(ret,st.query1(1,1,n,dfn[fy],dfn[y])),y=fa[fy];
fx=top[x];
fy=top[y];
}
if(dfn[x]dfn[y])
ret=max(ret,st.query1(1,1,n,dfn[x],dfn[y]));
else
ret=max(ret,st.query1(1,1,n,dfn[y],dfn[x]));
returnret;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

#include&LTalgorithm>
#include&LTcstdio>
#include&LTcstring>
#define lc o
#define rc o
constintmaxn=60010;
constintinf=2e9;
intn,a,b,w[maxn],q,u,v;
intcur,h[maxn],nxt[maxn],p[maxn];
intsiz[maxn],top[maxn],son[maxn],dep[maxn],fa[maxn],dfn[maxn],rnk[maxn],
cnt;
charop[10];

voidadd_edge(intx,inty){// thêm biên
cur++;
nxt[cur]=h[x];
h[x]=cur;
p[cur]=y;
}

structSegTree{
intsum[maxn*4],maxx[maxn*4];

voidbuild(into,intl,intr){
if(l==r){
sum[o]=maxx[o]=w[rnk[l]];
return;
}
intmid=(l+r)>>1;
build(lc,l,mid);
build(rc,mid+1,r);
sum[o]=sum[lc]+sum[rc];
maxx[o]=std::max(maxx[lc],maxx[rc]);
}

intquery1(into,intl,intr,intql,intqr){// tuần tra max
if(l>qr||rql)return-inf;
if(qll&&rqr)returnmaxx[o];
intmid=(l+r)>>1;
returnstd::max(query1(lc,l,mid,ql,qr),query1(rc,mid+1,r,ql,qr));
}

intquery2(into,intl,intr,intql,intqr){// tuần tra sum
if(l>qr||rql)return0;
if(qll&&rqr)returnsum[o];
intmid=(l+r)>>1;
returnquery2(lc,l,mid,ql,qr)+query2(rc,mid+1,r,ql,qr);
}

voidupdate(into,intl,intr,intx,intt){// đổi mới
if(l==r){
maxx[o]=sum[o]=t;
return;
}
intmid=(l+r)>>1;
if(xmid)
update(lc,l,mid,x,t);// tả hữu phân biệt đổi mới
else
update(rc,mid+1,r,x,t);
sum[o]=sum[lc]+sum[rc];
maxx[o]=std::max(maxx[lc],maxx[rc]);
}
}st;

voiddfs1(into){
son[o]=-1;
siz[o]=1;
for(intj=h[o];j;j=nxt[j])
if(!dep[p[j]]){
dep[p[j]]=dep[o]+1;
fa[p[j]]=o;
dfs1(p[j]);
siz[o]+=siz[p[j]];
if(son[o]==-1||siz[p[j]]>siz[son[o]])son[o]=p[j];
}
}

voiddfs2(into,intt){
top[o]=t;
cnt++;
dfn[o]=cnt;
rnk[cnt]=o;
if(son[o]==-1)return;
dfs2(son[o],t);
for(intj=h[o];j;j=nxt[j])
if(p[j]!=son[o]&&p[j]!=fa[o])dfs2(p[j],p[j]);
}

intquerymax(intx,inty){// tuần tra, xem main hàm số lý giải một chút
intret=-inf,fx=top[x],fy=top[y];
while(fx!=fy){
if(dep[fx]>=dep[fy])
ret=std::max(ret,st.query1(1,1,n,dfn[fx],dfn[x])),x=fa[fx];
else
ret=std::max(ret,st.query1(1,1,n,dfn[fy],dfn[y])),y=fa[fy];
fx=top[x];
fy=top[y];
}
if(dfn[x]dfn[y])
ret=std::max(ret,st.query1(1,1,n,dfn[x],dfn[y]));
else
ret=std::max(ret,st.query1(1,1,n,dfn[y],dfn[x]));
returnret;
}

intquerysum(intx,inty){
intret=0,fx=top[x],fy=top[y];
while(fx!=fy){
if(dep[fx]>=dep[fy])
ret+=st.query2(1,1,n,dfn[fx],dfn[x]),x=fa[fx];
else
ret+=st.query2(1,1,n,dfn[fy],dfn[y]),y=fa[fy];
fx=top[x];
fy=top[y];
}
if(dfn[x]dfn[y])
ret+=st.query2(1,1,n,dfn[x],dfn[y]);
else
ret+=st.query2(1,1,n,dfn[y],dfn[x]);
returnret;
}

intmain(){
scanf("%d",&n);
for(inti=1;in;i++)
scanf("%d%d",&a,&b),add_edge(a,b),add_edge(b,a);
for(inti=1;in;i++)scanf("%d",w+i);
dep[1]=1;
dfs1(1);
dfs2(1,1);
st.build(1,1,n);
scanf("%d",&q);
while(q--){
scanf("%s%d%d",op,&u,&v);
if(!strcmp(op,"CHANGE"))st.update(1,1,n,dfn[u],v);
if(!strcmp(op,"QMAX"))printf("%d\n",querymax(u,v));
if(!strcmp(op,"QSUM"))printf("%d\n",querysum(u,v));
}
return0;
}

Nauuo and Binary Tree

Đây là một đạo lẫn nhau đề, cũng là thụ mổ phi truyền thống ứng dụng.

Đề mục đại ý

Có một cây lấyLàm gốc nhị xoa thụ, ngươi có thể dò hỏi tùy ý hai điểm chi gian khoảng cách, cầu ra mỗi cái điểm phụ thân.

Tiết điểm số không vượt qua,Ngươi nhiều nhất có thể tiến hànhThứ dò hỏi.

Giải pháp

Đầu tiên có thể thông quaThứ dò hỏi xác định mỗi cái tiết điểm chiều sâu.

Sau đó suy xét ấn chiều sâu từ nhỏ đến lớn xác định mỗi cái tiết điểm phụ thân, nói như vậy xác định một cái tiết điểm phụ thân khi này sở hữu tổ tiên nhất định đều là đã biết.

Xác định một cái tiết điểm phụ thân phía trước, trước đối thụ đã biết bộ phận tiến hành trọng liên mổ phân.

Giả thiết chúng ta yêu cầu ở tử thụTrung tìm tiết điểmNơi vị trí, chúng ta có thể dò hỏiCùngNơi trọng liên phần đuôi khoảng cách, liền có thể tiến thêm một bước xác địnhVị trí, cụ thể thấy đồ:

Trong đó màu đỏ hư tuyến là một cái trọng liên,Là dò hỏi kết quả tức,Chiều sâu vì.

Nói như vậy, nếuChỉ có một cái nhi tử,Phụ thân chính là,Nếu không có thể đệ quy mà ởTử thụ trung tìmPhụ thân.

Thời gian phức tạp độ,Dò hỏi phức tạp độ.

Cụ thể mà, thiếtVì nhất hư dưới tình huống ở một cây lớn nhỏ vìThụ trung tìm được một cái tân tiết điểm vị trí sở cần dò hỏi số lần, có thể được đến:

,Trên thực tế cái này thượng giới là có thể thông qua cấu tạo số liệu đạt tới, nhưng mà chỉ cần tiến hành một ít tùy cơ nhiễu loạn ( như đối chiều sâu tiến hành bài tự khi sử dụng không ổn định bài tự thuật toán ), dò hỏi số lần rất khó vượt quaThứ.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

#include&LTalgorithm>
#include&LTcstdio>
#include&LTiostream>

usingnamespacestd;

constintN=3010;

intn,fa[N],ch[N][2],dep[N],siz[N],son[N],bot[N],id[N];

intquery(intu,intv){
printf("?%d %d\n",u,v);
fflush(stdout);
intd;
scanf("%d",&d);
returnd;
}

voidsetFather(intu,intv){
fa[v]=u;
if(ch[u][0])
ch[u][1]=v;
else
ch[u][0]=v;
}

voiddfs(intu){
if(ch[u][0])dfs(ch[u][0]);
if(ch[u][1])dfs(ch[u][1]);

siz[u]=siz[ch[u][0]]+siz[ch[u][1]]+1;

if(ch[u][1])
son[u]=int(siz[ch[u][0]]siz[ch[u][1]]);
else
son[u]=0;

if(ch[u][son[u]])
bot[u]=bot[ch[u][son[u]]];
else
bot[u]=u;
}

voidsolve(intu,intk){
if(!ch[u][0]){
setFather(u,k);
return;
}
intd=query(k,bot[u]);
intv=bot[u];
while(dep[v]>(dep[k]+dep[bot[u]]-d)/2)v=fa[v];
intw=ch[v][son[v]^1];
if(w)
solve(w,k);
else
setFather(v,k);
}

intmain(){
inti;

scanf("%d",&n);

for(i=2;in;++i){
id[i]=i;
dep[i]=query(1,i);
}

sort(id+2,id+n+1,[](intx,inty){returndep[x]dep[y];});

for(i=2;in;++i){
dfs(1);
solve(1,id[i]);
}

printf("!");
for(i=2;in;++i)printf("%d",fa[i]);
printf("\n");
fflush(stdout);

return0;
}

Trường liên mổ phân

Trường liên mổ phân bản chất chính là mặt khác một loại liên mổ phân phương thức.

Định nghĩaHạt cơ bản tiết điểmTỏ vẻ này tử tiết điểm trúng tử thụ chiều sâu lớn nhất tử giao điểm. Nếu có bao nhiêu vóc dáng thụ lớn nhất tử giao điểm, lấy thứ nhất. Nếu không có tử tiết điểm, liền vô hạt cơ bản tiết điểm.

Định nghĩaNhẹ tử tiết điểmTỏ vẻ còn thừa tử giao điểm.

Từ cái này giao điểm đến hạt cơ bản tiết điểm biên vìTrọng biên.

Đến mặt khác nhẹ tử tiết điểm biên vìNhẹ biên.

Bao nhiêu điều đầu đuôi hàm tiếp trọng biên cấu thànhTrọng liên.

Đem lạc đơn giao điểm cũng làm như trọng liên, như vậy chỉnh cây đã bị mổ phân thành bao nhiêu điều trọng liên.

Như đồ ( loại này mổ phân phương thức đã có thể xem thành trọng liên mổ phân cũng có thể xem trưởng thành liên mổ phân ):

Trường liên mổ phân thực hiện phương thức cùng trọng liên mổ phân loại tựa, nơi này liền không hề triển khai.

Thường thấy ứng dụng

Đầu tiên, chúng ta phát hiện trường liên mổ phân từ một cái tiết điểm đến căn đường nhỏ nhẹ biên cắt điều số làCấp bậc.

Trường liên mổ phân ưu hoá DP

Trong tình huống bình thường có thể sử dụng trường liên mổ phân tới ưu hoá DP sẽ có một duy trạng thái vì chiều sâu duy.

Chúng ta có thể suy xét sử dụng trường liên mổ phân ưu hoá trên cây DP.

Cụ thể, chúng ta mỗi cái tiết điểm trạng thái trực tiếp kế thừa này trọng nhi tử tiết điểm trạng thái, đồng thời đem nhẹ nhi tử DP trạng thái bạo lực xác nhập.

Chú ý, trong tình huống bình thường DP số tổ nội tồn phân phối vì một cái trọng liên chỉnh thể phân phối nội tồn, liên thượng bất đồng tiết điểm có bất đồng thủ vị trí kim đồng hồ.

DP số tổ chiều dài chúng ta có thể căn cứ tử thụ sâu nhất tiết điểm tính ra.

Ví dụ mẫu tham khảo số hiệu:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

#include&LTbits/stdc++.h>
usingnamespacestd;
constintN=1000005;

structedge{
intto,next;
}e[N*2];

inthead[N],tot,n;
intd[N],fa[N],mx[N];
int*f[N],g[N],mxp[N];
intdfn[N];

voidadd(intx,inty){
e[++tot]=(edge){y,head[x]};
head[x]=tot;
}

voiddfs1(intx){// lần đầu tiên cắm vào một cái 1
d[x]=1;
for(inti=head[x];i;i=e[i].next)
if(e[i].to!=fa[x]){
fa[e[i].to]=x;
dfs1(e[i].to);
d[x]=max(d[x],d[e[i].to]+1);
if(d[e[i].to]>d[mx[x]])mx[x]=e[i].to;
}
}

voiddfs2(intx){// lần thứ hai xác nhập
dfn[x]=++*dfn;
f[x]=g+dfn[x];
if(mx[x])dfs2(mx[x]);
for(inti=head[x];i;i=e[i].next)
if(e[i].to!=fa[x]&&e[i].to!=mx[x])dfs2(e[i].to);
}

voidgetans(intx){// bạo lực xác nhập tính đáp án
if(mx[x]){
getans(mx[x]);
mxp[x]=mxp[mx[x]]+1;
}
f[x][0]=1;
if(f[x][mxp[x]]1)mxp[x]=0;
for(inti=head[x];i;i=e[i].next)
if(e[i].to!=fa[x]&&e[i].to!=mx[x]){
getans(e[i].to);
intlen=d[e[i].to];
for(intj=0;jlen-1;j++){
f[x][j+1]+=f[e[i].to][j];
if(f[x][j+1]>f[x][mxp[x]])mxp[x]=j+1;
if(f[x][j+1]==f[x][mxp[x]]&&j+1mxp[x])mxp[x]=j+1;
}
}
}

intmain(){
scanf("%d",&n);
for(inti=1;in;i++){
intx,y;
scanf("%d%d",&x,&y);
add(x,y);
add(y,x);
}
dfs1(1);
dfs2(1);
getans(1);
for(inti=1;in;i++)printf("%d\n",mxp[i]);
}

Đương nhiên trường liên mổ phân ưu hoá DP kỹ xảo rất nhiều, bao gồm nhưng là không chỉ có giới hạn trong đánh đánh dấu từ từ. Nơi này không hề triển khai.

Tham khảoThuê tô vũ blog.

Trường liên mổ phân cầu k cấp tổ tiên

Tức dò hỏi một cái điểm hướng phụ thân nhảyThứ nhảy đến tiết điểm.

Đầu tiên chúng ta giả thiết chúng ta đã dự xử lý mỗi một cái tiết điểmCấp tổ tiên.

Hiện tại chúng ta giả thiết chúng ta tìm được rồi dò hỏi tiết điểmCấp tổ tiên thỏa mãn.

Chúng ta suy xét cầu ra này nơi trọng liên tiết điểm hơn nữa dựa theo chiều sâu xếp vào bảng biểu. Giả thiết trọng liên chiều dài vì.

Đồng thời chúng ta ở dự xử lý thời điểm tìm được mỗi điều trọng liên căn tiết điểmĐếnCấp tổ tiên, đồng dạng để vào bảng biểu.

Căn cứ trường liên mổ phân tính chất,,Nói cách khác, chúng ta có thểTại đây điều trọng liên bảng biểu thượng cầu ra cái này tiết điểmCấp tổ tiên.

Dự xử lý yêu cầu tăng gấp bội raThứ cấp tổ tiên, đồng thời yêu cầu dự xử lý mỗi điều trọng liên đối ứng bảng biểu.

Dự xử lý phức tạp độ,Dò hỏi phức tạp độ.

Luyện tập

“Lạc cốc P3379” 【 khuôn mẫu 】 gần nhất công cộng tổ tiên ( LCA )( thụ mổ cầu LCA không cần số liệu kết cấu, có thể dùng làm luyện tập )

“JLOI2014” sóc tân gia( đương nhiên cũng có thể dùng trên cây kém phân )

“HAOI2015” trên cây thao tác

“Lạc cốc P3384” 【 khuôn mẫu 】 trọng liên mổ phân / thụ liên mổ phân

“NOI2015” phần mềm bảo đảm lý khí

“SDOI2011” nhuộm màu

“SDOI2014” lữ hành

“POI2014” Hotel tăng mạnh bản( trường liên mổ phân ưu hoá DP )

Công lược( trường liên mổ phân ưu hoá lòng tham )

Bổn giao diện gần nhất đổi mới:2023/7/17 19:14:32,Đổi mới lịch sử
Phát hiện sai lầm? Tưởng cùng nhau hoàn thiện?Ở GitHub thượng biên tập này trang!
Bổn giao diện cống hiến giả:Marcythm,dkz051,ftxj,GoodCoder666,greyqz,hsfzLZH1,hyp1231,Ir1d,LuoshuiTianyi,ouuan,sshwy,StudyingFather,Xeonacid,2997ms,Alexander-a-l,CCXXXI,Chrogeek,ChungZH,countercurrent-time,Early0v0,Enter-tainer,fearlessxjdx,Great-designer,H-J-Granger,Henry-ZHR,kenlig,ksyx,Macesuted,mao1t,Menci,mgt,NachtgeistW,SukkaW,Tiphereth-A,zhouyuyang2002
Bổn giao diện toàn bộ nội dung ởCC BY-SA 4.0CùngSATAHiệp nghị chi điều khoản hạ cung cấp, phụ gia điều khoản cũng khả năng ứng dụng