【网络中心】解题报告

                                网络中心

【问题描述】

      计算机网络最初只有一台计算机，以后联入计算机网络的每台计算机都与
一台已连入网络的计算机相连。每台新联入的计算机得到一个序号，并且知道与
其连接的那台计算机的序号。因此，协议是由N-1个数字组成，这些数的第一个
总是1，因为第二台计算机仅能连在第一台计算机上，第二个数是1或者2等等。
协议的总数是N－1（N是计算机的总台数）。例如，协议1，1，2，2是根据下列
网络得到的：

                                    1-2-5
                                    | |
                                    3 4

      计算机之间的距离是在链中相互连接的数目（在两计算机之间），这样，在
上例中，计算机＃4和＃5间的距离是2，计算机＃3和＃5的距离是3。
      定义：网络的中心是指到最远计算机距离最小的计算机。在例子中计算机
＃1和＃2是网络的中心。

     问题：你的任务是将给出协议的所有中心找出来。数据范围：N是一个整数，
且1<N<=10000

【输入文件】

    输入的第一个数是N——网络中计算机数量，下面N-1个数是对协议的描述。

【输出文件】

    以递增的顺序输出网络中心的数字。

【输入样例】

    5
    1
    1
    2
    2

【输出样例】

    1 2

有点意思。。

这道题我用的方法是类似于树网的核，在直径上找点。

可以证明，A-B，A-D，比E-B，E-D长。且E-A比E-B、E-D短。

所以到最远点最短的点一定在直径上。

（两次dfs求直径。我使用数组来记录方案，但是据王哥说，用父亲表示法即可维护出方案。这个应该好一些。以后就采取这个了）

然后就是这里没有想清楚：同时可以证明E的最远点的距离小于C到最远点的距离。

（中位数的思想，每条边权值为1）

一开始我是对直径上每一个点都进行dfs，找到他们距距最远点的距离，这个代价有点大。（而且写错了）

可以简单处理为如果直径上的点数量为偶数，则取中间两个，若为奇数，则取中间。

改了这一点之后就AC了。

另外，我忽略了一个问题，就是树的直径可能有多条。

不过经孙川说，数的直径可能有多条，但是只会交于一点。因此解是唯一的。

（那如果是偶数个点怎么办？）

//#include <iostream>
//using std::cout;
//using std::cin;
#include <cstdio>
#include <cstdlib>
struct ftv
{
    long f;
    long t;
//    long v;
};
const long oo = 0x7fff0000;
long max = -oo;
long k = 0;
long fa[10002];
ftv bian[10002];
long fangan[10002];
long zhijing[10002];
bool used[10002];
long start[10002];
long m;long n;

long min = oo;
ftv dist[10002];

void dfs(long l,long s)
{
    if (max<s)
    {
        max=s;k=l;
        for (long i=1;i<s+1;i++)
        {
            zhijing[i] = fangan[i];
        }
    }
    for (long i=start[l];i<m+1;i++)
    {
        if (bian[i].f!=l) break;
        if (!used[bian[i].t])
        {
            fangan[s+1] = bian[i].t;
            used[bian[i].t]=true;
            dfs(bian[i].t,s+1);
            used[bian[i].t]=false;
        }
    }
    if(!used[fa[l]]&&fa[l]!=0)
    {
        fangan[s+1]=fa[l];
        used[fa[l]] = true;
        dfs(fa[l],s+1);
        used[fa[l]] = false;
    }
}

void dfs1(long l,long s)
{
    if (max<s)
    {
        max=s;k=l;
    }
    for (long i=start[l];i<m+1;i++)
    {
        if (bian[i].f!=l) break;
        if (!used[bian[i].t])
        {
            used[bian[i].t]=true;
            dfs1(bian[i].t,s+1);
            used[bian[i].t]=false;
        }
    }
    if(!used[fa[l]]&&fa[l]!=0)
    {
        used[fa[l]] = true;
        dfs1(fa[l],s+1);
        used[fa[l]] = false;
    }
}

int bigger(const void* a,const void* b)
{
    ftv* aa = (ftv*)a;
    ftv* bb = (ftv*)b;
    long aaa= aa->f;
    long bbb= bb->f;
    if (aaa>bbb)
        return 1;
    if (aaa==bbb)
        return 0;
    return -1;
}

int main()
{
    freopen("net.in","r",stdin);
    freopen("net.out","w",stdout);
    
    scanf("%ld",&n);
    //=================
    if (n==1){printf("1");return 0;}
    //==================
    for (long i=2;i<n+1;i++)
    {
        long t;
        scanf("%ld",&t);
        fa[i] = t;
        bian[++m].f = t;
        bian[m].t = i;
    }
    qsort(bian+1,m,sizeof(ftv),&bigger);
    for (long i=1;i<m+1;i++)
        if (start[bian[i].f]==0)
            start[bian[i].f]=i;
    used[1] = true;
    dfs1(1,0);
    used[1] = false;
    max = -oo;
    used[k] = true;
    zhijing[0] = k;
    used[k] = true;
    dfs(k,0);
    used[k] = false;
    dist[0].t = max;
    dist[0].f = zhijing[0];
    dist[max].t = max;
    dist[max].f = k;
    
    long tot = max;
    
    for (long i=1;i<tot;i++)
    {
        max = -oo;
        used[zhijing[i]]=true;
        dfs1(zhijing[i],0);
        used[zhijing[i]]=false;
        dist[i].t = max;
        dist[i].f = zhijing[i];
        if (max < min)
            min = max;
    }/*
    for (long i=0;i<tot+1;i++)
    {
        if (dist[i].t!=min)
            dist[i].t=oo;
    }
    qsort(dist,tot+1,sizeof(ftv),&bigger);
    for (long i=0;i<tot+1;i++)
    {
        if (dist[i].t<oo)
            printf("%ld ",dist[i].f);
    }*/
    if (tot%2==0)
        printf("%ld",zhijing[tot/2]);
    else
        printf("%ld %ld",zhijing[tot/2+1],zhijing[tot/2]);
    return 0;
}