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 =  << ;

     static char buf[siz];
     static char *hd = buf + siz;
     static char *tl = buf + siz;

     if (hd == tl)
         fread(hd = buf, , siz, stdin);

     return int(*hd++);
 }

 inline int nextInt(void)
 {
     int r = , c = nextChar();

     for (; c < ; c = nextChar());
     for (; c > ; c = nextChar())
         r = r *  + c - '';

     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 <  ? -x : x;
 }

 const int mxn = ;
 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,   , sizeof vis);
     memset(dis, inf, sizeof dis);

     int lt = , rt = ;

     que[rt++] = ;
     vis[] = ;
     dis[] = ;

     while (lt != rt)
     {
         int u = que[lt++], v;

         if (lt > mxn)lt = ;

         vis[u] = ;

         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] = ;

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

 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][];

 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][] = u;
         if (y != u)bel[y] = cnt, fat[y][] = 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][] = 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] + , build(to[i]);
 }

 inline void prework(void)
 {
     spfa();

     tarjan(, );

     for (int i = ; i <= ; ++i)
         for (int j = ; j <= n; ++j)
             fat[j][i] = fat[fat[j][i - ]][i - ];

     memset(hd, -, sizeof hd), tot = ;

     for (int i = ; i <= n; ++i)
         add(fat[i][], i, );

     dep[] = , build();
 }

 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 = ; ~i; --i)
         if (dep[fat[a][i]] >= dep[b])
             a = fat[a][i];

     if (a == b)
         return x = y = a, ret - dis[a] * ;

     for (int i = ; ~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][]] * ;
 }

 signed main(void)
 {
     n = nextInt();
     m = nextInt();
     q = nextInt();

     memset(hd, -, sizeof(hd)), tot = ;

     for (int i = ; i <= m; ++i)
     {
         int x = nextInt();
         int y = nextInt();
         int w = nextInt();

         add(x, y, w);
         add(y, x, w);
     }

     prework();

     for (int i = , 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\n", ans);
     }
 }

@Author: YouSiki