[SDOI2010]魔法猪学院

K短路，A*

新鲜出炉的A*
A是什么，其实就是bfs，只不过加了一个估价函数h（x），并把队列换成了优先队列。令h(x)==已经花费的代价，f（x）=g(x)+h(x),，那么f(x)就是优先队列的比较标准。这样我们就会尽可能向最优解的方向搜索，我们如果想要求最优解，就跑A，每次扩展状态，压入队列中，如果感觉要T了，直接结束程序，那么解极为可能就是最优解。

K短路有一个性质：估价函数是100%正确的，我们就利用优先队列扩展状态，如果我们到达了终点，就cnt++一次，直到cnt==k为止。这样我们就不会重复搜索。
但是，这种算法空间复杂度极高，IDA*正在学。

code：（92分）

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<cstring>
#include<vector>
#include<stack>
#define db double
using namespace std;
const int maxn=400006;
int head[maxn],cur,fhead[maxn];
struct hzw
{
	int to,next;
	db v;
}e[maxn],ed[maxn];
inline void add(int a,int b,db c,hzw e[],int head[])
{
	e[cur].to=b;
	e[cur].next=head[a];
	e[cur].v=c;
	head[a]=cur++;
}
typedef pair <double,int>p;
int n,m;
double dis[maxn];
double k;
inline void dij(int firs)
{
	for (int i=1;i<=n;++i) dis[i]=1e17;
	priority_queue<p,vector<p>,greater<p> >q;
	q.push(p(0,firs));
	dis[firs]=0;
	while (!q.empty())
	{
		p fr=q.top();
		q.pop();
		int s=fr.second;
		if (dis[s]<fr.first) continue;
		for (int i=fhead[s];i!=-1;i=ed[i].next)
		{
			int v=ed[i].to;
			double w=ed[i].v;
			if (dis[v]>dis[s]+w)
			{
				dis[v]=dis[s]+w;
				q.push(p(dis[v],v));
			}
		}
	}
}
struct gk
{
	db l,rnd;
	int id;
	bool operator <(const gk &rhs) const
	{
		return l+rnd>rhs.l+rhs.rnd;
	}
};
inline int A_star(double lmt)
{
	priority_queue<gk>q;
	int cnt=0;
	q.push((gk){0,dis[1],1});
	while (!q.empty())
	{
		gk all=q.top();
		q.pop();
		int s=all.id;
		db leth=all.l,fina=all.rnd;
		if (s==n)
		{
			lmt-=leth;
			if (lmt<=0) return cnt;
			cnt++;
			continue;
		}
		for (int i=head[s];i!=-1;i=e[i].next)
		{
			int v=e[i].to;
			double w=e[i].v;
			q.push((gk){leth+w,dis[v],v}); 
		} 
	}
	return cnt;
}
signed main()
{
	memset(head,-1,sizeof(head));
	memset(fhead,-1,sizeof(fhead));
	cin>>n>>m>>k;
	for (int i=1,a,b;i<=m;++i)
	{
		db c;
		scanf("%d%d%lf",&a,&b,&c);
		add(a,b,c,e,head);
		add(b,a,c,ed,fhead);
	}
	dij(n);
	cout<<A_star(k);
	return 0;
}

总结：

A*算法适合解决寻找路径问题，她能尽可能的像最优解逼近。