洛谷P3387 缩点模板

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

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

因为可以重复经过点，所以一个点所在的强联通分量必定可以到达。所以直接缩点即可。

缩点之后，我们要让权值最大化，必须从入度为0的点开始搜。因为这是DAG，入度不为零的点的最后祖先必定是入度为零的点。由于这道题没有负数权值，从入度为零的结点开始走肯定是一个最好的选择。然后DAG上跑动归即可。

 #include <cstdio>
 #include <cstring>
 using namespace std;

 const int maxn=1e4+, maxm=1e5+;

 class Graph{
 public:
     //为什么用嵌套类，因为声明很烦。。并不是访问问题的原因。
     //如果类的成员不是static的话，内部类是不知道获取哪个外部类对象的。。
     //所以无论是把类放在里面还是外面，访问都有问题。
     //另外，把private放在下面，应该是因为嵌套类类必须完全声明才能使用吧。。
     //我也不大清楚。。先这么用着，以后再去翻c++ primer。
     class Edge{
     private:
         Graph *belong;
     public:
         int v, to, next; //感觉这里还是不优雅。。
         Edge(){}
         Edge(Graph& g, int x, int y, int z){
             belong=&g;
             to=x, v=y, next=z;
         }
         Edge operator ++(){ //不能打引用！
             *this=belong->edge[next]; //因为有自增运算，这个edge不能等同于图中的！
             return *this;
         }
         int operator *(){
             return to;
         }
     };
     Graph(){}
     void addedge(int x, int y, int v){
         ++cntedge;
         edge[cntedge]=Edge(*this, y, v, fir[x]);
         fir[x]=cntedge;
         return;
     }
     Edge get_link(int x){ //这里改成begin较好
         return edge[fir[x]];
     }
 private:
     int cntedge, fir[maxn];
     Edge edge[maxm];
 };

 int n, m, cnttime, cntscc;
 int v[maxn], visit[maxn], time[maxn];
 int scc[maxn], vofscc[maxn], in[maxn], ans[maxn];
 Graph g, g_t, g_scc;

 void dfs(int now, int flag){
     visit[now]=;
     Graph::Edge e=g.get_link(now);
     if (flag==) e=g_t.get_link(now);
     int to=*e;
     while (to){
         if (!visit[to]) dfs(to, flag);
         to=*(++e);
     }
     if (flag==){
         ++cnttime;
         time[cnttime]=now;
     }
     if (flag==) {
         scc[now]=cntscc;
         vofscc[cntscc]+=v[now];
     }
     return;
 }

 void dfs2(int x){
     Graph::Edge e=g.get_link(x);
     int to=*e;
     visit[x]=;
     while (to){
         if (scc[to]!=scc[x]){
             g_scc.addedge(scc[x], scc[to], v[scc[to]]);
             ++in[scc[to]];
         }
         if (!visit[to])
             dfs2(to);
         to=*(++e);
     }
     return;
 }

 void dfs3(int x){
     Graph::Edge e=g_scc.get_link(x);
     int to=*e;
     visit[x]=;
     ans[x]=vofscc[x];
     while (to){
         if (!visit[to]) dfs3(to);
         if (ans[to]+vofscc[x]>ans[x])
             ans[x]=ans[to]+vofscc[x];
         to=*(++e);
     }
     return;
 }

 int main(){
     scanf("%d%d", &n, &m);
     for (int i=; i<=n; ++i)
         scanf("%d", &v[i]);
     int x, y;
     for (int i=; i<=m; ++i){
         scanf("%d%d", &x, &y);
         g.addedge(x, y, );
         g_t.addedge(y, x, );
     } //建图
     for (int i=; i<=n; ++i)
         if (!visit[i]) dfs(i, ); //时间戳
     memset(visit, , sizeof(visit));
     for (int i=n; i>; --i){
         if (!visit[time[i]]){
             ++cntscc;
             dfs(time[i], );
         }
     } //求强联通分量
     memset(visit, , sizeof(visit));
     for (int i=; i<=n; ++i){
         if (!visit[i]) dfs2(i);
     } //缩点
     for (int i=; i<=cntscc; ++i)
         if (!in[i]) g_scc.addedge(, i, vofscc[i]); //超级源汇
     memset(visit, , sizeof(visit));
     dfs3(); //树形dp
     printf("%d\n", ans[]);
     return ;
 }