Day Twenty-eight

算法

来源: 力扣 978. 最长湍流子数组
当 A 的子数组 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]。
也就是说，如果比较符号在子数组中的每个相邻元素对之间翻转，则该子数组是湍流子数组。
返回 A 的最大湍流子数组的长度。

示例 1：
输入：[9,4,2,10,7,8,8,1,9]
输出：5
解释：(A[1] > A[2] < A[3] > A[4] < A[5])

示例 2：
输入：[4,8,12,16]
输出：2

示例 3：
输入：[100]
输出：1

提示：
1 <= A.length <= 40000
0 <= A[i] <= 10^9

解题思路
这题和摆动序列很相似只是变成了需要连续的摆动子序列.这道题也可以用动态规划来做
原问题: 求当前i个元素下,最长的元素值连续交替[增加]和[减少]的子序列
子问题:求前1,前2,…前i-1个元素下,最长的元素值连续交替[增加]和[减少]的子序列
状态: 第i个状态即为前i个元素最长的元素值连续交替[增加]和[减少]的子序列
边界状态: 由于1 <= A.length,至少为1
状态转移方程:
[增加] if(nums[i]>nums[i+1]) dp[i]=dp[i-1]+1
[减少] if(nums[i]<nums[i+1]) dp[i]=dp[i-1]+1

代码

class Solution {
public:
    int maxTurbulenceSize(vector<int>& arr) {
        int result=1;
        int increased=1,decreased=1;
        int n=arr.size();
        for(int i=1;i<n;i++){
            if(arr[i-1]<arr[i]){
                increased=decreased+1;
                decreased=1;
            }else if(arr[i-1]>arr[i]){
                decreased=increased+1;
                increased=1;
            }else{
                decreased=1;
                increased=1;
            }
            result=max(increased,result);
            result=max(decreased,result);
        }
        return result;
    }
};

来源: 力扣 64. 最小路径和

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。

示例 1：

输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
输出：7
解释：因为路径 1→3→1→1→1 的总和最小。

示例 2：
输入：grid = [[1,2,3],[4,5,6]]
输出：12

提示：
m == grid.length
n == grid[i].length
1 <= m, n <= 200
0 <= grid[i][j] <= 100

解题思路
当元素只有一个左边或者上边元素时,即第一行和第一列,处理方式如下图.
特殊情况:

正常情况:
相邻元素上左选取较小元素相加即可.

代码

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        vector<vector<int>> dp(grid);
        int rows = grid.size(), columns = grid[0].size();
        for(int i=1;i<columns;i++){
            dp[0][i]+=dp[0][i-1];
        }
        for(int i=1;i<rows;i++){
            dp[i][0]+=dp[i-1][0];
        }
        for(int i=1;i<rows;i++){
            for(int j=1;j<columns;j++){
                dp[i][j]+=min(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[rows-1][columns-1];
    }
};