栈模拟 or 双指针 -leetcode-5236. 美化数组的最少删除数

5236. 美化数组的最少删除数

今天周赛的题目

栈-模拟

思路：

1. 栈中元素个数为偶数，相当于下标奇数位置，此时下一个元素可以任意；
2. 栈中元素个数为奇数，相当于下标偶数位置，下一个元素不能和栈顶元素相同；
3. 最终栈中元素即为新数组，若栈中元素个数为奇数，还要额外去掉一个元素（题目要求美丽数组长度为偶数）

class Solution {
    public int minDeletion(int[] nums) {
        int n = nums.length;
        Deque<Integer> stack = new LinkedList<>();
        for (int i = 0; i < nums.length; i++) {
            // 栈中元素个数为偶数，相当于奇数位置，此时下一个元素可以任意
            if (stack.size() % 2 == 0) {
                stack.push(nums[i]);
            } else {
                // 栈中元素个数为奇数，相当于下标偶数位置，下一个元素不能和栈顶元素相同
                if (stack.peek() != nums[i]) {
                    stack.push(nums[i]);
                }
            }
        }
        System.out.println("stack = " + stack);
        // 最终栈中元素即为新数组，若元素个数为奇数，还要额外去掉一个元素
        int size = stack.size();
        return size % 2 == 0 ? n - size : n - (size - 1);
    }
}

• 时间复杂度：$O(n)$
• 时间复杂度：$O(n)$

双指针

思路：

1. 初始化快慢指针：slow = 0;、fast = 1;
2. 遍历 $fast\in [1,n)$
   • 若fast为奇数位置，后面一个元素可以任意；
   • 若fast为偶数位置，下一个数不能和nums[slow]相同：
     • nums[slow] 和 下一个元素$nums[fast]$不同时，可以将$nums[fast]$放入左边的结果数组
     • 相同时，则将fast向右移动

class Solution {
    public int minDeletion(int[] nums) {
        int n = nums.length;
        int slow = 0;
        int fast = 1;
        while (fast < n) {
            if (slow % 2 == 1) { // 奇数位置，后面有一个任意
                nums[++slow] = nums[fast++];
            } else { // 偶数位置，下一个数不能和nums[slow]相同
                if (nums[slow] != nums[fast]) {
                    // 不同时，可以将fast放入左边的结果数组
                    nums[slow++] = nums[fast++];
                } else {
                    // 相同时，则将fast向右移动
                    fast++;
                }
            }
        }
        System.out.println(Arrays.toString(nums));
        System.out.println("slow = " + slow);
        System.out.println("fast = " + fast);
        boolean flag = false;
        // 新数组长度为奇数时，还需减去一个
        if ((slow + 1) % 2 != 0) {
            flag = true;
        }
        int res = fast - (slow + 1);
        return flag ? res + 1 : res;
    }
}

• 时间复杂度：$O(n)$
• 时间复杂度：$O(1)$