可以想到的就是滑动窗口(sliding window)，由于最长长度未知，我们可以使用动态滑动窗口。

记录当前滑动窗口中T和F出现的次数，如果其中较少的一个<=k，那么就可以全部替换它，使得整个滑动窗口都变成相同的值。如果这个时候滑动窗口长度大于当前最大长度，我们就把滑动窗口变大，右侧+1，并更新最大长度。否则，减少滑动窗口，左侧-1。

时间复杂度：O(n)
空间复杂度：O(2)

class Solution {
public:
  int maxConsecutiveAnswers(string_view A, int k) {
    int ans = 0;
    int f = 0;
    array<int, 2> count; // number of 'F' and 'T' in the sliding window
    for (int i = 0; i < A.size(); ++i) {
      ++count[A[i] == 'T'];
      if (min(count[0], count[1]) <= k && count[0] + count[1] > ans)
        ++ans;
      else
        --count[A[i - ans] == 'T'];
    }
    return ans;
  }
};

The beauty of a subarray is the xth smallest integer in the subarray if it is negative, or 0 if there are fewer than x negative integers.

Return an integer array containing n - k + 1 integers, which denote the beauty of the subarrays in order from the first index in the array.

• A subarray is a contiguous non-empty sequence of elements within an array.

Example 1:

Input: nums = [1,-1,-3,-2,3], k = 3, x = 2
Output: [-1,-2,-2]
Explanation: There are 3 subarrays with size k = 3. 
The first subarray is [1, -1, -3] and the 2nd smallest negative integer is -1. 
The second subarray is [-1, -3, -2] and the 2nd smallest negative integer is -2. 
The third subarray is [-3, -2, 3] and the 2nd smallest negative integer is -2.

Example 2:

Input: nums = [-1,-2,-3,-4,-5], k = 2, x = 2
Output: [-1,-2,-3,-4]
Explanation: There are 4 subarrays with size k = 2.
For [-1, -2], the 2nd smallest negative integer is -1.
For [-2, -3], the 2nd smallest negative integer is -2.
For [-3, -4], the 2nd smallest negative integer is -3.
For [-4, -5], the 2nd smallest negative integer is -4. 

Example 3:

Input: nums = [-3,1,2,-3,0,-3], k = 2, x = 1
Output: [-3,0,-3,-3,-3]
Explanation: There are 5 subarrays with size k = 2.
For [-3, 1], the 1st smallest negative integer is -3.
For [1, 2], there is no negative integer so the beauty is 0.
For [2, -3], the 1st smallest negative integer is -3.
For [-3, 0], the 1st smallest negative integer is -3.
For [0, -3], the 1st smallest negative integer is -3.

Constraints:

• n == nums.length 
• 1 <= n <= 105
• 1 <= k <= n
• 1 <= x <= k 
• -50 <= nums[i] <= 50 

Solution: Sliding Window + Counter

Since the range of nums are very small (-50 ~ 50), we can use a counter to track the frequency of each element, s.t. we can find the k-the smallest element in O(50) instead of O(k).

Time complexity: O((n – k + 1) * 50)
Space complexity: O(50)

// Author: Huahua
class Solution {
public:
  vector<int> getSubarrayBeauty(vector<int>& nums, int k, int x) {
    constexpr int kMax = 50;    
    const int n = nums.size();
    vector<int> counts(2 * kMax + 1);
    vector<int> ans;    
    for (int i = 0; i < n; ++i) {
      if (i >= k)
        --counts[nums[i - k] + kMax];
      ++counts[nums[i] + kMax];      
      if (i >= k - 1) {
        int b = 0;
        for (int j = 0, s = 0; j <= kMax; ++j) {
          s += counts[j];
          if (s >= x) {
            b = j - kMax;
            break;
          }
        }
        ans.push_back(b);
      }
     
    }
    return ans;
  }
};

• hash(s, p, m) = (val(s[0]) * p0 + val(s[1]) * p1 + ... + val(s[k-1]) * pk-1) mod m.

Where val(s[i]) represents the index of s[i] in the alphabet from val('a') = 1 to val('z') = 26.

