bzoj2125 最短路

https://www.lydsy.com/JudgeOnline/problem.php?id=2125

http://www.tsinsen.com/ViewGProblem.html?gpid=-1000001268

题解

貌似还有一种仙人掌圆方树，跟点双圆方树区别不大，暂时不清楚有什么本质上的区别（貌似写起来容易？）；以下用点双圆方树

建圆方树，当成以dfs起始点(圆点)为根的有根树，方点到其圆点父亲的边权设为0，圆点到其方点父亲的边权设为圆点到其父亲的父亲(是圆点)在原图上的最短距离（可以预处理每个环上的前缀和方便求区间和）（话说我发现自己根本不会维护这个环...研究了一段时间有了一个可行做法：首先tarjan时候确定一个点双时弹出来的边就是点双内边，如果是仙人掌的话，若当前节点是u，可以发现是按照(v,u),(*,v),..,(u,*)的顺序；如果点双内有超过1条边，说明这个点双不是两点一线/单点(然而我并不清楚具体是怎样的?)，是环；求出每个环的长度；考虑求出数组s，其中s[i]表示i点所在环的“根”（即环中在圆方树上深度最小的点）在环上顺时针/逆时针（就是一个环要同一个方向）走到i点的距离；割点在多个点双中，怎么办？设该点为u，考虑在其各个子节点(方点)代表的环中，s[u]=0，因此直接定义割点u属于的环是它父亲节点代表的环；查询距离的时候，特判掉割点）

对于询问，如果两点lca是圆点，直接输出两点在树上距离即可

如果两点lca是方点，“题解”里面有讲

