HYSBZ-1179 ATM

题目链接

题目描述

求最大点权路，但是必须从规定点（仅有一个）开始到任意一个规定点（可能有多个点）结束。（保证至少有一条这样的路径）

输入格式

第一行输入两个整数n，m表示点的个数和单向边的条数；
接下m行每行两个整数描述m条有向边；
接下来n个整数表示点权；
接下来一个整数s表示起点，一个整数p表示可能的终点个数；
接下来p个整数表示可能的终点编号。
（n, m <= 5e5）（0 <= 点权 <= 4000）

输出格式

输出一个整数表示符合要求的最大点权路径的点权和。

解题思路

强连通分量缩点，然后边拓扑边DP（注意只有当拓扑到起点之后才更新DP值，起点之前的DP值应该全部为-inf，而只有有终点的强连通分量的DP值才可以更新答案）

代码CodeTime

#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define debug(x) cout << #x << " = " << x << endl;
#define debug_mul(x, y) for(int i = 0; i < y; i++) cout << #x << "[" << i << "]" << " = " << x[i] << endl;

//value为点权，flag为是否为终点，skod为出栈顺序，scc_num就是所属强连通分量编号； 
const int maxn = 5e5 + 10;
int n, value[maxn];
bool flag[maxn];
vector<int> G[maxn], rG[maxn];
int skod_cnt, skod[maxn];
bool vis[maxn];
int scc_num[maxn];
vector<int> scc_val;
vector<bool> scc_flag;

//正向dfs 
void dfs(int u){
	vis[u] = 1;
	for(unsigned i = 0; i < G[u].size(); i++)
		if(!vis[G[u][i]])
			dfs(G[u][i]);
	skod[++skod_cnt] = u;
}

//反向dfs 
void rdfs(int u, int k){
	scc_num[u] = k;
	scc_val[k] += value[u];//强连通分量的点权为该分量所有点的权值和 
	scc_flag[k] = scc_flag[k] || flag[u];//只要该强连通分量中有一个点可以作为终点则该强连通分量可以作为终点 
	for(unsigned i = 0; i < rG[u].size(); i++)
		if(!scc_num[rG[u][i]])
			rdfs(rG[u][i], k);
}

int scc(){
//	memset(vis, 0, sizeof vis);
	for(int i = 1; i <= n; i++)
		if(!vis[i])
			dfs(i);
//	scc_val.clear();
//	memset(scc_num, 0, sizeof scc_num);
	scc_val.push_back(-1);
	scc_flag.push_back(false); //占据0号位 
	int k = 0;
	for(int i = skod_cnt; i > 0; i--)
		if(!scc_num[skod[i]]){
			scc_val.push_back(0);
			scc_flag.push_back(false);
			rdfs(skod[i], ++k);
		}
	return k;
}

//缩点之后的图的信息（入度，DP值，出边） 
vector<int> degree;
vector<int> dp;
vector<vector<int> > sccG;

int main(){
	int m;
	scanf("%d%d", &n, &m);
	while(m--){//读边 
		int u, v;
		scanf("%d%d", &u, &v);
		G[u].push_back(v);
		rG[v].push_back(u);
	}
	int rt, q;
	for(int i = 1; i <= n; i++)//读点权 
		scanf("%d", value + i);
	scanf("%d%d", &rt, &q);//读起点和终点数 
	while(q--){//读终点 
		int s;
		scanf("%d", &s);
		flag[s] = true;
	}
	int cnt = scc();//强连通分量缩点 
	degree.assign(cnt + 1, 0);//cnt为缩点后的点数，+1是因为0号位不存 
	dp.assign(cnt + 1, 1 << 31);//1<<31为int内最小的数，相当于-inf 
	sccG.assign(cnt + 1, vector<int>());
	for(int u = 1; u <= n; u++)
		for(unsigned i = 0; i < G[u].size(); i++)
			if(scc_num[u] != scc_num[G[u][i]]){
				degree[scc_num[G[u][i]]]++;//缩点后重新建图 
				sccG[scc_num[u]].push_back(scc_num[G[u][i]]);
			}
	queue<int> qwe;//拓扑用的队列 
	rt = scc_num[rt];//起点变为起点所在的强连通分量 
	dp[rt] = scc_val[rt];//初始化起点的值 
	for(int i = 1; i <= cnt; i++)
		if(!degree[i])
			qwe.push(i);
	int ans = 0;
	while(!qwe.empty()){//边拓扑边更新答案 
		int u = qwe.front();
		if(scc_flag[u]) ans = max(ans, dp[u]);//如何该强连通分量可以作为终点则尝试更新答案 
		qwe.pop();
		for(unsigned i = 0; i < sccG[u].size(); i++){
			int v = sccG[u][i];
			degree[v]--;
			//尝试更新所能到达的点的DP值（即使在起点前也没有关系，因为全部点的点权和也只有20亿，不足以抵消-inf的作用） 
			dp[v] = max(dp[v], dp[u] + scc_val[v]);
			if(!degree[v])
				qwe.push(v);
		}
	}
	printf("%d\n", ans);//输出答案 
	return 0;//然后完美结束 
}