POJ 3160 缩点+拓扑排序+简单dp

题目链接： http://poj.org/problem?id=3160

题目大意：

　　给定一个有向图，每个点有权值，要求选定一个起点，从该点出发一直走，走出一条路径，该路径上的所有点的权值可取可不取，要求最大的权值和，注意可以重复走点，但是权值只可以加一次。

分析：

　　显然，如果权值<=0，一律赋为0,

　　由输入数据，我们用Tarjan算法缩点得到一个有向无环图，同时注意每个强连通分量（SCC）的权值是该分量所含点的权值和;

　　得到的有向无环图（DAG）可能是一个有多个入度为0的点的图，为了方便dp，进行拓扑排序，然后简单更新即可，具体见代码。

　　（我自己对这类题目的理解就是：  进行拓扑排序可以方便dp，不会有后效性）

代码：

/*3160    Accepted    1436K    79MS    C++    2940B    2012-06-09 20:36:23*/
#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

#define mpair make_pair
#define pii pair<int,int>
#define MM(a,b) memset(a,b,sizeof(a));
typedef long long lld;
typedef unsigned long long u64;
template<class T> bool up_max(T& a,const T& b){return b>a? a=b,1 : 0;}
template<class T> bool up_min(T& a,const T& b){return b<a? a=b,1 : 0;}
#define maxn 30020

int n,m;
int val[maxn];
vector<int>g[maxn], adj[maxn];

void Read(){
    for(int i=0;i<n;++i){
        scanf("%d", val+i);
        if( val[i]<0 ) val[i]= 0;
    }
    for(int i=0;i<n;++i) g[i].clear(); /// clear();
    for(int i=1;i<=m;++i){
        int x,y;
        scanf("%d%d", &x, &y);
        g[x].push_back(y);
    }
}

int c[maxn];
int Bcnt, Index, Top;
int low[maxn], dfn[maxn], stack[maxn], belong[maxn];
bool vis[maxn];
void Init_tarjan(){
    Bcnt= Index= Top= 0;
    for(int i=0;i<n;++i) low[i]= dfn[i]= vis[i]= 0;
}
void Tarjan(int u){
    stack[++Top]= u;
    vis[u]= 1;
    low[u]= dfn[u]= ++Index;
    for(int i=0;i<g[u].size();++i){
        int v= g[u][i];
        if( !dfn[v] ){
            Tarjan(v);
            up_min( low[u], low[v] );
        }
        else if( vis[v] )
            up_min( low[u], dfn[v] );
    }
    if( low[u]==dfn[u] ){
        c[ ++Bcnt ] = 0;
        int v;
        do{
            v= stack[Top--];
            vis[v]= 0;
            belong[v]= Bcnt;
            c[Bcnt]+= val[v];
        }while(u!=v);
    }
}

int in[maxn];
void dfs(int u){
    vis[u]= 1;
    for(int i=0;i<g[u].size();++i){
        int v= g[u][i];
        if( belong[u]!=belong[v] ){
            adj[ belong[u] ].push_back( belong[v] );
            in[ belong[v] ]++;
        }
        if( !vis[v] ) dfs(v);
    }
}

int *que;
int dp[maxn];
int Topsort(){
    int head=0, tail= 0;
    fill( dp, dp+1+Bcnt, 0 );
    for(int i=1;i<=Bcnt;++i) if( in[i]==0 ) { que[tail++]= i; dp[i]= c[i];}
    while( head<tail ){
        int u= que[head++];
        for(int i=0;i<adj[u].size();++i){
            int v= adj[u][i];
            if( --in[v] == 0 )
                que[tail++]= v;
        }
    }

    for(int i=0;i<tail;++i){
        int u= que[i];
        for(int j=0;j<adj[u].size();++j){
            int v= adj[u][j];
            up_max( dp[v], dp[u]+c[v] );
        }
    }
    return *max_element( dp+1, dp+1+Bcnt );
}

int solve(){
    Init_tarjan();
    for(int i=0;i<n;++i){
        if( !dfn[i] )
            Tarjan(i);
    }

    MM( vis, 0 );
    for(int i=1;i<=Bcnt;++i) adj[i].clear(), in[i]= 0;
    for(int i=0;i<n;++i){
        if( !vis[i] )
            dfs(i);
    }
    que= stack; ///
    return Topsort();
}

int main()
{
    // freopen("poj3160.in","r",stdin);
    while( cin>>n>>m ){
        Read();
        cout<< solve() << endl;
    }
}