这道题目事实上就是在求有没有正环。与求负环的差别就是要不断的更新值,可是这个值要变大。而不是变小。

Currency Exchange
Time Limit: 1000MS   Memory Limit: 30000K
Total Submissions: 20441   Accepted: 7337

Description

Several currency exchange points are working in our city. Let us suppose that each point specializes in two particular currencies and performs exchange operations only with these currencies. There can be several points specializing in the same pair of currencies.
Each point has its own exchange rates, exchange rate of A to B is the quantity of B you get for 1A. Also each exchange point has some commission, the sum you have to pay for your exchange operation. Commission is always collected in source currency. 

For example, if you want to exchange 100 US Dollars into Russian Rubles at the exchange point, where the exchange rate is 29.75, and the commission is 0.39 you will get (100 - 0.39) * 29.75 = 2963.3975RUR. 

You surely know that there are N different currencies you can deal with in our city. Let us assign unique integer number from 1 to N to each currency. Then each exchange point can be described with 6 numbers: integer A and B - numbers of currencies it exchanges,
and real RAB, CAB, RBA and CBA - exchange rates and commissions when exchanging A to B and B to A respectively. 

Nick has some money in currency S and wonders if he can somehow, after some exchange operations, increase his capital. Of course, he wants to have his money in currency S in the end. Help him to answer this difficult question. Nick must always have non-negative
sum of money while making his operations. 

Input

The first line of the input contains four numbers: N - the number of currencies, M - the number of exchange points, S - the number of currency Nick has and V - the quantity of currency units he has. The following M lines contain 6 numbers each - the description
of the corresponding exchange point - in specified above order. Numbers are separated by one or more spaces. 1<=S<=N<=100, 1<=M<=100, V is real number, 0<=V<=103

For each point exchange rates and commissions are real, given with at most two digits after the decimal point, 10-2<=rate<=102, 0<=commission<=102

Let us call some sequence of the exchange operations simple if no exchange point is used more than once in this sequence. You may assume that ratio of the numeric values of the sums at the end and at the beginning of any simple sequence of the exchange operations
will be less than 104

Output

If Nick can increase his wealth, output YES, in other case output NO to the output file.

Sample Input

3 2 1 20.0
1 2 1.00 1.00 1.00 1.00
2 3 1.10 1.00 1.10 1.00

Sample Output

YES
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <limits.h>
#include <ctype.h>
#include <string.h>
#include <string>
#include <math.h>
#include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <deque>
#include <vector>
#include <set>
#include <map>
using namespace std;
const int INF = 99999999.9;
const int EM = 5555;
const int VM = 110;
int n,m,s;
double mon; struct Edge{
int u,v;
double com;
double exg;
}edge[EM<<1];
int cnt;
double dis[VM];
//double mon; /*void addage(int cu,int vu,double aa,double bb){
edge[cnt].from = cu;
edge[cnt].to = vu;
edge[cnt].com = aa;
edge[cnt].exg = bb;
cnt++;
}*/ int Bellman(){
int i,j,flag;
for(i=1;i<=n;i++){
dis[i] = 0.0;
}
dis[s] = mon;
for(i=1;i<n;i++){
bool flag = false;
for(j=0;j<cnt;j++){
int u = edge[j].u;
int v = edge[j].v;
double rate = edge[j].exg;
double cost = edge[j].com;
if(dis[v]<(dis[u]-cost)*rate)//求最大的路径
{
dis[v]=(dis[u]-cost)*rate;
flag=true;
}
//if(dis[edge[j].to] < (dis[edge[j].from]-edge[j].com)*edge[j].exg){
// dis[edge[j].to] = (dis[edge[j].from]-edge[j].com)*edge[j].exg;
// flag = 1;
//}
}
if(flag==false){
return false;
}
}
for(j=0; j<cnt; j++)
{
if(dis[edge[j].v]<(dis[edge[j].u]-edge[j].com)*edge[j].exg)//与传统的bell不一样,传统的bell是找负环。如今是找正环,正环无限松弛
return true;
}
return false;
} int main(){
//int n,m,s;
//double mon;
double rab,cab,rba,cba;
int marka,markb; while(~scanf("%d%d%d%lf",&n,&m,&s,&mon)){
cnt = 0;
//flag = 1;
while(m--){
scanf("%d%d%lf%lf%lf%lf",&marka,&markb,&rab,&cab,&rba,&cba);
//addage(marka,markb,a2,a1);
//addage(markb,marka,b2,b1);
edge[cnt].u=marka,edge[cnt].v=markb,edge[cnt].com=cab,edge[cnt].exg=rab;
cnt++;
edge[cnt].u=markb,edge[cnt].v=marka,edge[cnt].com=cba,edge[cnt].exg=rba;
cnt++;
}
if(Bellman()){
printf("YES\n");
}
else{
printf("NO\n");
}
} return 0;
}

