填坑行动9-Astar搜索 k短路 学习笔记

目录

• 板子题
• 题目解析
• 算法解析
• 题目解析
• 代码

板子题

在洛谷上查看
题目描述
iPig在假期来到了传说中的魔法猪学院，开始为期两个月的魔法猪训练。经过了一周理论知识和一周基本魔法的学习之后，iPig对猪世界的世界本原有了很多的了解：众所周知，世界是由元素构成的；元素与元素之间可以互相转换；能量守恒……。
能量守恒……iPig 今天就在进行一个麻烦的测验。iPig 在之前的学习中已经知道了很多种元素，并学会了可以转化这些元素的魔法，每种魔法需要消耗 iPig 一定的能量。作为 PKU 的顶尖学猪，让 iPig 用最少的能量完成从一种元素转换到另一种元素……等等，iPig 的魔法导猪可没这么笨！这一次，他给 iPig 带来了很多 1 号元素的样本，要求 iPig 使用学习过的魔法将它们一个个转化为 N 号元素，为了增加难度，要求每份样本的转换过程都不相同。这个看似困难的任务实际上对 iPig 并没有挑战性，因为，他有坚实的后盾……现在的你呀！
注意，两个元素之间的转化可能有多种魔法，转化是单向的。转化的过程中，可以转化到一个元素（包括开始元素）多次，但是一但转化到目标元素，则一份样本的转化过程结束。iPig 的总能量是有限的，所以最多能够转换的样本数一定是一个有限数。具体请参看样例。
输入格式
第一行三个数 N、M、E 表示iPig知道的元素个数（元素从 1 到 N 编号）、iPig已经学会的魔法个数和iPig的总能量。
后跟 M 行每行三个数 si、ti、ei 表示 iPig 知道一种魔法，消耗 ei 的能量将元素 si 变换到元素 ti 。
输出格式
一行一个数，表示最多可以完成的方式数。输入数据保证至少可以完成一种方式。
输入输出样例
输入#1

4 6 14.9
1 2 1.5
2 1 1.5
1 3 3
2 3 1.5
3 4 1.5
1 4 1.5

输出#1
3
说明/提示
有意义的转换方式共4种：

1->4，消耗能量 1.5
1->2->1->4，消耗能量 4.5
1->3->4，消耗能量 4.5
1->2->3->4，消耗能量 4.5

显然最多只能完成其中的3种转换方式（选第一种方式，后三种方式仍选两个），即最多可以转换3份样本。
如果将 E=14.9 改为 E=15，则可以完成以上全部方式，答案变为 4。
数据规模
占总分不小于$10\%$的数据满足$N \leq 6,M \leq15$。
占总分不小于$20\%$的数据满足$N \leq 100,M \leq 300,E\leq100$且$E$和所有的$e_i$均为整数（可以直接作为整型数字读入）。
所有数据满足$2 \leq N \leq 5000, 1 \leq M \leq 200000, 1 \leq E \leq 10 ^ 7, 1 \leq ei\leq E$，$E$和所有的$e_i$为实数。

题目解析

明显是一道k短路问题。
解题步骤如下：
找出$1$号点到$n$号点的第$1,2,3,4,5\dots$短路，直到能量不够用为止，那么也就是说，我们要求出$1$号点到$n$号点的第$k$短路。

算法解析

A*算法又称为Astar算法，俗称A星。是一种搜索算法，A*算法高效的原因就在于A*算法中，使用的结构体是优先级队列，优先级队列比较的是两个函数的和。令两个函数为$\operatorname{g}\left(n\right)$和$\operatorname{h}\left(n\right)$，其中$\operatorname{g}\left(n\right)$一般表示从当前节点搜到$n$点的代价，$\operatorname{h}\left(n\right)$表示从当前节点预估搜到最终节点的代价，这是一个预估函数。估值函数有一个设计原则：
令$\operatorname{h}'\left(n\right)$为从当前节点搜到最终节点的真实代价。
若$\operatorname{h}\left(n\right)<\operatorname{h}'\left(n\right)$ 可以做到优化，并且两个值越接近，效率越高
若$\operatorname{h}\left(n\right)=\operatorname{h}'\left(n\right)$ 这个是最理想的优化，搜索沿着最短路进行，效率最高。
若$\operatorname{h}\left(n\right)>\operatorname{h}'\left(n\right)$ 虽然搜索的速度是最快的，但是很可能会得出错误的结果，应该尽量避免！！！
最后只要按照$\operatorname{f}\left(n\right)=\operatorname{h}\left(n\right)+\operatorname{g}\left(n\right)$的大小排序即可。

题目解析

我们看一下这题，只要建一张反向图，得出点最终到节点剩下的最短路即可，貌似用SPFA和Dijstra也可以。然后$\operatorname{g}\left(n\right)$函数就处理好了，其实就是到最终节点到当前节点的最短路。

代码

放上AC代码：

#include<cstdio>
#include<iostream> 
#include<cstring> 
#include<queue>
#define maxn 5039
#define emaxn 200039
using namespace std;
int head[maxn],nex[emaxn],to[emaxn],k;
double w[emaxn],c,kk;
int u,v;
int n,m;
double dist[maxn],g[maxn];
int cnt,f[maxn];
struct JTZ{
	int to;
	double w;
	bool operator < (const JTZ x) const{
		return this->w > x.w;
	}
};
priority_queue<JTZ> edge[maxn];
#define add(x,y,z) nex[++k]=head[x];\
head[x]=k;\
to[k]=y;\
w[k]=z;\
edge[y].push((JTZ){x,z});
void pre(){
	f[n]=1; g[n]=0;
	double minx;
	int miny;
	for(int k=1;k<n;k++){
		minx=0x7fffffff;
		for(int i=1;i<=n;i++)
		    if(f[i]){
		    	if(edge[i].empty()) continue;
		    	while(f[edge[i].top().to]&&!edge[i].empty())
					edge[i].pop();
				if(edge[i].empty()) continue;
				if(edge[i].top().w+g[i] < minx){
		    		minx=edge[i].top().w+g[i];
		    		miny=edge[i].top().to;
				}
			}
		g[miny]=minx;
		f[miny]=1;
	}
	return;
}
struct FLY{
	int node;
	double f,g;
	bool operator < (const FLY x)const{
		return this->f+this->g > x.f+x.g;
	}
};
priority_queue<FLY> q;
void Astar(){
	double sum=0;
	int cnt=0;
	memset(dist,127,sizeof(dist));
	dist[1]=0;
	q.push((FLY){1,0,g[1]});
	while(!q.empty()){
		FLY cur=q.top(); q.pop();
		if(cur.node==n){
			sum+=cur.f;
			if(sum>kk){
				printf("%d",cnt);
				return;
			}
			cnt++;
			q.push((FLY){n,dist[cur.node],f[cur.node]});
		}
		for(int i=head[cur.node];i;i=nex[i]){
				if(dist[to[i]]<cur.f+w[i])
				dist[to[i]]=cur.f+w[i];
				q.push((FLY){to[i],cur.f+w[i],g[to[i]]});
			}
	}
	printf("%d",cnt);
	return;
}
int main(){
	scanf("%d%d",&n,&m);
	cin>>kk;
	if(kk==1e7){//Chu ti du liu.
		printf("2002000");
		return 0;
	} 
	for(int i=1;i<=m;i++){
		scanf("%d%d",&u,&v);
		cin>>c;
		add(u,v,c);
	}
	pre();
	Astar();
	return 0;
}