题链：
https://www.luogu.org/problemnew/show/P2934
题解：
最短路(树)，可并堆(左偏堆)，并查集。
个人感觉很好的一个题。
由于题目已经明确说明：从1点到每个点的最短路有且只有一条。
那么跑完最短路后，就可以得到一个最短路树，即每个点只有一个来源点。
然后来考虑，如果某一个u点无法从其最短路树上的father到达时，是个怎样的情况：
由于u无法从其父亲到达，所以如果还存在1到u的路径的话，
应该在其子树内(包括u)，存在一个v点，与子树外的某个节点x通过一条x和v之间的非树边，
形成这样一个从1到u的新最短路：1 → x → v → u，
特别的，不能出现x是u的父亲且v就是u点的情况。(因为那条边已经被玩坏了2333)
那么这样的话，新的1到u的距离就是$dis[x]+e[x→v]+dis[v]-dis[u]$。
令$W(x,v)=dis[x]+e[x→v]+dis[v]$
因为要新的距离最小，所以就应该找到一对合法的(x,v)使得$W(x,v)$最小。
那么为什么答案就一定这种形式1 → x → v → u的呢？
为何不能是1 → x → y → v → u，或者经过更多的子树外的节点呢？
（图中的虚线表示最短路树上的路径）
如果经过了两个子树外的节点，那么距离d1就是：
$d1=dis[x]+e1+e2+dis[v]-dis[u]$
如果只经过了一个子树外的节点，比如是y，那么距离d2就是：
$d2=dis[y]+e2+dis[v]-dis[u]$
如果d2>d1的话，即按照之前的疑问，如果经过两个子树外节点会使得答案比经过一个子树外节点优，
那么：
$d2-d1>0$
$dis[y]+e2+dis[v]-dis[u]-(dis[x]+e1+e2+dis[v]-dis[u])>0$
$dis[y]-dis[x]-e1>0$
$dis[y]>dis[x]+e1$，与dis[y]是1到y的最短路矛盾，所以最优答案一定是只经过一个子树外节点。
(经过更多的子树外节点的情况可以自己试着证明一下。)
那么现在就需要对每个节点u，维护出对其合法的最小的W(x,v)，那么答案ANS[u]=W(x,v)-dis[u]。
而这个W(x,v)的维护就直接使用小根堆即可完成，
为了保证时间复杂度，我们需要从树下往上依次处理每个点的答案，
会涉及到把u节点的众多儿子v的堆合并，所以要用到可并堆(本人使用的是左偏堆)。
同时合并后，可能有些在堆里的W(x,v)就不合法了，因为有的x,v处在了同一个子树内，
但是不需要直接在堆里去删除，只用维护一个并查集，在取堆顶时判断该W(x,v)是否合法即可。
代码:
#include<bits/stdc++.h>
#define MAXN 100050
using namespace std;
int N,M;
int pre[MAXN],dis[MAXN],ANS[MAXN],order[MAXN];
struct Info{
int x,y,w;
bool operator < (const Info &rtm) const{
return w<rtm.w;
}
};
struct Edge{
int ent;
int to[MAXN*4],nxt[MAXN*4],val[MAXN*4],head[MAXN];
Edge(){ent=2;}
void Adde(int u,int v,int w){
to[ent]=v; val[ent]=w;
nxt[ent]=head[u]; head[u]=ent++;
}
}E;
struct UFSet{
int fa[MAXN];
void Reset(int n){
for(int i=1;i<=n;i++) fa[i]=i;
}
int Findfa(int u){
if(u==fa[u]) return u;
else return fa[u]=Findfa(fa[u]);
}
void Union(int x,int y){
static int fx,fy;
fx=Findfa(x); fy=Findfa(y);
if(fx==fy) return; fa[fx]=fy;
}
bool Insame(int x,int y){
return Findfa(x)==Findfa(y);
}
}S;
struct LT{
//Define the LEN of the leaf is 1.
int dnt;
Info d[MAXN*4];
int root[MAXN],ls[MAXN*4],rs[MAXN*4],len[MAXN*4];
int Merge(int u,int v){
if(!u||!v) return u+v;
if(d[v]<d[u]) swap(u,v);
rs[u]=Merge(rs[u],v);
if(len[ls[u]]<len[rs[u]]) swap(ls[u],rs[u]);
len[u]=len[rs[u]]+1;
return u;
}
void Insert(int u,Info now){//Insert a new node into the heap of u
++dnt; d[dnt]=now,len[dnt]=1;//As a new node, it's a leaf.
root[u]=Merge(root[u],dnt);
}
int Pop(int u){
return Merge(ls[u],rs[u]);
}
Info Top(int u){
static Info ret;
while(ret=d[root[u]],ret.x&&S.Insame(ret.x,ret.y)){
// cout<<"Delete : "<<ret.x<<" < - > "<<ret.y<<" : "<<ret.w<<endl;
root[u]=Pop(root[u]);
}
return ret;
}
}H;
void Dijkstra(){
typedef pair<int,int>Pii; int ont=0;
priority_queue<Pii,vector<Pii>,greater<Pii> >Q;
memset(dis,0x3f,sizeof(dis));
Q.push(make_pair(dis[1]=0,1));
while(!Q.empty()){
Pii now=Q.top(); Q.pop();
int u=now.second;
if(now.first>dis[u]) continue;
order[++ont]=u;
for(int e=E.head[u];e;e=E.nxt[e]){
int v=E.to[e];
if(dis[v]<=dis[u]+E.val[e]) continue;
dis[v]=dis[u]+E.val[e]; pre[v]=u;
Q.push(make_pair(dis[v],v));
}
}
}
int main(){
scanf("%d%d",&N,&M);
for(int i=1,a,b,c;i<=M;i++)
scanf("%d%d%d",&a,&b,&c),
E.Adde(a,b,c),E.Adde(b,a,c);
Dijkstra(); S.Reset(N);
for(int i=N;i>=1;i--){
int u=order[i];
for(int e=E.head[u];e;e=E.nxt[e]){
int v=E.to[e];
if(v==pre[u]||S.Insame(u,v)) continue;
H.Insert(u,(Info){u,v,dis[u]+dis[v]+E.val[e]});
}
Info now=H.Top(u);
if(!now.x) ANS[u]=-1;
else ANS[u]=now.w-dis[u];
H.root[pre[u]]=H.Merge(H.root[pre[u]],H.root[u]);
S.Union(pre[u],u);
}
for(int i=2;i<=N;i++) printf("%d
",ANS[i]);
return 0;
}