【[APIO2010]巡逻】

\(APIO\)的题就是非常难啊

首先看到\(k=1\)的情况，显然我们只需要找到一条直径把这条直径的两端连起来就好了

因为我们连这一条新边的实质是使得这一条链上的边不需要重复经过了，我们想让走的边尽量少，自然需要重复经过的尽量少，所以\(k=1\)找到直径就好了

答案就是\(2\times(n-1)-R+1\)，\(R\)是直径的长度，\(+1\)是因为多了一条边要走

之后是\(k=2\)的情况

有了上面的经验可能第一感受就是在找一条尽量长的路径，使得这条路径上的边只需要经过一次就好了

但是有一些边非常特殊，就是那些已经在第一次被走过的边，由于每一条边都必须被经过一次，如果有一条边在两次选择的都出现了，我们显然不能将这条边的出现次数变成\(0\)，而且这条边还得经过两次

好像这个样子不仅没有什么贡献反而使得这条边多走了一次，所以这条边实际上的边权应该是\(-1\)

所以我们把第一条路径上的所有边搞成\(-1\)就好了，之后再求一遍直径直径就好了

代码

由于这次有了负数，所以\(dfs\)求直径就挂了，只能换根\(dp\)求直径了

#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
#define LL long long
#define re register
#define maxn 100005
#define max(a,b) ((a)>(b)?(a):(b))
inline int read()
{
    char c=getchar();
    int x=0;
    while(c<'0'||c>'9') c=getchar();
    while(c>='0'&&c<='9')
        x=(x<<3)+(x<<1)+c-48,c=getchar();
    return x;
}
struct E
{
    int v,nxt,w;
}e[maxn<<1];
int head[maxn],deep[maxn],pre[maxn];
int dp[2][maxn],f[maxn],vis[maxn];
int n,m,S,num=1,R,ans;
int now,t;
inline void add_edge(int x,int y)
{
    e[++num].v=y;
    e[num].w=1;
    e[num].nxt=head[x];
    head[x]=num;
}
void up(int x)
{
    for(re int i=head[x];i;i=e[i].nxt)
    if(!deep[e[i].v])
    {
        deep[e[i].v]=deep[x]+1;
        up(e[i].v);
        if(dp[0][e[i].v]+e[i].w>dp[0][x]) dp[1][x]=dp[0][x],dp[0][x]=e[i].w+dp[0][e[i].v];
            else dp[1][x]=max(dp[0][e[i].v]+e[i].w,dp[1][x]);
    }
}
void down(int x)
{
    R=max(R,dp[0][x]+f[x]);
    R=max(R,dp[1][x]+dp[0][x]);
    for(re int i=head[x];i;i=e[i].nxt)
    if(deep[e[i].v]>deep[x])
    {
        if(dp[0][e[i].v]+e[i].w==dp[0][x]) f[e[i].v]=max(f[x],dp[1][x])+e[i].w;
            else f[e[i].v]=max(f[x],dp[0][x])+e[i].w;
        down(e[i].v);
    }
}
void dfs(int x)
{
    for(re int i=head[x];i;i=e[i].nxt)
    if(!deep[e[i].v])
    {
        deep[e[i].v]=deep[x]+1;
        dfs(e[i].v);
    }
}
void find_route(int x)
{
    if(!pre[x]) return;
    e[pre[x]].w=-1;
    e[pre[x]^1].w=-1;
    find_route(e[pre[x]^1].v);
}
void BFS()
{
    std::queue<int> q;
    q.push(now);
    vis[now]=1;
    while(!q.empty())
    {
        int k=q.front();
        q.pop();
        for(re int i=head[k];i;i=e[i].nxt)
        if(!vis[e[i].v])
        {
            pre[e[i].v]=i;
            if(e[i].v==t)
            {
                find_route(t);
                return;
            }
            vis[e[i].v]=1;
            q.push(e[i].v);
        }
    }
}
inline void get_R()
{
    now=0;
    for(re int i=1;i<=n;i++)
    if(deep[i]>deep[now]) now=i;
    memset(deep,0,sizeof(deep));
    deep[now]=1;
    dfs(now);
    t=0;
    for(re int i=1;i<=n;i++) 
        if(deep[i]>deep[t]) t=i;
    R=deep[t]-1;
    BFS();
}
int main()
{
    n=read(),S=read();
    int x,y,z;
    for(re int i=1;i<n;i++) x=read(),y=read(),add_edge(x,y),add_edge(y,x);
    deep[1]=1;
    dfs(1);
    memset(dp[1],-20,sizeof(dp[1]));
    get_R();
    if(S==1) 
    {
        printf("%d\n",2*(n-1)-R+1);
        return 0;
    }
    ans=2*(n-1)-R+1;
    R=0;
    memset(deep,0,sizeof(deep));
    deep[1]=1;
    up(1),down(1);
    printf("%d\n",ans-R+1);
    return 0;
}

转载于:https://www.cnblogs.com/asuldb/p/10205697.html