Sightseeing Cows
Time Limit: 1000MS   Memory Limit: 65536K
Total Submissions: 8915   Accepted: 3000

Description

Farmer John has decided to reward his cows for their hard work by taking them on a tour of the big city! The cows must decide how best to spend their free time.

Fortunately, they have a detailed city map showing the L (2 ≤ L ≤ 1000) major landmarks (conveniently numbered 1.. L) and the P (2 ≤ P ≤ 5000) unidirectional cow paths that join them. Farmer John will drive the cows to a starting landmark of their choice, from which they will walk along the cow paths to a series of other landmarks, ending back at their starting landmark where Farmer John will pick them up and take them back to the farm. Because space in the city is at a premium, the cow paths are very narrow and so travel along each cow path is only allowed in one fixed direction.

While the cows may spend as much time as they like in the city, they do tend to get bored easily. Visiting each new landmark is fun, but walking between them takes time. The cows know the exact fun values Fi (1 ≤ Fi ≤ 1000) for each landmark i.

The cows also know about the cowpaths. Cowpath i connects landmark L1i to L2i (in the direction L1i -> L2i ) and requires time Ti (1 ≤ Ti ≤ 1000) to traverse.

In order to have the best possible day off, the cows want to maximize the average fun value per unit time of their trip. Of course, the landmarks are only fun the first time they are visited; the cows may pass through the landmark more than once, but they do not perceive its fun value again. Furthermore, Farmer John is making the cows visit at least two landmarks, so that they get some exercise during their day off.

Help the cows find the maximum fun value per unit time that they can achieve.

Input

* Line 1: Two space-separated integers: L and P
* Lines 2..L+1: Line i+1 contains a single one integer: Fi
* Lines L+2..L+P+1: Line L+i+1 describes cow path i with three space-separated integers: L1i , L2i , and Ti

Output

* Line 1: A single number given to two decimal places (do not perform explicit rounding), the maximum possible average fun per unit time, or 0 if the cows cannot plan any trip at all in accordance with the above rules.

Sample Input

5 7
30
10
10
5
10
1 2 3
2 3 2
3 4 5
3 5 2
4 5 5
5 1 3
5 2 2

Sample Output

6.00
题解:
题意就是,这个人带牛旅行,旅行每个城市会有幸福度,通过每个城市会花费时间,让找平均每秒的最大幸福度;
最短路01分数规划,也就是最优比率环问题;刚开始用了Bellman各种超时,换了SPFA也是,最后把INF改大了,SPFA过了,最后想想BELLMAN的时间复杂度N*M又改了种写法,就各种wa了,真心疲惫;
SPFA:
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#define mem(x,y) memset(x,y,sizeof(x))
using namespace std;
const int INF=10000000000000;
typedef long long LL;
const int MAXN=1010;
const int MAXM=100010;
/*struct Node{
int u,v;
double t;
};
Node dt[MAXM];*/
struct Edge{
int from,to,next,t;
};
Edge edg[MAXM];
int head[MAXM];
int edgnum;
void add(int u,int v,int t){
Edge E={u,v,head[u],t};
edg[edgnum]=E;
head[u]=edgnum++;
}
int L,P;
double hp[MAXN],dis[MAXN];
int usd[MAXN],vis[MAXN];
/*void add(int u,int v,double t){
Node E={u,v,t};
dt[edgnum++]=E;
}*/
//double R;
/*bool Bellman(){
mem(dis,INF);
mem(usd,0);
dis[1]=0;
while(1){
int temp=0;
for(int j=0;j<edgnum;j++){
int u=dt[j].u,v=dt[j].v;
double t=dt[j].t;
//dis[v]=min(dis[v],dis[u]+R*t-hp[u]);//应该是R*t-hp[u];
if(dis[v]>dis[u]+R*t-hp[u])usd[v]++,dis[v]=dis[u]+R*t-hp[u],temp=1;
if(usd[v]>L)return false;
}
if(!temp)return true;
}
}*/
bool SPFA(double R){
queue<int>dl;
while(!dl.empty())dl.pop();
for(int i=1;i<=L;i++){
dis[i]=INF;
vis[i]=0;
usd[i]=0;
}
dl.push(1);
vis[1]=1;
usd[1]++;
dis[1]=0;
while(!dl.empty()){
int u=dl.front();
dl.pop();
vis[u]=0;
for(int i=head[u];i!=-1;i=edg[i].next){
int v=edg[i].to,t=edg[i].t;
if(dis[v]>dis[u]+R*t-hp[u]){
dis[v]=dis[u]+R*t-hp[u];
if(!vis[v]){
vis[v]=1;
usd[v]++;
dl.push(v);
// printf("%d\n",usd[v]);
if(usd[v]>=L)return false;
}
}
}
}
return true;
}
int main(){
int a,b;
int c;
while(~scanf("%d%d",&L,&P)){
edgnum=0;
double mih=INF,mxh=-INF;
int mit=INF,mxt=-INF;
mem(head,-1);
for(int i=1;i<=L;i++){
scanf("%lf",hp+i);
mih=min(mih,hp[i]);
mxh=max(mxh,hp[i]);
}
while(P--){
scanf("%d%d%d",&a,&b,&c);
add(a,b,c);
mit=min(mit,c);
mxt=max(mxt,c);
}
double l=mih/mxt,r=mxh/mit;
// printf("%f %f\n",l,r);
double R;
while(r-l>=0.001){
R=(l+r)/2;
if(SPFA(R))r=R;
else l=R;
}
printf("%.2f\n",l);
}
return 0;
}

  

  Bellman还在wa,贴上求大神帮忙看看;

