最小生成树

1.prim算法O(n^2)

让你从一个树中找出一条生成树，使他的路径之和最小，用贪心的思想，从任意一点开始，算出其他点到他的距离，找出一条最短的路径，记录下他的位置的长度，然后在算出其他未走过的点到这个找到的点的距离，和之前的路径比较，较小的就代替他的距离，然后重复工作

#define inf 0x3f3f3f3f
int visit[1010];//用来标记0和1  表示这个点是否被选择过
int map1[1010][1010];//邻接矩阵用来存储图的信息
int dis[1010];//记录任意一点到这个点的最近距离
int n;//点个数
int prim()
{
    int i,j,pos;
    int sum=0;
    /*初始化*/
    for(i=1; i<=n; i++)
    {
        dis[i]=inf;
        visit[i]=0;
    }
    /*选定1为起始点，初始化*/
    for(i=1; i<=n; i++)
    {
        dis[i]=map1[1][i];
    }
    dis[1]=0;
    visit[1]=1;
    /*循环找最小边，循环n-1次*/
    for(i=1; i<n; i++)
    {
        pos=inf;
        int min1=inf;
        for(j=1; j<=n; j++)
            if(visit[j]==0&&dis[j]<min1)
            {
                pos=j;
                min1=dis[j];
            }
        if(pos==inf)
            break;//防止不成图
        visit[pos]=1;
        sum+=min1;
        for(j=1;j<=n;j++)//添入新点后更新最小距离
            if(visit[j]==0&&dis[j]>map1[pos][j])
                dis[j]=map1[pos][j];
    }
        return sum;
}
int main()
{
    while(scanf("%d",&n),n)//n是点数
    {
        int m=n*(n-1)/2;//m是边数
        memset(map1,0x3f3f3f3f,sizeof(map1));//map是邻接矩阵存储图的信息
        for(int i=0; i<m; i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            if(c<map1[a][b])//防止重边
                map1[a][b]=map1[b][a]=c;
        }
        prim();
    }
}

2，kruskal（NlogN）

大概思路就是把每一条边的权值从小到大排个序，如果这两点都不在生成树里面，那么就可以把这两点加入树里，如果都用过那就不加，一直循环，找到n-1条边的时候就完成了

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<map>
#include<vector>
#include<queue>
#include<stack>
#define sf scanf
#define scf(x) scanf("%lld",&x)
#define scff(x,y) scanf("%lld%lld",&x,&y)
#define scfff(x,y,z) scanf("%lld%lld%lld",&x,&y,&z)
#define vi vector<ll>
#define pf printf
#define prf(x) printf("%lld
",x)
#define mm(x,b) memset((x),(b),sizeof(x))
#define rep(i,a,n) for (ll i=a;i<n;i++)
#define per(i,a,n) for (ll i=a;i>=n;i--)
typedef long long ll;
using namespace std;
const ll inf=0x7fffffff;
const ll N=1e5+7;
ll used[N];
struct Edge
{
	ll u,v,w;
}edge[N*4];
ll tol=0;
void add_edge(ll u,ll v,ll w)//加边 
{
	edge[tol].u =u;
	edge[tol].v =v;
	edge[tol++].w =w;
}
bool cmp(Edge a,Edge b)
{
	return a.w <b.w ;
}

ll Kruskal(ll n)	//最小生成树 输入节点数目，如果能生成返回最小花费，否则返回-1 
{
	mm(used,0);	//初始化每一点都没有被用过 
	sort(edge,edge+tol,cmp);
	ll cnt=1;		//以加点的数值 
	ll ans=0;
	for(ll i=0;i<tol&&cnt<n;i++)
	{
		if( !used[edge[i].u] || !used[edge[i].v])	//如果这点没被用过 
		{
			ans+=edge[i].w;
			used[edge[i].u]=used[edge[i].v]=1;		//标记 
			cnt++;
		}
	}
	if(cnt<n)  return -1;
	else return ans;
}
int main()
{
	ll n,m;scff(n,m);	//输入点和边的数量 
	while(m--)
	{
		ll x,y,w;
		scfff(x,y,w);
		add_edge(x,y,w);
	}
	ll ans=Kruskal(n);
	prf(ans);
	return 0;
}