Sliding Window on Hang Zhang

Maximum Sum Circular Subarray

Sun, 09 Feb 2025 00:00:00 +0000

918. 环形子数组的最大和

分析

双倍扩展数组
- 为了处理环形数组，将 nums 扩展为两倍长度的数组 s（模拟拼接后的连续数组），便于通过滑动窗口寻找环形最大子数组
前缀和数组
- s[i] 表示从 nums[0] 到 nums[i % n] 的前缀和，通过前缀和计算任意区间的子数组和
滑动窗口 + 单调队列
- 维护一个单调递增的双端队列 q，存储前缀和的索引：
  - 队首：保证窗口长度不超过 n，且队首元素是当前窗口内的最小前缀和
    - 队尾：维护递增性质
动态更新结果
- 在每一步中计算 s[i] - s[q.front()]，更新最大子数组和

时间复杂度

总时间复杂度 O(n)，每个元素最多进出队列一次，遍历一遍即可得到结果

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int maxSubarraySumCircular(vector<int>& nums)
    {
        int n = nums.size();
        std::vector<int> s(n * 2);  // 扩展两倍长度的前缀和数组
        s[0] = nums[0];

        // 构建前缀和数组
        for (int i = 1; i < n * 2; ++i)
            s[i] = s[i - 1] + nums[i % n];

        std::deque<int> q;  // 单调队列存储前缀和的索引
        q.push_front(0);
        int res = INT_MIN;

        for (int i = 1; i < n * 2; ++i)
        {
            // 窗口长度大于 n 时弹出队首
            while (q.size() && i - q.front() > n)
                q.pop_front();

            // 更新最大子数组和
            res = std::max(res, s[i] - s[q.front()]);

            // 维护单调递增的队列
            while (q.size() && s[i] <= s[q.back()])
                q.pop_back();

            q.push_back(i);
        }

        return res;
    }
};

Substr with Concatenation of All Words

Tue, 14 Jan 2025 00:00:00 +0000

30. 串联所有单词的子串

分析

窗口长度固定：
- 每个单词长度相同，假设单词长度为 w，words 长度为 m，则窗口长度为 m * w
哈希表记录单词频次：
- 使用哈希表 total 统计 words 中每个单词出现的次数
- 窗口内部用另一个哈希表 window 统计窗口内单词频次
多起点滑动窗口：
- 从 s 的下标 0 ~ w - 1 依次滑动，确保不会遗漏跨单词边界的情况
窗口内单词匹配：
- 每次从当前位置提取长度为 w 的单词，更新窗口哈希表
- 如果窗口内单词频次超过 words 中的频次，则收缩窗口
- 当窗口内单词频次与 words 完全一致时，记录窗口的起始位置

时间复杂度

外层循环 w 次（单词长度）
内层遍历 n / w 次，每次提取单词和更新哈希表，代价为 O(1)

总时间复杂度 O(n * w)

空间复杂度

空间复杂度为 O(m)

C++代码

class Solution
{
public:
    vector<int> findSubstring(string s, vector<string>& words)
    {
        std::vector<int> res;
        if (words.empty())  // 边界情况：words为空
            return res;

        int n = s.size();             // 字符串 s 的长度
        int m = words.size();         // 单词个数
        int w = words[0].size();      // 单词长度

        // 统计 words 中每个单词出现的次数
        std::unordered_map<std::string, int> total;
        for (std::string& word : words)
            ++ total[word];

        // 遍历所有可能的起始位置（避免跨单词边界）
        for (int i = 0; i < w; ++i)
        {
            std::unordered_map<std::string, int> window;  // 窗口内单词频次
            int cnt = 0;  // 匹配到的单词数

            // 滑动窗口，步长为 w（单词长度）
            for (int j = i; j + w <= n; j += w)
            {
                // 当前窗口右侧加入新单词
                std::string rightWord = s.substr(j, w);
                ++ window[rightWord];
                if (window[rightWord] <= total[rightWord])  // 新单词未超额
                    ++ cnt;

                // 如果窗口超过了大小 m * w，滑动窗口左侧
                if (j >= i + m * w)
                {
                    std::string leftWord = s.substr(j - m * w, w);
                    -- window[leftWord];
                    if (window[leftWord] < total[leftWord])  // 如果减少后不匹配
                        -- cnt;
                }

                // 匹配到所有单词，记录起始索引
                if (cnt == m)
                    res.push_back(j - (m - 1) * w);
            }
        }
        return res;
    }
};

