Return the minimum cost of deletions such that there are no two identical letters next to each other.

Notice that you will delete the chosen characters at the same time, in other words, after deleting a character, the costs of deleting other characters will not change.

Example 1:

Input: s = "abaac", cost = [1,2,3,4,5]
Output: 3
Explanation: Delete the letter "a" with cost 3 to get "abac" (String without two identical letters next to each other).

Example 2:

Input: s = "abc", cost = [1,2,3]
Output: 0
Explanation: You don't need to delete any character because there are no identical letters next to each other.

Example 3:

Input: s = "aabaa", cost = [1,2,3,4,1]
Output: 2
Explanation: Delete the first and the last character, getting the string ("aba").

Constraints:

• s.length == cost.length
• 1 <= s.length, cost.length <= 10^5
• 1 <= cost[i] <= 10^4
• s contains only lowercase English letters.

Solution: Group by group

For a group of same letters, delete all expect the one with the highest cost.

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

class Solution {
public:
  int minCost(string s, vector<int>& cost) {
    int t = cost[0];
    int m = cost[0];
    int ans = 0;
    for (int i = 1; i < s.length(); ++i) {
      if (s[i] != s[i - 1]) {
        ans += t - m;
        t = m = 0;
      }
      t += cost[i];
      m = max(m, cost[i]);
    }
    return ans + (t - m);
  }
};

class Solution:
  def minCost(self, s: str, cost: List[int]) -> int:
    s = '*' + s + '*'
    cost = [0] + cost + [0]
    ans = t = m = 0    
    for i in range(1, len(s)):
      if s[i] != s[i - 1]:
        ans += t - m
        t = m = 0
      t += cost[i]
      m = max(m, cost[i])
    return ans

The post 花花酱 LeetCode 1578. Minimum Deletion Cost to Avoid Repeating Letters appeared first on Huahua's Tech Road.

You can return any solution in any order and the same applies for IDs. Also, it is guaranteed that there exists at least one solution. 

Example 1:

Input: groupSizes = [3,3,3,3,3,1,3]
Output: [[5],[0,1,2],[3,4,6]]
Explanation: 
Other possible solutions are [[2,1,6],[5],[0,4,3]] and [[5],[0,6,2],[4,3,1]].

Example 2:

Input: groupSizes = [2,1,3,3,3,2]
Output: [[1],[0,5],[2,3,4]]

Constraints:

• groupSizes.length == n
• 1 <= n <= 500
• 1 <= groupSizes[i] <= n

Solution: HashMap + Greedy

hashmap: group_size -> {ids}
greedy: whenever a group of size s has s people, assign those s people to the same group.

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

// Author: Huahua
class Solution {
public:
  vector<vector<int>> groupThePeople(vector<int>& groupSizes) {
    vector<vector<int>> ans;
    const int n =  groupSizes.size();
    unordered_map<int, vector<int>> m;
    for (int i = 0; i < n; ++i) {
      auto& v = m[groupSizes[i]];
      v.push_back(i);
      if (v.size() == groupSizes[i])
        ans.push_back(std::move(v));                       
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1282. Group the People Given the Group Size They Belong To appeared first on Huahua's Tech Road.

题目大意：给你一些牌，问你能否分组，要求每组w张连续的牌。

https://leetcode.com/problems/hand-of-straights/description/

Alice has a hand of cards, given as an array of integers.

Now she wants to rearrange the cards into groups so that each group is size W, and consists of W consecutive cards.

Return true if and only if she can.

Example 1:

Input: hand = [1,2,3,6,2,3,4,7,8], W = 3
Output: true
Explanation: Alice's hand can be rearranged as [1,2,3],[2,3,4],[6,7,8].

Example 2:

Input: hand = [1,2,3,4,5], W = 4
Output: false
Explanation: Alice's hand can't be rearranged into groups of 4.

Note:

1. 1 <= hand.length <= 10000
2. 0 <= hand[i] <= 10^9
3. 1 <= W <= hand.length

Solution: Greedy

Time complexity: O(nlogn)

Space complexity: O(n)

// Author: Huahua
// Running time: 65 ms
class Solution {
public:
  bool isNStraightHand(vector<int>& hand, int W) {
    map<int, int> counts;
    for (int h : hand) ++counts[h];
    while (!counts.empty()) {
      auto it = counts.begin();
      int start = it->first;
      for (int j = 0; j < W; ++j) {        
        if (it == counts.end() 
            || it->first != start + j) return false;
        auto prev = it++;
        if (--(prev->second) == 0) 
          counts.erase(prev);
      }
    }    
    return true;
  }
};

The post 花花酱 LeetCode 846. Hand of Straights appeared first on Huahua's Tech Road.