1671. 得到山形数组的最少删除次数

题目描述

我们定义 arr是 山形数组 当且仅当它满足：

• arr.length >= 3
• 存在某个下标 i（从 0 开始） 满足 0 < i < arr.length - 1且：
  • arr[0] < arr[1] < ... < arr[i - 1] < arr[i]
  • arr[i] > arr[i + 1] > ... > arr[arr.length - 1]

给你整数数组 nums​ ，请你返回将 nums变成 山形状数组 的​ 最少 删除次数。

做题情况

1. 做出来且思路与标答一致
2. 做出来但思路较为复杂
3. 有思路，但时间复杂度较高无法通过 ☑
4. 没有思路

自己的想法：

自己的想法是单调栈。但后面想了想，单调栈还是有蛮多局限性的，例如删除的元素只能记录前面一个。但由于是需要考虑两个方向的，可能最优解两个方向都并不突出，但合起来很厉害。而单调栈会丢失这一部分。

标答：动态规划——最长递增子序列

整理这道题，一方面是从原本的题目转换到这个问题，还是需要想一想的，最起码自己还是没有想出来。另一方面是因为最长递增子序列的O(nlogn)复杂度的解法自己记得不是很清楚了，因此再来回忆一下。首先两者都是动态规划，但两者的出发点其实还不太一样，相当于是温故而知新了。

方法一：O(n*n)
对于每一个点，我们观察这个点之前的所有点，选取比这个点小，且以当前点结束长度最大的点。这样我们就可以得到以当前点结尾的最长递增子序列。同时我们可以反方向再进行一次，并将两次得到的和相加，即可找到最优点。
需要注意的是，由于题目要求两侧均小于最高点，或者说两侧均有点，因此我们不能选择两个值钟有0的情况。
ps： 之前在思考如何构造O(nlogn)的解时，尝试从这个框架出发，那么相当于对于每个点，我们需要在O(logn)时间复杂度得到小于当前点，且最优的点。需要注意的时，由于大小，以及最大值均没有任何规律，因此使用这样的框架是得不到最优解的。

方法二：O(nlogn)
同样是动态规划，但是切入点有些细微的差别。上一种算法是以当前点结尾的最长长度，这一种是以当前长度结尾的最小元素数。对于每一个元素，我们都在最小值结尾数组钟找到上一个小于这个元素，当前大于这个元素的位置，并将这个元素替代这个位置上的数。由于最小值结尾数组是一个递增的数组，我们使用二分查找只需要O(logn)时间就可以找到这个位置。
其实这种算法确实还蛮抽象的，因为自己刚刚再写的时候还想了很久。但这确实是对的，也可以求得当前元素的最长子序列长度。说实话，我感觉这种算法和单调栈有点类似，但两者确实还是有点差距的hh。
还是在多想一下吧，很难说自己下次遇到可以准确的找到。不过有一点是确定的，就是这个算法确实和单调栈有点像。

实际代码

class Solution {
public:
    int minimumMountainRemovals(vector<int>& nums)
    {
        //啧感觉还是差一点，单调栈会摧毁每个点之前所有的特征，保留下来的只有弹出或者放入的那一个瞬间
        int n = nums.size();
        vector<int>dp1(n);
        dp1[0] = 0; //不包含本身
        for (int i = 1; i < n; ++i)
        {
            int maxnum = 0;
            for (int j = i - 1; j >= 0; --j)
            {
                if (nums[i] > nums[j] && dp1[j] + 1 > maxnum)
                {
                    maxnum = dp1[j] + 1;
                }
            }
            dp1[i] = maxnum;
        }
        vector<int>dp2(n);
        dp2[n - 1] = 0; //同样不包含本身
        for (int i = n - 2; i >= 0; --i)
        {
            int maxnum = 0;
            for (int j = i + 1; j < n; ++j)
            {
                if (nums[i] > nums[j] && dp2[j] + 1 > maxnum)
                {
                    maxnum = dp2[j] + 1;
                }
            }
            dp2[i] = maxnum;
        }
        int res = 0;
        for (int i = 0; i < n; ++i)
        {
            if (dp1[i] && dp2[i] && dp1[i] + dp2[i] + 1 > res) res = dp1[i] + dp2[i] + 1;
        }
        return n - res;
    }
};

总结

我感觉多想想自己是可以想出来的。首先其实时间没有很紧，O(n*n)的复杂度就ok的，单调栈只有O(n)，还是有很多余量的。
另外这种每个元素众生平等且比较依赖相邻元素还是比较能想到动态规划的。可能自己最近做的单调栈的题目太多了，导致自己的思维固化了。前一段时间因为回家，过元旦，状态也没有很好，不过下一阶段就没有什么多的负担了，希望自己这段时间好好搞。