BZOJ1912 || 洛谷P3629 [APIO2010]巡逻【树的直径】

Time Limit: 4 Sec
Memory Limit: 64 MB

Description

Input

第一行包含两个整数 n, K(1 ≤ K ≤ 2)。接下来 n – 1行，每行两个整数 a, b， 表示村庄a与b之间有一条道路(1 ≤ a, b ≤ n)。

Output

输出一个整数，表示新建了K 条道路后能达到的最小巡逻距离。

HINT

10%的数据中，n ≤ 1000, K = 1；
30%的数据中，K = 1；
80%的数据中，每个村庄相邻的村庄数不超过 25；
90%的数据中，每个村庄相邻的村庄数不超过 150；
100%的数据中，3 ≤ n ≤ 100,000, 1 ≤ K ≤ 2。

---

题目分析

若k==1
不难想到最优方案一定是连接树的直径的两个端点
最后距离就是$(n-1)\ast 2-d+1$

那么k==2的情况呢
这种情况下第一条路还是连接直径的两个端点
第二条路就应该连接树上次长链的两个端点

这条次长链有两种情况
1.与第一条路连接后形成的环重叠
2.不与第一条路连接后形成的环重叠

如果是第二种情况，再次减去次长链长度即可
而如果是第一种情况
显然新建道路后又要重新走一遍重叠的部分，即还要再加回来
为了将重复走的这段路表示为减少的长度
我们可以把树的直径经过的边权变成-1
这样求第二条路的时候若和其重合，则减减得加
最后距离为$(n-1)\ast 2-d1+1-d2+1=n\ast 2-d1-d2$

---

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
typedef long long lt;
 
int read()
{
    int f=1,x=0;
    char ss=getchar();
    while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
    while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
    return f*x;
}
 
const int maxn=100010;
int n,k;
struct node{int v,dis,nxt;}E[maxn<<2];
int head[maxn],tot=1;
int dp[maxn],rem[maxn];
int mxlen[2],p,q;
 
void add(int u,int v,int dis)
{
    E[++tot].nxt=head[u];
    E[tot].v=v; E[tot].dis=dis;
    head[u]=tot;
}
 
void dfs1(int u,int pa)
{
    rem[u]=u; dp[u]=0;
    for(int i=head[u];i;i=E[i].nxt)
    {
        int v=E[i].v;
        if(v==pa) continue;
        dfs1(v,u);
        if(dp[u]<=dp[v]+E[i].dis)
        dp[u]=dp[v]+E[i].dis,rem[u]=rem[v];
    }
}
 
void DP(int u,int pa)
{
    dp[u]=0;
    for(int i=head[u];i;i=E[i].nxt)
    {
        int v=E[i].v;
        if(v==pa) continue;
        DP(v,u);
        mxlen[1]=max(mxlen[1],dp[u]+dp[v]+E[i].dis);
        dp[u]=max(dp[u],dp[v]+E[i].dis);
    }
}
 
void dfs2(int u,int pa)
{
    if(u==q) return;
    for(int i=head[u];i;i=E[i].nxt)
    {
        int v=E[i].v;
        if(v==pa) continue;
        if(rem[v]==q) 
        {
            mxlen[0]+=E[i].dis; E[i].dis=-1;
            if(u<v) E[i+1].dis=-1; else E[i-1].dis=-1;
            dfs2(v,u); break;
        }
    }
}
 
int main()
{
    n=read();k=read();
    for(int i=1;i<n;++i)
    {
        int u=read(),v=read();
        if(u>v) swap(u,v);
        add(u,v,1); add(v,u,1);
    }
    dfs1(1,0); p=rem[1];//dfs法以便得知具体节点信息
    dfs1(p,0); q=rem[p];
     
    if(k==1) printf("%d",(n-1)*2-dp[p]+1);
    else if(k==2)
    {
        dfs2(p,0); DP(1,0);//第二次求得时候有负边权，只能用DP法
        printf("%d",n*2-mxlen[0]-mxlen[1]);
    }
     
    return 0;
}