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

Sample Output

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 = ;
     while(!isdigit((x = getchar())) && x != '-' && x != -);
     if(x == -)    {
         ungetc(x, stdin);
         return false;
     }
     if(x == '-') {
         aFlag = -;
         x = getchar();
     }
     for(u = x - ''; isdigit((x = getchar())); u = u *  + x - '');
     u *= aFlag;
     ungetc(x, stdin);
     return true;
 }

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

 typedef class MapManager{
     public:
         int ce;
         int *h;
         Edge *edge;
         MapManager() {    }
         MapManager(int points, int limit):ce() {
             h = new int[(const int)(points + )];
             edge = new Edge[(const int)(limit + )];
             memset(h, , sizeof(int) * (points + ));
         }
         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 + )];
     rest = new boolean[(const int)(n + )];
     g = MapManager(n,  * m);
     memset(rest, false, sizeof(boolean) * (n + ));
     for(int i = , a, b; i <= m; i++) {
         readInteger(a);
         readInteger(b);
         g.addEdge(a, b);
     }
     for(int i = ; i <= n; i++)
         readInteger(moneys[i]);
     readInteger(s);
     readInteger(p);
     for(int i = , a; i <= p; i++) {
         readInteger(a);
         rest[a] = true;
     }
 }

 int cnt = ;
 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 != ; 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 + )];
     instack = new boolean[(const int)(n + )];
     visitID = new int[(const int)(n + )];
     exitID  = new int[(const int)(n + )];
     belong  = new int[(const int)(n + )];
     memset(visited, false, sizeof(boolean) * (n + ));
     memset(instack, false, sizeof(boolean) * (n + ));
     ng = MapManager(n, m);
     tarjan(s);
     for(int i = ; i <= n; i++) {
         for(int j = m_begin(g, i); j != ; 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 + )];
     memset(f, , sizeof(int) * (n + ));
     memset(visited, false, sizeof(boolean) * (n + ));
     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 != ; 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 = ;
     for(int i = ; i <= n; i++) {
         if(belong[i] == i && rest[i]) {
             smax(res, f[i]);
         }
     }
     printf("%d", res);
 }

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