Question

3034. 匹配模式数组的子数组数目 I

English Version

题目描述

给你一个下标从 0 开始长度为 n 的整数数组 nums ，和一个下标从 0 开始长度为 m 的整数数组 pattern ，pattern 数组只包含整数 -1 ，0 和 1 。

大小为 m + 1 的子数组 nums[i..j] 如果对于每个元素 pattern[k] 都满足以下条件，那么我们说这个子数组匹配模式数组 pattern ：

• 如果 pattern[k] == 1 ，那么 nums[i + k + 1] > nums[i + k]
• 如果 pattern[k] == 0 ，那么 nums[i + k + 1] == nums[i + k]
• 如果 pattern[k] == -1 ，那么 nums[i + k + 1] < nums[i + k]

请你返回匹配 pattern 的 nums 子数组的 数目 。

 

示例 1：

输入：nums = [1,2,3,4,5,6], pattern = [1,1]
输出：4
解释：模式 [1,1] 说明我们要找的子数组是长度为 3 且严格上升的。在数组 nums 中，子数组 [1,2,3] ，[2,3,4] ，[3,4,5] 和 [4,5,6] 都匹配这个模式。
所以 nums 中总共有 4 个子数组匹配这个模式。

示例 2：

输入：nums = [1,4,4,1,3,5,5,3], pattern = [1,0,-1]
输出：2
解释：这里，模式数组 [1,0,-1] 说明我们需要找的子数组中，第一个元素小于第二个元素，第二个元素等于第三个元素，第三个元素大于第四个元素。在 nums 中，子数组 [1,4,4,1] 和 [3,5,5,3] 都匹配这个模式。
所以 nums 中总共有 2 个子数组匹配这个模式。

 

提示：

• 2 <= n == nums.length <= 100
• 1 <= nums[i] <= 109
• 1 <= m == pattern.length < n
• -1 <= pattern[i] <= 1

解法

方法一：枚举

我们可以枚举数组 nums 的所有长度为 $m + 1$ 的子数组，然后判断是否满足模式数组 pattern，如果满足则答案加一。

时间复杂度 $O(n \times m)$，其中 $n$ 和 $m$ 分别是数组 nums 和 pattern 的长度。空间复杂度 $O(1)$。

class Solution:
  def countMatchingSubarrays(self, nums: List[int], pattern: List[int]) -> int:
    def f(a: int, b: int) -> int:
      return 0 if a == b else (1 if a < b else -1)

    ans = 0
    for i in range(len(nums) - len(pattern)):
      ans += all(
        f(nums[i + k], nums[i + k + 1]) == p for k, p in enumerate(pattern)
      )
    return ans

class Solution {
  public int countMatchingSubarrays(int[] nums, int[] pattern) {
    int n = nums.length, m = pattern.length;
    int ans = 0;
    for (int i = 0; i < n - m; ++i) {
      int ok = 1;
      for (int k = 0; k < m && ok == 1; ++k) {
        if (f(nums[i + k], nums[i + k + 1]) != pattern[k]) {
          ok = 0;
        }
      }
      ans += ok;
    }
    return ans;
  }

  private int f(int a, int b) {
    return a == b ? 0 : (a < b ? 1 : -1);
  }
}

class Solution {
public:
  int countMatchingSubarrays(vector<int>& nums, vector<int>& pattern) {
    int n = nums.size(), m = pattern.size();
    int ans = 0;
    auto f = [](int a, int b) {
      return a == b ? 0 : (a < b ? 1 : -1);
    };
    for (int i = 0; i < n - m; ++i) {
      int ok = 1;
      for (int k = 0; k < m && ok == 1; ++k) {
        if (f(nums[i + k], nums[i + k + 1]) != pattern[k]) {
          ok = 0;
        }
      }
      ans += ok;
    }
    return ans;
  }
};

func countMatchingSubarrays(nums []int, pattern []int) (ans int) {
  f := func(a, b int) int {
    if a == b {
      return 0
    }
    if a < b {
      return 1
    }
    return -1
  }
  n, m := len(nums), len(pattern)
  for i := 0; i < n-m; i++ {
    ok := 1
    for k := 0; k < m && ok == 1; k++ {
      if f(nums[i+k], nums[i+k+1]) != pattern[k] {
        ok = 0
      }
    }
    ans += ok
  }
  return
}

function countMatchingSubarrays(nums: number[], pattern: number[]): number {
  const f = (a: number, b: number) => (a === b ? 0 : a < b ? 1 : -1);
  const n = nums.length;
  const m = pattern.length;
  let ans = 0;
  for (let i = 0; i < n - m; ++i) {
    let ok = 1;
    for (let k = 0; k < m && ok; ++k) {
      if (f(nums[i + k], nums[i + k + 1]) !== pattern[k]) {
        ok = 0;
      }
    }
    ans += ok;
  }
  return ans;
}

public class Solution {
  public int CountMatchingSubarrays(int[] nums, int[] pattern) {
    int n = nums.Length, m = pattern.Length;
    int ans = 0;
    for (int i = 0; i < n - m; ++i) {
      int ok = 1;
      for (int k = 0; k < m && ok == 1; ++k) {
        if (f(nums[i + k], nums[i + k + 1]) != pattern[k]) {
          ok = 0;
        }
      }
      ans += ok;
    }
    return ans;
  }

  private int f(int a, int b) {
    return a == b ? 0 : (a < b ? 1 : -1);
  }
}