二分

二分

　　二分有两种：二分答案和二分查找；一般来说二分查找没什么意思，主要还是二分答案。

　　聪明的质检员：https://www.luogu.org/problemnew/show/P1314

　　题意概述：

　　题目给定了n个矿石，有价值和重量，m个区间$[L_i,R_i]$,自选一个参数W，对于每个区间求校验值并相加，为总校验值。求一个最优的$W$使得总校验值与标准值(给定)最接近。

　　如何计算校验值？区间内质量超过W的矿石数量与这些矿石的价值之和的乘积。

　　首先呢...W越大，满足条件的矿石数量就越多，价值之和就越大，校验值自然也越大啦，所以可以二分。因为我二分的知识十分匮乏...所以想了一个比较适合二分蒟蒻的做法：首先二分一个最大的小于标准值的校验值，再二分一个最小的大于标准值的校验值，取一个min。二分答案之后怎么check呢？用前缀和就好了。时间复杂度$O(log(maxw)(n+m))$

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# define R register int

using namespace std;

const int maxn=200005;
int n,m,l,r;
long long s,ans,t,S[maxn],cnt[maxn];
int w[maxn],v[maxn],maxw,minw,mid;
struct nod
{
    int l,r;
}a[maxn];

int read()
{
    int x=0,f=1;
    char c=getchar();
    while (!isdigit(c))
    {
        if(c=='-') f=-f;
        c=getchar();
    }
    while (isdigit(c))
    {
        x=(x<<3)+(x<<1)+(c^48);
        c=getchar();
    }
    return x*f;
}

long long ab (long long a)
{
    if(a<0) return -a;
    return a;
}

long long check (int W)
{
    memset(S,0,sizeof(S));
    memset(cnt,0,sizeof(cnt));
    for (int i=1;i<=n;++i)
    {
        if(w[i]>=W) S[i]=v[i],cnt[i]=1;
        S[i]+=S[i-1];
        cnt[i]+=cnt[i-1];
    }
    long long ans=0;
    for (int i=1;i<=m;++i)
        ans+=(S[ a[i].r ]-S[ a[i].l-1 ])*(cnt[ a[i].r ]-cnt[ a[i].l-1 ]);
    return ans;
}

int main()
{
    scanf("%d%d%lld",&n,&m,&s);
    w[1]=read(),v[1]=read();
    maxw=minw=w[1];
    for (R i=2;i<=n;i++)
        w[i]=read(),v[i]=read(),maxw=max(maxw,w[i]),minw=min(minw,w[i]);
    for (R i=1;i<=m;i++)
        a[i].l=read(),a[i].r=read();
    l=minw,r=maxw;
    ans=check(l);
    while (l<=r)
    {
        mid=(l+r)>>1;
        t=check(mid);
        if(t<s) r=mid-1;
        else { l=mid+1; ans=min(ans,ab(t-s)); }
    }
    l=minw,r=maxw;
    while (l<=r)
    {
        mid=(l+r)>>1;
        t=check(mid);
        if(t>s) l=mid+1;
        else { r=mid-1; ans=min(ans,ab(t-s)); };
    }
    printf("%lld",ans);
    return 0;
}

　　Best Cow Fences:https://loj.ac/problem/10012

　　题意概述：给定一个长度为$n$的非负整数序列$A$,找出一个平均数最大的，长度不小于$L$的子段,输出这个平均值。

　　这道题乍一看没有什么思路,仔细想一下发现是一道$0-1$分数规划;

　　$0-1$分数规划这个算法我没有专门学过,类似于一种二分化式子的思想?

　　这道题的答案是满足单调性的,显然平均数大于$2$肯定更大于$1.$二分之后$check$:把所有数字都减去这个平均值,那么如果一段的和是整数就说明它的平均值大于等于二分值.找长度大于等于$L$的最大子段和就很简单啦.

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

const int maxn=100005;
int n,L,l,r,mid,ans;
int mi,ma,a[maxn];
ll s[maxn];

bool check (int x)
{
    ll minn=0;
    for (R i=1;i<=n;++i)
        s[i]=s[i-1]+a[i]-x;
    for (R i=L;i<=n;++i)
    {
        if(i-L>=0) minn=min(minn,s[i-L]);
        if(s[i]>=minn) return true;
    }
    return false;
}

int main()
{
    scanf("%d%d",&n,&L);
    scanf("%d",&a[1]);
    a[1]*=1000;
    mi=ma=a[1];
    for (R i=2;i<=n;++i)
        scanf("%d",&a[i]),a[i]*=1000,mi=min(mi,a[i]),ma=max(ma,a[i]);
    l=mi,r=ma;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(check(mid))
            ans=mid,l=mid+1;
        else
            r=mid-1;
    }
    printf("%d",ans);
    return 0;
}

　　最小圈:https://www.lydsy.com/JudgeOnline/problem.php?id=1486

　　题意概述:在一个有向图中找一个平均值最小的环.

　　说实话这道题我一直不大想写,因为它实在是有点假.嗯,非常假.太假了!

　　和上边那个题其实差不多的,都是$0-1$分数规划;

　　二分答案之后全部减掉,然后找负环.找负环.找负环.这道题网上的大多数题解竟然都是拿$dfs-spfa$过的!而且只要用$spfa$这算个什么题目.

　　不过这题也是有理论正解的,偷偷贴一个$rqy$的博客好了:https://www.cnblogs.com/y-clever/p/7043553.html;

　　

// luogu-judger-enable-o2
# include <cstdio>
# include <iostream>
# include <queue>
# include <cstring>
# include <string>
# define pac make_pair
# define R register int
# define ll long long

using namespace std;

const double eps=0.000000001;
const int maxn=3003;
const int maxm=10004;
int h,n,m,firs[maxn],x,y,in_que[maxn],vis[maxn];
double l=-1,r,mid,ans,d[maxn],z;
bool f=false;
struct edge
{
    int too,nex;
    double co;
}g[maxm+maxn];

void add (int x,int y,double z)
{
    g[++h].too=y;
    g[h].nex=firs[x];
    firs[x]=h;
    g[h].co=z;
}

void dfs (int x,double k)
{
    vis[x]=true;
    int j;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(d[x]+g[i].co-k<d[j])
        {
            if(f) return;
            if(vis[j])
            {
                f=true;
                return ;
            }
            d[j]=d[x]+g[i].co-k;
            dfs(j,k);
        }
    }
    vis[x]=false;
}

bool check (double k)
{
    memset(d,0,sizeof(d));
    memset(vis,0,sizeof(vis));
    d[0]=0;
    f=false;
    dfs(0,k);
    return f;
}

int main()
{
    scanf("%d%d",&n,&m);
    for (R i=1;i<=m;++i)
    {
        scanf("%d%d%lf",&x,&y,&z);
        add(x,y,z);
    }
    for (R i=1;i<=n;++i)
        add(0,i,0);
    r=1e5,l=-1e5;
    ans=r;
    while (r-l>=-eps)
    {
        mid=(l+r)/2.0;
        if(check(mid))
            ans=min(ans,mid),r=mid-eps;
        else
            l=mid+eps;
    }
    printf("%.8lf",ans);
    return 0;
}