二分

最新推荐文章于 2024-03-13 21:03:49 发布
最新推荐文章于 2024-03-13 21:03:49 发布
阅读量102 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/LITTLESUNwl/p/11010765.html
版权

递增排序，递减排序，非递减排序，非递增排序

1,2,3,4,5,.:递增排列
9,8,7,6,5.:递减排列
1,2,3,3,4,5,8,8,.:非递减排列
9,8,7,7,6,5,5,2,1,.:非递增排列

二分查找&&二分答案（部分内容参照二分查找和[ShawnZhou (https://www.luogu.org/blog/user20197/solution-p2678)）

使用二分需要满足两个条件。一个是有界，一个是单调。如果题目规定了有“最大值最小”或者“最小值最大”的东西，那么这个东西应该就满足二分答案的有界性（显然）和单调性（能看出来）。
二分查找依赖于一个有序的集合。开始时，先找出有序集合中间的那个元素。如果此元素比要查找的元素大，就接着在较小的一个半区进行查找；反之，如果此元素比要找的元素小，就在较大的一个半区进行查找。在每个更小的数据集中重复这个查找过程，直到找到要查找的元素或者数据集不能再分割。
查找数列中第一个大于某值的下标。也就是c++里的lower_bound（）
手写出来是这样的：

int find(int a[],key,len)
{
    int left=0;
    int right=len;
    int mid;
    while(left<=right)
    {
        mid=(left+right)>>1;
        if(a[mid]<key)
        {
            left=mid+1;
        }
        else
        {
            right=mid-1;
        }
    }
    return left;
}

二分答案的题：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define MAXN 100010
using namespace std;

int d,n,m;
int a[MAXN];
int l,ans,r,mid;

bool check(int x)
{
    int cnt=0;
    int i=0;
    int now=0;
    while(i<n+1)
    {
        i++;
        if(a[i]-a[now]<x)
        {
            cnt++;
        }
        else
        {
            now=i;
        }
    }
    if(cnt>m) return false;
    else return true;
}

int main()
{
    scanf("%d%d%d",&d,&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    a[n+1]=d;
    l=1;r=d;
    
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(check(mid))
        {
            ans=mid;
            l=mid+1;
        }
        else
        {
            r=mid-1;
        }
    }
    cout<<ans;
    return 0;
}

P1316 丢瓶盖和P1824 进击的奶牛
这道题和跳石头很像，不同的地方是题中所给的为留下多少而不是拿走多少，还有就是需要对坐标进行排序
代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define MAXN 1001000
using namespace std;

int n,k,b;
int l,r,mid,ans;
int a[MAXN];

bool check(int x)
{
    int i=1;
    int now=1;
    int cnt=0;
    while(i<n)
    {
        i++;
        if(a[i]-a[now]<x)
        {
            cnt++;
        }
        else
        {
            now=i;
        }
    }
    if(cnt>k) return false;
    else return true;
}
int main()
{
    scanf("%d%d",&n,&b);
    k=n-b;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    sort(a+1,a+n+1);
    l=1;
    r=a[n];
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(check(mid))
        {
            ans=mid;
            l=mid+1;
        }
        else
        {
            r=mid-1;
        }
    }
    cout<<ans;
    return 0;
}

P1873 砍树
这道题除了要记得开long long 好像也没什么特别需要注意得了
代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define ll long long
#define MAXN 20000010
using namespace std;

ll n,m;
ll l,r,ans,mid;
ll a[MAXN];

bool check(ll x)
{
    ll cnt=0;
    for(int i=1;i<=n;i++)
    {
        if(a[i]>x)
        {
            cnt=cnt+(a[i]-x);
        }
    }
    if(cnt>=m) return true;
    else return false;
 } 
 
 int main()
 {
    scanf("%lld%lld",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a+1,a+n+1);
    l=1;
    r=a[n];
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(check(mid))
        {
            ans=mid;
            l=mid+1;
         }
         else
         {
            r=mid-1;
         }
    }
    cout<<ans;
 }

