BZOJ1179_APIO2009_抢掠计划_C++

　　题目：http://www.lydsy.com/JudgeOnline/problem.php?id=1179

　　一道用 Tarjan 缩点+SPFA 最长路的题（Tarjan 算法：http://www.cnblogs.com/hadilo/p/5889333.html ）

　　我们可以这样考虑，把一个连通块缩成一个点，点权为所有权值和，且只要一个点有酒吧那么该点也就有酒吧

　　因为当我们进入该连通块任意一个点时，显然把它里面所有的点都抢一遍才使答案最优，而且能回到原进入点，并且只要有一个有酒吧就可以选择在那里庆祝

　　缩完点后，就可以用 SPFA 求最长路，边权变为点权，因为里面已经没有环了，所以可以用

　　当然最大路也可以用 Dijkstra 或 DP 等方法做

　　还有这道题细节很多很多，调了我4个多小时QuQ

#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<queue>
#include<stack>
#define N 500001
using namespace std;

int t,first[N],next[N],back[N],last[N],v[N],a[N],dfn[N],low[N],ans,d[N];
bool f[N],g[N],b[N];
stack<int> s;
queue<int> q;
void tarjan(int x)
{
    dfn[x]=low[x]=++t;
    s.push(x);
    int i;
    for (i=first[x];i;i=next[i])
        {
            if (f[v[i]]) continue;
            if (dfn[v[i]]) low[x]=min(low[x],dfn[v[i]]);
            else
                {
                    tarjan(v[i]);
                    low[x]=min(low[x],low[v[i]]);
                }
        }
    if (dfn[x]==low[x])
        {
            int k,c=first[x];
            while (s.top()!=x)
                {
                    i=c;
                    k=s.top();
                    f[k]=b[k]=1;
                    s.pop();
                    a[x]+=a[k];
                    g[x]|=g[k];
                    while (next[i]) i=next[i];
                    next[i]=first[k];
                    c=i;
                    for (i=last[k];i;i=back[i]) v[i]=x;
                }
            f[s.top()]=1;
            s.pop();
        }
}
int main()
{
    int n,m,i,x,k;
    scanf("%d%d",&n,&m);
    for (i=1;i<=m;i++)
        {
            scanf("%d%d",&x,&v[i]);
            next[i]=first[x];
            first[x]=i;
            back[i]=last[v[i]];
            last[v[i]]=i;
        }
    for (i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            g[i]=b[i]=f[i]=0;
        }
    scanf("%d%d",&k,&m);
    for (i=1;i<=m;i++)
        {
            scanf("%d",&x);
            g[x]=1;
        }
    tarjan(k);
    for (i=1;i<=n;i++) f[i]=1;
    d[k]=a[k];
    q.push(k);
    while (!q.empty())
        {
            k=q.front();
            q.pop();
            if (g[k]) ans=max(ans,d[k]);
            for (i=first[k];i;i=next[i])
                {
                    if (b[v[i]]||v[i]==k) continue;
                    if (d[v[i]]<d[k]+a[v[i]])
                        {
                            d[v[i]]=d[k]+a[v[i]];
                            q.push(v[i]);
                        }
                }
        }
    cout<<ans<<endl;
    return 0;
}

　　这道题需要开无限栈，因为递归的 Tarjan 会爆栈，然而并不会手写栈

　　BZOJ 上幸好开了无限栈，不然就 RE 了，不过其它的 OJ 好像没有开无限栈，RE 两个点……

　　只好去网上下了一个代码，在 CodeVS 上交了一发手写栈的 Tarjan，终于A了orz（手写栈的戳这里： http://www.cnblogs.com/hadilo/p/5892791.html ）

版权所有，转载请联系作者，违者必究

QQ：740929894