Number of Recent Calls

Fri, 27 Dec 2024 00:00:00 +0000

933. 最近的请求次数

分析

利用队列的先进先出特性来存储请求的时间点，并维护一个滑动窗口：

存储请求时间：
- 每次调用 ping(t)，将时间 t 加入队列
移除过期请求：
- 从队列头部开始检查，如果某个时间点不在 [t-3000, t] 范围内（即 t - q.front() > 3000），则将其从队列中移除
统计有效请求：
- 最后，队列的大小即为过去 3000 毫秒内的请求数量

时间复杂度

时间复杂度 O(1)

空间复杂度

空间复杂度为 O(n)

C++代码

class RecentCounter
{
public:
    std::queue<int> q; // 用于存储请求时间点的队列

    RecentCounter()
    {
        // 构造函数初始化，无需额外操作
    }

    int ping(int t)
    {
        q.push(t); // 将当前请求时间添加到队列
        // 移除不在 [t-3000, t] 范围内的请求
        while (t - q.front() > 3000)
            q.pop();
        return q.size(); // 返回队列大小，即为有效请求数
    }
};

Longest Subarray of 1 After Deleting one Element

Mon, 23 Dec 2024 00:00:00 +0000

1493. 删掉一个元素以后全为1的最长子数组

分析

定义两个指针 i 和 j，表示滑动窗口的左右边界
使用变量 cnt 记录窗口中 0 的个数
遍历数组 nums ：
- 如果当前元素是 0，则将 cnt 加 1
- 如果 cnt > 1 ，说明窗口内多于一个 0，不符合题目要求，需要将左指针 j 向右移动，并根据移出的元素更新 cnt
- 每次更新窗口长度 res = max(res, i - j + 1)
遍历完成后，结果为 res - 1，因为必须删除一个元素

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int longestSubarray(vector<int>& nums)
    {
        int res = 0;       // 最大连续 1 的长度
        int cnt = 0;       // 当前窗口中 0 的数量
        for (int i = 0, j = 0; i < nums.size(); ++i)
        {
            if (nums[i] == 0)
                ++cnt;    // 遇到 0，增加计数
            while (cnt > 1)  // 如果窗口内 0 的数量超过 1
            {
                if (nums[j] == 0)
                    --cnt; // 左指针移出 0，减少计数
                ++j;       // 缩小窗口
            }
            res = std::max(res, i - j + 1); // 更新最大长度
        }
        return res - 1; // 因为必须删掉一个元素
    }
};

Max Consecutive Ones III

Mon, 23 Dec 2024 00:00:00 +0000

1004. 最大连续1的个数III

分析

定义两个指针 i 和 j，表示滑动窗口的左右边界
使用变量 cnt 记录当前窗口中 0 的个数
遍历数组 nums ：
- 如果遇到 0，增加 cnt
- 当 cnt > k 时，说明当前窗口内翻转 0 的数量超出了限制，需要将左指针 j 向右移动，并且如果移除的元素是 0，更新 cnt
- 每次移动右指针 i 时，计算当前窗口的长度 res = max(res, i - j + 1)
遍历完成后，返回最大窗口长度 res

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int longestOnes(vector<int>& nums, int k)
    {
        int res = 0;       // 最大连续 1 的长度
        int cnt = 0;       // 当前窗口内 0 的数量
        for (int i = 0, j = 0; i < nums.size(); ++i)
        {
            if (nums[i] == 0)
                ++cnt;    // 遇到 0，增加计数
            while (cnt > k)  // 如果翻转的 0 超过限制
            {
                if (nums[j] == 0)
                    --cnt; // 左指针移除 0，减少计数
                ++j;       // 缩小窗口
            }
            res = std::max(res, i - j + 1); // 更新最大长度
        }
        return res;
    }
};

Maximum Number of Vowels In a Substring Of Given Length

Sun, 22 Dec 2024 00:00:00 +0000

1456. 定长子串中元音的最大数目

分析

