HDU 2196 Computer

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=2196

题目大意：

给定一棵树，求树上所有点到其他点的距离中的最大值。

解题思路：

思路1：

比较典型的树形DP

dp[i][0] ：以i节点为根节点的子树中，与i距离的最大值

dp[i][1]：以i节点为根节点的子树中，与i距离的次大值

dis[i]：    不在i的子树的其他节点中，与i距离的最大值

那么最后的结果应该就是：max(dp[i][0],dis[i]);

在求取最大值和次大值的时候，用dir[i]数组记录下节点i的最大值的来源。

思路2：

每个节点的最远距离肯定是与端点的最远距离。

开始的想法是找出所有的端点，即叶子节点。

然后从端点开始进行dfs，不断的更新其他节点的最大距离。

这个做法不可行，因为时间复杂读太大，如果叶子节点的数目过多的话，肯定会超时。

后来想，其实没必要找出所有的端点，只需要找出距离最远的两个端点即可。

证明如下：

假设j和k是找到的距离最远的两个端点。

a是树中的任意一点。

如果a点在j--k的最远路径上，那么a的最大距离肯定a--j或者是a--k。

如果a点不在j--k的最远路径上，用反证法，假设a--b是a的最远距离。

因为j--k是最远的距离，所以kj>bj，所以dk>bd。

ab=ac+cd+db;

ak=ac+cd+dk;

因为dk>db，所以ak>ab，所以a--b不是最远距离，a的最远距离是aj或者是ak。

证明可知，所有点的最远距离是到k或者到j的距离。

通过从k点和j点进行dfs去更新其他点的最远距离就能得到正确答案。

树形dp源代码:

//树形dp，建立有向树，有父亲节点和孩子节点
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<set>
#include<map>
#include<vector>
#include<algorithm>
#include<iostream>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long LL;
const double eps=1e-8;
int dp[10005][2];
//dp[i][1],表示以i为根节点的子树中，i点的最远距离
//dp[i][0],表示以i为根节点的子树中，i点的次远距离
int dis[10005];     //不在本子树中，存在的最远距离
//那么最后的结果就是max(dp[i][0],dis[i])
int dir[10005];     //记录最远距离来自的孩子节点
int N;
struct node
{
    vector<int> v;
    vector<int> child;
}c[10005];
void dfs1(int now)
{
    int i,j,k,t,size,child,max1,flag;
    size=c[now].child.size();
    if(dp[now][0])  return;
    if(size==0)     return;     //叶子节点的最远距离和次元距离都是0

    //求最长距离,先dfs，后处理。自下而上的更新
    max1=0;
    for(i=0;i<size;i++)
    {
        child=c[now].child[i];
        dfs1(child);
        if(max1<c[now].v[i]+dp[child][0])
        {
            max1=dp[child][0]+c[now].v[i];
            flag=child;
        }
    }
    dp[now][0]=max1;
    dir[now]=flag;      //记录最远距离来自的孩子节点，那么次远距离就不能是这个点

    //求次远距离
    max1=0;
    for(i=0;i<size;i++)
    {
        child=c[now].child[i];
        dfs1(child);
        if(child!=dir[now] && max1<dp[child][0]+c[now].v[i])
        {
            max1=dp[child][0]+c[now].v[i];
        }
    }
    dp[now][1]=max1;
    return;
}
void dfs(int now)
{
    int size,i,j,child;
    size=c[now].child.size();
    for(i=0;i<size;i++)
    {
        //先处理，后进行dfs，自上而下的更新
        child=c[now].child[i];
        if(dir[now]==child)
        //根节点是由该孩子节点更新过来的,那么只能由次远距离来更新dis
            dis[child]=max(dp[now][1],dis[now])+c[now].v[i];
        else
            dis[child]=max(dp[now][0],dis[now])+c[now].v[i];
        dfs(child);
    }
    return;
}
int main()
{
	freopen("in.txt","r",stdin);
	int i,j,a,b,size;
	while(scanf("%d",&N)==1)
	{
	    memset(c,0,sizeof(c));
	    for(i=2;i<=N;i++)
	    {
	        scanf("%d%d",&a,&b);
	        c[a].child.push_back(i);
	        c[a].v.push_back(b);
	    }
	    //求取dp数组,在本子树上的最远距离
	    memset(dp,0,sizeof(dp));
	    memset(dir,0,sizeof(dir));
	    dfs1(1);

	    //求取不在本子树的最远距离，dis数组
	    memset(dis,0,sizeof(dis));
	    dfs(1);

	    //输出最后结果
	    for(i=1;i<=N;i++)
            printf("%d\n",max(dp[i][0],dis[i]));
	}
	return 0;
}

dfs求最远点对源代码：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<set>
#include<map>
#include<vector>
#include<algorithm>
#include<iostream>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long LL;
const double eps=1e-8;
int N;
struct node
{
    vector<int> child;      //与之相接的点
    vector<int> v;          //权值
}c[10005];
int vis[10005];
int dis[10005];     //每个点的最大距离
int Max,k;
void dfs1(int now,int v)    //当前点以及当前权值
{
    int i,child,size;
    dis[now]=max(dis[now],v);
    if(dis[now]>Max)    //记录最远距离和最远点
    {
        Max=dis[now];
        k=now;
    }
    vis[now]=1;
    size=c[now].child.size();
    for(i=0;i<size;i++)
    {
        child=c[now].child[i];
        if(!vis[child])
        {
            dfs1(child,v+c[now].v[i]);
        }
    }
    return;
}
int main()
{
	freopen("in.txt","r",stdin);
	int i,j,a,b;
	int k1,k2;
	while(scanf("%d",&N)==1)
	{
	    memset(c,0,sizeof(c));
	    for(i=2;i<=N;i++)
	    {
	        scanf("%d%d",&a,&b);
	        c[a].child.push_back(i);
	        c[a].v.push_back(b);

	        c[i].child.push_back(a);
	        c[i].v.push_back(b);
	    }
	    //先通过dfs找到一个最远点k1
        memset(vis,0,sizeof(vis));
        memset(dis,0,sizeof(dis));
	    Max=0;
	    dfs1(1,0);
	    k1=k;
	    //再通过dfs找另外一个最远点k2
	    memset(vis,0,sizeof(vis));
	    Max=0;
	    dfs1(k1,0);
	    k2=k;
	    //k1和k2构成一个最远点对，所有点的最大距离是与k1的距离或者是与k2的距离
	    memset(vis,0,sizeof(vis));
	    dfs1(k2,0);
	    //输出最后的结果
	    for(i=1;i<=N;i++)
            printf("%d\n",dis[i]);
	}
	return 0;
}