最小生成树 Prim+Kruskal

最小生成树：Prim+Kruskal算法

1.问题

在某地分布着6个村庄，现在需要在6个村庄之间修路，每个村庄之前的距离不同，问怎么修最短的路，将各个村庄连接起来。

2.解析

Prim算法：

1. 在一个加权连通图中，顶点集合V，边集合为E
2. 随机选择一个初始顶点,标记为visit,计算所有与之相连接的点的距离，选择距离最短的边权dest，标记为visit.
3. 重复以上操作，直到所有点都被标记为visit。
4. 

Kruskal算法：
1.将每个顶点V放入其自身的数据集合中。
2.按照权值Weight的升序来选择边。当选择每条边时，判断定义边的顶点是否在不同的数据集中。如果是，将此边插入最小生成树的集合中，同时，将集合中包含每个顶点的联合体取出，如果不是，就移动到下一条边。
3.重复以上操作，直到找到n-1（5）条边。

3.设计

Prim算法：

#include <iostream>
#include <vector>
const int INF = 1000000;//不可达距离
const int V = 6; //六个点
char add[V] = {'A','B','C','D','E','F'};
int map[V][V] = {
                {INF,  7,  4,INF,INF,INF},
                {  7,INF,  6,  2,INF,  4},
                {  4,  6,INF,INF,  9,  8},
                {INF,  2,INF,INF,INF,  7},
                {INF,INF,  9,INF,INF,  1},
                {INF,  4,  8,  7,  1,INF}
        };
int prim(int target)
{
        int sum_distance = 0;//总和
        int index = 0;
        int dest[V] = {0}; //到每个点的最短距离
        int visit[V] = {0};//记录那些点已经被访问              
        int i = 0, j = 0; //循环变量
        int min_dist; //最小距离中间变量

        visit[target] = true;//从自己出发所以自己已经遍历过
        //以target为起点向周边运算
        while(i < V)
        {
               dest[i] = map[target][i];//到各个点的最短距离
               ++i;
        }
        for(i = 1;i < V; ++i)
        {
            std::cout<<add[index];
            min_dist = INF;
            for(j = 0; j < V;++j)
            //贪心算法,寻找每次dest中最短的
                {
                       if(!visit[j] && min_dist > dest[j])
                        {
                                min_dist = dest[j];
                                index = j; 
                         //记录是到哪一个地方最短以及最短距离
                        }
                }
				std::cout<<"----->"<<add[index]<<std::endl;
                sum_distance += min_dist;
                visit[index] = true;
                std::cout <<min_dist<< std::endl;
                for(j = 0;j < V; ++j)
                {
                        if(!visit[j] && dest[j] > map[index][j])
                        { 
                         dest[j] = map[index][j];//更新dest
                        }
                }
        }

        return sum_distance;
}

int main()
{

        std::cout <<"Shortest distance: "<<prim(0)<<std::endl;

        return 0;
}

Kruskal算法：

#include <iostream>
#include <algorithm>

#define maxRoad 1000
using namespace std;

const int V = 6; //六个点之间
const int Wght = 9;//连接路个数
char add[V] = {'A','B','C','D','E','F'};

struct Road
{
        int Start;
        int End;
        int Weight;
};

struct Road road[Wght] = {
{1,3,4},
{2,1,7},{2,4,2},{2,6,4},
{3,2,6},{3,5,9},{3,6,8},
{4,6,7},
{5,6,1}
};


bool comp(const Road& c1,const Road& c2)
{
        return c1.Weight < c2.Weight;
}

int find(int* Root, int val)
{
        int temp = val;
        while(Root[temp] != temp)
        {
                temp = Root[temp];
        }

        if(Root[val] != val && Root[val] != temp)
        {
                Root[val] = temp;
        }

        return Root[temp];
}

void unionRoot(int *Root,int x,int y)
{
        int temp;
        if(find(Root,x) != find(Root,y))
        {
                temp = find(Root,y);
                Root[temp] = x;;
        }

}

int main()
{
        sort(road,road+Wght,comp);


        int Root[maxRoad] = {0};
        int i, j;  //循环变量
        int sum = 0;


        for(i = 0; i <= V; ++i)
         {
                Root[i] = i;
        // std::cout<<"  "<< road[i].Weight<<endl;
        }

        for(i = 0; i < Wght; ++i)
        {
                if(find(Root,road[i].Start) != find(Root,road[i].End))
                {
                        unionRoot(Root,road[i].Start,road[i].End);
                        sum += road[i].Weight;
                        std::cout<<"start  end  "<< road[i].Start<<"  "<<road[i].End<<endl;
                }

        }


        cout<<"Shortest path is :"<< sum <<endl;

        return 0;
}

4.分析

1.最小生成树：一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。简单来说就是有且仅有n个点n-1条边的连通图。
2.prim算法
需要进行n次收录，且每次收录都需要对所有的顶点进行遍历寻找权值最小的边，适合稠密图，其时间复杂度为O(n^2)，
3.Kruskal算法：
需要首先将N条边按权值大小进行升序排序，然后再遍历这N条边，且每次遍历得判断<U,V>是否在一个集合中，适合稀疏图，其时间复杂度为O(eloge）

5.源码：

Prim算法
Kruskal算法