P1967 货车运输树链剖分

题目描述

AA国有nn座城市，编号从 11到nn，城市之间有 mm 条双向道路。每一条道路对车辆都有重量限制，简称限重。现在有 qq 辆货车在运输货物，司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。

输入输出格式

输入格式：

第一行有两个用一个空格隔开的整数n,mn,m，表示 AA 国有nn 座城市和 mm 条道路。

接下来 mm行每行33个整数 x, y, zx,y,z，每两个整数之间用一个空格隔开，表示从 xx号城市到yy号城市有一条限重为 zz 的道路。注意： xx 不等于 yy，两座城市之间可能有多条道路。

接下来一行有一个整数 q，表示有 q 辆货车需要运货。

接下来 q 行，每行两个整数 x、y，之间用一个空格隔开，表示一辆货车需要从 x 城市运输货物到 y 城市，注意： x 不等于 y 。

输出格式：

共有 qq 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。如果货车不能到达目的地，输出-1−1。

输入输出样例

输入样例#1：复制

输出样例#1：复制

说明

对于 30\%30%的数据，0 < n < 1,000,0 < m < 10,000,0 < q< 1,0000<n<1,000,0<m<10,000,0<q<1,000；

对于 60\%60%的数据，0 < n < 1,000,0 < m < 50,000,0 < q< 1,0000<n<1,000,0<m<50,000,0<q<1,000；

对于 100\%100%的数据，0 < n < 10,000,0 < m < 50,000,0 < q< 30,000,0 ≤ z ≤ 100,0000<n<10,000,0<m<50,000,0<q<30,000,0≤z≤100,000。

冷静思考这就是求一个最大生成树然后在这一颗树上面求路径最短

然后我就被坑了发现其实并不一定是联通总是不能全过

后面加了这个才过的