You are given a string s and the integers power, modulo, k, and hashValue. Return sub, the first substring of s of length k such that hash(sub, power, modulo) == hashValue.

The test cases will be generated such that an answer always exists.

A substring is a contiguous non-empty sequence of characters within a string.

Example 1:

Input: s = "leetcode", power = 7, modulo = 20, k = 2, hashValue = 0
Output: "ee"
Explanation: The hash of "ee" can be computed to be hash("ee", 7, 20) = (5 * 1 + 5 * 7) mod 20 = 40 mod 20 = 0. 
"ee" is the first substring of length 2 with hashValue 0. Hence, we return "ee".

Example 2:

Input: s = "fbxzaad", power = 31, modulo = 100, k = 3, hashValue = 32
Output: "fbx"
Explanation: The hash of "fbx" can be computed to be hash("fbx", 31, 100) = (6 * 1 + 2 * 31 + 24 * 312) mod 100 = 23132 mod 100 = 32. 
The hash of "bxz" can be computed to be hash("bxz", 31, 100) = (2 * 1 + 24 * 31 + 26 * 312) mod 100 = 25732 mod 100 = 32. 
"fbx" is the first substring of length 3 with hashValue 32. Hence, we return "fbx".
Note that "bxz" also has a hash of 32 but it appears later than "fbx".

Constraints:

• 1 <= k <= s.length <= 2 * 104
• 1 <= power, modulo <= 109
• 0 <= hashValue < modulo
• s consists of lowercase English letters only.
• The test cases are generated such that an answer always exists.

Solution: Sliding window

hash = (((hash – (s[i+k] * p^k-1) % mod + mod) * p) + (s[i] * p⁰)) % mod

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  string subStrHash(string s, int power, int modulo, int k, int hashValue) {    
    const int n = s.length();
    long p = 1; 
    for (int i = 1; i < k; ++i)
      p = (p * power) % modulo;
    long ans = 0;
    for (long i = n - 1, cur = 0; i >= 0; --i) {
      if (i + k < n) 
        cur = ((cur - (s[i + k] - 'a' + 1) * p) % modulo + modulo) % modulo;
      cur = (cur * power + (s[i] - 'a' + 1)) % modulo;      
      if (i + k <= n && cur == hashValue) 
        ans = i;
    }    
    return s.substr(ans, k);
  }
};

A circular array is defined as an array where we consider the first element and the last element to be adjacent.

Given a binary circular array nums, return the minimum number of swaps required to group all 1‘s present in the array together at any location.

Example 1:

Input: nums = [0,1,0,1,1,0,0]
Output: 1
Explanation: Here are a few of the ways to group all the 1's together:
[0,0,1,1,1,0,0] using 1 swap.
[0,1,1,1,0,0,0] using 1 swap.
[1,1,0,0,0,0,1] using 2 swaps (using the circular property of the array).
There is no way to group all 1's together with 0 swaps.
Thus, the minimum number of swaps required is 1.

Example 2:

Input: nums = [0,1,1,1,0,0,1,1,0]
Output: 2
Explanation: Here are a few of the ways to group all the 1's together:
[1,1,1,0,0,0,0,1,1] using 2 swaps (using the circular property of the array).
[1,1,1,1,1,0,0,0,0] using 2 swaps.
There is no way to group all 1's together with 0 or 1 swaps.
Thus, the minimum number of swaps required is 2.

Example 3:

Input: nums = [1,1,0,0,1]
Output: 0
Explanation: All the 1's are already grouped together due to the circular property of the array.
Thus, the minimum number of swaps required is 0.

Constraints:

• 1 <= nums.length <= 105
• nums[i] is either 0 or 1.

Solution: Sliding Window

Step 1: Count how many ones are there in the array. Assume it’s K.
Step 2: For each window of size k, count how many ones in the window, we have to swap 0s out with 1s to fill the window. ans = min(ans, k – ones).

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int minSwaps(vector<int>& nums) {
    const int n = nums.size();
    const int k = accumulate(begin(nums), end(nums), 0);
    int ans = INT_MAX;
    for (int i = 0, cur = 0; i < n + k; ++i) {
      if (i >= k) cur -= nums[(i - k + n) % n];
      cur += nums[i % n];      
      ans = min(ans, k - cur);
    }
    return ans;
  }
};

