蓝书（算法竞赛进阶指南）刷题记录——BZOJ1912 巡逻（树的直径）

题目：BZOJ1912.
题目大意：给定一棵$n$个点的树，要求加入$k$条边（$1<=k<=2$），使得从$1$出发，恰好经过这$k$条边一次，并遍历所有点需要经过多少距离，其中一条边的距离为$1$.
$1\le k\le 2,1\le n\le 10^5$.

这道题挺考思维的，我只想到了第一条边该如何处理，没有想到第二条边可以一样处理.

显然，加一条树边就会形成一个环，然后就可以让这个环只需要每条边走一次即可，然后我们就可以贪心地让这个环尽可能大，自然就想到了可以让树直径的两个端点连在一起可以最优.

我们考虑第二条边，若第二条边加入后，形成的环与第一条边形成的环有重边，那么显然重边就会要走两次，其它环边任然只需要走一次.

我们发现，第一条直径上的边对于第二条贡献其实是$-1$，其它都是$+1$，所以我们考虑一开始将边权设为$1$，第一次操作后将直径上的边的边权设为$-1$，其它边不变，再求一次直径即可得到两次直径的和$ans$.

那么答案就是$2(n-1)-ans+k$.

注意第二次求直径由于有负权边，所以要用树DP求直径.

代码如下：

#include<bits/stdc++.h>
  using namespace std;
#define Abigail inline void
const int N=100000;
struct side{
  int y,next,v;
}e[N*2+9];
int lin[N+9],top=1;
int dis[N+9],ans,pre[N+9],use[N+9];
int dp[N+9];
queue<int>q;
int n,k;
void ins(int x,int y){
  e[++top].y=y;e[top].v=1;
  e[top].next=lin[x];
  lin[x]=top;
}
int bfs(int st){
  int maxv=st;
  for (int i=1;i<=n;i++)
    dis[i]=pre[i]=use[i]=0;
  q.push(st);use[st]=1;
  while (!q.empty()){
    int t=q.front();q.pop();
    for (int i=lin[t];i;i=e[i].next)
      if (!use[e[i].y]){
      	dis[e[i].y]=dis[t]+e[i].v;
      	use[e[i].y]=1;
      	pre[e[i].y]=i;
        q.push(e[i].y);
        if (dis[e[i].y]>dis[maxv]) maxv=e[i].y;
      }
  }
  return maxv;
}
int dfs(int k){
  int ans;
  ans=dp[k]=0;use[k]=1;
  for (int i=lin[k];i;i=e[i].next)
    if (!use[e[i].y]){
      ans=max(ans,dfs(e[i].y));
      ans=max(ans,dp[e[i].y]+e[i].v+dp[k]);
      dp[k]=max(dp[k],dp[e[i].y]+e[i].v);
    }
  return ans;
}
Abigail into(){
  scanf("%d%d",&n,&k);
  int x,y;
  for (int i=1;i<n;i++){
    scanf("%d%d",&x,&y);
    ins(x,y);ins(y,x);
  }
}
Abigail work(){
  int x;
  x=bfs(bfs(1));
  for (int i=x;pre[i];i=e[pre[i]^1].y)
    e[pre[i]].v=e[pre[i]^1].v=-1;
  ans=dis[x];
  for (int i=1;i<=n;i++) use[i]=0;
  if (k==2) ans+=dfs(1);
}
Abigail outo(){
  printf("%d\n",2*(n-1)-ans+k);
}
int main(){
  into();
  work();
  outo();
  return 0;
}