树的直径，重心和基环树（2019.2.3）

基本概念（树的直径）：

   树是图论中的连通无环图，树上的任意两点间的路径是唯一的。树上的任意两点的距离是两点间路径的边权和。而树的直径（假设为MP）是树上的最长路径，M，P两点是树上距离最远的点。

算法（树的直径）：

   两次BFS或DFS:从树上的的任意一点C出发找到离它最远的一个点A，再从点A开始寻找离它最远的点B，AB的距离就是树的直径。

证明：只需要证明M点是树的直径的一个端点，那么MP就是树的直径了。通过反证法，假设M不是端点，AB才是树的直径。那么

  

    1.如果P是AB上的点，PM>PB,如图,则AM>AB，假设不成立。

     2.MP和AB间有公共点T，PT + TM > PT + TB，则TM > TB，则AM>AB,假设不成立。

     3.AB与MP平行，点PC + CM > PC + CD + BD，则CM > CD + BD， CM + CD > BD 故CM + CD + AD > BD + AD = AB,AB不是最长的。

    树的直径代码实现：

    1.老师的

2.我的：Poj 1985 Cow Marathon（树的直径模板题）

#include<bits/stdc++.h> 
using namespace std;
struct E
{
	int from,to,t,next;
}e[100000];
int d[50001],a[50001],b[50001],n,m;
int ans=0,num,T;
int x,y,z;
char c[2];
inline void work(int u,int v,int w)
{
	e[num].from =u;
	e[num].to =v;
	e[num].t =w;
	e[num].next=b[u];
	b[u]=num++;
}
inline void bfs(int s)
{
	memset(a,0,sizeof(a));
	memset(d,0,sizeof(d));
	queue<int>q;
	q.push(s);
	a[s]=1;
	ans=0;
	while(!q.empty())
	{
		int u,v;
		u=q.front();
		q.pop();
		for(int i=b[u];i!=-1;i=e[i].next)
		{
			v=e[i].to;
			if(!a[v])
			{
				if(d[v]<d[u]+e[i].t)
				d[v]=d[u]+e[i].t;
				a[v]=1;
				q.push(v);
			}
		}
	}
	for(int i=1;i<=n;i++)
	{
		if(ans<d[i])
		{
			ans=d[i];
			T=i;
		}
	}
}
int main()
{
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		num=1;
		memset(b,-1,sizeof(b));
		for(int i=0;i<m;i++)
		{
			scanf("%d%d%d%s",&x,&y,&z,c);
			work(x,y,z);
			work(y,x,z);
		}
		bfs(1);
		bfs(T);
		printf("%d\n",ans);
	}
	return 0;
}

树的重心：树的重心也叫树的质心。对于一棵树n个节点的无根树，找到一个点，使得把树变成以该点为根的有根树时，最大子树的结点数最小。换句话说，删除这个点后最大连通块（一定是树）的结点数最小。

树的重心可以通过两边搜索得出，第一次搜索每个节点的子节点数，第二次找出删去x吼最大子树的节点数，，可在一次遍历中同时完成。代码实现：老师的。

我的：POJ1655（树的重心模板

#include<iostream>
#include<string.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
#include<cstring>
#include<algorithm>
using namespace std;
int n;
vector<int> G[20010];
int a[20010];   
int b[20010];   
int c[20010];
inline void work()
{
    for (int i=1;i<=n;i++) G[i].clear();
    for (int i=1;i<=n;i++) a[i]=1;
    memset(c,0,sizeof(c));
    memset(b,0,sizeof(b));
}
 
inline int dfs(int x)
{
    c[x]=1;
    for (int i=0;i<G[x].size();i++)
    {
        int v=G[x][i];
        if (c[v]==0) a[x]+=dfs(v);
    }
    return a[x];
}
inline void DFS(int i,int x)
{
    for(int j=0;j<G[i].size();j++)
    {
        int v=G[i][j];
        if (v==x) b[i]=max(b[i],a[1]-a[i]);
        else
        {
            b[i]=max(b[i],a[v]);
            DFS(v,i);
        }
    }
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n;
        if (n==1)
            cout<<1<<' '<<0<<endl;
        else if (n==2)
        {
            int a,b;
            cin>>a>>b;
            cout<<1<<' '<<1<<endl;
        }
        else
        {
            work();
            for (int i = 0; i < n - 1;i++)
            {
                int a,b;
                cin>>a>>b;
                G[a].push_back(b);
                G[b].push_back(a);
            }
            dfs(1);
            DFS(1,-1);
            int ans=0x3f3f3f3f;
            int A5010S=0;
            for (int i=1;i<= n;i++)
            {
                if (b[i]<ans)
                {
                    ans=b[i];
                    A5010S=i;
                }
            }
            cout<<A5010S<<' '<<ans<<endl;
        }
    }
    return 0;
}

基环树：基环树是一种图，它由一个环组成，环上每个点都是一棵树点树 根，所以称为基环树。当然，一棵树上连一条边也会变成基环树。基环树分环和树来处理，首先找环。

 

基环树分为两种：

基环内向树：有向图，在基环树的基础上每个节点的出度为1。

基环外向树：有向图，在基环树的基础上每个节点的入度为1。