背景
题面
洛谷P3387 【模板】缩点传送门
题意
给定一个(n)个点(m)条边有向图，每个点有一个权值，求一条路径，使路径经过的点权值之和最大。你只需要求出这个权值和。
允许多次经过一条边或者一个点，但是，重复经过的点，权值只计算一次。
思路
~~点击获得更好的阅读体验~~
(Kosaraju)缩点+记忆化搜索
什么是(Kosaraju)缩点？
与(Tarjan)缩点的时间复杂度差不多，都是(O(n+m))。
其主要思想就是(dfs)两次。
核心代码如下：
void dfs_1(int x){
vis[x]=1;
for(int i=fir[x];i;i=nxt[i]){
if(vis[son[i]]==0) dfs_1(son[i]);
}
d[++t]=x;
}
void dfs_2(int x){
vis[x]=t;
s[t]++;
for(int i=fir2[x];i;i=nxt2[i]){
if(vis[son2[i]]==0) dfs_2(son2[i]);
}
}
void Kosaraju(){
t=0;
memset(vis,0,sizeof(vis));
for(int i=1;i<=n;i++){
if(vis[i]==0) dfs_1(i);
}
memset(vis,0,sizeof(vis));t=0;
for(int i=n;i>=1;i--){
if(vis[d[i]]==0) t++,dfs_2(d[i]);
}
}
当然，我认为(Kosaraju)有一定的缺点，比如说要建反边。
具体(Kosaraju)算法的介绍戳这里
什么是记忆化搜索
记忆化搜索（Memory search）心理学是指搜索信息的流程，但是搜索到的一些解用动态规划的那种思想和模式作一些保存。
——百度百科
其实说白了就是(dp)的进阶。多了一个搜索。。。
只不过在(dfs)时开了个数组存储了当前的状态，以便以后搜索需要。
关于这道题
那么这道题就愉快的解决了。。。
思路如下：
为什么有这丑陋无比的水印
CODE:（PS:请忽略边权）
#include<algorithm>
#include<bitset>
#include<complex>
#include<deque>
#include<exception>
#include<fstream>
#include<functional>
#include<iomanip>
#include<ios>
#include<iosfwd>
#include<iostream>
#include<istream>
#include<iterator>
#include<limits>
#include<list>
#include<locale>
#include<map>
#include<memory>
#include<new>
#include<numeric>
#include<ostream>
#include<queue>
#include<set>
#include<sstream>
#include<stack>
#include<stdexcept>
#include<streambuf>
#include<string>
#include<typeinfo>
#include<utility>
#include<valarray>
#include<vector>
#include<cctype>
#include<cerrno>
#include<cfloat>
#include<ciso646>
#include<climits>
#include<clocale>
#include<cmath>
#include<csetjmp>
#include<csignal>
#include<cstdarg>
#include<cstddef>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<ctime>
#define E 200010
using namespace std;//丑陋无比的头文件
inline int read(){
int res=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-') f=-1;ch=getchar();}
while(ch>='0'&&ch<='9') res=res*10+ch-'0',ch=getchar();
return res*f;
}//丑陋无比的读优
inline void write(int x){
if(x<0) putchar('-'),x=-x;
if(x<10) putchar(x+'0');
else{
write(x/10);
putchar(x%10+'0');
}
}//丑陋无比的输优
int n,m,a[E];
int fir[E],nxt[E],w[E],son[E],tot;
int vis[E],d[E],top,f[E],ans;
int fir2[E],nxt2[E],w2[E],son2[E],tot2;
void add(int x,int y,int z){
++tot;
nxt[tot]=fir[x];
fir[x]=tot;
son[tot]=y;
w[tot]=z;
}//建正边
void add2(int x,int y,int z){
++tot2;
nxt2[tot2]=fir2[x];
fir2[x]=tot2;
son2[tot2]=y;
w2[tot2]=z;
}//建反边
void dfs1(int x){//Kosaraju算法第一次dfs
vis[x]=1;
for(int i=fir[x];i;i=nxt[i]){//正向
int to=son[i];
if(!vis[to]) dfs1(to);
}
d[++top]=x;
}
void dfs2(int x){//Kosaraju算法第二次dfs
vis[x]=top;//标记第几个强连通分量
for(int i=fir2[x];i;i=nxt2[i]){//反向
int to=son2[i];
if(!vis[to]) dfs2(to);
}
}
void dp(int x){//记忆化搜索
if(f[x]!=0) return ;//记忆化体现
int ss=0;
f[x]=d[x];
for(int i=fir2[x];i;i=nxt2[i]){//使用新的DAG
int to=son2[i];
dp(to);
ss=max(ss,f[to]);//取最大值
}
f[x]+=ss;//别忘记加回去
}
int main(){
n=read();m=read();//读入
for(int i=1;i<=n;i++) a[i]=read();//读入
for(int i=1;i<=m;i++){
int x=read(),y=read();
add(x,y,1);//建正边
add2(y,x,1);//建反边
}
//Kosaraju Start
memset(vis,0,sizeof(vis));
memset(d,0,sizeof(d));top=0;//清空
for(int i=1;i<=n;i++){
if(!vis[i]) dfs1(i);//dfs第一次（正向）
}
memset(vis,0,sizeof(vis));top=0;//清空
for(int i=n;i>=1;i--){
if(!vis[d[i]]) ++top,dfs2(d[i]);//dfs第二次（反向）
}
//Kosaraju End
memset(d,0,sizeof(d));//清空
for(int i=1;i<=n;i++){
d[vis[i]]+=a[i];//权值累计
}
memset(fir2,0,sizeof(fir2));tot2=0;//清空
for(int i=1;i<=n;i++){//重新建DAG
for(int j=fir[i];j;j=nxt[j]){
int to=son[j];
if(vis[i]!=vis[to]) add2(vis[i],vis[to],1);//需要两个不同的强连通分量
}
}
for(int i=1;i<=top;i++){//记忆化搜索
if(!f[i]){//记忆化
dp(i);
ans=max(ans,f[i]);//取最大值
}
}
write(ans);putchar('
');//输出
return 0;//结束
}