【图论】【最小生成树】【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)

        memset(vis,inf,sizeof(vis));
        memset(dis,inf,sizeof(dis));//存储生成树到各个非树顶点的距离 
        memset(book,0,sizeof(book));//book数组标记顶点是否加入树 
        for(int i = 1; i <= m; i ++)
            vis[i][i] = 0;
        for(int i = 0; i < n; i ++)
        {
            scanf("%d%d%d",&x,&y,&w);
            vis[x][y] = w;
            vis[y][x] = w;//无向图 
        }
        for(int i = 1; i <= m; i ++)
            dis[i] = vis[1][i];
        book[1] = 1;//源点1加入树 
        for(int i = 1; i < m; i ++)
        {
            int minn = inf;
            for(int j = 1; j <= m; j ++)
                if(!book[j]&&dis[j] < minn)//找到离生成树距离最短的非树顶点 
                {
                    u = j;
                    minn = dis[j];
                }
            book[u] = 1;

            for(int j = 1; j <= m; j ++)
                if(!book[j]&&dis[j] > vis[u][j])//更新树到每一个非树顶点的距离 
                    dis[j] = vis[u][j];
        }
    }