1 最大子数组和

1.1 题目链接

1.2 题目描述

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组

是数组中的一个连续部分。

示例 1：

输入： nums = [-2,1,-3,4,-1,2,1,-5,4]
输出： 6
解释： 连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

输入： nums = [1]
输出： 1

示例 3：

输入： nums = [5,4,-1,7,8]
输出： 23

提示：

1 <= nums.length <= 105
-104 <= nums[i] <= 104

1.3 解法（动态规划）

算法思路：

状态表⽰：

对于线性 dp ，我们可以⽤「经验 + 题⽬要求」来定义状态表⽰：
- i. 以某个位置为结尾，巴拉巴拉；
- ii. 以某个位置为起点，巴拉巴拉。
这⾥我们选择⽐较常⽤的⽅式，以「某个位置为结尾」，结合「题⽬要求」，定义⼀个状态表⽰：
- dp[i] 表⽰：以 i 位置元素为结尾的「所有⼦数组」中和的最⼤和。

状态转移⽅程：

dp[i] 的所有可能可以分为以下两种：
- i. ⼦数组的⻓度为 1 ：此时 dp[i] = nums[i] ；
- ii. ⼦数组的⻓度⼤于 1 ：此时 dp[i] 应该等于以 i - 1 做结尾的「所有⼦数组」中和的最⼤值再加上 nums[i] ，也就是 dp[i - 1] + nums[i] 。
由于我们要的是「最⼤值」，因此应该是两种情况下的最⼤值，因此可得转移⽅程：
- dp[i] = max(nums[i], dp[i - 1] + nums[i]) 。

初始化：

可以在最前⾯加上⼀个「辅助结点」，帮助我们初始化。使⽤这种技巧要注意两个点：
- i. 辅助结点⾥⾯的值要「保证后续填表是正确的」；
- ii. 「下标的映射关系」。
在本题中，最前⾯加上⼀个格⼦，并且让 dp[0] = 0 即可。

填表顺序：

根据「状态转移⽅程」易得，填表顺序为「从左往右」。
返回值：

状态表⽰为「以 i 为结尾的所有⼦数组」的最⼤值，但是最⼤⼦数组和的结尾我们是不确定的。因此我们需要返回整个 dp 表中的最⼤值。

1.4 C++算法代码：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n + 1);
        int ret = INT_MIN;
        for(int i = 1; i <= n; i++)
        {
            dp[i] = max(dp[i - 1] + nums[i - 1], nums[i - 1]);
            ret =max(ret, dp[i]);
        }
        return ret;
    }
};

2 环形子数组的最大和

2.1 题目链接

918. 环形子数组的最大和

2.2 题目描述

给定一个长度为 n 的环形整数数组 nums ，返回 nums 的非空 子数组 的最大可能和 。

环形数组 **意味着数组的末端将会与开头相连呈环状。形式上， nums[i] 的下一个元素是 nums[(i + 1) % n] ， nums[i] 的前一个元素是 nums[(i - 1 + n) % n] 。

子数组 最多只能包含固定缓冲区 nums 中的每个元素一次。形式上，对于子数组 nums[i], nums[i + 1], ..., nums[j] ，不存在 i <= k1, k2 <= j 其中 k1 % n == k2 % n 。

示例 1：

输入： nums = [1,-2,3,-2]
输出： 3
解释： 从子数组 [3] 得到最大和 3

示例 2：

输入： nums = [5,-3,5]
输出： 10
解释： 从子数组 [5,5] 得到最大和 5 + 5 = 10

示例 3：

输入： nums = [3,-2,2,-3]
输出： 3
解释： 从子数组 [3] 和 [3,-2,2] 都可以得到最大和 3

提示：

n == nums.length
1 <= n <= 3 * 104
-3 * 104 <= nums[i] <= 3 * 104

2.3 解法（动态规划）

算法思路：

2.4 C++算法代码：

