最小生成树

题目背景

小杉坐在教室里，透过口袋一样的窗户看口袋一样的天空。

有很多云飘在那里，看起来很漂亮，小杉想摘下那样美的几朵云，做成棉花糖。

题目描述

给你云朵的个数 NN，再给你 MM 个关系，表示哪些云朵可以连在一起。

现在小杉要把所有云朵连成 KK 个棉花糖，一个棉花糖最少要用掉一朵云，小杉想知道他怎么连，花费的代价最小。

输入格式

第一行有三个数 N,M,KN,M,K。

接下来 MM 行每行三个数 X,Y,LX,Y,L，表示XX云和 YY 云可以通过 LL 的代价连在一起。

输出格式

对每组数据输出一行，仅有一个整数，表示最小的代价。

如果怎么连都连不出 KK 个棉花糖，请输出 No Answer。

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
#define int long long
const int maxn=2e4+5;
int vis[maxn];int fa[maxn];
struct node{
    int from,to,cost;
}edge[maxn];
vector<int> G[maxn];
bool cmp(node a,node b)
{
    return a.cost<b.cost;
}
int find(int x)
{
    return x==fa[x]?x:fa[x]=find(fa[x]);
}
void dfs(int root)
{
    for(int i=0;i<G[root].size();i++)
    {
        if(!vis[G[root][i]])
        {
            vis[G[root][i]]=1;
            dfs(G[root][i]);
        }
    }
}
signed main()
{
    int n,m,k;
    cin>>n>>m>>k;
    if(k>n) {
        cout<<"No Answer"<<endl;
        return 0;
    }
    int num=0;
    for(int i=0;i<m;i++)
    {
        int from,to,cost;
        cin>>from>>to>>cost;
        G[from].push_back(to);
        G[to].push_back(from);
        edge[++num].from=from,edge[num].to=to,edge[num].cost=cost;
        edge[++num].from=to,edge[num].to=from,edge[num].cost=cost;
    }
    sort(edge+1,edge+1+num,cmp);
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        fa[i]=i;
        if(!vis[i])
        {
            vis[i]=1;
            dfs(i);
            cnt++;
        }
    }
    if(cnt>k)
    {
        cout<<"No Answer"<<endl;
        return 0;
    }
    int sum=0;
    int ans=0;
    for(int i=1;i<=num;i++)
    {
        int from=edge[i].from,to=edge[i].to,cost=edge[i].cost;
        int x=find(from),y=find(to);
        if(x!=y) {
            ans += cost;
            fa[x] = y;
            sum++;
        }
        if(sum==n-k) break;
    }
    cout<<ans<<endl;
    return 0;
}

题目描述

又到了一年一度的明明生日了，明明想要买 BB 样东西，巧的是，这 BB 样东西价格都是 AA 元。

但是，商店老板说最近有促销活动，也就是：

如果你买了第 II 样东西，再买第 JJ 样，那么就可以只花 K_{I,J}KI,J​ 元，更巧的是，K_{I,J}KI,J​ 竟然等于 K_{J,I}KJ,I​。

现在明明想知道，他最少要花多少钱。

输入格式

第一行两个整数，A,BA,B。

接下来 BB 行，每行 BB 个数，第 II 行第 JJ 个为 K_{I,J}KI,J​。

我们保证 K_{I,J}=K_{J,I}KI,J​=KJ,I​ 并且 K_{I,I}=0KI,I​=0。

特别的，如果 K_{I,J}=0KI,J​=0，那么表示这两样东西之间不会导致优惠。

输出格式

一个整数，为最小要花的钱数。

#include<iostream>
#include<algorithm>
using namespace std;
#define int long long
const int maxn=1e6+5;
int fa[maxn];
struct node{
    int from,to,cost;
}edge[maxn];
int find(int x)
{
    return x==fa[x]?x:fa[x]=find(fa[x]);
}
bool cmp(node a,node b)
{
    return a.cost<b.cost;
}
signed main()
{
    int a,b;
    cin>>a>>b;
    int num=0;
    for(int i=0;i<b;i++)
    {
        fa[i+1]=i+1;
        for(int j=0;j<b;j++)
        {
            int cost;cin>>cost;
            cost=min(a,cost);
            if(cost==0) cost=a;
            edge[++num].from=i+1;edge[num].to=j+1;edge[num].cost=cost;
            edge[++num].from=j+1;edge[num].to=i+1;edge[num].cost=cost;
        }
    }
    sort(edge+1,edge+1+num,cmp);
    int ans=a;
    int cnt=0;
    for(int i=1;i<=num;i++)
    {
        int from=edge[i].from,to=edge[i].to,cost=edge[i].cost;
        int x=find(from),y=find(to);
        if(x!=y)
        {
            ans+=cost;
            //cout<<cost<<endl;
            fa[x]=y;
            cnt++;
        }
        if(cnt==num-1) break;
    }
    cout<<ans<<endl;
}

