0025算法笔记——【贪心算法】最小生成树问题

     1、问题描述

     设G =(V,E)是无向连通带权图，即一个网络。E中每条边(v,w)的权为c[v][w]。如果G的子图G’是一棵包含G的所有顶点的树，则称G’为G的生成树。生成树上各边权的总和称为该生成树的耗费。在G的所有生成树中，耗费最小的生成树称为G的最小生成树。

     网络的最小生成树在实际中有广泛应用。例如，在设计通信网络时，用图的顶点表示城市，用边(v,w)的权c[v][w]表示建立城市v和城市w之间的通信线路所需的费用，则最小生成树就给出了建立通信网络的最经济的方案。 

     2、MST性质

     设G=(V,E)是连通带权图，U是V的真子集。如果(u,v)ÎE，且uÎU，vÎV-U，且在所有这样的边中，(u,v)的权c[u][v]最小，那么一定存在G的一棵最小生成树，它以(u,v)为其中一条边。这个性质有时也称为MST性质。 

     MST性质的证明：如图所示，假设G的任何一颗最小生成树都不包含边(u,v)。将边(u,v)添加到G的一颗最小生成树T上，将产生含有边(u,v)的圈，并且在这个圈上有一条不同于(u,v)的边(u',v')，使得u'ÎU，v‘ÎV-U。将边(u',v')删去，得到G的另一颗生成树T'。由于c[u][v]<=c[u'][v']，所以T'的耗费<=T的耗费。于是T'是一颗含有边(u,v)的最小生成树，这与假设矛盾。

     3、Prim算法

     设G=(V,E)是连通带权图，V={1,2,…,n}。构造G的最小生成树的Prim算法的基本思想是：首先置S={1}，然后，只要S是V的真子集，就作如下的贪心选择：选取满足条件iÎS，jÎV-S，且c[i][j]最小的边，将顶点j添加到S中。这个过程一直进行到S=V时为止。在这个过程中选取到的所有边恰好构成G的一棵最小生成树。 

     算法具体代码如下：

//4d6 贪心算法 最小生成树 Prim算法
#include "stdafx.h"
#include   
#include  
#include  
using namespace std; 

#define inf 9999;
const int N = 6;
ifstream fin("4d6.txt");

template
void Prim(int n,Type c[][N+1]);