class Solution {
public:
    int maxSubarraySumCircular(vector<int>& nums) {
        int n = nums.size();
        vector<int> f(n + 1), g(n + 1);
        int fmax = INT_MIN, gmin = INT_MAX, sum = 0;
        for(int i = 1; i <= n; i++)
        {
            int x = nums[i - 1];
            f[i] = max(x, x + f[i - 1]);
            fmax = max(f[i], fmax);
            g[i] = min(x, x + g[i - 1]);
            gmin = min(g[i], gmin);
            sum += x;
        }
        return sum == gmin ? fmax : max(fmax, sum - gmin);
    }
};

3 乘积最大子数组

3.1 题目链接

152. 乘积最大子数组

3.2 题目描述

给你一个整数数组 nums ，请你找出数组中乘积最大的非空连续

子数组

（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

测试用例的答案是一个 32-位 整数。

示例 1:

输入: nums = [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

示例 2:

输入: nums = [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

提示:

1 <= nums.length <= 2 * 104
-10 <= nums[i] <= 10
nums 的任何前缀或后缀的乘积都保证是一个 32-位 整数

3.3 解法（动态规划）

算法思路：

这道题与「最⼤⼦数组和」⾮常相似，我们可以效仿着定义⼀下状态表⽰以及状态转移：

i. dp[i] 表⽰以 i 为结尾的所有⼦数组的最⼤乘积，
ii. dp[i] = max(nums[i], dp[i - 1] * nums[i]) ；

由于正负号的存在，我们很容易就可以得到，这样求 dp[i] 的值是不正确的。因为 dp[i -1] 的信息并不能让我们得到 dp[i] 的正确值。⽐如数组 [-2, 5, -2] ，⽤上述状态转移得

到的 dp数组为 [-2, 5, -2] ，最⼤乘积为 5 。但是实际上的最⼤乘积应该是所有数相乘，结果为 20 。

究其原因，就是因为我们在求 dp[2] 的时候，因为 nums[2] 是⼀个负数，因此我们需要的是「 i - 1 位置结尾的最⼩的乘积（-10）」，这样⼀个负数乘以「最⼩值」，才会得到真实的最⼤值。

因此，我们不仅需要⼀个「乘积最⼤值的 dp 表」，还需要⼀个「乘积最⼩值的 dp 表」。

状态表⽰：
- f[i] 表⽰：以 i 结尾的所有⼦数组的最⼤乘积，
- g[i] 表⽰：以 i 结尾的所有⼦数组的最⼩乘积。
状态转移⽅程：

遍历每⼀个位置的时候，我们要同步更新两个 dp 数组的值。
对于 f[i] ，也就是「以 i 为结尾的所有⼦数组的最⼤乘积」，对于所有⼦数组，可以分为下⾯三种形式：
- i. ⼦数组的⻓度为 1 ，也就是 nums[i] ；
- ii. ⼦数组的⻓度⼤于 1 ，但 nums[i] > 0 ，此时需要的是 i - 1 为结尾的所有⼦数组的最⼤乘积 f[i - 1] ，再乘上 nums[i] ，也就是 nums[i] * f[i - 1] ；
- iii. ⼦数组的⻓度⼤于 1 ，但 nums[i] < 0 ，此时需要的是 i - 1 为结尾的所有⼦数组的最⼩乘积 g[i - 1] ，再乘上 nums[i] ，也就是 nums[i] * g[i - 1] ；
（如果 nums[i] = 0 ，所有⼦数组的乘积均为 0 ，三种情况其实都包含了）
综上所述， f[i] = max(nums[i], max(nums[i] * f[i - 1], nums[i] * g[i - 1]) )。
对于 g[i] ，也就是「以 i 为结尾的所有⼦数组的最⼩乘积」，对于所有⼦数组，可以分为下⾯三种形式：
- i. ⼦数组的⻓度为 1 ，也就是 nums[i] ；
- ii. ⼦数组的⻓度⼤于 1 ，但 nums[i] > 0 ，此时需要的是 i - 1 为结尾的所有⼦数组的最⼩乘积 g[i - 1] ，再乘上 nums[i] ，也就是 nums[i] * g[i - 1] ；
- iii. ⼦数组的⻓度⼤于 1 ，但 nums[i] < 0 ，此时需要的是 i - 1 为结尾的所有⼦数组的最⼤乘积 f[i - 1] ，再乘上 nums[i] ，也就是 nums[i] * f[i - 1] ；
综上所述， g[i] = min(nums[i], min(nums[i] * f[i - 1], nums[i] * g[i - 1])) 。
- （如果 nums[i] = 0 ，所有⼦数组的乘积均为 0 ，三种情况其实都包含了）

初始化：

可以在最前⾯加上⼀个辅助结点，帮助我们初始化。使⽤这种技巧要注意两个点：
- i. 辅助结点⾥⾯的值要保证后续填表是正确的；
- ii. 下标的映射关系。
在本题中，最前⾯加上⼀个格⼦，并且让 f[0] = g[0] = 1 即可。

填表顺序：

根据状态转移⽅程易得，填表顺序为「从左往右，两个表⼀起填」。
返回值：

返回 f 表中的最⼤值。

3.4 C++算法代码：

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int n = nums.size();
        vector<double> f(n + 1), g(n + 1);
        f[0] = g[0] = 1; 

        double ret = INT_MIN;
        for(int i = 1; i <= n; i++)
        {
            double x = nums[i - 1], y = f[i - 1] * nums[i - 1], z = g[i - 1] * nums[i - 1];
            f[i] = max(x, max(y, z));
            g[i] = min(x, min(y, z));
            ret = max(ret, f[i]);
        }
        return ret;
    }
};

