时间复杂度：O(n)
空间复杂度：O(1) // no extra space used except for output

class Solution {
public:
  vector<int> pivotArray(vector<int>& nums, int pivot) {
    vector<int> ans;
    for (int x: nums)
      if (x < pivot) ans.push_back(x);
    for (int x : nums)
      if (x == pivot) ans.push_back(x);
    for (int x : nums)
      if (x > pivot) ans.push_back(x);
    return ans;
  }
};

方法1: Brute Force

双重循环枚举所有的(nums[i], nums[j])的组合。

时间复杂度：O(n²)
空间复杂度：O(1)

class Solution {
public:
  int maximumDifference(vector<int>& nums) {
    const int n = nums.size();
    int ans = 0;
    for (int i = 0; i < n; ++i)
      for (int j = i + 1; j < n; ++j)
        ans = max(ans, nums[j] - nums[i]);
    return ans ? ans : -1;
  }
};

方法2: 空间换时间

使用prefix sum算法，预先计算num[i] ~ nums[n-1]的最大值，存储在right[i]中。

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

class Solution {
public:
  int maximumDifference(vector<int>& nums) {
    const int n = nums.size();
    int ans = 0;
    vector<int> right(n, nums.back());
    for (int i = n - 2; i >= 0; --i)
      right[i] = max(right[i + 1], nums[i]);
    for (int i = 0; i < n; ++i)
      ans = max(ans, right[i] - nums[i]);
    return ans ? ans : -1;
  }
};

方法3: Running Min

从左到右遍历，记录当前为止出现过最小的值。比较 nums[i] – 最小值 和 最优解。

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

class Solution {
public:
  int maximumDifference(vector<int>& nums) {
    const int n = nums.size();
    int ans = 0;
    int smallest = nums[0];
    for (int i = 1; i < n; ++i) {
      ans = max(ans, nums[i] - smallest);
      smallest = min(smallest, nums[i]);
    }
    return ans ? ans : -1;
  }
};

可以预先使用O(n)时间计算nums[0] .. nums[i]的最大值，存在left[i]中，以及nums[i] .. nums[n-1]的最小值存在right[i]中。然后再按题目的定义计算即可。

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

class Solution {
public:
  int sumOfBeauties(vector<int>& nums) {
    const int n = nums.size();
    vector<int> left(n, nums[0]);
    vector<int> right(n, nums.back());
    for (int i = 1; i < n; ++i)
      left[i] = max(left[i - 1], nums[i]);
    for (int i = n - 2; i >= 0; --i)
      right[i] = min(right[i + 1], nums[i]);
    int ans = 0;
    for (int i = 1; i < n - 1; ++i)
      if (left[i - 1] < nums[i] && nums[i] < right[i + 1])
        ans += 2;
      else if (nums[i - 1] < nums[i] && nums[i] < nums[i + 1])
        ans += 1;
    return ans;
  }
};

使用nth_element找中位数，然后再循环一遍求合即可。

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

class Solution {
public:
  int minMoves2(vector<int>& nums) {
    const int n = nums.size();
    nth_element(begin(nums), begin(nums) + n / 2, end(nums));
    const int median = nums[n / 2];
    return accumulate(begin(nums), end(nums), 0, [median](int s, int x) {
      return s + abs(x - median);
    });
  }
};

速度比全排序或者heap/pq快到不知道哪里去了～

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

不用黑科技就达到99.77%

class Solution {
public:
  long long maxSum(vector<vector<int>>& grid, vector<int>& limits, int k) {
    // Step 1: Sort each row using fast parition, collect largest limits[i] elements.
    vector<int> nums;
    nums.reserve(grid.size() * grid[0].size());
    for (int i = 0; i < grid.size(); ++i) {
      nth_element(begin(grid[i]), begin(grid[i]) + limits[i], end(grid[i]), std::greater{});
      nums.insert(nums.end(), begin(grid[i]), begin(grid[i]) + limits[i]);
    }

    // Setp 2: fast partition to find the largest k elements. O(m*n).
    nth_element(begin(nums), begin(nums) + k, end(nums), std::greater{});
    
    // Step 3: Sum them up. O(k)
    return accumulate(begin(nums), begin(nums) + k, 0LL);
  }
};

Example 1:

Input: nums = [-1,1,2,3,1], target = 2
Output: 3
Explanation: There are 3 pairs of indices that satisfy the conditions in the statement:
- (0, 1) since 0 < 1 and nums[0] + nums[1] = 0 < target
- (0, 2) since 0 < 2 and nums[0] + nums[2] = 1 < target 
- (0, 4) since 0 < 4 and nums[0] + nums[4] = 0 < target
Note that (0, 3) is not counted since nums[0] + nums[3] is not strictly less than the target.

