bzoj 1179 [APIO 2009]Atm(APIO水题) - Tarjan - spfa

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

Hint

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

---

　　觉得这道题和某道noip题（买卖水晶球的题）比较像，这道题似乎不能双向spfa，但是可以先用Tarjan找到强联通分量，然后缩点，这样就是一个有向无环图，就可以进行spfa，在有酒吧的点找最大值。

Code

/**
 * bzoj
 * Problem#1179
 * Accepted
 * Time:6280ms
 * Memory:56800k
 */
#include<iostream>
#include<fstream> 
#include<sstream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<ctime>
#include<map>
#include<stack>
#include<set>
#include<queue>
#include<vector>
#ifndef WIN32
#define AUTO "%lld"
#else
#define AUTO "%I64d"
#endif
using namespace std;
typedef bool boolean;
#define inf 0xfffffff
#define smin(a, b) (a) = min((a), (b))
#define smax(a, b) (a) = max((a), (b))
template<typename T>
inline boolean readInteger(T& u) {
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-' && x != -1);
    if(x == -1)    {
        ungetc(x, stdin);
        return false;
    }
    if(x == '-') {
        aFlag = -1;
        x = getchar();
    }
    for(u = x - '0'; isdigit((x = getchar())); u = u * 10 + x - '0');
    u *= aFlag;
    ungetc(x, stdin);
    return true;
}

///map template starts
typedef class Edge{
    public:
        int end;
        int next;
        Edge(const int end = 0, const int next = 0):end(end), next(next) {    }
}Edge;

typedef class MapManager{
    public:
        int ce;
        int *h;
        Edge *edge;
        MapManager() {    }
        MapManager(int points, int limit):ce(0) {
            h = new int[(const int)(points + 1)];
            edge = new Edge[(const int)(limit + 1)];
            memset(h, 0, sizeof(int) * (points + 1));
        }
        inline void addEdge(int from, int end) {
            edge[++ce] = Edge(end, h[from]);
            h[from] = ce;
        }
        Edge& operator [] (int pos) {
            return edge[pos];
        }
}MapManager;
#define m_begin(g, i) (g).h[(i)]
///map template ends

int n, m, s, p;
int* moneys;
MapManager g;
boolean *rest;

inline void init() {
    readInteger(n);
    readInteger(m);
    moneys = new int[(const int)(n + 1)];
    rest = new boolean[(const int)(n + 1)];
    g = MapManager(n, 2 * m);
    memset(rest, false, sizeof(boolean) * (n + 1));
    for(int i = 1, a, b; i <= m; i++) {
        readInteger(a);
        readInteger(b);
        g.addEdge(a, b);
    }
    for(int i = 1; i <= n; i++)
        readInteger(moneys[i]);
    readInteger(s);
    readInteger(p);
    for(int i = 1, a; i <= p; i++) {
        readInteger(a);
        rest[a] = true;
    }
}

int cnt = 0;
boolean *visited, *instack;
int* visitID, *exitID;
int *belong;
stack<int> st;

inline void getPart(int end) {
    int x;
    do {
        x = st.top();
        st.pop();
        instack[x] = false;
        if(x != end) {
            moneys[end] += moneys[x];
            rest[end] = rest[x] || rest[end];
        }
        belong[x] = end;
    } while(x != end);
}

void tarjan(int node) {
    visited[node] = instack[node] = true;
    st.push(node);
    visitID[node] = exitID[node] = ++cnt;
    for(int i = m_begin(g, node); i != 0; i = g[i].next) {
        int& e = g[i].end;
        if(!visited[e]) {
            tarjan(e);
            smin(exitID[node], exitID[e]);
        } else if(instack[e]) {
            smin(exitID[node], visitID[e]);
        }
    }
    if(visitID[node] == exitID[node])    getPart(node);
}

MapManager ng;
inline void build() {
    visited = new boolean[(const int)(n + 1)];
    instack = new boolean[(const int)(n + 1)];
    visitID = new int[(const int)(n + 1)];
    exitID  = new int[(const int)(n + 1)];
    belong  = new int[(const int)(n + 1)];
    memset(visited, false, sizeof(boolean) * (n + 1));
    memset(instack, false, sizeof(boolean) * (n + 1));
    ng = MapManager(n, m);
    tarjan(s);
    for(int i = 1; i <= n; i++) {
        for(int j = m_begin(g, i); j != 0; j = g[j].next) {
            int& e = g[j].end;
            if(belong[i] == belong[e])    continue;
            ng.addEdge(belong[i], belong[e]);
        }
    }
    delete[] instack;
    delete[] visitID;
    delete[] exitID;
}

queue<int> que;
int *f;
inline void spfa() {
    f = new int[(const int)(n + 1)];
    memset(f, 0, sizeof(int) * (n + 1));
    memset(visited, false, sizeof(boolean) * (n + 1));
    que.push(belong[s]);
    f[belong[s]] = moneys[belong[s]];
    while(!que.empty()) {
        int e = que.front();
        que.pop();
        visited[e] = false;
        for(int i = m_begin(ng, e); i != 0; i = ng[i].next) {
            int eu = ng[i].end;
            if(belong[eu] != eu || belong[eu] == belong[e])    continue;
            if(f[eu] < f[e] + moneys[eu]) {
                f[eu] = f[e] + moneys[eu];
                if(!visited[eu]) {
                    que.push(eu);
                    visited[eu] = true;
                }
            }
        }
    }
}

inline void solve() {
    build();
    spfa();
    int res = 0;
    for(int i = 1; i <= n; i++) {
        if(belong[i] == i && rest[i]) {
            smax(res, f[i]); 
        } 
    }
    printf("%d", res);
}

int main() {
    init();
    solve();
    return 0;
}