树

下面我们来介绍一般意义上的树，

包括有根树 和 无根树；

---

有根树基本操作：

vector实现：

const int N = 100001;

VI edges[N + 1];
//数组里面的每一个元素都是一个vector，就是用vector来存树，当然也可以用链表来存
//edges[i]（这是个vector）就代表第i个点的所有子节点的下标
int n, father[N + 1];//n代表树里面有多少个节点，father[]代表节点的父节点编号

void addEdge(int x, int y){
    edges[x].pb(y);//给x节点添加一个儿子y
    father[y] = x;//更新y的父节点信息（对于有根树而言）
    return;
}

void PrintSon1(int x){
    //遍历x的所有儿子
    int cntson = edges[x].size();
    for (int i = 0;i < cntson;i++){
        cout << edges[x][i] << " ";
    }
    return;
}

void PrintSon2(int x){
    //更简洁的写法
    for (auto i : edges[x]){
        cout << edges[x][i] << " ";
    }
    return;
}

VI dfn;//有根树的DFS序
void DFS(int x){
    dfn.pb(x);
    for (/*x的所有儿子y*/){
        DFS(y);
    }
    return;
}
//DFS(root);


//有根树的BFS序
void BFS(int root){
    //将root加入队列q
    while(!q.empty()){
        //x = q队首元素;
        //x出队;
        for (/*x的所有儿子y*/){
            //y入队;
        }
    }
    return;
}

//BFS(root);
//q中出现的元素顺序即BFS序

---

链表实现：

const int N = 100001;
const int M = 100001;

struct Node{
    int where;//记录Node的下标
    Node *next;
} *head[N + 1], a[M];//a[M]与a[N]在有根树内等价，a[]用来存Node
//head[i] -> son -> sonson -> sonsonson...

int n, father[N + 1], l = 0;

void addEdge(int x, int y){
    a[++l].where = y;//先++
    a[l].next = head[x];
    head[x] = &a[l];
    father[y] = x;
    return;
}

void PrintSon(int x){
    for (Node *p = head[x]; p; p = p->next){
        cout << p->where << " ";
    }
    return;
}

void DFS2(int from, int x){
    for (/*x的所有相邻节点y*/){
        if (y ！= from){
            DFS2(x, y);
        }
    }
    return;
}
//DFS(-1, x);

void BFS2(int x){
    //将x加入队列q，x的来源节点为空
    while(!q.empty()){
        /*
        x = q队首元素
        from = x的来源节点
        x出队
        */
        for (/*x的所有相邻节点y*/){
            if (y != from){
                //y入队
                //y的来源节点为x
            }
        }
    }
    return;
}
//BFS(x); 

---

无根树的求树上路径模板题：

inline int rd(){
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9') {if(ch=='-')f=-1; ch=getchar();}
    while (ch>='0'&&ch<='9'){x=(x<<3)+(x<<1)+ch-'0'; ch=getchar();}
    return x*f;
}

const int N = 1000001;
VI edges[N + 1];
int pre[N + 1], l, c[N + 1];

inline void DFS(int x){
    for (auto i : edges[x]){
        if (i != pre[x]){
            pre[i] = x;
            DFS(i);
        }
    }
}

int main(){
    ios;
    int n, x, y, u, v;
    n = rd();
    for (int i = 1;i <= n - 1;i++){
        x = rd();
        y = rd();
        edges[x].pb(y);
        edges[y].pb(x);
    }
    u = rd();
    v = rd();
    pre[u] = -1;
    DFS(u);
    l = 0;
    for (int i = v;i != u;i = pre[i]){
        c[++l] = i;
    }
    c[++l] = u;
    for (int i = l; i;--i){
        cout << c[i] << " ";
    }
    return 0;
}

 

---

 

接下来我们说一说树的直径：

树的直径是指树上任意两个节点之间最长（经过边的数量）的路径。

一棵树可以存在很多条直径，其长度相等。

树的直径的中间节点被称为树的中心，如果直径上的节点总数是偶数，则有两个中心。

树的中心到其他点的最长路径最短。

 

树的直径可以用两次搜索求得，第一次从任意节点开始搜索，找出距离最远的节点a；

第二次从节点a出发，找到距离节点a最远的节点b，则路径a-b即为树的直径。

（反证法可证）

 

---

 

然后我们把时间交给树的重心

对于一颗无根树而言，当一个节点被选为根节点时，

它底下每个子节点的子树的大小（子树包含的节点数目）的最大值最小的那个节点，

被称为树的重心。

一棵树有可能有一个或两个重心。

 

树的重心有以下性质：

　　当重心为根节点时，它底下的每个子树的大小不大于整棵树大小的一半；

　　重心到其他所有节点的距离之和（路径长度）最小；

树的重心可以通过枚举根节点，然后递归求出所有子节点的子树大小，最后进行比较得到。