4 乘积为正数的最长子数组长度

4.1 题目链接

1567. 乘积为正数的最长子数组长度

4.2 题目描述

给你一个整数数组 nums ，请你求出乘积为正数的最长子数组的长度。

一个数组的子数组是由原数组中零个或者更多个连续数字组成的数组。

请你返回乘积为正数的最长子数组长度。

示例 1：

输入： nums = [1,-2,-3,4]
输出： 4
解释： 数组本身乘积就是正数，值为 24 。

示例 2：

输入： nums = [0,1,-2,-3,-4]
输出： 3
解释： 最长乘积为正数的子数组为 [1,-2,-3] ，乘积为 6 。
注意，我们不能把 0 也包括到子数组中，因为这样乘积为 0 ，不是正数。

示例 3：

输入： nums = [-1,-2,-3,0,1]
输出： 2
解释： 乘积为正数的最长子数组是 [-1,-2] 或者 [-2,-3] 。

提示：

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

4.3 解法（动态规划）

算法思路：

继续效仿「最⼤⼦数组和」中的状态表⽰，尝试解决这个问题。
状态表⽰： dp[i] 表⽰「所有以 i 结尾的⼦数组，乘积为正数的最⻓⼦数组的⻓度」。
思考状态转移：对于 i 位置上的 nums[i] ，我们可以分三种情况讨论：
- i. 如果 nums[i] = 0 ，那么所有以 i 为结尾的⼦数组的乘积都不可能是正数，此时dp[i] = 0 ；
- ii. 如果 nums[i] > 0 ，那么直接找到 dp[i - 1] 的值（这⾥请再读⼀遍 dp[i - 1] 代表的意义，并且考虑如果 dp[i - 1] 的结值是 0 的话，影不影响结果），然后加⼀即可，此时 dp[i] = dp[i - 1] + 1 ；
- iii. 如果 nums[i] < 0 ，这时候你该蛋疼了，因为在现有的条件下，你根本没办法得到此时的最⻓⻓度。因为乘法是存在「负负得正」的，单单靠⼀个 dp[i - 1] ，我们⽆法推导出 dp[i] 的值。
但是，如果我们知道「以 i - 1 为结尾的所有⼦数组，乘积为负数的最⻓⼦数组的⻓度」 neg[i - 1] ，那么此时的 dp[i] 是不是就等于 neg[i - 1] + 1 呢？
通过上⾯的分析，我们可以得出，需要两个 dp 表，才能推导出最终的结果。不仅需要⼀个「乘积为正数的最⻓⼦数组」，还需要⼀个「乘积为负数的最⻓⼦数组」。

状态表⽰：
- f[i] 表⽰：以 i 结尾的所有⼦数组中，乘积为「正数」的最⻓⼦数组的⻓度；
- g[i] 表⽰：以 i 结尾的所有⼦数组中，乘积为「负数」的最⻓⼦数组的⻓度。
状态转移⽅程：

