APIO2009 抢掠计划

Problem H: 抢掠计划

Time Limit: 1 Sec   Memory Limit: 128 MB
Submit: 108   Solved: 63
[ Submit][ Status][ Web Board]

Description

Siruseri城中的道路都是单向的。不同的道路由路口连接。按照法律的规定，在每个路口都设立了一个Siruseri银行的ATM取款机。令人奇怪的是，Siruseri的酒吧也都设在路口，虽然并不是每个路口都设有酒吧。 Banditji计划实施Siruseri有史以来最惊天动地的ATM抢劫。他将从市中心出发，沿着单向道路行驶，抢劫所有他途径的ATM机，最终他将在一个酒吧庆祝他的胜利。 使用高超的黑客技术，他获知了每个ATM机中可以掠取的现金数额。他希望你帮助他计算从市中心出发最后到达某个酒吧时最多能抢劫的现金总数。他可以经过同一路口或道路任意多次。但只要他抢劫过某个ATM机后，该ATM机里面就不会再有钱了。 例如，假设该城中有6个路口，道路的连接情况如下图所示：

市中心在路口1，由一个入口符号→来标识，那些有酒吧的路口用双圈来表示。每个ATM机中可取的钱数标在了路口的上方。在这个例子中，Banditji能抢劫的现金总数为47，实施的抢劫路线是：1-2-4-1-2-3-5。

50%的输入保证N, M<=3000。所有的输入保证N, M<=500000。每个ATM机中可取的钱数为一个非负整数且不超过4000。输入数据保证你可以从市中心沿着Siruseri的单向的道路到达其中的至少一个酒吧。

Input

第一行包含两个整数N、M。N表示路口的个数，M表示道路条数。接下来M行，每行两个整数，这两个整数都在1到N之间，第i+1行的两个整数表示第i条道路的起点和终点的路口编号。接下来N行，每行一个整数，按顺序表示每个路口处的ATM机中的钱数。接下来一行包含两个整数S、P，S表示市中心的编号，也就是出发的路口。P表示酒吧数目。接下来的一行中有P个整数，表示P个有酒吧的路口的编号。

Output

输出一个整数，表示Banditji从市中心开始到某个酒吧结束所能抢劫的最多的现金总数。

Sample Input

6 7
1 2
2 3
3 5
2 4
4 1
2 6
6 5
10
12
8
16
1
5
1 4
4 3 5 6

Sample Output

47

此题看上去是最长路，但是由于可能存在正环，因此不能直接用spfa来做，首先必须消去环，我们看到题目里有一个条件：每个点只能算一次点权，那么当我们进入一个环之后，必定采取贪心策略，先把环上所有点权累加一次，然后任意选择一点出环，这样等价于将环缩成一点。然而这样是不对的，如果存在两个环相交，那么如果每个环单独缩成点的话，显然相交部分权值多算了一次，但是我们可以发现相交的环，任意两点还是可达，因此合在一起可以缩成一点，由此推广，这便是强连通分量（极大连通分量）。

缩点之后，图中显然不能存在环，否则可以继续消去，也就是剩下的图必定是DAG（有向无环图），那么spfa就可以用了，当然，既然是DAG，那么直接DP就可以了。

此题据说官方版是卡递归的，那就来一发非递归吧。从递归转非递归那就看对算法的理解深度和编程功底了。。。

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<stack>
#include<algorithm>
#define Maxn 500010
using namespace std;

struct line{
    int fr,to,next;
}p[Maxn];
int tot,n,head[Maxn],val[Maxn];
int dfn[Maxn],low[Maxn],belong[Maxn],in[Maxn],st[Maxn];
int cnt[Maxn],rd[Maxn],dp[Maxn];
int tmpdfn,top,scc;
vector<int> dv[Maxn];
void addedge(int u,int v){
    p[tot].to=v;
    p[tot].fr=u;
    p[tot].next=head[u];
    head[u]=tot++;
}
/*
void tarjan(int u){
    dfn[u]=low[u]=++tmpdfn;
    st[top++]=u;
    in[u]=1;
    for(int i=head[u];i!=-1;i=p[i].next){
        int v=p[i].to;
        if(!dfn[v]){
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(in[v])
            low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u]){
        scc++;
        do{
            belong[st[top-1]]=scc;
            in[st[top-1]]=0;
            cnt[scc]+=val[st[top-1]];
        }while(st[--top]!=u);
    }
}
*/
/***非递归版本***/
stack<int> ss;
int nx[Maxn]; //下一个儿子
int lx[Maxn]; //上一个儿子
void tarjan(int u){
    while(!ss.empty()) ss.pop();
    ss.push(u);
    for(int i=1;i<=n;i++) nx[i]=head[i],lx[i]=-1;
    while(!ss.empty()){
        int v=ss.top();
        if(!dfn[v]){ //第一次访问
            dfn[v]=low[v]=++tmpdfn;
            st[++top]=v;
            in[v]=1;
        }
        if(lx[v]!=-1) low[v]=min(low[v],low[lx[v]]); //访问完儿子
        if(nx[v]!=-1){ //有儿子
            while(nx[v]!=-1){ //寻找下一个还未访问的儿子
                if(!dfn[p[nx[v]].to]){ //树边
                    lx[v]=p[nx[v]].to;
                    nx[v]=p[nx[v]].next;
                    ss.push(lx[v]);
                    break;
                }
                else if(in[p[nx[v]].to]) //回边
                    low[v]=min(low[v],dfn[p[nx[v]].to]);
                nx[v]=p[nx[v]].next;
            }
        }
        else{ //全部儿子访问完毕
            if(low[v]==dfn[v]){
                scc++;
                do{
                    belong[st[top]]=scc;
                    in[st[top]]=0;
                    cnt[scc]+=val[st[top]];
                }while(st[top--]!=v);
            }
            ss.pop();
        }
    }
}
int dfs(int u){
    int &ans=dp[u];
    if(ans) return ans;
    for(int i=0;i<dv[u].size();i++)
        ans=max(ans,dfs(dv[u][i]));
    if(!ans) return ans=rd[u]?cnt[u]:0;
    return ans+=cnt[u];
}
int main()
{
    int m,a,b,s,num;
    while(cin>>n>>m){
        tot=0;
        memset(head,-1,sizeof head);
        for(int i=0;i<m;i++){
            scanf("%d%d",&a,&b);
            addedge(a,b);
        }
        for(int i=1;i<=n;i++)
            scanf("%d",val+i);
        memset(dfn,0,sizeof dfn);
        memset(in,0,sizeof in);
        memset(cnt,0,sizeof cnt);
        scc=0;
        for(int i=1;i<=n;i++){
            tmpdfn=top=0;
            if(!dfn[i]) tarjan(i);
        }
        for(int i=1;i<=n;i++) dv[i].clear();
        for(int i=1;i<=n;i++)
            for(int j=head[i];j!=-1;j=p[j].next){
                if(belong[p[j].fr]!=belong[p[j].to])
                    dv[belong[p[j].fr]].push_back(belong[p[j].to]);
            }
        for(int i=1;i<=scc;i++){
            sort(dv[i].begin(),dv[i].end());
            dv[i].erase(unique(dv[i].begin(),dv[i].end()),dv[i].end());
        }
        scanf("%d%d",&s,&num);
        memset(rd,0,sizeof rd);
        for(int i=1;i<=num;i++){
            scanf("%d",&a);
            rd[belong[a]]=1;
        }
        memset(dp,0,sizeof dp);
        cout<<dfs(belong[s])<<endl;
    }
    return 0;
}