hdu 5441 离线处理+并查集

很容易想到离线处理：将边按权值从小到大排序，将询问从小到大排序，然后对于某个询问，边权值不超过该次询问的边都加上，用并查集来维护答案。

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int N = 20001;
const int M = 100000;
const int Q = 5000;
int f[N];
int r[N];
int ans[Q];
int n, m, q;

void init()
{
    for ( int i = 1; i <= n; i++ )
    {
        f[i] = i;
        r[i] = 1;
    }
}

int findf( int x )
{
    if ( f[x] != x ) f[x] = findf( f[x] );
    return f[x];
}

struct Edge
{
    int u, v, w;
    bool operator < ( const Edge & o ) const
    {
        return w < o.w;
    }
} edge[M];

struct Query
{
    int id, val;
    bool operator < ( const Query & o ) const 
    {
        return val < o.val;
    }
} query[Q];

int main ()
{
    int t;
    scanf("%d", &t);
    while ( t-- )
    {
        scanf("%d%d%d", &n, &m, &q);
        init();
        for ( int i = 0; i < m; i++ )
        {
            scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
        }
        sort( edge, edge + m );
        for ( int i = 0; i < q; i++ )
        {
            query[i].id = i;
            scanf("%d", &query[i].val);
        }
        sort( query, query + q );
        int cur = 0, cnt = 0;
        for ( int i = 0; i < q; i++ )
        {
            while ( cur < m && edge[cur].w <= query[i].val )
            {
                int u = findf( edge[cur].u ), v = findf( edge[cur].v );
                if ( u != v )
                {
                    cnt += r[u] * r[v];
                    f[u] = v;
                    r[v] += r[u];
                }
                cur++;
            }
            ans[query[i].id] = cnt << 1;
        }
        for ( int i = 0; i < q; i++ )
        {
            printf("%d
", ans[i]);
        }
    }
    return 0;
}