Pick the scores of any k students from the array so that the difference between the highest and the lowest of the k scores is minimized.

Return the minimum possible difference.

Example 1:

Input: nums = [90], k = 1
Output: 0
Explanation: There is one way to pick score(s) of one student:
- [90]. The difference between the highest and lowest score is 90 - 90 = 0.
The minimum possible difference is 0.

Example 2:

Input: nums = [9,4,1,7], k = 2
Output: 2
Explanation: There are six ways to pick score(s) of two students:
- [9,4,1,7]. The difference between the highest and lowest score is 9 - 4 = 5.
- [9,4,1,7]. The difference between the highest and lowest score is 9 - 1 = 8.
- [9,4,1,7]. The difference between the highest and lowest score is 9 - 7 = 2.
- [9,4,1,7]. The difference between the highest and lowest score is 4 - 1 = 3.
- [9,4,1,7]. The difference between the highest and lowest score is 7 - 4 = 3.
- [9,4,1,7]. The difference between the highest and lowest score is 7 - 1 = 6.
The minimum possible difference is 2.

Constraints:

• 1 <= k <= nums.length <= 1000
• 0 <= nums[i] <= 105

Solution: Sliding Window

Sort the array, to minimize the difference, k numbers must be consecutive (i.e, from a subarray). We use a sliding window size of k and try all possible subarrays.
Ans = min{(nums[k – 1] – nums[0]), (nums[k] – nums[1]), … (nums[n – 1] – nums[n – k])}

Time complexity: O(nlogn)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int minimumDifference(vector<int>& nums, int k) {
    int ans = INT_MAX;
    sort(begin(nums), end(nums));
    for (int i = k - 1; i < nums.size(); ++i)
      ans = min(ans, nums[i] - nums[i - k + 1]);
    return ans;
  }
};

Solution 1: Range sum query

Assuming we can collect fruits in range [l, r], we need a fast query to compute the sum of those fruits.

Given startPos and k, we have four options:
1. move i steps to the left
2. move i steps to the left and k – i steps to the right.
3. move i steps to the right
4. move i steps to the right and k – i steps to the left.

We enumerate i steps and calculate maximum range [l, r] covered by each option, and collect all the fruit in that range.

Time complexity: O(m + k)
Space complexity: O(m)
where m = max(max(pos), startPos)

// Author: Huahua
class Solution {
public:
  int maxTotalFruits(vector<vector<int>>& fruits, int startPos, int k) {    
    const int m = max(startPos, (*max_element(begin(fruits), end(fruits)))[0]);
    vector<int> sums(m + 2);   
    for (int i = 0, j = 0; i <= m; ++i) {
      sums[i + 1] += sums[i];
      while (j < fruits.size() && fruits[j][0] == i)        
        sums[i + 1] += fruits[j++][1];      
    }    
    int ans = 0;
    for (int s = 0; s <= k; ++s) {
      if (startPos - s >= 0) {
        int l = startPos - s;
        int r = min(max(startPos, l + (k - s)), m);        
        ans = max(ans, sums[r + 1] - sums[l]);
      }
      if (startPos + s <= m) {
        int r = startPos + s;
        int l = max(0, min(startPos, r - (k - s)));
        ans = max(ans, sums[r + 1] - sums[l]);
      }
    }             
    return ans;
  }
};

Solution 2: Sliding Window

Maintain a window [l, r] such that the steps to cover [l, r] from startPos is less or equal to k.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int maxTotalFruits(vector<vector<int>>& fruits, int startPos, int k) {    
    auto steps = [&](int l, int r) {
      if (r <= startPos)
        return startPos - l;
      else if (l >= startPos)
        return r - startPos;
      else
        return min(startPos + r - 2 * l, 2 * r - startPos - l);
    };
    int ans = 0;
    for (int r = 0, l = 0, cur = 0; r < fruits.size(); ++r) {
      cur += fruits[r][1];
      while (l <= r && steps(fruits[l][0], fruits[r][0]) > k)
        cur -= fruits[l++][1];      
      ans = max(ans, cur);
    }
    return ans;
  }
};

