poj 1860 2378 3259带负边最短路 ** bellman ford 模板

最新推荐文章于 2020-08-02 23:36:18 发布
最新推荐文章于 2020-08-02 23:36:18 发布
阅读量584 收藏
点赞数
分类专栏： 图论--最短路专题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cfzjxz/article/details/8722499
版权

题意很明确了

采用FIFO的基本队列进行bellman ford计算

#include <iostream>
#include <vector>
#include <map>
#include <list>
#include <set>
#include <deque>
#include <stack>
#include <queue>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <cstdio>
#include <iomanip>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <sstream>
#include <cstring>
#include <queue>
using namespace std;

///宏定义
const int  INF = 10000000;
const int MAXN = 1257;
const int maxn = MAXN;
///全局变量 和 函数
///
struct Edge
{
    int from, to;
    double R, C;
};
vector<Edge> edges;   //边列表
vector<int> G[maxn];  //每个结点出发的边编号
//bool done[maxn];      //是否已永久编号
double d[maxn];          //s到各个点的距离
int N, M, S;
double V;
bool bellman_ford()
{
    queue<int> q;
    bool inq[maxn];
    int cnt[maxn];
    memset(cnt, 0, sizeof(cnt));
    memset(inq, false, sizeof(inq));
    memset(d, 0, sizeof(d));
    d[S] = V;
    q.push(S);
    while(!q.empty())
    {
        int cur = q.front();
        q.pop();
        inq[cur] = false;
        bool flag = false;
        for(int i = 0; i < G[cur].size(); i++)
        {
            Edge &e = edges[ G[cur][i] ];
            if (d[e.to] < (d[cur] - e.C) * e.R)
            {
                flag = true;
                d[e.to] = (d[cur] - e.C) * e.R;
                if(!inq[e.to])
                {
                    inq[e.to] = true;
                    q.push(e.to);
                    if(++cnt[e.to] > N)
                        return true;
                }
            }
        }

    }
    return false;
}
int main()
{

	///变量定义
	int i, j;
    while(cin >> N >> M >> S >> V)
    {
        for(i = 0; i <= N; i++)
        {
            G[i].clear();
        }
        edges.clear();
        for(i = 0; i < M; i++)
        {
            int from, to;
            double R, C, R1, C1;
            cin >> from >> to >> R >> C >> R1 >> C1;

            Edge tmp;
            tmp.from = from;
            tmp.to = to;
            tmp.R = R;
            tmp.C = C;
            edges.push_back(tmp);
            int m = edges.size();
            G[from].push_back(m - 1);

            tmp.from = to;
            tmp.to = from;
            tmp.R = R1;
            tmp.C = C1;
            edges.push_back(tmp);
            m = edges.size();
            G[to].push_back(m - 1);
        }
        if(bellman_ford())
            cout << "YES" << endl;
        else
            cout << "NO" << endl;
    }


	///结束
	return 0;
}

整理一下 bellman ford 模板如下 针对 poj 2387使用 

#include <iostream>
#include <vector>
#include <map>
#include <list>
#include <set>
#include <deque>
#include <stack>
#include <queue>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <cstdio>
#include <iomanip>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <sstream>
#include <cstring>
#include <queue>
using namespace std;

///宏定义
const int  INF = 10000000;
const int MAXN = 1257;
const int maxn = MAXN;
///全局变量 和 函数
///
struct Edge
{
	int from, to, dist;
};

struct BellmanFord
{
	int n, m;
	vector<Edge> edges;    //边的存储
	vector<int> G[maxn];   //点的邻接表
	bool inq[maxn];        //是否在队列中
	int d[maxn];           //源点到各点的距离
	int p[maxn];           //最短路中的上一条弧，打印用
	int cnt[maxn];         //进队次数

	void init(int n)
	{
		this->n = n;
		for(int i = 0; i <= n; i++)
			G[i].clear();
		edges.clear();
	}
	void AddEdge(int from, int to, int dist)
	{
		Edge edge;
		edge.from = from;
		edge.to = to;
		edge.dist = dist;
		edges.push_back(edge);
		m = edges.size();
		G[from].push_back(m - 1);
	}
	bool negativeCycle(int s)
	{
		queue<int> Q;
		memset(inq, 0, sizeof(inq));
		memset(cnt, 0, sizeof(cnt));
		for(int i = 0; i <= n; i++)
		{
			d[i] = INF;
		}
		d[s] = 0;
		inq[s] = true;
		Q.push(s);
		while(!Q.empty())
		{
			int u = Q.front();
			Q.pop();
			inq[u] = false;
			for(int i = 0; i <G[u].size(); i++)
			{
				Edge& e = edges[ G[u][i] ];
				if(d[e.to] > d[u] + e.dist)
				{
					d[e.to] = d[u] + e.dist;
					p[e.to] = G[u][i];
					if(!inq[e.to])
					{
						Q.push(e.to);
						inq[e.to] = true;
						if(++cnt[e.to] > n)
							return true;
					}
				}
			}
		}
		return false;
	}
};
int t, n;
//int N, M, S, V;
int main()
{
	///变量定义
	int i, j;
	while(scanf("%d %d", &t, &n) != EOF)
	{

		BellmanFord bellman_ford;
		bellman_ford.init(n);
		for(i = 0; i < t; i++)
		{
			int from, to, weight;
			scanf("%d %d %d", &from, &to, &weight);
			bellman_ford.AddEdge(from, to, weight);
			bellman_ford.AddEdge(to, from, weight);
		}
		bellman_ford.negativeCycle(n);

		int ans = bellman_ford.d[1];
		printf("%d\n", ans);

	}



	///结束
	return 0;
}

