POJ --1985--Cow Marathon

题意：在一棵树上，有边权，求出距离最大的两个点之间的距离

解题报告：

借助动态规划的思想来做，由于每个点有四个方向的距离，记录每个树上每个节点到其子节点的最远距离maxlen[i]，由于节点之间具有层次（祖先）关系，所以需要增加一个fa数组记录节点之间的继承关系，然后进行一次深搜，确定节点之间继承关系。

树上任意两点的唯一最短路径是一条链，所以这个最远距离点对的路径也是一条链。

这个最远的距离可以这样组成：

1：就是树上其中的一点到以其为根的子树的最远叶子节点的距离（这个点是最远距离路径的起始点）

2：树上任意一点的到其任意两个直接子节点(u,v)的距离加上这两个直接子节点的子树最远叶子距离，即maxlenu[u]和maxlen[v]

#include<iostream>
#include<cstring>
#include<cstdio>
#define maxn 51000
using namespace std;
struct node
{
    int v[5];
    int len[5];
    int maxlen;
}p[maxn];
int n,m;
int ans=0;
char cd[256];
int fa[maxn];
bool vis[maxn];

void init()
{
    int x,y,l;
    int idx;
    char dir[10];
    cd['N']=0;
    cd['S']=1;
    cd['E']=2;
    cd['W']=3;
    memset(p,0,sizeof(node)*(n+3));
    memset(fa,-1,sizeof(fa));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d%s",&x,&y,&l,dir);
        idx=cd[dir[0]];
        p[x].v[idx]=y;
        p[x].len[idx]=l;


        idx+=idx%2?-1:1;
        p[y].v[idx]=x;
        p[y].len[idx]=l;
    }
}
void dfs(int u) //深搜确定节点之间的继承关系以及以u为根节点的子树的最远叶子距离
{
    vis[u]=1;
    int v;
    for(int i=0;i<4;i++)
    {
        v=p[u].v[i];
        if(p[u].len[i])
        {
            if(!vis[v])
            {
                fa[v]=u;
                dfs(v);
                p[u].maxlen=max(p[u].maxlen,p[u].len[i]+p[v].maxlen);
            }
        }
    }
}
void solve()
{
    int son1,son2;
    ans=0;
    memset(vis,0,sizeof(vis));
    dfs(1);
    for(int g=1;g<=n;g++)
    for(int i=0;i<4;i++)
    {
        if(p[g].len[i])
        {
            son1=p[g].v[i];
            if(fa[g]==son1)continue;
            ans=max(ans,p[g].maxlen);
            for(int j=i+1;j<4;j++)
            {
                if(p[g].len[j])
                {
                    son2=p[g].v[j];
                    if(fa[g]==son2)continue;
                    ans=max(ans,p[g].len[i]+p[son1].maxlen+p[g].len[j]+p[son2].maxlen);
                }
            }
        }
    }
    printf("%d\n",ans);
}
int main()
{
    freopen("1985.txt","r",stdin);
    init();
    solve();
    return 0;
}