【图论】【最小生成树】【kruskal+prime】

ACM模板

【kruskal+并查集模板】

kruskal的时间复杂度为O（MlogM）

#include<stdio.h>
#include<algorithm>//c++  sort头文件 
using namespace std;
int f[100];//数组大小按题目所给条件设定 
struct edge{
    int u,v,w;
};//为方便排序，创建一个结构体存储边的关系 
struct edge e[10];//数组大小根据题目所给条件而定
int cmp(struct edge a,struct edge b)//sort函数 
{
    return a.w < b.w ;
}
int find(int v)//并查集查找根结点函数 
{
    if(f[v] == v)
        return v;
    else
    {
        f[v] = find(f[v]);
        return f[v];
    }
}
int merge(int u,int v)//并查集合并两个子集的函数 
{
    int t1,t2;
    t1 = find(f[u]);
    t2 = find(f[v]);
    if(t1 != t2)
    {
        f[t1] = t2;
        return 1;
    }
    return 0;
} 
int main()
{
    int n,m;/*n表示顶点个数，m表示边的条数*/
    int i, sum = 0;
    int count = 0;//记录已选边条数 
    scanf("%d%d",&n,&m);
    for( i = 0; i < m; i ++)
        scanf("%d%d%d",&e[i].u,&e[i].v ,&e[i].w );  
    sort(e,e+m,cmp);//对权值进行排序
    //并查集初始化 
    for(i = 0; i < n; i ++)
        f[i] = i;
    //kruskal算法核心部分 
    for(i = 0; i < m; i ++)//从小到大枚举每一条边 
    {
        if(merge(e[i].u ,e[i].v ))//判断一条边的两个顶点是否连通，尚未连通选择该边 
        {
            count ++;
            sum += e[i].w ;
        }
        if(count == n-1)//连通n个顶点，至少需要n-1条边 
            break;
    }
    printf("%d\n",sum);//输出结果 
    return 0;
}

kruskal路径优化算法

void Init()
{
    for(i = 1; i <= N; i ++)
        parent[i] = -1;
} 
int find(int x)//查找根节点 
{
    int tmp,s;
    for(s = x; parent[s]>=0;s = parent[s]);//找到x的根节点 
    while(s != x)//优化方案，压缩路径，方便后续查找 
    {
        tmp = parent[x];
        parent[x] = s;
        x = tmp;
    } 
    return x;
}
void Union(int a,int b)//合并函数 
{
    int tmp,t1,t2;
    t1 = find(a);//找到a的根节点t1 
    t2 = find(b);//找到b的根节点t2 
    tmp = parent[t1] + parent[t2];//tmp为根节点t1,t2的子节点和(为负数)
    // 如果a所在树结点个数 > b所在树结点个数  
    // 注意parent[t1]和parent[t2]都是负 数  
    if(parent[t1] > parent[t2])
    {
        parent[t2] = t1;//将根节点t2的子树作为根节点t1的子树 
        parent[t1] = tmp;//根节点t1的子树数目为合并后的子树数目,仍为负数 
    }
    else
    {
        parent[t1] = t2;
        parent[t2] = tmp; 
    }
    return;
}

【Prime】

未用堆和邻接表优化的时间复杂度为：O(N*N)

#define inf 99999999
while(scanf("%d%d",&n,&m)!=EOF)
{   //初始化 
    for(i = 1; i <= n; i ++)
        for(j = 1; j <= n; j ++)
            if(i == j)
                e[i][j] = 0;
            else
                e[i][j] = inf;

    for(i = 1; i <= n; i ++)
        book[i] = 0;
    for(i = 1; i <= m; i ++)
    {
        scanf("%d%d%d",&t1,&t2,&t3);
        e[t1][t2] = t3;//无向图，所以需要反向存一遍 
        e[t2][t1] = t3;
    }

    //初始化dis数组，这里是1号顶点到各个顶点的初始距离 
    for(i = 1; i <= n; i ++)
        dis[i] = e[1][i];
    //Prime核心部分开始，将1号顶点加入树 
    book[1] = 1;//这里用book来标记一个顶点是否已经加入树 
    for(i = 1; i <= n-1; i ++)
    {
        min = inf;
        for(j = 1; j <= n; j ++)
        {
            if(!book[j]&&dis[j] < min)
            {
                min = dis[j];
                u = j;
            }
        }
        book[u] = 1;sum += dis[u];
        //扫描当前顶点j所有的边，再以j为中间点，更新生成树到每一个非树顶点的距离 
        for(j = 1; j <= n; j ++)
            if(dis[j] > e[u][k])
                dis[j] = e[u][k];
    }
    printf("%d\n",sum);
}