Luogu P3000 [USACO10DEC]牛的健美操Cow Calisthenics

题目描述

Farmer John continues his never-ending quest to keep the cows fit by having them exercise on various cow paths that run through the pastures. These cow paths can be represented as a set of vertices connected with bidirectional edges so that each pair of vertices has exactly one simple path between them. In the abstract, their layout bears a remarkable resemblance to a tree. Surprisingly, each edge (as it winds its way through the pastures) has the same length.

For any given set of cow paths, the canny cows calculate the longest possible distance between any pair of vertices on the set of cowpaths and call it the pathlength. If they think this pathlength is too large, they simply refuse to exercise at all.

Farmer John has mapped the paths and found V (2 <= V <= 100,000) vertices, conveniently numbered from 1..V. In order to make shorter cowpaths, he can block the path between any two vertices, thus creating more sets of cow paths while reducing the pathlength of both cowpath sets.

Starting from a single completely connected set of paths (which have the properties of a tree), FJ can block S (1 <= S <= V-1) paths, creating S+1 sets of paths. Your goal is to compute the best paths he can create so that the largest pathlength of all those sets is minimized.

Farmer John has a list of all V-1 edges in his tree, each described by the two vertices A_i (1 <= A_i <= V) and B_i (1 <= B_i <= V; A_i != B_i) that it connects.

Consider this rather linear cowpath set (a tree with 7 vertices):

1---2---3---4---5---6---7

If FJ can block two paths, he might choose them to make a map like this:

1---2 | 3---4 | 5---6---7 where the longest pathlength is 2, which would be the answer in this case. He can do no better than this.

TIME LIMIT: 2 seconds

MEMORY LIMIT: 32 MB

Farmer John为了保持奶牛们的健康，让可怜的奶牛们不停在牧场之间 的小路上奔跑。这些奶牛的路径集合可以被表示成一个点集和一些连接 两个顶点的双向路，使得每对点之间恰好有一条简单路径。简单的说来， 这些点的布局就是一棵树，且每条边等长，都为1。 对于给定的一个奶牛路径集合，精明的奶牛们会计算出任意点对路径的最大值， 我们称之为这个路径集合的直径。如果直径太大，奶牛们就会拒绝锻炼。 Farmer John把每个点标记为1..V (2 <= V <= 100,000)。为了获得更加短 的直径，他可以选择封锁一些已经存在的道路，这样就可以得到更多的路径集合， 从而减小一些路径集合的直径。 我们从一棵树开始，FJ可以选择封锁S (1 <= S <= V-1)条双向路，从而获得 S+1个路径集合。你要做的是计算出最佳的封锁方案，使得他得到的所有路径集合 直径的最大值尽可能小。 Farmer John告诉你所有V-1条双向道路，每条表述为：顶点A_i (1 <= A_i <= V) 和 B_i (1 <= B_i <= V; A_i!= B_i)连接。

输入输出格式

输入格式：

* Line 1: Two space separated integers: V and S

* Lines 2..V: Two space separated integers: A_i and B_i

输出格式：

* Line 1: A single integer that is the best maximum pathlength FJ can achieve with S blocks

输入输出样例

输入样例#1：

7 2 
6 7 
3 4 
6 5 
1 2 
3 2 
4 5 

输出样例#1：

2 

思路：
　　非常简单的树形DP，加一个二分答案，对于每个点，假设已经有儿子的信息，对儿子的所有链长进行排序，大于mid就cut并sum++，最后判断sum是否大于s次机会

// luogu-judger-enable-o2
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cctype>
#include <queue>
using namespace std;
const int N = 110000;
int head[N], nxt[N<<1], to[N<<1], cnt;
int s,n;
int f[N];
int summ;
int a[N], top;
void add_edge(int a,int b) {
    to[++cnt] = b;
    nxt[cnt] = head[a];
    head[a] = cnt;

    to[++cnt] = a;
    nxt[cnt] = head[b];
    head[b] = cnt;
}
void dfs(int p,int fa,int x) {
    f[p]=0;
    for(int i=head[p];i;i=nxt[i]) {
        if(to[i]!=fa) {
            dfs(to[i],p,x);
        }
    }
    top=0;
    for(int i=head[p];i;i=nxt[i])
        if(to[i]!=fa) a[++top]=f[to[i]]+1;
    sort(a+1,a+top+1);
    while(top&&a[top]+a[top-1]>x)top--,summ++;
    f[p]=a[top];
 } 
bool check(int x) {
    summ=0;
    dfs(1,0,x);
    return summ<=s;
}
int main() {
    cin>>n>>s;
    int i,a,b;
    for(i=1;i<n;i++) {
        cin>>a>>b;
        add_edge(a, b);
    }
    int l=0,r=n;
    while(l<r) {
        int mid=(l+r)>>1;
        if(check(mid)) {
            r=mid;
        }
        else {
            l=mid+1;
        }
    }
    printf("%d
",l);
}