遍历每⼀个位置的时候，我们要同步更新两个 dp 数组的值。
对于 f[i] ，也就是以 i 为结尾的乘积为「正数」的最⻓⼦数组，根据 nums[i] 的值，可以分为三种情况：
- i. nums[i] = 0 时，所有以 i 为结尾的⼦数组的乘积都不可能是正数，此时 f[i] = 0 ；
- ii. nums[i] > 0 时，那么直接找到 f[i - 1] 的值（这⾥请再读⼀遍 f[i - 1] 代表的意义，并且考虑如果 f[i - 1] 的结值是 0 的话，影不影响结果），然后加⼀即可，此时 f[i] = f[i - 1] + 1 ；
- iii. nums[i] < 0 时，此时我们要看 g[i - 1] 的值（这⾥请再读⼀遍 g[i - 1] 代表的意义。因为负负得正，如果我们知道以 i - 1 为结尾的乘积为负数的最⻓⼦数组的⻓度，加上 1 即可），根据 g[i - 1] 的值，⼜要分两种情况：
  - 1. g[i - 1] = 0 ，说明以 i - 1 为结尾的乘积为负数的最⻓⼦数组是不存在的，⼜因为 nums[i] < 0 ，所以以 i 结尾的乘积为正数的最⻓⼦数组也是不存在的，此时 f[i] = 0 ；
  - 1. g[i - 1] != 0 ，说明以 i - 1 为结尾的乘积为负数的最⻓⼦数组是存在的，⼜因为 nums[i] < 0 ，所以以 i 结尾的乘积为正数的最⻓⼦数组就等于 g[i - 1] + 1 ；
综上所述， nums[i] < 0 时， f[i] = g[i - 1] == 0 ? 0 : g[i - 1] + 1;
- 对于 g[i] ，也就是以 i 为结尾的乘积为「负数」的最⻓⼦数组，根据 nums[i] 的值，可以分为三种情况：
- i. nums[i] = 0 时，所有以 i 为结尾的⼦数组的乘积都不可能是负数，此时 g[i] = 0 ；
- ii. nums[i] < 0 时，那么直接找到 f[i - 1] 的值（这⾥请再读⼀遍 f[i - 1] 代表的意义，并且考虑如果 f[i - 1] 的结值是 0 的话，影不影响结果），然后加⼀即可（因为正数 * 负数 = 负数），此时 g[i] = f[i - 1] + 1 ；
- iii. nums[i] > 0 时，此时我们要看 g[i - 1] 的值（这⾥请再读⼀遍 g[i - 1] 代表的意义。因为正数 * 负数 = 负数），根据 g[i - 1] 的值，⼜要分两种情况：
  - 1. g[i - 1] = 0 ，说明以 i - 1 为结尾的乘积为负数的最⻓⼦数组是不存在的，⼜因为 nums[i] > 0 ，所以以 i 结尾的乘积为负数的最⻓⼦数组也是不存在的，此时 f[i] = 0 ；
  - 1. g[i - 1] != 0 ，说明以 i - 1 为结尾的乘积为负数的最⻓⼦数组是存在的，⼜因为 nums[i] > 0 ，所以以 i 结尾的乘积为正数的最⻓⼦数组就等于 g[i - 1] + 1 ；
综上所述， nums[i] > 0 时， g[i] = g[i - 1] == 0 ? 0 : g[i - 1] + 1 ;
这⾥的推导⽐较绕，因为不断的出现「正数和负数」的分情况讨论，我们只需根据下⾯的规则，严格找到此状态下需要的 dp 数组即可：
- i. 正数 * 正数 = 正数
- ii. 负数 * 负数 = 正数
- iii. 负数 * 正数 = 正数 * 负数 = 负数

初始化：

可以在最前⾯加上⼀个「辅助结点」，帮助我们初始化。使⽤这种技巧要注意两个点：
- i. 辅助结点⾥⾯的值要「保证后续填表是正确的」；
- ii. 「下标的映射关系」。
在本题中，最前⾯加上⼀个格⼦，并且让 f[0] = g[0] = 0 即可。

填表顺序：