Example 2:

Input: nums = [-6,2,5,-2,-7,-1,3], target = -2
Output: 10
Explanation: There are 10 pairs of indices that satisfy the conditions in the statement:
- (0, 1) since 0 < 1 and nums[0] + nums[1] = -4 < target
- (0, 3) since 0 < 3 and nums[0] + nums[3] = -8 < target
- (0, 4) since 0 < 4 and nums[0] + nums[4] = -13 < target
- (0, 5) since 0 < 5 and nums[0] + nums[5] = -7 < target
- (0, 6) since 0 < 6 and nums[0] + nums[6] = -3 < target
- (1, 4) since 1 < 4 and nums[1] + nums[4] = -5 < target
- (3, 4) since 3 < 4 and nums[3] + nums[4] = -9 < target
- (3, 5) since 3 < 5 and nums[3] + nums[5] = -3 < target
- (4, 5) since 4 < 5 and nums[4] + nums[5] = -8 < target
- (4, 6) since 4 < 6 and nums[4] + nums[6] = -4 < target

Constraints:

• 1 <= nums.length == n <= 50
• -50 <= nums[i], target <= 50

Solution 1: Brute force

Enumerate all pairs.

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

// Author: Huahua
class Solution {
public:
  int countPairs(vector<int>& nums, int target) {
    const int n = nums.size();
    int ans = 0;
    for (int i = 0; i < n; ++i)
      for (int j = i + 1; j < n; ++j)
        ans += nums[i] + nums[j] < target;
    return ans;
  }
};

Solution 2: Two Pointers

Sort the numbers.

Use two pointers i, and j.
Set i to 0 and j to n – 1.
while (nums[i] + nums[j] >= target) –j
then we have nums[i] + nums[k] < target (i < k <= j), in total (j – i) pairs.
++i, move to the next starting number.
Time complexity: O(nlogn + n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countPairs(vector<int>& nums, int target) {
    const int n = nums.size();
    sort(begin(nums), end(nums));
    int ans = 0;
    for (int i = 0, j = n - 1; i < n; ++i) {
      while (j >= i && nums[i] + nums[j] >= target) --j;      
      ans += max(0, j - i);
    }
    return ans;
  }
};

Return the maximum sum or -1 if no such pair exists.

Example 1:

Input: nums = [51,71,17,24,42]
Output: 88
Explanation: 
For i = 1 and j = 2, nums[i] and nums[j] have equal maximum digits with a pair sum of 71 + 17 = 88. 
For i = 3 and j = 4, nums[i] and nums[j] have equal maximum digits with a pair sum of 24 + 42 = 66.
It can be shown that there are no other pairs with equal maximum digits, so the answer is 88.

Example 2:

Input: nums = [1,2,3,4]
Output: -1
Explanation: No pair exists in nums with equal maximum digits.

Constraints:

• 2 <= nums.length <= 100
• 1 <= nums[i] <= 104

Solution: Brute Force

Enumerate all pairs of nums and check their sum and max digit.

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

// Author: Huahua
class Solution {
public:
  int maxSum(vector<int>& nums) {
    auto maxDigit = [](int x) {
      int ans = 0;
      while (x) {
        ans = max(ans, x % 10);
        x /= 10;
      }
      return ans;
    };
    int ans = -1;
    const int n = nums.size();
    for (int i = 0; i < n; ++i)
      for (int j = i + 1; j < n; ++j)
        if (nums[i] + nums[j] > ans 
            && maxDigit(nums[i]) == maxDigit(nums[j]))
          ans = nums[i] + nums[j];
    return ans;
  }
};

A prefix common array of A and B is an array C such that C[i] is equal to the count of numbers that are present at or before the index i in both A and B.

Return the prefix common array of A and B.

A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.

Example 1:

Input: A = [1,3,2,4], B = [3,1,2,4]
Output: [0,2,3,4]
Explanation: At i = 0: no number is common, so C[0] = 0.
At i = 1: 1 and 3 are common in A and B, so C[1] = 2.
At i = 2: 1, 2, and 3 are common in A and B, so C[2] = 3.
At i = 3: 1, 2, 3, and 4 are common in A and B, so C[3] = 4.

Example 2:

Input: A = [2,3,1], B = [3,1,2]
Output: [0,1,3]
Explanation: At i = 0: no number is common, so C[0] = 0.
At i = 1: only 3 is common in A and B, so C[1] = 1.
At i = 2: 1, 2, and 3 are common in A and B, so C[2] = 3.

