POJ3160 Father Christmas flymouse 圣诞老人给集训队送礼物

/*
*State: POJ3160 Accepted    1812K    63MS    C++    3743B    
*题目大意：
*        一个圣诞老人去给n个同学送东西，然后每个同学会给圣诞老人评价(可正负)，
*        然后n个同学的地址是一个有向有环图，每到一个同学家门口，圣诞老人可以
*        选择进去，或者不进去，圣诞老人走到无路可走为止，然后要求给圣诞老人选
*        一个起点，使得圣诞老人这次旅行获得的权值最大。
*解题思路：
*        题意看了好久啊，有向有环图，还可以选择拿权值或者不拿，最终要求总共最
*        大权值，那么可以一开始就给点赋权值，如果权值为负就赋值为0，然后给有向
*        有环图缩点。之后再把缩点后的图入度为0的点都用一个虚拟节点汇点，然后从
*        这个虚拟节点开始用spfa求最长路，最后算一下出度为0的点的最长度的最大值
*        即为所求。
*解题感想：
*        其实题目还是挺基础的，只是代码比较长，足足写了200+ rows,然后一开始用
*        树形dp去计算最大值，后来wa了一次画图发现，这样行不通，因为缩点后的图
*        是DAG而不是树形，DAG有可能点是公用的，所以用类似记忆化搜索的树形dp是
*        不行的，相反，转化为最长路却很容易算出答案。
*        最后还是wa了三次，re了一次，re是因为一开始用了向量去存邻接表，发现速度
*        慢得很，就索性改为静态邻接表，有一个地方看错了，不过还好，re很快就查了
*        出来，剩下的wa就够蛋疼的了，一开始是发现初始化少了一些，然后很冲动地
*        交，结果还是wa，后来蛋疼无比之时，发现，汗死我了，我怎么把最长路写成了
*        最短路，我是不是最短路写疯了？一写spfa就写成了最短路，汗死我~~~~~~~~~
*        思维定势的痛楚。不过还是那样，200+的代码，一定要wa一次，很少能1a,但是
*        花点儿时间认真查，还是可以查出来的。
*/

#include <iostream>
#include <queue>
using namespace std;

const int MAXN = 30005;
const int MAXE = 150005;
const int inf = 0x3f3f3f3f;

typedef struct _edge
{
    int v, next;
}E;
E edge[MAXE];
int cntEdge, head[MAXN];
int myS[MAXN], top;
int weight[MAXN], dfn[MAXN], low[MAXN], step;
int inS[MAXN], scc, id[MAXN];

//缩点,建DAG
typedef struct _node
{
    int v, w, next;
}N;
N sccEdge[MAXE];
int sccHead[MAXN], sccCntEdge;
int idw[MAXN], in[MAXN], out[MAXN];

void init()
{
    top = 0;
    step = cntEdge = sccCntEdge = 0;
    scc = 1;
    for(int i = 0; i < MAXN; i++)
    {
        myS[i] = 0;
        in[i] = out[i] = 0;
        weight[i] = 0;
        id[i] = -1;
        sccHead[i] = head[i] = -1;
        inS[i] = idw[i] = 0;
        dfn[i] = low[i] = -1;
    }
}

void addEdge(int u, int v)
{
    edge[cntEdge].v = v;
    edge[cntEdge].next = head[u];
    head[u] = cntEdge++;
}

void tarjan_scc(int n)
{
    dfn[n] = low[n] = ++step;
    myS[top++] = n;
    inS[n] = 1;
    for(int f = head[n]; f != -1; f = edge[f].next)
    {
        int son = edge[f].v;
        if(dfn[son] == -1)
        {
            tarjan_scc(son);
            low[n] = min(low[n], low[son]);
        }
        else if(inS[son] == 1)
            low[n] = min(low[n], dfn[son]);
    }

    if(low[n] == dfn[n] && top != 0)
    {
        int tmp;
        do
        {
            tmp = myS[--top];

            inS[tmp] = 0;
            id[tmp] = scc;
            idw[scc] += weight[tmp];
            
        }while(top != 0 && tmp != n);
        scc++;
    }
}

int spfa(int s)
{
    int dis[MAXN], inQ[MAXN] = {0};
    for(int i = 0; i < MAXN; i++)
        dis[i] = -inf;
    queue<int> Q;

    Q.push(s);
    dis[s] = 0;
    inQ[s] = 1;

    while(!Q.empty())
    {
        int pre = Q.front();
        Q.pop();
        inQ[pre] = 0;

        for(int i = sccHead[pre]; i != -1; i = sccEdge[i].next)
        {
            int son = sccEdge[i].v, w = sccEdge[i].w;
            if(dis[son] < dis[pre] + w)
            {
                dis[son] = dis[pre] + w;
                if(inQ[son] == 0)
                {
                    Q.push(son);
                    inQ[son] = 1;
                }
            }
        }
    }

    int Max = 0;
    for(int i = 1; i < scc; i++)
    {
        if(out[i] == 0)
        {
            if(dis[i] > Max)
                Max = dis[i];
        }
    }
    return Max;
}

void bulid_scc(int n, int &sol)
{
    int u, v;
    for(int i = 0; i < n; i++)
    {
        for(int j = head[i]; j != -1; j = edge[j].next)
        {
            u = i, v = edge[j].v;
            if(id[u] == id[v])
                continue;
            else
            {
                sccEdge[sccCntEdge].v = id[v];
                sccEdge[sccCntEdge].w = idw[id[v]];
                sccEdge[sccCntEdge].next = sccHead[id[u]];
                sccHead[id[u]] = sccCntEdge++;

                in[id[v]]++;
                out[id[u]]++;
            }
        }
    }

    int Max = 0;
    for(int i = 1; i < scc; i++)
    {
        if(in[i] == 0)
        {
            sccEdge[sccCntEdge].v = i;
            sccEdge[sccCntEdge].w = idw[i];
            sccEdge[sccCntEdge].next = sccHead[0];
            sccHead[0] = sccCntEdge++;

        }
    }

    sol = spfa(0);
    return ;
}

int main(void)
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif

    int n, m;
    while(scanf("%d %d", &n, &m) == 2)
    {
        int u, v, t;
        init();
        for(int i = 0; i < n; i++)
        {
            scanf("%d", &t);
            if(t > 0)
                weight[i] = t;
            else
                weight[i] = 0;
        }
        for(int i = 0; i < m; i++)
        {
            scanf("%d %d", &u, &v);
            addEdge(u, v);
        }
        for(int i = 0; i < n; i++)
        {
            if(dfn[i] == -1)
                tarjan_scc(i);
        }
        int sol;
        bulid_scc(n, sol);
        printf("%d\n", sol);
    }
    return 0;
}