根据「状态转移⽅程」易得，填表顺序为「从左往右，两个表⼀起填」。
返回值：

根据「状态表⽰」，我们要返回 f 表中的最⼤值。

4.4 C++算法代码：

class Solution {
public:
    int getMaxLen(vector<int>& nums) {
        int n = nums.size();
        vector<int> f(n + 1), g(n + 1);

        int ret = INT_MIN;
        for(int i = 1; i <= n; i++)
        {
            if(nums[i - 1] > 0)
            {
                f[i] = f[i - 1] + 1;
                g[i] = g[i - 1] == 0 ? 0 : g[i - 1] + 1;
            }
            else if(nums[i - 1] < 0)
            {
                f[i] = g[i - 1] == 0 ? 0 : g[i - 1] + 1;
                g[i] = f[i - 1] + 1;
            }
            ret = max(ret, f[i]);
        }
        return ret;
    }
};

5 等差数列划分

5.1 题目链接

413. 等差数列划分

5.2 题目描述

如果一个数列 至少有三个元素 ，并且任意两个相邻元素之差相同，则称该数列为等差数列。

例如，[1,3,5,7,9]、[7,7,7,7] 和 [3,-1,-5,-9] 都是等差数列。

给你一个整数数组 nums ，返回数组 nums 中所有为等差数组的 子数组 个数。

子数组 是数组中的一个连续序列。

示例 1：

输入： nums = [1,2,3,4]
输出： 3
解释： nums 中有三个子等差数组：[1, 2, 3]、[2, 3, 4] 和 [1,2,3,4] 自身。

示例 2：

输入： nums = [1]
输出： 0

提示：

1 <= nums.length <= 5000
-1000 <= nums[i] <= 1000

5.3 解法（动态规划）

算法思路：

状态表⽰：

由于我们的研究对象是「⼀段连续的区间」，如果我们状态表⽰定义成 [0, i] 区间内⼀共有多少等差数列，那么我们在分析 dp[i] 的状态转移时，会⽆从下⼿，因为我们不清楚前⾯那么多的「等差数列都在什么位置」。所以说，我们定义的状态表⽰必须让等差数列「有迹可循」，让状态转移的时候能找到「⼤部队」。因此，我们可以「固定死等差数列的结尾」，定义下⾯的状态表⽰：
- dp[i] 表⽰必须「以 i 位置的元素为结尾」的等差数列有多少种。
状态转移⽅程：

我们需要了解⼀下等差数列的性质：如果 a b c 三个数成等差数列，这时候来了⼀个 d ，其中 b c d 也能构成⼀个等差数列，那么 a b c d 四个数能够成等差序列吗？答案是：显然的。因为他们之间相邻两个元素之间的差值都是⼀样的。有了这个理解，我们就可以转⽽分析我们的状态转移⽅程了。

对于 dp[i] 位置的元素 nums[i] ，会与前⾯的两个元素有下⾯两种情况：
- i. nums[i - 2], nums[i - 1], nums[i] 三个元素不能构成等差数列：那么以nums[i] 为结尾的等差数列就不存在，此时 dp[i] = 0 ；
- ii. nums[i - 2], nums[i - 1], nums[i] 三个元素可以构成等差数列：那么以 nums[i - 1] 为结尾的所有等差数列后⾯填上⼀个 nums[i] 也是⼀个等差数列，此时 dp[i] = dp[i - 1] 。但是，因为 nums[i - 2], nums[i - 1], nums[i] 三者⼜能构成⼀个新的等差数列，因此要在之前的基础上再添上⼀个等差数列，于是dp[i] = dp[i - 1] + 1 。
综上所述：状态转移⽅程为：
- 当： nums[i - 2] + nums[i] != 2 * nums[i - 1] 时， dp[i] = 0
- 当： nums[i - 2] + nums[i] == 2 * nums[i - 1] 时， dp[i] = 1 + dp[i - 1]

初始化：

由于需要⽤到前两个位置的元素，但是前两个位置的元素⼜⽆法构成等差数列，因此 dp[0] = dp[1] = 0 。
填表顺序：

毫⽆疑问是「从左往右」。
返回值：

因为我们要的是所有的等差数列的个数，因此需要返回整个 dp 表⾥⾯的元素之和。

