poj 3635 Full Tank 动态规划思想在spfa算法中的应用

题意:

有n个城市,和m条已知长度的路,在路上走1单位距离要花1单位油,每个城市都可以加油且有各自的油价,现在任给两个城市s,t,要求从s到t最少花多少油。

思路:

网上大多数都是拿优先队列做的,拿spfa做更有意思,但一般的spfa会超时。dis[i][j]表示到城市i时油箱里有j单位油时的最小花费。对于城市x,y,他们的距离为w,如果存在dis[x][j]<dis[y][i-w],则确定对y进行更新,注意如果对每个dis[x][j]<dis[y][j-w],dis[x][j+1]<dis[y][j-w+1]...都跟新dis[y][m],dis[y][m+1]...dis[y][c]的话会超时,需要用动态规划的思想在确定对y进行更新后只总的更新一次,具体的见代码注释部分。

代码:

#include <iostream>
#include <queue>
using namespace std;
const int maxN=1024;
const int maxM=10024;
const int maxC=128;
struct Edge
{
	int v,w,next;
}edge[maxM*2];
int price[maxN];
int head[maxN];
int inq[maxN];
int dis[maxN][maxC];
int n,m,e;

void spfa(int c,int s,int t){
	int i,j;
	queue<int> Q;
	memset(inq,0,sizeof(inq));
	for(i=0;i<n;++i)
		for(j=0;j<=c;++j)
			dis[i][j]=INT_MAX;
	for(j=0;j<=c;++j)
		dis[s][j]=price[s]*j;
	inq[s]=1;
	Q.push(s);
	while(!Q.empty()){
		int u=Q.front();
		Q.pop();
		inq[u]=0;
		for(int i=head[u];i!=-1;i=edge[i].next){
			int v=edge[i].v,w=edge[i].w;
			int flag=0;
			for(int j=w;j<=c;++j)
				if(dis[u][j]<dis[v][j-w]){
					dis[v][j-w]=dis[u][j];
					flag=1;
				}
			if(flag==1){
				for(int j=1;j<=c;++j)//用动态规划的思想只更新一次
					dis[v][j]=min(dis[v][j],dis[v][j-1]+price[v]);
				if(inq[v]==0){
					inq[v]=1;
					Q.push(v);
				}
			}
		}
	/*超时代码:
			for(int i=head[u];i!=-1;i=edge[i].next){
			int v=edge[i].v,w=edge[i].w;
			int flag=0;
			for(int j=w;j<=c;++j)
				if(dis[u][j]<dis[v][j-w]){
					dis[v][j-w]=dis[u][j];
					for(int k=j-w;k<=c;++k)//每次都尝试到更新到加满
						dis[v][k]=min(dis[v][k],dis[v][j-w]+(k-(j-w))*price[v]);
					flag=1;
				}
			if(flag==1&&inq[v]==0){
				inq[v]=1;
				Q.push(v);
			}
		}
	*/ 

	}
	int ans=INT_MAX;
	for(i=0;i<=c;++i)
		ans=min(ans,dis[t][i]);
	if(ans==INT_MAX)
		printf("impossible\n");
	else
		printf("%d\n",ans);
	return ;
} 

int main()
{
	e=0;
	memset(head,-1,sizeof(head));
	scanf("%d%d",&n,&m);
	int i;
	for(i=0;i<n;++i)
		scanf("%d",&price[i]);
	while(m--){
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		edge[e].v=v;edge[e].w=w;edge[e].next=head[u];
		head[u]=e++;
		edge[e].v=u;edge[e].w=w;edge[e].next=head[v];
		head[v]=e++;
	}
	int q,c,s,t;
	scanf("%d",&q);
	while(q--){
		scanf("%d%d%d",&c,&s,&t);
		spfa(c,s,t);
	}
	return 0;
}
时间: 2024-12-08 14:28:51

poj 3635 Full Tank 动态规划思想在spfa算法中的应用的相关文章

poj 3635 Full Tank? ( 图上dp )

