The array nums is called alternating if:

• nums[i - 2] == nums[i], where 2 <= i <= n - 1.
• nums[i - 1] != nums[i], where 1 <= i <= n - 1.

In one operation, you can choose an index i and change nums[i] into any positive integer.

Return the minimum number of operations required to make the array alternating.

Example 1:

Input: nums = [3,1,3,2,4,3]
Output: 3
Explanation:
One way to make the array alternating is by converting it to [3,1,3,1,3,1].
The number of operations required in this case is 3.
It can be proven that it is not possible to make the array alternating in less than 3 operations. 

Example 2:

Input: nums = [1,2,2,2,2]
Output: 2
Explanation:
One way to make the array alternating is by converting it to [1,2,1,2,1].
The number of operations required in this case is 2.
Note that the array cannot be converted to [2,2,2,2,2] because in this case nums[0] == nums[1] which violates the conditions of an alternating array.

Constraints:

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

Solution: Greedy

Count and sort the frequency of numbers at odd and even positions.

Case 1: top frequency numbers are different, change the rest of numbers to them respectively.
Case 2: top frequency numbers are the same, compare top 1 odd + top 2 even vs top 2 even + top 1 odd.

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

// Author: Huahua
class Solution {
public:
  int minimumOperations(vector<int>& nums) {
    const int n = nums.size();
    if (n == 1) return 0;
    unordered_map<int, int> odd, even;
    for (int i = 0; i < n; ++i)
      ((i & 1 ? odd : even)[nums[i]])++;
    vector<pair<int, int>> o, e;
    for (const auto [k, v] : odd)
      o.emplace_back(v, k);
    for (const auto [k, v] : even)
      e.emplace_back(v, k);
    sort(rbegin(o), rend(o));
    sort(rbegin(e), rend(e));        
    if (o[0].second != e[0].second) 
      return n - o[0].first - e[0].first;    
    int mo = o[0].first + (e.size() > 1 ? e[1].first : 0);
    int me = e[0].first + (o.size() > 1 ? o[1].first : 0);
    return n - max(mo, me);
  }
};

The post 花花酱 LeetCode 2170. Minimum Operations to Make the Array Alternating appeared first on Huahua's Tech Road.

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.

Any two characters may be swapped, even if they are not adjacent.

Example 1:

Input: s = "111000"
Output: 1
Explanation: Swap positions 1 and 4: "111000" -> "101010"
The string is now alternating.

Example 2:

Input: s = "010"
Output: 0
Explanation: The string is already alternating, no swaps are needed.

Example 3:

Input: s = "1110"
Output: -1

Constraints:

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

Solution: Greedy

Two passes, make the string starts with ‘0’ or ‘1’, count how many 0/1 swaps needed. 0/1 swaps must equal otherwise it’s impossible to swap.

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

// Author: Huahua
class Solution {
public:
  int minSwaps(string s) {    
    auto count = [&](int m) {
      vector<int> swaps(2);
      for (int i = 0; i < s.length(); ++i, m ^= 1)
        if (s[i] - '0' != m)
          ++swaps[s[i] - '0'];
      return swaps[0] == swaps[1] ? swaps[0] : INT_MAX;
    };
    
    int ans = min(count(0), count(1));
    return ans != INT_MAX ? ans : -1;
  }
};

The post 花花酱 LeetCode 1864. Minimum Number of Swaps to Make the Binary String Alternating appeared first on Huahua's Tech Road.