5.4 C++算法代码：

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n);

        int sum = 0;
        for(int i = 2; i < n; i++)
        {
            dp[i] = nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2] ? dp[i - 1] + 1 : 0;
            sum += dp[i];
        }
        return sum;
    }
};

6 最长湍流子数组

6.1 题目链接

978. 最长湍流子数组

6.2 题目描述

给定一个整数数组 arr ，返回 arr 的 最大湍流子数组的长度 ****。

如果比较符号在子数组中的每个相邻元素对之间翻转，则该子数组是 湍流子数组 。

更正式地来说，当 arr 的子数组 A[i], A[i+1], ..., A[j] 满足仅满足下列条件时，我们称其为湍流子数组：

若 i <= k < j ：
- 当 k 为奇数时， A[k] > A[k+1]，且
- 当 k 为偶数时，A[k] < A[k+1]；
或若 i <= k < j ：
- 当 k 为偶数时，A[k] > A[k+1] ，且
- 当 k 为奇数时， A[k] < A[k+1]。

示例 1：

输入： arr = [9,4,2,10,7,8,8,1,9]
输出： 5
解释： arr[1] > arr[2] < arr[3] > arr[4] < arr[5]

示例 2：

输入： arr = [4,8,12,16]
输出： 2

示例 3：

输入： arr = [100]
输出： 1

提示：

1 <= arr.length <= 4 * 104
0 <= arr[i] <= 109

6.3 解法（动态规划）

算法思路：

状态表⽰：

我们先尝试定义状态表⽰为：

dp[i] 表⽰「以 i 位置为结尾的最⻓湍流数组的⻓度」。但是，问题来了，如果状态表⽰这样定义的话，以 i 位置为结尾的最⻓湍流数组的⻓度我们没法从之前的状态推导出来。因为我们不知道前⼀个最⻓湍流数组的结尾处是递增的，还是递减的。因此，我们需要状态表⽰能表⽰多⼀点的信息：要能让我们知道这⼀个最⻓湍流数组的结尾是「递增」的还是「递减」的。

因此需要两个 dp 表：
- f[i] 表⽰：以 i 位置元素为结尾的所有⼦数组中，最后呈现「上升状态」下的最⻓湍流数组的⻓度；
- g[i] 表⽰：以 i 位置元素为结尾的所有⼦数组中，最后呈现「下降状态」下的最⻓湍流数组的⻓度。

状态转移⽅程：

对于 i 位置的元素 arr[i] ，有下⾯两种情况：
- i. arr[i] > arr[i - 1] ：如果 i 位置的元素⽐ i - 1 位置的元素⼤，说明接下来应该去找 i -1 位置结尾，并且 i - 1 位置元素⽐前⼀个元素⼩的序列，那就是 g[i - 1] 。更新 f[i] 位置的值： f[i] = g[i - 1] + 1 ；
- ii. arr[i] < arr[i - 1] ：如果 i 位置的元素⽐ i - 1 位置的元素⼩，说明接下来应该去找 i - 1 位置结尾，并且 i - 1 位置元素⽐前⼀个元素⼤的序列，那就是f[i - 1] 。更新 g[i] 位置的值： g[i] = f[i - 1] + 1 ；
- iii. arr[i] == arr[i - 1] ：不构成湍流数组。

初始化：

所有的元素「单独」都能构成⼀个湍流数组，因此可以将 dp 表内所有元素初始化为 1 。

由于⽤到前⾯的状态，因此我们循环的时候从第⼆个位置开始即可。
填表顺序：

毫⽆疑问是「从左往右，两个表⼀起填」。
返回值：

应该返回「两个 dp 表⾥⾯的最⼤值」，我们可以在填表的时候，顺便更新⼀个最⼤值。

6.4 C++算法代码：

class Solution {
public:
    int maxTurbulenceSize(vector<int>& arr) {
        int n = arr.size();
        vector<int>f(n, 1), g(n, 1);

        int ret = 1;
        for(int i = 1; i < n; i++)
        {
            if(arr[i - 1] < arr[i]) f[i] = g [i- 1] + 1;
            else if(arr[i - 1] > arr[i]) g[i] = f[i - 1] + 1;
            ret = max(ret, max(f[i], g[i]));
        }
        return ret;
    }
};