题意: 已知每个点的加油站的油价单价(即点权),每条路的长度(边权). 有q个询问,每个询问包括起点s.终点e和油箱容量. 问从起点走到终点的最小花费.如果不可达输出impossible,否则输出最小的旅途费用. 算法: 其实要分析状态= =感觉就像是dp. 最直接的想法是  每到一个点都加上要走到下一个点所需要的油量.但是走的路不同,到底怎么处理加多少的问题呢? 因此想到分解状态,即拆点.每到一个点都+1单位的油量,然后把这个状态加入队列.另外如果现在油箱内的油足够达到下一点, 则更新状态,把

POJ 1847 Tram 【最短路,spfa算法,题意理解是关键呀!!】

Tram Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 13468   Accepted: 4954 Description Tram network in Zagreb consists of a number of intersections and rails connecting some of them. In every intersection there is a switch pointing to t

POJ 3635 Full Tank?

题意:告诉你n个城市的油价和m条道路的距离.Q次询问,告诉你出发点,目的地以及油箱的最大容量,要求问答最少花费是多少. 思路:参考了网上的思路http://blog.csdn.net/sdj222555/article/details/7693093   SPFA+优先队列         用类似于dp的思想,dp[i][j]表示到达第i个城市剩余j升油的最小花费.维护一个优点队列,一开始我的思路是对于当前节点相连的每一条边从边的长度开始+1直到加到油箱容量的限制,然后把所有的点入队 然后这样做

poj 3662 Telephone Lines spfa算法的灵活运用

题意: 给一个有n个结点的无向图,要求一条从1到n的路径,你可以让其中的k条免费,这条路径的花费是这条路径上剩下的边中长度的最大值,现在要求花费的最小值. 思路: 这道题可以首先想到二分枚举路径上的最大值,我觉得用spfa更简洁一些.spfa的本质是一种搜索算法,既然是搜索,就涉及到状态的转移.在一般求最短路的spfa算法中,当到结点u时,对e(u,v)只需做如下转移:if(d[v]>d[u]+w(e)) d[v]=d[u]+w(e).在跟一般的情况下,到结点u,对e(u,v)需做多种转移,比如

hihocoder1093最短路(SPFA算法)

算法描述: 首先将起始节点入队,然后每次从队列中取出一个节点,更新其邻接点的最短路径值,若有被更新,则检查该邻接点是否在队列中,若不在队列中,则入队.如此循环直到队空时算法结束. 当图中不存在负环时,算法一定会收敛,并能得到所求最短路.原因在于,每次从队列中取出一个节点并更新其邻接点的过程其实都是在向最优解逼近的过程,且只有当有更新的时候才可能向队列增加节点.由于不断的再向最优解逼近,所以到最后一定会达到最优解且不再有节点入队,队列最终为空,算法收敛.SPFA算法与dijkstra相比有一个好处

POJ 3259 Wormholes SPFA算法题解

本题其实也可以使用SPFA算法来求解的,不过就一个关键点,就是当某个顶点入列的次数超过所有顶点的总数的时候,就可以判断是有负环出现了. SPFA原来也是可以处理负环的. 不过SPFA这种处理负环的方法自然比一般的Bellman Ford算法要慢点了. #include <stdio.h> #include <string.h> #include <limits.h> const int MAX_N = 501; const int MAX_M = 2501; const

POJ 2449Remmarguts&#39; Date K短路模板 A*+SPFA

太水了我不想说了,模板在这里 14312K 313MS 1 #include<queue> 2 #include<cstdio> 3 #include<cstring> 4 #include<algorithm> 5 using namespace std; 6 int v[100010],v2[100010],c[100010],c2[100010],s,t,k,duin; 7 int n,m,point[1010],next[100010],cnt=0,

Maximum Product Subarray动态规划思想

该题即是昨天没有做出来的题目,想了很久,想出了一个普通的做法,提交发现超时了.思想是新建一个数组,保存每个元素与后面的元素相乘后得到的最大值,然后再在该数组中选出最大的值,返回.[笨死 发现行不通后决定还是求教度娘了. 果然大神无处不在,该题可运用动态规划思想解决.考虑到正负数相乘后会出现的各种结果,采取保存局部最小和局部最大值的方式.列出公式: int a=localmin*A[i] int b=localmax*A[i] localmin = min(A[i],min(a,b)) local

POJ 3071 Football (动态规划-概率DP)

Football Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 2768   Accepted: 1412 Description Consider a single-elimination football tournament involving 2n teams, denoted 1, 2, -, 2n. In each round of the tournament, all teams still in the