Example 1:

Input: nums = [1,2,3,1], k = 3
Output: true

Example 2:

Input: nums = [1,0,1,1], k = 1
Output: true

Example 3:

Input: nums = [1,2,3,1,2,3], k = 2
Output: false

Constraints:

• 1 <= nums.length <= 105
• -109 <= nums[i] <= 109
• 0 <= k <= 105

Solution: Sliding Window + Hashtable

Hashtable to store the last index of a number.

Remove the number if it’s k steps behind the current position.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  bool containsNearbyDuplicate(vector<int>& nums, int k) {
    unordered_map<int, int> m; // num -> last index
    for (int i = 0; i < nums.size(); ++i) {
      if (i > k && m[nums[i - k - 1]] < i - k + 1)
        m.erase(nums[i - k - 1]);
      if (m.count(nums[i])) return true;
      m[nums[i]] = i;
    }
    return false;
  }
};

The k-radius average for a subarray of nums centered at some index i with the radius k is the average of all elements in nums between the indices i - k and i + k (inclusive). If there are less than k elements before or after the index i, then the k-radius average is -1.

Build and return an array avgs of length n where avgs[i] is the k-radius average for the subarray centered at index i.

The average of x elements is the sum of the x elements divided by x, using integer division. The integer division truncates toward zero, which means losing its fractional part.

• For example, the average of four elements 2, 3, 1, and 5 is (2 + 3 + 1 + 5) / 4 = 11 / 4 = 2.75, which truncates to 2.

Example 1:

Input: nums = [7,4,3,9,1,8,5,2,6], k = 3
Output: [-1,-1,-1,5,4,4,-1,-1,-1]
Explanation:
- avg[0], avg[1], and avg[2] are -1 because there are less than k elements before each index.
- The sum of the subarray centered at index 3 with radius 3 is: 7 + 4 + 3 + 9 + 1 + 8 + 5 = 37.
  Using integer division, avg[3] = 37 / 7 = 5.
- For the subarray centered at index 4, avg[4] = (4 + 3 + 9 + 1 + 8 + 5 + 2) / 7 = 4.
- For the subarray centered at index 5, avg[5] = (3 + 9 + 1 + 8 + 5 + 2 + 6) / 7 = 4.
- avg[6], avg[7], and avg[8] are -1 because there are less than k elements after each index.

Example 2:

Input: nums = [100000], k = 0
Output: [100000]
Explanation:
- The sum of the subarray centered at index 0 with radius 0 is: 100000.
  avg[0] = 100000 / 1 = 100000.

Example 3:

Input: nums = [8], k = 100000
Output: [-1]
Explanation: 
- avg[0] is -1 because there are less than k elements before and after index 0.

Constraints:

• n == nums.length
• 1 <= n <= 105
• 0 <= nums[i], k <= 105

Solution: Sliding Window

We compute i – k’s average at position i.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  vector<int> getAverages(vector<int>& nums, int k) {
    const int n = nums.size();
    long long sum = 0;
    vector<int> ans(n, -1);    
    for (int i = 0; i < n; ++i) {
      sum += nums[i];
      if (i >= 2 * k) {
        ans[i - k] = sum / (2 * k + 1);           
        sum -= nums[i - 2 * k];
      }
    }
    return ans;
  }
};

nums is considered continuous if both of the following conditions are fulfilled:

• All elements in nums are unique.
• The difference between the maximum element and the minimum element in nums equals nums.length - 1.

For example, nums = [4, 2, 5, 3] is continuous, but nums = [1, 2, 3, 5, 6] is not continuous.

Return the minimum number of operations to make numscontinuous.

Example 1:

Input: nums = [4,2,5,3]
Output: 0
Explanation: nums is already continuous.

Example 2:

Input: nums = [1,2,3,5,6]
Output: 1
Explanation: One possible solution is to change the last element to 4.
The resulting array is [1,2,3,5,4], which is continuous.

