[bzoj3694]最短路_树链剖分_线段树

最短路 bzoj-3694

题目大意：给你一个n个点m条边的无向图，源点为1，并且以点1为根给出最短路树。求对于2到n的每个点i，求最短路，要求不经过给出的最短路树上的1到i的路径上的最后一条边。

注释：$1\le n \le 4000$，$1\le m\le 10^5$。

想法：对于任意两个点u和v，满足u和v之间直接相连了一条不在给出最短路树上的边，我们设这条边的长度为val(u,v)。对于任意的一个点i，它到根节点的最短路，也就是从根节点开始走最短路树所到达i的路径和，我们设为dis[i]。那么，对于u到lca(u,v)之间的任意一个点x，我们都可以从1(root)$\rightarrow$t$\rightarrow$v$\rightarrow$u$\rightarrow$x。我们可以用这条路径更新x的答案。这条路径的长度是dis[v]+val(u,v)+dis[u]-dix(x)。我们只需要令这样的(dis[v]+val(u,v)-dis[u])最小即可。显然，每两个这样满足条件的u和v，都可以更新从u到lca(u,v)之间的点和v到lca(u,v)之间的点，就是区间取min。这个操作我们可以用树链剖分+线段树实现。

最后，附上丑陋的代码... ...

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#define ll long long
#define inf 1000000000
using namespace std;
inline ll read()
{
	ll x=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
int n,m,cnt1,cnt2=1,place;
int bin[12];
int u[100005],v[100005],w[100005];
int dis[100005],deep[100005],son[100005],fa[100005][12];
int pl[100005],belong[100005];
struct data{int to,next,v;}e[100005];int head[100005];
struct seg{int l,r,v,tag;}t[400005];
void ins(int u,int v,int w)
{
	e[++cnt1].to=v;e[cnt1].next=head[u];head[u]=cnt1;e[cnt1].v=w;
}
void insert(int u,int v,int w)
{
	ins(u,v,w);ins(v,u,w);
}
void dfs1(int x,int f)
{
	for(int i=1;i<=11;i++)
	    if(bin[i]<=deep[x])fa[x][i]=fa[fa[x][i-1]][i-1];
	    else break;
	son[x]=1;
	for(int i=head[x];i;i=e[i].next)
	{
		if(e[i].to==f)continue;
		deep[e[i].to]=deep[x]+1;
		fa[e[i].to][0]=x;
		dis[e[i].to]=dis[x]+e[i].v;
		dfs1(e[i].to,x);
		son[x]+=son[e[i].to];
	}
}
void dfs2(int x,int chain)
{
	belong[x]=chain;place++;pl[x]=place;
	int k=0;
	for(int i=head[x];i;i=e[i].next)
		if(deep[e[i].to]>deep[x]&&son[e[i].to]>son[k])
		    k=e[i].to;
	if(k)dfs2(k,chain);
	for(int i=head[x];i;i=e[i].next)
	    if(deep[e[i].to]>deep[x]&&e[i].to!=k)
	        dfs2(e[i].to,e[i].to);
}
int lca(int x,int y)
{
	if(deep[x]<deep[y])swap(x,y);
	int t=deep[x]-deep[y];
	for(int i=0;i<=11;i++)
	    if(bin[i]&t)x=fa[x][i];
	for(int i=11;i>=0;i--)
	   if(fa[x][i]!=fa[y][i])
	      x=fa[x][i],y=fa[y][i];
	if(x==y)return x;
	return fa[x][0];
}
void build(int k,int l,int r)
{
	t[k].l=l;t[k].r=r;t[k].tag=inf;
	if(l==r){t[k].v=inf;return;}
	int mid=(l+r)>>1;
	build(k<<1,l,mid);build(k<<1|1,mid+1,r);
}
void pushdown(int k)
{
	if(t[k].tag==inf||t[k].l==t[k].r)return;
	int tag=t[k].tag;t[k].tag=inf;
	t[k<<1].tag=min(t[k<<1].tag,tag);
	t[k<<1|1].tag=min(t[k<<1|1].tag,tag);
	if(t[k<<1].l==t[k<<1].r)t[k<<1].v=min(t[k<<1].v,tag);
	if(t[k<<1|1].l==t[k<<1|1].r)t[k<<1|1].v=min(t[k<<1|1].v,tag);
}
void update(int k,int x,int y,int v)
{
	pushdown(k);
    int l=t[k].l,r=t[k].r;
	if(x==l&&y==r)
	{
		t[k].tag=min(t[k].tag,v);
		if(l==r)t[k].v=min(v,t[k].v);
		return;
	}
	int mid=(l+r)>>1;
	if(y<=mid)update(k<<1,x,y,v);
	else if(x>mid)update(k<<1|1,x,y,v);
	else {update(k<<1,x,mid,v);update(k<<1|1,mid+1,y,v);}
}
int ask(int k,int x)
{
	pushdown(k);
	int l=t[k].l,r=t[k].r;
	if(l==r)return t[k].v;
	int mid=(l+r)>>1;
	if(x<=mid)return ask(k<<1,x);
	else return ask(k<<1|1,x);
}
void solveupdate(int x,int f,int v)
{
	while(belong[x]!=belong[f])
	{
		update(1,pl[belong[x]],pl[x],v);
		x=fa[belong[x]][0];
	}
	if(x!=f)update(1,pl[f]+1,pl[x],v);
}
void solve()
{
	build(1,1,n);
	for(int i=1;i<cnt2;i++)
	{
		int t=lca(u[i],v[i]);
		solveupdate(u[i],t,dis[u[i]]+dis[v[i]]+w[i]);
		solveupdate(v[i],t,dis[u[i]]+dis[v[i]]+w[i]);
	}
	for(int i=2;i<=n;i++)
	{
		int t=ask(1,pl[i]);
		if(t!=inf)printf("%d ",t-dis[i]);
	    else printf("-1 ");
	}
}
int main()
{
	//freopen("shortest.in","r",stdin);
	//freopen("shortest.out","w",stdout);
	bin[0]=1;for(int i=1;i<=12;i++)bin[i]=bin[i-1]*2;
	n=read();m=read();
	for(int i=1;i<=m;i++)
	{
	    u[cnt2]=read();v[cnt2]=read(),w[cnt2]=read();
		bool f=read();
	    if(!f)cnt2++;
	    else insert(u[cnt2],v[cnt2],w[cnt2]);
	}
	dfs1(1,0);dfs2(1,1);
	solve();
	return 0;
}

小结：考虑一个最值问题我们通常考虑一个式子可以更新什么样的情况下什么样的值，或者什么样的值可以被什么样情况的状态更新。比如说我们在进行倍增floyd时，我们是想到了每一条对于每一条最短路来讲，它的最后一条边可以从那些点来更新，从而想到矩阵来一遍一遍乘。而这个操作可以用矩乘优化。这道题也是同理，我们想到每一个点可以从哪种路径来进行更新，我们想到了如上述的方法，又因为给出的是最短路树，所以根节点到一个点的最短路一定是最短路树上的。更加说明了我们算法的正确性。