QYQ在艾泽拉斯（并查集）（Tarjan）（拓扑序DP）

QYQ在艾泽拉斯

题目大意

给你一个有向图，然后定义一个区域是将有向边看做无向边所形成的连通块。
然后你可以选 K+1 个区域，从任意点出发走到任意点。
然后点有点权，要你最大化点权和。

思路

看到有向图走路径要点权最大，不难想到 Tarjan 缩点之后跑拓扑序 DP。

然后看到它说有区域之分，那你就用并查集搞出来每个区域。
然后要选 K+1 个区域，那你就对于每个预期都跑出结果，然后把结果排序，选最优的前面的几个。

然后就好了。

代码

#include<queue>
#include<cstdio>
#include<vector>
#include<iostream>
#include<algorithm>

using namespace std;

struct node {
	int to, nxt;
}e[1000001], e_[1000001];
int n, m, fa[100001], x, y, tmp;
int le[100001], KK, dfn[100001];
int low[100001], sta[100001], K;
int in[100001], nn, a[100001], answer;
int sum[100001], le_[100001], KK_;
int du[100001], ans[100001], f[100001];
vector <int> jh[100001];
queue <int> q;

bool cmp(int x, int y) {
	return x > y;
}

void add(int x, int y) {
	e[++KK] = (node){y, le[x]}; le[x] = KK;
}

void add_(int x, int y) {
	e_[++KK_] = (node){y, le_[x]}; le_[x] = KK_;
	du[y]++; 
}

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

void connect(int x, int y) {
	int X = find(x), Y = find(y);
	if (X == Y) return ;
	fa[X] = Y;
}

void tarjan(int now) {
	dfn[now] = low[now] = ++tmp;
	sta[++sta[0]] = now;
	for (int i = le[now]; i; i = e[i].nxt)
		if (!dfn[e[i].to]) tarjan(e[i].to), low[now] = min(low[now], low[e[i].to]);
			else if (!in[e[i].to]) low[now] = min(low[now], low[e[i].to]);
	if (dfn[now] == low[now]) {
		in[now] = ++nn;
		sum[nn] = a[now];
		jh[find(now)].push_back(nn);
		while (sta[sta[0]] != now) {
			in[sta[sta[0]]] = nn;
			sum[nn] += a[sta[sta[0]]];
			sta[0]--;
		}
		sta[0]--;
	}
}

int main() {
//	freopen("azeroth.in", "r", stdin);
//	freopen("azeroth.out", "w", stdout);
	
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= n; i++) fa[i] = i;
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &x, &y);
		add(x, y);
		connect(x, y);
	}
	for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
	scanf("%d", &K);
	
	for (int i = 1; i <= n; i++)//缩点建新图
		if (!dfn[i]) tarjan(i);
	for (int i = 1; i <= n; i++)
		for (int j = le[i]; j; j = e[j].nxt)
			if (in[i] != in[e[j].to])
				add_(in[i], in[e[j].to]);
	
	for (int i = 1; i <= n; i++)
		if (jh[i].size()) {//每个连通块求答案
			ans[0]++;
			for (int j = 0; j < jh[i].size(); j++)//拓扑
				if (!du[jh[i][j]]) {
					q.push(jh[i][j]);
					f[jh[i][j]] = sum[jh[i][j]];
				}
			while (!q.empty()) {
				int now = q.front();
				q.pop();
				
				ans[ans[0]] = max(ans[ans[0]], f[now]);
				for (int i = le_[now]; i; i = e_[i].nxt) {
					f[e_[i].to] = max(f[e_[i].to], f[now] + sum[e_[i].to]);
					du[e_[i].to]--;
					if (!du[e_[i].to]) q.push(e_[i].to);
				}
			}
		}
	
	sort(ans + 1, ans + ans[0] + 1, cmp);
	for (int i = 1; i <= min(ans[0], K + 1); i++)//排序选前面几个
		answer += ans[i];
	printf("%d", answer);
	
	fclose(stdin);
	fclose(stdout);
	
	return 0;
}