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 < n; ++k) {
 9         for (i = 0; i < m; ++i) {
10             if (dist[edges[i].u] != INF && edges[i].w + dist[edges[i].u] < dist[edges[i].v]) {
11                 dist[edges[i].v] = edges[i].w + dist[edges[i].u];
12                 path[edges[i].v] = edges[i].u;
13             }
14         }
15     }
16 }
17
18 //判断是否存在从原点可达的负权值回路
19 for (i = 0; i < m; ++i) {
20     if (dist[edges[i].u] != INF && edges[i].w + dist[edges[i].u] < dist[edges[i].v])
21         return 0;
22 }
23 return 1;

Bellman

该算法还可以求最长路径

Bellman-Ford 判断环 + 最大路径值是否大于1

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstdlib>
 4 #include<cstring>
 5 #include<string>
 6 #include<queue>
 7 #include<algorithm>
 8 #include<map>
 9 #include<iomanip>
10 #include<climits>
11 #include<string.h>
12 #include<cmath>
13 #include<stdlib.h>
14 #include<vector>
15 #include<set>
16 #define INF 1e7
17 #define MAXN 100010
18 #define maxn 50
19 #define maxm 1000
20 #define Mod 1000007
21 using namespace std;
22 typedef long long LL;
23
24 struct exchange{
25     int ci, cj;
26     double cij;
27 }ex[maxm];
28 int i, j, k;
29 int n, m;
30 string name[maxn], a, b;
31 double x, maxdist[maxn];
32 bool flag;
33 int kase = 0;
34
35 int readkase()
36 {
37     cin >> n;
38     if (n == 0) return 0;
39     for (i = 0; i < n; ++i)
40         cin >> name[i];
41     cin >> m;
42     for (i = 0; i < m; ++i) {
43         cin >> a >> x >> b;
44         for (j = 0; a != name[j]; ++j);
45         for (k = 0; b != name[k]; ++k);
46         ex[i].ci = j, ex[i].cj = k, ex[i].cij = x;
47     }
48     return 1;
49 }
50
51 void Bellman(int v0)
52 {
53     flag = false;
54     memset(maxdist,0,sizeof(maxdist));
55     maxdist[v0] = 1;
56     for (k = 1; k <= n; ++k) {   //从maxdist(0)递推到maxdist(n)
57         for (i = 0; i < m; ++i) {//判断加入每条边是否能是最大距离增大
58             if (maxdist[ex[i].ci] * ex[i].cij > maxdist[ex[i].cj])
59                 maxdist[ex[i].cj] = maxdist[ex[i].ci] * ex[i].cij;
60         }
61     }
62     if (maxdist[v0] > 1.0) flag = true;
63 }
64
65 int main()
66 {
67     while (readkase()) {
68         for (int i = 0; i < n; ++i) {
69             Bellman(i);
70             if (flag) break;
71         }
72         if (flag) printf("Case %d: Yes\n",++kase);
73         else printf("Case %d: No\n", ++kase);
74     }
75     return 0;
76 }
时间: 2024-11-08 08:18:37

nyoj Arbitrage (Bellman-Ford)的相关文章

ACM/ICPC 之 最短路径-Bellman Ford范例(POJ1556-POJ2240)

两道Bellman Ford解最短路的范例,Bellman Ford只是一种最短路的方法,两道都可以用dijkstra, SPFA做. Bellman Ford解法是将每条边遍历一次,遍历一次所有边可以求得一点到任意一点经过一条边的最短路,遍历两次可以求得一点到任意一点经过两条边的最短路...如 此反复,当遍历m次所有边后,则可以求得一点到任意一点经过m条边后的最短路(有点类似离散数学中邻接矩阵的连通性判定) POJ1556-The Doors 初学就先看POJ2240吧 题意:求从(0,5)到

POJ 1860 Currency Exchange (Bellman ford)

Currency Exchange Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 22405   Accepted: 8095 Description Several currency exchange points are working in our city. Let us suppose that each point specializes in two particular currencies and pe

Bellman - Ford 算法解决最短路径问题

Bellman - Ford 算法: 一:基本算法 对于单源最短路径问题,上一篇文章中介绍了 Dijkstra 算法,但是由于 Dijkstra 算法局限于解决非负权的最短路径问题,对于带负权的图就力不从心了,而Bellman - Ford算法可以解决这种问题. Bellman - Ford 算法可以处理路径权值为负数时的单源最短路径问题.设想可以从图中找到一个环路且这个环路中所有路径的权值之和为负.那么通过这个环路,环路中任意两点的最短路径就可以无穷小下去.如果不处理这个负环路,程序就会永远运

POJ-2240 -Arbitrage(Bellman)

题目链接:Arbitrage 让这题坑了,精度损失的厉害,用赋值的话,直接全部变成0.00了,无奈下,我只好往里输了,和POJ1860一样找正环,代码也差不多,稍微改改就可以了,但是这个题精度损失的比那个....水过 POJ计划的最短路模块,刷完了,最短路问题,挺坑的,但是就是那点东西,变来变去,就是改改dis[]的更新条件. 明天就要开始POJ的最小生成树了, ME                  TI 704Kb            46Ms #include <iostream> #

Bellman—Ford算法思想

---恢复内容开始--- Bellman—Ford算法能在更普遍的情况下(存在负权边)解决单源点最短路径问题.对于给定的带权(有向或无向)图G=(V,E),其源点为s,加权函数w是边集E的映射.对图G运行Bellman—Ford算法的结果是一个布尔值,表明图中是否存在着一个从源点s可达的负权回路.若存在负权回路,单源点最短路径问题无解:若不存在这样的回路,算法将给出从源点s到图G的任意顶点v的最短路径值d[v] Bellman—Ford算法流程 分为三个阶段: (1)初始化:将除源点外的所有顶点

Nyoj Arbitrage(Floyd or spfa or Bellman-Ford)

描述Arbitrage is the use of discrepancies in currency exchange rates to transform one unit of a currency into more than one unit of the same currency. For example, suppose that 1 US Dollar buys 0.5 British pound, 1 British pound buys 10.0 French francs

ACM/ICPC 之 Bellman Ford练习题(ZOJ1791(POJ1613))

这道题稍复杂一些,需要掌握字符串输入的处理+限制了可以行走的时间. ZOJ1791(POJ1613)-Cave Raider //限制行走时间的最短路 //POJ1613-ZOJ1791 //Time:16Ms Memory:324K #include<iostream> #include<cstring> #include<cstdio> #include<algorithm> using namespace std; #define MAX 505 #d

poj 3259 Wormholes (BELLman—FOrd算法)(邻接矩阵表示)

http://poj.org/problem?id=3259 之前一开始 ,没做出来,搁置了好几天才看见bug所在.所以今天a掉了 ,把代码贴出来,这个使用邻接矩阵表示的 ,下一篇用邻接表可以提高效率. #include<iostream> #include<queue> #include<stdio.h> #include<string.h> using namespace std; const int INF=600; int G[INF][INF];

Bellman ford 最短路径算法

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" /> 下表记录S到每一个节点的距离: 第一次迭代, S->A = 4 ,由于S->A眼下为INF.因此更新MIN(S->A)为4 S->B = 6.由于S->B眼下为INF.因此更新MIN(S->B)为6 S->C