一、最小生成樹---prim演算法實現

思想：

1、從任意一個頂點開始構造生成樹，假設就從1號頂點吧， 首先將頂點1加入生成樹中，用一個一維陣列book來標記 哪些頂點已經加入了生成樹。
 2、用陣列dis記錄生成樹到各個頂點的距離，最初生成樹中之後1號 頂點，有直連邊時，陣列dis中儲存的就是1號頂點到該頂點 的邊的權值，沒有直連邊的時候就是無窮大，即初始化dis陣列。
 3、從陣列dis中選出離生成樹最近的頂點（假設這個頂點為j） 加入到生成樹中（即在陣列dis中找到最小值）。再以j為中間點， 更新生成樹到每一個非樹頂點的距離（就是鬆弛啦）， 即如果dis[k]>e[j][k]則更新dis[k]=e[j][k]。
 4、重複第三步，直到生成樹中有n個頂點為止。
 

程式碼實現：

<span style="font-size:18px;">#include<stdio.h>
int main(void)
{
	int n,m,i,j;
	int k,min;
	int t1,t2,t3;
	int e[7][7],dis[7];
	int book[7]={0};//book陣列初始化 
	int inf=99999999;
	int count=0,sum=0;
	//count用來記錄生成樹中頂點的個數，sum用來儲存路徑之和 
	scanf("%d %d",&n,&m);
	//讀入n，m，n表示頂點的個數，m表示邊的條數。 
	//初始化 
	for(i=1;i<=n;i++)
	{
		for(j=1;j<=n;j++)
		{
			if(i==j)
			{
				e[i][j]=0;
			}
			else
			{
				e[i][j]=inf;
			}
		}
	}
	//開始讀入邊 
	for(i=1;i<=m;i++)
	{
		scanf("%d%d%d",&t1,&t2,&t3);
		//注意無向圖，需要將邊反向在儲存一遍 
		e[t1][t2]=t3;
		e[t2][t1]=t3;
	}
	//初始化dis陣列，這裡是1號頂點到各個頂點的初始距離，因為當前生成樹中只有1號頂點	
	for(i=1;i<=n;i++)
	{
		dis[i]=e[1][i];
	}
	//將1號頂點加入生成樹，這裡book來標記一個頂點是否已經加入生成樹 
	book[1]=1;
	count++;
	while(count<n)
	{
		min=inf;
		for(i=1;i<=n;i++)
		{
			if(book[i]==0&&dis[i]<min)
			{
				min=dis[i];
				j=i;
			}
		}
		book[j]=1;
		count++;
		sum=sum+dis[j];
		//掃描當前頂點j所有的邊，再以j為中間點，更新生成樹到每一個非樹頂點的距離； 
		for(k=1;k<=n;k++)
		{
			if(book[k]==0&&dis[k]>e[j][k])
			{
				dis[k]=e[j][k];
			} 
		}
	}
	printf("%d\n",sum);
	return 0;	
} 
</span>
 

需要用到三個陣列
1、陣列dis用來記錄生成樹到各個頂點的距離
2、陣列h是一個最小堆，堆裡面儲存的是頂點編號。（請注意，這裡並不是按照頂點編號的大小來建立最小堆的，而是按照頂點在陣列dis中所對應的值來建立這個最小堆的）
3、pos陣列來記錄每個頂點在最小堆中的位置


例如，下圖中
下面最小堆中的圓圈中儲存的是頂點編號，圓圈右下角的數是該頂點（圓圈裡面的數）到生成樹的最短距離，即陣列dis中儲存的值 

程式碼實現：

