nyoj38布线问题两种算法详解

布线问题

时间限制：1000 ms  |           内存限制：65535 KB

难度：4

描述

南阳理工学院要进行用电线路改造，现在校长要求设计师设计出一种布线方式，该布线方式需要满足以下条件：
1、把所有的楼都供上电。
2、所用电线花费最少

输入

第一行是一个整数n表示有n组测试数据。(n<5)
每组测试数据的第一行是两个整数v,e.
v表示学校里楼的总个数(v<=500)
随后的e行里，每行有三个整数a,b,c表示a与b之间如果建铺设线路花费为c(c<=100)。（哪两栋楼间如果没有指明花费，则表示这两栋楼直接连通需要费用太大或者不可能连通）
随后的1行里，有v个整数,其中第i个数表示从第i号楼接线到外界供电设施所需要的费用。( 0<e<v*(v-1)/2 )
（楼的编号从1开始），由于安全问题，只能选择一个楼连接到外界供电设备。
数据保证至少存在一种方案满足要求。

输出

每组测试数据输出一个正整数,表示铺设满足校长要求的线路的最小花费。

样例输入

1

4 6

1 2 10

2 3 10

3 1 10

1 4 1

2 4 1

3 4 1

1 3 5 6

样例输出

4

 

prim算法：

#include<stdio.h>  
#include<string.h>  
#include<algorithm>  
#define INF 0x3f3f3f  
#define max 500+10  
using namespace std;  	
bool cmp(int x,int y)  		//利用sort函数来将城市需要外接电路花费排序 
{  
    return x<y;  	
}  
int lowcost[max],map[max][max],visit[max],contact[max];  	//lowcost:每个点对当前mst的最短距离    map：记录都那两点之间有联系   visit：记录哪个点已经进入最小树中   contact：每栋楼需要外接电路的花费 
int school;  		//大楼数目 
int prime()  
{  
    int i,j;  
    int next;//下一并入点  	
    int min,mincost=0;  
    memset(visit,0,sizeof(visit));//将visit数组初始化为0   
    for(i=1;i<=school;i++)  		//初始化第一组lowcost数组，得出现在每个点与当前mst的距离 
    {  
        lowcost[i]=map[1][i];  
    }  
    visit[1]=1;  	
    for(i=2;i<=school;i++)  	
    {  
        min=INF;  	//记录最小权值 
        for(j=1;j<=school;j++)  
        {  
            if(!visit[j]&&min>lowcost[j])//找最小权值   
            {  
                min=lowcost[j];  
                next=j;  
            }  
        }  
        mincost+=min;  
        visit[next]=1;  
        for(j=1;j<=school;j++)  
        {  
            if(!visit[j]&&lowcost[j]>map[next][j])//更新lowcost数组   
            {  
                lowcost[j]=map[next][j];  
            }   
        }  
    }  
    return mincost;   
}   
int main()  
{  
    int t,i,j;  	
    int line,need;  	//line ： 行数   need：最后所需要的花费 
    int x,y,c;  //x,y:楼标    c:花费 
    scanf("%d",&t);  
    while(t--)  
    {  
        memset(map,INF,sizeof(map));  //将map连接地图数组初始化为极大值 
        scanf("%d%d",&school,&line);  	//输入大楼数目  和  连接路线数目 
        while(line--)  				 
        {  
            scanf("%d%d%d",&x,&y,&c);  //输入楼标与花费 
            map[x][y]=map[y][x]=c;  	//将每一处连接权值都录入地图 
        }  
        for(i=0;i<school;i++)  	
        {  
            scanf("%d",&contact[i]);  //录入每一栋楼外接电路的花费 
        }  
        sort(contact,contact+school,cmp);  	//排序 
        need=contact[0];  	//将最大值取出 
        need+=prime();  		//调用函数，将函数返回值加到need上面 
        printf("%d\n",need);   
    }  
    return 0;  
}  

kruskal算法：

