Arbitrage

POJ2240-Arbitrage

转载请注明出处：優YoU http://user.qzone.qq.com/289065406/blog/1299339309 提示：本题需要建立容器，建立字符串到int的映射（一一对应）关系，把然后字符串作为数组下标，模拟数组   题意：求自身到自身的最大转换率。   最简单的方法就是floryd算法变形，求最大路径后，求最大环，看它是否满足条件。&nbs
·2015-11-13 10:54

POJ 2240 Arbitrage

  要套现的前提是有一种货币经过几次交换能是其到其本身的汇率大于1。就转换成了求任一货币到 其自身的汇率，不过要通过其他货币才能转换到自身，所以用floyd算法，求出所有货币到其他货币 或者自身的最大汇率。这里的floyd计算时是汇率相乘取最大值，这也是与普通floyd的区别。字符串 的处理是本题设置的一个考点吧，不过还好对于这个已经无压力了。   /*Accep
·2015-11-13 03:01

poj2240Arbitrage 判断是否有负环

编辑器加载中... /* 题目：        问周游一圈后能不能换钱得到利润 分析：        有向图是否处在负环问题，因为涉及每个顶点都可能存在负环，        直接用flord算法做即可 */
·2015-11-13 03:07

[POJ2240 Arbitrage]

[题目来源]：POJ2240 [关键字]：判断环 [题目大意]：给出一些汇率，问是否能将手中的钱通过兑换，使最后再换回本币时数量增加。 //===================================================================================================== [分析]：就是判断给出的图中是否存在一条正权环。
·2015-11-13 02:02

POJ 2240, Arbitrage

Time Limit: 1000MS  Memory Limit: 65536KTotal Submissions: 4217  Accepted: 1939 DescriptionArbitrage is the use of discrepancies in currency exchange rates to transform one unit o
·2015-11-13 01:56

Arbitrage

http://poj.org/problem?id=2240 1 #include<cstdio> 2 #include<cstring> 3 #include<algorithm> 4 #define MAXN 100 5 const int INF=1<<28; 6 using namespace std; 7
·2015-11-12 23:49

POJ 2240 Arbitrage

/* bellman，加上map，判断是否有负权回路即可 * */ #include < iostream > #include < string > #include < map > using   namespace  std; #define  MAX 1000 #define  
·2015-11-12 21:31

Arbitrage HDU

                                  &
·2015-11-12 19:13

poj 2240 Arbitrage

又是套汇为题，初始化d数组为1就可以了，用bellman—ford算法。 1 #include<stdio.h> 2 #include<string.h> 3 4 int n, m, num, u[2000], v[2000]; 5 double w[2000], d[50], ra; 6 char s[50][100], s1[100], s2
·2015-11-12 15:07

poj2240Arbitrage（map+floyd)

http://poj.org/problem?id=2240 简单题 1A 只是把结点变成了字符串 用map调下就好 数据量不大 floyd300+ms 货币之间的转换 问转换完是否能获利 View Code 1 #include <iostream> 2 #include<cstdio> 3 #include<string.h>
·2015-11-12 14:34

POJ 1860 Currency Exchange + 2240 Arbitrage + 3259 Wormholes 解题报告

    三道题都是考察最短路算法的判环。其中1860和2240判断正环，3259判断负环。     难度都不大，可以使用Bellman-ford算法，或者SPFA算法。也有用弗洛伊德算法的，笔者还不会SF-_-……     直接贴代码。     1860 Currency Exchange: #in
·2015-11-12 11:01

poj 2240 Arbitrage（bellman-ford spfa 判断正环）

http://poj.org/problem?id=2240   基本和poj 1860相同 只是把单点变成了任意点 做完1860再做这题就完全把思路套上就过了  做完才发现网上的题解都用的是floyd 不过整体思路都是大同小异吧 不过在效率上好像就低下了太多(发现原来是cin的原因 真的是深深感到cin的恶意了)= =   bellman #i
·2015-11-12 10:43

