BZOJ 2125 最短路 仙人掌最短路

为了证明我还活着所以我发了篇博客_ (:з」∠) _

题意:

给定一张仙人掌图，n<=10000，多次询问两点间最短路。

Q<=10000.

解析:

首先如果这是一棵树的话，那么我们只需要选定一个根，之后扫一遍这棵树，询问的话即是两点到根节点的距离之和减去二倍的两点lca到根节点距离。

那么如果是一棵仙人掌的话，我们强行套用这个办法，重新构造一棵树。

对于仙人掌中的一个环来说，我们把该环中深度最小的点当做这个环的根，然后环上其他点连向该环，非环上边正常连接。

这个树有什么优越性呢？

不妨假定1为根，那么每个点到1的最短路即是他到根的距离。

在新树中，我们可以记录两个点(a,b)找到他们lca前的那两个点(c,d)，如果那两个点在一个环中，那么显然这两个点的lca在一个环中，所以我们需要比较在环上逆时针走的距离以及顺时针走的距离，取最小值，再把答案加上dis[a]−dis[c]+dis−dis[d]即可（画图可以知道这个距离就是刨除环上走的那段距离的距离）。

如果那两个点不在一个环中，那么直接像树一样，输出答案即可。

主函数不打内容这个事情，是一种信仰！

[b]代码:

/************************************/
/*         SZY?SZY!SZSZYYY!         */
/************************************/
#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 11000
using namespace std;
int q,top;
int ringcnt;
vector<int>ring
,belong
;
struct Stack
{
int fr,to,val;
Stack(){}
Stack(int _fr,int _to,int _val):fr(_fr),to(_to),val(_val){}
}sta[N*10];
class Graph
{
int head
,cnt,n,m,q;
struct Edge
{
int from,to,val,next;
}edge[N<<3];
int dis
,dep
,low
,tot;
int fa
[21];
bool v
;
void init(){memset(head,-1,sizeof(head));cnt=1;}
void edgeadd(int from,int to,int val)
{edge[cnt].from=from,edge[cnt].to=to;
edge[cnt].val=val,edge[cnt].next=head[from];head[from]=cnt++;}
void readin()
{
scanf("%d%d%d",&n,&m,&q);
for(int i=1;i<=m;i++)
{
int x,y,z;scanf("%d%d%d",&x,&y,&z);
edgeadd(x,y,z),edgeadd(y,x,z);
}
}
void spfa(int s)
{
memset(dis,0x3f,sizeof(dis));
memset(v,0,sizeof(v));
queue<int>q;
q.push(s),dis[s]=0,v[s]=true;
while(!q.empty())
{
int u=q.front();q.pop();
v[u]=false;
for(int i=head[u];i!=-1;i=edge[i].next)
{
int to=edge[i].to;
if(dis[u]+edge[i].val<dis[to])
{
dis[to]=dis[u]+edge[i].val;
if(!v[to])
{
v[to]=true;
q.push(to);
}
}
}
}
}
int lenthofring
,cntring;
int belong
,lenth
,sum
;
void addring(int u,int v)
{
cntring++;
while(sta[top].fr!=u&&sta[top].to!=v)
{
int x=sta[top].fr,y=sta[top].to;
int val=sta[top--].val;
sum[x]=sum[y]+val;
lenth[cntring]+=val;
if(x!=u)
belong[x]=cntring,fa[x][0]=u;
if(y!=u)
belong[y]=cntring,fa[y][0]=u;
}
int x=sta[top].fr,y=sta[top].to,val=sta[top--].val;
lenth[cntring]+=val,sum[x]=sum[y]+val;
fa[y][0]=x;
}
void tarjan(int now,int ff)
{
dep[now]=low[now]=++tot;
for(int i=head[now];i!=-1;i=edge[i].next)
{
int to=edge[i].to;
if(to==ff)continue;
if(!dep[to])
{
sta[++top]=Stack(now,to,edge[i].val);
tarjan(to,now);
low[now]=min(low[now],low[to]);
if(low[to]>=dep[now])
{
addring(now,to);
}
}else if(dep[to]<low[now])low[now]=min(low[now],dep[to]),sta[++top]=Stack(now,to,edge[i].val);
}
}
void rebuild(int now,int ff)
{
dep[now]=dep[ff]+1;
for(int i=head[now];i!=-1;i=edge[i].next)
{
int to=edge[i].to;
if(to==ff)continue;
rebuild(to,now);
}
}
int lca(int x,int y,int &lca1,int &lca2)
{
if(dep[x]<dep[y])swap(x,y);
int ret=dis[x]+dis[y];
lca1=lca2=y;
for(int i=20;i>=0;i--)
if(dep[fa[x][i]]>=dep[y])
x=fa[x][i];
if(x==y)return ret-2*dis[lca1];
for(int i=20;i>=0;i--)
if(fa[x][i]!=fa[y][i])
x=fa[x][i],y=fa[y][i];
lca1=x,lca2=y;
return ret-2*dis[fa[x][0]];
}
public:
Graph()
{
init();
readin();
spfa(1);
tarjan(1,0);
for(int i=1;i<=20;i++)
for(int j=1;j<=n;j++)
fa[j][i]=fa[fa[j][i-1]][i-1];
init();
for(int i=2;i<=n;i++)
edgeadd(fa[i][0],i,0);
rebuild(1,0);
for(int i=1;i<=q;i++)
{
int x,y,lca1,lca2;
scanf("%d%d",&x,&y);
int ans=lca(x,y,lca1,lca2);
if(belong[lca1]!=0&&belong[lca1]==belong[lca2])
{
ans=dis[x]-dis[lca1]+dis[y]-dis[lca2];
int lenth1=abs(sum[lca1]-sum[lca2]);
int lenth2=lenth[belong[lca1]]-lenth1;
ans+=min(lenth1,lenth2);
}
printf("%d\n",ans);
}
}
}g;
int main(){}