蓝桥杯安慰奶牛

纪念一下，这是我第一次不依靠网上的代码自己写及格的一次题。虽然仍然运行超时，但是真的已经很给我这个代码小白信心了

问题描述Farmer John变得非常懒，他不想再继续维护供奶牛之间供通行的道路。道路被用来连接N个牧场，牧场被连续地编号为1到N。每一个牧场都是一个奶牛的家。FJ计划除去P条道路中尽可能多的道路，但是还要保持牧场之间 的连通性。你首先要决定那些道路是需要保留的N-1条道路。第j条双向道路连接了牧场Sj和Ej(1 <= Sj <= N; 1 <= Ej <= N; Sj != Ej)，而且走完它需要Lj的时间。没有两个牧场是被一条以上的道路所连接。奶牛们非常伤心，因为她们的交通系统被削减了。你需要到每一个奶牛的住处去安慰她们。每次你到达第i个牧场的时候(即使你已经到过)，你必须花去Ci的时间和奶牛交谈。你每个晚上都会在同一个牧场(这是供你选择的)过夜，直到奶牛们都从悲伤中缓过神来。在早上 起来和晚上回去睡觉的时候，你都需要和在你睡觉的牧场的奶牛交谈一次。这样你才能完成你的 交谈任务。假设Farmer John采纳了你的建议，请计算出使所有奶牛都被安慰的最少时间。输入格式第1行包含两个整数N和P。接下来N行，每行包含一个整数Ci。接下来P行，每行包含三个整数Sj, Ej和Lj。输出格式输出一个整数, 所需要的总时间(包含和在你所在的牧场的奶牛的两次谈话时间)。样例输入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 <= Lj <= 1000，1 <= Ci <= 1,000。首先，数据给的是错的，要是有人看的话，建议不要按他给的数据用
然后，这里主要考察了最小生成树的思想。
下面是我一开始的思路
#include<stdio.h>
int a[100005];//宏定义，要是在int main里没办法开 
int b[100005];
int c[100005];
int l[10005];
struct Node//定义一个节点，包含他的指向和指向点所对应的距离和一个flag变量 
{
int zhi;
int ju;
int flag=0;
};
Node node[10005];
int main()
{
int n,p;//n点p线
scanf("%d%d",&n,&p);
FILE *fpRead=fopen("D:\\p.txt","r");  //这里是为了方便debug做的文件输入可以采用 
    int i,j;
    for( i=1;i<=p;i++)  
    {  
        fscanf(fpRead,"%d%d%d ",&a[i],&b[i],&c[i]);   //同上 
    }  
int temp,temp1;
int k=0;
//for (i=1;i<=p;i++)
//{
// scanf("%d%d%d",&a[i],&b[i],&c[i]);
//}
//实际上这里是一个冒泡排序。因此会运行超时。我觉得可以改善成快排，但是我不想去改了 
int min;
for (i=1;i<=n-1;i++)
{
min=99999;//每次找最小边的时候先将最小边定义为一个很大的值 
for(j=1;j<=p;j++)
{
if (c[j]<min&&(node[a[j]].flag!=node[b[j]].flag||node[a[j]].flag==0||node[b[j]].flag==0)) //flag初始都为0，表示没有任何的连线，一旦flag不是0意味着有连线
//那么，既然要避免相连的再次入选，就不能让非零相等项进入判别 
{
min=c[j];
temp=j;
}
}
//这段代码理解较为困难。
//我们应该注意到，每个双向的边它可以用单向边去表示。
//如果没有下面这一段代码，若是有一个点需要连着两条或者更多条线路
//那么后面的就会覆盖前面的
//本来应该使用之前学的dnf那一块思想去遍历
//后来觉得太烦，就发现总共只有n-1条边，那么一个点应该只有不到1条定义边
//那么我就可以对即将被覆盖掉的数据，先送给他所指向的那个点
//这样虽然会反掉顺序，但是不会丢失数据 
 
if (node[a[temp]].zhi!=0&&node[node[temp].zhi].zhi==0)
{
node[node[a[temp]].zhi].zhi=a[temp];
node[node[a[temp]].zhi].ju=node[a[temp]].ju;
   }
   
   //赋值语句，很好理解 
node[a[temp]].zhi=b[temp];
node[a[temp]].ju=min;

//flag全为0，直接赋值就可以了。为了不让k重复，就要让他不断增加 
if (node[a[temp]].flag==node[b[temp]].flag&&node[b[temp]].flag==0)
{
node[a[temp]].flag=++k;
node[b[temp]].flag=node[a[temp]].flag;
}
//一个为0，将另一个为0的替换 
if (node[a[temp]].flag!=node[b[temp]].flag&&(node[a[temp]].flag==0||(node[b[temp]].flag==0)))
{
if (node[a[temp]].flag==0)
node[a[temp]].flag=node[b[temp]].flag; 
else
node[b[temp]].flag=node[a[temp]].flag;
}
 
//这里就是和上面的全部"归为一个点 "呼应了。改掉一个点并不够
//还要将和他一样的点全部改掉 
//找大的其实没有必要就是为了好看 

if (node[a[temp]].flag!=node[b[temp]].flag&&node[b[temp]].flag!=0&&(node[a[temp]].flag!=0))
{
if (node[a[temp]].flag>node[b[temp]].flag)
   {
    temp1=node[b[temp]].flag;
for (j=1;j<=n;j++)
    if (node[j].flag==temp1)
    {
    node[j].flag=node[a[temp]].flag;
}
}
   
if (node[a[temp]].flag<node[b[temp]].flag)
   {
    temp1=node[a[temp]].flag;
for (j=1;j<=n;j++)
    if (node[j].flag==temp1)
    {
    node[j].flag=node[b[temp]].flag;
}
}
}
temp=99999;//temp重新置无穷 
}
for (i=1;i<=n;i++)
{
if (node[i].zhi!=0)
{
printf("%d %d %d",i,node[i].zhi,node[i].ju);//输出 
printf("\n");
}
}
return 0;

}
我一开始写的时候遇到一个难题。就是后面出现的数据会覆盖掉我之前记载的数据。
这个问题的最好的解法可能和之前的那些dfs之类差不多
但是我在想，既然只有n-1条路，而我有n个点可以去存储数据，那我调换一下位置不就没有任何问题了吗
于是出现了上面那一段代码。

