思路：要找第K短路，暴力的话就是bfs搜索每一个可以到达的点，那么第K个到终点的距离就是第K短路，这样铁T，对于这种搜索的点巨多的就用A*，
A*
在最短路问题中，如果所有的边权非负，那么就可以用启发函数来优化bfs过程启发函数
是一种函数用来估算当前状态和 目标状态之间的距离，用于路径决策。
也就是说，该函数的IQ直接决定了寻找路径的快慢和准确度（accuracy）
我们吧f(s)作为启发函数（s到目标点的估算距离），g(s)是从s到目标点的实际距离，要满足f(s)<=g(s)，就可以保证当某个状态s，第一次从优先队列出来时是最短距离，那么我们可以发现对应这个题f(s)可以通过跑一遍最短路（反向）获得，然后通过对加上的启发式函数排序（优先队列）找到第K个到T的距离
#pragma GCC optimize(2)
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define SIS std::ios::sync_with_stdio(false)
#define space putchar(' ')
#define enter putchar('\n')
#define lson root<<1
#define rson root<<1|1
typedef pair<int,int> PII;
typedef pair<int,PII> PIII;
const int mod=1e9+7;
const int N=2e5+5;
const int inf=0x7f7f7f7f;
int gcd(int a,int b)
{
return b==0?a:gcd(b,a%b);
}
ll lcm(ll a,ll b)
{
return a*(b/gcd(a,b));
}
template <class T>
void read(T &x)
{
char c;
bool op = 0;
while(c = getchar(), c < '0' || c > '9')
if(c == '-')
op = 1;
x = c - '0';
while(c = getchar(), c >= '0' && c <= '9')
x = x * 10 + c - '0';
if(op)
x = -x;
}
template <class T>
void write(T x)
{
if(x < 0)
x = -x, putchar('-');
if(x >= 10)
write(x / 10);
putchar('0' + x % 10);
}
ll qsm(int a,int b,int p)
{
ll res=1%p;
while(b)
{
if(b&1)
res=res*a%p;
a=1ll*a*a%p;
b>>=1;
}
return res;
}
struct node
{
int nex,to,w;
/* data */
}edge[N];
int head[N],tail[N],tot;
int vis[N],dis[N];
int S=-1,T=-1,K=-1;
void add(int *h,int u,int v,int w)
{
edge[++tot].to=v;
edge[tot].w=w;
edge[tot].nex=h[u];
h[u]=tot;
}
void dijkstra()
{
memset(dis,inf,sizeof dis);
priority_queue<PII,vector<PII>,greater<PII> > heap;
heap.push({
0,T});
dis[T]=0;
// vis[T]=1;
while(heap.size())
{
auto now=heap.top();
heap.pop();
int u=now.second,distance=now.first;
if(vis[u])continue;
vis[u]=1;
for(int i=tail[u];~i;i=edge[i].nex)
{
int v=edge[i].to;
int w=edge[i].w;
if(dis[v]>dis[u]+w)
{
dis[v]=dis[u]+w;
heap.push({
dis[v],v});
}
}
}
}
int A_star()
{
// memset(vis,0,sizeof vis);
if(dis[S]==inf)return -1;
priority_queue<PIII,vector<PIII>,greater<PIII> > heap;
heap.push({
dis[S],{
0,S}});
int cnt=0;
while(heap.size())
{
auto now=heap.top();
heap.pop();
int u=now.second.second,distance=now.second.first;
if(u==T)cnt++;
if(cnt==K) return distance;
for(int i=head[u];~i;i=edge[i].nex)
{
int v=edge[i].to,w=edge[i].w;
heap.push({
distance+w+dis[v],{
distance+w,v}});
}
}
return -1;
}
int main()
{
memset(head,-1,sizeof head);
memset(tail,-1,sizeof tail);
int n,m;
scanf("%d%d",&n,&m);
for(int i=0;i<m;i++)
{
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
add(head,u,v,w);add(tail,v,u,w);
}
scanf("%d%d%d",&S,&T,&K);
if(S==T)K++;
dijkstra();
printf("%d",A_star());
return 0;
}