wa代码:

 #include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#define mem(x,y) memset(x,y,sizeof(x))
using namespace std;
const int INF=;
typedef long long LL;
const int MAXN=;
const int MAXM=;
struct Node{
int u,v;
int t;
};
Node dt[MAXM];
/*struct Edge{
int from,to,next,t;
};
Edge edg[MAXM];
int head[MAXM];*/
int edgnum;
/*void add(int u,int v,int t){
Edge E={u,v,head[u],t};
edg[edgnum]=E;
head[u]=edgnum++;
}*/
int L,P;
double hp[MAXN],dis[MAXN];
int usd[MAXN],vis[MAXN];
void add(int u,int v,int t){
Node E={u,v,t};
dt[edgnum++]=E;
}
//double R;
bool Bellman(double R){
for(int i=;i<=L;i++){
usd[i]=;
dis[i]=INF;
}
dis[]=;
usd[]++;
while(){
int temp=;
for(int j=;j<edgnum;j++){
int u=dt[j].u,v=dt[j].v;
int t=dt[j].t;
//dis[v]=min(dis[v],dis[u]+R*t-hp[u]);//应该是R*t-hp[u];
if(dis[v]>dis[u]+R*t-hp[u])dis[v]=dis[u]+R*t-hp[u],temp=,usd[v]++;
if(usd[v]>=L)return false;
}
if(!temp)return true;
}
/*for(int j=0;j<edgnum;j++){
int u=dt[j].u,v=dt[j].v;
int t=dt[j].t;
if(dis[v]>dis[u]+R*t-hp[u])return false;
}
return true;*/
}
/*bool SPFA(double R){
queue<int>dl;
while(!dl.empty())dl.pop();
for(int i=1;i<=L;i++){
dis[i]=INF;
vis[i]=0;
usd[i]=0;
}
dl.push(1);
vis[1]=1;
usd[1]++;
dis[1]=0;
while(!dl.empty()){
int u=dl.front();
dl.pop();
vis[u]=0;
for(int i=head[u];i!=-1;i=edg[i].next){
int v=edg[i].to,t=edg[i].t;
if(dis[v]>dis[u]+R*t-hp[u]){
dis[v]=dis[u]+R*t-hp[u];
if(!vis[v]){
vis[v]=1;
usd[v]++;
dl.push(v);
// printf("%d\n",usd[v]);
if(usd[v]>=L)return false;
}
}
}
}
return true;
}*/
int main(){
int a,b;
int c;
while(~scanf("%d%d",&L,&P)){
edgnum=;
// double mih=INF,mxh=-INF,mit=INF,mxt=-INF;
//mem(head,-1);
for(int i=;i<=L;i++){
scanf("%lf",hp+i);
// mih=min(mih,hp[i]);
// mxh=max(mxh,hp[i]);
}
while(P--){
scanf("%d%d%d",&a,&b,&c);
add(a,b,c);
//mit=min(mit,c);
// mxt=max(mxt,c);
}
double l=,r=;
// printf("%f %f\n",l,r);
double ans=;
double R;
while(r-l>=0.001){
R=(l+r)/;
if(Bellman(R))r=R;
else ans=R,l=R;
}
printf("%.2f\n",ans);
}
return ;
}

