最小生成树——模板

题目

模版题很简单；
一共有n个城市（从1开始编号），有m条路线，求出一条能连通n个城市的最小路线；

分析

首先需要找到一条能连通所有城市的路线；
其次要保证这条路径的路程最短；

算法简介

常用两种算法：
Kruskal 时间复杂度为eloge e为总共的边数。
1.先将各个边的权值从小到大排序；
2.按从小到大的顺序依次将边连接的点加入到一个集合中，并利用并查集确定一个祖先节点，使其中的节点能连接在一起，确定关系；
prim 普里姆算法 时间复杂度（n^2 未被优化） （优化后，elogn）n为节点数；
1.现将初始值赋好；
2.算法主体思想就是，从一点出发，找到与之相连的最短路径的顶点，贪心寻找，逐渐将一个点变成两个，三个，然后就是将这些被搜索过的点，去寻找未被搜索点的最小值；

1.kru，算法模板；

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include<cstring>
#include<vector>
#include<cmath>
using namespace std;
const int N=1e3;
int bin[N];                 // 并查集的标记数组，注意要初始化；
struct node{               // 结构体存边，方便使用，排序；
    int a,b,val;
}edge[N<<2];
bool cpu(node a, node b)    // 将边权按从小到大排序；
{
    return a.val<b.val;
}
int find1(int x)            // 并查集寻找祖先节点；这也是并查集的标准模板；
{
    if(bin[x]==x) return x;                    
    return bin[x]=find1(bin[x]);    // 递归寻找，并且实现路径压缩，减少时间复杂度；
}
int kru(int n,int m)
{
    int i,val,x,y,fx,fy,cnt=0,sum=0;
    for(i=0;i<m;i++){
        x=edge[i].a;
        y=edge[i].b;
        val=edge[i].val;
        fx=find1(x);
        fy=find1(y);
        if(fx!=fy){                  // 若找到的祖先节点不同，说明两点还没被连接，是新的边；
            bin[fx]=fy;
            sum+=val;        // 将新的边权加入总和；
            cnt++;            // 增加了一条边；
        }
        if(cnt==n-1)           // 若边数等于n-1说明全部连通了，跳出循环；
            break;
    }
    if(cnt==n-1)
        return sum;
    return -1;           // 若边数不等于n-1说明不能实现全部连通；
}
int main()
{
    int n,m,i;
    scanf("%d%d",&n,&m);
    for(i=0;i<m;i++){
        scanf("%d%d%d",&edge[i].a,&edge[i].b,&edge[i].val);
    }
    for(i=1;i<=n;i++)          // 并查集标记数组初始化；
        bin[i]=i;
    int ans=kru(n,m);
    if(ans)
        printf("%d\n",ans);
    else
        printf("-1\n");
    return 0;
}

prim算法（未被优化）

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cmath>
#include<vector>
using namespace std;
const int N=200;
const int inff=0x3f3f3f3f;      // 很大的数，用于比较；
int mp[N][N],dis[N];          // mp，邻接矩阵建边；dis[]用于存储最小的未被处理点的边权；
bool p[N];                    // 标记点是否被处理过；
int prim(int n,int m)
{
    int i,j,m1,m2,ans=0;
    for(i=2;i<=m;i++){
        m1=inff;                 // m1 找到dis[]中未被处理点的最小值；
        for(j=1;j<=m;j++){
            if(p[j]&&dis[j]<=m1){
                m1=dis[j];
                m2=j;
            }
        }
        p[m2]=false;         // 找到了m2点，为本次处理点；
        ans+=m1;
        for(j=1;j<=m;j++){
            if(p[j]&&dis[j]>mp[m2][j]){
                dis[j]=mp[m2][j];
            }
        }
    }
    if(ans>=inff)
        return 0;
    return ans;
}
int main()
{
    int n,m,i,x,y,val;
    while(scanf("%d",&n)!=EOF&&n){
        memset(mp,inff,sizeof(mp));
        memset(p,true,sizeof(p));
        memset(dis,inff,sizeof(dis));
        scanf("%d",&m);
        for(i=0;i<n;i++){
            scanf("%d%d%d",&x,&y,&val);
            mp[x][y]=mp[y][x]=val;
        }
        for(i=1;i<=m;i++){            // 注意这儿是选择开始的点；
            if(dis[i]>mp[x][i])
                dis[i]=mp[x][i];
        }
        p[x]=false;
        int k=find1(n,m);
        if(k)
            printf("%d\n",k);
        else
            printf("-1\n");
    }
    return 0;
}

优化，算了吧，优先队列。。。。。感觉还不如用kru 算法，清晰明了；