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;

}