定义一个固定长度为 k 的窗口，用变量 cur 记录窗口内的元音字母数量
遍历字符串 s
- 当加入一个新字符时，若其为元音，则增加 cur
- 若窗口大小超过 k，移除窗口左端字符，若其为元音，则减少 cur
- 在窗口大小达到 k 时，更新最大元音数量 res
遍历结束后，返回结果

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int maxVowels(string s, int k)
    {
        std::unordered_set<char> hash = {'a', 'e', 'i', 'o', 'u'}; // 元音集合
        int res = 0, cur = 0; // res: 最大元音数量, cur: 当前窗口元音数量
        for (int i = 0, j = 0; i < s.size(); ++i)
        {
            if (hash.count(s[i])) // 判断当前字符是否为元音
                ++cur;
            if (i - j + 1 > k) // 如果窗口超过长度 k
            {
                if (hash.count(s[j])) // 窗口左端字符是否为元音
                    --cur;
                ++j; // 移动左端
            }
            if (i >= k - 1) // 当窗口长度达到 k 时，更新结果
                res = std::max(res, cur);
        }
        return res;
    }
};

Maximumu Average Subarray I

Sun, 22 Dec 2024 00:00:00 +0000

643. 子数组最大平均数I

分析

用一个变量 sum 表示当前窗口中 k 个数的和
遍历数组，依次更新 sum，当窗口大小达到 k 时，计算当前窗口的平均值，并尝试更新最大平均值
如果窗口大小超过 k，将窗口的左端值从 sum 中减去，同时将窗口右端的新值加上
遍历结束后，返回最大平均值

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    double findMaxAverage(vector<int>& nums, int k)
    {
      double max_average = INT_MIN; // 用于存储最大平均数
      double sum = 0; // 当前窗口的总和
      for (int i = 0, j = 0; i < nums.size(); i++) // 遍历数组
      {
        sum += nums[i]; // 将当前元素加入窗口
        if (i - j + 1 > k) // 如果窗口大小超过 k
          sum -= nums[j++]; // 移除窗口左端的值
        if (i >= k - 1) // 确保窗口大小恰好为 k 时
          max_average = std::max(max_average, sum / (double)k); // 计算平均值并更新最大值
      }
      return max_average; // 返回最大平均值
    }
};

findAnagrams

Tue, 26 Nov 2024 00:00:00 +0000

438. 找到字符串中所有字母异位词

算法

初始化目标频率表：
- 使用哈希表 hash 存储字符串 p 中每个字符的频率
滑动窗口遍历字符串 s：
- 窗口初始范围为 [j, i]，窗口长度不超过 p.size()
- 遍历字符串 s，对窗口内的字符更新哈希表：
  - 窗口右扩（加入字符）：
    - 将当前字符 s[i] 加入窗口，并在 hash 中减少其频率
    - 如果该字符的频率变为 0，说明该字符的频率匹配，增加匹配计数 count
  - 窗口左缩（移除字符）：
    - 如果窗口长度超过 p.size()，将左端字符 s[j] 从窗口移除：
      - 如果 s[j] 在 hash 中频率变为非零，匹配计数 count 减少
      - 更新左指针 j
判断异位词：
- 如果窗口内所有字符频率均匹配（count == total），将当前窗口左端索引 j 加入结果集 res

复杂度分析

时间复杂度

初始化哈希表：O(p)，其中 p 是字符串 p 的长度
滑动窗口遍历：O(s)，其中 s 是字符串 s 的长度
总时间复杂度：O(s + p)

空间复杂度

使用了一个哈希表存储字符频率，空间复杂度为 O(k)，其中 k 是字符集大小

C++ 代码

class Solution
{
public:
    vector<int> findAnagrams(string s, string p)
    {
        std::unordered_map<char, int> hash; // 存储目标字符频率
        for (char c : p)
            ++hash[c];

        std::vector<int> res;
        int total = hash.size(), count = 0;

        for (int i = 0, j = 0; i < s.size(); ++ i)
        {
            // 右扩：加入字符 s[i]
            -- hash[s[i]];
            if (hash[s[i]] == 0)
                ++ count;

            // 左缩：移除字符 s[j]
            if (i - j + 1 > p.size())
            {
                if (hash[s[j]] == 0)
                    -- count;
                ++ hash[s[j]];
                ++ j;
            }

            // 检查是否找到异位词
            if (count == total)
                res.push_back(j);
        }

        return res;
    }
};

