Acwing二分整理

1、数组中数值和下标相等的元素

解题思路

单调性 二分
mid左边的数会小于mid，mid右边的数会大于mid,符合单调性

AC代码

class Solution {
public:
    int getNumberSameAsIndex(vector<int>& nums) {
        int l = 0, r = nums.size() - 1;
        while (l < r){
            int mid = l + r >> 1;
            if (mid <= nums[mid]) r = mid;
            else l = mid + 1;
        }
        if (l == nums[l])
        return l;
        else 
        return -1;
    }
};

2、不修改数组找出重复的数字

解题思路

(暴力枚举) O(n)O(n)
直接搜索

AC代码

class Solution {
public:
    int ans[1010];
    int duplicateInArray(vector<int> & nums) {
        for (auto x : nums)
            if (++ ans[x] > 1) return x;
    }
};

虽然我是这么做的 但是放在整理里面显然不合适 那么就来看一下恩师yxc大神的正经分析思路

yxc题解入口

解题思路

算法
(分治，抽屉原理) O(nlogn)O(nlogn)
这道题目主要应用了抽屉原理和分治的思想。

抽屉原理：n+1 个苹果放在 n 个抽屉里，那么至少有一个抽屉中会放两个苹果。

用在这个题目中就是，一共有 n+1 个数，每个数的取值范围是1到n，所以至少会有一个数出现两次。

然后我们采用分治的思想，将每个数的取值的区间[1, n]划分成[1, n/2]和[n/2+1, n]两个子区间，然后分别统计两个区间中数的个数。
注意这里的区间是指 数的取值范围，而不是 数组下标。

划分之后，左右两个区间里一定至少存在一个区间，区间中数的个数大于区间长度。
这个可以用反证法来说明：如果两个区间中数的个数都小于等于区间长度，那么整个区间中数的个数就小于等于n，和有n+1个数矛盾。

因此我们可以把问题划归到左右两个子区间中的一个，而且由于区间中数的个数大于区间长度，根据抽屉原理，在这个子区间中一定存在某个数出现了两次。

依次类推，每次我们可以把区间长度缩小一半，直到区间长度为1时，我们就找到了答案。

复杂度分析
时间复杂度：每次会将区间长度缩小一半，一共会缩小 O(logn)O(logn) 次。每次统计两个子区间中的数时需要遍历整个数组，时间复杂度是 O(n)O(n)。所以总时间复杂度是 O(nlogn)O(nlogn)。
空间复杂度：代码中没有用到额外的数组，所以额外的空间复杂度是 O(1)O(1)。

AC代码

class Solution {
public:
    int duplicateInArray(vector<int>& nums) {
        int l = 1, r = nums.size() - 1;
        while (l < r) {
            int mid = l + r >> 1; // 划分的区间：[l, mid], [mid + 1, r]
            int s = 0;
            for (auto x : nums) s += x >= l && x <= mid;
            if (s > mid - l + 1) r = mid;
            else l = mid + 1;
        }
        return r;
    }
};

3、数据在排序数组中出现的次数

思路一：二分

AC代码

class Solution {
public:
    int getNumberOfK(vector<int>& nums , int k) {
        if(nums.empty()) 
        return 0;
        int l = 0, r = nums.size() - 1;
        while (l < r) {
            int mid = l + r >> 1;
            if(nums[mid] >= k) r = mid;
            else l = mid + 1;
        }
        int left = l;
        if(nums[l]!= k) return 0;//这里加一个判断条件，用来通过nums中没有k的情况
        l = 0, r = nums.size() - 1;
        while (l < r){
            int mid = l + r + 1 >> 1;
            if(nums[mid] <= k) l = mid;
            else r = mid - 1;
        }
        int right = l;
        return right - left + 1;
    }
};

思路二：遍历vector

AC代码

class Solution {
public:
    int getNumberOfK(vector<int>& nums, int k) {
        int cnt = 0;
        for(int x : nums)
            if(x == k)
             cnt++;
        return cnt;
    }
};

4、 0到n-1中缺失的数字

解题思路：

方法很多 我使用的是二分 y总视频讲解里用的是哈希表

利用y总给的二分代码模板。
y总模板的使用技巧是：使用某种判断条件将数组分为左右两个子数组，若右子数组是满足条件的，用模板1进行二分知道找出右子数组的最左侧的点；若左子数组是满足条件的，用模板2进行二分找出左子数组最右侧的点。

AC代码（二分）

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int len = nums.size();
        if(len == 0)return -1;
        /*将数组分为左右两个数组，左子数组下标和值对应，右子数组下标和值
        不对应，利用二分法的模板2，求出满足左子数组的最右侧端点，该端点的索引+1
        即为缺失的数字
        */
        if(nums[0] != 0)return 0;//边界特判，左子数组长度等于0的情况
        int l = 0, r = len - 1;
        while(l < r){
            int mid = l + (r - l) / 2 + 1;
            if(nums[mid] == mid)l = mid;
            else r = mid - 1;
        }
        return l + 1;
    }
};

AC代码（哈希表）

class Solution {
public:
    int getMissingNumber(vector<int>& nums) {
        unordered_set<int> S;
        for (int i = 0; i <= nums.size(); i ++ )S.insert(i);
        for (auto x : nums) S.erase(x);
        return *S.begin();
    }
};

5、旋转数组的最小数字

解题思路：

二分出旋转的点，那个点即是最小值，并对完全单调特判。
时间复杂度 O(n)

AC代码（yxc）

class Solution {
public:
    int findMin(vector<int>& nums) {
        if (nums.empty()) return -1;
        int n = nums.size() - 1;
        while (n > 0 && nums[0] == nums[n]) n -- ;  //去除末尾重复元素
        if (nums[0] <= nums[n]) return nums[0];     //数组完全单调的情况，第一个就是最小元素
        int l = 0, r = n;
        while (l < r){
            int mid = l + r >> 1;                  // [l, mid], [mid + 1, r]
            if (nums[mid] < nums[0]) r = mid;
            else l = mid + 1;
        }
        return nums[l];                             //数组不是完全单调，则分界点是最小元素
    }
};

6、分巧克力

解题思路：

小巧克力边长 a 一定在 1 – 100000 之间
所以只要在 1 – 100000 之间找到一个最大的数，使得所有的 (w[i]/a) * (h[i]/a) 之和大于要求的数量 k。
使用二分法找到 a 的最大取值即为答案。

#include <iostream>
using namespace std;
int const N = 100010;
int w[N], h[N];//存储长、宽
int n, k;
bool chack(int a)
{
    int num = 0;//记录分成长度为 a 的巧克力数量
    for (int i = 0; i < n; i++)
    {
        num += (w[i] / a) * (h[i] / a);//每一大块可以分成的边长为 a 的巧克力数量
        if (num >= k) return true;//大于要求数量，返回真
    }
    return false;
}
int main()
{
    cin >> n >> k;
    for (int i = 0; i < n; i++) cin >> h[i] >> w[i];
    int l = 1, r = 1e5;//小巧克力数量边长一定在 1 -- 100000 之间
    while (l < r)//二分小巧克力边长范围，找到符合要求的最大值
    {
        int mid = l + (r - l + 1 >> 1);//因为l = mid ，所以 mid 取 l + r + 1 >> 1,为了防止加和越界，改写成 l + (r - l + 1 >> 1)
        if (chack(mid)) l = mid;
        else r = mid - 1;
    }
    cout << r;
}