图论：树（总）

一.树的基本性质

充要条件：即可以正推（因->果），也可以逆推（果->因）的结论

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;
        }
    }
}