【BZOJ2525】[Poi2011]Dynamite(二分，树形dp)

【BZOJ2525】[Poi2011]Dynamite

Description

Byteotian Cave的结构是一棵N个节点的树，其中某些点上面已经安置了炸.药，现在需要点燃M个点上的引线引爆所有的炸.药。

某个点上的引线被点燃后的1单位时间内，在树上和它相邻的点的引线会被点燃。如果一个有炸.药的点的引信被点燃，那么这个点上的炸.药会爆炸。
求引爆所有炸.药的最短时间。
输入：
第一行是两个整数N,M。(1<=m<=n<=300000）
接下来一行有N个整数Di，第I个数为1表示该点有炸.药。
接下来N-1行每行有两个数A,B，表示A和B之间有一条边。
输出：
最短时间。
样例解释： 
点燃3,5上的引线。

Sample Input

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

Sample Output

1

 

/*
二分答案。
然后接下来从下往上扫整棵树。
节点的状态有：
第一种 子树内没有不被覆盖的关键点，并且子树中有一个节点的贡献可以继续往上。
第二种 子树内有不被覆盖的关键点，子树中没有节点的贡献可以继续往上。
第三种 既没有 不被覆盖的关键点，又没有 可以继续往上贡献的点。
第四种 都有。
但是 可以证明，第四种情况存在的话，显然可以在子树外挑一个点来覆盖没有被覆盖的关键点，但是这个时候子树内的挑选的点就没有卵用了，所以这种情况可以归到第三种。
然后具体就是贪心讨论的过程了。
贪心的思想就是，能不染就不染
显然第一种需要记录还能往上走多少。
第二种需要记录最远的不被覆盖的关键点到达目前的根节点的距离
*/
 
#include<iostream>
#include<cstdio>
 
#define N 300007
 
using namespace std;
int n,m,h[N],cnt,d[N],sum,sm,mx[N],mn[N];
struct edge
{
    int ne,to;
}e[N<<];
 
inline int read()
{
    int x=,f=;char c=getchar();
    while(c>''||c<''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
    return x*f;
}
 
void add(int u,int v)
{
    e[++cnt].to=v;e[cnt].ne=h[u];h[u]=cnt;
}
 
void dfs(int u,int fa,int w)
{
    mx[u]=-1e9,mn[u]=1e9;
    for(int i=h[u];i;i=e[i].ne)
        if(e[i].to!=fa)
        {
            dfs(e[i].to,u,w);
            mx[u]=max(mx[u],mx[e[i].to]+);
            mn[u]=min(mn[u],mn[e[i].to]+);
        }
    if(d[u]&&mn[u]>w) mx[u]=max(mx[u],);
    if(mx[u]+mn[u]<=w)mx[u]=-1e9;
    if(mx[u]==w) sm++,mx[u]=-1e9,mn[u]=;
}
 
bool ok(int w)
{
    sm=;dfs(,,w);
    return sm+(mx[]>=)<=m;
}
 
int main()
{
    n=read(),m=read();
    for(int i=;i<=n;i++)
        d[i]=read(),sum+=d[i];
    for(int i=;i<n;i++)
    {
        int x=read(),y=read();
        add(x,y),add(y,x);
    }
    if(sum<=m)
    {
        puts("");return ;
    }
    int l=,r=n,ans=n;
    while(l<=r)
    {
        int mid=(l+r)>>;
        if(ok(mid)) r=mid-,ans=mid;
        else l=mid+;
    }
    printf("%d\n",ans);
    return ;
}