【codevs1700】施工方案第二季 MST+树的重心

题目描述 Description

c国边防军在边境某处的阵地是由n个地堡组成的。工兵连受命来到阵地要进行两期施工。

第一期的任务是挖掘暗道让所有地堡互联互通。现已勘测设计了m条互不相交的暗道挖掘方案，如果这m条暗道都实施挖掘，肯定能达到互联互通的目的。事实上，适当选择其中n-1个方案挖掘，就能实现互联互通，即从每个地堡出发都能到达其他任何一个地堡（允许经过别的地堡）。

连长精心谋算，在m个设计规划中选取了挖掘总距离最短且能保证互联互通的若干个暗道规划实施了挖掘，完成了第一期的施工任务后又接受了第二期的施工任务，要求选择一个地堡进行扩建改造，使其能向每个地堡提供弹药。为了让弹药供应更及时、更快捷，从改扩建的地堡到最远地堡的距离（称为最远输送距离）应当尽量小。

你的任务是先求出第一期施工挖掘的总距离，再求改扩建地堡最远输送距离的最小值。

输入描述 Input Description

其中第一行是n和m，m>=n
下面的m行每行3个数xi、yi、zi,表示xi到yi的距离是zi
zi<1000000且m个距离互不相等

输出描述 Output Description

共包含两行，每行一个整数，
第一行是第一期的挖掘总距离，第二行是最远输送距离的最小值。

样例输入 Sample Input

4 5
1 2 1
2 3 2
3 4 3
4 1 4
3 1 5

样例输出 Sample Output

6
3

数据范围及提示 Data Size & Hint

【样例说明】
第一期挖掘1到2、2到3和3到4的3条暗道，第二期选择3号地堡进行改扩建，最远输送距离是3
【数据规模】
60%的数据 n<10且m<20
80%的数据 n<1000且m<2000
100%的数据 n<100000且m<200000

求最小生成树上的重心。

其实写这个题的题解并没有什么必要，我只是想说，带权树求重心不可以一遍dfs就完事，因为带权了…

【poj1655】Balancing Act 求树的重心
这是我上一篇题解，其中讲了无权树如何简单的求重心。带权树中，对于一个点，因为有出入边的权值的影响，并不能很好的求解。当然样例是不会告诉你这些的233

所以我打的朴素bfs找直径。代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int size=1000010;
const int INF=233333333;
typedef long long LL;
int fa[size];
int find(int x)
{
    return x==fa[x]?x:fa[x]=find(fa[x]);
}

int head[size],nxt[size],tot=0;

struct edge{
    int t;
    LL d;
}l[size];

void build(int f,int t,LL d)
{
    l[++tot].t=t;
    l[tot].d=d;
    nxt[tot]=head[f];
    head[f]=tot;
}


queue<int> q;
LL ans1=0;
bool vis[size];
LL dist[size];
int pre[size];
void bfs(int u)
{
    memset(pre,0,sizeof(pre));
    memset(dist,0,sizeof(dist));
    memset(vis,0,sizeof(vis));
    q.push(u);
    vis[u]=1;
    while(q.size())
    {
        int f=q.front(); q.pop();
        for(int i=head[f];i;i=nxt[i])
        {
            int v=l[i].t;
            if(vis[v]) continue;
            vis[v]=1;
            dist[v]=dist[f]+l[i].d;
            pre[v]=f;
            q.push(v);  
        }
    }
}

    int n,m;
int gets()
{
    LL maxn=0;
    int s;
    for(int i=1;i<=n;i++)
    {
        if(dist[i]>maxn) s=i,maxn=dist[i];
    }
    return s;
}

int path[size],len=0;
void dfs(int u,int s)
{
    if(u==s)
    {
        path[++len]=s;
        return ;
    }
    dfs(pre[u],s);
    path[++len]=u;
}

struct haha{
    int f,t;
    LL d;
}ll[size];
bool cmp(haha a,haha b)
{
    return a.d<b.d;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) fa[i]=i;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%lld",&ll[i].f,&ll[i].t,&ll[i].d); 
    }
    sort(ll+1,ll+1+m,cmp);
    LL ans1=0;
    for(int i=1;i<=m;i++)
    {
        int x=find(ll[i].f);
        int y=find(ll[i].t);
        if(x!=y)
        {
            fa[x]=y;
            ans1+=ll[i].d;
            build(ll[i].f,ll[i].t,ll[i].d);
            build(ll[i].t,ll[i].f,ll[i].d);
        }
    }

    bfs(1);
    int s=gets();
    bfs(s);
    int e=gets();
    dfs(e,s);
    LL ans2=INF;
// for(int i=1;i<=n;i++) cout<<dist[i]<<endl;
    for(int i=1;i<=len;i++) 
    {
        ans2=min(ans2,max(dist[path[i]],dist[e]-dist[path[i]]));
    }

    printf("%lld\n%lld",ans1,ans2);
    return 0;
}

先附个样例：
输入：

8 15
6 3 46
8 8 17
3 3 28
5 7 35
5 7 33
3 2 14
2 6 28
2 2 25
1 2 7
7 1 44
1 5 39
6 7 20
6 7 26
7 6 46
6 5 5

输出：

74
42

这是我打dfsWA了的代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;
const LL size=1000010;
const LL INF=233333333;
LL fa[size];
LL find(LL x)
{
    return x==fa[x]?x:fa[x]=find(fa[x]);
}

LL head[size],nxt[size],tot=0;

struct edge{
    LL t;
    LL d;
}l[size];

void build(LL f,LL t,LL d)
{
    l[++tot].t=t;
    l[tot].d=d;
    nxt[tot]=head[f];
    head[f]=tot;
}

bool vis[size];
LL dist[size];

LL ans1=0,ans2=INF;
void dfs(LL u)
{
    dist[u]=0;
    vis[u]=1;
    LL ans=0;
    for(LL i=head[u];i;i=nxt[i])
    {
        LL v=l[i].t;
        if(vis[v]) continue;
        dfs(v);
        dist[u]+=dist[v]+l[i].d;
        ans=max(ans,dist[v]+l[i].d);
    }
    ans=max(ans,ans1-dist[u]);
    if(ans2>ans) ans2=ans;
    cout<<u<</*" "<<ans1-dist[u]<<*/" "<<ans<<endl;
}

struct haha{
    LL f,t;
    LL d;
}ll[size];
bool cmp(haha a,haha b)
{
    return a.d<b.d;
}
int main()
{
    freopen("1700.in","r",stdin); 
// freopen("1700.out","w",stdout); 
    LL n,m;
    scanf("%lld%lld",&n,&m);
    for(LL i=1;i<=n;i++) fa[i]=i;
    for(LL i=1;i<=m;i++)
    {
        scanf("%lld%lld%lld",&ll[i].f,&ll[i].t,&ll[i].d); 
    }
    sort(ll+1,ll+1+m,cmp);
    for(LL i=1;i<=m;i++)
    {
        LL x=find(ll[i].f);
        LL y=find(ll[i].t);
        if(x!=y)
        {
            fa[x]=y;
            ans1+=ll[i].d;
            build(ll[i].f,ll[i].t,ll[i].d);
            build(ll[i].t,ll[i].f,ll[i].d);
        }
    }

    dfs(1);
    for(LL i=1;i<=n;i++) cout<<dist[i]<<" ";puts("");   

    printf("%lld\n%lld",ans1,ans2);
    return 0;
}