kruskal

[toyo]

Void BiKruskal (Graph &G, Edge* &MST)
{
ParTree A(G.VerticesNum()); //声明等价类变量
MST=new Edge [G.VerticesNum()-1]; //最小生成树
int MSTtag=0; //最小生成树边的标号
int n=G.EdgeNum();
Gragh G1=G.Vertex[]; //G1,G2初始为图G的无边顶点集
Graph G2= G.Vertex[];
Edge e=G.Edge[0];
int Pivot=e.weight; //选择轴值
for(i=1;i<n;i++) //分别求 G1,G2，即将边值序列分成两子序列
{
int from=G.FromVertex(e);
int to=G.FromVertex(e);
Edge t=G.Edge[i];
if(Pivot>t.weight)
G2.InsertEdge(from,to,t.weight);
else
G1.InsertEdge(from,to,t.weight);
}
Kruskal(G1,G, MST);
Kruskal(G2,G, MST);
}
Void Kruskal (Graph &G1, Graph &G, Edge* &MST)
//形参G1用于求最小堆序列，形参G用于区分不同等价类
{
int EdgesNum= G1.EdgesNum(); //声明考虑各边一次的变量
MinHeap<Edge> H(EdgesNum); //最小值堆（minheap）
for(int i=0;i< G1.VerticesNum();i++) //将图的所有边插入最小值堆H中
for(Edge e= G1.FirstEdge(i); G1.IsEdge(e);e= G1.NextEdge(e))
-5-
http://www.paper.edu.cn
if(G1.FromVertex(e)< G1.ToVertex(e)) //因为是无向图，故应防止重复插入
H.Insert(e);
While(EdgesNum>0) //合并等价类
{
Edge e=H.RemoveMin(); //获得下一条权最小的边
if(e.weight==INFINITY) //边权值为无穷大
{
Print(“不存在最小支撑树.”);
delete []MST; //释放空间
MST=NULL; //MST是空数组
Return;
}
int from=G.FromVertex(e); //记录该条边的信息
int to =G.ToVertex(e);
if(A.Different(from.to)) //如果边e的两个顶点不在一个等价类
{
A.Union(from,to); //将边e的两个顶点所在的等价类合并为一个
AddEdgetoMST(e,MST,MSTtag++); //将边e加到MST
EdgesNum--;
}
}
}
哪位大神帮忙完善一下这段代码啊，能运行就行，3Q

[lingyin55]

给你一个可以运行的吧
，你上面的代码乱啊，命名那些都不知道是什么意思，而且里面还有网址~~~~

#include <fstream>
#include <iostream>
using namespace std;
struct myline{
       int a,b;
};
int ok[100];
int father[100];
int inimap();
int n,d;
int map[100][100];
myline lines[10000];
int inimap()
{
    ifstream fin("in.txt");
    fin >>n;
    d=0;
    int i,j,k,l=0,min,minida,minidb;
    for (i=0;i<n;i++)
    {
        for (j=0;j<n;j++)
        {
            fin >>map[i][j];
            if (i<j && map[i][j]>0)
            {
                    d++;
                    lines[l].a=i;
                    lines[l].b=j;
                    l++;
            }
        }
    }
    myline tmp;
    for (i=0;i<d;i++)
    {
        min=2000000;
        for (j=i;j<d;j++)
        {
            if (map[lines[j].a][lines[j].b]<min)
            {
               min=map[lines[j].a][lines[j].b];
               minida=j;
            }
        }
        tmp=lines[i];
        lines[i]=lines[minida];
        lines[minida]=tmp;
    }
    for (i=0;i<d;i++){cout <<map[lines[i].a][lines[i].b]<<' ';}
    cout <<endl;
    for (i=0;i<n;i++)father[i]=-1;
    return 0;
}
int find(int j)
{
    if (father[j]==-1)return j;
    int i;
    i=find(father[j]);father[j]=i;return i;
}
int together(int j,int k)
{
    if (find(j)==find(k))return 1;
    return 0;
}
int thesame(int j,int k)
{
    father[find(j)]=find(k);
    return 0;
}
int main()
{
    inimap();
    int i,j,k,cost=0;
    for (i=0;i<d;i++)
    {
        j=lines[i].a;k=lines[i].b;
        if (!together(j,k))
        {
           thesame(j,k);cost+=map[j][k];
        }
    }
    cout <<cost;system("pause");
    return 0;
}                    

[liliangbao]

up

[toyo]

Void BiKruskal (Graph &G, Edge* &MST)
{
ParTree A(G.VerticesNum()); //声明等价类变量
MST=new Edge [G.VerticesNum()-1]; //最小生成树
int MSTtag=0; //最小生成树边的标号
int n=G.EdgeNum();
Gragh G1=G.Vertex[]; //G1,G2初始为图G的无边顶点集
Graph G2= G.Vertex[];
Edge e=G.Edge[0];
int Pivot=e.weight; //选择轴值
for(i=1;i <n;i++) //分别求 G1,G2，即将边值序列分成两子序列
{
int from=G.FromVertex(e);
int to=G.FromVertex(e);
Edge t=G.Edge[i];
if(Pivot>t.weight)
G2.InsertEdge(from,to,t.weight);
else
G1.InsertEdge(from,to,t.weight);
}
Kruskal(G1,G, MST);
Kruskal(G2,G, MST);
}
Void Kruskal (Graph &G1, Graph &G, Edge* &MST)
//形参G1用于求最小堆序列，形参G用于区分不同等价类
{
int EdgesNum= G1.EdgesNum(); //声明考虑各边一次的变量
MinHeap <Edge> H(EdgesNum); //最小值堆（minheap）
for(int i=0;i < G1.VerticesNum();i++) //将图的所有边插入最小值堆H中
for(Edge e= G1.FirstEdge(i); G1.IsEdge(e);e= G1.NextEdge(e))
if(G1.FromVertex(e) < G1.ToVertex(e)) //因为是无向图，故应防止重复插入
H.Insert(e);
While(EdgesNum>0) //合并等价类
{
Edge e=H.RemoveMin(); //获得下一条权最小的边
if(e.weight==INFINITY) //边权值为无穷大
{
Print(“不存在最小支撑树.”);
delete []MST; //释放空间
MST=NULL; //MST是空数组
Return;
}
int from=G.FromVertex(e); //记录该条边的信息
int to =G.ToVertex(e);
if(A.Different(from.to)) //如果边e的两个顶点不在一个等价类
{
A.Union(from,to); //将边e的两个顶点所在的等价类合并为一个
AddEdgetoMST(e,MST,MSTtag++); //将边e加到MST
EdgesNum--;
}
}
}


