\(Dijkstra\) 水一发

对于题目，我们可以转化为如下图所示：

我们设点 \(s\) 到点 \(e\) 的距离就是题目里面每个点到终点的距离，然后节点 \(t\) 就是多出的干草（有可能在最短路上，有可能在最短路外）。设点到点的距离为 \(dis\) ，干草垛的美味度为 \(k\) 值，那么题目就是求：

\[dis_{s->t}+dis_{t->e}-dis_{s->e} \geq k \]

移项，可得：

\[dis_{s->t}+dis_{t->e}\geq k+dis_{s->e} \]

毫无疑问，右式极易求出，那么问题就变成求左式了。
如果分布求解的话，两个不确定的点 \(s\) 和 \(t\) 肯定会将其复杂度降得很低，那我们不妨试着将其转化为一个直线上的问题，直接强迫我们最短路通过点 \(t\) 来简化问题。
那再转化一下：

我们映像出一个超级点，只会链接点 \(t\) 并且长度与点 \(t\) 到终点的长度一样。
这样我们再以超级点为起点做最短路的时候，是一定会经过点 \(t\) 的。
问题再次转化：

\[dis_{s->e'}\geq k+dis_{s->e} \]

但是在一开始的时候我们就默认 \(dis\) 值是最大值，所以我们最好将大于等于转化为小于等于。
转化一下：

\[dis_{s->e'}\leq dis_{s->e}-k \]

自己理解一下就可以了。

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#define Maxn 500000 
using namespace std;
typedef long long ll;
const ll INF=0x7f7f7f7f7f;
ll n,m,x,k,u,v,w,hay[Maxn];
struct Edge{
	int to,next,val;
}edge[Maxn<<1];
ll top,head[Maxn];
void add(ll u,ll v,ll w){
	edge[++top].to=v;
	edge[top].next=head[u];
	edge[top].val=w;
	head[u]=top;
}
bool vis[Maxn];
ll dis[Maxn];
struct Node{
	ll dis,pos;
	Node(int dis,int pos):dis(dis),pos(pos){}
	bool operator <(const Node &x) const{
		return dis>x.dis;
	}
};
priority_queue<Node>q;
void Dijkstra(int s){
	for(ll i=1;i<=n;i++) dis[i]=INF;
	dis[s]=0;
	q.push(Node(0,s));
	while(!q.empty()){
		Node temp=q.top();
		q.pop();
		ll u=temp.pos;
		ll d=temp.dis;
		if(vis[u]) continue;
		vis[u]=true;
		for(ll i=head[u];i;i=edge[i].next){
			ll v=edge[i].to;
			if(dis[v]>dis[u]+edge[i].val){
				dis[v]=dis[u]+edge[i].val;
				if(!vis[v]) q.push((Node){dis[v],v});
			}
		}
	}
} 
ll ans1[Maxn];
int main(){
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1;i<=m;i++){
		scanf("%lld%lld%lld",&u,&v,&w);
		add(u,v,w),add(v,u,w);
	}
	Dijkstra(n);
	for(int i=1;i<=n;i++)
		ans1[i]=dis[i];
	for(int i=1;i<=k;i++){
		scanf("%lld%lld",&x,&hay[i]);
		add(x,n+1,ans1[x]-hay[i]),add(n+1,x,ans1[x]-hay[i]);
	}
	memset(vis,false,sizeof(vis));
	Dijkstra(n+1);
	for(int i=1;i<n;i++){
		if(dis[i]<=ans1[i]) printf("1\n");
		else printf("0\n");
	}
	return 0;
}