poj-------(2240)Arbitrage(最短路)

Arbitrage Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 
·2015-11-11 19:55

POJ 2240 Arbitrage(最短路 套汇)

题意  给你n种币种之间的汇率关系  推断是否能形成套汇现象  即某币种多次换为其他币种再换回来结果比原来多 基础的最短路  仅仅是加号换为了乘号 #include<cstdio> #include<cstring> #include<string> #include<map> using namesp
·2015-11-11 18:49

最短路(Floyd_Warshall) POJ 2240 Arbitrage

  题目传送门 1 /* 2 最短路：Floyd模板题 3 只要把+改为*就ok了，热闹后判断d[i][i]是否大于1 4 文件输入的ONLINE_JUDGE少写了个_，WA了N遍:) 5 */ 6 #include <cstdio> 7 #include <iostream> 8 #include <cstring> 9
·2015-11-11 18:59

poj2240 - Arbitrage(汇率问题,floyd)

题目大意： 给你一个汇率图， 让你判断能否根据汇率盈利   #include <iostream> #include <cstdlib> #include <cstdio> #include <algorithm> #include <vector> #include <queue> #inclu
·2015-11-11 13:59

POJ 2240 Arbitrage(Flyod)

题目链接 理解错题意啊。。。。看题解知道到做法后就很简单了，自己想的算法是错误的。。。对Floyd加深一下理解。这个是有向图找最大的环，我理解的题意偏差的太多了。。。 1 #include <stdio.h> 2 #include <string.h> 3 #define N 1000000 4 char p[31][100]; 5 double
·2015-11-11 10:25

POJ 2240 Arbitrage（floyd）

http://poj.org/problem?id=2240 题意 ： 好吧，又是一个换钱的题：套利是利用货币汇率的差异进行的货币转换，例如用1美元购买0.5英镑，1英镑可以购买10法郎，一法郎可以购买0.21美元，所以0.5*10*0.21 = 1.05，从中获利百分之五，所以需要编写一个程序，在进行完转换之后能不能获利，如果能就输出Yes，反之No； 样例解释 ：  3 US
·2015-11-11 10:57

NYOJ 188 Arbitrage

View Code 1 /* 2 题意： 3 货币之间存在着转换 ，从一种货币转换到 4 另一种货币有有一个转换率，有没有这种情况 5 一种货币经过几次转换再回到这个货币时 6 会增值 7 8 思路： 9 这相当与一个路径问题，找到各个点的最大距离 10 每次从一条边的左边的货币开始转换，看是否能 11 增值 有几条边循环几次 12 */ 13
·2015-11-11 06:51

HDU 1217 Arbitrage (初学Floyed)

题目：http://acm.hdu.edu.cn/showproblem.php?pid=1217   题意：转化成图，然后求是否存在某回路，其权值的积大于1   Floyed是求任意两点间的最短路径的，用了动态规划，思想和松弛一样，其中有个k,是指最短路径的中间点都在集合1....k里，然后k从小到大推，当k最大的时候就得到结果。。。。松弛思想在g[i][k]*g[k
·2015-11-11 04:16

POJ 2240 Arbitrage

解题思路: Bellman-Ford算法，求解负权回路问题，考虑到图的不连通性，添加一个超级初始点，到各顶点汇率均为1： #include < iostream > #include < map > #include < string > using
·2015-11-11 04:02

poj 2240 Arbitrage （floyd 变形）

http://poj.org/problem?id=2240 floyd 的变形 题意 有n个货币，他们的交换情况m个 例如： 3 USDollar BritishPound FrenchFranc 3 USDollar 0.5 BritishPound BritishPound 10.0 FrenchFranc FrenchFranc 0.21 USDollar
·2015-11-11 01:05

Arbitrage HDU

                                  &
·2015-11-09 14:53

POJ 2240 Arbitrage (最短路)

Arbitrage Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 
·2015-11-08 16:50

DFS判断正环

hdu1217 Arbitrage Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536
·2015-11-08 14:17

