POJ 3099 Go Go Gorelians

http://poj.org/problem?id=3099

树的重心：找到一个点,其所有的子树中最大的子树节点数最少,那么这个点就是这棵树的重心

求树的重心

如何在点中构造符合条件的树

得到树后 从任意一个点出发 dfs一次找到离这个点最远的点作为root1

在以root1出发 同样的方式求得root2

root1-root2就是这个树的直径 那么中心必然在这个直径上， 如果直径上点的个数是奇数的话那么 这个点就是重心 否则有两个重心 分别输出

 #include <iostream>
 #include <string.h>
 #include <stdio.h>
 #include <vector>
 #include <math.h>
 #define MAXN 1007

 using namespace std;

 int dp[MAXN];
 int id[MAXN];
 int pre[MAXN];
 double dist[MAXN][MAXN];
 double x[MAXN], y[MAXN], z[MAXN];
 int path[MAXN];
 int n;
 vector<int> G[MAXN];

 double getdis(int i, int j)
 {
     double dx = x[i] - x[j];
     double dy = y[i] - y[j];
     double dz = z[i] - z[j];
     return sqrt(dx*dx+dy*dy+dz*dz);
 }

 void build()
 {
     for(int i = ; i < n; i++)
     {
         double dis = 0x3fffffff;
         int obj = -;
         for (int j = ; j < i; j++)
         {
             if (dist[id[i]][id[j]] < dis)
             {
                 dis = dist[id[i]][id[j]];
                 obj = j;
             }
         }
         if (obj == -) continue;
         int u = id[i], v = id[obj];
         G[u].push_back(v);
         G[v].push_back(u);
     }
 }
 void dfs(int x, int par, int len)
 {
     dp[x] = len;
     for (int i = ; i < G[x].size(); i++)
     {
         if (G[x][i] != par)
             dfs(G[x][i], x, len+);
     }

 }

 void dfs1(int x, int par, int len)
 {
     dp[x] = len;
     pre[x] = par;
     for (int i = ; i < G[x].size(); i++)
     {
         if(G[x][i] != par)
             dfs1(G[x][i], x, len+);
     }
 }
 int main()
 {
     while (~scanf("%d", &n))
     {
         if (n == ) break;
         memset(dp, , sizeof(dp));
         memset(path, , sizeof(path));
         memset(dist, , sizeof(dist));
         memset(pre, , sizeof(pre));
         for (int i = ; i < MAXN; i++)
             G[i].clear();
         for (int i = ; i < n; i++)
         {
             scanf("%d%lf%lf%lf", &id[i], &x[i], &y[i], &z[i]);
         }
         for (int i = ; i < n; i++)
             for (int j = ; j < n; j++)
                 dist[id[i]][id[j]] = getdis(i, j);
         build();
         dfs(id[], -, );//权值都为1
         int tmp = ;
         //找到离节点最远的节点 得到root1
         int root1, root2;
         for (int i = ; i < n; i++)
         {
             if ( dp[id[i]] > tmp)
             {
                 tmp = dp[id[i]];
                 root1 = id[i];
             }
         }
         memset(dp, , sizeof(dp));
         dfs1(root1, -, );
         tmp = ;
         for (int i = ; i < n; i++)
         {
             if (dp[id[i]] > tmp)
             {
                 tmp = dp[id[i]];
                 root2 = id[i];
             }
         }//找到root2;
         int s = ;
         for(int i = root2; i != -; i = pre[i])
         {
             path[++s] = i;
         }
         int mid = (s+)/;
         if (s %  == )
         {
             printf("%d\n", path[mid]);
         }
         else
         {
             int a = path[mid], b = path[mid+];
             printf("%d %d\n", min(a, b), max(a, b));
         }

     }

     return ;
 }

关于树的重心更多的内容

转载 ：http://www.cnblogs.com/patrickzhou/p/5867208.html