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[b]-dis[lca(a,b)].

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

• 我们可以构造这样的一棵树：先按照deep深搜 将所有的环上的点连到deep最小的那个点上面； 这样的话符合思路1中的做法.
• 每次倍增找lca的时候都判断一下lca是不是在环上；如果是的话就得分两种情况取min.

---

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 : 转载请注明出处