Python 代码

class Solution:
  def findAnagrams(self, s: str, p: str) -> List[int]:
    freq = {}

    for ch in p:
      freq[ch] = freq.get(ch, 0) + 1

    total, count = len(freq), 0
    res = []

    j = 0
    for i in range(len(s)):
      freq[s[i]] = freq.get(s[i], 0) - 1
      if freq[s[i]] == 0:
        count += 1
      if i - j + 1 > len(p):
        if freq[s[j]] == 0:
          count -= 1
        freq[s[j]] = freq.get(s[j], 0) + 1
        j += 1
      if total == count:
        res.append(j)

    return res

Go 代码

func findAnagrams(s string, p string) []int {
  freq := make(map[byte]int)
  for i := 0; i < len(p); i ++ {
    freq[p[i]] ++
  }

  total, count := len(freq), 0
  res := []int{}

  for i, j := 0, 0; i < len(s); i ++ {
    freq[s[i]] --
    if freq[s[i]] == 0 {
      count ++
    }
    if i - j + 1 > len(p) {
      if freq[s[j]] == 0 {
        count --
      }
      freq[s[j]] ++
      j ++
    }
    if count == total {
      res = append(res, j)
    }
  }
  return res
}

JavaScript 代码

/**
 * @param {string} s
 * @param {string} p
 * @return {number[]}
 */
var findAnagrams = function (s, p) {
  let freq = new Map();
  for (let i = 0; i < p.length; i++) {
    freq.set(p[i], (freq.get(p[i]) || 0) + 1);
  }

  let total = freq.size,
    count = 0;
  let res = [];

  for (let i = 0, j = 0; i < s.length; i++) {
    freq.set(s[i], (freq.get(s[i]) || 0) - 1);

    if (freq.get(s[i]) == 0) {
      count++;
    }

    if (i - j + 1 > p.length) {
      if (freq.get(s[j]) == 0) {
        count--;
      }
      freq.set(s[j], (freq.get(s[j]) || 0) + 1);
      j++;
    }

    if (total == count) {
      res.push(j);
    }
  }
  return res;
};

Longest Substring Without Repeating Characters

Tue, 26 Nov 2024 00:00:00 +0000

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

算法

维护一个滑动窗口：
- 滑动窗口用两个指针表示，j 为窗口左端，i 为窗口右端
- 窗口内的子串为 [j, i]，保证该窗口内没有重复字符
使用哈希表记录字符出现的次数：
- 哈希表 hash 的 key 为字符，value 为该字符在窗口中的出现次数
移动窗口右端：
- 遍历字符串，右端指针 i 每次右移一格，将字符加入窗口并更新哈希表
处理重复字符：
- 如果窗口中出现重复字符（即当前字符的出现次数大于 1），移动左端指针 j，并在哈希表中移除字符，直到窗口内没有重复字符。
更新结果：
- 每次移动窗口时，计算当前窗口的长度 (i - j + 1)，并更新结果 res

复杂度分析

时间复杂度

每个字符至多被访问两次（右指针扩展时访问一次，左指针收缩时访问一次），时间复杂度为 O(n)

空间复杂度

使用哈希表存储字符出现次数，空间复杂度为 O(k)，其中 k 为字符集大小

C++ 代码

class Solution
{
public:
    int lengthOfLongestSubstring(string s)
    {
        std::unordered_map<char, int> hash; // 记录字符出现次数
        int res = 0; // 最长子串长度

        for (int i = 0, j = 0; i < s.size(); ++ i)
        {
            ++hash[s[i]]; // 将字符加入窗口

            // 如果出现重复字符，移动左指针 j
            while (hash[s[i]] > 1)
            {
                -- hash[s[j]];
                ++ j;
            }

            // 更新最长子串长度
            res = std::max(res, i - j + 1);
        }

        return res;
    }
};

Python 代码

class Solution:
  def lengthOfLongestSubstring(self, s: str) -> int:
    res = 0
    freq = {}
    j = 0
    for i, ch in enumerate(s):
      if ch not in freq:
        freq[ch] = 0
      freq[ch] += 1
      while freq[ch] > 1:
        freq[s[j]] -= 1
        j += 1
      res = max(res, i - j + 1)
    return res

