Description

為了 隨時 與 rainbow快速交流， Freda製造了 兩部傳呼機 。Freda和 rainbow所在的地方有N座房屋、M條雙向 光纜 。每條光纜連線兩座房屋， 傳呼機發出的訊號只能沿著光纜傳遞，並且 傳呼機的訊號 從光纜的其中一端傳遞到另需要花費 t單位時間 。現在 Freda要 進行 Q次試驗， 每次選取兩座房屋，並想知道 傳呼機的訊號在這兩座房屋之間傳遞 至少需 要多長時間。 Freda 和 rainbow簡直弱爆了有木有T_TT_T ，請你幫他們吧……

N座房屋 通過光纜 一定是連通的， 並且這 M條光纜有以下三類連線情況：

A：光纜不形成環 ，也就是光纜僅 有 N-1條。（30%的資料）

B：光纜只 形成一個環，也就是光纜 僅有 N條。（50%的資料）

C：每條光纜僅在一個環中。（10%資料N，M較小，10%資料N，M較大）

Solution

先看A類資料，顯然樹上lca可以完美解決。

再看一下B類資料，環套樹，我們考慮拆掉環。

搜尋一遍把環邊找出來，特殊處理環邊連線的兩個點到所求兩點的距離即可。

對於C類資料，仙人掌圖。

於是我們可以考慮將環拆散，對於每個環，我們找出它們的環頂（這裡環頂的定義是進入該環必須經過的點，注意，環頂不屬於任何環，因為它可以被多個環包含），然後把環頂向這個環上的點連一條邊，邊權為該點到環頂的最短路。

具體實現就是開個棧，處理每個環上的點經過環的兩條路徑的距離即可。

然後原圖就變成一棵樹了，是不是覺得很簡單了！

然而，如果我們直接像A類資料那樣的話，會出現一個問題：

我們看，如果(u′,v′)在同一個環內，那麼它們的最短距離就可能不需要經過lca，那麼統計的時候答案就可能大了。

這時，我們先前統計的環上的兩條路徑就派上用場了。

記兩條路徑分別為l1，l2，那麼這兩個點的最短路就是：
min(l1x+l2y,l2x+l1y,|l1x−l1y|)（|a|表示a的絕對值）

所以，我們求lca時只需走到lca的兒子即可。

注意細節。

Code

#include<iostream>
#include<cstdio>
 

#include<cstdlib>
#include<cstring>
#define fo(i,j,k) for(int i=j;i<=k;i++)
#define fd(i,j,k) for(int i=j;i>=k;i--)
#define N 20010
#define M 40010
using namespace std;
int to[M],next[M],last[M],val[M],num=0;
int nt[M],nn[M],nl[M],nv[M],cnt=0;
int dfn[N];
int top=0;
int f[N][15],g[N][15];
int fa[N];
int c1[N],c2[N];
int bl[N],zx[N];
int zz=0;
int d[N];
struct stack{
    int x,s;
}st[N];
int tt=0;
int abs(int x)
{
    return x<0?-x:x;
}
void link(int x,int y,int c)
{
    num++;
    to[num]=y;
    next[num]=last[x];
    last[x]=num;
    val[num]=c;
}
void nlink(int x,int y,int c)
{
    cnt++;
    nt[cnt]=y;
    nn[cnt]=nl[x];
    nl[x]=cnt;
    nv[cnt]=c;
}
void dfs(int x)
{
    dfn[x]=++tt;
    for(int i=last[x];i;i=next[i])
    {
        int v=to[i];
        if(v!=fa[x] && !dfn[v])
        {
            fa[v]=x;
            top++;
            st[top].x=v;
            st[top].s=val[i];
            dfs(v);
        }
        else if(v!=fa[x] && dfn[v]<dfn[x])
        {
            zz++;
            int p=top,tmp=val[i];
            while(st[p].x!=v && p)
            {
                c1[st[p].x]=tmp;
                tmp+=st[p].s;
                p--;
            }
            tmp=st[p+1].s;
            fo(i,p+1,top)
            {
                zx[st[i].x]=v;
                bl[st[i].x]=zz;
                c2[st[i].x]=tmp;
                int jx=min(c1[st[i].x],c2[st[i].x]);
                nlink(st[i].x,v,jx);
                nlink(v,st[i].x,jx);
                tmp+=st[i+1].s;
            }
        }
    }
    top--;
}
bool vis[N];
void cxlb(int x)
{
    vis[x]=true;
    for(int i=last[x];i;i=next[i])
    {
        int v=to[i];
        if(v!=fa[x] && !vis[v])
        {
            if((bl[x]!=bl[v] || !bl[x] && !bl[v]) && zx[v]!=x && zx[x]!=v)
            {
                nlink(x,v,val[i]);
                nlink(v,x,val[i]);
            }
            cxlb(v);
        }
    }
}
int sbll=0;
void find(int x)
{
    for(int i=nl[x];i;i=nn[i])
    {
        int v=nt[i];
        if(v!=f[x][0])
        {
            f[v][0]=x;
            g[v][0]=nv[i];
            d[v]=d[x]+1;
            find(v);
        }
    }
}
int lca(int x,int y)
{
    int tmp=0;
    if(d[x]>d[y]) swap(x,y);
    fd(i,14,0)
    while(d[f[y][i]]>=d[x])
    tmp+=g[y][i],y=f[y][i];
    if(x==y) return tmp;
    fd(i,14,0)
    while(f[x][i]!=f[y][i]) 
    {
        tmp+=g[x][i]+g[y][i];
        x=f[x][i];
        y=f[y][i];
    }
    if(x!=y && bl[x] && bl[x]==bl[y]) tmp+=min(min(c1[x]+c2[y],c1[y]+c2[x]),min(abs(c2[x]-c2[y]),abs(c1[x]-c1[y])));
    else tmp+=g[x][0]+g[y][0];
    return tmp;
}
int main()
{
    int n,m,q;
    cin>>n>>m>>q;
    fo(i,1,m)
    {
        int x,y,t;
        scanf("%d %d %d",&x,&y,&t);
        link(x,y,t);
        link(y,x,t);
    }
    dfs(1);
    cxlb(1);
    find(1);
    d[0]=-1;
    fo(j,1,14)
    fo(i,1,n)
    {
        f[i][j]=f[f[i][j-1]][j-1];
        g[i][j]=g[i][j-1]+g[f[i][j-1]][j-1];
    }
    fo(i,1,q)
    {
        int x,y;
        scanf("%d %d",&x,&y);
        printf("%d\n",lca(x,y));
    }
}