Hdu 1217 Arbitrage

大意：通过货币的兑换去套利，若能套利则输出Yes，否则输出No。 思路：通过Floyd算法算出的d[i][i]即每种货币能不能套利，只要存在一种则输出Yes。数据的处理通过STL中的map容器去处理。   CODE：   #include <iostream> #include <cstdio> #include&nb
·2015-11-08 11:34

uva 104 Arbitrage

DP构建（仿照Floyd） 这题说难挺难的，现在想想好像也不太难，是因为想复杂了。其实这题的要求不算多，它仅仅是要求最后转换回到出发时的那种硬币并且获利大于0.01，而转换次数不能超过n次，转换次数越少越好，然后输出最短的路径。注意：题目并没有说要你获利最大，只是是获利>=0.01即可，另外题目对路径并没有什么特殊要求，仅仅是要求不能超过n，在路径长度相同的情况任意一条都可以的。 所以我
·2015-11-07 13:49

Arbitrage

  Description Arbitrage is the use of discrepancies in currency exchange rates to transform
·2015-11-07 11:39

poj 2240 Arbitrage

这个题求是否经过兑换后钱能不能增加。 这题可以用bellman比较容易解决； View Code #include<iostream> #include<cstdio> #include<cstdlib> #include<algorithm> #include<cmath> #include<queue&g
·2015-11-07 11:58

POJ2240——Bellman_ford——Arbitrage

Description Arbitrage is the use of discrepancies in currency exchange rates to transform one unit of
·2015-11-07 10:56

Arbitrage--POJ 2240

1、题目类型：图论、最短路径、Floyd算法。 2、解题思路：Floyd算法的简单应用；STL中map的简单应用。 3、注意事项：避免map报警告，文件开始调用#pragma warning(disable:4786)。 4、实现方法: #pragma warning(disable:4786) #include < iostream
·2015-11-02 16:43

hdu 1217 Arbitrage (spfa算法)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1217 题目大意：通过货币的转换，来判断是否获利，如果获利则输出Yes，否则输出No。 这里介绍一个STL中的map容器去处理数据，map<string,int>V,M; 现在我目前的理解是将字符串转换成数字，然后就是根据spfa的模板找最短路了。。哇哈哈( ⊙o⊙ )哇
·2015-11-02 14:08

pku 2240 Arbitrage 第一周训练——最短路

http://poj.org/problem?id=2240 刚开始看到题目时，看到数据量很小，就想到了搜索，搜索所有的环然后将边的权值相乘看是否大存在于1.0的环。。结果果断的TLE无语。。。 最后看了看Discuss floyd1A View Code #include <iostream>#include <cstring>#include <c
·2015-11-01 14:10

nyoj Arbitrage (Bellman-Ford)