聪聪研究发现，荒岛野人总是过着群居的生活，但是，并不是整个荒岛上的所有野人都属于同一个部落，野人们总是拉帮结派形成属于自己的部落，不同的部落之间则经常发生争斗。只是，这一切都成为谜团了——聪聪根本就不知道部落究竟是如何分布的。

不过好消息是，聪聪得到了一份荒岛的地图。地图上标注了 nn 个野人居住的地点（可以看作是平面上的坐标）。我们知道，同一个部落的野人总是生活在附近。我们把两个部落的距离，定义为部落中距离最近的那两个居住点的距离。聪聪还获得了一个有意义的信息——这些野人总共被分为了 kk 个部落！这真是个好消息。聪聪希望从这些信息里挖掘出所有部落的详细信息。他正在尝试这样一种算法：

对于任意一种部落划分的方法，都能够求出两个部落之间的距离，聪聪希望求出一种部落划分的方法，使靠得最近的两个部落尽可能远离。

例如，下面的左图表示了一个好的划分，而右图则不是。请你编程帮助聪聪解决这个难题。

输入格式

输入文件第一行包含两个整数 nn 和 kk，分别代表了野人居住点的数量和部落的数量。

接下来 nn 行，每行包含两个整数 xx，yy，描述了一个居住点的坐标。

输出格式

输出一行一个实数，为最优划分时，最近的两个部落的距离，精确到小数点后两位。

把最小生成树划分成不同块，每个块之间的边就是两个块之间的最小距离。

#include<iostream>
#include<cmath>
#include<cstdio>
#include<algorithm>
using namespace std;
#define int long long
const int maxn=1e3+5;
int f[maxn];
struct node{
    int from,to;
    double cost;
}edge[maxn*maxn];
struct point{
    double x,y;
}p[maxn];
bool cmp(node a,node b) {
    return a.cost < b.cost;
}
double cal(point a,point b)
{
    return (double)sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
int find(int x)
{
    return x==f[x]?x:f[x]=find(f[x]);
}
signed main()
{
    int n,k;scanf("%lld%lld",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%lf%lf",&p[i].x,&p[i].y);
        f[i+1]=i+1;
    }
    int num=0;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            edge[num].from=i+1,edge[num].to=j+1,edge[num].cost=cal(p[i],p[j]);
            num++;
        }
    }
    sort(edge,edge+num,cmp);
    int cnt=0;
    for(int i=0;i<num;i++)
    {
        int x=edge[i].from,y=edge[i].to;
        int xn=find(x),yn=find(y);
        if(xn!=yn)
        {
            f[xn]=yn;
            cnt++;
            if(cnt==n-k+1) {
                printf("%.2lf",edge[i].cost);
                break;
            }
        }
    }
    return 0;
}

 

题目背景

“咚咚咚……”“查水表！”原来是查水表来了，现在哪里找这么热心上门的查表员啊！小明感动得热泪盈眶，开起了门……

题目描述

妈妈下班回家，街坊邻居说小明被一群陌生人强行押上了警车！妈妈丰富的经验告诉她小明被带到了 tt 区，而自己在 ss 区。

该市有 mm 条大道连接 nn 个区，一条大道将两个区相连接，每个大道有一个拥挤度。小明的妈妈虽然很着急，但是不愿意拥挤的人潮冲乱了她优雅的步伐。所以请你帮她规划一条从 ss 至 tt 的路线，使得经过道路的拥挤度最大值最小。

输入格式

第一行有四个用空格隔开的 nn，mm，ss，tt，其含义见【题目描述】。

接下来 mm 行，每行三个整数 u, v, wu,v,w，表示有一条大道连接区 uu 和区 vv，且拥挤度为 ww。

两个区之间可能存在多条大道。

输出格式

输出一行一个整数，代表最大的拥挤度。

当s和t第一次连同时，即可输出答案。

#include<iostream>
#include<algorithm>
using namespace std;
#define int long long
const int maxn=2e4+5;
int fa[maxn];
struct node{
    int from,to,cost;
}edge[maxn<<1];
bool cmp(node a,node b)
{
    return a.cost<b.cost;
}
int find(int x)
{
    return x==fa[x]?x:fa[x]=find(fa[x]);
}
signed main()
{
    int n,m,s,t;
    cin>>n>>m>>s>>t;
    int num=0;
    for(int i=1;i<=n;i++) fa[i]=i;
    for(int i=1;i<=m;i++)
    {
        int from,to,cost;
        cin>>from>>to>>cost;
        edge[num].from=from,edge[num].to=to,edge[num++].cost=cost;
        edge[num].from=to,edge[num].to=from,edge[num++].cost=cost;
    }
    sort(edge,edge+num,cmp);
    for(int i=0;i<num;i++)
    {
        int x=edge[i].from,y=edge[i].to;
        int xn=find(x),yn=find(y);
        if(xn!=yn)
        {
            fa[xn]=yn;
        }
        if(find(s)==find(t))
        {
            cout<<edge[i].cost<<endl;
            return 0;
        }
    }
}