同样的方式，针对poj 1860 货币交换  进行应用

注意到 修改的地方是

Edge的定义  以及松弛的规则（因为现在是判断正环的存在性）

#include <iostream>
#include <vector>
#include <map>
#include <list>
#include <set>
#include <deque>
#include <stack>
#include <queue>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <cstdio>
#include <iomanip>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <sstream>
#include <cstring>
#include <queue>
using namespace std;

///宏定义
const int  INF = 10000000;
const int MAXN = 1257;
const int maxn = MAXN;
///全局变量 和 函数
///
int N, M, S;
double V;

struct Edge
{
//	int from, to, dist; 
	//根据题意修改结构体，上面的是原来的定义
	int from, to;
	double R, C;
};

struct BellmanFord
{
	int n, m;
	vector<Edge> edges;    //边的存储
	vector<int> G[maxn];   //点的邻接表
	bool inq[maxn];        //是否在队列中
//	int d[maxn];           //源点到各点的距离
	double d[maxn];        //根据题意采用double类型
	int p[maxn];           //最短路中的上一条弧，打印用
	int cnt[maxn];         //进队次数

	void init(int n)
	{
		this->n = n;
		for(int i = 0; i <= n; i++)
			G[i].clear();
		edges.clear();
	}
	/*
	void AddEdge(int from, int to, int dist)
	{
		Edge edge;
		edge.from = from;
		edge.to = to;
		edge.dist = dist;
		edges.push_back(edge);
		m = edges.size();
		G[from].push_back(m - 1);
	}*/
	//可对比原始的定义
	void AddEdge(int from, int to, double R, double C)
	{
		Edge edge;
		edge.from = from;
		edge.to = to;
		edge.R = R;
		edge.C = C;
		edges.push_back(edge);
		m = edges.size();
		G[from].push_back(m - 1);
	}
	bool negativeCycle(int s)
	{
		queue<int> Q;
		memset(inq, 0, sizeof(inq));
		memset(cnt, 0, sizeof(cnt));
		for(int i = 0; i <= n; i++)
		{
//			d[i] = INF;
			//根据题意修改为0
			d[i] = 0;
		}
		d[s] = V; //根据题意为初始钱数
		inq[s] = true;
		Q.push(s);
		while(!Q.empty())
		{
			int u = Q.front();
			Q.pop();
			inq[u] = false;
			for(int i = 0; i <G[u].size(); i++)
			{
				Edge& e = edges[ G[u][i] ];
				//根据题意修改松弛方法
				/*
				if(d[e.to] > d[u] + e.dist)
				{
					d[e.to] = d[u] + e.dist;
					p[e.to] = G[u][i];
					if(!inq[e.to])
					{
						Q.push(e.to);
						inq[e.to] = true;
						if(++cnt[e.to] > n)
							return true;
					}
				}*/
				if(d[e.to] < (d[u] - e.C) * e.R )
				{
					d[e.to] = (d[u] - e.C) * e.R;
	//				p[e.to] = G[u][i];
					if(!inq[e.to])
					{
						Q.push(e.to);
						inq[e.to] = true;
						if(++cnt[e.to] > n)
							return true; //存在正环
					}
				}
			}
		}
		return false;
	}
};

int main()
{

	///变量定义
	int i, j;
	while(cin >> N >> M >> S >> V)
	{
		BellmanFord bellman_ford;
		bellman_ford.init(N);
		for(i = 0; i < M; i++)
		{
			int from, to;
			double R, C, R1, C1;
			cin >> from >> to >> R >> C >> R1 >> C1;
			bellman_ford.AddEdge(from, to, R, C);
			bellman_ford.AddEdge(to, from, R1, C1);
		}
		if (bellman_ford.negativeCycle(S))
			cout << "YES" << endl;
		else
			cout << "NO" << endl;
	}



	///结束
	return 0;
}