7 单词拆分

7.1 题目链接

139. 单词拆分

7.2 题目描述

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true。

注意： 不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

示例 1：

输入: s = "leetcode", wordDict = ["leet", "code"]
输出: true
解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。

示例 2：

输入: s = "applepenapple", wordDict = ["apple", "pen"]
输出: true
解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。
     注意，你可以重复使用字典中的单词。

示例 3：

输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
输出: false

提示：

1 <= s.length <= 300
1 <= wordDict.length <= 1000
1 <= wordDict[i].length <= 20
s 和 wordDict[i] 仅由小写英文字母组成
wordDict 中的所有字符串 互不相同

7.3 解法（动态规划）

算法思路：

状态表⽰：

对于线性 dp ，我们可以⽤「经验 + 题⽬要求」来定义状态表⽰：
- i. 以某个位置为结尾，巴拉巴拉；
- ii. 以某个位置为起点，巴拉巴拉。
这⾥我们选择⽐较常⽤的⽅式，以某个位置为结尾，结合题⽬要求，定义⼀个状态表⽰：
- dp[i] 表⽰： [0, i] 区间内的字符串，能否被字典中的单词拼接⽽成。

状态转移⽅程：

对于 dp[i] ，为了确定当前的字符串能否由字典⾥⾯的单词构成，根据最后⼀个单词的起始位置 j ，我们可以将其分解为前后两部分：
- i. 前⾯⼀部分 [0, j - 1] 区间的字符串；
- ii. 后⾯⼀部分 [j, i] 区间的字符串。
其中前⾯部分我们可以在 dp[j - 1] 中找到答案，后⾯部分的⼦串可以在字典⾥⾯找到。
因此，我们得出⼀个结论：当我们在从 0 ~ i 枚举 j 的时候，只要 dp[j - 1] = true并且后⾯部分的⼦串 s.substr(j, i - j + 1) 能够在字典中找到，那么 dp[i] = true 。

初始化：

可以在最前⾯加上⼀个「辅助结点」，帮助我们初始化。使⽤这种技巧要注意两个点：
- i. 辅助结点⾥⾯的值要「保证后续填表是正确的」；
- ii. 「下标的映射关系」。
在本题中，最前⾯加上⼀个格⼦，并且让 dp[0] = true ，可以理解为空串能够拼接⽽成。
其中为了⽅便处理下标的映射关系，我们可以将字符串前⾯加上⼀个占位符 s = ' ' + s ，这样就没有下标的映射关系的问题了，同时还能处理「空串」的情况。

填表顺序：

显⽽易⻅，填表顺序「从左往右」。
返回值：

由「状态表⽰」可得：返回 dp[n] 位置的布尔值。

哈希表优化的⼩细节：

在状态转移中，我们需要判断后⾯部分的⼦串「是否在字典」之中，因此会「频繁的⽤到查询操作」。为了节省效率，我们可以提前把「字典中的单词」存⼊到「哈希表」中。

