洛谷3629[APIO2010]巡逻（树的直径）

题目

洛谷3629 [APIO2010]巡逻

题解

树的直径

当k=0时，ans=2*(n-1)。

当k=1时，显然连接树的直径两端是最优的。
当连接两个点x，y时，x-y之间的路径就只被算了一次，ans=2(n-1)-l+1，其中l为树的直径。

当k=2时，如果连接的部分没有关联，那ans=2(n-1)-l1+1-l2+1，其中l1，l2为树的直径。
如果有相交部分，那么相交部分从原来的走一次又退化成了走两次。因为新建的路必须走一次，所以这部分的路变成了没人巡逻！又得花两倍路长来巡逻。
总结上面的情况，我们得到这样一个算法：
1、先求一遍树的直径l1；
2、把树的直径上的点权值从1变为-1，表示选择这段又会增加1的时间；
3、再在新树上求一遍树的直径l2；
4、ans=2*(n-1)-l1+1-l2+1。

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=1e5+10;

int n,k;
int l1,l2;

struct E{int y,c,next;}e[maxn*2];int len=1,last[maxn];
void ins(int x,int y,int c)
{
    e[++len]=(E){y,1,last[x]};last[x]=len;
}

int vis[maxn];int T=0;
int son[maxn],d[maxn];
void dfs(int x)
{
    vis[x]=T;
    d[x]=0;son[x]=x;
    for(int k=last[x];k;k=e[k].next)
    {
        int y=e[k].y;
        if(vis[y]==T) continue;
        dfs(y);
        if(d[y]+e[k].c>d[x])
        {
            d[x]=d[y]+1;
            son[x]=son[y];
        }
    }
}

bool change(int x,int E)
{
    vis[x]=T;
    for(int k=last[x];k;k=e[k].next)
    {
        int y=e[k].y;
        if(vis[y]==T) continue;
        if(y==E)
        {
            e[k].c=e[k^1].c=-1;
            return true;
        }
        if(change(y,E))
        {
            e[k].c=e[k^1].c=-1;
            return true;
        }
    }
    return false;
}

int find()
{
    T++;
    dfs(1);int s=son[1];
    T++;
    dfs(s);int e=son[s];
    T++;
    change(s,e);
    return d[s];
}

void dp(int x)
{
    vis[x]=T;
    d[x]=0;
    for(int k=last[x];k;k=e[k].next)
    {
        int y=e[k].y;
        if(vis[y]==T) continue;
        dp(y);
        l2=max(l2,d[x]+d[y]+e[k].c);
        d[x]=max(d[x],d[y]+e[k].c);
    }
}

int main()
{
    scanf("%d%d",&n,&k);
    for(int i=1;i<n;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        ins(x,y,1);ins(y,x,1);
    }
    l1=find();
    if(k==1)
    {
        printf("%d\n",2*(n-1)-l1+1);
        return 0;
    }
    T++;
    dp(1);
    printf("%d\n",2*(n-1)-l1+1-l2+1);
    return 0;
}