2067: [Poi2004]SZN——树上贪心+二分

题目大意：

给一棵树。求用最少的链覆盖这棵树（链不能相交），在这个基础上求最长的链最短可以是多少。

n<=10000

题解：

肯定先处理第一问：

答案：$\sum_(du[i]-1)/2+1$

证明：

1.对于一个非根的节点x，x的每一个到儿子的边必须被覆盖。

只有两种可能：要么这个链不超过x，要么从x头上进来。

发现，从x头上进来的链有且只有一个。

如果x的儿子数量是偶数，肯定只能把边两两配对。如果奇数，那么剩下这一个就和从x头上下来的链在一起即可。

儿子数du[i]-1，花费：（du[i]-1）/2

2.对于根节点rt

儿子偶数的话，同理，如果儿子是奇数的话，由于rt没有从头上下来的链，只能单独算作一个链。

所以答案是：(du[i]+1)/2，即(du[i]-1)/2+1

证毕。

第二问：

二分答案显然。

判定mid：我们既要满足最长小于等于mid，还要满足贪心方法依然能使得链数最小。

根据刚才第一问的分析，子树x的对于儿子的覆盖情况无非就那么两种。而且x内的覆盖情况对其他子树的影响只有从x上去的那一条链。

而比较麻烦的是x头上下来的链。发现，这个链只有一个。

所以，我们在x子树内合法覆盖、用的链最少的前提下，想头上的链越短越有利。

f[x]表示 ，x头上的链的最短长度。

或者更准确地说，x头上的链进入x子树后，还要延伸多少。

dfs时，

对于x，我们先求出f[son]

然后想办法求f[x]

把f[son]+1计入mem数组，然后从小到大排序。

如果x有奇数个儿子，二分f[x]位置，然后大小配对。

如果x有偶数个儿子，如果可以大小直接配对，完事大吉，f[x]=0,然后回溯。

否则，二分f[x]位置，然后把剩下的最大的f[son]+1独自一条链（这样也可以满足方案数最小的）

继续大小配对判断。

当然，对于根节点，f[x]没有意义了，就检查一下，如果偶数个儿子，直接配对。奇数个，去掉最大的配对。

任何时候，如果f[son]+1>mid，或者f[x]不存在，或者根节点匹配失败，都return false

所以，其实是大二分，然后dfs贪心的时候再二分。

代码：

注意两个mid不要弄混。。。。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=+;
int n;
struct node{
    int nxt,to;
}e[*N];
int hd[N],cnt;
void add(int x,int y){
    e[++cnt].nxt=hd[x];
    e[cnt].to=y;
    hd[x]=cnt;
}
int son[N],tot;
int mid;
int ans1,ans2;
int du[N];
bool fl;
int f[N];
void dfs(int x,int fa){
    //cout<<x<<" "<<fa<<endl;
    if(!fl) return;//warning!!!
    for(int i=hd[x];i;i=e[i].nxt){
        int y=e[i].to;
        if(y==fa) continue;
        dfs(y,x);
    }
    tot=;
    if(!fl) return;//warning!!
    for(int i=hd[x];i;i=e[i].nxt){
        int y=e[i].to;
        if(y==fa) continue;
        son[++tot]=f[y]+;
    }
    sort(son+,son+tot+);
    //cout<<x<<" 's son "<<endl;
    //for(int i=1;i<=tot;i++) cout<<son[i]<<" ";cout<<endl;
    if(son[tot]>mid) {fl=false;return;}//warning!!!
    if(x==){
        bool can=true;
        if(tot%==) tot--;
        for(int i=;i<=tot/;i++){
            if(son[i]+son[tot-i+]>mid){
                can=false;break;
            }
        }
        if(!can) fl=false;
    }
    else{
        if(tot%==){
            bool can=true;
            for(int i=;i<=tot/;i++){
                if(son[i]+son[tot-i+]>mid){
                    can=false;break;
                }
            }
            if(can) {
                f[x]=;return;//warning!!!!! has returned
            }
        }
        f[x]=-;//warning!!!
        int L=,R=tot;
        while(L<=R){
            int M=(L+R)>>;
            int up=tot;
            if(M==tot) up--;
            if(tot%==) up--;
            bool can=true;
            for(int i=;i<=up;i++){
                if(i==M) continue;
                if(son[i]+son[up]>mid) {
                    can=false;break;
                }
                up--;
            }
            //cout<<x<<" M "<<M<<" : "<<can<<endl;
            if(can) f[x]=son[M],R=M-;
            else L=M+;
        }
        if(f[x]==-) {
            fl=false;
        }
    }
}
bool che(){
    fl=true;
    //cout<<" mid "<<mid<<" ------------------"<<endl;
    memset(f,,sizeof f);
    dfs(,);
    //cout<<" ff "<<endl;
    //for(int i=1;i<=n;i++){
    /// cout<<i<<" : "<<f[i]<<endl;
    //}
    return fl;
}
int main(){
    scanf("%d",&n);int x,y;
    for(int i=;i<=n-;i++){
        scanf("%d%d",&x,&y);add(x,y);add(y,x);
        du[x]++,du[y]++;
    }
    for(int i=;i<=n;i++){
        ans1+=(du[i]-)/;
    }
    ans1++;
    int l=,r=n-;
    while(l<=r){
        mid=(l+r)>>;
        if(che()){
            ans2=mid,r=mid-;
        }
        else l=mid+;
    }
    printf("%d %d",ans1,ans2);
    return ;
}

总结：

树上贪心肯定和儿子有关系。

观察覆盖x到儿子的边的两种方案。结合二分贪心

---

$upda:2018.12.29$

NOIP考到了这个题目，几乎是原题，而且没有第一问。。。。

大致的思路是对的。

但是二分里面的二分没有写上，，（反而写了儿子个数平方套set？）

看来写题目不光是思路要有，关键的trick也不能放过

（对了感谢ywy_c_asm神犇，多亏了他给我推荐SZN这个题，否则NOIP就GG了）