洛谷—— P2656 采蘑菇

https://www.luogu.org/problem/show?pid=2656

题目描述

小胖和ZYR要去ESQMS森林采蘑菇。

ESQMS森林间有N个小树丛，M条小径，每条小径都是单向的，连接两个小树丛，上面都有一定数量的蘑菇。小胖和ZYR经过某条小径一次，可以采走这条路上所有的蘑菇。由于ESQMS森林是一片神奇的沃土，所以一条路上的蘑菇被采过后，又会长出一些新的蘑菇，数量为原来蘑菇的数量乘上这条路的“恢复系数”，再下取整。

比如，一条路上有4个蘑菇，这条路的“恢复系数”为0.7，则第一~四次经过这条路径所能采到的蘑菇数量分别为4,2,1,0.

现在，小胖和ZYR从S号小树丛出发，求他们最多能采到多少蘑菇。

对于30%的数据，N<=7，M<=15

另有30%的数据，满足所有“恢复系数”为0

对于100%的数据，N<=80,000，M<=200,000，0.1<=恢复系数<=0.8且仅有一位小数，1<=S<=N.

输入输出格式

输入格式：

第一行，N和M

第2……M+1行，每行4个数字，分别表示一条小路的起点，终点，初始蘑菇数，恢复系数。

第M+2行，一个数字S

输出格式：

一个数字，表示最多能采到多少蘑菇，在int32范围内。

输入输出样例

输入样例#1： 复制

3 3
1 2 4 0.5
1 3 7 0.1
2 3 4 0.6
1

输出样例#1： 复制

8

容易发现当他可以来回走多次采蘑菇的时候，就是出现环的时候，那么就可以将这个环的所有能得到的蘑菇数处理出来。
一遍最短路求出ans、需要注意的是这里两个强连通分量连边时，因为边是有权值的，所以不能只连一条。

 #include <cstdio>
 #include <vector>
 #include <queue>

 #define min(a,b) (a<b?a:b)

 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }
 const int M();
 const int N();
 int n,m,s; double r;
 int head[N],sumedge;
 struct Edge {
     int v,next,w;double r;
     Edge(int v=,int next=,int w=,double r=.):v(v),next(next),w(w),r(r){}
 }edge[M];
 inline void ins(int u,int v,int w,double r)
 {
     edge[++sumedge]=Edge(v,head[u],w,r),head[u]=sumedge;
 }

 int tim,low[N],dfn[N];
 int top,Stack[N],instack[N];
 int sumcol,col[N];
 void DFS(int u)
 {
     low[u]=dfn[u]=++tim;
     Stack[++top]=u,instack[u]=;
     for(int v,i=head[u]; i; i=edge[i].next)
     {
         v=edge[i].v;
         if(!dfn[v]) DFS(v), low[u]=min(low[u],low[v]);
         else if(instack[v]) low[u]=min(low[u],dfn[v]);
     }
     if(dfn[u]==low[u])
     {
         col[u]=++sumcol;
         for(; u!=Stack[top]; --top)
         {
             col[Stack[top]]=sumcol;
             instack[u]=;
         }
         instack[u]=; top--;
     }
 }

 int dis[N];
 bool inq[N];
 std::queue<int>que;
 std::vector< std::pair<int,int> >vec[N];
 inline int SPFA(int s)
 {
     int ret=-; que.push(s);
     for(int u,v,w; !que.empty(); )
     {
         u=que.front(); que.pop(); inq[u]=;
         for(int i=; i<vec[u].size(); ++i)
         {
             v=vec[u][i].first,w=vec[u][i].second;
             if(dis[v]>=dis[u]+w) continue;
             dis[v]=dis[u]+w;
             if(!inq[v]) inq[v]=,que.push(v);
         }
     }
     for(int i=; i<=n; ++i) ret=ret>dis[i]?ret:dis[i];
     return ret;
 }

 int Presist()
 {
     read(n),read(m);
     for(int u,v,w,i=; i<=m; ++i)
     {
         read(u),read(v),read(w),
         scanf("%lf",&r),ins(u,v,w,r);
     }
     for(int i=; i<=n; ++i)
         if(!dfn[i])    DFS(i);
     for(int v,u=; u<=n; ++u)
         for(int i=head[u]; i; i=edge[i].next)
         {
             v=edge[i].v;
             if(col[v]==col[u])
                  for(int w=edge[i].w; w; w*=edge[i].r) dis[col[u]]+=w;
             else vec[col[u]].push_back(std::make_pair(col[v],edge[i].w));
         }
     read(s); printf("%d\n",SPFA(col[s]));
     return ;
 }

 int Aptal=Presist();
 int main(int argc,char**argv){;}