这个代码是kruskal的改进，二分kruskal算法，基本思想如下，求大神帮帮忙

假设G=（V,E）是连通图，其中V是G的顶点集合，E是G的边集合。MST为G的最小生成树。二分Kruskal算法的基本思想如下：
（1） 首先从图G的各边的权值组成序列P中，选择第一个权值K作为轴值，然后将序列分割成两个子序列P1和P2(其中P1包含所有小于或等于轴值K的权值,P2包含所有大于轴值K的权值),根据权值对应于边的原则，分别得到对应于P1的边集E1和对应于P2的边集E2。
（2） 将顶点集分为|V|个等价类，每个等价类包括一个顶点；
（3） 对于图G1=(V,E1),以权值的从小到大的顺序处理各条边，如果某条边连接两个不同等价类的顶点，则这条边被添加到MST，两个等价类被合并为一个；反复执行此过程，直到E1种各条边均被考虑过一次；
（4） 对于图G而言，此时等价类个数为1+|E2|，以权值的从小到大的顺序处理E2中各条边，如果某条边连接图G中两个不同等价类的顶点，则这条边被添加到MST，两个等价类被合并为一个；反复执行此过程，直到E2中各条边均被考虑过一次。

[pml1988]

应该见名知意，你取变量名太让人看不懂啦

[liyong_zhang]

#include <iostream>
#define INF 0x3fff
#define MAXN 100
using namespace std;
typedef struct 
{
	int s;//start结点 
	int e;//end结点 
	int w;//weight权值 
}edge;
edge e[MAXN*MAXN/2];//存储每一条边的数组 
void insertsort(edge e[],int n)//直接插入排序 
{
	int i,j;
	edge temp;
	for(i = 0 ; i < n ;i++)
	{
		temp = e[i];
		j = i - 1;
		while(j >= 0 && temp.w < e[j].w)
		{
			e[j+1]= e[j];
			j--;
		}
		e[j+1] = temp;
	}
}
void kruskal(int n,int mat[][MAXN])//Kruskal实现 
{
	int i,j,k,m1,m2,sn1,sn2;
	edge e[MAXN*MAXN/2];
	int vset[MAXN];
	for(i = 0 ; i < n ; i++)//每个节点都初始化 
		vset[i] = i;
	k = 0;

	for(i = 0 ; i < n;i++)
	{
		for(j = 0 ; j < n;j++)
		{
			if(mat[i][j] != 0 && mat[i][j] != INF)//将邻接矩阵中的每一条边都加入到边权值的数组中 
			{
				e[k].s = i;e[k].e = j;
				e[k].w = mat[i][j];
				k++;
			}
		}
	}
	insertsort(e,k);//对边的权值从大到小排序，这里采用直接插入排序，如果采用堆排序时间复杂度会减少 
	int cnt = 1 ;//记录加入到最小生成树的边的数量 
	k = 0;
	while(cnt < n)
	{
		m1 = e[k].s; m2 = e[k].e;//记录这条边的start , end 结点 
		sn1 = vset[m1]; sn2 = vset[m2];//看这两个结点属于哪一个set 
		if(sn1 != sn2)//如果不等，说明这两个结点不在一个生成树中，合并 
		{
			printf("edge (%d,%d):%d is added!\n", e[k].s,e[k].e,e[k].w);
			cnt++;
			for(i = 0 ; i < n ; i++)
			{
				if(vset[i] == sn2)//把所有的原有的生成树的结点重新加入到新的生成树中 
					vset[i] = sn1;
			}
		}
		k++;//k为边的权值数组的Index 
	}	

}
int mat[MAXN][MAXN];
int main()
{
	memset(mat,0,sizeof(mat));
	int num;
	printf("please input vertex:");
	scanf("%d",&num);
	int n;
	printf("input the number of edge:");
	scanf("%d",&n);
	int t = n;
	while(t--)
	{
		int a,b,cost;
		scanf("%d %d %d",&a,&b,&cost);
		--a,--b;
		if(mat[a][b] == 0 && mat[b][a] == 0 || cost < mat[a][b] )
			mat[a][b] = mat[b][a] = cost;
	}
	int i,j;
	for(i = 0 ; i < num;i++){
		for(j = 0 ; j < num; j++)
			printf("%4d",mat[i][j]);printf("\n");}
	kruskal(num,mat);
/*
test data:
6
10
1 2 6
1 3 1
1 4 5
2 3 5
3 4 5
2 5 3
3 5 6
3 6 4
4 6 2
5 6 6
*/	
	return 0;
}