Constraints:

• 1 <= A.length == B.length == n <= 50
• 1 <= A[i], B[i] <= n
• It is guaranteed that A and B are both a permutation of n integers.

Solution 1: Bitset

Use bitsets to store the numbers seen so far for each array, and use sA & sB to count the common elements.

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

// Author: Huahua
class Solution {
public:
  vector<int> findThePrefixCommonArray(vector<int>& A, vector<int>& B) {
    bitset<51> sA;
    bitset<51> sB;
    vector<int> ans;
    for (int i = 0; i < A.size(); ++i) {
      sA.set(A[i]);
      sB.set(B[i]);
      ans.push_back((sA & sB).count());
    }
    return ans;
  }
};

Solution 2: Counter

Use a counter to track the frequency of each element, when the counter[x] == 2, we found a pair.

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

// Author: Huahua
class Solution {
public:
  vector<int> findThePrefixCommonArray(vector<int>& A, vector<int>& B) {
    vector<int> count(A.size() + 1);
    vector<int> ans;
    for (int i = 0, s = 0; i < A.size(); ++i) {
      if (++count[A[i]] == 2) ++s;
      if (++count[B[i]] == 2) ++s;
      ans.push_back(s);
    }
    return ans;
  }
};

• conver[i] = arr[i] + max(arr[0..i]) where max(arr[0..i]) is the maximum value of arr[j] over 0 <= j <= i.

We also define the score of an array arr as the sum of the values of the conversion array of arr.

Given a 0-indexed integer array nums of length n, return an array ans of length n where ans[i] is the score of the prefix nums[0..i].

Example 1:

Input: nums = [2,3,7,5,10]
Output: [4,10,24,36,56]
Explanation: 
For the prefix [2], the conversion array is [4] hence the score is 4
For the prefix [2, 3], the conversion array is [4, 6] hence the score is 10
For the prefix [2, 3, 7], the conversion array is [4, 6, 14] hence the score is 24
For the prefix [2, 3, 7, 5], the conversion array is [4, 6, 14, 12] hence the score is 36
For the prefix [2, 3, 7, 5, 10], the conversion array is [4, 6, 14, 12, 20] hence the score is 56

Example 2:

Input: nums = [1,1,2,4,8,16]
Output: [2,4,8,16,32,64]
Explanation: 
For the prefix [1], the conversion array is [2] hence the score is 2
For the prefix [1, 1], the conversion array is [2, 2] hence the score is 4
For the prefix [1, 1, 2], the conversion array is [2, 2, 4] hence the score is 8
For the prefix [1, 1, 2, 4], the conversion array is [2, 2, 4, 8] hence the score is 16
For the prefix [1, 1, 2, 4, 8], the conversion array is [2, 2, 4, 8, 16] hence the score is 32
For the prefix [1, 1, 2, 4, 8, 16], the conversion array is [2, 2, 4, 8, 16, 32] hence the score is 64

Constraints:

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

Solution: Prefix Sum

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

// Author: Huahua
class Solution {
public:
  vector<long long> findPrefixScore(vector<int>& nums) {
    vector<long long> ans(nums.size());
    for (int i = 0, m = 0; i < nums.size(); ++i) {
      m = max(m, nums[i]);
      ans[i] = (i ? ans[i - 1] : 0) + nums[i] + m;
    }    
    return ans;
  }
};

The divisibility score of divisors[i] is the number of indices j such that nums[j] is divisible by divisors[i].

Return the integer divisors[i] with the maximum divisibility score. If there is more than one integer with the maximum score, return the minimum of them.

Example 1:

Input: nums = [4,7,9,3,9], divisors = [5,2,3]
Output: 3
Explanation: The divisibility score for every element in divisors is:
The divisibility score of divisors[0] is 0 since no number in nums is divisible by 5.
The divisibility score of divisors[1] is 1 since nums[0] is divisible by 2.
The divisibility score of divisors[2] is 3 since nums[2], nums[3], and nums[4] are divisible by 3.
Since divisors[2] has the maximum divisibility score, we return it.

Example 2:

Input: nums = [20,14,21,10], divisors = [5,7,5]
Output: 5
Explanation: The divisibility score for every element in divisors is:
The divisibility score of divisors[0] is 2 since nums[0] and nums[3] are divisible by 5.
The divisibility score of divisors[1] is 2 since nums[1] and nums[2] are divisible by 7.
The divisibility score of divisors[2] is 2 since nums[0] and nums[3] are divisible by 5.
Since divisors[0], divisors[1], and divisors[2] all have the maximum divisibility score, we return the minimum of them (i.e., divisors[2]).

