AcWing 178 第K短路 题解（搜索—A*搜索）

AcWing 178 第K短路
A*搜索，应用于点特别多的图找最短路的情况
思路：先用dijkstra算法求出各个点到终点的最短距离，这些距离的排序其实照应他们距离起点的距离的顺序，所以在找到距离最短路之后，从起点依次遍历距离他的点，距离近的点被遍历的次数少，距离远的点会留在队列中被多次遍历

#include<bits/stdc++.h>

using namespace std;

const int N = 1010, M = 2e5 + 10;

#define x first
#define y second
typedef pair<int, int>PII;
typedef pair<int, PII>PIII;

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

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});  //将终点入堆 
	memset(dist, 0x3f, sizeof dist);  //初始化距离 
	dist[T] = 0;  //终点的距离为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 != -1; 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 a_star(){  //类似于dijkstra()求最短路，此时每个点的最短路已求出	
	priority_queue<PIII, vector<PIII>, greater<PIII>>heap;  //堆内储存的是点和点到起点的距离和点到终点的距离 
	//谁的d[u]+f[u]更小 谁先出队列，d[u]是实际距离，f[u]是预估距离 
	heap.push({dist[S], {0, S}});
	/*理一下思路 
		从起点开始依次入堆，同时记录入堆次数，这是一个有向图，所以前面的点不会重复入堆
			这是一个连通图，所以后面和起点连通的点肯定会被访问多次，距离为x的点被访问的次数就是x 
			同时访问到第x远的点时，距离大于x的点被访问的次数也在递增，最明显的就是终点的被访问次数在增加 
			当终点的被访问次数为k时，当前被访问的点就是第k远的点，距离就是第k远的距离，所以可以直接返回当前点的距离 
	*/ 
	while(heap.size()){
		auto t = heap.top();
		heap.pop();
		int ver = t.y.y, dis = t.y.x;
		
		cnt[ver] ++ ;  //记录点被访问的次数
		//如果终点已经被访问过k次了 则此时的ver就是终点T返回答案
		
		if(cnt[T] == K) return dis;
		
		for(int i = h[ver]; i != -1; i = ne[i]){  //所有和ver连通的点依次入堆，这样保证了距离为x的点可以入堆x次 
			int j = e[i];
			/* 
            如果走到一个中间点都cnt[j]>=K，则说明j已经出队k次了，且astar()并没有return distance,
            说明从j出发找不到第k短路(让终点出队k次)，
            即继续让j入队的话依然无解，
            那么就没必要让j继续入队了
            */			
			if(cnt[j] < K){
				// 按 真实值+估计值 = d[j]+f[j] = dist[S->t] + w[t->j] + dist[j->T] 堆排
                // 真实值 dist[S->t] = distance+w[i]
				heap.push({dis + dist[j] + w[i], {dis + w[i], j}});
			}
		}
	}
	// 终点没有被访问k次
	return -1; 
}

int main()
{
	cin>>n>>m;
	memset(h, -1, sizeof h);
	memset(rh, -1, sizeof rh);
	for(int i = 0; i < m; i ++ ){
		int a, b, c;
		cin>>a>>b>>c;
		add(h, a, b, c);
		add(rh, b, a, c);
	}
	cin>>S>>T>>K;
	
	if(S == T) K ++ ;
	// 起点==终点时 则d[S→S] = 0 这种情况就要舍去 ,总共第K大变为总共第K+1大 
	dijkstra();
	// 从各点到终点的最短路距离 作为估计函数f[u]
	cout<<a_star();
	
	return 0;
}