luogu5021 [NOIp2018]赛道修建 (二分答案+dp(贪心?))

首先二分一下答案，就变成了找长度>=m的 不相交的路径的个数

考虑到在一个子树中，只有一个点能出这个子树去和别的点搞

所以我这个子树里尽量自我满足是不会有坏处的

而且要在自我满足数最大的条件下，剩下一个尽量大的去把他搞出去

具体来说，我们设f[x]是x的子树中的满足条件的最大路径数，g[x]是在f[x]最大的情况下能剩下来的x的子树中到x的最大的路径长度

我们假设y们是x的孩子们，那我们拿着g[y]+edge[x][y]，又可以拼出好多路径

首先如果他已经>=m了，那就直接f[x]++

然后我把剩下的排个序，开一个l一个r，对着扫，我找能满足它的最小的那个，然后把他俩踢掉

但踢完以后我还要把r往右搞，因为有可能再把它往左搞的话他就不能满足新的l+1了

所以需要用一个双向链表来做

但还有一个问题，我不能在l>=r的时候就直接跳出，考虑1 2 4 5，我第一次做完以后l指在4 r也指在4 所以我要让r再跳一跳，直到他跳出去了在结束

还是看代码吧...

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 typedef long long ll;
 const int maxn=5e4+;

 inline ll rd(){
     ll x=;char c=getchar();int neg=;
     while(c<''||c>''){
         if(c=='-') neg=-;
         c=getchar();
     }
     while(c>=''&&c<='') x=x*+c-'',c=getchar();
     return x*neg;
 }

 int eg[maxn*][],egh[maxn],ect;
 int N,M,f[maxn],g[maxn],son[maxn],sh;
 int nxt[maxn],pre[maxn];

 inline void adeg(int a,int b,int c){
     eg[++ect][]=b,eg[ect][]=c,eg[ect][]=egh[a],egh[a]=ect;
 }

 inline bool cmp(int a,int b){
     return g[a]<g[b];
 }

 void dfs(int x,int fa,int k){
     f[x]=g[x]=;
     for(int i=egh[x];i;i=eg[i][]){
         int b=eg[i][];if(b==fa) continue;
         dfs(b,x,k);
     }sh=;
     for(int i=egh[x];i;i=eg[i][]){
         int b=eg[i][];if(b==fa) continue;
         son[++sh]=b;
         g[b]+=eg[i][];f[x]+=f[b];
     }
     sort(son+,son+sh+,cmp);
     int l=,r=sh;
     pre[]=;nxt[]=,pre[sh+]=sh;nxt[sh+]=;
     for(int i=;i<=sh;i++){
         pre[i]=i-;nxt[i]=i+;
     }
     for(;r;r=pre[r]){
         if(g[son[r]]<k) break;
         f[x]++;
         pre[nxt[r]]=pre[r],nxt[pre[r]]=nxt[r];
     }
     for(;l<=sh;l=nxt[l]){
         for(;l<pre[r]&&g[son[l]]+g[son[pre[r]]]>=k;r=pre[r]);
         if(l<r&&r<=sh&&g[son[l]]+g[son[r]]>=k){
             f[x]++;
             pre[nxt[r]]=pre[r],nxt[pre[r]]=nxt[r];
             pre[nxt[l]]=pre[l],nxt[pre[l]]=nxt[l];
             r=nxt[r];
         }
         while(nxt[l]<=sh&&r<=nxt[l]) r=nxt[r];
     }
     if(pre[sh+]) g[x]=g[son[pre[sh+]]];
 }
 inline bool judge(int k){
     dfs(,,k);
     return f[]>=M;
 }

 int main(){
     // freopen("track.in","r",stdin);
     // freopen("track.out","w",stdout);
     int i,j,k;
     N=rd(),M=rd();
     int l=,r=,ans=;
     for(i=;i<N;i++){
         int a=rd(),b=rd(),c=rd();
         r+=c;
         adeg(a,b,c);adeg(b,a,c);
     }
     while(l<=r){
         int m=l+r>>;
         if(judge(m)) l=m+,ans=m;
         else r=m-;
     }
     printf("%d\n",ans);

     return ;
 }