Sightseeing Cows(最优比率环)的更多相关文章

  1. POJ3621 Sightseeing Cows 最优比率环 二分法

    题目链接:http://poj.org/problem?id=3621 Sightseeing Cows Time Limit: 1000MS   Memory Limit: 65536K Total ...

  2. POJ3621 Sightseeing Cows(最优比率环)

    题目链接:id=3621">http://poj.org/problem?id=3621 在一个有向图中选一个环,使得环上的点权和除以边权和最大.求这个比值. 经典的分数规划问题,我认 ...

  3. POJ 3621 Sightseeing Cows [最优比率环]

    感觉去年9月的自己好$naive$ http://www.cnblogs.com/candy99/p/5868948.html 现在不也是嘛 裸题,具体看学习笔记 二分答案之后判负环就行了 $dfs$ ...

  4. [转]01分数规划算法 ACM 二分 Dinkelbach 最优比率生成树 最优比率环

    01分数规划 前置技能 二分思想最短路算法一些数学脑细胞? 问题模型1 基本01分数规划问题 给定nn个二元组(valuei,costi)(valuei,costi),valueivaluei是选择此 ...

  5. poj 3621(最优比率环)

    题目链接:http://poj.org/problem?id=3621 思路:之前做过最小比率生成树,也是属于0/1整数划分问题,这次碰到这道最优比率环,很是熟悉,可惜精度没控制好,要不就是wa,要不 ...

  6. POJ 3621-Sightseeing Cows-最优比率环|SPFA+二分

    最优比率环问题.二分答案,对于每一个mid,把节点的happy值归类到边上. 对于每条边,用mid×weight减去happy值,如果不存在负环,说明还可以更大. /*---------------- ...

  7. 【poj3621】最优比率环

    题意: 给定n个点,每个点有一个开心度F[i],每个点有m条单向边,每条边有一个长度d,要求一个环,使得它的 开心度的和/长度和 这个比值最大.n<=1000,m<=5000 题解: 最优 ...

  8. POJ 3621 Sightseeing Cows (最优比率环 01分数划分)

    题意: 给定L个点, P条边的有向图, 每个点有一个价值, 但只在第一经过获得, 每条边有一个花费, 每次经过都要付出这个花费, 在图中找出一个环, 使得价值之和/花费之和 最大 分析: 这道题其实并 ...

  9. POJ 3621:Sightseeing Cows(最优比率环)

    http://poj.org/problem?id=3621 题意:有n个点m条有向边,每个点有一个点权val[i],边有边权w(i, j).找一个环使得Σ(val) / Σ(w)最大,并输出. 思路 ...

随机推荐

  1. C++_基础_C与C++的区别2

    内容: (1)C++中的函数 (2)动态内存 (3)引用 (4)类型转换 (5)C++社区对C程序员的建议 1.C++中的函数1.1 函数的重载(1)重载的概念 在同一个作用域中,函数名相同,函数的参 ...

  2. C学习之结构体

    结构体(struct) 结构体是由基本数据类型构成的.并用一个标识符来命名的各种变量的组合,结构体中可以使用不同的数据类型. 1. 结构体说明和结构体变量定义 在Turbo C中, 结构体也是一种数据 ...

  3. Spring管理Hibernate

    为什么要用Hibernate框架? 既然用Hibernate框架访问管理持久层,那为何又提到用Spring来管理以及整合Hibernate呢? 首先我们来看一下Hibernate进行操作的步骤.比如添 ...

  4. 智能电视TV开发---直播视频客户端结构设计和实现

    在智能电视TV开发---客户端和服务器通信里面我们实现了客户端和服务端的简单通信,接下来我们做一个简单的客户端界面,来实现手机端来操控智能电视的TV端. 一.存储视频的结构设计 我们在做客户端的时候, ...

  5. nodejs事件机制

    var EventEmitter = function() { this.evts = {}; }; EventEmitter.prototype = { constructor: EventEmit ...

  6. ngrok原理浅析(转载)

    之前在进行 微信Demo开发时曾用到过 ngrok这个强大的tunnel(隧道)工具,ngrok在其github官方页面上的自我诠释是 "introspected tunnels to lo ...

  7. 简谈python反射

    写出一个简单类:import sysclass webserver(object): def __init__(self,host,post): self.host = host self.post ...

  8. 输入输出函数库stdio.h

    函数名 函数类型与形参类型 函数功能 函数返回值 clearerr void clearerr(fp) FILE * fp; 清除文件指针错误 无 close int close(fp) int fp ...

  9. SMTP邮件传输协议发送邮件和附件

    在以前接触的项目中,一直都是在做网站时用到了发送mail 的功能,在asp 和.net 中都有相关的发送mail 的类, 实现起来非常简单.最近这段时间因工作需要在C++ 中使用发送mail 的功能, ...

  10. PCB成型製程介紹

    PCB成型製程在電子構裝中所扮演的角色 下圖是電腦主機的內部組成 我們將以插在主機板上的一片 USB擴充卡來說明PCB成型製 程在電子構裝中所扮演的角色 PCB成型製程的子製程 USB擴充卡要插入主機 ...