错误记录：边数开小了。注意仙人掌的边数范围是[n-1,2*n-2]（n是点数）

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cassert>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
typedef long long ll;
typedef unsigned long long ull;
#define int ll
struct E
{
    int f,to,nxt,d;
};
int n,m,qq;
int s[20010];//维护从i所在环的"起点"到i的距离
int len[20010];//表示第i个环的长度
namespace T
{

E e[40100];
int f1[20100],ne=1;
void me(int x,int y,int z)
{
    //printf("at%lld %lld %lld\n",x,y,z);
    e[++ne].to=y;e[ne].nxt=f1[x];f1[x]=ne;e[ne].f=x;e[ne].d=z;
    e[++ne].to=x;e[ne].nxt=f1[y];f1[y]=ne;e[ne].f=y;e[ne].d=z;
}
int anc[20010][16],l2n=15,dd[20010][16],dep[20010];
void dfs(int u,int fa)
{
    int i;
    anc[u][0]=fa;
    for(i=1;i<=l2n;++i)
    {
        anc[u][i]=anc[anc[u][i-1]][i-1];
        dd[u][i]=dd[u][i-1]+dd[anc[u][i-1]][i-1];
    }
    for(int k=f1[u];k;k=e[k].nxt)
        if(e[k].to!=fa)
        {
            dep[e[k].to]=dep[u]+1;
            dd[e[k].to][0]=e[k].d;
            dfs(e[k].to,u);
        }
}
int getcircledis(int x,int y)//保证x,y在同一个点双内，求两点间距离
//如果满足这个条件，那么要么x,y深度相等，要么一个是另一个的爷爷
{
    if(x==y)    return 0;
    if(dep[x]!=dep[y])
    {
        //puts("type1");
        if(dep[x]<dep[y])    swap(x,y);
        assert(anc[x][1]==y);
        return min(s[x],len[anc[x][0]-n]-s[x]);
    }
    else
    {
        int an1=s[x]-s[y],an2=s[y]-s[x];
        if(an1<0)    an1+=len[anc[x][0]-n];
        if(an2<0)    an2+=len[anc[x][0]-n];
        return min(an1,an2);
    }
}
int calc(int x,int y)
{
    if(dep[x]<dep[y])    swap(x,y);
    int t=dep[x]-dep[y],an=0,i;
    for(i=l2n;i>=0;--i)
        if(t&(1<<i))
        {
            an+=dd[x][i];
            x=anc[x][i];
        }
    if(x==y)    return an;
    //printf("1t%lld %lld\n",x,y);
    for(i=l2n;i>=0;--i)
        if(anc[x][i]!=anc[y][i])
        {
            an+=dd[x][i];an+=dd[y][i];
            //printf("9t%lld %lld\n",dd[x][i],dd[y][i]);
            x=anc[x][i];y=anc[y][i];
        }
    an+=anc[x][0]>n?getcircledis(x,y):(dd[x][0]+dd[y][0]);
    return an;
}

}
namespace G
{

E e[40100];
int f1[10100],ne=1;
void me(int x,int y,int z)
{
    e[++ne].to=y;e[ne].nxt=f1[x];f1[x]=ne;e[ne].d=z;e[ne].f=x;
    e[++ne].to=x;e[ne].nxt=f1[y];f1[y]=ne;e[ne].d=z;e[ne].f=y;
}
int st[40010];int tp;
int dfn[10100],dfc,cnt;//bno[10100],cnt;
int tmp[40010],tlen;
int dfs(int u,int lst)
{
    int i,k,v,lowu=dfn[u]=++dfc,lowv;
    for(k=f1[u];k;k=e[k].nxt)
    {
        v=e[k].to;
        if(!dfn[v])
        {
            st[++tp]=k;//++chi;
            lowv=dfs(v,k);lowu=min(lowu,lowv);
            if(lowv>=dfn[u])
            {
                ++cnt;
                tlen=0;
                while(st[tp]!=k)    tmp[++tlen]=st[tp--];
                tmp[++tlen]=st[tp--];
                //printf("1t%lld %lld\n",u,tlen);
                int k;
                if(tlen>1)
                {
                    s[u]=0;
                    for(i=1;i<=tlen;++i)
                    {
                        k=tmp[i];
                        s[e[k].f]=s[e[k].to]+e[k].d;
                    }
                    len[cnt]=s[u];
                    for(i=1;i<tlen;++i)
                    {
                        k=tmp[i];
                        T::me(n+cnt,e[k].f,min(s[e[k].f],
                            len[cnt]-s[e[k].f]));
                    }
                    T::me(n+cnt,u,0);
                }
                else
                {
                    k=tmp[1];
                    s[e[k].to]=e[k].d;
                    len[cnt]=2*s[e[k].to];
                    T::me(n+cnt,u,e[k].d);
                    T::me(n+cnt,e[k].to,0);
                }
            }
        }
        else if(dfn[v]<dfn[u]&&k!=(lst^1))
        {
            st[++tp]=k;
            lowu=min(lowu,dfn[v]);
        }
    }
    return lowu;
}
void work()
{
    int i;
    dfs(1,0);
    T::dfs(1,0);
}

}
signed main()
{
    int i,x,y,z;
    scanf("%lld%lld%lld",&n,&m,&qq);
    for(i=1;i<=m;++i)
    {
        scanf("%lld%lld%lld",&x,&y,&z);
        G::me(x,y,z);
    }
    G::work();
    //printf("at%lld\n",G::tp);
    /*
    for(i=1;i<=n;++i)
        printf("1t%lld\n",s[i]);
    for(i=1;i<=G::cnt;++i)
        printf("2t%lld\n",len[i]);
    while(1)
    {
        int a,b;
        scanf("%lld%lld",&a,&b);
        printf("%lld\n",T::getcircledis(a,b));
    }
    */
    while(qq--)
    {
        scanf("%lld%lld",&x,&y);
        printf("%lld\n",T::calc(x,y));
    }
    return 0;
}

数据生成器（只能生成每个点、边都仅在一个环上的仙人掌）

from random import *
circle_num=50
n0=0
cir=[[] for i in range(10000)]
cirlen=[0]*1000
e=[]
ld=1
rd=500
for i in range(circle_num):
    cirlen[i]=randint(1,50)
    for j in range(cirlen[i]):
        n0+=1
        cir[i].append(n0)
    #print('t1',n0)
    for j in range(cirlen[i]-1):
        e.append([cir[i][j],cir[i][j+1],randint(ld,rd)])
    e.append([cir[i][0],cir[i][cirlen[i]-1],randint(ld,rd)])
    #print(e)
    #print(cir)
for i in range(1,circle_num):
    fa=randint(0,i-1)
    e.append([cir[fa][randint(0,cirlen[fa]-1)],cir[i][randint(0,cirlen[i]-1)],randint(ld,rd)])
qq=5000
print(n0,len(e),qq)
for i in e:
    print(i[0],i[1],i[2])
for i in range(qq):
    print(randint(1,n0),randint(1,n0))