BZOJ 2125 最短路 仙人掌最短路

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

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

解析:
首先如果这是一棵树的话，那么我们只需要选定一个根，之后扫一遍这棵树，询问的话即是两点到根节点的距离之和减去二倍的两点lca到根节点距离。
那么如果是一棵仙人掌的话，我们强行套用这个办法，重新构造一棵树。
对于仙人掌中的一个环来说，我们把该环中深度最小的点当做这个环的根，然后环上其他点连向该环，非环上边正常连接。
这个树有什么优越性呢？
不妨假定1为根，那么每个点到1的最短路即是他到根的距离。
在新树中，我们可以记录两个点(a,b)找到他们lca前的那两个点(c,d)，如果那两个点在一个环中，那么显然这两个点的lca在一个环中，所以我们需要比较在环上逆时针走的距离以及顺时针走的距离，取最小值，再把答案加上$dis[a]-dis[c]+dis[b]-dis[d]$即可（画图可以知道这个距离就是刨除环上走的那段距离的距离）。
如果那两个点不在一个环中，那么直接像树一样，输出答案即可。

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

/************************************/
/*         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[N],belong[N];
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[N],cnt,n,m,q;
    struct Edge
    {
        int from,to,val,next;
    }edge[N<<3];
    int dis[N],dep[N],low[N],tot;
    int fa[N][21];
    bool v[N];
    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[N],cntring;
    int belong[N],lenth[N],sum[N];
    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(){}