Go 代码

func lengthOfLongestSubstring(s string) int {
  freq := make(map[byte]int)
  res, j := 0, 0
  for i := 0; i < len(s); i ++ {
    freq[s[i]] ++
    for freq[s[i]] > 1 {
      freq[s[j]] --
      j ++
    }
    res = max(res, i - j + 1)
  }
  return res
}

Javascript

/**
 * @param {string} s
 * @return {number}
 */
var lengthOfLongestSubstring = function (s) {
  let res = 0;
  let freq = new Map();
  for (let i = 0, j = 0; i < s.length; i++) {
    freq.set(s[i], (freq.get(s[i]) || 0) + 1);
    while (freq.get(s[i]) > 1) {
      freq.set(s[j], freq.get(s[j]) - 1);
      j++;
    }
    res = Math.max(res, i - j + 1);
  }
  return res;
};

maxSlidingWindow

Tue, 26 Nov 2024 00:00:00 +0000

239. 滑动窗口最大值

算法

维护一个单调递减队列：
- 使用一个双端队列 q 存储数组的索引
- 队列中的元素对应的值保持单调递减顺序，队首始终是当前窗口的最大值索引
窗口滑动的处理：
- 窗口失效处理：检查队首索引是否超出当前窗口范围 (i - k + 1)，若超出则弹出队首
- 保持单调性：将新元素加入队列时，弹出队列中所有小于当前元素值的索引，以确保队列的单调递减性
- 记录最大值：当窗口的大小达到 k 时 (i >= k - 1)，窗口的最大值即为队首索引对应的值

复杂度分析

时间复杂度

遍历数组：所有元素仅被插入和弹出队列一次，时间复杂度为 O(n)
队列操作：每次插入和弹出操作的平均时间复杂度为 O(1)
总时间复杂度：O(n)

空间复杂度

使用了一个双端队列存储索引，空间复杂度为 O(k)

C++ 代码

class Solution
{
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k)
    {
        std::deque<int> q;            // 双端队列存储索引
        std::vector<int> res;         // 存储结果

        for (int i = 0; i < nums.size(); ++i)
        {
            // 移除队首超出窗口范围的元素
            if (q.size() && q.front() < i - k + 1)
                q.pop_front();

            // 保持队列单调递减
            while (q.size() && nums[q.back()] <= nums[i])
                q.pop_back();

            // 添加当前元素索引到队列
            q.push_back(i);

            // 当窗口形成时，记录窗口最大值
            if (i >= k - 1)
                res.push_back(nums[q.front()]);
        }

        return res;
    }
};

Python 代码

from collections import deque

class Solution:
  def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
    dq = deque()
    res = []

    for i in range(len(nums)):
      while dq and nums[dq[-1]] <= nums[i]:
        dq.pop()

      if dq and dq[0] < i - k + 1:
        dq.popleft()

      dq.append(i)

      if i >= k - 1:
        res.append(nums[dq[0]])

    return res

Go 代码

func maxSlidingWindow(nums []int, k int) []int {
  dq := []int{}
  res := []int{}

  for i := 0; i < len(nums); i ++ {
    for len(dq) > 0 && nums[dq[len(dq) - 1]] <= nums[i] {
      dq = dq[:len(dq) - 1]
    }
    if len(dq) > 0 && dq[0] < i - k + 1 {
      dq = dq[1:]
    }
    dq = append(dq, i)

    if i >= k - 1 {
      res = append(res, nums[dq[0]]);
    }
  }

  return res;
}

JavaScript 代码

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number[]}
 */
var maxSlidingWindow = function (nums, k) {
  let dq = [],
    res = [];
  for (let i = 0; i < nums.length; i++) {
    while (dq.length && nums[dq[dq.length - 1]] <= nums[i]) {
      dq.pop();
    }

    if (dq.length && dq[0] < i - k + 1) {
      dq.shift();
    }

    dq.push(i);

    if (i >= k - 1) {
      res.push(nums[dq[0]]);
    }
  }
  return res;
};

Minimum Window

Tue, 26 Nov 2024 00:00:00 +0000

76. 最小覆盖子串

算法

