HDU 4612 and 4607 （tarjan求桥+树形dp求树的直径）

HDU 4612

题意：给你一个无向图，里面有桥，问你连给它加一条边，桥变为多少

题解：很明显是先求出桥的数量，然后缩点成一棵树，然后求树的直径，答案就是桥-直径

但是这题有20W点100W边，而且有重边，我重边处理的不太好，一直不太会，特别是20W点，我都不知道如何记录，看了题解之后学了个比较屌的方法，而且可以一边求桥一边用树形dp求直径，而不需要缩点后用连通分量做，代码顿时短了很多

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")

using namespace std;
#define   MAX       200005
#define   MAXN      2000005
#define   lson      l,m,rt<<1
#define   rson      m+1,r,rt<<1|1
#define   lrt       rt<<1
#define   rrt       rt<<1|1
#define   mid       int m=(r+l)>>1
#define   LL        long long
#define   ull       unsigned long long
#define   mem0(x)   memset(x,0,sizeof(x))
#define   mem1(x)   memset(x,-1,sizeof(x))
#define   meminf(x) memset(x,INF,sizeof(x))
#define   lowbit(x) (x&-x)

const LL     mod   = 1000000;
const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const int    INFF  = 1e9;
const double pi    = 3.141592653589793;
const double inf   = 1e18;
const double eps   = 1e-10;

struct Edge{
    int v,next;
}edge[MAXN];
int head[MAX];
int dfn[MAX];
int low[MAX];
int vis[MAXN];
int dp[MAX][2];//0存的是点u往下的最长路径，1存的是u往下的次长路径
int tot;
int Index;
int bridge;

void init(){
    mem1(head);
    mem0(dfn);
    mem0(low);
    mem0(vis);
    tot=0;
    Index=0;
    bridge=0;
}

void add_edge(int a,int b){
    edge[tot].v=b;
    edge[tot].next=head[a];
    head[a]=tot++;
}

void tarjan(int u){
    dfn[u]=low[u]=++Index;
    dp[u][0]=dp[u][1]=0;
    for(int i=head[u];i!=-1;i=edge[i].next){
        if(!vis[i>>1]){
            vis[i>>1]=1;
            int v=edge[i].v;
            if(!dfn[v]){
                tarjan(v);
                int temp=dp[v][0];//树形dp
                if(dfn[u]<low[v]){
                    bridge++;
                    temp++;//是否在同一个连通块里
                }
                if(temp>dp[u][0]){
                    dp[u][1]=dp[u][0];
                    dp[u][0]=temp;
                }
                else if(dp[u][1]<temp) dp[u][1]=temp;
                low[u]=min(low[v],low[u]);
            }
            else low[u]=min(dfn[v],low[u]);
        }
    }
}
int main(){
    int n,m;
    while(scanf("%d%d",&n,&m)&&n&&m){
        init();
        for(int i=0;i<m;i++){
            int a,b;
            scanf("%d%d",&a,&b);
            add_edge(a,b);
            add_edge(b,a);
        }
        tarjan(1);
        int ans=0;
        for(int i=1;i<=n;i++){
            ans=max(ans,dp[i][0]+dp[i][1]);
        }
        printf("%d\n",bridge-ans);
    }
    return 0;
}

hdu 4607

题意：这题给你一棵树，然后要游玩k个点，问你最少走多少距离

题解：这题很明显是和树的直径有关，但是我比较虚，k>直径时怎么弄有点犯二

现在想想挺简单的，比如a,b是直径的起点终点，然后k>直径上的点，那么就从a开始走，走到一个节点，就往不和直径重合的路径上走，直径上有d个点，那么要走的不在直径上的点就有k-d个，那么从a，b之间一些节点去绕路走这k-d个点，最少需要走2*（k-d）的距离（想上去还是挺明显的），然后直径长度d-1。

所以结论是k<=d ,ans=k-1

                    k>d,  ans=d-1+2*(k-d);

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")

using namespace std;
#define   MAX       200005
#define   MAXN      2000005
#define   lson      l,m,rt<<1
#define   rson      m+1,r,rt<<1|1
#define   lrt       rt<<1
#define   rrt       rt<<1|1
#define   mid       int m=(r+l)>>1
#define   LL        long long
#define   ull       unsigned long long
#define   mem0(x)   memset(x,0,sizeof(x))
#define   mem1(x)   memset(x,-1,sizeof(x))
#define   meminf(x) memset(x,INF,sizeof(x))
#define   lowbit(x) (x&-x)

const LL     mod   = 1000000;
const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const int    INFF  = 1e9;
const double pi    = 3.141592653589793;
const double inf   = 1e18;
const double eps   = 1e-10;

struct Edge{
    int v,next;
}edge[MAXN];
int head[MAX];
int dp[MAX][2];
int vis[MAX];
int tot;
int d;

void init(){
    mem1(head);
    mem0(vis);
    tot=0;
    d=0;
}

void add_edge(int a,int b){
    edge[tot].v=b;
    edge[tot].next=head[a];
    head[a]=tot++;
}

void tree_dp(int u){//树形dp
    vis[u]=1;
    dp[u][0]=dp[u][1]=0;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].v;
        if(!vis[v]){
            tree_dp(v);
            int temp=dp[v][0]+1;
            if(temp>dp[u][0]){
                dp[u][1]=dp[u][0];
                dp[u][0]=temp;
            }
            else if(temp>dp[u][1]) dp[u][1]=temp;
        }
    }
    d=max(d,dp[u][0]+dp[u][1]);
}

int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        init();
        int n,m;
        scanf("%d%d",&n,&m);
        for(int i=0;i<n-1;i++){
            int a,b;
            scanf("%d%d",&a,&b);
            add_edge(a,b);
            add_edge(b,a);
        }
        tree_dp(1);
        d++;
        while(m--){
            int k;
            scanf("%d",&k);
            if(k<=d) printf("%d\n",k-1);
            else printf("%d\n",d-1+2*(k-d));
        }
    }
    return 0;
}