实际上那还是错误的
因为那个代码只能调换一次，调换之后如果再遇到仍然会覆盖。这样去写一个迭代直到找到flag==0的时候应该也能解决问题。
但是那太烦了
我觉得还不如新开几个数组来存储
但是那样又太耗费空间了
那这样不如找到一个立刻输出就是了
于是有了这一段代码
#include<stdio.h>
int a[100005];//宏定义，要是在int main里没办法开 
int b[100005];
int c[100005];
int l[10005];
int a1[100005];
int b1[100005];
int c1[100005];
struct Node//定义一个节点，包含他的指向和指向点所对应的距离和一个flag变量 
{
int zhi;
int ju;
int flag=0;
};
Node node[10005];
int main()
{
int n,p;//n点p线
scanf("%d%d",&n,&p);
//FILE *fpRead=fopen("D:\\c.txt","r");  //这里是为了方便debug做的文件输入可以采用 
    int i,j;
    //for( i=1;i<=p;i++)  
    //{  
    //    fscanf(fpRead,"%d%d%d ",&a[i],&b[i],&c[i]);   //同上 
    //}  
int temp,temp1;
int k=0;
for (i=1;i<=p;i++)
{
scanf("%d%d%d",&a[i],&b[i],&c[i]);
}
int min;
for (i=1;i<=n-1;i++)
{
min=99999;//每次找最小边的时候先将最小边定义为一个很大的值 
for(j=1;j<=p;j++)
{
if (c[j]<min&&(node[a[j]].flag!=node[b[j]].flag||node[a[j]].flag==0||node[b[j]].flag==0))
//flag初始都为0，表示没有任何的连线，一旦flag不是0意味着有连线
//那么，既然要避免相连的再次入选，就不能让非零相等项进入判别 
{
min=c[j];
temp=j;
}
}
printf("%d %d %d\n",a[temp],b[temp],c[temp]);
 

//flag全为0，直接赋值就可以了。为了不让k重复，就要让他不断增加 
if (node[a[temp]].flag==node[b[temp]].flag&&node[b[temp]].flag==0)
{
node[a[temp]].flag=++k;
node[b[temp]].flag=node[a[temp]].flag;
}
//一个为0，将另一个为0的替换 
if (node[a[temp]].flag!=node[b[temp]].flag&&(node[a[temp]].flag==0||(node[b[temp]].flag==0)))
{
if (node[a[temp]].flag==0)
node[a[temp]].flag=node[b[temp]].flag; 
else
node[b[temp]].flag=node[a[temp]].flag;
}
 
//这里就是和上面的全部"归为一个点 "呼应了。改掉一个点并不够
//还要将和他一样的点全部改掉 
//找大的其实没有必要就是为了好看 

if (node[a[temp]].flag!=node[b[temp]].flag&&node[b[temp]].flag!=0&&(node[a[temp]].flag!=0))
{
if (node[a[temp]].flag>node[b[temp]].flag)
   {
    temp1=node[b[temp]].flag;
for (j=1;j<=n;j++)
    if (node[j].flag==temp1)
    {
    node[j].flag=node[a[temp]].flag;
}
}
   
if (node[a[temp]].flag<node[b[temp]].flag)
   {
    temp1=node[a[temp]].flag;
for (j=1;j<=n;j++)
    if (node[j].flag==temp1)
    {
    node[j].flag=node[b[temp]].flag;
}
}
}
temp=99999;//temp重新置无穷 
}

return 0;

}
好了这样我们就有了一个傻瓜式的最小生成树
这样代入到题目里面去
#include<stdio.h>
int a[100005];//宏定义，要是在int main里没办法开 
int b[100005];
int c[100005];
int c2[100005];
int l[10005];
int g[100005];//奶牛谈话时间 
struct Node//定义一个节点，包含他的指向和指向点所对应的距离和一个flag变量 
{
int zhi;
int ju;
int flag=0;
};
Node node[10005];
int main()
{
int n,p;//n点p线
scanf("%d%d",&n,&p);
//FILE *fpRead=fopen("D:\\c.txt","r");  这里是为了方便debug做的文件输入可以采用 
    int i,j;
    //for( i=1;i<=p;i++)  
    //{  
    //    fscanf(fpRead,"%d%d%d ",&a[i],&b[i],&c[i]);   同上 
    //}  
int temp,temp1;
int k=0;
for (i=1;i<=n;i++)
{
scanf("%d",&g[i]);
}
for (i=1;i<=p;i++)
{
scanf("%d%d%d",&a[i],&b[i],&c2[i]);
}
for (i=1;i<=p;i++)
{
c[i]=2*c2[i]+g[a[i]]+g[b[i]];//加权赋值 
}
int min;
int sum=0;
int t=99999;
for (i=1;i<=n;i++)
{
if(t>g[i])
t=g[i];//找到最小的那个点去睡觉 
}
for (i=1;i<=n-1;i++)
{
min=99999;//每次找最小边的时候先将最小边定义为一个很大的值 
for(j=1;j<=p;j++)
{
if (c[j]<min&&(node[a[j]].flag!=node[b[j]].flag||node[a[j]].flag==0||node[b[j]].flag==0))
//flag初始都为0，表示没有任何的连线，一旦flag不是0意味着有连线
//那么，既然要避免相连的再次入选，就不能让非零相等项进入判别 
{
min=c[j];
temp=j;
}
}
   sum+=c[temp];

//flag全为0，直接赋值就可以了。为了不让k重复，就要让他不断增加 
if (node[a[temp]].flag==node[b[temp]].flag&&node[b[temp]].flag==0)
{
node[a[temp]].flag=++k;
node[b[temp]].flag=node[a[temp]].flag;
}

//一个为0，将另一个为0的替换 
if (node[a[temp]].flag!=node[b[temp]].flag&&(node[a[temp]].flag==0||(node[b[temp]].flag==0)))
{
if (node[a[temp]].flag==0)
node[a[temp]].flag=node[b[temp]].flag; 
else
node[b[temp]].flag=node[a[temp]].flag;
}
 
//这里就是和上面的全部"归为一个点 "呼应了。改掉一个点并不够
//还要将和他一样的点全部改掉 
//找大的其实没有必要就是为了好看 

if (node[a[temp]].flag!=node[b[temp]].flag&&node[b[temp]].flag!=0&&(node[a[temp]].flag!=0))
{
if (node[a[temp]].flag>node[b[temp]].flag)
   {
    temp1=node[b[temp]].flag;
for (j=1;j<=n;j++)
    if (node[j].flag==temp1)
    {
    node[j].flag=node[a[temp]].flag;
}
}
   
if (node[a[temp]].flag<node[b[temp]].flag)
   {
    temp1=node[a[temp]].flag;
for (j=1;j<=n;j++)
    if (node[j].flag==temp1)
    {
    node[j].flag=node[b[temp]].flag;
}
}
}
temp=99999;//temp重新置无穷 
}

printf("%d",sum+t);
return 0;

}
我觉得还是学学网上的官方算法比较好。
但是我毕竟要比赛了，一堆算法我也记不住
还不如自己写个能拿60分的
大家不必要关心我的代码，但是这个学习方法还是值得留意的哈