POJ 3126 --Father Christmas flymouse【scc缩点构图 && SPFA求最长路】

Father Christmas flymouse

Time Limit: 1000MS		Memory Limit: 131072K
Total Submissions: 3007		Accepted: 1021

Description

After retirement as contestant from WHU ACM Team, flymouse volunteered to do the odds and ends such as cleaning out the computer lab for training as extension of his contribution to the team. When Christmas came, flymouse played Father Christmas to give
gifts to the team members. The team members lived in distinct rooms in different buildings on the campus. To save vigor, flymouse decided to choose only one of those rooms as the place to start his journey and follow directed paths to visit one room after
another and give out gifts en passant until he could reach no more unvisited rooms.

During the days on the team, flymouse left different impressions on his teammates at the time. Some of them, like LiZhiXu, with whom flymouse shared a lot of candies, would surely sing flymouse’s deeds of generosity, while the others, like snoopy, would
never let flymouse off for his idleness. flymouse was able to use some kind of comfort index to quantitize whether better or worse he would feel after hearing the words from the gift recipients (positive for better and negative for worse). When arriving at
a room, he chould choose to enter and give out a gift and hear the words from the recipient, or bypass the room in silence. He could arrive at a room more than once but never enter it a second time. He wanted to maximize the the sum of comfort indices accumulated
along his journey.

Input

The input contains several test cases. Each test cases start with two integers N and M not exceeding 30 000 and 150 000 respectively on the first line, meaning that there were N team members living in N distinct rooms
and M direct paths. On the next N lines there are N integers, one on each line, the i-th of which gives the comfort index of the words of the team member in the i-th room. Then follow M lines, each containing
two integers i and j indicating a directed path from the i-th room to the j-th one. Process to end of file.

Output

For each test case, output one line with only the maximized sum of accumulated comfort indices.

Sample Input

2 2
14
21
0 1
1 0

Sample Output

35

Hint

32-bit signed integer type is capable of doing all arithmetic.

题目大意：flymouse要去给人送礼，每一个人分布在不同的地方。且他们之间有m条单向边，另外每一个人获得礼物后flymouse会得到一个舒心值（可正可负）。起始舒适指数为0，现flymouse从某个人開始，沿单向边訪问下一个人（当中点能够訪问多次。但舒心值仅仅能获得一次），求他能获得的最大舒心值。

大致思路：能够先利用强连通缩点。这样在【一个SCC】里的点必定会都訪问，这里需注意。訪问不代表获得该点舒心值，比方该点是负的。那么就不会获得该点舒心值，而不过借用此点訪问下个点。缩点后建立新图，新建的图不一定是连通图，所以虚拟一个起点。有向连接全部的SCC。SPFA跑一遍最长路。 能够求出到每一个点的最长距离，取最大值就是我们要的答案。

详细思路：

思路：用sumnum数组记录每一个SCC的最大舒适指数，用dist数组存储虚拟源点0到节点的最远距离。

一：对有向图求出全部的SCC。

二：求出每一个SCC的sumnum值。（累加全部为正的舒适指数）

三：缩点并对每<u。v>边 建立边权sumnum [v]。

四：设置虚拟源点0。连接全部的SCC。边权为相应SCC的sumnum值。

五：以0为源点跑一次SPFA。对dist数组排序后，输出最大的dist值。

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <queue>
#define maxn 30000 + 3000
#define maxm 150000 + 15000
#define INF 0x3f3f3f3f
using namespace std;
int n, m;
 
struct node {
    int u, v, next;
};
 
node edge[maxn];
int head[maxn], cnt;
int low[maxn], dfn[maxn];
int dfs_clock;
int Stack[maxn], top;
bool Instack[maxn];
int Belong[maxn];
int scc_clock;
int num[maxn];//记录每一个点的舒适度
vector<int>scc[maxn];
 
void initedge(){
    cnt = 0;
    memset(head, -1, sizeof(head));
}
 
void addedge(int u, int v){
    edge[cnt] = {u, v, head[u]};
    head[u] = cnt++;
}
 
void getmap(){
    for(int i = 1; i <= n; ++i)
        scanf("%d", &num[i]);
    while(m--){
        int a, b;
        scanf("%d%d", &a, &b);
        a++, b++;
        addedge(a, b);
    }
}
 
void Tarjan(int u, int per){
    int v;
    low[u] = dfn[u] = ++dfs_clock;
    Stack[top++] = u;
    Instack[u] = true;
    for(int i = head[u]; i != -1; i = edge[i].next){
        int v = edge[i].v;
        if(!dfn[v]){
            Tarjan(v, u);
            low[u] = min(low[u], low[v]);
        }
        else if(Instack[v])
            low[u] = min(low[u], dfn[v]);
    }
    if(dfn[u] == low[u]){
        scc_clock++;
        scc[scc_clock].clear();
        do{
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc_clock;
            scc[scc_clock].push_back(v);
        }
        while( v != u);
    }
}
 
void find(){
    memset(low, 0, sizeof(low));
    memset(dfn, 0, sizeof(dfn));
    memset(Belong, 0, sizeof(Belong));
    memset(Stack, 0, sizeof(Stack));
    memset(Instack, false, sizeof(false));
    dfs_clock = scc_clock = top = 0;
    for(int i = 1; i <= n ; ++i){
        if(!dfn[i])
            Tarjan(i, i);
    }
}
 
struct NODE {
    int u, v, w, next;
};
 
NODE Map[maxn];
int head1[maxn], cnt1;
int vis[maxn], dist[maxn];
int sumnum[maxn];//记录每一个缩点能得到的最大舒适度
 
void initMap(){
    cnt1 = 0;
    memset(head1, -1, sizeof(head1));
}
 
void addMap(int u, int v, int w){
    Map[cnt1] = {u, v, w, head1[u]};
    head1[u] = cnt1++;
}
 
//求出每一个缩点能得到的最大舒适度
//作为到达这个缩点的权值
void change(){
    memset(sumnum, 0, sizeof(sumnum));
    for(int i = 1; i <= scc_clock; ++i){
        for(int j = 0; j < scc[i].size(); ++j){
            if(num[scc[i][j]] > 0)
                sumnum[i] += num[scc[i][j]];
        }
    }
}
 
void suodian(){//缩点 && 新建图
    for(int i = 0; i < cnt; ++i){
        int u = Belong[edge[i].u];
        int v = Belong[edge[i].v];
        if(u != v){
            addMap(u, v, sumnum[v]);
        }
    }
    for(int i = 1; i <= scc_clock; ++i)
        addMap(0, i, sumnum[i]); //建立虚拟源点
}
 
//SPFA跑最长路。求出到达每一个缩点的所能得到的最大舒适度
void SPFA(int x){
    queue<int>q;
    for(int i = 0; i <= scc_clock; ++i){
        dist[i] = -INF;
        vis[i] = 0;
    }
    vis[x] = 1;
    dist[x] = 0;
    q.push(x);
    while(!q.empty()){
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for(int i = head1[u]; i != -1; i = Map[i].next){
            int v = Map[i].v;
            int w = Map[i].w;
            if(dist[v] < dist[u] + w){
                dist[v] = dist[u] + w;
                if(!vis[v]){
                    vis[v] = 1;
                    q.push(v);
                }
            }
        }
    }
}
 
int main(){
    while(scanf("%d%d", &n, &m) != EOF){
        initedge();
        getmap();
        find();
        change();
        initMap();
        suodian();
        SPFA(0);
        sort(dist, dist + scc_clock + 1);
        printf("%d\n", dist[scc_clock]);
    }
    return 0;
}