逃离 最短路

题目大意：给定一个无向正权图，有k个“安全点”，你初始在1号点，每次在你走之前对方可以同时最多封锁d条道路。（封锁仅限于当前这一轮）。

现在问在两人都绝顶聪明的情况下，你从1号点能否走到任意一个安全点，以及最少要走多少路。

题解：第一次在比赛里面写spfa，莫名其妙的spfa就挂了。。。。

好像这个题不能用spfa(下文有解释)

首先注意到从k个安全点出发可以到达某一个安全点并且最短路是0（就是它本身）。

然后发现和至少d+1个安全点直接相连的点也可以认作安全点，并且这个新的安全点到达与它相连的若干安全点的最短路应该不会比这些边权的第d+1小边更大。

在此基础上就可以dijkstra了。取d+1可以用一个堆维护。

和原来的dijkstra算法相比，每次用堆中的第d+1小元素来松弛其他边即可。

为什么不能用spfa维护呢？因为spfa维护的堆中可能有两个答案来自同一条边跟新出来的答案。

代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<queue>
#include<climits>
#define INF INT_MAX
#define MAXN 100010
using namespace std;
struct node{
	int id,dist;
	node(int _i,int _d)
	{
		id=_i;
		dist=_d;
	}
	bool operator<(const node &n)const
	{
		return this->dist>n.dist;
	}
};
vector<node> g[MAXN];
priority_queue<node> q;
priority_queue<int> h[MAXN];
int sz[MAXN],dist[MAXN];
int main()
{
	int n,m,k,d;scanf("%d%d%d%d",&n,&m,&k,&d);
	for(int i=1;i<=m;i++)
	{
		int u,v,w;scanf("%d%d%d",&u,&v,&w);
		g[u].push_back(node(v,w));
		g[v].push_back(node(u,w));
	}
	for(int i=1;i<=n;i++) dist[i]=INF;
	for(int i=1;i<=k;i++)
	{
		int x;scanf("%d",&x);
		q.push(node(x,dist[x]=0));
		h[x].push(0);sz[x]=d+1;
	}
	while(!q.empty())
	{
		int x=q.top().id,dis=q.top().dist;q.pop();
		if(dis!=h[x].top()) continue;
		dist[x]=h[x].top();
		for(int i=g[x].size()-1;i>=0;i--)
		{
			int v=g[x][i].id,w=g[x][i].dist;
			if(sz[v]<d+1||h[v].top()>dist[x]+w)
			{
				h[v].push(dist[x]+w);
				if(sz[v]==d+1) h[v].pop();
				else sz[v]++;
				if(sz[v]==d+1) q.push(node(v,h[v].top()));
			}
		}
	}
	if(dist[1]<INF) printf("%d\n",dist[1]);
	else printf("-1\n");return 0;
}