洛谷2656 采蘑菇

洛谷2656 采蘑菇

本题地址： http://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

【思路】

强连通分量+最长路。

Tarjan算法求SCC＋缩点。SCC中的结点是可以互相到达的因此SCC内部的边权可以全部获得，将每条指向SCC的边权加上SCC的内部边权，再求一遍最长路即可。

需要注意的有：

1、记录f而不要将w提前分解成边。

2、不要把大数组开在函数里面，否则会ＲＥ　＝－＝。这点学了。

【代码】

#include<cstdio>
#include<cstring>
#include<queue>
#include<stack>
#include<cmath>
#include<iostream>
using namespace std;

const int maxn = 80000+10,maxm=200000+10;
const int INF=1<<30;
struct Edge{
int v,w,next;
double f;
}e[maxm];
int en=-1,front[maxn];

int n,m,s;

stack<int> S;
int scc_cnt,dfs_clock;
int sccno[maxn],pre[maxn],lowlink[maxn],scc_v[maxn];
void dfs(int u) {
pre[u]=lowlink[u]=++dfs_clock;
S.push(u);
for(int i=front[u];i>=0;i=e[i].next){
int v=e[i].v;
if(!pre[v]) {
dfs(v);
lowlink[u]=min(lowlink[u],lowlink[v]);
}
else if(!sccno[v]) {
lowlink[u]=min(lowlink[u],pre[v]);
}
}
if(lowlink[u]==pre[u])
{
scc_cnt++;
for(;;) {
int v=S.top(); S.pop();
sccno[v]=scc_cnt;
if(v==u) break;
}
}
}
void find_scc(int n) {
dfs_clock=scc_cnt=0;
memset(pre,0,sizeof(pre));
memset(sccno,0,sizeof(sccno));
for(int i=1;i<=n;i++)
if(!pre[i]) dfs(i);
}

inline void AddEdge(int u,int v,int w,double f) {
en++; e[en].v=v; e[en].w=w; e[en].f=f; e[en].next=front[u]; front[u]=en;
}

struct SPFA
{
Edge es[maxm];
int esn,fr[maxn];
int inq[maxn],d[maxn];
queue<int> q;
int n;
void init(int n) {
this->n=n; esn=0;
memset(fr,-1,sizeof(fr));
}
void addedge(int u,int v,int w) {
esn++; es[esn].v=v; es[esn].w=w; es[esn].next=fr[u]; fr[u]=esn;
}
void solve(int s) {
memset(inq,0,sizeof(inq));
for(int i=1;i<=n;i++) d[i]=-INF;

d[s]=scc_v[s]; inq[s]=1; q.push(s);
while(!q.empty()) {
int u=q.front(); q.pop(); inq[u]=0;
for(int i=fr[u];i>=0;i=es[i].next) {
int v=es[i].v,w=es[i].w;
if(d[v]<d[u]+w) {
d[v]=d[u]+w;
if(!inq[v]) {
inq[v]=1;
q.push(v);
}
}
}
}
int ans=0;
for(int i=1;i<=n;i++) ans=max(ans,d[i]);
printf("%d\n",ans);
}
};
SPFA spfa;

int main() {
memset(front,-1,sizeof(front));
scanf("%d%d",&n,&m);
int u,v,w; double f;
for(int i=0;i<m;i++) {
scanf("%d%d%d%lf",&u,&v,&w,&f);
AddEdge(u,v,w,f);
}
scanf("%d",&s);
find_scc(n);

spfa.init(scc_cnt);

for(int u=1;u<=n;u++) {
for(int i=front[u];i>=0;i=e[i].next) {
int v=e[i].v,w=e[i].w;
double f=e[i].f;
if(sccno[u]==sccno[v])
{
scc_v[sccno[v]] += w; w=(int)(w*f);
while(w) {
scc_v[sccno[v]] += w;
w=(int)(w*f);
}
}
}
}
for(int u=1;u<=n;u++) {
for(int i=front[u];i>=0;i=e[i].next) {
int v=e[i].v,w=e[i].w;
if(sccno[u]!=sccno[v]) {
w += scc_v[sccno[v]];    //sccno[v]
spfa.addedge(sccno[u],sccno[v],w);  //sccno[u]->sccno[v]
}
}
}

spfa.solve(sccno[s]);

return 0;
}