学习日记：2022年2月16日

首先这个题目的意思有点不明确

其中的云朵有两种，一种是天上的云朵，一种是使用的云朵

最开始每一个云朵就是一个棉花糖

如果有1 2 3节点，那么就是三个棉花糖

如果连接1 2 那么就是两个

如果在连接3那么就是一个

题目中给出了消耗的量，同时也给出了连接关系

很容易就想到了prim算法

首先我们把题目给出的数据进行排序

一共有n个云朵，同时也有n个棉花糖

然后根据排序的数据通过prim算法来进行选择

其中连接的个数有一定的限制，因为我们只需要k个棉花糖

每次连接一对云朵就会减少一个棉花糖的数量

所以要达到k个棉花糖就要连接n-k次

对应的修改prim算法中控制连接数量的变量就可以了

然后就是其中的No answer情况

这个就是当所有的云朵都连接完成后都没有完成k个棉花糖的要求就是no answer

其实也就是当k>n的时候

然后根据前面写过的prim算法的模板，稍加修改

#include<iostream>
using namespace std;
#define N 1003
#define M 10004
int cloud,rela,candy;
int record[N];
struct Data
{
    int a;
    int b;
    int need;
}data[M];

// 并查集
int parent[N];
int check(int a)
{
    if(parent[a]==a)
    return a;
    parent[a]=check(parent[a]);
    return parent[a];
}

int comp(int start,int end)
{
    int mid=(start+end)/2;
    int a=start;
    int b=mid+1;
    Data shadow[M];
    int len=0;
    while(a<=mid&&b<=end)
    {
        if(data[a].need>data[b].need)
        shadow[len++]=data[b++];
        else
        shadow[len++]=data[a++];
    }
    while(a<=mid)
    shadow[len++]=data[a++];
    while(b<=end)
    shadow[len++]=data[b++];
    for(int i=0;i<len;i++)
    data[start+i]=shadow[i];
}
int sorting(int start,int end)
{
    if(start>=end)
    return 0;
    int mid=(start+end)/2;
    sorting(start,mid);
    sorting(mid+1,end);
    comp(start,end);
}

int finding()
{
    // 并查集赋初值
    for(int i=1;i<=cloud;i++)
    parent[i]=i;
    
    int result=0;
    int present=1;
    for(int i=1;i<=cloud-candy&&present<=rela;i++)
    {
        while(check(data[present].a)==check(data[present].b))
        present++;
        result+=data[present].need;
        parent[check(data[present].a)]=check(data[present].b);
        present++;
    }
    if(present<=rela)
    cout<<result;
    else
    cout<<"No Answer";
}
int main()
{
    cin>>cloud>>rela>>candy;
    for(int i=1;i<=rela;i++)
    {
        cin >>data[i].a
            >>data[i].b
            >>data[i].need;
    }
    sorting (1,rela);
    // for(int i=1;i<=rela;i++)
    // cout<<data[i].need<<endl;
    finding();
}

总的来说，这个题目还是最小生成树的使用

最开始我认为给出的云朵和使用的云朵是同一种云朵

结果就一直没有通过

最终看了题解中的解释

这个题目说实话我是想破了脑袋也没有想出解决方案。

就是其中已经给出的边到底该怎么处理。

我最开始的想法就是每 走一次就判断是否在题目给出的边中有；

这样需要计算的数据就很大

嵌套了三层for循环，不用想都知道会时间超限

但是现在想一下，其中给出的数据也就1000；如果我用桶排来记录题目给出的边好像也是可以的

最终看了题解中的一个思路

就是将题目给出的两点的距离全部弄成0

然后我就恍然大悟了

为了更加方便的计算两点之间的距离，我直接建立了一个二维表存储所有节点的距离

为了防止会出现重路外加一个min的判断

然后就是经典的克鲁斯算法

#include<iostream>
#include<math.h>
using namespace std;
#define N 1003
#define inf 99999999
int n,m;
double result[N];
int node[N][2];
double range[N][N];

double distance(int a,int b)
{
    double x=node[a][0]-node[b][0];
    double y=node[a][1]-node[b][1];
    return sqrt(x*x+y*y);
}

int finding()
{
    double ans=0;
    for(int i=1;i<=n;i++)
    result[i]=inf;
    int present=1;
    int count=1;
    int book[N]={0};
    while(count++<n)
    {
        // cout<<present<<' ';
        book[present]=1;
        //更新所有最短的节点
        for(int i=1;i<=n;i++)
        {
            if(book[i]==0)
            {
                if(result[i]>range[present][i])
                result[i]=range[present][i];
            }
        }

        double ming=inf;
        for(int i=1;i<=n;i++)
        if(book[i]==0&&result[i]<ming)
        {
            ming=result[i];
            present=i;
        }
        ans+=ming;
    }
    printf("%.2lf",ans);
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>node[i][0]>>node[i][1];
    }

    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    range[i][j]=distance(i,j);//任意两点之间的距离

    for(int i=1;i<=m;i++)
    {
        int a,b;
        cin>>a>>b;
        range[a][b]=0;//一个来
        range[b][a]=0;//一个回
    }
    finding();

}

但是其中还有一个要注意的点

就是计算两点之间的距离

题目中给出的坐标范围是0-10^6

如果是极端数据的话，在计算两点之间的距离会使用到平方也就是10^12

int是无法承受的

所以要用一个更大的数据结构来进行存储