7.4 C++算法代码：

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        // 优化
        unordered_set<string> hash;
        for(auto& s : wordDict) hash.insert(s);

        int n = s.size();
        vector<bool> dp(n + 1);
        dp[0] = true;  // 保证后续填表是正确的
        s = ' ' + s;  // 使原始字符串的下标统一 + 1
        for(int i = 1; i <= n; i++)
        {
            for(int j = i; j >= 1; j--)  // 最后一个单词的起始位置
            {
                if(dp[j - 1] && hash.count(s.substr(j, i - j + 1)))
                {
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[n];
    }
};

8 环绕字符串中唯一的子字符串

8.1 题目链接

467. 环绕字符串中唯一的子字符串

8.2 题目描述

定义字符串 base 为一个 "abcdefghijklmnopqrstuvwxyz" 无限环绕的字符串，所以 base 看起来是这样的：

"...zabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd....".

给你一个字符串 s ，请你统计并返回 s 中有多少不同 非空子串 也在 base 中出现。

示例 1：

输入： s = "a"
输出： 1
解释： 字符串 s 的子字符串 "a" 在 base 中出现。

示例 2：

输入： s = "cac"
输出： 2
解释： 字符串 s 有两个子字符串 ("a", "c") 在 base 中出现。

示例 3：

输入： s = "zab"
输出： 6
解释： 字符串 s 有六个子字符串 ("z", "a", "b", "za", "ab", and "zab") 在 base 中出现。

提示：

1 <= s.length <= 105
s 由小写英文字母组成

8.3 解法（动态规划）

算法思路：

状态表⽰：

对于线性 dp ，我们可以⽤「经验 + 题⽬要求」来定义状态表⽰：
- i. 以某个位置为结尾，巴拉巴拉；
- ii. 以某个位置为起点，巴拉巴拉。
这⾥我们选择⽐较常⽤的⽅式，以某个位置为结尾，结合题⽬要求，定义⼀个状态表⽰：

dp[i] 表⽰：以 i 位置的元素为结尾的所有⼦串⾥⾯，有多少个在 base 中出现过。
状态转移⽅程：

对于 dp[i] ，我们可以根据⼦串的「⻓度」划分为两类：
- i. ⼦串的⻓度等于 1 ：此时这⼀个字符会出现在 base 中；
- ii. ⼦串的⻓度⼤于 1 ：如果 i 位置的字符和 i - 1 位置上的字符组合后，出现在 base 中的话，那么 dp[i - 1] ⾥⾯的所有⼦串后⾯填上⼀个 s[i] 依旧在 base 中出现。因此 dp[i] = dp[i - 1] 。
综上， dp[i] = 1 + dp[i - 1] ，其中 dp[i - 1] 是否加上需要先做⼀下判断。

初始化：

可以根据「实际情况」，将表⾥⾯的值都初始化为 1 。
填表顺序：

显⽽易⻅，填表顺序「从左往右」。
返回值

这⾥不能直接返回 dp 表⾥⾯的和，因为会有重复的结果。在返回之前，我们需要先「去重」：
- i. 相同字符结尾的 dp 值，我们仅需保留「最⼤」的即可，其余 dp 值对应的⼦串都可以在最⼤的⾥⾯找到；
- ii. 可以创建⼀个⼤⼩为 26 的数组，统计所有字符结尾的最⼤ dp 值。
最后返回「数组中所有元素的和」即可。

8.4 C++算法代码：

class Solution {
public:
    int findSubstringInWraproundString(string s) {
        int n = s.size();
        vector<int> dp(n, 1);  // 创建 dp 表 + 初始化
        for(int i = 1; i < n; i++)  // 填表
            if(s[i - 1] + 1 == s[i] || (s[i- 1] == 'z' && s[i] == 'a'))
                dp[i] += dp[i - 1];

        int hash[26] = {0};
        for(int i = 0;i < n; i++)
            hash[s[i] - 'a'] = max(hash[s[i] - 'a'],dp[i]);

        int sum = 0;
        for(auto x : hash) sum += x;
        return sum;
    }
};

专题四：子数组、子串系列（数组中连续的⼀段）

1 最大子数组和

1.1 题目链接

1.2 题目描述

1.3 解法（动态规划）

1.4 C++算法代码：

2 环形子数组的最大和

2.1 题目链接

2.2 题目描述

2.3 解法（动态规划）

2.4 C++算法代码：

3 乘积最大子数组

3.1 题目链接

3.2 题目描述

3.3 解法（动态规划）

3.4 C++算法代码：

4 乘积为正数的最长子数组长度

4.1 题目链接

4.2 题目描述

4.3 解法（动态规划）

4.4 C++算法代码：

5 等差数列划分

5.1 题目链接

5.2 题目描述

5.3 解法（动态规划）

5.4 C++算法代码：

6 最长湍流子数组

6.1 题目链接

6.2 题目描述

6.3 解法（动态规划）

6.4 C++算法代码：

7 单词拆分

7.1 题目链接

7.2 题目描述

7.3 解法（动态规划）

7.4 C++算法代码：

8 环绕字符串中唯一的子字符串

8.1 题目链接

8.2 题目描述

8.3 解法（动态规划）

8.4 C++算法代码：