贪心算法

贪心算法之prim

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

解决上述问题称为prim算法, 他是一种产生最小生成树的算法, prim在定点选择利用了贪婪算法

//如图解决上述问题, 要求最短
#include <iostream>
#include <vector>
//不可达距离
const int INF = 1000000;
//地图表
const int N = 6; //六个点之间
//输出点标识方便查看
char add[N] = {'A','B','C','D','E','F'};

int map[N][N] = {
                {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[N] = {0}; //到每个点的最短距离
        int visit[N] = {0};//记录那些点已经被访问              
        int i = 0, j = 0; //循环变量
        int min_dist; //最小距离中间变量

        visit[target] = true;//从自己出发所以自己是已经遍历过的
//以target为起点向周边运算
        while(i < N)
        {
                dest[i] = map[target][i];//到各个点的最短距离
                ++i;
        }
        for(i = 1;i < N; ++i)
        {
            	std::cout<<add[index];
                min_dist = INF;
                for(j = 0; j < N;++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 < N; ++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算法

Kruskal算法

#include <iostream>
#include <algorithm>

#define maxRoad 1000
using namespace std;

const int N = 6; //六个点之间
const int Wght = 9;//连接路个数
char add[N] = {'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 <= N; ++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;
}
~
~