本周培训题目的心得体会

最新推荐文章于 2024-06-21 17:14:10 发布

神奇世界伊甸园

最新推荐文章于 2024-06-21 17:14:10 发布

阅读量218

点赞数

分类专栏：新人周报文章标签：算法 c++

本文链接：https://blog.csdn.net/qq_66056271/article/details/127731729

版权

新人同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

周报

13 篇文章 0 订阅

订阅专栏

1.二分查找

题目描述

输入 n 个不超过 $10^{9}$ 的单调不减的（就是后面的数字不小于前面的数字）非负整数 a1,a2,…,an，然后进行 m 次询问。对于每次询问，给出一个整数 q，要求输出这个数字在序列中第一次出现的编号，如果没有找到的话输出 -1。

输入格式

第一行 2 个整数 n 和 m，表示数字个数和询问次数。

第二行 n 个整数，表示这些待查询的数字。

第三行 m 个整数，表示询问这些数字的编号，从 1 开始编号。

输出格式

输出一行，m 个整数，以空格隔开，表示答案。

输入输出样例

输入 #1

11 3
1 3 3 3 5 7 9 11 13 15 15
1 3 6

输出 #1

1 2 -1

说明/提示

数据保证， $1\leq n \leq 10^{6}, 0 \leq a_{i} , q\leq 10^{9}, 1\leq m \leq 10^{5}$ ;

本题输入输出量较大，请使用较快的 IO 方式。

这题我看了题目本来觉得是so-easy的，但是提交了好几次硬是过不了，原因就在于如何处理那些重复出现的数（题目要求输出第一次出现的下标），就在这里纠缠了好久，用while遍历到第一个呢，不行，因为这样就违背了二分法的原则了，在数目很多的情况下，运行超时变得无可避免。因为我们的二分查找本来就是一个类似递归的概念，因此我们没必要再使用递归了。当我看了另一个题的题解后突然茅塞顿开，接下来上代码。

#include <iostream>
using namespace std;
int find(int *arr, int start, int end, int tofind)
{
    //start为开始下标，end为结束下标
    int L = start, R = end, pos = L+(R-L)/2;
    int ans = -2;
    while(R >= L)
    {
        pos = L+(R-L)/2;
        if(arr[pos] == tofind)  //找到的话就存下下标，然后在前面继续二分查找
        {
            ans = pos;
            R = pos-1;
        }
        else if(arr[pos] < tofind)
        {
            L = pos+1;
        }
        else
        {
            R = pos-1;
        }
    }
    return ans;
}
int main()
{
    int m, n;
    scanf("%d %d", &m, &n);
    int *arr = new int[m];

    for(int i = 0; i < m; i++)
        scanf("%d", &arr[i]);
    
    int num = 0;
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &num);
        printf("%d ", find(arr, 0, m-1, num)+1);
    }
    delete[] arr;
    return 0;
}

其他的地方不难理解，就是对于重复数据处理这块上，如果找到了，就存下答案，然后让R=pos-1，不要退出循环。这样的话如果前面还能找到的话，ans变量可以重新被赋值，直到到达第一次出现的地方。如果没找到重复出现的情况，那么在后面循环中我们也不会对ans重新赋值，所以无论是否重复出现，最终ans都能得到第一次出现的下标。因此该问题就得以解决。

2.二分答案-进击的奶牛

看到这题我突然想到了pvz的狂野西部，接着就想起了前段时间卡了好久的拓展boss......（bushi）

题目描述

Farmer John 建造了一个有 $N(2 \leq N \leq 100000)$ 个隔间的牛棚，这些隔间分布在一条直线上，坐标是 $x_{1}, x_{2}, ......, x_{N}$ (0 ≤ N ≤ 1000000000)。

他的 C(2≤ C ≤ N) 头牛不满于隔间的位置分布，它们为牛棚里其他的牛的存在而愤怒。为了防止牛之间的互相打斗，Farmer John 想把这些牛安置在指定的隔间，所有牛中相邻两头的最近距离越大越好。那么，这个最大的最近距离是多少呢？

输入格式

第 1 行：两个用空格隔开的数字 N 和 C。

第 2 ~ N+1 行：每行一个整数，表示每个隔间的坐标。

输出格式

输出只有一行，即相邻两头牛最大的最近距离。

输入输出样例

输入 #1

输出 #1

这题猛的一看感觉和二分法没什么关系。但是再仔细想，能有什么办法？最先想到的就是遍历所有路径，但是当C和N很大时，算法的时间复杂度就趋于O(2^n)，因此靠蛮力解决问题是不行的，但是我们这样想，我们如果已知了一个距离，要让根据这个距离分配牛的位置让牛之间的最小间隔不能小于这个距离，那么我们是可以做到的（把第一个牛放在第一个位置，之后依次寻找下一个牛的位置，如果排到最后一个位置之前能把所有的牛排上，那么这个距离就满足题意，否则就不行），我们二分遍历所有可能的情况，直到找到一个最小满足题意的答案就可以了。

