P3387 【模板】缩点

题目背景

缩点+DP

题目描述

给定一个n个点m条边有向图，每个点有一个权值，求一条路径，使路径经过的点权值之和最大。你只需要求出这个权值和。

允许多次经过一条边或者一个点，但是，重复经过的点，权值只计算一次。

输入输出格式

输入格式：

第一行，n,m

第二行，n个整数，依次代表点权

第三至m+2行，每行两个整数u,v，表示u->v有一条有向边

输出格式：

共一行，最大的点权之和。

输入输出样例

输入样例#1： 复制

2 2
1 1
1 2
2 1

输出样例#1： 复制

2

说明

n<=10^4,m<=10^5,点权<=1000

算法：Tarjan缩点+DAGdp

题解：缩点+记忆化搜索

 #include<cstdio>
 #include <algorithm>
 #include <stack>
 #include <vector>
 #include <cstring>
 using namespace std;

 const int MAXN=1e5+;
 const int inf=0x3f3f3f3f;
 struct node{
     int to;
     int next;
 }edge[MAXN*];
 int head[MAXN];
 int val[MAXN];
 bool instack[MAXN];
 int cnt;
 int dfn[MAXN],low[MAXN];
 int sum[MAXN];
 void add(int x,int y)
 {
     edge[++cnt].to =y;
     edge[cnt].next=head[x];
     head[x]=cnt;
 }
 int Time,num;
 stack<int >st;
 vector<int >G[MAXN];
 int du[MAXN];
 int color[MAXN];
 int x[MAXN],y[MAXN];
 int f[MAXN];
 void search(int x)
 {
     if(f[x]) return;
     f[x]=sum[x];
     int maxsum=;
     for (int i = ; i <G[x].size() ; ++i) {
         if(!f[G[x][i]]) search(G[x][i]);
         maxsum=max(maxsum,f[G[x][i]]);
     }
     f[x]+=maxsum;

 }
 void tarjan(int u)
 {
     dfn[u]=low[u]= ++Time;
     st.push(u);
     instack[u]=true;
     for (int i = head[u]; i !=- ; i=edge[i].next) {
         int v=edge[i].to;
         if(!dfn[v]){
             tarjan(v);
             low[u]=min(low[u],low[v]);
         }
         else if(instack[v]) low[u]=min(low[u],dfn[v]);
     }
     if(dfn[u]==low[u])
     {
         int x;
         num++;
         while() {
             x=st.top();
             st.pop();
             color[x]=num;
             instack[x]=false;
             if(x==u) break;
         }

     }
 }

 int main()
 {
     int n,m;
     scanf("%d%d",&n,&m);
     for (int i = ; i <=n ; ++i) {
         scanf("%d",&val[i]);
     }
     cnt=;
     memset(head,-,sizeof(head));
     memset(instack,false, sizeof(instack));
     memset(sum, ,sizeof(sum));
     for (int i = ; i <=m ; ++i) {
         scanf("%d%d",&x[i],&y[i]);
         add(x[i],y[i]);
     }
     for (int i = ; i <=n ; ++i) {
         if(!dfn[i]) tarjan(i);
     }
     for (int i = ; i <=n ; ++i) {
         sum[color[i]]+=val[i];
     }
     for (int k = ; k <=num ; ++k) {
 //        printf("%d --%d\n",k,sum[k]);
     }
     for (int i = ; i <=m ; ++i) {
         if(color[x[i]]!=color[y[i]])
         {
             G[color[x[i]]].push_back(color[y[i]]);
         }
     }
     for (int i = ; i <=num; ++i) {
         for (int j = ; j <G[i].size() ; ++j) {
 //            printf("%d-->%d\n",i,G[i][j]);
         }
     }

     int ans=;
     for (int i = ; i <=num ; ++i) {
         if(!f[i]){
             search(i);
             ans=max(ans,f[i]);
         }
     }
     printf("%d\n",ans);
     return ;
 }