图论:树(总)

一.树的基本性质

充要条件:即可以正推(因->果),也可以逆推(果->因)的结论

1.树是连通、无环图。如果只无环,那么这个图一定是森林结构(充要)

(森林结构:几个不连通的树,至少有一个)

2.树顶点数为n,边数为n-1,如果是森林则边数<=n-1(必须是无环图才是充要条件)

(忽略有向图)

二.树上倍增

树上倍增是ST表最经典应用拓展之一,由于树结构有父亲下面的节点是儿子的单调性,因此可以使用倍增算法。

http://t.csdnimg.cn/2FhLi

代码:某个节点往上跳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;
        }
    }
}

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值