for ( int i = 1 ; i <= n ; i++ ) {
if ( id[i] ) continue;
dfs1 ( i, 0, 1 );
dfs2 ( i, i );
}

 #include <cstdio>

 #include <cstring>

 #include <queue>

 #include <cmath>

 #include <algorithm>

 #include <set>

 #include <iostream>

 #include <map>

 #include <stack>

 #include <string>

 #include <vector>

 #define  pi acos(-1.0)

 #define  eps 1e-6

 #define  fi first

 #define  se second

 #define  lson l,mid,rt<<1

 #define  rson mid+1,r,rt<<1|1

 #define  rtl   rt<<1

 #define  rtr   rt<<1|1

 #define  mid   ((l+r)>>1)

 #define  bug         printf("******\n")

 #define  mem(a,b)    memset(a,b,sizeof(a))

 #define  name2str(x) #x

 #define  fuck(x)     cout<<#x" = "<<x<<endl

 #define  f(a)        a*a

 #define  sf(n)       scanf("%d", &n)

 #define  sff(a,b)    scanf("%d %d", &a, &b)

 #define  sfff(a,b,c) scanf("%d %d %d", &a, &b, &c)

 #define  sffff(a,b,c,d) scanf("%d %d %d %d", &a, &b, &c, &d)

 #define  pf          prLLf

 #define  FRE(i,a,b)  for(i = a; i <= b; i++)

 #define  FREE(i,a,b) for(i = a; i >= b; i--)

 #define  FRL(i,a,b)  for(i = a; i < b; i++)

 #define  FRLL(i,a,b) for(i = a; i > b; i--)

 #define  FIN         freopen("in.txt","r",stdin)

 #define  gcd(a,b)    __gcd(a,b)

 #define  lowbit(x)   x&-x

 #pragma comment(linker, "/STACK:1024000000,1024000000")

 using namespace std;

 typedef long long  LL;

 typedef unsigned long long ULL;

 const int mod = 1e9 + ;

 const int maxn = 5e4;

 const int INF = 0x7fffffff;

 const LL INFLL = 0x3f3f3f3f3f3f3f3fLL;

 int n, m, tot, head[maxn];

 int tree[maxn << ], w1[maxn], rk[maxn];

 int son[maxn], id[maxn], fa[maxn], dep[maxn], sz[maxn], top[maxn], cnt;

 int father[maxn];

 struct Edge {

     int v, nxt, w;

 } edge[maxn];

 void init() {

     tot = cnt = ;

     mem ( head, - );

     mem ( son, - );

 }

 void add ( int u, int v, int w ) {

     edge[tot].v = v;

     edge[tot].w = w;

     edge[tot].nxt = head[u];

     head[u] = tot++;

 }

 void dfs1 ( int u, int f, int deep ) {

     dep[u] = deep;

     fa[u] = f;

     sz[u] = ;

     for ( int i = head[u]; ~i; i = edge[i].nxt ) {

         int v = edge[i].v;

         if ( v == f ) continue;

         w1[v] = edge[i].w;

         dfs1 ( v, u, deep +  );

         sz[u] += sz[v];

         if ( sz[son[u]] < sz[v] ) son[u] = v;

     }

 }

 void dfs2 ( int x, int topf ) {

     id[x] = ++cnt;

     rk[cnt] = x;

     top[x] = topf ;

     if ( son[x] == - ) return;

     dfs2 ( son[x], topf );

     for ( int i = head[x]; ~i; i = edge[i].nxt ) {

         int y = edge[i].v;

         if ( y == fa[x] || y == son[x] ) continue;

         dfs2 ( y, y );

     }

 }

 void build ( int l, int r, int rt ) {

     if ( l == r ) {

         tree[rt] = w1[rk[l]];

         return ;

     }

     build ( lson );

     build ( rson );

     tree[rt] = min ( tree[rtl], tree[rtr] );

 }

 int quary ( int L, int R, int l, int r, int rt ) {

     int ans = INF;

     if ( L <= l && r <= R ) return tree[rt];

     if ( L <= mid ) ans = min ( ans, quary ( L, R, lson ) );

     if ( R > mid )  ans = min ( ans, quary ( L, R, rson ) );

     return ans;

 }

 int qrange ( int x, int y ) {

     int ans = INF;

     while ( top[x] != top[y] ) {

         if ( dep[top[x]] < dep[top[y]] ) swap ( x, y );

         ans = min ( ans, quary ( id[top[x]], id[x], , n,  ) ) ;

         x = fa[top[x]];

     }

     if ( x != y ) {

         if ( dep[x] > dep[y] ) swap ( x, y );

         ans = min ( ans, quary ( id[x] + , id[y], , n,  ) ) ;

     }

     return ans ;

 }

 struct node {

     int u, v, w;

 } qu[maxn];

 int cmp ( node a, node b ) {

     return a.w > b.w;

 }

 int Find ( int x ) {

     return father[x] == x ? x : father[x] = Find ( father[x] );

 }

 int combine ( int x, int y ) {

     int nx = Find ( x ), ny = Find ( y );

     if ( nx != ny ) {

         father[ny] = nx;

         return ;

     }

     return ;

 }

 void krucal() {

     int k = ;

     for ( int i =  ; i < m ; i++ ) {

         if ( combine ( qu[i].u, qu[i].v ) ) {

             k++;

             add ( qu[i].u, qu[i].v, qu[i].w );

             add ( qu[i].v, qu[i].u, qu[i].w );

             if ( k == n -  ) break;

         }

     }

 }

 int main() {

     scanf ( "%d%d", &n, &m );

     init();

     for ( int i =  ; i < m ; i++ ) scanf ( "%d%d%d", &qu[i].u, &qu[i].v, &qu[i].w );

     for ( int i =  ; i <= n ; i++  ) father[i] = i;

     sort ( qu, qu + m, cmp );

     krucal();

     for ( int i =  ; i <= n ; i++ ) {

         if ( id[i] ) continue;

         dfs1 ( i, ,  );

         dfs2 ( i, i );

     }

     build ( , n,  );

     int q;

     scanf ( "%d", &q );

     while ( q-- ) {

         int x, y;

         scanf ( "%d%d", &x, &y );

         if ( Find ( x ) == Find ( y ) ) printf ( "%d\n", qrange ( x, y ) );

         else printf ( "-1\n" );

     }

     return ;

 }