hihocoder #1185 : 连通性·三

时间限制: 10000ms

单点时限: 1000ms

内存限制: 256MB

描述

暑假到了!!小Hi和小Ho为了体验生活，来到了住在大草原的约翰家。今天一大早，约翰因为有事要出去，就拜托小Hi和小Ho忙帮放牧。

约翰家一共有N个草场，每个草场有容量为W[i]的牧草，N个草场之间有M条单向的路径。

小Hi和小Ho需要将牛羊群赶到草场上，当他们吃完一个草场牧草后，继续前往其他草场。当没有可以到达的草场或是能够到达的草场都已经被吃光了之后，小hi和小Ho就把牛羊群赶回家。

一开始小Hi和小Ho在1号草场，在回家之前，牛羊群最多能吃掉多少牧草？

举个例子：

图中每个点表示一个草场，上部分数字表示编号，下部分表示草场的牧草数量w。

在1吃完草之后，小Hi和小Ho可以选择把牛羊群赶到2或者3，假设小Hi和小Ho把牛羊群赶到2：

吃完草场2之后，只能到草场4，当4吃完后没有可以到达的草场，所以小Hi和小Ho就把牛羊群赶回家。

若选择从1到3，则可以到达5，6：

选择5的话，吃完之后只能直接回家。若选择6，还可以再通过6回到3，再到5。

所以该图可以选择的路线有3条：

1->2->4 		total: 11
1->3->5 		total: 9
1->3->6->3->5: 		total: 13
  

所以最多能够吃到的牧草数量为13。

本题改编自USACO月赛金组

提示：强连通分量

输入

第1行：2个正整数，N,M。表示点的数量N，边的数量M。1≤N≤20,000, 1≤M≤100,000

第2行：N个正整数，第i个整数表示第i个牧场的草量w[i]。1≤w[i]≤100,000

第3..M+2行：2个正整数，u,v。表示存在一条从u到v的单向路径。1≤u,v≤N

输出

第1行：1个整数，最多能够吃到的牧草数量。

样例输入

6 6
2 4 3 5 4 4
1 2
2 4
1 3
3 5
3 6
6 3

样例输出

13

思路：先用tarjan算法缩点，然后再重新建图，最后从1号所属的连通分量深搜，求出最大值。

提示中用拓扑排序可以求最值，可我一直wrong answer。。。(无语..)

#include <iostream>
#include<string.h>
using namespace std;
#include<vector>
#include<algorithm>
#define maxn 20010
int low[maxn],dfn[maxn],a[100010],b[100010];
int vis[maxn],Belong[maxn],n,m,instack[maxn];
int cnt,scnt,top,stackn[maxn];
long long w1[maxn],w2[maxn],ans;
vector<int>mat1[maxn];
vector<int>mat2[maxn];
void tarjan(int s)
{
    int k,t,i;
    low[s]=dfn[s]=++cnt;
    instack[s]=1;
    stackn[top++]=s;
   for(i=0;i<mat1[s].size();i++)
   {
       k=mat1[s][i];
       if(!dfn[k])
       {
         tarjan(k);
         low[s]=min(low[s],low[k]);
       }
       else if(instack[k])
       low[s]=min(low[s],dfn[k]);
   }
    if(low[s]==dfn[s])
    {
        scnt++;
        do
        {
            t=stackn[--top];
            Belong[t]=scnt;
            instack[t]=0;
        }while(s!=t);
    }
}
void dfs(int v,long long sum)
{
   int i,k;
   ans=max(ans,sum);
   for(i=0;i<mat2[v].size();i++)
   {  k=mat2[v][i];
       if(!vis[k])
       {
           vis[k]=1;
           dfs(k,sum+w2[k]);
           vis[k]=0;
       }
   }
}
int main()
{
    int i,j,s,e;
    cin>>n>>m;
    for(i=1;i<=n;i++)
        cin>>w1[i];
    for(i=0;i<m;i++)
    {
      cin>>a[i]>>b[i];
      mat1[a[i]].push_back(b[i]);
    }
    memset(low,0,sizeof(low));
    memset(dfn,0,sizeof(dfn));
    scnt=cnt=top=0;
    for(i=1;i<=n;i++)
        if(!dfn[i])
           tarjan(i);
     memset(w2,0,sizeof(w2));
     for(i=1;i<=n;i++)
        w2[Belong[i]]+=w1[i];
     for(i=0;i<m;i++)
     {
         s=Belong[a[i]];
         e=Belong[b[i]];
         if(s!=e)
         {
             mat2[s].push_back(e);
         }
     }
     ans=0;
     dfs(Belong[1],w2[Belong[1]]);
     cout<<ans<<endl;
    return 0;
}