NOIP2013 货车运输

 

题意：给定一张地图，n个地点m条道路，每段道路有最大限重。q次询问从u到v两地之间货车载重量的最大值，如果两地不能互达输出-1
题解：我们知道，最小生成树具有瓶颈性质，不难猜出，最大生成树也具有同样的性质，即货车运输的路线一定在最大生成树上。

又因为树上两点之间的路径是唯一的，容易想到lca。要求的是该路径上限重最小的道路，显然套模板是不行的。
仿照lca的倍增算法，可以预处理点j及其上2^i个节点的最小边权，在求解lca的同时以logN的时间遍历了路径，同时更新途中最小的w，即可确定答案。
总的时间复杂度为O（NlogN）
代码也就一百行左右

#include<bits/stdc++.h>
#define inf 20200306
using namespace std;
int n,m,u,v,w,cnt,q;
int f[100005][21],wi[100005][21],head[100005],d[10005],fa[100005],vis[100005];
struct Edget{int u,v,w;}et[100005];
struct Edge{int v,next,w;}e[100005];
bool cmp(Edget a,Edget b){return a.w>b.w;}
int find(int x){return x==fa[x]?fa[x]:fa[x]=find(fa[x]);}
void add(int u,int v,int w){
    e[++cnt].v=v;
    e[cnt].w=w;
    e[cnt].next=head[u];
    head[u]=cnt;
} 

void kruskal(){
    sort(et+1,et+1+m,cmp);
    for(int i=1;i<=n;++i)fa[i]=i;
    for(int i=1;i<=m;++i){
        int u=et[i].u,v=et[i].v,w=et[i].w;;
        if(find(u)!=find(v)){
            fa[find(u)]=find(v);
            add(u,v,w);
            add(v,u,w);
        }
    }
}

void dfs(int u){
  vis[u]=1;
  for(int i=head[u];i;i=e[i].next){
    int v=e[i].v;
    if(!vis[v]){
      d[v]=d[u]+1;
      f[v][0]=u;
      wi[v][0]=e[i].w;
      dfs(v);
    }
  }
  return;
}

int lca(int x,int y){
  if(find(x)!=find(y)) return -1;
  int ans=inf;
 
  if(d[x]<d[y])swap(x,y);
  int k=d[x]-d[y];
  for(int j=20;j>=0;j--){
    if(k&(1<<j)){
      ans=min(ans,wi[x][j]);
      x=f[x][j];
    }
  }
  if(x==y)return ans;
  
  for(int j=20;j>=0;j--){
    if(f[x][j]!=f[y][j]){ 
      ans=min(ans,min(wi[x][j],wi[y][j]));
      x=f[x][j],y=f[y][j];
    }
  }
  ans=min(ans,min(wi[x][0],wi[y][0]));
  return ans;
}

int main(){
  ios::sync_with_stdio(false);
  
  cin>>n>>m;
  for(int i=1;i<=m;++i){
      cin>>u>>v>>w;
      et[i].u=u;
    et[i].v=v;
    et[i].w=w; 
    }
    
    kruskal();
  
  for(int i=1; i<=n; i++)
    if(!vis[i]){ //dfs仅收集信息 
      d[i]=1; 
      dfs(i);
      f[i][0]=i;
      wi[i][0]=inf;
   }
  
  for(int i=1; i<=20; i++)
    for(int j=1; j<=n; j++){
      f[j][i]=f[f[j][i-1]][i-1]; 
      wi[j][i]=min(wi[j][i-1], wi[f[j][i-1]][i-1]);
   }
  
  cin>>q;
  while(q--){
    cin>>u>>v;
    cout<<lca(u,v)<<endl;
  }
  return 0;
}