最小生成树

kruskal：

这种算法是从小到大枚举边的权重，当当前边可以连接两个不相连的点，即记录下来，当边数为n-1时，成最小生成树。

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
using namespace std;
const int N =1e5;
struct edge
{
  int x;
  int y;
  int w;

}eg[N];
struct data
{
  int x;
  int y;

}qur[1100];
int  cnt=0;
int n,m,k,f[1100],ans[1100];
int father(int x)
{
   if(x!=f[x]) f[x]=father(f[x]);
    return f[x];
}
bool cmp(const struct edge &a, const struct edge &b)
{

    return a.w<b.w;
}
int main()
{  
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++)
       f[i]=i;
    for(int i=1;i<=m;i++)
    {  int x, y, w;
        scanf("%d%d%d",&x,&y,&w);
          eg[i].x=x;
          eg[i].y=y;
          eg[i].w=w;
    }
    for(int i=1;i<=k;i++)
    {  int x,y;
       scanf("%d%d",&x,&y);
          qur[i].x=x;
          qur[i].y=y;
    }
    sort(eg+1,eg+1+m,cmp);
     int fa,fb;
    for(int i=1;i<=m&&cnt<n-1;i++)
    {     fa=father(eg[i].x);
           fb=father(eg[i].y);
          
          if(fa==fb) continue;
          for(int j=1;j<=k;j++)
          {   
              if(ans[j]) continue;
             int fx=father(qur[j].x),fy=father(qur[j].y);  
             if((fx==fa&&fy==fb)||(fx==fb&&fy==fa))
               ans[j]=eg[i].w;
          }
         f[fa]=fb;
          cnt++;
    }
   
    for(int i=1;i<=k;i++)
    {
        if(ans[i])
        printf("%d\n",ans[i]);
        else
        printf("-1\n");

    }
   
    return 0;
}

prime算法:

这个首先定一个点，定义其他点到他距离无穷大，将那个点放进优先队列（按边权从小到大），从当前点更新他到其他未在集合内的点距离，如果到其他点距离被更新，就将其他点放进优先队列，知道队列为空，或生成最小生成树。

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
using namespace std;
const int N = 1e5+100;
long long ans;
int dis[N],vis[N],cnt;
struct edge
{
    int x;
    int w;
};
vector<struct edge> p[N];
struct data
{
    int no;
    int w;
}o;
bool operator > (const struct data& a, const struct data& b)
{
    return a.w > b.w;
}
priority_queue<struct data, vector<struct data>, greater<struct data> > q;
int main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        dis[i] = 1e9;
       dis[1] = 0;
       for (int i = 1; i <= m; i++)
       {
           int x, y, w;
           cin >> x >> y >> w;
           p[x].push_back({ y ,w});
           p[y].push_back({ x ,w});
       }
       q.push({ 1,0 });
       while (!q.empty() && cnt < n)
       {  
           o = q.top();
           q.pop();
           if (vis[o.no]) continue;
           cnt++;
           ans += o.w;
           vis[o.no] = 1;
           for (int i = 0; i < p[o.no].size(); i++)
           {
               int v = p[o.no][i].x;
               if (vis[v]) continue;
               if (p[o.no][i].w < dis[v])
                   dis[v] = p[o.no][i].w, q.push({ v,dis[v]});
           }
       }
       if (cnt != n)
           cout << "impossible" << endl;
       else
           cout<<ans<<endl;
    return 0;
}