最小生成树模版

克鲁斯卡尔

struct edge
{
	int u, v, w;
}e[maxn];
int f[110];

bool cmp(edge a, edge b)
{
	return a.w < b.w;
}
int find(int x)
{
	if(x != f[x])
		return f[x] = find(f[x]);
	return f[x];
}

int MST()
{
	int sum = 0;
	for(int i = 0; i < m; i++)
	{
		int x = find(e[i].u);
		int y = find(e[i].v);
		if(x != y)
		{
			sum += e[i].w;
			f[x] = y;
		}
	}
	return sum;
}

 

有向图的最小生成树 朱刘算法

double MST(int n, int m, int rt)
{
	double ans = 0;
	while(1)
	{
		for(int i = 1; i <= n; i++)
			in[i] = INF;
		for(int i = 1; i <= m; i++)
		{
			int u = e[i].u;
			int v = e[i].v;
			if(u != v && in[v] > e[i].w)
			{
				pre[v] = u;
				in[v] = e[i].w;
			}
		}
		for(int i = 1; i <= n; i++)
		{
			if(i == rt)
				continue;
			if(in[i] == INF)
				return -1;
		}
		memset(no, -1, sizeof(no));
		memset(vis, -1, sizeof(vis));
		in[rt] = 0;
		int cnt = 0;
		for(int i = 1; i <= n; i++)
		{
			ans += in[i];
			int v = i;
			while(v != rt && vis[v] != i && no[v] == -1)
			{
				vis[v] = i;
				v = pre[v];
			}
			if(v != rt && no[v] == -1)
			{
				for(int u = pre[v]; u != v; u = pre[u])
					no[u] = cnt+1;
				no[v] = cnt+1;
				cnt++;
			}
		}
		if(!cnt)
			return ans;
		for(int i = 1; i <= n; i++)
			if(no[i] == -1)
				no[i] = ++cnt;
		for(int i = 1; i <= m; i++)
		{
			int u = e[i].u;
			int v = e[i].v;
			e[i].u = no[u];
			e[i].v = no[v];
			if(no[u] != no[v])
			{
				e[i].w -= in[v];
			}
		}
		n = cnt;
		rt = no[rt];
	}
	return ans;
}

 Prim 优先队列+链表版

const int maxn = 111;
const int INF = 999999999;
struct Point
{
	double x, y;
}p[maxn];

struct Node
{
	int v, w;
	Node(int v, int w) : v(v), w(w){}
	bool operator < (const Node& rhs) const
	{
		return w > rhs.w;
	}
};
struct edge
{
	int u, v, w;
	int next;
}a[maxn*maxn];
int d[maxn];
bool vis[maxn];
int n, cnt;
int first[maxn];
void AddEdge(int u, int v, int w)
{
	a[cnt].u = u;
	a[cnt].v = v;
	a[cnt].w = w;
	a[cnt].next = first[u];
	first[u] = cnt++;
	a[cnt].u = v;
	a[cnt].v = u;
	a[cnt].w = w;
	a[cnt].next = first[v];
	first[v] = cnt++;
	
}
int prim()
{
	priority_queue <Node> Q;
	int ans = 0;
	for(int i = 1; i <= n; i++)
		d[i] = INF;
	for(int u = first[1]; u != -1; u = a[u].next)
	{
		d[a[u].v] = a[u].w;
		Q.push(Node(a[u].v, a[u].w));
	}
	memset(vis, false, sizeof(vis));
	vis[1] = true;
	d[1] = 0;
	
	while(!Q.empty())
	{
		Node x = Q.top();
		Q.pop();
		int u = x.v;
		if(vis[u])
			continue;
		vis[u] = true;
		int dis = x.w;
		ans += dis;
		for(int v = first[u]; v != -1; v = a[v].next)
		{
			if(!vis[a[v].v] && d[a[v].v] > a[v].w)
			{
				d[a[v].v] = a[v].w;
				Q.push(Node(a[v].v, d[a[v].v]));
			}
		}
	}
	return ans;
}