HDU 5452 LCA

点击打开链接

题意：给一个树和树上的分支组成的图，问我当且仅当删除一条树上的边，最少再删除几条边使得图不连通

思路：我写了两个做法，第一种是不加优化的十分暴力的LCA，也就是裸的，因为这道题目的数据说很水，这样的复杂度也可以，O(n*m)，n为20000，m为200000，明明是超时好不好，这个做法也简单易懂，在这个树上，我们加了一条边u->v，那么u与v的最近公共祖先为fa，那么u->fa与fa->v上的所有边在删除时都需要在多删除u->v这条边，不懂的画个图就行了，然后可以用点代替边，因为这是颗树嘛，对于每个点来说，它只可能有一个父亲，所以我们用这个点就可以代替它父亲到它这条边，然后找出最小值就行了，这个思路很简单，但应该是超时的

#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3fll;
const int maxn=20010;
vector<int>G[maxn];
int f[maxn],depth[maxn],ans[maxn];
void dfs(int v,int p,int d){
    f[v]=p;depth[v]=d;
    for(unsigned int i=0;i<G[v].size();i++){
        if(G[v][i]!=p) dfs(G[v][i],v,d+1);
    }
}
int LCA(int u,int v){
    while(depth[u]>depth[v]){
        ans[u]++;
        u=f[u];
    }
    while(depth[v]>depth[u]){
        ans[v]++;
        v=f[v];
    }
    while(u!=v){
        ans[u]++;ans[v]++;
        u=f[u];
        v=f[v];
    }
    return u;
}
int main(){
    int T,n,m,cas=1,u,v;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        for(int i=0;i<maxn;i++) G[i].clear();
        for(int i=0;i<=n;i++) ans[i]=1;
        for(int i=0;i<n-1;i++){
            scanf("%d%d",&u,&v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        dfs(1,0,0);
        for(int i=0;i<m-(n-1);i++){
            scanf("%d%d",&u,&v);
            int answe=LCA(u,v);
        }
        int min1=inf;
        for(int i=2;i<=n;i++) min1=min(min1,ans[i]);
        printf("Case #%d: %d\n",cas++,min1);
    }
    return 0;
}

第二种就是基于RMQ的查询，但是这种查询就不会遍历到两个节点的父亲，但是能够高效的找到父节点，复杂度为O(m*log(n))；这样即使数据不是水数据那么我们也能够在规定时限内完成，那么问题是周这样该怎么统计每条边的个数，也就是第一种方法所记录的那个ans，我们考虑u->v这条边能够影响的边只有他们父节点到他们的边，那么我们换一种记录方法，这两个节点的ans++，然后父节点的上面的所有边都不会变，然后父节点-=2，然后再跑一遍dfs为了记录所有值起来，也可以看成是这个样子，下面的节点向上更新，正常的就正常更新，而遇到一次父节点，父节点以及它之上的所有节点的值应该是不变的，当然这是对于一对u->v来说，这样就保证了父节点到u和v的所有边加了1，上面的点没变的效果，这样统计出来的就是要删除的边的数量，+1是要加上树上的一条边

#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int maxn=40010;
vector<int>G[maxn];
int dp[maxn*2][20],L[maxn*2],E[maxn*2],H[maxn],ans[maxn];//E为编号
bool vis[maxn];
int n,k;
void dfs(int t,int deep){
    k++;E[k]=t;L[k]=deep;H[t]=k;
    for(unsigned int i=0;i<G[t].size();i++){
        int e=G[t][i];
        if(!vis[e]){
            vis[e]=1;
            dfs(e,deep+1);
            k++;E[k]=t;L[k]=deep;
        }
    }
}
void RMQ_init(){
    for(int i=1;i<=2*n-1;i++) dp[i][0]=i;
    for(int i=1;(1<<i)<=2*n-1;i++){
        for(int j=1;j+(1<<i)-1<=2*n-1;j++){
            if(L[dp[j][i-1]]<L[dp[j+(1<<(i-1))][i-1]]) dp[j][i]=dp[j][i-1];
            else dp[j][i]=dp[j+(1<<(i-1))][i-1];
        }
    }
}
int RMQ(int le,int ri){
    le=H[le];ri=H[ri];
    if(le>ri) swap(le,ri);
    int kk=0;
    while((1<<(kk+1))<=ri-le+1) kk++;
    if(L[dp[le][kk]]<L[dp[ri-(1<<kk)+1][kk]]) return E[dp[le][kk]];
    else return E[dp[ri-(1<<kk)+1][kk]];
}
void rdfs(int u,int fa){
    for(unsigned int i=0;i<G[u].size();i++){
        int v=G[u][i];
        if(v==fa) continue;
        rdfs(v,u);
        ans[u]+=ans[v];
    }
}
int main(){
    int T,m,u,v,cas=1;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        memset(vis,0,sizeof(vis));
        memset(ans,0,sizeof(ans));
        for(int i=0;i<maxn;i++) G[i].clear();
        for(int i=0;i<n-1;i++){
            scanf("%d%d",&u,&v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        k=0;vis[1]=1;
        dfs(1,1);RMQ_init();
        for(int i=0;i<m-(n-1);i++){
            scanf("%d%d",&u,&v);
            ans[u]++;ans[v]++;
            int t=RMQ(u,v);
            ans[t]-=2;
        }
        rdfs(1,0);
        int min1=inf;
        for(int i=2;i<=n;i++) min1=min(min1,ans[i]+1);
        printf("Case #%d: %d\n",cas++,min1);
    }
    return 0;
}