多源最短路问题（迪杰斯特拉变形）

题目

题意大概就是给你p个点，要你求出每个点离其它p-1个点中最近的点的距离。

开始看见多源最短路就想用Floyd，一看数据量 1e5，直接嗝屁。

后来百思不得其解。 在逛了一大堆大佬的题解之后终于有点明白。

首先放弃了Floyd之后我们可以想想其他的解法，p遍djikstra是复杂度是O（p * mlogn）， p 和 m都是1e5，直接爆炸。

那我们想想看能不能将djiksra优化一下呢？既然有多个起点，那么我们在djikstra开始的时候就将所有起点放入优先队列中，然后开始正常松弛。
很容易发现这样松弛会出现问题，当两个不同的起点的最短路相遇的时候，我们需要更新这两个起点的最短距离，如下图：

这个时候 dis(i,j) = dis(u) + dis(v) + w

所以我们需要记录每个点是由哪个源点扩展的，（有点类似染色的过程）只要两个不同源点的最短路相遇，就更新两个源点的最短距离。

#include <bits/stdc++.h>
#define ll long long
#define inf 0x3f3f3f3f
#define fi first
#define se second
#define endl '\n'
#define IOS std::ios::sync_with_stdio(false),cin.tie(0), cout.tie(0)
using namespace std;

int read()
{
	int x=0;
	char c=getchar();
	while(c<'0'||c>'9') c=getchar();
	while(c>='0'&&c<='9') x=(x<<3)+(x<<1)+c-'0',c=getchar();
	return x;
}

void write(int x)
{
	if(x<0) putchar('-'),x=-x;
	if(x>9) write(x/10);
	putchar(x%10+'0');
	return;
}

const int N = 5e5 + 100;
const ll INF = 0x3f3f3f3f3f3f3f3f;
int n, m, p;

int t[N];
int h[N], e[N], w[N], ne[N], idx, bj[N], belong[N];
ll dis[N], ans[N];

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

struct node
{
	bool friend operator < (node a, node b)
	{
		return a.cost > b.cost;
	}
	int to;
	ll cost;
};

void dji()
{
	priority_queue<node> Q;
	memset(dis, INF, sizeof dis);  //初始化过程
	memset(bj, 0, sizeof bj);
	memset(ans, INF, sizeof ans);

	for(int i = 0; i < p; i ++)  //将所有的源点放入优先队列
	{
		node x;
		x.cost = 0;
		x.to = t[i];
		dis[t[i]] = 0;
		Q.push(x);
	}

	while(Q.size())
	{
		node head = Q.top();
		Q.pop();

		int o = head.to;
		if(bj[o]) continue;
		bj[o] = 1;

		for(int j = h[o]; ~j; j = ne[j])
		{
			int now = e[j];

			if(dis[now] > head.cost + w[j])  //能松弛肯定先更新最短路，更新完后需要染色。
			{
				dis[now] = head.cost + w[j];
				node next;
				next.to = now;
				next.cost = dis[now];
				Q.push(next);
				belong[now] = belong[o];
			}

			// 没有松弛有两种可能，第一种是已经没有更优的最短路；
			//第二种是已经到了另外一个起点,因为起点的dis为0。

			if(belong[now] != belong[o])  //两个不同源点的最短路相遇
			{
				ans[belong[now]] = min(ans[belong[now]], dis[now] + dis[o] + w[j]);
				ans[belong[o]] = min(ans[belong[o]], dis[now] + dis[o] + w[j]);
			}
		}
	}
}

int main()
{
	n = read(), m = read(), p = read();
	memset(h, -1, sizeof h);
	for(int i = 0; i < p; i ++)
		t[i] = read(), belong[t[i]] = t[i];  //将自己染色
	while(m --)
	{
		int a, b, c;
		a = read(), b = read(), c = read();
		add(a, b, c);
		add(b, a, c);
	}

	dji();
	
	for(int i = 0; i < p; i ++)
		printf("%lld ", ans[t[i]]); //输出答案

	return 0;
}