算法| ss 滑动窗口

• 3.无重复字符的最长子串
• 209.长度最小的子数组
• 1052.爱生气的书店老板
• 904.水果成篮
• 1695.删除子数组的最大得分
• 1004.最大连续1的个数 III
• 1438.绝对差不超过限制的最长连续子数组

3.无重复字符的最长子串

/**
 * @param {string} s
 * @return {number}
 */
// 思路
// 滑窗三问三答
// 右指针是谁
// 左指针什么时候移动 偏爱while循环
// 结果更新
var lengthOfLongestSubstring = function (s) {
  let len = 0;
  let left = 0;
  const sets = new Set();
  for (let right = 0; right < s.length; right++) {
    let ch = s[right];
    while (sets.has(ch)) {
      let leftch = s[left];
      sets.delete(leftch);
      left += 1;
    }
    sets.add(ch);
    len = Math.max(len, right - left + 1);
  }
  //   console.log(len);
  return len;
};
lengthOfLongestSubstring("abcabcbb");

209.长度最小的子数组

/**
 * @param {number} target
 * @param {number[]} nums
 * @return {number}
 */
// 思路
// 三问三答
// for  while循环
// 相等时更新最小值
// 是大于等于 不是等于
var minSubArrayLen = function (target, nums) {
  let minLen = Infinity;
  let left = 0;
  let sum = 0;
  for (let right = 0; right < nums.length; right++) {
    let ch = nums[right];
    sum += ch;
    while (sum >= target && left <= right) {
      let leftCh = nums[left];
      minLen = Math.min(minLen, right - left + 1);
      sum -= leftCh;
      left += 1;
    }
  }
  //   console.log(minLen);
  return minLen === Infinity ? 0 : minLen;
};
// minSubArrayLen(7, [2, 3, 1, 2, 4, 3]);
// minSubArrayLen(4, [1, 4, 4]);
minSubArrayLen(11, [1, 2, 3, 4, 5]);

1052.爱生气的书店老板

/**
 * @param {number[]} customers
 * @param {number[]} grumpy
 * @param {number} minutes
 * @return {number}
 */
// 思路
// 先将不生气的时候的客户加起来, 再重置为0
// 对重置后的客户数组进行求 连续minutes 个数的最大值
var maxSatisfied = function (customers, grumpy, minutes) {
  let ans = 0;
  let n = customers.length;
  for (let i = 0; i < n; i++) {
    if (grumpy[i] === 0) {
      ans += customers[i];
      customers[i] = 0;
    }
  }
  //   [
  //     0, 0, 0, 2,
  //     0, 1, 0, 5
  //   ]
  let sum = 0;
  let max = 0;
  for (let i = 0; i < n; i++) {
    sum += customers[i];
    if (i >= minutes) {
      sum -= customers[i - minutes];
    }
    max = Math.max(max, sum);
  }
  console.log(max);
  console.log(ans + max);
  console.log(customers);
  return ans + max;
};
// maxSatisfied([1, 0, 1, 2, 1, 1, 7, 5], [0, 1, 0, 1, 0, 1, 0, 1], 3);
maxSatisfied([9, 10, 4, 5], [1, 0, 1, 1], 1);
// customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], minutes = 3

904. 水果成篮

/**
 * @param {number[]} fruits
 * @return {number}
 */
// 思路
// 滑动窗口解决
// for循环遍历 hash统计
// while循环 查看key的数量是否超过了2，如果超过，哈希统计更新。 左指针右移
// 更新答案
var totalFruit = function (fruits) {
  let ans = 0;
  let left = 0;
  const map = {};
  for (let right = 0; right < fruits.length; right++) {
    let ch = fruits[right];
    map[ch] = (map[ch] ?? 0) + 1;
    while (Object.keys(map).length > 2) {
      let leftCh = fruits[left];
      map[leftCh] -= 1;
      if (map[leftCh] === 0) delete map[leftCh];
      left += 1;
    }
    ans = Math.max(ans, right - left + 1);
  }
  console.log(ans);
  return ans;
};
totalFruit([0, 1, 2, 2]);

// 输入：fruits = [0,1,2,2]
// 输出：3
// 解释：可以采摘 [1,2,2] 这三棵树。

1695. 删除子数组的最大得分

/**
 * @param {number[]} nums
 * @return {number}
 */
// 思路
// 滑窗3步曲解决
// 使用Set进行统计
var maximumUniqueSubarray = function (nums) {
  let left = 0;
  let sets = new Set();
  let sum = 0;
  let ans = 0;
  for (let right = 0; right < nums.length; right++) {
    sum += nums[right];
    while (sets.has(nums[right])) {
      sum -= nums[left];
      sets.delete(nums[left]);
      left += 1;
    }
    sets.add(nums[right]);
    ans = Math.max(ans, sum);
  }
  console.log(ans);
  return ans;
};
maximumUniqueSubarray([4, 2, 4, 5, 6]);

// 输入：nums = [4,2,4,5,6]
// 输出：17
// 解释：最优子数组是 [2,4,5,6]

1004.最大连续1的个数 III

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
// 思路 滑动窗口
// 右边元素是什么
// 满足什么条件 左指针移动
// 更新结果
var longestOnes = function (nums, k) {
  let left = 0;
  let ans = 0;
  for (let right = 0; right < nums.length; right++) {
    let ch = nums[right];
    if (ch === 0) {
      k--;
    }
    while (k < 0) {
      if (nums[left] === 0) k++;
      left += 1;
    }
    ans = Math.max(ans, right - left + 1);
  }
  console.log(ans);
  return ans;
};
longestOnes([1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0], 2);
longestOnes([0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1], 3);
// 输入：nums = [1,1,1,0,0,0,1,1,1,1,0], K = 2
// 输出：6

1438.绝对差不超过限制的最长连续子数组

/**
 * @param {number[]} nums
 * @param {number} limit
 * @return {number}
 */
// 思路 单调栈+滑动窗口
// 这题挺费解的
var longestSubarray = function (nums, limit) {
  const maxQueue = [];
  const minQueue = [];
  const len = nums.length;
  let left = 0;
  let ans = 1;
  for (let i = 0; i < len; i++) {
    const val = nums[i];
    while (maxQueue.length && val >= nums[maxQueue[maxQueue.length - 1]])
      maxQueue.pop();
    while (minQueue.length && val <= nums[minQueue[minQueue.length - 1]])
      minQueue.pop();
    maxQueue.push(i);
    minQueue.push(i);
    console.log("maxQueue", maxQueue);
    console.log("minQueue", minQueue);
    if (maxQueue.length && nums[maxQueue[0]] - nums[minQueue[0]] <= limit) {
      ans = Math.max(ans, i - left + 1);
    } else {
      while (nums[maxQueue[0]] - nums[minQueue[0]] > limit) {
        if (val === nums[minQueue[0]]) {
          left = maxQueue.shift();
        } else {
          left = minQueue.shift();
        }
      }
      left += 1;
    }
  }
  console.log(ans);
};

longestSubarray([8, 2, 4, 7], 4);
// 输入：nums = [8,2,4,7], limit = 4
// 输出：2