不是图论 【tarjan求scc】+【缩点】

给出一个n个点，m条边的有向图。每个点上有分值，经过这个点时可以获得一定的分数。

一个点可以经过多次，但是一个点上的分数只能获得一次。

问最多能获得多少分数，起点任选。

1<=n<=30000,1<=m<=100000

Input
输入包含多组数据

每组数据第一行为n，m
接下来n行，每行有一个数，表示第ii个节点的分值。

接下来m行，每行有两个数a、b，表示有一条从a到b的有向边

Output
每组数据输出一行，每行仅有一个整数：可以获得的最多的分数。

Sample input and output
5 5
1 1 1 2 3
1 2
2 3
3 1
1 4
1 5
5 3
1 2 3 4 5
1 2
1 3
4 5
Sample Input Sample Output
6
9

按道理来说，感觉应该是可以 按 topo 一个个扫，但是时间复杂度太高，所以就想。如果是在一个SCC中，那么只要经过其中的一个点（那么在同一scc中点的所有的分值都是可以拿到的）所以
思路 就是 tarjan + 缩点 +dfs
思考了这道题之后我更加理解了。
对于一个有向图来说，求一遍 tarjan+缩点 所得到的 图的含义——对于一个有向图，可以分解为多组或一组 SCC ，将每个SCC 缩点，得到的新图 ，就是一个 无环的有向图；对于 有入度的新点， 一定会由别的 新点指向； 对于入度为0的新点来说，以他为根节点，就可以得到一棵树 。（可以用dfs 遍历每一条路径（注意这里不能用bfs 那样的话就不是一条 路径了））；
代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#include<set>
#define CLR(a,b) memset((a),(b),sizeof(a))
#define inf 0x3f3f3f3f
#define mod 100009
#define LL long long
#define M  100000+100
#define ll o<<1
#define rr o<<1|1
#define lson o<<1,l,mid
#define rson o<<1|1,mid+1,r
using namespace std;
void read(int &x){
    x=0;char c;
    while((c=getchar())<'0');
    do x=x*10+c-'0';while((c=getchar())>='0');
}
struct Edge {
    int from,to,next;
}edge[M];
int head[M],top;
int score[M]; // 记录原图中每一个点的分数
int points[M];//记录缩点后每一个点的分数
int n,m;
vector<int>G[M];
vector<int >scc[M];
int scc_cnt,dfs_clock;
int low[M],dfn[M],in[M];
stack<int>S;int Instack[M];
int sccno[M];
void init()
{
    top=0;
    memset(head,-1,sizeof(head));
    while(!S.empty()) S.pop();
}
void addedge(int a,int b)
{
    Edge e={a,b,head[a]};
    edge[top]=e; head[a]=top++;
}
void getmap()
{
    int i,j;
    for(i=1;i<=n;i++)
    read(score[i]);

    int a,b;
    for(i=0;i<m;i++)
    {
        read(a);read(b);
        addedge(a,b);
    }
}
void tarjan(int now)
{
    int nexts;
    low[now]=dfn[now]=++dfs_clock;
    S.push(now);Instack[now]=1;
    for(int i=head[now];i!=-1;i=edge[i].next)
    {
        Edge e=edge[i];
        if(!dfn[e.to])
        {
          tarjan(e.to);
          low[now]=min(low[e.to],low[now]);
        }
        else if(Instack[e.to])
        low[now]=min(low[now],dfn[e.to]);
    }
    if(dfn[now]==low[now]) 
    {
        scc_cnt++;
        scc[scc_cnt].clear();
        for(;;)
        {
        nexts=S.top();S.pop();Instack[nexts]=0;
        sccno[nexts]=scc_cnt;
        points[scc_cnt]+=score[nexts];// 记录每一个 scc（缩点） 内部所有的值的和
        scc[scc_cnt].push_back(nexts);
        if(nexts==now) break;
        }
    }
}
void find_cut(int le,int ri)
{
    memset(low,0,sizeof(low));
    memset(dfn,0,sizeof(dfn));
    memset(Instack,0,sizeof(Instack));
    memset(sccno,0,sizeof(sccno));
    memset(points,0,sizeof(points));
    scc_cnt=dfs_clock=0;

    for(int i=le;i<=ri;i++)
    if(!dfn[i]) tarjan(i);
}
void suodian()
{
    int i,j;
    for(i=1;i<=scc_cnt;i++) G[i].clear(),in[i]=0;
    for(i=0;i<top;i++)
    {
        int u=sccno[edge[i].from];
        int v=sccno[edge[i].to];
        if(v!=u) 
        {
            G[u].push_back(v);
            in[v]++;
        }
    }
}
int value; // 记录以当前新点为起点最多可以获得多少分数
void dfs(int now,int sum) // 一开始我用了bfs 之后样例都过不了，之后仔细想了一下，才发现，只能用dfs才可以遍历每一个条路径。。。汗。（还有这里好像可以用dp 汗，可是我不会就尴尬了只能用dfs求了，虽然浪费了点时间但还是过了）
{
    value=max(value,sum);
    for(int i=0;i<G[now].size();i++)
    dfs(G[now][i],sum+points[G[now][i]]);
}
void solve()
{
    int i,j;int sum=-1;
    for(i=1;i<=scc_cnt;i++)
    {
        if(!in[i])  // 这里有一个小优化，对于入度不为0的新点，则在经过它之前一定还要经过别的点。所以一定不是最大的，所以只有从入度为0的点出发才可能得到最大的分数
        {
            value=-1;
            dfs(i,points[i]); 
            sum=max(value,sum);
        }   
    }   
    printf("%d\n",sum); 
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        getmap();
        find_cut(1,n);
        suodian();
        solve();
    }
    return 0;
}