<span style="font-size:18px;">#include<stdio.h>
int dis[7],book[7]={0};
//book陣列用來記錄哪些頂點已經放入生成樹中 
int h[7],pos[7],size; 
//h陣列用來儲存堆，pos陣列用來儲存每個頂點在堆中的位置，size為堆的大小 
//交換函式，用來交換堆中的兩個元素的值 
void swap(int x,int y)
{
	int t;
	t=h[x];
	h[x]=h[y];
	h[y]=t;
	//同步更新pos 
	t=pos[h[x]];
	pos[h[x]]=pos[h[y]];
	pos[h[y]]=t;
} 
//向下調整函式，傳入一個需要向下調整的結點編號 
void siftdown(int i)
{
	int t,flag=0;
	//flag用來標記是否需要繼續向下調整 
	while(i*2<=size&&flag==0)
	{
		//比較i和它左兒子i*2在dis中的值，並用t記錄值較小的結點編號 
		if(dis[h[i]]>dis[h[i*2]])
		{
			t=i*2;
		}
		else
		{
			t=i;
		}
		//如果它有右兒子，再對右兒子進行討論 
		if(t*2+1<=size)
		{
			//如果右兒子的值更小，更新較小的結點編號 
			if(dis[h[t]]>dis[h[i*2+1]])
			{
				t=i*2+1;
			}
		}
		//如果發現最小的結點編號不是自己，說明子結點中有比父結點更小的 
		if(t!=i)
		{
			//交換它們 
			swap(t,i);
			//更新i為剛才與它交換的兒子結點的編號，便於接下來繼續向下調整 
			i=t;
		}
		else
		{
			//否則說明當前的父結點已經比兩個子結點都要小了，不需要再進行調整了 
			flag=1;
		}
	}
}
//傳入一個需要向上調整的結點編號i 
void siftup(int i)
{
	int flag=0;
	//flag用來標記是否需要繼續向上調整 
	if(i==1)
	{
		//如果是堆頂，就返回，不需要調整 
		return ;
	}
	//不在堆頂，並且當前結點i的值比父結點小的時候繼續向上調整 
	while(i!=1&&flag==0)
	{
		//判斷是否比父結點的小 
		if(dis[h[i]]<dis[h[i/2]])
		{
			//交換它和它父親的位置 
			swap(i,i/2);
		}
		else
		{
			//表示已經不需要調整了，當前結點的值比父結點的值要大 
			flag=1;
		}
		//更新編號i為它父結點的編號，從而便於下一次繼續向上調整 
		i=i/2;
	}
}
//從堆頂取出一個元素 
int pop()
{
	int t;
	t=h[1];//用一個臨時變數記錄堆頂點的值 
	pos[t]=0;//其實這句話可以不要 
	h[1]=h[size];//將堆的最後一個點賦值到堆頂 
	pos[h[1]]=1;
	size--;//堆的元素減少1 
	siftdown(1);//向下調整 
	return t;//返回之前記錄的堆頂點 
}
int main(void)
{
	int n,m,i,j,k;
	//u,v,w和next的陣列大小要根據實際情況來設定，此圖是無向圖，要比2*m的最大值要大1 
	//first要比n的最大值要大1，要比2*m的最大值要大1 
	int u[19],v[19],w[19],first[7],next[19];
	int inf=99999999;
	//count用來記錄生成樹中頂點的個數，sum用來記錄儲存路徑之和 
	int count=0,sum=0;
	//讀入n和m,n表示頂點個數,m表示邊的條數 
	scanf("%d %d",&n,&m);
	//開始讀入邊 
	for(i=1;i<=m;i++)
	{
		scanf("%d%d%d",&u[i],&v[i],&w[i]);
	}
	//這裡是無向圖，所以需要將所有的邊再反向儲存一次 
	for(i=m+1;i<=2*m;i++)
	{
		u[i]=v[i-m];
		v[i]=u[i-m];
		w[i]=w[i-m];
	}
	//開始使用鄰接表儲存邊 
	for(i=1;i<=n;i++)
	{
		first[i]=-1;
	}
	for(i=1;i<=2*m;i++)
	{
		next[i]=first[u[i]];
		first[u[i]]=i;
	}
	//將1號頂點加入生成樹，book陣列來標記一個頂點是否已經加入生成樹 
	book[1]=1;
	count++;
	//初始化dis陣列，這裡是1號頂點到其餘各個頂點的初始距離 
	dis[1]=0;
	for(i=2;i<=n;i++)
	{
		dis[i]=inf;
	}
	k=first[1];
	while(k!=-1)
	{
		dis[v[k]]=w[k];
		k=next[k];
	} 
	//初始化堆 
	size=n;
	for(i=1;i<=size;i++)
	{
		h[i]=i;
		pos[i]=i;
	}
	for(i=size/2;i>=1;i--)
	{
		siftdown(i);
	}
	//先彈出一個堆頂元素，因為此時堆頂是1號頂點 
	pop();
	while(count<n)
	{
		j=pop();
		book[j]=1;
		count++;
		sum=sum+dis[j];
		//掃描當前頂點j所有的邊，再以j為中間結點，進行鬆弛 
		k=first[j];
		while(k!=-1)
		{
			if(book[v[k]]==0&&dis[v[k]]>w[k])
			{
				//更新距離 
				dis[v[k]]=w[k];
				//對該點在堆中進行向上調整
				//pos[v[k]]儲存的是頂點v[k]在堆中的位置 
				siftup(pos[v[k]]); 
			}
			k=next[k];
		}
	}
	printf("%d\n",sum);
	return 0;
}</span>