用同样的方法解poj 3259 时光穿梭

#include <iostream>
#include <vector>
#include <map>
#include <list>
#include <set>
#include <deque>
#include <stack>
#include <queue>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <cstdio>
#include <iomanip>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <sstream>
#include <cstring>
#include <queue>
using namespace std;

///宏定义
const int  INF = 10000000;
const int MAXN = 1257;
const int maxn = MAXN;
///全局变量 和 函数
///


struct Edge
{
	int from, to, dist; 
};

struct BellmanFord
{
	int n, m;
	vector<Edge> edges;    //边的存储
	vector<int> G[maxn];   //点的邻接表
	bool inq[maxn];        //是否在队列中
	int d[maxn];           //源点到各点的距离
	int p[maxn];           //最短路中的上一条弧，打印用
	int cnt[maxn];         //进队次数

	void init(int n)
	{
		this->n = n;
		for(int i = 0; i <= n; i++)
			G[i].clear();
		edges.clear();
	}
	
	void AddEdge(int from, int to, int dist)
	{
		Edge edge;
		edge.from = from;
		edge.to = to;
		edge.dist = dist;
		edges.push_back(edge);
		m = edges.size();
		G[from].push_back(m - 1);
	}
	
	bool negativeCycle(int s)
	{
		queue<int> Q;
		memset(inq, 0, sizeof(inq));
		memset(cnt, 0, sizeof(cnt));
		for(int i = 0; i <= n; i++)
		{
			d[i] = INF;
			//根据题意修改为0
		}
		d[s] = 0; //根据题意为初始钱数
		inq[s] = true;
		Q.push(s);
		while(!Q.empty())
		{
			int u = Q.front();
			Q.pop();
			inq[u] = false;
			for(int i = 0; i <G[u].size(); i++)
			{
				Edge& e = edges[ G[u][i] ];
				//根据题意修改松弛方法
				
				if(d[e.to] > d[u] + e.dist)
				{
					d[e.to] = d[u] + e.dist;
//					p[e.to] = G[u][i];
					if(!inq[e.to])
					{
						Q.push(e.to);
						inq[e.to] = true;
						if(++cnt[e.to] > n)
							return true;
					}
				}

			}
		}
		return false;
	}
};
int T;
int N, M, W;
int main()
{
	///变量定义
	int i, j;
	cin >> T;
	while (T--)
	{
		cin >> N >> M >> W;
		BellmanFord bellman_ford;
		bellman_ford.init(N);
		for (i = 0; i < M; i++)
		{
			int S, E, T;
			cin >> S >> E >> T;
			bellman_ford.AddEdge(S, E, T);
			bellman_ford.AddEdge(E, S, T);
		}
		for (i = 0; i < W; i++)
		{
			int S, E, T;
			cin >> S >> E >> T;
			bellman_ford.AddEdge(S, E, -T);
		}
		if (bellman_ford.negativeCycle(1))
		{
			cout << "YES" << endl;
		}
		else
			cout << "NO" << endl;
		
	}



	///结束
	return 0;
}


