最小化最大值+拓扑排序要点+概率

今天嫖来的两道题：
$D.ScoreofaTree$
$E.EdgeReverse$

$D$题是比较离谱的一道题，你在做的时候好像是dp，但是选择的情况太多了，其实对于每一个节点来说，除了叶节点之外，每一个节点的值为$0$和$1$的概率都是$0.5$，那么最后异或和的概率还是$0.5$（为$0$和$1$）这样的节点记为$A$类节点，$A$类节点迟早会被$B$类节点所取代，$B$类节点就是一定为$0$的节点，也就是叶节点，那么一个$A$节点对于总答案的贡献度就是$2^{n-1}$，而$B$不贡献，所以要看这个节点能活多长时间就看他有多高，只要足够高，僵尸就不容易吃掉它的脑子。只要$B$节点没上来，他就永远是$A$类节点，其实看他有多高就是看他过了多少个$t$时间。
参考：点我（写的很不错）
代码：

#include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long ll;
const int length = 2e5 + 5;
vector<vector<int>> edge(length);
int dp[length];
int vis[length];
int mod = 1e9 + 7;
void dfs(int cur)
{
	vis[cur] = 1;
	for (int v : edge[cur])
	{
		if (!vis[v])
		{
			vis[v] = 1;
			dfs(v);
			dp[cur]=max(dp[v] + 1, dp[cur]);
			vis[v] = 0;
		}
	}
}
int ksm(int x, int n)
{
	int sum = 1;
	while (n)
	{
		if (n % 2 == 1)
		{
			sum = ((ll)sum*x) % mod;
		}
		n = n >> 1;
		x = ((ll)x*x) % mod;
	}
	return sum;
}
int main(void)
{
	int t;
	scanf_s("%d", &t);
	for (int i = 0; i < t; i++)
	{
		int n;
		scanf_s("%d", &n);
		for (int i = 1; i <= n; i++)
		{
			edge[i].clear();
			dp[i] = 1;
		}
		for (int i = 0; i < n - 1; i++)
		{
			int a, b;
			scanf_s("%d%d", &a, &b);
			edge[a].push_back(b);
			edge[b].push_back(a);
		}
		dfs(1);
		int sum = 0;
		for (int i = 1; i <= n; i++)
		{
			sum = (sum + dp[i] % mod) % mod;
		}
		sum = ((ll)sum*ksm(2, n - 1))%mod;
		printf("%d\n", sum);
	}
}

$E$题是最小化最大值，可以二分枚举最大值，还是参考刚才的文章。这里面主要是这个拓扑排序比较闹心，这个图里面可能有自环，所以必须得缩点，为啥非得缩点？我一开始的时候没有缩点做的，但是怎么都不对，如果有两个不连通的环，那么没法把入度为$0$的点放进去，后来又想，既然找不到就随便放进去一个点（反正有环），但是可能是一个连通分量含有一个环，如果随便放一个点，可能不是起始的，（那个环可能没有点指向
代码：

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<stack>
#define PII pair<int,int>
using namespace std;
const int length = 2e5 + 5;
vector<vector<PII>> edge(length);
vector<vector<int>> tmp;
int color[length];
int dfn[length];
int low[length];
int in_stack[length];
int cl = 0;
int cnt = 0;
stack<int> s;
void tarjan(int cur,int fa)
{
	dfn[cur] = ++cnt;
	low[cur] = dfn[cur];
	in_stack[cur] = 1;
	s.push(cur);
	for (int v : tmp[cur])
	{
		if (!dfn[v])
		{
			tarjan(v, cur);
			low[cur] = min(low[cur], low[v]);
		}
		else if (in_stack[v])
			low[cur] = min(low[cur], dfn[v]);
	}
	if (low[cur] == dfn[cur])
	{
		cl++;
		while (s.top() != cur)
		{
			int tmp = s.top();
			color[tmp] = cl;
			in_stack[tmp] = 0;
			s.pop();
		}
		color[cur] = cl;
		in_stack[cur] = 0;
		s.pop();
	}
}
bool check(int x,int n)
{
	vector<vector<int>> edge1(n + 5);
	vector<int> rudu(n + 5);
	for (int i = 1; i <= n; i++)
	{
		color[i] = 0;
		dfn[i] = 0;
		low[i] = 0;
		for (auto tmp : edge[i])
		{
			int c = tmp.second;
			int a = i;
			int b = tmp.first;
			if (c <= x)
			{
				edge1[a].push_back(b);
				edge1[b].push_back(a);
			//	rudu[a]++;
			}
			else
			{
				//edge1[b].push_back(a);
				edge1[a].push_back(b);
			}
		}
	}
	cnt = 0;
	cl = 0;
	tmp = edge1;
	for(int i=1;i<=n;i++)
		if(!dfn[i])
	    tarjan(i,-1);
	
	vector<vector<int>> edge2(n + 5);
	for (int i = 1; i <= n; i++)
	{
		for (int v : edge1[i])
		{
			if (color[i] != color[v])
			{
				edge2[color[i]].push_back(color[v]);
				rudu[color[v]]++;
			}
		}
	}
	queue<int> q;
	for (int i = 1; i <= cl; i++)
	{
		if (rudu[i] == 0)
			q.push(i);
	}
	if (q.size() > 1)
		return 0;
	
	vector<int> vis(n + 5, 0);
	while (!q.empty())
	{
		int tmp = q.front();
		vis[tmp] = 1;
		q.pop();
		for (int v : edge2[tmp])
		{
			if (!vis[v])
				q.push(v);
			vis[v] = 1;
		}
	}
	for (int i = 1; i <= cl; i++)
		if (!vis[i])
			return 0;
	return 1;
}
int main(void)
{
	int t;
	scanf_s("%d", &t);
	for (int i = 0; i < t; i++)
	{
		int n, m;
		scanf_s("%d%d", &n, &m);
		for (int i = 1; i <= n; i++)
		{
			edge[i].clear();
		}
		for (int i = 0; i < m; i++)
		{
			int a, b, c;
			scanf_s("%d%d%d", &a, &b, &c);
			edge[a].push_back({ b,c });
		}
		
		int l = -1;
		int r = INT_MAX;
		while (l < r-1)
		{
			int mid = ((long long)l + r) / 2;
			if (!check(mid,n))
			{
				l = mid;
			}
			else
				r = mid;
		}
		if (r == INT_MAX)
			r = -1;
        printf("%d\n", r);
	}
	
}