int main()
{
	int c[N+1][N+1];
	cout<<"连通带权图的矩阵为："<>c[i][j];    
            cout<
void Prim(int n,Type c[][N+1])
{
	Type lowcost[N+1];//记录c[j][closest]的最小权值
	int closest[N+1];//V-S中点j在S中的最邻接顶点

	bool s[N+1];

	s[1] = true;

	//初始化s[i],lowcost[i],closest[i]
	for(int i=2; i<=n; i++)
	{
		lowcost[i] = c[1][i];
		closest[i] = 1;
		s[i] = false;
	}

	for(int i=1; i

         上述代码中，数组closest[j]是j( j Î V-S)在S中的领接顶点，它与j在S中的其它顶点相比较有c[j][cloest[j]]<=c[j][k]。lowest[j]的值就是c[j][cloest[j]]。在算法执行过程中，先找出V-S中是lowest值最小的顶点j，然后根据数组closest选取边(j,cloest[j])，最后将j添加到S中，并对closest和lowest作必要的修改。

     程序运行结果为：

      例如，对于下图中的带权图，按Prim算法选取边的过程如图所示：

     利用最小生成树性质和数学归纳法容易证明，上述算法中的边集合T始终包含G的某棵最小生成树中的边。因此，在算法结束时，T中的所有边构成G的一棵最小生成树，Prim算法所需要的计算时间为O(n^2)。

     4、Kruskal算法

     Kruskal算法构造G的最小生成树的基本思想是，首先将G的n个顶点看成n个孤立的连通分支。将所有的边按权从小到大排序。然后从第一条边开始，依边权递增的顺序查看每一条边，并按下述方法连接2个不同的连通分支：当查看到第k条边(v,w)时，如果端点v和w分别是当前2个不同的连通分支T1和T2中的顶点时，就用边(v,w)将T1和T2连接成一个连通分支，然后继续查看第k+1条边；如果端点v和w在当前的同一个连通分支中，就直接再查看第k+1条边。这个过程一直进行到只剩下一个连通分支时为止。

     实现算法Kruskal需要准备两个数据结构：(1)最小堆MinHeap，按权的递增顺序查看的边的序列可以看做是一个优先队列，它的优先级为边权；(2)并查集UnionFind，主要包括Union(a,b)和Find(v)两个基本运算：Union(a,b)将两个连通分支a和b连接起来，所得的结果为A或B；Find(v)返货U总包含顶点v的连通分支的名字。这个运算用来确定某条边的两个端点所属的连通分支。

    具体代码如下：

     (1)MinHeap.h

#include 
using namespace std;
template
class MinHeap
{
	private:
		T *heap; //元素数组，0号位置也储存元素
		int CurrentSize; //目前元素个数
		int MaxSize; //可容纳的最多元素个数

		void FilterDown(const int start,const int end); //自上往下调整，使关键字小的节点在上
		void FilterUp(int start); //自下往上调整

	public:
		MinHeap(int n=1000);
		~MinHeap();
		bool Insert(const T &x); //插入元素

		T RemoveMin(); //删除最小元素
		T GetMin(); //取最小元素

		bool IsEmpty() const;
		bool IsFull() const;
		void Clear();
};

template
MinHeap::MinHeap(int n)
{
	MaxSize=n;
	heap=new T[MaxSize];
	CurrentSize=0;
}

template
MinHeap::~MinHeap()
{
	delete []heap;
}

template
void MinHeap::FilterUp(int start) //自下往上调整
{
	int j=start,i=(j-1)/2; //i指向j的双亲节点
	T temp=heap[j];

	while(j>0)
	{
		if(heap[i]<=temp)
			break;
		else
		{
			heap[j]=heap[i];
			j=i;
			i=(i-1)/2;
		}
	}
	heap[j]=temp;
}

template
void MinHeap::FilterDown(const int start,const int end) //自上往下调整，使关键字小的节点在上
{
	int i=start,j=2*i+1;
	T temp=heap[i];
	while(j<=end)
	{
		if( (jheap[j+1]) )
			j++;
		if(temp<=heap[j])
			break;
		else
		{
			heap[i]=heap[j];
			i=j;
			j=2*j+1;
		}
	}
	heap[i]=temp;
}

template
bool MinHeap::Insert(const T &x)
{
	if(CurrentSize==MaxSize)
		return false;

	heap[CurrentSize]=x;
	FilterUp(CurrentSize);

	CurrentSize++;
	return true;
}

template
T MinHeap::RemoveMin( )
{
	T x=heap[0];
	heap[0]=heap[CurrentSize-1];

	CurrentSize--;
	FilterDown(0,CurrentSize-1); //调整新的根节点

	return x;
}

template
T MinHeap::GetMin()
{
	return heap[0];
}

template
bool MinHeap::IsEmpty() const
{
	return CurrentSize==0;
}

template
bool MinHeap::IsFull() const
{
	return CurrentSize==MaxSize;
}

template
void MinHeap::Clear()
{
	CurrentSize=0;
}

     (2)UnionFind.h

class UnionFind
{
	public: 
		UnionFind(int);
		~UnionFind();
	public:
		int Find(int);
		void Union(int, int);
	private:
		int EleNum;
		int *Parents;
		int *Rank;
};

UnionFind::UnionFind(int n)
{
	EleNum = n;
	Parents = new int[EleNum];
	Rank = new int[EleNum];
	for(int i = 0; i < EleNum; i++)
	{
		Parents[i] = -1;
		Rank[i] = 1;
	}
}

UnionFind::~UnionFind()
{
	delete[] Parents;
	delete[] Rank;
}

int UnionFind::Find(int i)
{
	int r = i;
	while(Parents[r] != -1) 
		r = Parents[r];
	while(r != i)
	{
		int q = Parents[i];
		Parents[i] = r;
		i = q;
	}
	return r;
}

void UnionFind::Union(int i, int j)
{
	int a = Find(i);
	int b = Find(j);

	if(a == b) return;
	if(Rank[a] > Rank[b])
	{
		Parents[b] = a;
		Rank[a] += Rank[b]; 
	}
	else
	{
		Parents[a] = b;
		Rank[b] += Rank[a];
	}
}

     (3)4d6-2.cpp

//4d6-2 贪心算法 最小生成树 Kruskal算法
#include "stdafx.h"
#include "MinHeap.h"
#include "UnionFind.h"
#include   
#include  
#include  
using namespace std; 

const int N = 10;//图的边数
const int M = 6;//图的顶点数
ifstream fin("4d6-2.txt");

template 
class EdgeNode
{
	friend ostream& operator <<(ostream&,EdgeNode);
	
	//不知道为什么，一去掉注释就会报错误LNK2019: 无法解析的外部符号 错误
	//friend bool Kruskal(int,int,EdgeNode[],EdgeNode[]);
	friend int main(void);

	public:
		operator Type() const
		{
			return weight;
		}
	//暂时这么放了，日后解决
	//private:
		Type weight;
		int u,v;
};

template 
bool Kruskal(int n,int e,EdgeNode E[],EdgeNode t[]);

int main()
{
	EdgeNode E[N+1],t[N+1];//存储连通带权图所有边的两端顶点，权)
	cout<<"连通带权图所有边的两端顶点，权分别为："<>E[i].u>>E[i].weight>>E[i].v;    
		cout<<"u:"<
bool Kruskal(int n,int e,EdgeNode E[],EdgeNode t[])
{
	MinHeap> H(e);

	//初始化最小堆
	for(int i=1; i<=e; i++) H.Insert(E[i]);

	UnionFind U(n);

	int k = 1;
	while(e && k x;
		x = H.RemoveMin();
		e--;

		//返回u中包含顶点V的连通分支的名字
		int a = U.Find(x.u);
		int b = U.Find(x.v);

		if(a!=b)
		{
			t[k++] = x;
			U.Union(a,b);
		}
	}

	return (k==n-1);
}

      例如，对前面的连通带权图，按Kruskal算法顺序得到的最小生成树上的边如下图所示：

     当图的边数为e时，Kruskal算法所需的计算时间是 。当时，Kruskal算法比Prim算法差，但当时，Kruskal算法却比Prim算法好得多。程序运行结果为：