Example 3:

Input: nums = [12], divisors = [10,16]
Output: 10
Explanation: The divisibility score for every element in divisors is:
The divisibility score of divisors[0] is 0 since no number in nums is divisible by 10.
The divisibility score of divisors[1] is 0 since no number in nums is divisible by 16.
Since divisors[0] and divisors[1] both have the maximum divisibility score, we return the minimum of them (i.e., divisors[0]).

Constraints:

• 1 <= nums.length, divisors.length <= 1000
• 1 <= nums[i], divisors[i] <= 109

Solution: Brute Force

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

// Author: Huahua
class Solution {
public:
  int maxDivScore(vector<int>& nums, vector<int>& divisors) {
    int maxScore = 0;
    int ans = INT_MAX;
    for (int d : divisors) {
      int score = 0;
      for (int x : nums) {
        score += x % d == 0;
      }
      if (score > maxScore) {
        maxScore = score;
        ans = d;
      }
      if (score == maxScore)
        ans = min(ans, d);
    }
    return ans;
  }
};

In case there are multiple rows that have the maximum count of ones, the row with the smallest row number should be selected.

Return an array containing the index of the row, and the number of ones in it.

Example 1:

Input: mat = [[0,1],[1,0]]
Output: [0,1]
Explanation: Both rows have the same number of 1's. So we return the index of the smaller row, 0, and the maximum count of ones (1). So, the answer is [0,1]. 

Example 2:

Input: mat = [[0,0,0],[0,1,1]]
Output: [1,2]
Explanation: The row indexed 1 has the maximum count of ones (2). So we return its index, 1, and the count. So, the answer is [1,2].

Example 3:

Input: mat = [[0,0],[1,1],[0,0]]
Output: [1,2]
Explanation: The row indexed 1 has the maximum count of ones (2). So the answer is [1,2].

Constraints:

• m == mat.length 
• n == mat[i].length 
• 1 <= m, n <= 100 
• mat[i][j] is either 0 or 1.

Solution: Counting

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

// Author: Huahua
class Solution {
public:
  vector<int> rowAndMaximumOnes(vector<vector<int>>& mat) {
    vector<int> ans(2);
    for (int i = 0; i < mat.size(); ++i) {
      int ones = accumulate(begin(mat[i]), end(mat[i]), 0);
      if (ones > ans[1]) {
        ans[0] = i;
        ans[1] = ones;
      }
    }
    return ans;
  }
};

• answer.length == nums.length.
• answer[i] = |leftSum[i] - rightSum[i]|.

Where:

• leftSum[i] is the sum of elements to the left of the index i in the array nums. If there is no such element, leftSum[i] = 0.
• rightSum[i] is the sum of elements to the right of the index i in the array nums. If there is no such element, rightSum[i] = 0.

Return the array answer.

Example 1:

Input: nums = [10,4,8,3]
Output: [15,1,11,22]
Explanation: The array leftSum is [0,10,14,22] and the array rightSum is [15,11,3,0].
The array answer is [|0 - 15|,|10 - 11|,|14 - 3|,|22 - 0|] = [15,1,11,22].

Example 2:

Input: nums = [1]
Output: [0]
Explanation: The array leftSum is [0] and the array rightSum is [0].
The array answer is [|0 - 0|] = [0].

Constraints:

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

Solution: O(1) Space

Pre-compute the sum of all numbers as right sum, and accumulate left sum on the fly then we can achieve O(1) space.

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

// Author: Huahua
class Solution {
public:
  vector<int> leftRigthDifference(vector<int>& nums) {
    int right = accumulate(begin(nums), end(nums), 0);
    vector<int> ans;
    for (int i = 0, left = 0; i < nums.size(); ++i) {
      right -= nums[i];
      ans.push_back(abs(left - right));
      left += nums[i];      
    }
    return ans;
  }
};

The concatenation of two numbers is the number formed by concatenating their numerals.

• For example, the concatenation of 15, 49 is 1549.

The concatenation value of nums is initially equal to 0. Perform this operation until nums becomes empty:

• If there exists more than one number in nums, pick the first element and last element in nums respectively and add the value of their concatenation to the concatenation value of nums, then delete the first and last element from nums.
• If one element exists, add its value to the concatenation value of nums, then delete it.

Return the concatenation value of the nums.

Example 1:

Input: nums = [7,52,2,4]
Output: 596
Explanation: Before performing any operation, nums is [7,52,2,4] and concatenation value is 0.
 - In the first operation:
We pick the first element, 7, and the last element, 4.
Their concatenation is 74, and we add it to the concatenation value, so it becomes equal to 74.
Then we delete them from nums, so nums becomes equal to [52,2].
 - In the second operation:
We pick the first element, 52, and the last element, 2.
Their concatenation is 522, and we add it to the concatenation value, so it becomes equal to 596.
Then we delete them from the nums, so nums becomes empty.
Since the concatenation value is 596 so the answer is 596.

Example 2:

Input: nums = [5,14,13,8,12]
Output: 673
Explanation: Before performing any operation, nums is [5,14,13,8,12] and concatenation value is 0.
 - In the first operation:
We pick the first element, 5, and the last element, 12.
Their concatenation is 512, and we add it to the concatenation value, so it becomes equal to 512.
Then we delete them from the nums, so nums becomes equal to [14,13,8].
 - In the second operation:
We pick the first element, 14, and the last element, 8.
Their concatenation is 148, and we add it to the concatenation value, so it becomes equal to 660.
Then we delete them from the nums, so nums becomes equal to [13].
 - In the third operation:
nums has only one element, so we pick 13 and add it to the concatenation value, so it becomes equal to 673.
Then we delete it from nums, so nums become empty.
Since the concatenation value is 673 so the answer is 673.

Constraints:

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

Solution: Follow the rules

Time complexity: O(sum(log(nums[i]))
Space complexity: O(1)

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

Each query queries[i] = [li, ri] asks us to find the number of strings present in the range li to ri (both inclusive) of words that start and end with a vowel.

Return an array ans of size queries.length, where ans[i] is the answer to the i^th query.

Note that the vowel letters are 'a', 'e', 'i', 'o', and 'u'.

Example 1:

Input: words = ["aba","bcb","ece","aa","e"], queries = [[0,2],[1,4],[1,1]]
Output: [2,3,0]
Explanation: The strings starting and ending with a vowel are "aba", "ece", "aa" and "e".
The answer to the query [0,2] is 2 (strings "aba" and "ece").
to query [1,4] is 3 (strings "ece", "aa", "e").
to query [1,1] is 0.
We return [2,3,0].

Example 2:

Input: words = ["a","e","i"], queries = [[0,2],[0,1],[2,2]]
Output: [3,2,1]
Explanation: Every string satisfies the conditions, so we return [3,2,1].

Constraints:

• 1 <= words.length <= 105
• 1 <= words[i].length <= 40
• words[i] consists only of lowercase English letters.
• sum(words[i].length) <= 3 * 105
• 1 <= queries.length <= 105
• 0 <= li <= ri < words.length

Solution: Prefix Sum

Let sum[i] := number of valid strings in words[0:i]

For each query [l, r], answer will be sum[r + 1] – sum[l]

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

// Author: Huahua
class Solution {
public:
  vector<int> vowelStrings(vector<string>& words, vector<vector<int>>& queries) {
    const size_t n = words.size();
    vector<int> sum(n + 1);
    auto check = [](char c) {
      return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
    };
    for (size_t i = 0; i < n; ++i)
      sum[i + 1] = sum[i] + 
        (check(words[i][0]) && check(words[i][words[i].size() - 1]));
    vector<int> ans;
    for (const auto& q : queries)
      ans.push_back(sum[q[1] + 1] - sum[q[0]]);
    return ans;
  }
};

• 0 <= i < j < k < nums.length
• nums[i], nums[j], and nums[k] are pairwise distinct.
  • In other words, nums[i] != nums[j], nums[i] != nums[k], and nums[j] != nums[k].

Return the number of triplets that meet the conditions.

Example 1:

Input: nums = [4,4,2,4,3]
Output: 3
Explanation: The following triplets meet the conditions:
- (0, 2, 4) because 4 != 2 != 3
- (1, 2, 4) because 4 != 2 != 3
- (2, 3, 4) because 2 != 4 != 3
Since there are 3 triplets, we return 3.
Note that (2, 0, 4) is not a valid triplet because 2 > 0.

Example 2:

Input: nums = [1,1,1,1,1]
Output: 0
Explanation: No triplets meet the conditions so we return 0.

Constraints:

• 3 <= nums.length <= 100
• 1 <= nums[i] <= 1000

Solution 1: Brute Force

Enumerate i, j, k.

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

// Author: Huahua
class Solution {
public:
  int unequalTriplets(vector<int>& nums) {
    int ans = 0;
    const int n = nums.size();
    for (int i = 0; i < n; ++i)
      for (int j = i + 1; j < n; ++j)
        for (int k = j + 1; k < n; ++k)
          if (nums[i] != nums[j] && nums[j] != nums[k] && nums[i] != nums[k])
            ++ans;
    return ans;
  }
};