P1577 切绳子
这道题因为小数的精度不够，所以小数的二分是另一种写法

while(l+eps<=r)
    {
        mid=(l+r)/2.00000000;
        if(check(mid))
        {
            ans=mid;
            l=mid;
        }
        else r=mid;
    }
    int aa=(int)((ans+eps)*100);
    printf("%.2lf",1.0*aa/100.0);

这道题除了用小数写也可以用整数写最后转化为小数
这道题的AC代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define MAXN 100010
#define eps 1e-8
using namespace std;

int n,k;
double a[MAXN];
double l,r,mid,ans;

bool check(double x)
{
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        int p=floor(a[i]/x) ;
        cnt=cnt+p;
    }
    if(cnt>=k) return true;
    else return false;
}

int main()
{
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++)
    {
        scanf("%lf",&a[i]);
    }
    sort(a+1,a+n+1);
    l=0.00000000001;
    r=a[n];
    while(l+eps<=r)
    {
        mid=(l+r)/2.00000000;
        if(check(mid))
        {
            ans=mid;
            l=mid;
        }
        else r=mid;
    }
    int aa=(int)((ans+eps)*100);
    printf("%.2lf",1.0*aa/100.0);
    return 0;
}

P1843 奶牛晒衣服
这道题如果每一步进行贪心的话会TLE,所以可以进行一些简单的优化
代码如下：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define MAXN 2000001
#define ll long long
using namespace std;

ll n,a;
double b;
ll l,r,mid,ans;
ll tot;
ll A[MAXN],B[MAXN];

bool check(ll x)
{
    for(int i=1;i<=n;i++)
    {
        A[i]=B[i];
    }
    for(int i=1;i<=n;i++)
    {
        A[i]=A[i]-a*x;
    }
    for(int i=1;i<=n;i++)
    {
        tot=tot+A[i];
    }
    if((tot/b)>x) return false;
    int cur=0;
    for(int i=1;i<=n;i++)
    {
        if(A[i]>0&&A[i]<=b) cur++;
        else if(A[i]>b)
        {
            cur=cur+ceil(A[i]/b);
        }
    }
    if(cur>x) return false;
    else return true;
}

int main()
{
    scanf("%lld%lld%lf",&n,&a,&b);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&A[i]);
    }
    for(int i=1;i<=n;i++)
    {
        B[i]=A[i];
    }
    sort(A+1,A+n+1);
    tot=0;
    l=1;
    r=A[n]/a+1;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(check(mid))
        {
            ans=mid;

            r=mid-1;
        }
        else l=mid+1;
    }
    cout<<ans;
    return 0;
}

P1918 保龄球

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
#define MAXN 1000001
#define M 100000000
using namespace std;
int a[MAXN];
map<int,int> b;
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    for(int i=1;i<=1000000;i++)
    {
        if(a[i]==0) continue;
//      cout<<i<<endl;
        b[a[i]]=i;
    }

    sort(a+1,a+n+1);
    int q;
    scanf("%d",&q);
    while(q--)
    {
        int m;
        bool flag=0;
        scanf("%d",&m);
        int l=1,r=a[n];
        int mid;
        while(l<=r)
        {
//          printf("l=%d,r=%d\n",l,r);
            mid=(l+r)>>1;
//          printf("mid=%d\n",mid);
            if(mid==m)
            {
                printf("%d\n",b[m]);
                flag=1;
//              cout<<"aaa"<<endl;
                break;
            }
            if(mid>m)
            {
                r=mid-1;
//              cout<<"bbb"<<endl;
            }
            if(mid<m)
            {
                l=mid+1;;
//              cout<<"ccc"<<endl;
            }
        }
        if(!flag)
        {
            printf("0\n");
//          cout<<"ddd"<<endl;
        }
    }
    return 0;
 }

转载于:https://www.cnblogs.com/LITTLESUNwl/p/11010765.html

