并査集 & 克鲁斯卡尔&普里姆

最小生成树：构造连通网的最小代价生成树。（包含所有顶点，以及n-1条边。）也就是说，一个连通图的生成树是一个极小连通子图，包含图中所有顶点，以及足以构成一棵树的n-1条边。经典的有两种算法：Prim普鲁姆和克鲁斯卡尔Kruskal。

比如上面左边是一个有向图G，右边是它的极小连通子图。

【并查集】

*使用*

用于处理一些不相交的的合并问题。一些常见的用途有求连通子图、求最小生成树的 Kruskal 算法和求最近公共祖先（Least Common Ancestors, LCA）等

*大概方法*

首先会存在一组不相交的动态集合，一般都会使用一个整数表示集合中的一个元素。每个集合可能包含一个或多个元素，并选出集合中的某个元素作为代表。每个集合中具体包含了哪些元素是不关心的，具体选择哪个元素作为代表一般也是不关心的。我们关心的是，对于给定的元素，可以很快的找到这个元素所在的集合（的代表），以及合并两个元素所在的集合，而且这些操作的时候用树来表示集合，树的每个节点就表示集合中的一个元素，树根对应的元素就是该集合的代表。

*步骤*

①建立 makeSet(s)：建立一个新的并查集，其中包含 s 个单元素集合。

void makeSet(int size)   //初始化
{
    for(int i = 0;i < size;i++) 
		uset[i] = i;     //令每个的代表都是自己。
}

②合并 unionSet(x, y)：把元素 x 和元素 y 所在的集合合并，要求 x 和 y 所在的集合不相交，如果相交则不合并。合并就是将一个集合的树根指向另一个集合的树根，就是总是将比较矮的树作为子树，添加到较高的树中。为了保存树的高度，需要额外使用一个与 par 同长度的数组，并将所有元素都初始化为 0。

void unionSet(int x, int y) 
{
    if ((x = find(x)) == (y = find(y))) 
		return;
    if (rank[x] > rank[y])     //树X比树Y高
		par[y] = x;           //让Y的parent为X
    else 
	{
        par[x] = y;
        if (rank[x] == rank[y])  //若两棵树一样高
			rank[y]++;      //让成为根节点的那棵树再+1；
    }
}

合并一：//按秩合并
const int MAXSIZE = 500;
int uset[MAXSIZE];
int rank[MAXSIZE];
void makeSet(int size)
{
 
    for(int i = 0;i < size;i++)  uset[i] = i;
    for(int i = 0;i < size;i++)  rank[i] = 0;
}
int find(int x) 
{
    if (x != uset[x]) 
		uset[x] = find(uset[x]);
    return uset[x];
}
void unionSet(int x, int y) 
{
    if ((x = find(x)) == (y = find(y))) 
		return;
    if (rank[x] > rank[y]) uset[y] = x;
    else 
	{
        uset[x] = y;
        if (rank[x] == rank[y]) 
			rank[y]++;
    }
}

//合并二：
//按元素个数合并，将包含节点较少的树根，指向包含节点较多的树根。若 uset 的值是正数，则表示该元素的父节点；若是负数，则表示该元素是所在集合的代表（即树根），而且值的相反数即为集合中的元素个数。
//取某个元素 x 所在集合包含的元素个数，可以使用 -uset[find(x)] 得到。
const int MAXSIZE = 500;
int uset[MAXSIZE];
void makeSet(int size) 
{
    for(int i = 0;i < size;i++) 
		uset[i] = -1;
}

//int find(int x)
//{
//    if (uset[x] < 0) return x;
//    uset[x] = find(uset[x]);
//    return uset[x];
//}

int find(int x) 
{
    int p = x, t;
    while (uset[p] >= 0) p = uset[p];
    while (x != p)
	{
        t = uset[x];
        uset[x] = p;
        x = t;
    }
    return x;
}
void unionSet(int x, int y)
{
    if ((x = find(x)) == (y = find(y)))
		return;
    if (uset[x] < uset[y])
	{
        uset[x] += uset[y];
        uset[y] = x;
    } 
	else 
	{
        uset[y] += uset[x];
        uset[x] = y;
    }
}
}

③查找 find(x)：找到元素 x 所在的集合的代表，该操作也可以用于判断两个元素是否位于同一个集合，只要将它们各自的代表比较一下就可以了。如果每次都沿着父节点向上查找，那时间复杂度就是树的高度，完全不可能达到常数级。这里需要应用一种非常简单而有效的策略——路径压缩。就是在每次查找时，令查找路径上的每个节点都直接指向根节点。

//不压缩查找//
int find(int x)  
{
    if (x != uset[x]) 
		uset[x] = find(uset[x]);    //递归查找
    return uset[x];
}


