Codevs1700 施工路线第二季

• 前言：这题写得相当费劲，其实还是思路不好。本来想两次dfs找最远点求得树的直径，但不幸多处TLE。后来发现可以用树形DP做，写出来以后还是T，以为是vector的push_back惹的祸，就学了邻接表（邻接表学习处），仍T。最后发现是并查集忘记了路径压缩，于是改后就A了。

• 题目大意：求最小生成树的边权和及树的中心到最远点的距离。

• 思路：kruskal+树形DP。在以任意一点为根建树以后，就可以开始DP了。记down[i][1]与down[i][2]分别表示不含公共边的从点i向下的最远距离与次远距离，up[i]表示点i到非以i为根的子树中的点的最远距离即可。因为邻接表的枚举及访问是有序的，所以用vis数组标记访问情况以后，对于up和down数组的处理顺序也一致，不必重新建树。还要注意long long的使用。具体的在代码中解释。

• 代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn=100005;
const int maxm=200005;
struct edges
{
       int u,v,w;
       edges(int u=0,int v=0,int w=0):u(u),v(v),w(w){}
       bool operator < (const edges &a) const
       {
            return w<a.w;
       }
}; 
int n,m;
edges edge[maxm];
int u[maxm*2+5],v[maxm*2+5],w[maxm*2+5],fst[maxm*2+5],nxt[maxm*2+5],cnt=0;

void add(int id,int ui,int vi,int wi)
{
     u[id]=ui;
     v[id]=vi;
     w[id]=wi;
     nxt[id]=fst[u[id]];
     fst[u[id]]=id;
}

void init()
{
     memset(fst,-1,sizeof(fst));
     memset(nxt,-1,sizeof(nxt));
     scanf("%d%d",&n,&m);
     for (int i=1;i<=m;++i)
     {
         int u,v,w;
         scanf("%d%d%d",&u,&v,&w);
         edge[i]=edges(u,v,w);
     }
}

int fa[maxn];

int find(int x)
{
    return fa[x]==x ? x:fa[x]=find(fa[x]);
    //一定要加上“fa[x]=”，这是路径压缩 
}

void unite(int a,int b)
{
     fa[find(a)]=find(fa[b]);
}

void getMST()
{
     for (int i=1;i<=n;++i)
       fa[i]=i;
     sort(edge+1,edge+m+1);
     int ingraph=0;
     long long ans=0;
     for (int k=1;k<=m;++k)
     {
         int i=edge[k].u;
         int j=edge[k].v;
         if (find(i)!=find(j))
         {
             ans+=edge[k].w;
             unite(i,j);
             add(++cnt,i,j,edge[k].w);
             add(++cnt,j,i,edge[k].w);
             ingraph++;
             if (ingraph==n-1)
               break;
         }
     }
     printf("%lld\n",ans);
}

long long up[maxn],down[maxn][3];
bool vis[maxn];

void dpdown(int root) 
//这里需要用儿子推导父亲，所以要先递归到最底层，返回时再处理父亲 
{
     vis[root]=1;
     for (int i=fst[root];i!=-1;i=nxt[i])
     {
         if (!vis[v[i]])
           dpdown(v[i]);
         else continue;
         if (down[v[i]][1]+w[i]>down[root][1])
         {
             down[root][2]=down[root][1];
             down[root][1]=down[v[i]][1]+w[i];
             //更新向下最远距离 
         }
         else
           down[root][2]=max(down[root][2],down[v[i]][1]+w[i]);
     }
}

void dpup(int root,int fa,int wi)   
//这里需要用父亲推导儿子，所以要传递父亲的信息至下一层递归 
{
     vis[root]=1;
     if (root==1)
     {
         up[root]=0;
     }
     else
     {
         up[root]=up[fa]+wi;
         //一种情况：由父亲的up数组得来 
         int tmp=0;
         if (down[fa][1]==down[root][1]+wi)
     //这里判断的目的是，防止父亲的down是由目前访问的儿子推导来的，这种情况不合法 
           tmp=down[fa][2]+wi;
         else
           tmp=down[fa][1]+wi;
         if (tmp>up[root])
           up[root]=tmp;
     }
     for (int i=fst[root];i!=-1;i=nxt[i])
       if (!vis[v[i]])
         dpup(v[i],root,w[i]);
}

void work()
{
     memset(vis,0,sizeof(vis));
     dpdown(1);
     memset(vis,0,sizeof(vis));
     dpup(1,0,0);
     long long ans=max(up[1],down[1][1]);
     //求最小偏心距 
     for (int i=2;i<=n;++i)
       ans=min(ans,max(up[i],down[i][1]));
     printf("%lld",ans);
}         

int main()
{
    init();
    getMST();
    work();
    return 0;
}