#include<stdio.h>  		
#include<algorithm>  
#define max 200000+10  
using namespace std;  
int set[550],contact[550];  	//set ： 记录每个点的根结点 
struct line  
{  
    int money;  	//建立结构体 ： money ：花费  start：开始点  end：结束点 
    int start;  
    int end;  
}num[max];  
bool cmp(line a,line b)  	//以花费大小从小到大将每一组联系排列 
{  
    return a.money<b.money;  
}  
bool cmp1(int x,int y)  
{  
    return x<y;  	// 设置 sort 排序比较函数 
}  
int find(int p)  	//并查集   ：寻找根结点 
{  
    int child=p;  
    int t;  
    while(p!=set[p])  
    p=set[p];  
    while(child!=p)  
    {  
        t=set[child];  
        set[child]=p;  
        child=t;  
    }  
    return p;  
}  
void merge(int x,int y)  	//连接  将两个联系连接成图 
{  
    int fx=find(x);  
    int fy=find(y);  
    if(fx!=fy)  
    set[fx]=fy;  
}  
int main()  
{  
    int n,i,j,t;  
    int school,road,need;  	//shool：学校数   need：路的数 
    scanf("%d",&n);  
    while(n--)  
    {  
        scanf("%d%d",&school,&road);  
        for(i=0;i<road;i++)  
        {  
            scanf("%d%d%d",&num[i].start,&num[i].end,&num[i].money);  	//用一个数组分别用结构体来存储开始结束和花费 
        }  
        sort(num,num+road,cmp);  	//将以花费大小将数组排序 
        for(i=1;i<=school;i++)  	//输入每个楼外接电路花费大小 
        {  
            set[i]=i;  				//初始化根结点为自己 
            scanf("%d",&contact[i]);  //顺便输入各自外接电路花费 
        }  
        sort(contact+1,contact+school+1,cmp1);  
        need=contact[1];  	//最小花费先记录 contact【1】 
        for(i=0;i<road;i++)  
        {  
            if(find(num[i].start)!=find(num[i].end))  
            {  
                merge(num[i].start,num[i].end);  
                need+=num[i].money;  
            }  
        }  
        printf("%d\n",need);  
    }  
    return 0;  
}  

有的图论问题一眼看过去就知道是最短路径问题，这个时候都可以挑适合顺手的算法代码直接敲上去，如果第一次理解需要一步一步的理解含义，后面用的多了可以直接往里面套代码就行。

//prim核心代码




#define INF 0x3f3f3f
#define max x  //x为题目中图的规模 
int lowcost[maxx],map[maxx][maxx],visit[maxx]; //lowcost：记录权值
											   //map：记录点与点之间的关系
											   //visit：记录点是否别访问过   
int num; 		//记录共有几个点 
void prim()
{
	int i,j;
	int next;   //下一并入点
	int min,mincost;    //min:记录每次的最小权值   mincost；记录总的最小权值 
	memset(visit,0,sizeof(visit));  //将数组初始化为0标记为为访问过
	for(i=1;i<=num;i++)
	{
		lowcost[i]=map[1][i];	//初始化第一轮lowcost的值 
	} 
	visit[1]=1;				//设置1为起点 
	for (i=2;i<=num;i++)
	{
		min=INF;		//将min初始为最大值 
		for(j=1;j<=num;j++)		//寻找最小权值 
		{
			if(!visit[j]&&min>lowcost[j])	//找到最小权值记录 
			{
				min=lowcost[j];
				next=j;
			}
		}
		mincost+=min;		//最小权值累加 
		visit[next]=1;		//将访问过的点标记 
		for(j=1;j<=num;j++)		//更新lowcost数组 
		{
			if(!visit[j]&&lowcost[j]>map[next][j])
			{
				lowcost[j]=map[next][j];
			}
		}		
	}
	return mincost;
} 

//kruskal 算法核心代码


#include<altorithm>
#define maxx  x  //x为 范围
int set[maxx];		//set为 头结点数组 
struct line		//设置结构体 
{
	int money;
	int start;
	int end;
}num[maxx];
bool cmp(line a,line b)	//设置比较函数 
{
	return a.money < b.money ;
}
int find(int p)		//并查集 
{
	int child=p;
	int t;
	while(p!=set[p])
	p=set[p];
	while(child!=p)
	{
		t=set[child];
		set[child]=p;
		child=t;
	}
	return p;
}
void merge(int x,int y)
{
	int fx=find(x);
	int fy=find(y);
	if(fx!=fy)
		set[fx]=fy; 
}

int main()		//主函数 
{
	for(i=0;i<road;i++)
	{
		//输入花费和路径起始结束点 
	}
	sort(num,num+road,cmp);	//排序 
	for(i=1;i<=school;i++)	//初始化头结点数组 
	{
		set[i]=[i];
	} 
	int need=0; 
	for(i=0;i<road;i++)		//累加最小权值 
	{
		if(find(num[i].start )!=find(num[i].end ))
		{
			merge(num[i].start ,num[i].end )
			need+=num[i].money ;
		}
	}
	printf("%d\n",need);
}