记录目标字符频率：
- 使用哈希表 hashT 记录字符串 t 中每个字符的频率。
维护当前窗口的字符频率：
- 使用另一个哈希表 hashS 记录当前窗口内字符的频率。
滑动窗口：
- 扩展窗口：从左到右遍历字符串 s，将当前字符加入窗口，并更新 hashS
- 满足条件：当窗口中的字符满足 t 中的所有字符（包括频率要求），记录当前窗口长度
- 收缩窗口：尝试从窗口左端收缩，以找到更小的满足条件的子串
更新结果：
- 如果窗口当前覆盖所有所需字符且长度更短，则更新结果字符串

复杂度分析

时间复杂度

遍历字符串 s：每个字符至多被访问两次（一次扩展窗口，一次收缩窗口），时间复杂度为 O(n)
更新哈希表：更新和查询哈希表的操作时间复杂度为 O(1)
总时间复杂度：O(n)

空间复杂度

使用了两个哈希表存储字符频率，空间复杂度为 O(n)

C++ 代码

class Solution
{
public:
    string minWindow(string s, string t)
    {
        std::unordered_map<char, int> hashS, hashT;
        for (char c : t)
            ++ hashT[c]; // 记录目标字符串 t 的字符频率

        int cnt = 0; // 当前窗口内满足条件的字符个数
        std::string res; // 记录结果子串
        for (int i = 0, j = 0; i < s.size(); ++i)
        {
            ++ hashS[s[i]]; // 扩展窗口
            if (hashS[s[i]] <= hashT[s[i]])
                ++ cnt; // 更新满足条件的字符数

            // 收缩窗口：移除多余的字符
            while (hashS[s[j]] > hashT[s[j]])
            {
                -- hashS[s[j]];
                ++ j;
            }

            // 检查当前窗口是否满足条件
            if (cnt == t.size())
                if (res.empty() || res.size() > i - j + 1)
                    res = s.substr(j, i - j + 1); // 更新结果
        }
        return res;
    }
};

Python 代码

class Solution:
  def minWindow(self, s: str, t: str) -> str:
    freqS, freqT = defaultdict(int), defaultdict(int)
    for c in t:
      freqT[c] += 1

    j, cnt = 0, 0
    res = ""
    for i in range(len(s)):
      freqS[s[i]] += 1
      if freqS[s[i]] <= freqT[s[i]]:
        cnt += 1
      while j < len(s) and freqS[s[j]] > freqT[s[j]]:
        freqS[s[j]] -= 1
        j += 1
      if cnt == len(t):
        if not res or len(res) > i - j + 1:
          res = s[j : i + 1]
    return res

Go 代码

func minWindow(s string, t string) string {
  freqS, freqT := make(map[byte]int), make(map[byte]int)
  for i := 0; i < len(t); i ++ {
    freqT[t[i]] ++ ;
  }

  cnt := 0
  res := ""
  for i, j := 0, 0; i < len(s); i ++ {
    freqS[s[i]] ++
    if freqS[s[i]] <= freqT[s[i]] {
      cnt ++
    }
    for j < len(s) && freqS[s[j]] > freqT[s[j]] {
      freqS[s[j]] --
      j ++
    }
    if (cnt == len(t)) {
      if (res == "" || len(res) > i - j + 1) {
        res = s[j : i + 1]
      }
    }
  }
  return res;
}

JavaScript 代码

/**
 * @param {string} s
 * @param {string} t
 * @return {string}
 */
var minWindow = function (s, t) {
  let freqS = new Map(),
    freqT = new Map();
  for (let c of t) {
    freqT.set(c, (freqT.get(c) || 0) + 1);
  }

  let cnt = 0;
  let res = "";
  for (let i = 0, j = 0; i < s.length; i++) {
    freqS.set(s[i], (freqS.get(s[i]) || 0) + 1);
    if (freqS.get(s[i]) <= freqT.get(s[i])) {
      cnt++;
    }
    while (freqS.get(s[j]) > (freqT.get(s[j]) || 0)) {
      freqS.set(s[j], freqS.get(s[j]) - 1);
      j++;
    }
    if (cnt == t.length) {
      if (res.length == 0 || res.length > i - j + 1) {
        res = s.slice(j, i + 1);
      }
    }
  }
  return res;
};