Return the total frequencies of elements in nums such that those elements all have the maximum frequency.

The frequency of an element is the number of occurrences of that element in the array.

Example 1:

Input: nums = [1,2,2,3,1,4]
Output: 4
Explanation: The elements 1 and 2 have a frequency of 2 which is the maximum frequency in the array.
So the number of elements in the array with maximum frequency is 4.

Example 2:

Input: nums = [1,2,3,4,5]
Output: 5
Explanation: All elements of the array have a frequency of 1 which is the maximum.
So the number of elements in the array with maximum frequency is 5.

Constraints:

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

Solution: Hashtable

Use a hashtable to store the frequency of each element, and compare it with a running maximum frequency. Reset answer if current frequency is greater than maximum frequency. Increment the answer if current frequency is equal to the maximum frequency.

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

class Solution {
public:
  int maxFrequencyElements(vector<int>& nums) {
    unordered_map<int, int> m;
    int freq = 0;
    int ans = 0;
    for (int x : nums) {
      if (++m[x] > freq)
        freq = m[x], ans = 0;
      if (m[x] == freq)
        ans += m[x];
    }
    return ans;
  }
};

The post 花花酱 LeetCode 3005. Count Elements With Maximum Frequency appeared first on Huahua's Tech Road.

• For example, the beauty of "abaacc" is 3 - 1 = 2.

Given a string s, return the sum of beauty of all of its substrings.

Example 1:

Input: s = "aabcb"
Output: 5
Explanation: The substrings with non-zero beauty are ["aab","aabc","aabcb","abcb","bcb"], each with beauty equal to 1.

Example 2:

Input: s = "aabcbaa"
Output: 17

Constraints:

• 1 <= s.length <=500
• s consists of only lowercase English letters.

Solution: Treemap

Time complexity: O(n²log26)
Space complexity: O(26)