下面就是上代码环节，注意下循环的次数，只用考虑后面c-1头牛就行，然后注意题目没有说明一定是从小到大的顺序给出，所以需要自己排序，这里使用sort函数。

#include <iostream>
#include <algorithm>
using namespace std;
//arr为坐标数组，n为数组长度，a为检验距离，c为牛的个数
bool check(int *arr, int n, int a, int c)
{
    int now = 0, next = 0;
    //第一头牛已经定位，所以只需要考虑后两头牛
    for(int i = 0; i < c-1; i++)
    {
        next = now+1;
        while(next < n)
        {
            if(arr[next] - arr[now] >= a)
            {
                break;
            }
            else
            {
                next ++;
            }
        }
        now = next;
        if(now == n)
        {
            return false;    //如果现在的位置无法满足条件，那么就返回错误
        }                    //否则返回正确
    }
    return true;
}
int main()
{
    int n = 0, c = 0;
    cin >> n >> c;
    int *arr = new int[n];

    for(int i = 0; i < n; i++)
        scanf("%d", &arr[i]);
    
    sort(arr, arr+n);
    int L = 0, R = (arr[n-1]-arr[0])/(c-1);    //R是理论上的最大值
    int pos = L+(R-L)/2, ans = 0;
    while(L <= R)
    {
        pos = L+(R-L)/2;
        if(check(arr, n, pos, c))              //有可能pos就是最大也有可能不是
        {
            ans = pos;
            L = pos+1;
        }
        else
        {
            R = pos-1;
        }
    }
    printf("%d", ans);
    delete[] arr;
    return 0;
}

3.二分答案-跳石头

题目背景

一年一度的“跳石头”比赛又要开始了!

题目描述

这项比赛将在一条笔直的河道中进行，河道中分布着一些巨大岩石。组委会已经选择好了两块岩石作为比赛起点和终点。在起点和终点之间，有 N 块岩石（不含起点和终点的岩石）。在比赛过程中，选手们将从起点出发，每一步跳向相邻的岩石，直至到达终点。

为了提高比赛难度，组委会计划移走一些岩石，使得选手们在比赛过程中的最短跳跃距离尽可能长。由于预算限制，组委会至多从起点和终点之间移走 M 块岩石（不能移走起点和终点的岩石）。

输入格式

第一行包含三个整数 L,N,M分别表示起点到终点的距离，起点和终点之间的岩石数，以及组委会至多移走的岩石数。保证 L ≥1 且 N ≥ M ≥ 0。

接下来 N 行，每行一个整数，第 i 行的整数 Di( 0 < Di < L)，表示第 i 块岩石与起点的距离。这些岩石按与起点距离从小到大的顺序给出，且不会有两个岩石出现在同一个位置。

输出格式

一个整数，即最短跳跃距离的最大值。

输入输出样例

输入 #1复制

输出 #1复制

说明/提示

输入输出样例 1 说明

将与起点距离为 2和 14 的两个岩石移走后,最短的跳跃距离为 4(从与起点距离 17 的岩石跳到距离 21 的岩石,或者从距离 21 的岩石跳到终点)。

数据规模与约定

对于 20%的数据，100≤M≤N≤10。
对于 50%的数据，1000≤M≤N≤100。
对于 100%的数据，0≤M≤N≤50000,1≤L≤ $10^{9}$ 。

这个题的本质和第二题一样，但是我做到这里时就有些犯迷糊了，后来我才明白。

这题也需要自己用二分法遍历可能的答案，然后代入某一个函数来验证即可。

验证函数的编写和2题类似，找寻距离大于等于检测值的下一个石头，直到最后到达终点，看能不能走够给定数量的石头。如果没有走完或者刚好走完那就是一定可以（对于没有走完的情况，虽然没有走完，但是事实上如果跳步的话就能满足最小距离大于等于检测距离且到达终点了）此题的数据已经排好序了，所以不用编写排序函数。

#include <iostream>
#include <algorithm>
using namespace std;
//arr为坐标数组，n为数组长度，a为检验距离，c为石头的个数
bool check(int *arr, int n, int a, int c)
{
    int now = 0, next = 0;
    for(int i = 0; i < c+1; i++)    //next包括最后一个石头但是不包括第一个
    {
        next = now + 1;
        while(next < n && arr[next]-arr[now] < a)
        {
            next ++;
        }
        now = next;
        if(now == n)    //不是最后一个石头，但是已经到达终点
        {
            return false;
        }
    }
    return true;
}
int main()
{
    int l, n, m;
    cin >> l >> n >> m;
    int *arr = new int[n+2];
    for(int i = 1; i <= n; i++)
    {
        cin >> arr[i];
    }
    arr[0] = 0, arr[n+1] = l;
    int L = 0, R = l/(n-m+1);
    int ans = 0, pos = L +(R-L)/2;
    while(L <= R)
    {
        pos = L +(R-L)/2;
        if(check(arr, n+2, pos, n-m))
        {
            ans = pos;
            L = pos+1;
        }
        else
        {
            R = pos-1;
        }
    }
    cout << ans << endl;
    delete[] arr;
    return 0;
}