Example 3:

Input: nums = [1,10,100,1000]
Output: 3
Explanation: One possible solution is to:
- Change the second element to 2.
- Change the third element to 3.
- Change the fourth element to 4.
The resulting array is [1,2,3,4], which is continuous.

Constraints:

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 109

Solution: Sliding Window

Remove duplicates and sort the numbers.
Try using nums[i] as the min number of the final array.
window [i, j), max – min < n, then change the rest of array to fit into or append after the window, which takes n – (j – i) steps.
e.g. input = [10, 3, 1, 4, 5, 6, 6, 6, 11, 15] => sorted + unique => [1, 3, 4, 5, 6, 10, 11, 15]
n = 10, window = [3, 4, 5, 6, 10, 11], max = 11, min = 3, max – min = 8 < 10
Final array = [3, 4, 5, 6, 1->7, 6₂->8, 6₃->9, 10, 11, 15->12]
Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int minOperations(vector<int>& A) {
    const int n = A.size();
    sort(begin(A), end(A));
    A.erase(unique(begin(A), end(A)), end(A));    
    int ans = INT_MAX;
    for (int i = 0, j = 0, m = A.size(); i < m; ++i) {
      while (j < m && A[j] < A[i] + n) ++j;
      ans = min(ans, n - (j - i));
    }
    return ans;
  }
};

A vowel substring is a substring that only consists of vowels ('a', 'e', 'i', 'o', and 'u') and has all five vowels present in it.

Given a string word, return the number of vowel substrings in word.

Example 1:

Input: word = "aeiouu"
Output: 2
Explanation: The vowel substrings of word are as follows (underlined):
- "aeiouu"
- "aeiouu"

Example 2:

Input: word = "unicornarihan"
Output: 0
Explanation: Not all 5 vowels are present, so there are no vowel substrings.

Example 3:

Input: word = "cuaieuouac"
Output: 7
Explanation: The vowel substrings of word are as follows (underlined):
- "cuaieuouac"
- "cuaieuouac"
- "cuaieuouac"
- "cuaieuouac"
- "cuaieuouac"
- "cuaieuouac"
- "cuaieuouac"

Example 4:

Input: word = "bbaeixoubb"
Output: 0
Explanation: The only substrings that contain all five vowels also contain consonants, so there are no vowel substrings.

Constraints:

• 1 <= word.length <= 100
• word consists of lowercase English letters only.

Solution 1: Brute Force

Time complexity: O(n²)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countVowelSubstrings(string_view word) {
    const int n = word.size();
    auto check = [&](string_view s) {
      set<int> seen;
      string vowels {"aeiou"};
      for (char c : s) {
        if (vowels.find(c) == string::npos) return false;
        seen.insert(c);
      }
      return seen.size() == 5;
    };
    int ans = 0;
    for (int i = 0; i < n; ++i)
      for (int l = 5; i + l <= n; ++l)
        if (check(word.substr(i, l))) ++ans;
    return ans;
  }
};

Solution 2: Sliding Window / Three Pointers

Maintain a window [i, j] that contain all 5 vowels, find k s.t. [k + 1, i] no longer container 5 vowels.
# of valid substrings end with j will be (k – i).

##aeiouaeioo##
..i....k...j..
i = 3, k = 8, j = 12

Valid substrings are:
aeiouaeioo
.eiouaeioo
..iouaeioo
...ouaeioo
....uaeioo
8 – 3 = 5

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countVowelSubstrings(string_view word) {    
    constexpr string_view vowels{"aeiou"};
    int ans = 0;
    unordered_map<char, int> m;
    for (char c : vowels) m[c] = 0;
    for (size_t i = 0, j = 0, k = 0, v = 0; j < word.size(); ++j) {
      if (m.count(word[j])) {
        v += (++m[word[j]] == 1);
        while (v == 5)
          v -= (--m[word[k++]] == 0);
        ans += k - i;
      } else {
        for (char c : vowels) m[c] = 0;
        v = 0;
        i = k = j + 1;
      }
    }
    return ans;
  }
};