// Author: Huahua
class Solution {
public:
  int beautySum(string_view s) {
    const int n = s.size();
    int ans = 0;
    vector<int> f(26);
    map<int, int> m;
    for (int i = 0; i < n; ++i) {
      fill(begin(f), end(f), 0);
      m.clear();
      for (int j = i; j < n; ++j) {
        const int c = ++f[s[j] - 'a'];
        ++m[c];
        if (c > 1) {
          auto it = m.find(c - 1);
          if (--it->second == 0)
            m.erase(it);
        }
        ans += rbegin(m)->first - begin(m)->first;  
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1781. Sum of Beauty of All Substrings appeared first on Huahua's Tech Road.

Given a string s, return the minimum number of characters you need to delete to make s good.

The frequency of a character in a string is the number of times it appears in the string. For example, in the string "aab", the frequency of 'a' is 2, while the frequency of 'b' is 1.

Example 1:

Input: s = "aab"
Output: 0
Explanation: s is already good.

Example 2:

Input: s = "aaabbbcc"
Output: 2
Explanation: You can delete two 'b's resulting in the good string "aaabcc".
Another way it to delete one 'b' and one 'c' resulting in the good string "aaabbc".

Example 3:

Input: s = "ceabaacb"
Output: 2
Explanation: You can delete both 'c's resulting in the good string "eabaab".
Note that we only care about characters that are still in the string at the end (i.e. frequency of 0 is ignored).

Constraints:

• 1 <= s.length <= 105
• s contains only lowercase English letters.

Solution: Hashtable

The deletion order doesn’t matter, we can process from ‘a’ to ‘z’. Use a hashtable to store the “final frequency” so far, for each char, decrease its frequency until it becomes unique in the final frequency hashtable.

Time complexity: O(n + 26^2)
Space complexity: O(26)

class Solution {
public:
  int minDeletions(string s) {
    vector<int> freq(26);
    for (char c : s) ++freq[c - 'a'];    
    unordered_set<int> seen;
    int ans = 0;
    for (int f : freq) {
      while (f && !seen.insert(f).second) {        
        --f;
        ++ans;
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1647. Minimum Deletions to Make Character Frequencies Unique appeared first on Huahua's Tech Road.

• Type 1: Triplet (i, j, k) if nums1[i]2 == nums2[j] * nums2[k] where 0 <= i < nums1.length and 0 <= j < k < nums2.length.
• Type 2: Triplet (i, j, k) if nums2[i]2 == nums1[j] * nums1[k] where 0 <= i < nums2.length and 0 <= j < k < nums1.length.

Example 1:

Input: nums1 = [7,4], nums2 = [5,2,8,9]
Output: 1
Explanation: Type 1: (1,1,2), nums1[1]^2 = nums2[1] * nums2[2]. (4^2 = 2 * 8). 

Example 2:

Input: nums1 = [1,1], nums2 = [1,1,1]
Output: 9
Explanation: All Triplets are valid, because 1^2 = 1 * 1.
Type 1: (0,0,1), (0,0,2), (0,1,2), (1,0,1), (1,0,2), (1,1,2).  nums1[i]^2 = nums2[j] * nums2[k].
Type 2: (0,0,1), (1,0,1), (2,0,1). nums2[i]^2 = nums1[j] * nums1[k].

Example 3:

Input: nums1 = [7,7,8,3], nums2 = [1,2,9,7]
Output: 2
Explanation: There are 2 valid triplets.
Type 1: (3,0,2).  nums1[3]^2 = nums2[0] * nums2[2].
Type 2: (3,0,1).  nums2[3]^2 = nums1[0] * nums1[1].

Example 4:

Input: nums1 = [4,7,9,11,23], nums2 = [3,5,1024,12,18]
Output: 0
Explanation: There are no valid triplets.

Constraints:

• 1 <= nums1.length, nums2.length <= 1000
• 1 <= nums1[i], nums2[i] <= 10^5

Solution: Hashtable

For each number y in the second array, count its frequency.

For each number x in the first, if x * x % y == 0, let r = x * x / y
if r == y: ans += f[y] * f[y-1]
else ans += f[y] * f[r]

Final ans /= 2

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

// Author: Huahua
class Solution {
public:
  int numTriplets(vector<int>& nums1, vector<int>& nums2) {
    return solve(nums1, nums2) + solve(nums2, nums1);
  }
private:
  int solve(vector<int>& nums1, vector<int>& nums2) {
    int ans = 0;
    unordered_map<int, int> f;
    for (int y : nums2) ++f[y];
    for (long x : nums1)
      for (const auto& [y, c] : f) {                
        long r = x * x / y;
        if (x * x % y || !f.count(r)) continue;
        if (r == y) ans += c * (c - 1);
        else ans += c * f[r];
      }
    return ans / 2;
  }
};

The post 花花酱 LeetCode 1577. Number of Ways Where Square of Number Is Equal to Product of Two Numbers appeared first on Huahua's Tech Road.

Return the number of good splits you can make in s.

Example 1:

Input: s = "aacaba"
Output: 2
Explanation: There are 5 ways to split "aacaba" and 2 of them are good. 
("a", "acaba") Left string and right string contains 1 and 3 different letters respectively.
("aa", "caba") Left string and right string contains 1 and 3 different letters respectively.
("aac", "aba") Left string and right string contains 2 and 2 different letters respectively (good split).
("aaca", "ba") Left string and right string contains 2 and 2 different letters respectively (good split).
("aacab", "a") Left string and right string contains 3 and 1 different letters respectively.

Example 2:

Input: s = "abcd"
Output: 1
Explanation: Split the string as follows ("ab", "cd").

Example 3:

Input: s = "aaaaa"
Output: 4
Explanation: All possible splits are good.

Example 4:

Input: s = "acbadbaada"
Output: 2

Constraints:

• s contains only lowercase English letters.
• 1 <= s.length <= 10^5

Solution: Sliding Window

1. Count the frequency of each letter and count number of unique letters for the entire string as right part.
2. Iterate over the string, add current letter to the left part, and remove it from the right part.
3. We only
   1. increase the number of unique letters when its frequency becomes to 1
   2. decrease the number of unique letters when its frequency becomes to 0

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

class Solution {
public:
  int numSplits(string s) {
    vector<int> r(26);
    vector<int> l(26);
    int cr = 0;
    for (char c : s)
      cr += (++r[c - 'a'] == 1);    
    int ans = 0;
    int cl = 0;
    for (char c : s) {
      cl += (++l[c - 'a'] == 1);
      cr -= (--r[c - 'a'] == 0);
      ans += cl == cr;
    }
    return ans;
  }
};

class Solution {
  public int numSplits(String s) {
    int[] l = new int[26];
    int[] r = new int[26];
    int ans = 0;
    int cl = 0;
    int cr = 0;
    for (char c : s.toCharArray())
      if (++r[c - 'a'] == 1) ++cr;
    for (char c : s.toCharArray()) {
      if (++l[c - 'a'] == 1) ++cl;
      if (--r[c - 'a'] == 0) --cr;
      if (cl == cr) ++ans;
    }
    return ans;
  }
}

class Solution:
  def numSplits(self, s: str) -> int:
    s = [ord(c) - ord('a') for c in s]
    l, r = [0] * 26, [0] * 26
    cl, cr, ans = 0, 0, 0
    for c in s:
      r[c] += 1
      if r[c] == 1: cr += 1
    for c in s:
      l[c] += 1
      r[c] -= 1
      if l[c] == 1: cl += 1
      if r[c] == 0: cr -= 1
      if cl == cr: ans += 1
    return ans

The post 花花酱 LeetCode 1525. Number of Good Ways to Split a String appeared first on Huahua's Tech Road.

We want to divide the array into exactly n / 2 pairs such that the sum of each pair is divisible by k.

Return True If you can find a way to do that or False otherwise.

Example 1:

Input: arr = [1,2,3,4,5,10,6,7,8,9], k = 5
Output: true
Explanation: Pairs are (1,9),(2,8),(3,7),(4,6) and (5,10).

Example 2:

Input: arr = [1,2,3,4,5,6], k = 7
Output: true
Explanation: Pairs are (1,6),(2,5) and(3,4).

Example 3:

Input: arr = [1,2,3,4,5,6], k = 10
Output: false
Explanation: You can try all possible pairs to see that there is no way to divide arr into 3 pairs each with sum divisible by 10.

Example 4:

Input: arr = [-10,10], k = 2
Output: true

Example 5:

Input: arr = [-1,1,-2,2,-3,3,-4,4], k = 3
Output: true

Constraints:

• arr.length == n
• 1 <= n <= 10^5
• n is even.
• -10^9 <= arr[i] <= 10^9
• 1 <= k <= 10^5

Solution: Mod and Count

Count the frequency of (x % k + k) % k.
f[0] should be even (zero is also even)
f[1] = f[k -1] ((1 + k – 1) % k == 0)
f[2] = f[k -2] ((2 + k – 2) % k == 0)
…
Time complexity: O(n)
Space complexity: O(k)

// Author: Huahua
class Solution {
public:
  bool canArrange(vector<int>& arr, int k) {
    vector<int> f(k);
    for (int x : arr) ++f[(x % k + k) % k];
    for (int i = 1; i < k; ++i)
      if (f[i] != f[k - i]) return false;
    return f[0] % 2 == 0;
  }
};

The post 花花酱 LeetCode 1497. Check If Array Pairs Are Divisible by k appeared first on Huahua's Tech Road.

Example 1:

Input: arr = [5,5,4], k = 1
Output: 1
Explanation: Remove the single 4, only 5 is left.

Example 2:

Input: arr = [4,3,1,1,3,3,2], k = 3
Output: 2
Explanation: Remove 4, 2 and either one of the two 1s or three 3s. 1 and 3 will be left.

Constraints:

• 1 <= arr.length <= 10^5
• 1 <= arr[i] <= 10^9
• 0 <= k <= arr.length

Solution: Greedy

Count the frequency of each unique number. Sort by frequency, remove items with lowest frequency first.

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

// Author: Huahua
class Solution {
public:
  int findLeastNumOfUniqueInts(vector<int>& arr, int k) {    
    unordered_map<int, int> c;
    for (int x : arr) ++c[x];
    vector<int> m; // freq
    for (const auto [x, f] : c)
      m.push_back(f);
    sort(begin(m), end(m));
    int ans = m.size();    
    int i = 0;
    while (k--) {
      if (--m[i] == 0) {
        ++i;
        --ans;
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1481. Least Number of Unique Integers after K Removals appeared first on Huahua's Tech Road.

1. Pick the smallest character from s and append it to the result.
2. Pick the smallest character from s which is greater than the last appended character to the result and append it.
3. Repeat step 2 until you cannot pick more characters.
4. Pick the largest character from s and append it to the result.
5. Pick the largest character from s which is smaller than the last appended character to the result and append it.
6. Repeat step 5 until you cannot pick more characters.
7. Repeat the steps from 1 to 6 until you pick all characters from s.

In each step, If the smallest or the largest character appears more than once you can choose any occurrence and append it to the result.

Return the result string after sorting s with this algorithm.

Example 1:

Input: s = "aaaabbbbcccc"
Output: "abccbaabccba"
Explanation: After steps 1, 2 and 3 of the first iteration, result = "abc"
After steps 4, 5 and 6 of the first iteration, result = "abccba"
First iteration is done. Now s = "aabbcc" and we go back to step 1
After steps 1, 2 and 3 of the second iteration, result = "abccbaabc"
After steps 4, 5 and 6 of the second iteration, result = "abccbaabccba"

Example 2:

Input: s = "rat"
Output: "art"
Explanation: The word "rat" becomes "art" after re-ordering it with the mentioned algorithm.

Example 3:

Input: s = "leetcode"
Output: "cdelotee"

Example 4:

Input: s = "ggggggg"
Output: "ggggggg"

Example 5:

Input: s = "spo"
Output: "ops"

Constraints:

• 1 <= s.length <= 500
• s contains only lower-case English letters.

Solution: Counting frequency of each character

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

// Author: Huahua
class Solution {
public:
  string sortString(string s) {
    vector<int> count(26);
    for (char c : s) ++count[c - 'a'];
    string ans;
    while (ans.length() != s.length()) {
      for (char c = 'a'; c <= 'z'; ++c)
        if (--count[c - 'a'] >= 0)
          ans += c;
      for (char c = 'z'; c >= 'a'; --c)
        if (--count[c - 'a'] >= 0)
          ans += c;      
    }
    return ans;
  }
};

# Author: Huahua
class Solution:
  def sortString(self, s: str) -> str:
    seq = string.ascii_lowercase + string.ascii_lowercase[::-1]
    count = collections.Counter(s)
    ans = ""
    while len(ans) != len(s):
      for c in seq:
        if count[c] > 0:
          ans += c
          count[c] -= 1
    return ans

The post 花花酱 LeetCode 1370. Increasing Decreasing String appeared first on Huahua's Tech Road.

With respect to a given puzzle string, a word is valid if both the following conditions are satisfied:

• word contains the first letter of puzzle.
• For each letter in word, that letter is in puzzle.
  For example, if the puzzle is “abcdefg”, then valid words are “faced”, “cabbage”, and “baggage”; while invalid words are “beefed” (doesn’t include “a”) and “based” (includes “s” which isn’t in the puzzle).

Return an array answer, where answer[i] is the number of words in the given word list words that are valid with respect to the puzzle puzzles[i].

Example :

Input: 
words = ["aaaa","asas","able","ability","actt","actor","access"], 
puzzles = ["aboveyz","abrodyz","abslute","absoryz","actresz","gaswxyz"]
Output: [1,1,3,2,4,0]
Explanation:
1 valid word for "aboveyz" : "aaaa" 
1 valid word for "abrodyz" : "aaaa"
3 valid words for "abslute" : "aaaa", "asas", "able"
2 valid words for "absoryz" : "aaaa", "asas"
4 valid words for "actresz" : "aaaa", "asas", "actt", "access"
There're no valid words for "gaswxyz" cause none of the words in the list contains letter 'g'.

Constraints:

• 1 <= words.length <= 10^5
• 4 <= words[i].length <= 50
• 1 <= puzzles.length <= 10^4
• puzzles[i].length == 7
• words[i][j], puzzles[i][j] are English lowercase letters.
• Each puzzles[i] doesn’t contain repeated characters.

Solution: Subsets

Preprocessing:
Compress each word to a bit map, and compute the frequency of each bit map.
Since there are at most |words| bitmaps while its value ranging from 0 to 2^26, thus it’s better to use a hashtable instead of an array.

Query:
Use the same way to compress a puzzle into a bit map.
Try all subsets (at most 128) of the puzzle (the bit of the first character is be must), and check how many words match each subset.

words = [“aaaa”,”asas”,”able”,”ability”,”actt”,”actor”,”access”],
puzzle = “abslute”
bitmap(“aaaa”) = {0}
bitmap(“asas”) = {0, 18}
bitmap(“able”) = {0,1,4,11}
bitmap(“actt”) = {0, 2, 19}
bitmap(“actor”) = {0, 2, 14, 17, 19}
bitmap(“access”) = {0, 2, 4, 18}

bitmap(“abslute”) = {0, 1, 4, 11, 18, 19, 20}

Time complexity: O(sum(len(w_i)) + |puzzles|)
Space complexity: O(|words|)

// Author: Huahua, 136 ms, 29.7 MB
class Solution {
public:
  vector<int> findNumOfValidWords(vector<string>& words, vector<string>& puzzles) {
    vector<int> ans;    
    unordered_map<int, int> freq;
    for (const string& word : words) {
      int mask = 0;
      for (char c : word)
        mask |= 1 << (c - 'a');
      ++freq[mask];
    }    
    for (const string& p : puzzles) {
      int mask = 0;      
      for (char c : p)
        mask |= 1 << (c - 'a');
      int first = p[0] - 'a';
      int curr = mask;
      int total = 0;
      while (curr) {
        if ((curr >> first) & 1) {
          auto it = freq.find(curr);
          if (it != freq.end()) total += it->second;
        }
        curr = (curr - 1) & mask;
      }
      ans.push_back(total);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1178. Number of Valid Words for Each Puzzle appeared first on Huahua's Tech Road.

For each query queries[i] = [left, right, k], we may rearrange the substring s[left], ..., s[right], and then choose up to k of them to replace with any lowercase English letter. 

If the substring is possible to be a palindrome string after the operations above, the result of the query is true. Otherwise, the result is false.

Return an array answer[], where answer[i] is the result of the i-th query queries[i].

Note that: Each letter is counted individually for replacement so if for example s[left..right] = "aaa", and k = 2, we can only replace two of the letters.  (Also, note that the initial string s is never modified by any query.)

Example :

Input: s = "abcda", queries = [[3,3,0],[1,2,0],[0,3,1],[0,3,2],[0,4,1]]
Output: [true,false,false,true,true]
Explanation:
queries[0] : substring = "d", is palidrome.
queries[1] : substring = "bc", is not palidrome.
queries[2] : substring = "abcd", is not palidrome after replacing only 1 character.
queries[3] : substring = "abcd", could be changed to "abba" which is palidrome. Also this can be changed to "baab" first rearrange it "bacd" then replace "cd" with "ab".
queries[4] : substring = "abcda", could be changed to "abcba" which is palidrome.

Constraints:

• 1 <= s.length, queries.length <= 10^5
• 0 <= queries[i][0] <= queries[i][1] < s.length
• 0 <= queries[i][2] <= s.length
• s only contains lowercase English letters.

Solution: Prefix frequency

Compute the prefix frequency of each characters, then we can efficiently compute the frequency of each characters in the substring in O(1) time. Count the number odd frequency characters o, we can convert it to a palindrome if o / 2 <= k.

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

// Author: Huahua
class Solution {
public:
  vector<bool> canMakePaliQueries(string s, vector<vector<int>>& queries) {
    vector<bool> ans;
    int n = s.length();
    vector<vector<int>> f(n + 1, vector<int>(26));
    for (int i = 0; i < n; ++i) {
      ++f[i][s[i] - 'a'];
      f[i + 1] = f[i];
    }
    for (const auto& q : queries) {      
      int l = q[0];
      int r = q[1];
      int k = q[2];      
      int o = 0;
      for (int i = 0; i < 26; ++i) {
        int c = f[r][i] - (l == 0 ? 0 : f[l - 1][i]);        
        o += c % 2;
      }
      ans.push_back(o / 2 <= k);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1177. Can Make Palindrome from Substring appeared first on Huahua's Tech Road.

题目大意: 给你一个由字母和数字组成车牌。另外给你一些单词，让你找一个最短的单词能够覆盖住车牌中的字母（不考虑大小写）。如果有多个解，输出第一个解。

Problem:

Find the minimum length word from a given dictionary words, which has all the letters from the string licensePlate. Such a word is said to complete the given string licensePlate

Here, for letters we ignore case. For example, "P" on the licensePlate still matches "p" on the word.

It is guaranteed an answer exists. If there are multiple answers, return the one that occurs first in the array.

The license plate might have the same letter occurring multiple times. For example, given a licensePlate of "PP", the word "pair" does not complete the licensePlate, but the word "supper" does.

Example 1:

Input: licensePlate = "1s3 PSt", words = ["step", "steps", "stripe", "stepple"]
Output: "steps"
Explanation: The smallest length word that contains the letters "S", "P", "S", and "T".
Note that the answer is not "step", because the letter "s" must occur in the word twice.
Also note that we ignored case for the purposes of comparing whether a letter exists in the word.

Example 2:

Input: licensePlate = "1s3 456", words = ["looks", "pest", "stew", "show"]
Output: "pest"
Explanation: There are 3 smallest length words that contains the letters "s".
We return the one that occurred first.

Note:

1. licensePlate will be a string with length in range [1, 7].
2. licensePlate will contain digits, spaces, or letters (uppercase or lowercase).
3. words will have a length in the range [10, 1000].
4. Every words[i] will consist of lowercase letters, and have length in range [1, 15].

Idea:

Hashtable

Solution:

C++

Time complexity: 时间复杂度 O(N*26), N is number of words.

Space complexity: 空间复杂度 O(26) = O(1)

// Author: Huahua
// Runtime: 15 ms
class Solution {
public:
    string shortestCompletingWord(string licensePlate, vector<string>& words) {
        vector<int> l(26, 0);
        for (const char ch : licensePlate)
            if (isalpha(ch)) ++l[tolower(ch) - 'a'];
        string ans;
        int min_l = INT_MAX;
        for (const string& word : words) {
            if (word.length() >= min_l) continue;
            if (!matches(l, word)) continue;
            min_l = word.length();
            ans = word;
        }
        return ans;
    }
private:
    bool matches(const vector<int>& l, const string& word) {
        vector<int> c(26, 0);
        for (const char ch : word)
            ++c[tolower(ch) - 'a'];        
        for (int i = 0; i < 26; ++i)
            if (c[i] < l[i]) return false;
        return true;
    }
};

The post 花花酱 LeetCode 748. Shortest Completing Word appeared first on Huahua's Tech Road.

Problem:

Given a non-empty array of integers, return the k most frequent elements.

For example,
Given [1,1,1,2,2,3] and k = 2, return [1,2].

Note:
You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
Your algorithm’s time complexity must be better than O(n log n), where n is the array’s size.

Idea:

Solution 2: Priority queue / max heap

Time complexity: O(n) + O(nlogk)

Space complexity: O(n)

// Author: Huahuas
// Running time: 16 ms
class Solution {
public:
  vector<int> topKFrequent(vector<int>& nums, int k) {
    unordered_map<int, int> count;        
    for (const int num : nums)
      ++count[num];
    priority_queue<pair<int, int>> q;
    for (const auto& pair : count) {
      q.emplace(-pair.second, pair.first);
      if (q.size() > k) q.pop();
    }
    vector<int> ans;
    for (int i = 0; i < k; ++i) {
      ans.push_back(q.top().second);
      q.pop();
    }
    return ans;
  }
};

// Author: Huahua
// Running time: 56 ms
class Solution {
  public List<Integer> topKFrequent(int[] nums, int k) {    
    Map<Integer, Integer> counts = new HashMap<>();    
    for (int num : nums)
      counts.put(num, counts.getOrDefault(num, 0) + 1);    
    
    PriorityQueue<int[]> queue = new PriorityQueue<>((x, y) -> x[0] - y[0]);
    for (Integer num : counts.keySet()) {
      queue.offer(new int[]{counts.get(num), num});
      if (queue.size() > k) queue.poll();
    }
        
    List<Integer> ans = new ArrayList<>();
    for (int i = 0; i < k; ++i)
      ans.add(queue.poll()[1]);
    return ans;    
  }
}

"""
Author: Huahua
Running time: 56 ms
"""
class Solution:
  def topKFrequent(self, nums, k):
    counts = collections.Counter(nums)
    h = []
    for num in counts.keys():
      heapq.heappush(h, (counts[num], num))
      if len(h) > k: heapq.heappop(h)
    return [heapq.heappop(h)[1] for i in range(k)]

Solution 3: Bucket Sort

Time complexity: O(n)

Space complexity: O(n)

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> count;
        int max_freq = 1;
        for (const int num : nums)
            max_freq = max(max_freq, ++count[num]);
        map<int, vector<int>> buckets;
        for (const auto& kv : count)
            buckets[kv.second].push_back(kv.first);
        vector<int> ans;
        for (int i = max_freq; i >= 1; --i) {
            auto it = buckets.find(i);
            if (it == buckets.end()) continue;
            ans.insert(ans.end(), it->second.begin(), it->second.end());
            if (ans.size() == k) return ans;
        }
        return ans;
    }
};

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> count;
        for (const int num : nums)
            ++count[num];
        vector<vector<int>> buckets(nums.size() + 1);
        for (const auto& kv : count)
            buckets[kv.second].push_back(kv.first);
        vector<int> ans;
        for (auto it = buckets.rbegin(); it != buckets.rend(); ++it) {
            const vector<int>& keys = *it;
            if (keys.empty()) continue;
            ans.insert(ans.begin(), keys.begin(), keys.end());
            if (ans.size() == k) return ans;
        }
        return ans;
    }
};

// Author: Huahua
// Running time: 23 ms
class Solution {
  public List<Integer> topKFrequent(int[] nums, int k) {
    List[] buckets = new List[nums.length + 1];
    Map<Integer, Integer> counts = new HashMap<>();

    for (int num : nums)      
      counts.put(num, counts.getOrDefault(num, 0) + 1);    
        
    for (int num : counts.keySet()) {
      int count = counts.get(num);
      if (buckets[count] == null)
        buckets[count] = new ArrayList<Integer>();
      buckets[count].add(num);
    }
    
    List<Integer> ans = new ArrayList<>();
    for (int i = buckets.length - 1; i > 0 && ans.size() < k; --i) {
      if (buckets[i] != null) ans.addAll(buckets[i]);      
    }
    return ans;    
  }
}

"""
Author: Huahua
Running time: 64 ms
"""
class Solution:
  def topKFrequent(self, nums, k):
    counts = collections.Counter(nums)
    buckets = [[] for _ in range(len(nums) + 1)]    
    for num in counts.keys():
      buckets[counts[num]].append(num)
    ans = []
    for i in range(len(nums), 0, -1):      
      ans += buckets[i]      
      if len(ans) == k: return ans
    return ans

Related Problems

• [解题报告] LeetCode 692. Top K Frequent Words

The post 花花酱 LeetCode 347. Top K Frequent Elements appeared first on Huahua's Tech Road.

Problem:

Given a non-empty list of words, return the k most frequent elements.

Your answer should be sorted by frequency from highest to lowest. If two words have the same frequency, then the word with the lower alphabetical order comes first.

Example 1:

Input: ["i", "love", "leetcode", "i", "love", "coding"], k = 2
Output: ["i", "love"]
Explanation: "i" and "love" are the two most frequent words.
    Note that "i" comes before "love" due to a lower alphabetical order.

Example 2:

Input: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k = 4
Output: ["the", "is", "sunny", "day"]
Explanation: "the", "is", "sunny" and "day" are the four most frequent words,
    with the number of occurrence being 4, 3, 2 and 1 respectively.

Note:

1. You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
2. Input words contain only lowercase letters.

Follow up:

1. Try to solve it in O(n log k) time and O(n) extra space.

Idea:

Priority queue / min heap

Solution

C++ / priority_queue O(n log k) / O(n)

// Author: Huahua
// Runtime: 13 ms (< 90.31 %)
class Solution {
private:
    typedef pair<string, int> Node;
    typedef function<bool(const Node&, const Node&)> Compare;
public:
    vector<string> topKFrequent(vector<string>& words, int k) {
        unordered_map<string, int> count;
        for (const string& word : words)
            ++count[word];
        
        Compare comparator = [](const Node& a, const Node& b) {
            // order by alphabet ASC
            if (a.second == b.second) 
                return  a.first < b.first;
            // order by freq DESC
            return a.second > b.second;
        };
        
        // Min heap by frequency
        priority_queue<Node, vector<Node>, Compare> q(comparator);
        
        // O(n*logk)
        for (const auto& kv : count) {
            q.push(kv);
            if (q.size() > k) q.pop();
        }
        
        vector<string> ans;
        
        while (!q.empty()) {
            ans.push_back(q.top().first);
            q.pop();
        }
        
        std::reverse(ans.begin(), ans.end());
        return ans;
    }
};

Related Problems

• [解题报告] LeetCode 347. Top K Frequent Elements

The post 花花酱 LeetCode 692. Top K Frequent Words appeared first on Huahua's Tech Road.

https://leetcode.com/problems/longest-palindrome/description/

Problem:

Given a string which consists of lowercase or uppercase letters, find the length of the longest palindromes that can be built with those letters.

This is case sensitive, for example "Aa" is not considered a palindrome here.

Note:
Assume the length of given string will not exceed 1,010.

Example:

Input:
"abccccdd"

Output:
7

Explanation:
One longest palindrome that can be built is "dccaccd", whose length is 7.

Idea:

Greedy + Counting

Solution:

C++

// Author: Huahua
// Time complexity: O(n)
// Space complexity: O(128) = O(1)
// Running time: 3 ms 9/2017
class Solution {
public:
    int longestPalindrome(const string& s) {
        vector<int> freqs(128, 0);
        for (const char c : s)            
            ++freqs[c];

        int ans = 0;
        int odd = 0;
        for (const int freq : freqs) {            
            // same as: ans += freq % 2 == 0 ? freq : freq - 1;
            // same as: ans += freq / 2 * 2;
            // same as: ans += ((freq >> 1) << 1);            
            // same as: ans += freq & (INT_MAX - 1);
            ans += freq & (~1); // clear the last bit
            odd |= freq & 1;
        }
        
        ans += odd;
        
        return ans;
    }
};

Java

// Author: Huahua
// Running time: 11 ms
class Solution {
    public int longestPalindrome(String s) {        
        int[] freqs = new int[128];
        for (int i = 0; i < s.length(); ++i)
            ++freqs[s.charAt(i)];
        
        int ans = 0;
        int odd = 0;
        
        for (int freq: freqs) {
            ans += freq & (~1);
            odd |= freq & 1;
        }
        
        return ans + odd;
    }
}

Python

"""
Author: Huahua
Running time: 39 ms
"""
class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: int
        """
        freqs = [0] * 128
        
        for c in s:
            freqs[ord(c)] += 1
        
        ans, odd = 0, 0
        for freq in freqs:
            ans += freq & (~1)
            odd |= freq & 1
        
        return ans + odd

The post 花花酱 LeetCode 409. Longest Palindrome appeared first on Huahua's Tech Road.

Example 1:

<b>Input:</b>
"tree"

<b>Output:</b>
"eert"

<b>Explanation:</b>
'e' appears twice while 'r' and 't' both appear once.
So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.

Example 2:

<b>Input:</b>
"cccaaa"

<b>Output:</b>
"cccaaa"

<b>Explanation:</b>
Both 'c' and 'a' appear three times, so "aaaccc" is also a valid answer.
Note that "cacaca" is incorrect, as the same characters must be together.

Example 3:

<b>Input:</b>
"Aabb"

<b>Output:</b>
"bbAa"

<b>Explanation:</b>
"bbaA" is also a valid answer, but "Aabb" is incorrect.
Note that 'A' and 'a' are treated as two different characters.

class Solution {
public:
    string frequencySort(string s) {
        map<char, int> f;
        for(char c:s) ++f[c];
        vector<pair<int,char>> v;
        for(auto& kv : f)
            v.push_back({kv.second, kv.first});
        sort(v.rbegin(), v.rend());
        stringstream ans;
        for(auto& kv : v)
            ans << string(kv.first, kv.second);
        return ans.str();
    }
};

The post 花花酱 LeetCode 451. Sort Characters By Frequency appeared first on Huahua's Tech Road.