并查集拓扑排序专题总结

对于简单的问题，使用并查集模板可以轻松解决

而对于一些问题，则需要我们有所思考，比如正难则逆

拓扑排序我个人喜欢用队列实现

分享两个有趣的题目

题目简述：求一个图经过共k次拆边，每次拆边后的连通块个数

输入：n个节点，m条边

输出：每次拆边后的连通块个数

题目分析：并查集拆边很困难，因此可以逆向思维，考虑建边，每建一个边连通块数目少1，然而代码实现对我来说有点困难，参考大佬博客：https://www.luogu.com.cn/blog/user36297/solution-p1197

#include
#include
#include
#include
#include
#include
#define maxn 200005
using namespace std;

int fa[maxn*2];
int n, m;
int vis[maxn*2];//给点标号
int d[maxn*2], ans[maxn*2];//d:被攻占的点，ans：记录答案
int k, num;//num表示连通块个数

void init()
{
	for (int i = 0; i <= n; i++)
		fa[i] = i;
}

int find(int x)
{
	if (fa[x] == x)
		return x;
	else
		return fa[x] = find(fa[x]);
}

struct Node
{
	int x, y, w;
}node[maxn];

bool cmp(Node& a, Node& b)
{
	return a.w < b.w;
}

void unions(int x, int y)
{
	int fa_x = find(x);
	int fa_y = find(y);
	fa[fa_x] = fa_y;
	num--;//合并时总联通块-1
}

int main()
{
	cin >> n >> m;
	num = n;
	init();
	for (int i = 1; i <= m; i++)
	{
		cin >> node[i].x >> node[i].y;
	}
	cin >> k;
	for (int i = 1; i <= k; i++)
	{
		cin >> d[i];
		vis[d[i]] = k - i + 1;//从大到小编号
	}
	for (int i = 1; i <= m; i++)
	{
		node[i].w = max(vis[node[i].x], vis[node[i].y]);//边序号=两个点最大的
	}
	sort(node + 1, node + 1 + m, cmp);
	for (int i = 0, j = 1; i <= k; i++)//枚举被攻占星球的序号
	{
		for (; node[j].w == i; j++)
		{
			if(find(node[j].x)!=find(node[j].y))
			unions(node[j].x, node[j].y);
		}
		ans[i] = num - (k - i);//k-i:帝国攻占星球数
	}
	for (int i = k; i >= 0; i--)
		cout << ans[i] << endl;
}

题目简述：输入n个神经元的初状态和阈值，输入p行Wij表示连接i和j的边权值，输出状态大于0的输出层神经元的状态，（Ci代表状态，Ui代表阈值，满足C[i]=(j,i)∈E∑​W(j,i)​∗C[j]−U[i] ）

输入：n行n个神经元的状态和阈值，p行连接i，j的边权值

输出：状态大于0的输出层神经元的状态

题目分析：明显使用拓扑排序，我们可以将入度为0的点入队（c[i]!=0），如果可以传递信号就按公式传给下一个并不断入队，AC代码：

#include
#include
#include
#include
#include
#include
#define maxn 120
using namespace std;

int n, p;
int map[maxn][maxn], out[maxn], c[maxn], u[maxn];//out:出度，c:状态，u:阈值
queueq;
bool vis[maxn];

int main()
{
	cin >> n >> p;
	for (int i = 1; i <= n; i++)
	{
		cin >> c[i] >> u[i];
		if (c[i] != 0)
		{
			q.push(i);
			vis[i] = 1;
		}
		else
			c[i] -= u[i];
	}
	for (int i = 1; i <= p; i++)
	{
		int x, y, w;
		cin >> x >> y >> w;
		map[x][y] = w;
		out[x]++;
	}
	while (!q.empty())
	{
		int now = q.front();
		q.pop();
		if (c[now] > 0)
		{
			for (int i = 1; i <= n; i++)
			{
				if (map[now][i] != 0)
				{
					c[i] += map[now][i] * c[now];//代入公式
					if (!vis[i])
					{
						q.push(i);
						vis[i] = 1;
					}
				}
			}
		}
	}
	bool isok = 0;
	for (int i = 1; i <= n; i++)//输出层是否状态均为0
	{
		if (out[i] == 0 && c[i] > 0)
		{
			isok = 1;
			break;
		}
	}
	if (!isok)
		cout << "NULL";
	else
		for (int i = 1; i <= n; i++)
			if (out[i] == 0 && c[i] > 0)
				cout << i << ' ' << c[i] << endl;
}

转眼半学期就过去了，对我来说这门课教会我两点，一是脱离舒适圈，舒适圈限制了我们的思考，压低了我们的效率，而我们却好像怡然自得，二是学习要专一，精力分散很难将事情做好，如我平时喜欢自学一些东西，却因为没有明确规划而显得有些混乱，或者说广度的多了，深度的却不足

我上acm课的初衷便是为了学一些知识，增加一点见识，感谢这门课带给我方法上的收货