一.树的基本性质
充要条件:即可以正推(因->果),也可以逆推(果->因)的结论
1.树是连通、无环图。如果只无环,那么这个图一定是森林结构(充要)
(森林结构:几个不连通的树,至少有一个)
2.树顶点数为n,边数为n-1,如果是森林则边数<=n-1(必须是无环图才是充要条件)
(忽略有向图)
二.树上倍增
树上倍增是ST表最经典应用拓展之一,由于树结构有父亲下面的节点是儿子的单调性,因此可以使用倍增算法。
代码:某个节点往上跳k步是哪个节点
const int N = le5+10;
vector<int>tree;
int deep[N];
int st[N][30];
//建立ST表
void dfs(int cur,int fa){
deep[cur] = deep[fa]+1;
st[cur][0] = fa;
for(int i = 1;(1<<i)<=deep[cur];i++){
st[cur][i] = st[st[cur][i-1]][i-1];
}
for(int i = 0;i<tree[cur].size();i++){
if(tree[cur][i]!=fa){
dfs(tree[cur][i],cur);
}
}
}
//查询,从当前cur节点往上跳k层
int query(int cur,int k){
int target = deep[cur]-k;
for(int i = 30;i>=0;i--){
if(deep[st[cur][i]]>=target){
cur = st[cur][i];
}
}
return cur;
}
三.LCA问题(最近公共祖先)
一.树上倍增解法
算法过程:
1.让两个点到达同一深度
2.让两个点一同往上走,保证不会到达相同的点
3.最后往上走最后一层
时间复杂度(mlogn)
const int N = le5+10;
vector<int>tree;
int deep[N];
int st[N][30];
//建立ST表
void dfs(int cur,int fa){
deep[cur] = deep[fa]+1;
st[cur][0] = fa;
for(int i = 1;(1<<i)<=deep[cur];i++){
st[cur][i] = st[st[cur][i-1]][i-1];
}
for(int i = 0;i<tree[cur].size();i++){
if(tree[cur][i]!=fa){
dfs(tree[cur][i],cur);
}
}
}
//求a,b的最近公共祖先
int lca(int a,int b){
if(deep[a]<deep[b]){
int t = a;
a = b;
b = t;
}
for(int i = 30;i>=0;i--){
if(deep[st[a][i]]>=deep[b]){
a = st[a][i];
}
}
if(a==b){
return a;
}
for(int i = 30;i>=0;i--){
if(st[a][i]!=st[b][i]){
a = st[a][i];
b = st[b][i];
}
}
return st[a][0];
}
二.tarjan算法
算法思想:
1.使用并查集来确定当前正在遍历子树的根,vis数组确定哪些节点访问过。
2.将每个问题记录两次(两个节点各记录一次),保证每个问题第一次没有处理掉,一定会在第二次处理。
时间复杂度(n+m)
const int N = len5+10;
int fa[N];//并查集
bool vis[N];//判断每个节点是否访问过
vector<int>tree;
vector<int>query;//每个节点的LCA问题
unordered_set<int>queryIndex;//每个LCA问题的索引,key是问题的两个节点
int ans[N];
//并查集查找祖先
int find(int i){
if(i==fa[i]){
return i;
}else{
fa[i] = find(fa[i]);
return fa[i];
}
}
void tarjan(int cur,int fa){
vis[cur] = true;
for(int i = 0;i<tree[cur].size();i++){
int t = tree[cur][i];
if(t!=fa){
tarjan(t,cur);
fa[t] = cur;
}
}
for(int i = 0;i<query[cur].size();i++){
int t = query[cur][i];
if(vis[t]){
ans[queryIndex[t]] = find(v);
}
}
}
四.树的重心
一.定义
树的重心,也可以理解成树的平衡点。
有以下三种定义:
1.以重心节点为根时,最大节点子树的节点数最小
2.以重心节点为根时,每颗子树的节点数小于总结点的一半
3.以重心节点为根时,所有节点走向根的路程最短
二.性质
1.树的重心最多有两个,且两个一定相邻
2.增加或删除一个叶节点,重心最多移动一条边
3.如果把两颗树连接起来,新树重心一定在原来两颗树的重心的路径上
4.重心与点权有关,与边权无关(边权>0,重心仍是所有节点汇聚路程最短的点)
三.代码
第一种定义求树的重心
#define N 1e5
//假设树的节点数为N,且树已经建好
vector<int>tree[N];
int siz[N];
int best= 0,center;//假设只需求一个重心
void dfs(int cur,int fa){
siz[cur] = 1;//当求有点权的树的重心时,只需要把1变为该点的权重
int big = 0;
for(int i = 0;i<tree[cur].size();i++){
int v = tree[cur][i];
if(v!=fa){
dfs(v,cur);
siz[cur]+=siz[v];
big = max(big,siz[v]);
}
}
big = max(big,N-siz[cur]);
if(big>best){
best = big;
center = cur;
}
}
五.树的直径
一.定义
树上距离最远的两个点之间的路径,叫树的直径。
二.性质
1.如果一棵树包含多个直径,那么这些直径之间一定有公共部分。
2.树上任意一点,离他最远的点的集合,树的直径的两端至少有一个在里面。
三.代码
1.两次DFS
过程:一次求离根最远的点,另一次一最远点为根,再求一次最远点(性质二)。
优点:可以得到树的直径以及沿途的所有点
缺点:不能处理边权为负的树
const int N = 1e5;
vector<piar<int,int>>tree[N];
int root;
int dist[N];
int a,b;//直径两端的点
void dfs(int cur,int fa){
dist[cur] = dist[fa];
for(int i = 0;i<tree[cur].size();i++){
int v = tree[cur][i].first,w = tree[cur][i].second;
if(v==fa){
dist[cur]+=w;
}
dfs(v,cur);
}
}
int main(){
dist[root] = 0;
dfs(root,-1);
int maxv = 0;
for(int i = 0;i<N;i++){
if(maxv<dist[i]){
maxv = dist[i];
a = i;
}
}
dist[a] = 0;
maxv = 0;
dfs(a,-1);
for(int i = 0;i<N;i++){
if(maxv < dist[i]){
maxv = dist[i];
b = i;
}
}
}