AcWing 178.第k短路

给定一张 NN 个点（编号 1,2…N1,2…N），MM 条边的有向图，求从起点 SS 到终点 TT 的第 KK 短路的长度，路径允许重复经过点或边。

注意： 每条最短路中至少要包含一条边。

输入格式

第一行包含两个整数 NN 和 MM。

接下来 MM 行，每行包含三个整数 A,BA,B 和 LL，表示点 AA 与点 BB 之间存在有向边，且边长为 LL。

最后一行包含三个整数 S,TS,T 和 KK，分别表示起点 SS，终点 TT 和第 KK 短路。

输出格式

输出占一行，包含一个整数，表示第 KK 短路的长度，如果第 KK 短路不存在，则输出 −1−1。

数据范围

1≤S,T≤N≤10001≤S,T≤N≤1000,
0≤M≤1040≤M≤104,
1≤K≤10001≤K≤1000,
1≤L≤1001≤L≤100

输入样例：

2 2
1 2 5
2 1 4
1 2 2

输出样例：

14

A*算法是以全局的估计最小值来进行搜索的，dijkstra求最短路是按局部进行的，有一定的局限性。

A*的基础建立在评估函数必须大于实际函数。

A*算法条件:

#include<bits/stdc++.h>
#define x first
#define y second

using namespace std;

typedef pair<int, int> PII;
typedef pair<int, PII> PIII;

const int N = 1010, M = 200010;

int n, m, S, T, K;
int h[N], rh[N], e[M], w[M], ne[M], idx;
int dist[N], cnt[N];
bool st[N];

void add(int h[], int a, int b, int c)
{
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

void dijkstra()//预处理
{
	priority_queue<PII, vector<PII>, greater<PII>> heap;
	heap.push({0, T});
	/*
		dijkstra处理的是每个点到终点的距离
	*/
	memset(dist, 0x3f, sizeof dist);
	dist[T] = 0;
	
	while (heap.size())
	{
		auto t = heap.top();
		heap.pop();
		
		int ver = t.y;
		if (st[ver]) continue;
		st[ver] = true;
		
		for (int i = rh[ver]; ~i; i = ne[i])
		{
			int j = e[i];
			if (dist[j] > dist[ver] + w[i])
			{
				dist[j] = dist[ver] + w[i];
				heap.push({dist[j], j});
			}
		}
	}
}

int astar()
{
	priority_queue<PIII, vector<PIII>, greater<PIII>> heap;
	heap.push({dist[S], {0, S}});
	/*
		(到终点的距离（评估），（累计路程，点））
	*/
	while (heap.size())
	{
		auto t = heap.top();
		heap.pop();
		
		int ver = t.y.y, distance = t.y.x;
		cnt[ver] ++ ;
		if (cnt[T] == K) return distance;
		
		for (int i = h[ver]; ~i; i = ne[i])
		{
			int j = e[i];
			if (cnt[j] < K)
				/*
				d[state] + f[state] = 起点到state的真实距离 + state到终点的估计距离=估计距离
                                                                       ^
				d[state] + g[state] = 起点到state的真实距离 + state到终点的真实距离=真实距离
				*/
				heap.push({distance + w[i] + dist[j], {distance + w[i], j}});
		}
	}
	
	return -1;
}

int main()
{
	scanf("%d%d", &n, &m);
	memset(h, -1, sizeof h);
	memset(rh, -1, sizeof rh);
	
	for (int i = 0; i < m; i ++ )
	{
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		add(h, a, b, c);
		add(rh, b, a, c);
	}
	scanf("%d%d%d", &S, &T, &K);
	if (S == T) K ++ ;
	
	dijkstra();
	printf("%d\n", astar());
	
	return 0;
}

估计距离<=真实距离
d[state] + f[state] = 起点到state的真实距离 + state到终点的估计距离=估计距离
                                                                       
d[state] + g[state] = 起点到state的真实距离 + state到终点的真实距离=真实距离

假设终点第一次出队列时不是最优 
      则说明当前队列中存在点u
         有 d[估计]< d[真实]
      d[u] + f[u] <= d[u] + g[u] 

矛盾。