1563分的简单题，可能就简单在能被暴力AC

简单题，没思路的话试试暴力解法？至少先AC了再考虑优化

Problem: 2970. 统计移除递增子数组的数目 I

前言

这道题其实也是来自于周赛的一道题，而且虽然类型是简单，但是难度分可不低,1563分。

我第一眼看上去也是没有什么思路，所以大家不要灰心，这是常有的事情。

有些时候第一眼可能就会想太多，直接去想优化后的解法，考虑时间复杂度等等，诸多因素桎梏了我们的解题。

有句老话不是说"简单题，简单做"嘛，再加上这题的nums的长度只有50。

因此为了AC，我们直接可以考虑暴力解法。

思路

枚举目标数组nums的全部的子数组（子数组以index的形式进行存储），然后遍历全部的子数组结果，让目标数组nums过滤掉子数组中的index，判断过滤后的数组是否是严格递增的、或者数组长度是否为1、或者数组长度是否为0，是，则计数加一。

解题过程

如何判断一个数组是否严格递增？最先想到的肯定是俩俩比较对吧，后者一定比前者大，因此我们可以很快写一个O(n)的判断子数组是否严格递增的方法。之后就是枚举子数组的过程了，这里就和我们前几天写的那道题3101. 交替子数组计数很相似了。我自己是从长度为1到长度为nums.length去枚举子数组的。

判断是否严格递增

js 复制代码

 const isArrayStrictlyIncreasing = (arr) => {
        let flag = true;
        for (let i = 0; i < arr.length - 1; i++) {
            if (arr[i] >= arr[i + 1]) {
                flag = false;
            }
        }
        return flag;
    }

枚举子数组

js 复制代码

    let subArrayLength = 1;
    while (subArrayLength <= nums.length) {
        let result = []
        for (let i = 0; i < nums.length; i++) {
            let temp = [i];
            for (let j = i + 1; j < i + subArrayLength; j++) {
                if (j < nums.length) {
                    temp.push(j)

                }
            }
            if (temp[temp.length - 1] - temp[0] + 1 >= subArrayLength) {
                result.push(temp)
            }
        }
        subArrayLength++;
    }

取巧

如果nums在最开始就是一个严格递增的数组，那么它的全部子数组都可以被去掉，去掉后仍保持严格递增。因此遇到这种情况，我们直接return一个求和公式

js 复制代码

    // 如果数组本身就是严格递增的，则直接return
    if (isArrayStrictlyIncreasing(nums)) {
        return (1 + nums.length) * nums.length / 2;
    }

复杂度

时间复杂度:
空间复杂度: O(N)

Code

js 复制代码

/**
 * @param {number[]} nums
 * @return {number}
 */
var incremovableSubarrayCount = function (nums) {
    // 由于nums的长度只有50，因此可以考虑暴力的解法

    let count = 0;
    const isArrayStrictlyIncreasing = (arr) => {
        let flag = true;
        for (let i = 0; i < arr.length - 1; i++) {
            if (arr[i] >= arr[i + 1]) {
                flag = false;
            }
        }
        return flag;
    }

    // 如果数组本身就是严格递增的，则直接return
    if (isArrayStrictlyIncreasing(nums)) {
        return (1 + nums.length) * nums.length / 2;
    }

    let subArrayLength = 1;
    while (subArrayLength <= nums.length) {
        let result = []
        for (let i = 0; i < nums.length; i++) {
            let temp = [i];
            for (let j = i + 1; j < i + subArrayLength; j++) {
                if (j < nums.length) {
                    temp.push(j)

                }
            }
            if (temp[temp.length - 1] - temp[0] + 1 >= subArrayLength) {
                result.push(temp)
            }
        }
        // 遍历长度为subArrayLength的子数组集合，用nums过滤，之后判断是否严格递增。
        for (let i = 0; i < result.length; i++) {
            let newArray = nums.filter((item, index) => !result[i].includes(index))
            if (isArrayStrictlyIncreasing(newArray)) {
                count++;
            }
            else if (newArray.length === 1) {
                count++;
            }
            else if (newArray.length === 0) {
                count++;
            }
            else {
                // do nothing
            }
        }
        subArrayLength++;
    }
    return count;
};