洛谷P2916 [USACO08NOV]为母牛欢呼(最小生成树)

P2916 [USACO08NOV]为母牛欢呼Cheering up the C…

题目描述

Farmer John has grown so lazy that he no longer wants to continue maintaining the cow paths that currently provide a way to visit each of his N (5 <= N <= 10,000) pastures (conveniently numbered 1..N). Each and every pasture is home to one cow. FJ plans to remove as many of the P (N-1 <= P <= 100,000) paths as possible while keeping the pastures connected. You must determine which N-1 paths to keep.

Bidirectional path j connects pastures S_j and E_j (1 <= S_j <= N; 1 <= E_j <= N; S_j != E_j) and requires L_j (0 <= L_j <= 1,000) time to traverse. No pair of pastures is directly connected by more than one path.

The cows are sad that their transportation system is being reduced. You must visit each cow at least once every day to cheer her up. Every time you visit pasture i (even if you're just traveling

through), you must talk to the cow for time C_i (1 <= C_i <= 1,000).

You will spend each night in the same pasture (which you will choose) until the cows have recovered from their sadness. You will end up talking to the cow in the sleeping pasture at least in the morning when you wake up and in the evening after you have returned to sleep.

Assuming that Farmer John follows your suggestions of which paths to keep and you pick the optimal pasture to sleep in, determine the minimal amount of time it will take you to visit each cow at least once in a day.

For your first 10 submissions, you will be provided with the results of running your program on a part of the actual test data.

POINTS: 300

约翰有N个牧场，编号依次为1到N。每个牧场里住着一头奶牛。连接这些牧场的有P条道路，每条道路都是双向的。第j条道路连接的是牧场Sj和Ej，通行需要Lj的时间。两牧场之间最多只有一条道路。约翰打算在保持各牧场连通的情况下去掉尽量多的道路。

约翰知道，在道路被强拆后，奶牛会非常伤心，所以他计划拆除道路之后就去忽悠她们。约翰可以选择从任意一个牧场出发开始他维稳工作。当他走访完所有的奶牛之后，还要回到他的出发地。每次路过牧场i的时候，他必须花Ci的时间和奶牛交谈，即使之前已经做过工作了，也要留下来再谈一次。注意约翰在出发和回去的时候，都要和出发地的奶牛谈一次话。请你计算一下，约翰要拆除哪些道路，才能让忽悠奶牛的时间变得最少？

输入输出格式

输入格式：

• Line 1: Two space-separated integers: N and P

• Lines 2..N+1: Line i+1 contains a single integer: C_i

• Lines N+2..N+P+1: Line N+j+1 contains three space-separated

integers: S_j, E_j, and L_j

输出格式：

• Line 1: A single integer, the total time it takes to visit all the cows (including the two visits to the cow in your

sleeping-pasture)

输入输出样例

输入样例#1：

5 7
10
10
20
6
30
1 2 5
2 3 5
2 4 12
3 4 17
2 5 15
3 5 6
4 5 12

输出样例#1：

176

说明

   +-(15)-+
  /        \
 /          \
1-(5)-2-(5)-3-(6)--5
   \   /(17)  /
(12)\ /      /(12)
     4------+ 

Keep these paths:
1-(5)-2-(5)-3      5
       \          /
    (12)\        /(12)
        *4------+ 

Wake up in pasture 4 and visit pastures in the order 4, 5, 4, 2, 3, 2, 1, 2, 4 yielding a total time of 176 before going back to sleep.

/*
以A~B为例子，AB这条边的边权就等于A点的值+B点的值+2*AB（因为这条路要来回走，共两遍）
然后再找点的值最小的一个点，作为出发点，就可以愉快地跑Kruskal了
注意答案开始为最小点的点权
*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

#define N 10007
#define M 100007

using namespace std;
int head[M],fa[N],val[N];
int n,m,ans,cnt,x,y,z;
struct edge
{
    int u,to,next,dis;
    bool operator < (const edge &a) const{
        return dis<a.dis;
    }

}e[M];

inline int read()
{
    int x=,f=;char c=getchar();
    while(c>''||c<''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
    return x*f;
}

int find(int x)
{
    if(x==fa[x]) return x;
    return fa[x]=find(fa[x]);
}

void kruskal()
{
    int num=;
    sort(e+,e+m+);
    for(int i=;i<=m;i++)
    {
        int sa=find(e[i].u),sb=find(e[i].to);
        if(sa!=sb)
        {
            fa[sb]=sa;
            num++;
            ans+=e[i].dis;
        }
        if(num==n-) break;
    }
    printf("%d\n",ans);
}

int main()
{
    ans=0x7f7f7f7f;
    n=read();m=read();
    for(int i=;i<=n;i++)
    {
        val[i]=read();fa[i]=i;
        ans=min(ans,val[i]);
    }
    for(int i=;i<=m;i++)
    {
        e[i].u=read();e[i].to=read();e[i].dis=read();
        e[i].dis*=;e[i].dis+=val[e[i].u]+val[e[i].to];
    }
    kruskal();
    return ;
}