BZOJ 1576 [USACO]安全路经Travel (树剖+线段树)

题目大意：

给你一张无向图，求1到其他节点 不经过最短路的最后一条边 的最短路长度，保证每个节点的最短路走法唯一

神题，$USACO$题目的思维是真的好

先$dijkstra$出最短路树

对于每个节点，符合条件的走法必须满足，不经过它和它父亲之间的连边

显然只能从它的某个子节点走向它，就像绕了一圈

可以证明最优的合法路径一定只经过一条非树边，因为最短路方案唯一

如果还经过另外一条非树边，不论这条边在哪，都肯定会绕远

对于一条非树边$e<x,y>$，它连接了两个节点$x,y$，它们的$lca$是$f$

显然$x$到$f$路径上的某个点$S$(除了$f$点)，都存在一条合法路径，从根节点沿树边走到$y$，经过$e<x,y>$走到$x$，再向上沿树边走到$S$

这段路径的长度是$dis_{x}+dis_{y}+dis_{e<x,y>}-dis_{S}$

对于$y$到$f$的路径也是同理

上面的式子可以用线段树+树链剖分序维护

 #include <queue>
 #include <vector>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #define N1 1010
 #define M1 2010
 #define S1 (N1<<1)
 #define T1 (N1<<2)
 #define ll long long
 #define uint unsigned int
 #define rint register int
 #define dd double
 #define il inline
 #define inf 233333333
 using namespace std;

 int gint()
 {
     int ret=,fh=;char c=getchar();
     while(c<''||c>''){if(c=='-')fh=-;c=getchar();}
     while(c>=''&&c<=''){ret=ret*+c-'';c=getchar();}
     return ret*fh;
 }
 int n,m;
 struct Edge{
 int to[M1*],nxt[M1*],val[M1*],head[N1],cte;
 void ae(int u,int v,int w)
 {cte++,to[cte]=v,nxt[cte]=head[u],val[cte]=w,head[u]=cte;}
 }E,T;
 struct SEG{
 int mi[T1];
 void pushdown(int rt)
 {
     mi[rt<<]=min(mi[rt<<],mi[rt]);
     mi[rt<<|]=min(mi[rt<<|],mi[rt]);
 }
 void build(int l,int r,int rt)
 {
     mi[rt]=inf;
     if(l==r) return;
     int mid=(l+r)>>;
     build(l,mid,rt<<);
     build(mid+,r,rt<<|);
 }
 void update(int L,int R,int l,int r,int rt,int w)
 {
     if(L<=l&&r<=R) {mi[rt]=min(mi[rt],w);return;}
     int mid=(l+r)>>; pushdown(rt);
     if(L<=mid) update(L,R,l,mid,rt<<,w);
     if(R>mid) update(L,R,mid+,r,rt<<|,w);
 }
 int query(int x,int l,int r,int rt)
 {
     if(l==r) return mi[rt];
     int mid=(l+r)>>; pushdown(rt);
     if(x<=mid) return query(x,l,mid,rt<<);
     else return query(x,mid+,r,rt<<|);
 }
 }s;

 int dis[N1],use[N1],fa[N1],la[N1],ist[M1*];
 struct node{
     int id,d;
     friend bool operator < (const node &s1,const node &s2)
     {return s1.d>s2.d;}
 };
 void dijkstra()
 {
     int j,v,u;
     memset(dis,0x3f,sizeof(dis));
     priority_queue<node>q;
     dis[]=,q.push((node){,});
     while(!q.empty())
     {
         node k=q.top(); q.pop(); u=k.id;
         if(use[u]) continue; use[u]=;
         for(j=E.head[u];j;j=E.nxt[j]){
             v=E.to[j];
             if(dis[v]>dis[u]+E.val[j])
                 dis[v]=dis[u]+E.val[j],q.push((node){v,dis[v]}),fa[v]=u,la[v]=j;
         }
     }
 }

 int dep[N1],sz[N1],tp[N1],son[N1],st[N1],id[N1],tot;
 void dfs1(int u,int dad)
 {
     for(int j=T.head[u];j;j=T.nxt[j])
     {
         int v=T.to[j]; if(v==dad) continue;
         dep[v]=dep[u]+; dfs1(v,u); //fa[v]=u;
         sz[u]+=sz[v]; son[u]=sz[v]>sz[son[u]]?v:son[u];
     }
     sz[u]++;
 }
 void dfs2(int u)
 {
     st[u]=++tot,id[tot]=u;
     if(son[u]) tp[son[u]]=tp[u],dfs2(son[u]);
     for(int j=T.head[u];j;j=T.nxt[j])
     {
         int v=T.to[j];
         if(v==son[u]||v==fa[u]) continue;
         tp[v]=v; dfs2(v);
     }
 }
 void update(int x,int y,int w)
 {
     int px=x,py=y;
     while(tp[x]!=tp[y])
     {
         if(dep[tp[x]]<dep[tp[y]]) swap(x,y);
         s.update(st[tp[x]],st[x],,n,,dis[px]+dis[py]+w);
         x=fa[tp[x]];
     }
     if(dep[x]>dep[y]) swap(x,y);
     if(x!=y) s.update(st[x]+,st[y],,n,,dis[px]+dis[py]+w);
 }

 void solve()
 {
     int x,y,i,j,v,ans; dijkstra(); s.build(,n,);
     for(i=;i<=n;i++) T.ae(fa[i],i,E.val[la[i]]),ist[la[i]]=;
     dep[]=,dfs1(,-); tp[]=,dfs2();
     for(j=;j<=m*;j+=)
     {
         if(ist[j]||ist[j+]) continue;
         x=E.to[j],y=E.to[j+];
         update(x,y,E.val[j]);
     }
     for(i=;i<=n;i++)
     {
         ans=s.query(st[i],,n,);
         if(ans==inf) printf("-1\n");
         else printf("%d\n",ans-dis[i]);
     }
 }

 int main()
 {
     scanf("%d%d",&n,&m);
     int i,j,x,y,z;E.cte=;
     for(i=;i<=m;i++) x=gint(),y=gint(),z=gint(),E.ae(x,y,z),E.ae(y,x,z);
     solve();
     return ;
 }