刷题记录之递减，递增序列

刷题遇到一个很有意思的解法，递减序列/递增序列；
问题详情见：添加链接描述
抄的官方解答：添加链接描述

在本题中，自己的思路原来是：构造一个容量为k的大顶堆，从第k个往nums.length遍历，每次dp[i]=大顶堆中堆顶元素+nums[i],然后从大顶堆中弹出的dp[left]，left右移；再把dp[i]加入到大顶堆中。
时间复杂度：O(nlgk)；
空间复杂度：O(k);

这是自己可以想出的最复杂的方法了，对于该过程的模拟，可是还是由于时间复杂度给爆掉了;
代码如下：

class Solution {
 public int[] maxSlidingWindow(int[] nums, int k) {
        int[] res = new int[nums.length-k+1];
        int index = 0;
        //构造一个大顶堆
        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer i1, Integer i2) {
                return i2-i1;
            }
        });
		//初始化前k个元素
        for(int i = 0;i < k;i++){
            pq.offer(nums[i]);
        }
        //维护一个left指针，用来记录最左边的，每往后右移一个，就从大顶堆中弹出dp[left]；
        //相当于滑动窗口的使用;
        int left = 0;
        int right = left+k;
        res[index++] = pq.peek();
        //当右指针right没有移动到超出nums数组长度的时候,一直右移;
        while(right < nums.length){
            pq.remove(nums[left]);
            left++;
            pq.offer(nums[right]);
            right++;
            res[index++] = pq.peek();
        }
        return res;
    }
}

自己的解法没有通过，通过看解析，看懂了这么一个解法，为了以后方便复习，在这里记录：
在该解法中自己学到了一些想法：

1. 1)记录的时候，不一定非要记录元素nums[index]什么的，可以方便的来直接记录index,当使用的时候，直接使用nums[index]来进行转换;
   2)当使用索引来记录的时候，就会带来很多方便，如每次想判断某一个元素在没在这个范围内，该最大值可不可以使用，就直接，每次索引递增的时候，来通过i-k来与deq.getFirst()进行比较，如果相等，则表明刚过这个元素，需要移除，从而保证了队列中的元素始终在[i-k,i]之间;
   3) 因为需要每次找前k个里面最大的元素，因此，我们如果正在访问的元素比前面的大，就弹出前面的，知道没有前面的元素大或者队列变空;于是整个队列就形成了一个单调递减队列;
   4)还有就是ArrayDeque挺好用的，双端队列可以两边同时进行插入，删除，以后应该常记得使用;

class Solution {
    ArrayDeque<Integer> deq = new ArrayDeque<>();
    int[] nums;
    public void clean_deque(int i,int k){
		//如果队列不空且队首元素刚过时，需要弹出  
		//该条件不明白的话需要自己模拟一遍
        if(!deq.isEmpty() && deq.getFirst() == i-k){
            deq.removeFirst();
        }
        //如果队列不空且正在访问的元素比队尾元素大，需要弹出队尾元素;
        while(!deq.isEmpty() && nums[i] > nums[deq.getLast()]){
            deq.removeLast();
        }
        
    }
    
    
    public int[] maxSlidingWindow(int[] nums, int k) {
        //这一个num.length*k == 0条件比较有意思，表示两个如果有一个为空
        if(nums.length*k == 0){
            return new int[0];
        }else if(k == 1){
            return nums;
        }
        
        this.nums = nums;
        int max_id = 0;
        //初始化队列;
        for(int i = 0;i < k;i++){
            clean_deque(i,k);
            deq.addLast(i);
            if(nums[i] > nums[max_id]){
                max_id = i;
            }
        }
        
        int[] output = new int[nums.length-k+1];
        output[0] = nums[max_id];
        
        //访问其余剩余元素;
        for(int i = k;i < nums.length;i++){
            clean_deque(i,k);
            deq.addLast(i);
            //每次该范围内最大的元素都在队首
            output[i-k+1] = nums[deq.getFirst()];
        }
        return output;
    }
}

注意一下，在使用索引来记录，每次使用时需要通过数组来进行转换，不要忘记，切记切记！
具体的可以参考这个题：添加链接描述

这是官方题解给出的第二种解法，使用动态规划，分别从左和右记录两个数组，分别为left和right数组，每一个值是数组left和right在该位置的left最大和right的最右边界值最大，选出最大的，即为该位置应该是的;

class Solution {
  public int[] maxSlidingWindow(int[] nums,int k){
        int n = nums.length;
        if(n*k == 0){
            return new int[0];
        }else if(k == 1){
            return nums;
        }

        int[] left = new int[n];

        left[0] = nums[0];

        int[] right = new int[n];

        right[n-1] = nums[n-1];

        for(int i = 1;i < n;i++){
            //从左到右
            //块头
            if(i% k == 0){
                left[i] = nums[i];
            }else{
                left[i] = Math.max(left[i-1],nums[i]);
            }

            //从右到左
            int j = n-i-1;
            //块尾
            if((j+1)%k == 0){
                right[j] = nums[j];
            }else{
                right[j] = Math.max(right[j+1],nums[j]);
            }

        }
        int[] output = new int[n-k+1];
        for(int i = 0;i < n-k+1;i++){
            output[i] = Math.max(left[i+k-1],right[i]);
        }
        return output;
    }
}