cfzjxz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kuangbin acm模板超级好用
09-05
2.6 随机素数测试和大数分解 (POJ 1811) . . . . . . . . . . . . . . . . . . . . . . . 29 2.7 欧拉函数 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 2.7.1 分解质因素求...
NOIP NOI 信息学竞赛 ACM-ICPC POJ（北京大学在线评测系统）刷题推荐 OI复习计划 算法大纲
10-04
包括Dijkstra、Bellman-Ford、Floyd等算法，如1062、1125、1797、2253、2679等，其中Bellman-Ford适用于存在负权边的情况。 5. **最小生成树**（Minimum Spanning Tree, MST） Prim和Kruskal是最小生成树的经典...
【POJ 3259】Wormholes（最短路SPFA/Bellman_Ford）
Ice_Confuse
07-21 1123
DescriptionWhile exploring his many farms, Farmer John has discovered a number of amazing wormholes. A wormhole is very peculiar because it is a one-way path that delivers you to its destination at a t
POJ-3259 Wormholes（负权回路[Bellman-Ford]）
idealism_xxm的专栏
05-07 822
只以1号点为源点做Bellman-Ford即可判断图中是否存在负权回路（该负权回路不一定以1号点为起点） 例如： 1 3 0 2 2 3 1 3 2 1 这组数据会输出YES 调试时能发现，dis[2],dis[3]每次都在更新，但是是在INF的基础上更新，所以要判断1号点是否可打2，3时，要判断dis[2],dis[3]是否 大于 图中的最大权值和才行
带负权的最短路bellman_ford——POJ 3259 Wormholes题解
plsxysam的专栏
04-23 415
Description While exploring his many farms, Farmer John has discovered a number of amazing wormholes. A wormhole is very peculiar because it is a one-way path that delivers you to its destination a
poj 1860 最短路—Bellman-Ford算法
HARD_UNDERSTAND
07-06 414
有多种汇币，汇币之间可以交换，这需要手续费，当你用100A币 交换B币时，A到B的汇率是29.75，手续费是0.39，那么你可以得到 (100 - 0.39) * 29.75 = 2963.3975 B币。问s币的金额经过交换最终 得到的s币金额数能否增加 货币的交换是可以重复多次的，所以我们需要找出是否存在 正权回路，且最后得到的s金额是增加的 怎么找正权回路呢？（正权回路：在这一回路
POJ 3259 Wormholes Bellman-Ford算法模板题 SPAF模板题
RPG_Zero的博客
08-23 376
题目链接 Wormholes Time Limit: 2000MS Memory Limit: 65536K Description While exploring his many farms, Farmer John has discovered a number of amazing wormholes. A wormhole is very peculiar b...
POJ-2387 Til the Cows Come Home（Bellman-Ford最短路）
一只在校程序猿的技术贴
04-11 152
Problem Description: Bessie is out in the field and wants to get back to the barn to get as much sleep as possible before Farmer John wakes her for the morning milking. Bessie needs her beauty sleep,...
Currency Exchange POJ - 1860 Bellman-Ford最短路
turtle的博客
11-12 243
用Bellman-Ford最短路径算法，判断是否存在正环，如果存在，说明可以无限增加金钱（你不停绕着正环走就能无限增加）。如果不存在，就输出NO； Bellman-Ford是求最短路并判断是否有负环，也能求是否有正环。因为有n个点的图，最优路径最多n-1个路径，所以从起点出发松弛n-1次就行。如果第n 次还有路径变长，就说明存在正环。我们直接松弛n次就好（就是把每条路径判断n次，看是否能优化）
POJ 3259 Wormholes(最短路——Bellman-ford)
沐雨风栉
08-02 221
A - Wormholes While exploring his many farms, Farmer John has discovered a number of amazing wormholes. A wormhole is very peculiar because it is a one-way path that delivers you to its destination at a time that is BEFORE you entered the wormhole! Each of
POJ1860 Currency Exchange 最短路Bellman Ford变形
A confused programmer
05-14 198
这道题一看应该就是判环，然后就不会了QAQ...看了网上说的，只要判断是否有正环，那么循环无数次之后一定可以赚回本钱。说实话bellman_ford算法我用的不多。。这次也是懵逼了。。参考博客是kuangbin的Orz：https://www.cnblogs.com/kuangbin/archive/2012/08/17/2644807.html 正环是刚好和板子反的，注意点都在代码里了，AC代...
常用算法 (2).pdf
03-28
- **Bellman-Ford**：能处理负权重的边，但效率较低。 2. **最小生成树**： - **Prim**：用于加权无向图，基于贪心策略。 - **Kruskal**：同样用于加权无向图，使用并查集避免环路。 3. **大数运算**：实现高...
acm 题目汇总（好东西）
12-22
对于有负权重的边，A*搜索或Bellman-Ford算法可能是更好的选择。POJ 3463 "Sightseeing" 和 POJ 3635 "full tank?" 是较复杂的最短路问题，可能需要更深入理解Dijkstra算法或者结合其他策略，如参数搜索。 生成树...
参加ACM大赛应该准备哪些课程？ (2).pdf
07-03
1. 最短路（Floyd、Dijkstra、Bellman-Ford） 2. 最小生成树（Prim、Kruskal） 3. 大数（高精度）加减乘除 4. 二分查找 5. 叉乘、判线段相交、凸包 6. BFS、DFS、hash表 7. 数学上的辗转相除、线段交点、多角形面积...
基于Springboot和Vue的数码论坛系统设计与实现-源码 数码论坛系统设计与实现代码（高分毕设）
最新发布
07-24
数码论坛系统设计与实现-源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
java程序设计—JAVA局域网飞鸽传书软件设计与实现(源代码+论文)43.rar
07-24
java程序设计，可供正在学习的同学研究参考。
年终总结汇报PPT模板(20)三套材料.pptx
07-24
年终总结汇报PPT模板(20)三套材料.pptx
ListView侧边A-Z快速定位导航.zip
07-24
ListView侧边A-Z快速定位导航
使用Bellman-Ford解决差分约束系统与最短路径
我们可以构建一个加权图，正边代表正常时间消耗，负边代表虫洞的时间倒流效果。然后对每个顶点作为源点运行Bellman-Ford算法，检查是否存在负权回路，即是否存在回到起点的负时间消耗路径。 总结来说，差分约束系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值