Bellman 算法的更多相关文章

  1. 最短路径问题——bellman算法

    关于最短路径问题,最近学了四种方法——bellman算法.邻接表法.dijkstra算法和floyd-warshall算法. 这当中最简单的为bellman算法,通过定义一个边的结构体,存储边的起点. ...

  2. Bellman算法

    Bellman算法 当图有负圈的时候可以用这个判断最短路! [时间复杂度]O(\(nm\)) &代码: #include <bits/stdc++.h> using namespa ...

  3. 数据结构与算法--最短路径之Bellman算法、SPFA算法

    数据结构与算法--最短路径之Bellman算法.SPFA算法 除了Floyd算法,另外一个使用广泛且可以处理负权边的是Bellman-Ford算法. Bellman-Ford算法 假设某个图有V个顶点 ...

  4. Floyd 和 bellman 算法

    Floyd-Warshall算法(Floyd-Warshall algorithm)是解决任意两点间的最短路径的一种算法,可以正确处理有向图或负权的最短路径问题,同时也被用于计算有向图的传递闭包. F ...

  5. Dijkstra算法与Bellman - Ford算法示例(源自网上大牛的博客)【图论】

    题意:题目大意:有N个点,给出从a点到b点的距离,当然a和b是互相可以抵达的,问从1到n的最短距离 poj2387 Description Bessie is out in the field and ...

  6. 最短路径问题——floyd算法

    floyd算法和之前讲的bellman算法.dijkstra算法最大的不同在于它所处理的终于不再是单源问题了,floyd可以解决任何点到点之间的最短路径问题,个人觉得floyd是最简单最好用的一种算法 ...

  7. 最短路径问题——dijkstra算法

    仅谈谈个人对dijkstra的理解,dijkstra算法是基于邻接表实现的,用于处理单源最短路径问题(顺便再提一下,处理单源最短路径问题的还有bellman算法).开辟一个结构体,其变量为边的终点和边 ...

  8. nyoj 115------城市平乱( dijkstra // bellman )

    城市平乱 时间限制:1000 ms  |  内存限制:65535 KB 难度:4   描述 南将军统领着N个部队,这N个部队分别驻扎在N个不同的城市. 他在用这N个部队维护着M个城市的治安,这M个城市 ...

  9. poj 3259 Wormholes spfa算法

    点击打开链接 Wormholes Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 25582   Accepted: 9186 ...

随机推荐

  1. poj 2356 Find a multiple(鸽巢原理)

    Description The input contains N natural (i.e. positive integer) numbers ( N <= ). Each of that n ...

  2. FreeMarker的模板文件语法

    FreeMarker的模板文件并不比HTML页面复杂多少,FreeMarker模板文件主要由如下4个部分组成: 1,文本:直接输出的部分 2,注释:<#-- ... -->格式部分,不会输 ...

  3. iOS安全攻防(二十三):Objective-C代码混淆

    iOS安全攻防(二十三):Objective-C代码混淆 class-dump能够非常方便的导出程序头文件,不仅让攻击者了解了程序结构方便逆向,还让着急赶进度时写出的欠完好的程序给同行留下笑柄. 所以 ...

  4. python中使用mahotas包实现高斯模糊

    高斯模糊 import mahotas as mh import numpy as np from matplotlib import pyplot as plt image=mh.imread('i ...

  5. JAXB 注解

    JAXB(Java API for XML Binding),它提供了一个便捷的方式高速Java对象XML转变.于JAX-WS(Java的WebService规范之中的一个)中,JDK1.6 自带的版 ...

  6. android——背景颜色渐变(梯度变化)

    首先在drawable文件夹下面新建一个xml文件,起名为bgcolor.xml. 代码如下: <?xml version="1.0" encoding="utf- ...

  7. C++程序设计实践指导1.9统计与替换字符串中的关键字改写要求实现

    改写要求1:将字符数组str改为字符指针p,动态开辟存储空间 改写要求2:增加统计关键字个数的函数void CountKeyWords() 改写要求3: 增加替换函数void FindKeyWords ...

  8. jquery 获取自定义属性(attr 和 prop的区别)

    在高版本的jquery引入prop方法后,什么时候该用prop?什么时候用attr?它们两个之间有什么区别?这些问题就出现了. 关于它们两个的区别,网上的答案很多.这里谈谈我的心得,我的心得很简单: ...

  9. 是一个IPV6地址

    每次在VS上调试,发现本机地址是 ::1 这种就不解.由于太忙而没关注,今天看了IPV6的文章才明白.原来这是个IPV6地址,也就是本机环回地址.以前是127.0.0.1,IPV4版本,而IPV6的就 ...

  10. css3弹性盒模型(Flexbox)

    Flexbox是布局模块,而不是一个简单的属性,它包含父元素和子元素的属性. Flexbox布局的主体思想是似的元素可以改变大小以适应可用空间,当可用空间变大,Flex元素将伸展大小以填充可用空间,当 ...