2023-2-27 刷题情况

求出最多标记下标

题目描述

给你一个下标从 0 开始的整数数组 nums 。

一开始，所有下标都没有被标记。你可以执行以下操作任意次：

选择两个 互不相同且未标记 的下标 i 和 j ，满足 2 * nums[i] <= nums[j] ，标记下标 i 和 j 。
请你执行上述操作任意次，返回 nums 中最多可以标记的下标数目。

样例

样例输入

nums = [3,5,2,4]
nums = [9,2,5,4]
nums = [7,6,8]

样例输出

2
解释：第一次操作中，选择 i = 2 和 j = 1 ，操作可以执行的原因是 2 * nums[2] <= nums[1] ，标记下标 2 和 1 。
没有其他更多可执行的操作，所以答案为 2 。

4
解释：第一次操作中，选择 i = 3 和 j = 0 ，操作可以执行的原因是 2 * nums[3] <= nums[0] ，标记下标 3 和 0 。
第二次操作中，选择 i = 1 和 j = 2 ，操作可以执行的原因是 2 * nums[1] <= nums[2] ，标记下标 1 和 2 。
没有其他更多可执行的操作，所以答案为 4 。

0
解释：没有任何可以执行的操作，所以答案为 0 。

提示

• $1<=nums.length<=10^5$
• $1<=nums[i]<=10^9$

思路

遇到这个题目，反正我是没想出来用二分，事后看的题解，真是又开拓思路了，要使多种解法都没思路，看看能不能看出答案是否具有单调性。
这题的单调性是ans越小越能有ans对组合，ans越大，能组成的情况越小。

代码实现

class Solution {
    public int maxNumOfMarkedIndices(int[] nums) {
        int n = nums.length;
        Arrays.sort(nums);
        int l = 0, r = n / 2;
        while(l < r){
            int mid = (l + r + 1) / 2;
            if(check(nums, mid)) l = mid;
            else r = mid - 1;
        }
        return l * 2;
    }

    private boolean check(int[] nums, int k){
        for(int i = 0; i < k; i++){
            if(nums[i] * 2 > nums[nums.length - k + i]) return false;
        }
        return true;
    }
}

递减元素使数组呈锯齿状

题目描述

给你一个整数数组 nums，每次 操作 会从中选择一个元素并 将该元素的值减少 1。

如果符合下列情况之一，则数组 A 就是 锯齿数组：

每个偶数索引对应的元素都大于相邻的元素，即 A[0] > A[1] < A[2] > A[3] < A[4] > …
或者，每个奇数索引对应的元素都大于相邻的元素，即 A[0] < A[1] > A[2] < A[3] > A[4] < …
返回将数组 nums 转换为锯齿数组所需的最小操作次数。

样例

样例输入

nums = [1,2,3]
nums = [9,6,1,6,2]

样例输出

2
解释：我们可以把 2 递减到 0，或把 3 递减到 1。

4

提示

• 1 <= nums.length <= 1000
• 1 <= nums[i] <= 1000

思路

因为只有减少，那么只需要考虑了使得数组变为两种情况的最小代价即可。

代码实现

class Solution {
    public int movesToMakeZigzag(int[] nums) {
        int n = nums.length;
        int[] ans = new int[2];
        for(int i = 0; i < n; i++){
            int l = i > 0 ? nums[i - 1] : Integer.MAX_VALUE;
            int r = i < n - 1 ? nums[i + 1] : Integer.MAX_VALUE;
            ans[i & 1] += Math.max(nums[i] -  Math.min(l, r) + 1, 0);
        }
        return Math.min(ans[0], ans[1]);
    }
}
``