//压缩查找//
int find(int x)    
{
    int p = x, t;
    while (uset[p] != p)
		p = uset[p];     //保存根节点。
    while (x != p) 
	{ 
		t = uset[x];   //保存此结点的前结点
		uset[x] = p;   //让此结点的前结点直接等于根节点
		x = t;        //继续让前结点的前结点等于根节点，让经过的元素的前结点为根节点。
	}
    return x;
}

【克鲁斯卡尔Kruskal】

*注意*

以边来构建最小生成树，要考虑是否会形成环路，利用边集数组，要先把边按照权值的大小排序，比如，下面这张图，一开始点（4，7）的权值位7，先把它加入最小生成树那么输出par[4]=7,代表4与7连接。然后点（2，8）加入最小生成树，par[2]=8，继续加下去par[0]=1;当遇到（0，5）由于之前par[0]=1，那么就找par[1]的是否为0，是的话par[1]=5,继续 par[5]=8,par[3]=7,par[8]=6，当（5，6）一路往前推par[6]=6是不可以连接的。以此类推

#include<iostream>
using namespace std;
#define MAXRDGE 15  //边数量极大值
#define MAXVEX  9   //顶点数量极大值；
struct Rode
{
	int begin;
	int end;
	int weight;
};
int Find(int  *parent,int f)   //查找连线顶点的尾部下标。
{
	while (parent[f]>0)
		f=parent[f];
	return f;
}
int main()
{
	int sumedge;
	int sumvex;
	int n,m;
	Rode edge[MAXRDGE];//  
	int parent[MAXVEX]; //定义一组数组来判断边与边是否形成回路  
	/*边集数组按权由小到大排序*/
	memset(parent,0,sizeof(parent));
	for(int i=0;i<sumedge;i++)             //循环每一条边
	{
		n=Find(parent,edge[i].begin);    
		m=Find(parent,edge[i].end);
		if(n!=m)         //加入n和m不相等说明此边没有与现有生成树形成环，则加入会使形成环路
		{
			parent[n]=m;   //将此边结尾点放入下标为起点parent表示此顶点已经在生成树的集合中。
		}
	}
}

【Prim普里姆】

以某顶点为起点，逐步找到各顶点上最小权值的边来构成最小生成树。就不用按照权值来排序，直接从某个点开始，已经加入最小生成树这个点D,lowcost[D]=0,大概思路就是，先把与第一个点相关的边权值加入lowcost，选择到某个点P权值最小来加入最小生成树，然后把与P相关的边权值更新lowcost，继续找lowcost中最小的那条边，一次类推

#include<iostream>
using namespace std;
const int INF = 65535;
int map[9][9] = { { 0,10,99999,99999,99999,11,99999,99999,99999 },
{ 10,0,18,99999,99999,99999,16,99999,12 },
{ 99999,99999,0,22,99999,99999,99999,99999,8 },
{ 99999,99999,22,0,20,99999,99999,16,21 },
{ 99999,99999,99999,20,0,26,99999,7,99999 },
{ 11,99999,99999,99999,26,0,17,99999,99999 },
{ 99999,16,99999,99999,99999,17,0,19,99999 },
{ 99999,99999,99999,16,7,99999,19,0,99999 },
{ 99999,12,8,21,99999,99999,99999,99999,0 } };
int adjvex[9];     //保存相关点下标，
int lowcost[9];   //保存相关点权值，当权值为0，代表已加入最小生成树中
int main()
{
	lowcost[0] = 0;            //Vo已经被纳入最小生成树
	adjvex[0] = 0;
	for (int i = 1; i<9; i++)           //初始化
	{
		lowcost[i] = map[0][i];       //与Vo相关的权值
		adjvex[i] = 0;               //从顶点Vo开始到Vi
	}
	for (int i = 1; i<9; i++)
	{
		int min = INF;
		int j = 1;
		int k = 0; //保存当前最小权值下标。
		while (j<9)
		{
			if (lowcost[j] != 0 && lowcost[j]<min)  //找到最小权值
			{
				min = lowcost[j];
				k = j;                            //从adjvex[k]到k的权值最小  
			}
			j++;
		}
		printf("（%d，%d）\n", adjvex[k], k);   //打印当前顶点中权值最小的边
		lowcost[k] = 0;   
		for (int j = 1; j<9; j++) //查找邻接矩阵中Vk的各个权值，因为Vk是Vo的下一个点
		{
			if (lowcost[j] != 0 && map[k][j]<lowcost[j])//未加入生成树且小于最小权值
			{
				lowcost[j] = map[k][j];                 //将最小权值替换已存在的权值。
				adjvex[j] = k;                    //adjvex[j]到k。
			}
		}
	}
}