最小生成树模板（POJ 1258-prime+HDU 1233 Kruskal为例）

POJ 1258

Prime（类似于dijkstra）

#include <cstdio>
#include <cstring>
#define INF 0x3f3f3f3f

const int MAXN  =100+100;
int mp[MAXN][MAXN];
int n;

/*
*  数组tree[]用来记录最小生成树的节点
*  数组lowdis[]记录从起点到其余所有点的距离并不断更新
*  数组map[][]记录所有数据两点之间的距离
*  point是所有节点的数目，begin是起点
*  mindis是最小生成树的长度
*/

int tree[MAXN];
int lowdis[MAXN];
void prime(int begin)
{
    int i,j,min,mindis=0,next;
    memset(tree,0,sizeof(tree));
    for(i=1;i<=n;i++)
    {
        lowdis[i]=mp[begin][i];//用lowdis[]数组记录下从起点到剩下所有点的距离
    }
    tree[begin]=1;//标记起点（即最小生成树中的点）
    for(i=1;i<n;i++)
    {
        min=INF;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&min>lowdis[j])
            {
                min=lowdis[j];//求出从当前起点到其余所有点的距离中最短的
                next=j;
            }
        }
        mindis+=min;//记录下整条最小树的长度
        tree[next]=1;
        for(j=1;j<=n;j++)
        {
            if(!tree[j]&&lowdis[j]>mp[next][j])
            lowdis[j]=mp[next][j];//更新lowdis[]数组
        }
    }
    printf("%d\n",mindis);
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                scanf("%d",&mp[i][j]);
            }
        }
    prime(1);
    }

}

HDU 1233

Kruskal

# include<iostream>
# include<cstdio>
# include<cstring>
# include<algorithm>
using namespace std;
const int N=105;
const int INF=1<<30;
struct edge
{
    int fr,to,w,nxt;
    bool operator < (const edge &a) const {
        return w<a.w;
    }
};
int pre[N],n,head[N],cnt;
edge e[N*(N-1)+5];
void add(int fr,int to,int w)
{
    e[cnt].fr=fr;
    e[cnt].to=to;
    e[cnt].w=w;
    e[cnt].nxt=head[fr];
    head[fr]=cnt++;
}
int fin(int x)
{
    if(x==pre[x])
        return x;
    return pre[x]=fin(pre[x]);
}
void Kruskal()
{
    for(int i=1;i<=n;++i)
        pre[i]=i;
    sort(e,e+cnt);
    int ans=0;
    for(int i=0;i<cnt;++i){
        int u=fin(e[i].fr);
        int v=fin(e[i].to);
        if(u!=v){
            ans+=e[i].w;
            pre[u]=v;
        }
    }
    printf("%d\n",ans);
}
int main()
{
    int a,b,c;
    while(scanf("%d",&n)&&n)
    {
        cnt=0;
        int m=n*(n-1)/2;
        memset(head,-1,sizeof(head));
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&c);
            add(a,b,c);
            add(b,a,c);
        }
        Kruskal();
    }
    return 0;
}

2018年全国多校算法寒假训练营练习比赛（第四场） B 道路建设

#ifndef ONLINE_JUDGE
#pragma warning(disable : 4996)
#endif
#include <iostream>
#include <vector>
#include <queue>
#include <functional>
#include <cstring>
#include <cstdio>
using namespace std;

#define MAX_V 1024

int mincost[MAX_V];		// 从集合X出发的边到每个顶点的最小权值
bool used[MAX_V];		// 顶点i是否包含在集合X中
int V;					// 顶点数
// first 最短路径，second顶点编号
typedef pair<int, int> P;
struct edge
{
	int to, cost;
	edge(int to = 0, int cost = 0) : cost(cost), to(to) {}
};
// 边
vector<edge> G[MAX_V];	// G[i] 顶点i到G[i].to的权值为G[i].cost

int prim()
{
	int res = 0;
	memset(mincost, 0x3f, V * sizeof(int));
	memset(used, 0, V * sizeof(bool));
	mincost[1] = 0;
	priority_queue<P, vector<P>, greater<P> > que;
	que.push(P(0, 1));
	while (!que.empty())
	{
		P p = que.top(); que.pop();
		int v = p.second;
		if (used[v] || p.first > mincost[v]) continue;
		used[v] = true;
		res += mincost[v];
		for (int i = 0; i < G[v].size(); ++i)
		{
			edge e = G[v][i];
			if (mincost[e.to] > e.cost)
			{
				mincost[e.to] = e.cost;
				que.push(P(mincost[e.to], e.to));
			}
		}
	}
	return res;
}

int c,m;
int main(int argc, char *argv[])
{

	while (scanf("%d%d%d",&c,&m,&V)!=EOF)
	{
	    int p,q,r;
	    for(int i=1;i<=V;i++) G[i].clear();
		for (int i = 0; i < m; ++i)
		{
			scanf("%d%d%d",&p,&q,&r);
            G[p].push_back(edge(q, r));

		}
		int ans=prim();
		if(ans>c) printf("No\n");
		else printf("Yes\n");
	}

	return 0;
}