蓝桥杯 算法训练 安慰奶牛

问题描述

Farmer John变得非常懒，他不想再继续维护供奶牛之间供通行的道路。道路被用来连接N个牧场，牧场被连续地编号为1到N。每一个牧场都是一个奶牛的家。FJ计划除去P条道路中尽可能多的道路，但是还要保持牧场之间 的连通性。你首先要决定那些道路是需要保留的N-1条道路。第j条双向道路连接了牧场S_j和E_j(1 <= S_j <= N; 1 <= E_j <= N; S_j != E_j)，而且走完它需要L_j的时间。没有两个牧场是被一条以上的道路所连接。奶牛们非常伤心，因为她们的交通系统被削减了。你需要到每一个奶牛的住处去安慰她们。每次你到达第i个牧场的时候(即使你已经到过)，你必须花去C_i的时间和奶牛交谈。你每个晚上都会在同一个牧场(这是供你选择的)过夜，直到奶牛们都从悲伤中缓过神来。在早上 起来和晚上回去睡觉的时候，你都需要和在你睡觉的牧场的奶牛交谈一次。这样你才能完成你的 交谈任务。假设Farmer John采纳了你的建议，请计算出使所有奶牛都被安慰的最少时间。

输入格式

第1行包含两个整数N和P。

接下来N行，每行包含一个整数C_i。

接下来P行，每行包含三个整数S_j, E_j和L_j。

输出格式

输出一个整数, 所需要的总时间(包含和在你所在的牧场的奶牛的两次谈话时间)。

样例输入

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

样例输出

176

数据规模与约定

5 <= N <= 10000，N-1 <= P <= 100000，0 <= L_j <= 1000，1 <= C_i <= 1,000。

思路：每条道路的权值=2*道路的长度+两端结点的权值（可以这样理解，早上出发时，在每条道路上所花的时间为在起始端点所花的时间加上在路上花的时间，回来时，在每条道路上所花时间为在尾端点和路上花的时间），将道路权值更新后，再运用最小生成树算法，最后根据题意加上选择过夜的地方（即选择最小值）

下面是用prime算法实现（原本只是随便写的，想要练练手，没想到没超时居然过了）

#include <iostream>
#include <string.h>
using namespace std;

int head[20010],dis[20010];
int len,n,p,c[20010],tuji[20010],vis[20010],num[20010];
int cc=0;
struct edge
{
	int to;
	int pow;
	int next;
	int num;
	int s;
}e[400010];

void add(int from,int to,int pow)
{
	e[len].to=to;
	e[len].pow=2*pow+c[from]+c[to];//本题的关键点
	e[len].next=head[from];
	head[from]=len++;
}

int prime()
{
	memset(vis,0,sizeof(vis));
	memset(dis,99999999,sizeof(dis));
	memset(tuji,0,sizeof(tuji));
	for(int i=1;i<=n;i++)
	{
		dis[i]=99999999;
	}
	vis[1]=1;//最开始将1号点送入集合，其余点在另一集合
    dis[1]=0;//dis[i]表示i点和已选点的集合的最小距离
    for(int i=head[1];i!=-1;i=e[i].next)//遍历所有和1号点相邻的点
    {
	    dis[e[i].to]=e[i].pow;//此时只有1号点在已选点集合，这样赋值是很显然的
    }//因为将1号点送入集合，所以更新其相邻点的dis值
    for(int i=1;i<n;i++)//每一次循环将会有一个点进入已选点集合
    { 
	    int min=99999999;
		int t;
		for(int k=1;k<=n;k++)
        {
		    if(vis[k]==0&&dis[k]<min)
			{
			    min=dis[k];
				t=k;
		    }
        }//以上找到在所有未选点中，dis值最小的点，我们要把这个点选出来
        vis[t]=1;//扔进已选点集合
        cc+=dis[t];//最小生成树的长度也因此增加,到此循环还没结束
        for(int k=head[t];k!=-1;k=e[k].next)//以选点集合有新的点加入了，可以更新未选点的dis值,遍历t的相邻点
        {
	        if(vis[e[k].to]==0&&dis[e[k].to]>e[k].pow)//如果相邻点在未选点集合且该点到t点的值更小
            {
		        dis[e[k].to]=e[k].pow;//更新该点的dis值
            }
        }
    }
    return cc;
}

int main()
{
    cin>>n>>p;
	len=1;
	memset(head,-1,sizeof(head));
    for(int i=1;i<=n;i++)
    {
	    cin>>c[i];
	}
    for(int i=1;i<=p;i++)
    {
        int u,v,pow;
		cin>>u>>v>>pow;
        add(u,v,pow);
        add(v,u,pow);
    }//输入，建图
    int min=99999999;
    for(int i=1;i<=n;i++)
    {
        if(min>c[i])min=c[i];
    }//找到最小的c[i]作为过夜的点
    cout<<prime()+min<<endl;//输出
}

以下是用kruskal实现的，具体实现需要用到并查集的知识点

这里是一篇讲解并查集的文章，很有意思http://blog.csdn.net/u013546077/article/details/64509038 点击打开链接

#include <iostream>
#include <string.h>
#include <algorithm>
using namespace std;

int head[20010],dis[20010];
int len,n,p,c[20010],pre[20010],vis[20010],num[20010];
int cc=0;
struct edge
{
	int to;
	int pow;
	int from;
}e[400010];

bool cmp(edge x,edge y)
{
	return x.pow<y.pow;
}//按权值从小到大排序

void add(int from,int to,int pow)
{
	e[len].to=to;
	e[len].pow=2*pow+c[from]+c[to];
	e[len].from=from;
	len++;
}

int find(int i)
{
	int r=i;
	while(pre[r]!=r)
	{
		r=pre[r];
	}
	return r;
}

void join(int x,int y)
{
	int m=find(x);
	int n=find(y);
	pre[m]=n;
	int i=x,k;
	while(pre[i]!=n)
	{
		k=pre[i];
		pre[i]=n;
		i=k;
	}
	
}

int main()
{
	cin>>n>>p;
	len=1;
	memset(head,-1,sizeof(head));
	for(int i=1;i<=n;i++)
	{
		cin>>c[i];
	}
	for(int i=1;i<=p;i++)
	{
		int u,v,pow;
		cin>>u>>v>>pow;
		add(u,v,pow);
	}//输入
	sort(e+1,e+p+1,cmp);//排序
	for(int  i=1;i<=n;i++)
	{
		pre[i]=i;
	}//初始化
	for(int i=1;i<=p;i++)
	{每次选权值最小的边尝试加入
		int x=find(e[i].from);
		int y=find(e[i].to);
		if(x!=y)//说明这条边的两端点处在不同的集合，故加入这条边
		{
			join(e[i].from,e[i].to);
			cc+=e[i].pow;
		}
	}
	int min=99999999;
	for(int i=1;i<=n;i++)
	{
		if(min>c[i])
		min=c[i];
	}
	cout<<min+cc<<endl;
	
}

个人感觉并查集会的话，上面的kruskal算法的实现还是很容易理解的。