BZOJ 2125 最短路.

来源：Bzoj2125:http://www.lydsy.com/JudgeOnline/problem.php?id=2125.

Time: 2015.7.11.

Programmer： sherlock_zhuang.

Statu: AC.

题面：

给一个N个点M条边的连通无向图，满足每条边最多属于一个环，有Q组询问，每次询问两点之间的最短路径。

数据范围：

对于100%的数据，N<=10000，Q<=10000。

运用算法&知识：

(ps: 不会的可以先行学习相关内容)

- Tarjan

- 静态仙人掌的概念

- 倍增求lca

思路：

对于一颗普通的树，求上面任意两点的距离我们的做法：先转化成一棵有根树；然后a->b 的距离为dist[a]+dist-dis[lca(a,b)].

对于一颗仙人掌，我们可以用类似的做法求出两点之间的距离，但是对于lca在环上的则会出现两种情况.

我们可以构造这样的一棵树：先按照deep深搜 将所有的环上的点连到deep最小的那个点上面； 这样的话符合思路1中的做法.

每次倍增找lca的时候都判断一下lca是不是在环上；如果是的话就得分两种情况取min.

[b]CODE:

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<cstring>
#define F(i,begin,end) for(int i=begin;i<=end;i++)
using namespace std;
const int dmax=10000+229; //点数
const int bmax=229000; // 边数
const int inf=229000000;
int n,m,Q,deep;
int num,head[dmax],to[bmax],cost[bmax],next[bmax];//边表
int l,r,q[dmax],vis[dmax],dist[dmax];// spfa&&队列优化
int Time,top,dfn[dmax],low[dmax];
struct Stack
{
int u,v,w;
Stack(int _u=0,int _v=0,int _w=0) { u=_u; v=_v; w=_w;}
}st[dmax]; //Tarjan
int tot,len[dmax],sum[dmax],id[dmax],dep[dmax],fa[dmax][22],ans; // 本题相关

int iget()
{
int x; char ch; int f=1;
while(!isdigit(ch=getchar())) if(ch=='-') f=-1;
x=ch-48;
while( isdigit(ch=getchar())) x=x*10+ch-48; x*=f;
return x;
}

void add(int u,int v,int w)
{
to[num]=v; cost[num]=w; next[num]=head[u]; head[u]=num++;
}

void iread()
{
n=iget(); m=iget(); Q=iget();
int a,b,c;
memset(head,-1,sizeof(head));

for(int i=1;i<=m;i++)
{
a=iget(); b=iget(); c=iget();
add(a,b,c); add(b,a,c);
}

}

void spfa(int x) // 用循环队列优化spfa;
{
for(int i=1;i<=n;i++) vis[i]=0,dist[i]=inf;
l=1; r=2;
q[l]=x; vis[x]=1; dist[x]=0;
while(l!=r) // 循环队列切记不要写成 l<r;
{
int u=q[l];
vis[u]=0; l++;
for(int i=head[u];i!=-1;i=next[i])
{
int v=to[i];
if(dist[v]>dist[u]+cost[i])
{
dist[v]=dist[u]+cost[i];
if(!vis[v])
{
q[r++]=v;
if(r>n) r-=n;
}
}
}
if(l>n) l-=n;
}
}

void pushout(int father,int son)
{
len[++tot]; // 每个环的总长度；
while(st[top].u!=father && st[top].v!=son)
{
int x=st[top].u; int y=st[top].v; int w=st[top].w;
len[tot]+=w;  sum[x]=sum[y]+w; // 环上点之间的相对长度；
if(x!=father) id[x]=tot,fa[x][0]=father;
if(y!=father) id[y]=tot,fa[y][0]=father;
top--;
}// 这里将环上所有点的father 指向一个点； 这个点在等下构建新树的时候是这棵子树的根；
int x=st[top].u; int y=st[top].v; int w=st[top].w;
len[tot]+=w; sum[x]+=sum[y]+w; fa[y][0]=x;
top--;
}

void Tarjan(int x,int fa)
{
dfn[x]=low[x]=++Time;
for(int i=head[x];i!=-1;i=next[i])
{
int v=to[i];  int w=cost[i];
if(!dfn[v])
{
st[++top]=Stack(x,v,w);
Tarjan(v,x);
if(low[x]>low[v]) low[x]=low[v];
if(dfn[x]<=low[v]) pushout(x,v);
}
else if(v!=fa && dfn[v]<low[x])）low[x]=dfn[v],st[++top]=Stack(x,v,w);
}
}

void dfs(int x,int now_dep)
{
dep[x]=now_dep;
for(int i=head[x];i!=-1;i=next[i])
if(!dep[to[i]]) dfs(to[i],now_dep+1);
}

int get_lca(int a,int b,int &c,int &d)
{
int lishi=0;
if(dep[a]<dep[b]) swap(a,b);
lishi=dist[a]+dist[b];  c=d=b;// 防止第一次return的时候出错；
for(int i=deep;i>=0;i--) if(dep[fa[a][i]]>=dep[b]) a=fa[a][i];
if(a==b) return lishi-2*dist[b];

for(int i=deep;i>=0;i--)
if(fa[a][i]!=fa[b][i]) a=fa[a][i],b=fa[b][i];
c=a; d=b; //记录两个子节点；
return lishi-2*dist[fa[a][0]];
}

void iwork()
{
spfa(1);
Tarjan(1,0);
// 倍增求lca;
deep=(int)(log(n)/log(2));
for(int i=1;i<=deep;i++)
for(int j=1;j<=n;j++) fa[j][i]=fa[fa[j][i-1]][i-1];
// 构建新树；
num=0; memset(head,-1,sizeof(head));
for(int i=2;i<=n;i++) add(fa[i][0],i,0);
dfs(1,1);
int a,b,c,d;
for(int i=1;i<=Q;i++)
{
a=iget(); b=iget();
ans=get_lca(a,b,c,d);
if(id[c]!=0 && id[c]==id[d]) // lca出现在环上；
{
int l1,l2;
ans=dist[a]+dist[b]-dist[c]-dist[d]; //这里如果不懂要画图；
l1=abs(sum[c]-sum[d]); l2=len[id[c]]-l1;
//环上的两条路径；
ans+=min(l1,l2);
}
printf("%d\n",ans);
}
}

int main()
{
iread();
iwork();
return 0;
}

PS_NO1：对文章有任何疑问请联系作者（zhuangsherlock@126.com）or留言.

PS_NO2 : 转载请注明出处