洛谷—— 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=0; register char ch=getchar();
    for(; ch>'9'||ch<'0'; ) ch=getchar();
    for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
}
const int M(200005);
const int N(80005);
int n,m,s; double r;
int head[N],sumedge;
struct Edge {
    int v,next,w;double r;
    Edge(int v=0,int next=0,int w=0,double r=0.):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]=1;
    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]=0;
        }
        instack[u]=0; 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=-1; que.push(s);
    for(int u,v,w; !que.empty(); )
    {
        u=que.front(); que.pop(); inq[u]=0;
        for(int i=0; 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]=1,que.push(v);
        }
    }
    for(int i=1; i<=n; ++i) ret=ret>dis[i]?ret:dis[i];
    return ret;
}

int Presist()
{
    read(n),read(m);
    for(int u,v,w,i=1; i<=m; ++i)
    {
        read(u),read(v),read(w),
        scanf("%lf",&r),ins(u,v,w,r);
    }
    for(int i=1; i<=n; ++i)
        if(!dfn[i])    DFS(i);
    for(int v,u=1; 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
",SPFA(col[s]));
    return 0;
}

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