再谈二分

题面传送门
简单题哈，简单题。
我们二分能组成的套数，再遍历一遍找到答案。若答案大于$m$，那么收拢右边界。如果答案小于$m$，那么收拢左边界。
代码实现:

#include<cstdio>
using namespace std;
int n,m,a[139],l,r,mid,b[139];
long long ans;
int main(){
    register int i,j;
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;i++) scanf("%d",&a[i]);
    a[n+1]=m;
    l=0;r=2100000001;
    while(l+1<r){
        mid=(l+r)>>1;
        ans=0;
        for(i=1;i<=n+1;i++) b[i]=a[i];
        for(i=1;i<=n+1;i++){
            if(b[i]<mid) ans+=mid-b[i];
        }
        if(ans<=mid)l=mid;
        else r=mid; 
    }
    printf("%d",l);
}

题面传送门
中等题哈，中等题。
我们注意到一点: 使得所有机器的能量之差的最大值最小。这就是要二分的节奏了。
我们二分所有机器的能量之差的最大值，并根据这个mid来遍历数组。这里有一个贪心思想。若有多个满足$mid$的数对，那么取最小的几对。若无法取出，那么收拢左边界。若可以取出，那么继续验证，从后到前枚举，一边枚举一边记录不作最小值的数量，若从后到左第i对数后的不做最小值的数小于$2\times i\times (m-1)$，那么就不能满足要求，收拢左边界。反之收拢右边界。
代码实现:

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int n,m,a[1000039],l,r,mid,ans,tot,pus,flag,s[1000039];
int main() {
    register int i;
    scanf("%d%d",&n,&m);
    for(i=1; i<=2*n*m; i++) scanf("%d",&a[i]);
    sort(a+1,a+2*n*m+1);
    l=-1;
    r=1000000001;
    while(l+1<r) {
        mid=(l+r)>>1;
        ans=tot=pus=flag=0;
        memset(s,0,sizeof(s));
        for(i=2; i<=2*n*m; i++) {
            if(a[i]-a[i-1]<=mid&&!s[i-1])ans++,s[i]=s[i-1]=ans;
            if(ans==n)break;
        }
        if(ans==n) {
            for(i=2*n*m; i>=2; i--) {
                if(!s[i]) tot++;
                if(s[i]&&s[i]==s[i-1]) {
                    pus++;
                    if(tot<2*pus*(m-1)) {
                        flag=1;
                        break;
                    }
                }
            }
        } else flag=1;
        if(flag) l=mid;
        else r=mid;
    }
    printf("%d\n",r);
}

题面传送门
难题哈，难题。
二分+搜索验证。
我们将木板从大到小排序，因为一块木材如果能满足大木板，就一定能满足一块小木板。搜索从大到小搜索，若能满足前$mid$块木板，就收拢左边界。反之收拢右边界。
但爆搜很慢啊$qwq$。
于是我们可以考虑优化。
优化$1$:若一块木板大于任何一块木材，那么这块木板可以排除。
证明很好证，想想就通了。
优化$2$:若一块木板与下一块木板一样长，那么可以强制从当前这块木板开始枚举。
证明:可知这两块木板是一样的，那么这两块木板在木材中的完美排列为$\frac{n(n-1)}{2}$种，而如果还是从第一块开始枚举，那么有$n(n-1)$种可能，而这中间有一定重复的。从当前木板开始枚举就可以避免这个情况。
优化$3$:若一块木板被砍后小于最小的木板，那么可以看作浪费。若浪费总和加上要截的木板总数大于所有木材总数，那么这个方案可以直接返回。
优化$4$:如果有一种方案了，就直接全部$return$。
以上就可以直接过掉这题了，而且跑的飞快。
代码实现:

#include<cstdio>
#include<algorithm>
using namespace std;
int n,m,a[1039],b[59],l,r,mid,ans,tot,flag,now,s[59],q[1059];
inline void dfs(register int x,register int last) {
    if(flag) return;
    if(!x){flag=1;return;}
    if(now+q[mid]>ans) return;
    for(register int i=last; i<=n; i++) {
        if(b[i]>=a[x]){
            b[i]-=a[x];
            if(b[i]<a[1]) now+=b[i];
            if(a[x]==a[x-1]) dfs(x-1,i);
            else dfs(x-1,1);
            if(b[i]<a[1]) now-=b[i];
            b[i]+=a[x];
            if(flag) return;
        }
    }
}
int main() {
    register int i;
    scanf("%d",&n);
    for(i=1; i<=n; i++)scanf("%d",&b[i]),ans+=b[i];
    scanf("%d",&m);
    for(i=1; i<=m; i++) scanf("%d",&a[i]);
    sort(a+1,a+m+1);
    sort(b+1,b+n+1);
    for(i=1;i<=m;i++) q[i]=q[i-1]+a[i];
    while(q[m]>ans) m--;
    l=1;
    r=m;
    while(l<=r) {
        mid=(l+r)>>1;
        flag=0;now=0;
        dfs(mid,1);
        if(flag) l=mid+1;
        else r=mid-1;
    }
    if(!n) printf("14");
    else printf("%d",l-1);
}

忘了提醒你们，由于老师放题时没注意，把配置文件也放进来了。所以要加一行特判:

if(!n) printf("14");