• Type-1: Remove the character at the start of the string s and append it to the end of the string.
• Type-2: Pick any character in s and flip its value, i.e., if its value is '0' it becomes '1' and vice-versa.

Return the minimum number of type-2 operations you need to perform such that s becomes alternating.

The string is called alternating if no two adjacent characters are equal.

• For example, the strings "010" and "1010" are alternating, while the string "0100" is not.

Example 1:

Input: s = "111000"
Output: 2
Explanation: Use the first operation two times to make s = "100011".
Then, use the second operation on the third and sixth elements to make s = "101010".

Example 2:

Input: s = "010"
Output: 0
Explanation: The string is already alternating.

Example 3:

Input: s = "1110"
Output: 1
Explanation: Use the second operation on the second element to make s = "1010".

Constraints:

• 1 <= s.length <= 105
• s[i] is either '0' or '1'.

Solution: Sliding Window

Trying all possible rotations will take O(n²) that leads to TLE, we have to do better.

concatenate the s to itself, then using a sliding window length of n to check how many count needed to make the string in the window alternating which will cover all possible rotations. We can update the count in O(1) when moving to the next window.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int minFlips(string s) {
    const int n = s.length();    
    int ans = INT_MAX;
    for (int i = 0, c0 = 0, c1 = 1, a0 = 0, a1 = 0; i < 2 * n; ++i, c0 ^= 1, c1 ^= 1) {
      if (s[i % n] - '0' != c0) ++a0;
      if (s[i % n] - '0' != c1) ++a1;
      if (i < n - 1) continue;
      if (i >= n) {
        if (s[i - n] - '0' != c0 ^ (n & 1)) --a0;
        if (s[i - n] - '0' != c1 ^ (n & 1)) --a1;
      }
      ans = min({ans, a0, a1});      
    }    
    return ans;
  }
};

The frequency of an element is the number of times it occurs in an array.

You are given an integer array nums and an integer k. In one operation, you can choose an index of nums and increment the element at that index by 1.

Return the maximum possible frequency of an element after performing at most k operations.

Example 1:

Input: nums = [1,2,4], k = 5
Output: 3
Explanation: Increment the first element three times and the second element two times to make nums = [4,4,4].
4 has a frequency of 3.

Example 2:

Input: nums = [1,4,8,13], k = 5
Output: 2
Explanation: There are multiple optimal solutions:
- Increment the first element three times to make nums = [4,4,8,13]. 4 has a frequency of 2.
- Increment the second element four times to make nums = [1,8,8,13]. 8 has a frequency of 2.
- Increment the third element five times to make nums = [1,4,13,13]. 13 has a frequency of 2.

Example 3:

Input: nums = [3,9,6], k = 2
Output: 1

Constraints:

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 105
• 1 <= k <= 105

Solution: Sliding Window

Sort the elements, maintain a window such that it takes at most k ops to make the all the elements equal to nums[i].

Time complexity: O(nlogn)
Space complexity: O(1)

class Solution {
public:
  int maxFrequency(vector<int>& nums, int k) {
    sort(begin(nums), end(nums));
    int l = 0;
    long sum = 0;
    int ans = 0;
    for (int r = 0; r < nums.size(); ++r) {
      sum += nums[r];      
      while (l < r && 
             sum + k < static_cast<long>(nums[r]) * (r - l + 1))
        sum -= nums[l++];
      ans = max(ans, r - l + 1);
    }
    return ans;
  }
};

Return the minimum number of moves required so that nums has k consecutive 1‘s.

Example 1:

Input: nums = [1,0,0,1,0,1], k = 2
Output: 1
Explanation: In 1 move, nums could be [1,0,0,0,1,1] and have 2 consecutive 1's.

Example 2:

Input: nums = [1,0,0,0,0,0,1,1], k = 3
Output: 5
Explanation: In 5 moves, the leftmost 1 can be shifted right until nums = [0,0,0,0,0,1,1,1].

Example 3:

Input: nums = [1,1,0,1], k = 2
Output: 0
Explanation: nums already has 2 consecutive 1's.

Constraints:

• 1 <= nums.length <= 105
• nums[i] is 0 or 1.
• 1 <= k <= sum(nums)

Solution: Prefix Sum + Sliding Window

Time complexity: O(n)
Space complexity: O(n)

We only care positions of 1s, we can move one element from position x to y (assuming x + 1 ~ y are all zeros) in y – x steps. e.g. [0 0 1 0 0 0 1] => [0 0 0 0 0 1 1], move first 1 at position 2 to position 5, cost is 5 – 2 = 3.

Given a size k window of indices of ones, the optimal solution it to use the median number as center. We can compute the cost to form consecutive numbers:

e.g. [1 4 7 9 10] => [5 6 7 8 9] cost = (5 – 1) + (6 – 4) + (9 – 8) + (10 – 9) = 8

However, naive solution takes O(n*k) => TLE.

We can use prefix sum to compute the cost of a window in O(1) to reduce time complexity to O(n)

First, in order to use sliding window, we change the target of every number in the window to the median number.
e.g. [1 4 7 9 10] => [7 7 7 7 7] cost = (7 – 1) + (7 – 4) + (7 – 7) + (9 – 7) + (10 – 7) = (9 + 10) – (1 + 4) = right – left.
[5 6 7 8 9] => [7 7 7 7 7] takes extra 2 + 1 + 1 + 2 = 6 steps = (k / 2) * ((k + 1) / 2), these extra steps should be deducted from the final answer.

class Solution {
public:
  int minMoves(vector<int>& nums, int k) {
    vector<long> s(1);
    for (int i = 0; i < nums.size(); ++i)
      if (nums[i])
        s.push_back(s.back() + i);
    const int n = s.size();
    long ans = 1e10;
    const int m1 = k / 2, m2 = (k + 1) / 2;
    for (int i = 0; i + k < n; ++i) {
      const long right = s[i + k] - s[i + m1];
      const long left = s[i + m2] - s[i];
      ans = min(ans, right - left);
    }
    return ans - m1 * m2;
  }
};

class Solution:
  def minMoves(self, nums: List[int], k: int) -> int:
    ans = 1e10
    s = [0]    
    for i, v in enumerate(nums):
      if v: s.append(s[-1] + i)
    n = len(s)
    m1 = k // 2
    m2 = (k + 1) // 2
    for i in range(n - k):
      right = s[i + k] - s[i + m1]
      left = s[i + m2] - s[i]
      ans = min(ans, right - left)
    return ans - m1 * m2

Return the maximum score you can get by erasing exactly one subarray.

An array b is called to be a subarray of a if it forms a contiguous subsequence of a, that is, if it is equal to a[l],a[l+1],...,a[r] for some (l,r).

Example 1:

Input: nums = [4,2,4,5,6]
Output: 17
Explanation: The optimal subarray here is [2,4,5,6].

Example 2:

Input: nums = [5,2,1,2,5,2,1,2,5]
Output: 8
Explanation: The optimal subarray here is [5,2,1] or [1,2,5].

Constraints:

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

Solution: Sliding window + Hashset

Maintain a window that has no duplicate elements.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int maximumUniqueSubarray(vector<int>& nums) {
    const int n = nums.size();
    unordered_set<int> t;
    int ans = 0;
    for (int l = 0, r = 0, s = 0; r < n; ++r) {
      while (t.count(nums[r]) && l < r) {
        s -= nums[l];
        t.erase(nums[l++]);
      }      
      t.insert(nums[r]);
      ans = max(ans, s += nums[r]);
    }
    return ans;
  }
};

You are given an array boxes, where boxes[i] = [ports​​i​, weighti], and three integers portsCount, maxBoxes, and maxWeight.

• ports​​i is the port where you need to deliver the ith box and weightsi is the weight of the ith box.
• portsCount is the number of ports.
• maxBoxes and maxWeight are the respective box and weight limits of the ship.

The boxes need to be delivered in the order they are given. The ship will follow these steps:

• The ship will take some number of boxes from the boxes queue, not violating the maxBoxes and maxWeight constraints.
• For each loaded box in order, the ship will make a trip to the port the box needs to be delivered to and deliver it. If the ship is already at the correct port, no trip is needed, and the box can immediately be delivered.
• The ship then makes a return trip to storage to take more boxes from the queue.

The ship must end at storage after all the boxes have been delivered.

Return the minimum number of trips the ship needs to make to deliver all boxes to their respective ports.

Example 1:

Input: boxes = [[1,1],[2,1],[1,1]], portsCount = 2, maxBoxes = 3, maxWeight = 3
Output: 4
Explanation: The optimal strategy is as follows: 
- The ship takes all the boxes in the queue, goes to port 1, then port 2, then port 1 again, then returns to storage. 4 trips.
So the total number of trips is 4.
Note that the first and third boxes cannot be delivered together because the boxes need to be delivered in order (i.e. the second box needs to be delivered at port 2 before the third box).

Example 2:

Input: boxes = [[1,2],[3,3],[3,1],[3,1],[2,4]], portsCount = 3, maxBoxes = 3, maxWeight = 6
Output: 6
Explanation: The optimal strategy is as follows: 
- The ship takes the first box, goes to port 1, then returns to storage. 2 trips.
- The ship takes the second, third and fourth boxes, goes to port 3, then returns to storage. 2 trips.
- The ship takes the fifth box, goes to port 3, then returns to storage. 2 trips.
So the total number of trips is 2 + 2 + 2 = 6.

Example 3:

Input: boxes = [[1,4],[1,2],[2,1],[2,1],[3,2],[3,4]], portsCount = 3, maxBoxes = 6, maxWeight = 7
Output: 6
Explanation: The optimal strategy is as follows:
- The ship takes the first and second boxes, goes to port 1, then returns to storage. 2 trips.
- The ship takes the third and fourth boxes, goes to port 2, then returns to storage. 2 trips.
- The ship takes the fifth and sixth boxes, goes to port 3, then returns to storage. 2 trips.
So the total number of trips is 2 + 2 + 2 = 6.

Example 4:

Input: boxes = [[2,4],[2,5],[3,1],[3,2],[3,7],[3,1],[4,4],[1,3],[5,2]], portsCount = 5, maxBoxes = 5, maxWeight = 7
Output: 14
Explanation: The optimal strategy is as follows:
- The ship takes the first box, goes to port 2, then storage. 2 trips.
- The ship takes the second box, goes to port 2, then storage. 2 trips.
- The ship takes the third and fourth boxes, goes to port 3, then storage. 2 trips.
- The ship takes the fifth box, goes to port 3, then storage. 2 trips.
- The ship takes the sixth and seventh boxes, goes to port 3, then port 4, then storage. 3 trips. 
- The ship takes the eighth and ninth boxes, goes to port 1, then port 5, then storage. 3 trips.
So the total number of trips is 2 + 2 + 2 + 2 + 3 + 3 = 14.

Constraints:

• 1 <= boxes.length <= 105
• 1 <= portsCount, maxBoxes, maxWeight <= 105
• 1 <= ports​​i <= portsCount
• 1 <= weightsi <= maxWeight

Solution: Sliding Window

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int boxDelivering(vector<vector<int>>& boxes, int portsCount, int maxBoxes, int maxWeight) {
    const int n = boxes.size();
    vector<int> dp(n + 1); // dp[i] := min trips to deliver boxes[0:i]
    for (int i = 0, j = 0, b = 0, w = 0, t = 1; j < n; ++j) {
      // Different ports.
      if (j == 0 || boxes[j][0] != boxes[j - 1][0]) ++t;      
      // Load the box.
      w += boxes[j][1];
      while (w > maxWeight  // Too heavy.
             || (j - i + 1) > maxBoxes // Too many boxes.
             || (i < j && dp[i + 1] == dp[i])) { // Same cost more boxes.
        w -= boxes[i++][1]; // 'Unload' the box.
        if (boxes[i][0] != boxes[i - 1][0]) --t; // Different ports.
      }
      // Takes t trips to deliver boxes[i~j].
      dp[j + 1] = dp[i] + t;
    }
    return dp[n];
  }
};