题意：有一张无向图，一些点之间有有权边，某条路径的值等于路径上所有边的边权的最大值，而某个点对的值为这两点间所有路径的值的最小值，给出多个询问，每个询问有一个值，询问有多少点对满足其值小于等于询问值。点的顺序不同算作不同点对。
这题的做法很类似Kruskal算法。一开始所有的点都为一个并查集，从权值最小的边开始，当加入这条边的时候，这条边连接的两个点（并查集）之间相互到达的路径中，值最小的一个路径一定就是通过这条边的，所以这两点间的值就是这条边的权值。之后每加入一条最小边，如果可以用来合并两个并查集，那么这两个并查集中的点相互到达的值一定是这条边的边权，因为我们取出的是边权最小的一条边，之前边权更小的边并没有使这两个并查集连通，而剩余边的话边权又比当前的边的边权大，因此得证，所以符合这个值的答案数就会加上这两个并查集的点数的乘积的两倍。这样这题就能够解决了。首先将边按权值、询问按询问值排序，再通过边合并并查集，合并过程中顺便将符合当前边权的询问赋值，这样就能离线处理出所有询问了。只不过我当时做的时候因为初始化的时候写小了，导致WA了五法……
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn=;
const int maxp=;
const int maxm=1e5+; struct seg{
int a,b,v;
bool operator < (const seg a)const{
return v<a.v;
}
}s[maxm]; struct peo{
int num,v,cnt;
bool operator < (const peo a)const{
return v<a.v;
}
}p[maxp]; int n,m;
int fa[maxn],num[maxn],ans[maxp];
int nnum[]; void init(){
for(int i=;i<=n;i++){fa[i]=i;num[i]=;}
memset(ans,,sizeof(ans));
memset(p,,sizeof(p));
} int find(int x){
int r=x,t;
while(fa[r]!=r)r=fa[r];
while(x!=r){
t=fa[x];
fa[x]=r;
x=t;
}
return r;
} int main(){
int T;
scanf("%d",&T);
while(T--){
int k;
scanf("%d%d%d",&n,&m,&k);
init();
for(int i=;i<=m;++i)scanf("%d%d%d",&s[i].a,&s[i].b,&s[i].v);
int maxx=;
for(int i=;i<=k;++i){
scanf("%d",&p[i].v);
p[i].num=i;
if(p[i].v>maxx)maxx=p[i].v;
}
sort(s+,s+m+);
int pos=;
int aans=;
memset(nnum,,sizeof(nnum));
for(int i=;i<=m;++i){
int x=find(s[i].a),y=find(s[i].b);
if(x!=y){
int nx=num[x],ny=num[y];
aans+=nx*ny;
nnum[s[i].v]+=nx*ny*;
fa[x]=y;
num[y]+=num[x];
}
}
for(int i=;i<=maxx;++i)nnum[i]+=nnum[i-];
for(int i=;i<=k;++i)printf("%d\n",nnum[p[i].v]);
}
return ;
}