跟天下第一挺像的 1 void Bellman(int v0) 2 { 3 int i, k; 4 for (int i = 0; i < n; ++i) { 5 dist[i] = INF, path[i] = -1; 6 } 7 dist[v0] = 0; 8 for (k = 1; k &l
·2015-11-01 13:32

UVA 104 Arbitrage

  大意：给出n种国家的货币汇率，一定金额的某种货币经过一系列汇率变换后再换成原来货币，金额增加了，求出这样的一个变换，要求变换步数最少。   Floyd变形，关于Floyd动态规划的理解。   状态转移方程：f[k][i][j]=min(f[k-1][i][j],f[k-1][i][k]+f[k-1][k][j])f[k][i][j]表示只经过前k个点(包
·2015-10-31 17:26

poj 2240 Arbitrage （Floyd）

链接：poj 2240 题意：首先给出N中货币，然后给出了这N种货币之间的兑换的兑换率。 如 USDollar 0.5 BritishPound 表示 ：1 USDollar兑换成0.5 BritishPound。 问在这N种货币中是否存在货币经过若干次兑换后，兑换成原来的货币能够使货币量添加。 思路：本题事实上是Floyd的变形。将变换率作为构成图的路径的权值。只是
·2015-10-31 16:08

zoj 1092 Arbitrage （poj 2240）

Arbitrage Time Limit: 2 Seconds      Memory Limit: 65536 KB Arbitrage is
·2015-10-31 15:56

hdu1217Arbitrage

又是好久没写博客了。。 今年基本上是参加acm的最后一年了，一定要把写博客的习惯坚持下来！最近一直在看最短路和最小生成树的题目！以前只是看过代码，然后自己有了一个自己的模版！ 别人有时说关于这样的题目用prim，floyd什么样的算法，感觉自己不会，就会我自己的那种！ 近来没事，想起了这个问题，就决定了解透彻，就从《实用算法分析与程序设计》这本书上找到了答案，才发现原来我自己的算法算得上是p
·2015-10-31 15:19

POJ 2240 Arbitrage（求正环）

  Arbitrage Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 11008
·2015-10-31 12:50

Arbitrage（套利）

poj 2240 题目大意：给出不同的货币，然后是一种对另一种的兑换比率，若从一种货币，经过若干次兑换又换回本身，原来是1元，回来时比一元多，就输出Yes 否则输出No 解决：floyd算法 #include <iostream> #include <string> using namespace std; const int N=35; double
·2015-10-31 11:13

poj2240

Arbitrage Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 6441
·2015-10-31 10:09

HDOJ---1217 Arbitrage[弗洛伊德算法]

Arbitrage Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K
·2015-10-31 10:24

poj2240Arbitrage最长路

　　今天下午的痛。  很冲的和 Gxwar 说来题爽爽 ，然后就被这水题爽了一下午。 #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> #include <climits> #include <string&g
·2015-10-31 10:43

poj 2240 Arbitrage ( bellman+map 判断 环）

本题面壁：   1：数据的范围 （在第一次写代码马虎后，很不容易找出）   2：思路清晰后在写代码。。。、 #include<iostream> #include<cstdio> #include<string> #include<string.h> #include<map> #define N 3
·2015-10-31 10:51

hdu 1217 Arbitrage

Flody多源最短路 #include<cstdio> #include<cstring> #include<string> #include<cmath> #include<map> #include<algorithm> #include<iostream> using namespace s
·2015-10-31 09:25

最短路径__Arbitrage( poj 2240 )

DescriptionArbitrageistheuseofdiscrepanciesincurrencyexchangeratestotransformoneunitofacurrencyintomorethanoneunitofthesamecurrency.Forexample,supposethat1USDollarbuys0.5Britishpound,1Britishpoundbuys
y1196645376·2015-10-31 08:00

POJ 2240 Arbitrage (Floyd)

Arbitrage Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 
·2015-10-30 15:35

UVA 104 Arbitrage

UVA_104     这个题目实际上是在求一个汇率乘积大于等于1.01的最小环。由于数据量不大，我们可以直接用动规+floyd解决，设f[i][j][k]为由i到j经过k次转换所能达到的最大汇率乘积，每循环一次k我们就扫描一遍f[i][i][k]，如果有大于1.01的情况就直接打印结果即可。     在记录路径时用path[i][j][k]记录第k次转
·2015-10-30 13:48

POJ-2240 Arbitrage bellman

跟POJ-1860基本一样，bellman求是否存在环。这里吸取了别人的代码，让bellman算法的外循环直接增加一次，再判定是否在这个过程中有无更新推出的情况。 代码如下： #include <cstring> #include <cstdlib> #include <cstdio> #include <map> #include &
·2015-10-27 14:14

POJ 2240 Arbitrage 最短路径 Floyed-Warshall

ArbitrageTimeLimit: 1000MS MemoryLimit: 65536KTotalSubmissions: 18416 Accepted: 7800DescriptionArbitrageistheuseofdiscrepanciesincurrencyexchangeratestotransformoneunitofacurrencyintomorethanoneunitof
zp___waj·2015-10-24 12:00
上一页 1 2 3 4 5 下一页
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他