BZOJ 2125: 最短路

2125: 最短路

Time Limit: 1 Sec  Memory Limit: 259 MB
Submit: 756  Solved: 331
[Submit][Status][Discuss]

Description

给一个N个点M条边的连通无向图，满足每条边最多属于一个环，有Q组询问，每次询问两点之间的最短路径。

Input

输入的第一行包含三个整数，分别表示N和M和Q 下接M行，每行三个整数v，u，w表示一条无向边v-u，长度为w 最后Q行，每行两个整数v，u表示一组询问

Output

输出Q行，每行一个整数表示询问的答案

Sample Input

9 10 2
1 2 1
1 4 1
3 4 1
2 3 1
3 7 1
7 8 2
7 9 2
1 5 3
1 6 4
5 6 1
1 9
5 7

Sample Output

5
6

HINT

对于100%的数据，N<=10000，Q<=10000

Source

 

[Submit][Status][Discuss]

#include <cstdio>
#include <cstring>

inline int nextChar(void)
{
    static const int siz = 1 << 20;
    
    static char buf[siz];
    static char *hd = buf + siz;
    static char *tl = buf + siz;
    
    if (hd == tl)
        fread(hd = buf, 1, siz, stdin);
        
    return int(*hd++);
}

inline int nextInt(void)
{
    int r = 0, c = nextChar();
    
    for (; c < 48; c = nextChar());
    for (; c > 47; c = nextChar())
        r = r * 10 + c - '0';
    
    return r;
}

template <class T>
inline T min(const T &a, const T &b)
{
    return a < b ? a : b;
}

template <class T>
inline T abs(const T &x)
{
    return x < 0 ? -x : x;
}

const int mxn = 500005;
const int inf = 0x3f3f3f3f;

int n, m, q;

int tot;
int hd[mxn];
int to[mxn];
int vl[mxn];
int nt[mxn];

inline void add(int x, int y, int w)
{
    nt[tot] = hd[x];
    to[tot] = y;
    vl[tot] = w;
    hd[x] = tot++;
}

int dis[mxn];
int que[mxn];
int vis[mxn];

inline void spfa(void)
{
    memset(vis,   0, sizeof vis);
    memset(dis, inf, sizeof dis);
    
    int lt = 0, rt = 0;
    
    que[rt++] = 1;
    vis[1] = 1;
    dis[1] = 0;
    
    while (lt != rt)
    {
        int u = que[lt++], v;

        if (lt > mxn)lt = 0;
        
        vis[u] = 0;
        
        for (int i = hd[u]; ~i; i = nt[i])
            if (v = to[i], dis[v] > dis[u] + vl[i])
            {
                dis[v] = dis[u] + vl[i];
                
                if (!vis[v])
                {
                    vis[que[rt++] = v] = 1;

                    if (rt > mxn)rt = 0;
                }
            }
    }
}

struct data
{
    int u, v, w;
    
    inline data(void) {};
    inline data(int a, int b, int c)
        : u(a), v(b), w(c) {};
}stk[mxn]; int top;

int tim;
int dfn[mxn];
int low[mxn];

int cnt;
int cir[mxn];
int len[mxn];
int bel[mxn];
int fat[mxn][25];

inline void addcir(int u, int v)
{
    ++cnt;
    
    while (u != stk[top].u && v != stk[top].v)
    {
        int x = stk[top].u, y = stk[top].v, w = stk[top].w;
        
        if (x != u)bel[x] = cnt, fat[x][0] = u;
        if (y != u)bel[y] = cnt, fat[y][0] = u;
        
        len[cnt] += w, cir[x] = cir[y] + w;
        
        --top;
    }
    
    {
        int x = stk[top].u, y = stk[top].v, w = stk[top].w;
        
        len[cnt] += w, cir[x] = cir[y] + w;
        
        fat[y][0] = x;
        
        --top;
    }
}

void tarjan(int u, int f)
{
    dfn[u] = low[u] = ++tim;
    
    for (int i = hd[u], v; ~i; i = nt[i])
        if ((v = to[i]) != f)
        {
            if (!dfn[v])
            {
                stk[++top] = data(u, v, vl[i]), tarjan(v, u);
                
                if (low[v] < low[u])low[u] = low[v];
                
                if (low[v] >= dfn[u])addcir(u, v);
            }
            else if (dfn[v] < low[u])
                low[u] = dfn[v], stk[++top] = data(u, v, vl[i]);    
        }
}

int dep[mxn];

void build(int u)
{
    for (int i = hd[u]; ~i; i = nt[i])
        dep[to[i]] = dep[u] + 1, build(to[i]);
}

inline void prework(void)
{
    spfa();
    
    tarjan(1, 0);
    
    for (int i = 1; i <= 20; ++i)
        for (int j = 1; j <= n; ++j)
            fat[j][i] = fat[fat[j][i - 1]][i - 1];
    
    memset(hd, -1, sizeof hd), tot = 0;
    
    for (int i = 2; i <= n; ++i)
        add(fat[i][0], i, 0);
    
    dep[1] = 1, build(1);
}

inline int getLCA(int a, int b, int &x, int &y)
{
    if (dep[a] < dep[b])
        a ^= b ^= a ^= b;
    
    int ret = dis[a] + dis[b];
    
    for (int i = 20; ~i; --i)
        if (dep[fat[a][i]] >= dep[b])
            a = fat[a][i];
    
    if (a == b)
        return x = y = a, ret - dis[a] * 2;
    
    for (int i = 20; ~i; --i)
        if (fat[a][i] != fat[b][i])
            a = fat[a][i],
            b = fat[b][i];
    
    return x = a, y = b, ret - dis[fat[a][0]] * 2;
}

signed main(void)
{
    n = nextInt();
    m = nextInt();
    q = nextInt();
    
    memset(hd, -1, sizeof(hd)), tot = 0;
    
    for (int i = 1; i <= m; ++i)
    {
        int x = nextInt();
        int y = nextInt();
        int w = nextInt();
        
        add(x, y, w);
        add(y, x, w);
    }
    
    prework();
    
    for (int i = 1, x, y; i <= q; ++i)
    {
        int a = nextInt();
        int b = nextInt();
        
        int ans = getLCA(a, b, x, y);
        
        if (bel[x] && bel[x] == bel[y])
        {
            ans = dis[a] + dis[b] - dis[x] - dis[y];
            
            int len1 = abs(cir[x] - cir[y]);
            int len2 = len[bel[x]] - len1;
            
            ans += min(len1, len2);
        }
        
        printf("%d
", ans);
    }
}

@Author: YouSiki