George_Fal
关注
算法-二分查找
uncle_ll的博客
07-16 3259
现在我们来看一下二分查找二分查找的原理每次排除掉一半答案，使可能的答案区间快速缩小。二分查找log2(n)log_2(n)log2​(n)，因为每次询问会使可行区间的长度变为原来的一半。我们再来看一下二分查找的思路我们设定一个初始的L和R，保证答案在[L,R]中，当[L,R]中不止有一个数字的时候，取区间的中点M，询问这个中点和答案的关系，来判断答案是M，还是位于[L,M-1]中，还是位于[M+1,R]中。二分查找的伪代码如下intL=区间左端点;二分查找。...
C/C++ 二分查找最接近的数值m算法详解及源码
最新发布
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-29 7345
二分查找最接近的数值m算法是在有序数组中查找最接近给定数值m的元素。
二分查找法
weixin_46312449的博客
12-28 8120
一、基本概念 二分查找法（Binary Search）算法，也叫折半查找算法。二分查找针对的是一个有序的数据集合，查找思想有点类似于分治思想。每次都通过跟区间的中间元素对比，将带查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为0。二分查找是一种非常非常高效的查询算法，时间复杂度为O(logn)。 二、算法实现 之前有写过利用数组进行数据查找的文章，其采用的是二分查找，不过原先的实现代码并不通用，因为源代码只适用于整型数组，倘若要求在浮点数组或者字符串数组中查找，那只能重新编码了。 因此，对
二分查找算法总结
Summer_night_star的博客
02-18 7670
1 二分查找简介   二分查找也叫折半查找，是一种常见的查找方法，它将原本是线性时间提升到了对数时间范围，大大缩短了搜索时间。   二分查找必须具备两个条件，一是数列必须使用顺序存储结构（例如数组），二是数列必须有序。 2 二分查找的原理及实现   以升序数列为例，比较一个元素与数列中的中间位置的元素的大小，如果比中间位置的元素大，则继续在后半部分的数列中进行二分查找；如果比中间位置的元素小，则在数列的前半部分进行比较；如果相等，则找到了元素的位置。   每次比较的数列长度都会是之前数列的一半，直到找到相等
【Python算法系列十】二分查找算法
m0_70372647的博客
05-24 6288
二分查找，也叫折半查找，是一种适用于顺序存储结构的查找方法。它是一种效率较高的查找方法，时间复杂度为 O(lgn)，但它仅能用于有序表中。也就是说，表中的元素需按关键字大小有序排列。 二分查找用左右两个指针来标注查找范围。程序开始时，查找范围是整个线性表，左指针指向第一个元素，右指针指向最后一个元素；每一次循环过后，查找范围都缩小为原先的一半，直到左右指针重叠或者左指针处于右指针的右侧。因为每次缩小一半的范围，所以可以得出二分查找的时间复杂度为 O(lgn)。 ...
hdu pie
weixin_34345753的博客
08-24 122
Pie Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 109 Accepted Submission(s): 52 Problem Description My birt...
【1.基础算法-模板】3.二分（模板）
qq_52384627的博客
07-12 424
数的范围 #include<bits/stdc++.h> using namespace std; int main() { int n,m,q[100000+10]; cin>>n>>m; for(int i=0;i<n;i++)scanf("%d",&q[i]); while(m--) { int x; cin>>x; int
二分查找
赞美月亮的专栏
03-30 2262
折半查找，又叫二分查找 要求顺序存储结构且要求元素按关键字有序排列 时间复杂度O(log2n) 成功的情况下：查找过程走了一条从判定树的根到被查记录的路径，比较的次数恰为记录在树中的层数。 失败的情况下：查找过程经过了从判定树的根到某个外部节点的路径，所需比较次数不超过判定树的高度。 过程描述： 首先，用要查找的关键字k与中间位置的节点的关键字相比较，这个中间记录将这个表分为了两个子表
二分算法
Shuzi_master7的博客
03-13 338
二分一定要是单调队列，单调才具有二段性。特征 最小值最大化 最大值最小化。
Python实现二分查找法
"""二分查找法递归实现""" if len(array) == 0: return False array.sort() mid_index = len(array) // 2 if array[mid_index] == data: return True return self.binary_search(array[mid_index + 1:], ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值