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;
}