HDU 5452 LCA

HDU 5452

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=5452

题意：

给一个无向图G。

指定无向图的一棵生成树T。现要求删除最少的边使得无向图不连通，要求T上删除且只能删除一条边。输出删除的最少边数。

思路：

比赛的时候套最小割版、套网络流版、最小生成树版、连通分量版……

你知道这是套不出来的。

实际上，发现最后删边，必须要删除T上的一条边。然后问题就转化成了，把T中一条边删除后，形成两个连通子图G1和G2，G1和G2之间相连的边去掉就行。

问题转化成怎么统计G1和G2的相连边。

发现对于一条边E，连接的两个端点u，v。只有当u和v属于不同连通子图时，E需要加入到答案中。所以假设dp[u]为以u为根的子图，则dp[u]++,dp[v]++,dp[LCA(u,v)]-=2;

 

最近公公祖先有三种求法。

一、并查集的暴力写法，但是遇到极限数据过不了。

二、tarjan的离线处理。记录每个点的询问，按照dfs顺序遍历树。如果遍历到的当前节点为u，有边E相连且连接点为v，当v已经访问过时，他们的LCA = ancestor[find_fa(v)]

三、RMQ的在线处理。按照带回溯的深搜产生一个数组B，长度为结点数n*2-1。记录每个点第一次出现的下标R。对于点u、v的LCA，即在B数组中R[u]~R[v]范围内深度最小的点。

源码：

#include <cstdio>

#include <cstring>

#include <cstdlib>

#include <cmath>

#include <algorithm>

#include <iostream>

#include <string>

#include <queue>

using namespace std;

#define gmin(a,b) ((a) < (b) ? (a) : (b))

const int MAXN = 20000 + 5;

const int MAXM = 200000 * 2 + 5;

vector<int>lin[MAXN];

int B[MAXN * 2], cnt, R[MAXN], rmq[MAXM][30];

int deep[MAXN], dp[MAXN];

int n, m;

int MIN(int a, int b)

{

    if(deep[a] < deep[b])   return a;

    return b;

}

int vis[MAXN];

void build_tree(int u, int p)

{

//    printf("u = %d, p = %d\n", u, p);

    vis[u] = 1;

    R[u] = cnt, deep[u] = deep[p] + 1;

    B[cnt++] = u;

    for(int i = 0 ; i < (int)lin[u].size() ; i++){

        int v = lin[u][i];

        if(vis[v] == 0){

            build_tree(v, u);

            B[cnt++] = u;

        }

    }

}

void RMQ()

{

    for(int i = 0 ; i < cnt ; i++)

        rmq[i][0] = B[i];

    for(int j = 1 ; (1 << j) <= cnt ; j++){

        for(int i = 0 ; (i + (1 << j) - 1) < cnt ; i++){

            rmq[i][j] = MIN(rmq[i][j - 1], rmq[i + (1 << j) - (1 << (j - 1))][j - 1]);

        }

    }

}

int query(int L, int Re)

{

    int k = 0;

    while((1 << (k + 1)) <= Re - L + 1)  k++;

//    printf("k = %d, first = %d, second = %d\n", k, L, R - (1 << k) + 1);

//    printf("rmq1 = %d, rmq2 = %d\n", rmq[L][k], rmq[R - (1 << k) + 1][k]);

    return MIN(rmq[L][k], rmq[Re - (1 << k) + 1][k]);

}

void dfs(int u, int p)

{

    for(int i = 0 ; i < (int)lin[u].size() ; i++){

        int v = lin[u][i];

        if(v == p)  continue;

        dfs(v, u);

        dp[u] += dp[v];

    }

}

int main()

{

//    freopen("1003.in", "r", stdin);

    int t;

    scanf("%d", &t);

    for(int cas = 1 ; cas <= t ; cas++){

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

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

            lin[i].clear();

        int u, v;

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

            scanf("%d%d", &u, &v);

            lin[u].push_back(v);    lin[v].push_back(u);

        }

        cnt = 0;

        memset(vis, 0, sizeof(vis));

        memset(deep, 0, sizeof(deep));

        memset(R, -1, sizeof(R));

        memset(dp, 0, sizeof(dp));

        memset(rmq, -1, sizeof(rmq));

        build_tree(1, 0);

        RMQ();

//        printf("B\n");

//        for(int i = 0 ; i < cnt ; i++)

//            printf("%d ", B[i]);

//        printf("\n");

//        for(int i = 1 ; i <= n ; i++)

//            printf("deep[i] = %d\n", i, deep[i]);

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

            scanf("%d%d", &u, &v);

//            printf("R[u] = %d, R[v] = %d\n", R[u], R[v]);

            if(R[u] > R[v])

                swap(u, v);

            int temp = query(R[u], R[v]);

//            temp = B[temp];

//            printf("u = %d, v = %d, temp = %d\n", u, v, temp);

            dp[u]++;

            dp[v]++;

            dp[temp] -= 2;

        }

        dfs(1, -1);

        int ans = 2 * m + 1;

//        for(int i = 1 ; i <= n ; i++)

//            printf("dp[%d] = %d\n", i, dp[i]);

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

            ans = min(ans, dp[i] + 1);

        printf("Case #%d: %d\n", cas, ans);

    }

    return 0;

}