二分法学习

整数二分

二分法多用于寻找某个数在一个数组中的位置,有两种不同的写法分别找到一个数的起始位置和结束位置

不同的写法寻找到一个数开始或者结束的位置

//区间[l,r]被划分成[l,mid]和[mid+1,r]时使用
int bsearch_1(int l,int r)
{
	while(l<r)
	{
		int mid = (l+r)>>1;
		if(check(mid)) r = mid;  //check()函数是根据题目自己写的在左半边满足条件，右半边不满足条件
		else l = mid + 1;
	}
}

//区间[l,r]被划分成[l,mid-1]和[mid,r]时使用
int bsearch_2(int l,int r)
{
	while(l<r)
	{
		int mid = (1+l+r)>>1;
		if(check(mid)) l = mid;
		else r = mid - 1;
	}
}

例题

给定一个按照升序排列的长度为n的整数数组，以及 q 个查询。

对于每个查询，返回一个元素k的起始位置和终止位置（位置从0开始计数）。

如果数组中不存在该元素，则返回“-1 -1”。

输入格式

第一行包含整数n和q，表示数组长度和询问个数。

第二行包含n个整数（均在1~10000范围内），表示完整数组。

接下来q行，每行包含一个整数k，表示一个询问元素。

输出格式

共q行，每行包含两个整数，表示所求元素的起始位置和终止位置。

如果数组中不存在该元素，则返回“-1 -1”。

数据范围
1≤n≤100000
1≤q≤10000
1≤k≤10000

解答

下面这个题模板是针对于升序排列的

一定要注意如果是降序的话要使用不同的写法

#include<iostream>
using namespace std;

const int N = 100010;

int num[N];
int main()
{
    int n,q;
    cin >> n >> q;
    for(int i=0;i<n;i++)
    {
        cin >> num[i];
    }
    while(q--)
    {
        int find;
        cin >> find;
        int the_start,the_end;
        //下面这么写找到这个数开始的位置
        //这个写法如果这个数组中没有这个数，那么最终就会有start=end=第一个比find大的数的位置
        int start = 0,end = n-1;
        while(start<end)
        {
            int mid = (start+end)/2;
            if(num[mid]>=find)//这样子写法左端一定最终停在这个数开始位置，然后就不断更新右端
            {                 
                end = mid;
            }
            else{
                start = mid+1;
            }
        }
        the_start = start;
        //下面找到这个数结束的位置,就是上面那种写法从后向前看罢了
        //这个写法如果这个数组中没有这个数，那么最终就会有start=end=第一个比find小的数的位置
        int l = 0,r = n-1;
        while(l<r)
        {
            int mid2 = (l+r+1)/2;
            if(num[mid2]<=find)
            {
                l = mid2;
            }
            else{
                r = mid2 - 1;
            }
        }
        the_end = r;
        if(num[the_start]!=find){
            cout<<-1<<" "<<-1<<endl;
        }
        else{
            cout<<the_start<<" "<<the_end<<endl;
        }
        
        
    }
    return 0;
}

PAT 1012

PAT1012

#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<unordered_map>
using namespace std;

struct Person{
    string name;
    int A,C,M,E;
};
unordered_map<string,Person> record;
vector<int> the_A;
vector<int> the_C;
vector<int> the_M;
vector<int> the_E;

int find(vector<int> a,int target)
{
    int start = 0,end = a.size()-1;
    while(start<end)
    {
        int mid = (start+end+1)/2;
        if(a[mid]<=target) start = mid;
        else{
            end = mid -1;
        }
    }
    return a.size()-start;
}

int main()
{
    int N,M;
    cin >> N>> M;
    for(int i=0;i<N;i++)
    {
        string name;
        int a,c,m,e;
        cin >> name>>c>>m>>e;
        a = round((c+m+e)/3);
        record[name] = {name,a,c,m,e};
        the_A.push_back(a);
        the_C.push_back(c);
        the_M.push_back(m);
        the_E.push_back(e);
    }
    sort(the_A.begin(),the_A.end());
    sort(the_C.begin(),the_C.end());
    sort(the_M.begin(),the_M.end());
    sort(the_E.begin(),the_E.end());
    

    
    while(M--)
    {
        string the_name;
        cin >> the_name;
        if(record.count(the_name)==0)
        {
            puts("N/A");
        }
        else{
             
            char best = 'A';
            int best_score = 2010;
            for(int i=0;i<4;i++)
            {
                int find_score;
                if(i==0)
                {
                    find_score = find(the_A,record[the_name].A);
                    if(find_score<best_score)
                    {
                        best = 'A';
                        best_score = find_score;
                    }
                }
                else if(i==1){
                    find_score = find(the_C,record[the_name].C);
                    if(find_score<best_score)
                    {
                        best = 'C';
                        best_score = find_score;
                    }
                }
                else if(i==2){
                    find_score = find(the_M,record[the_name].M);
                    if(find_score<best_score)
                    {
                        best = 'M';
                        best_score = find_score;
                    }
                }
                else if(i==3){
                    find_score = find(the_E,record[the_name].E);
                    if(find_score<best_score)
                    {
                        best = 'E';
                        best_score = find_score;
                    }
                }
            }
            cout<<best_score<<" "<<best<<endl;
        }
        
    }
    
    return 0;
}

PAT1025

这个题就是个降序的二分
pat1025

#include<iostream>
#include<algorithm>
#include<vector>

using namespace std;

struct Person{
    string name;
    int area,score,total_rank,local_rank;
};

bool cmp(Person& a,Person& b)  //注意加上&
{
    if(a.score!=b.score) return a.score>b.score;
    else return a.name<b.name;
}

int find_rank(vector<Person>& the_record,int score_get)
{
    int start = 0;
    int end = the_record.size()-1;
    //找到降序排列的第一次出现的位置
    while(start<end)
    {
        int mid = (start+end)/2;
        if(the_record[mid].score<=score_get) end = mid;
        else start = mid + 1;
    }
    
    //找到降序排列最后一次出现的位置
    /*
    while(start<end)
    {
        int mid = (start+end+1)/2;
        if(the_record[mid].score>=score_get) start = mid;
        else end = mid - 1;
    }
    */
    return start+1;
}

vector<Person> record;
int main()
{
    int N;
    cin >> N;
    for(int i=1;i<=N;i++)
    {
        int k;
        cin >> k;
        vector<Person> local_record;
        
        while(k--)
        {
            string the_name;
            int the_score;
            cin >> the_name >> the_score;
            Person person = {the_name,i,the_score,1,1};
            local_record.push_back(person);
        }
        
        sort(local_record.begin(),local_record.end(),cmp);

        for(int j=0;j<local_record.size();j++)
        {
            int the_score_get = local_record[j].score;
            int the_rank_new = find_rank(local_record,the_score_get);
            local_record[j].local_rank = the_rank_new;
            record.push_back(local_record[j]);
        }
    }
    
    
  //假如你定义的vector变量为vector<Type> num，则如下：
  //sort(num.begin(), num.end(), sortFun);
  //然后如果是基本类型假如是int,第三个参数可以使用系统自带的less<int>()或者greater<int>()，
  //假如是自定义类型话或者复杂类型就需自己定义比较规则函数sortFun,
    sort(record.begin(),record.end(),cmp);
    for(int i=0;i<record.size();i++)
    {
        record[i].total_rank = find_rank(record,record[i].score);
    }
    cout<<record.size()<<endl;
    for(int i=0;i<record.size();i++)
    {
        cout << record[i].name << " "<<record[i].total_rank<<" "<<record[i].area<<" "<<record[i].local_rank<<endl;
    }
    
    return 0;
}