Return the minimum number of operations to reduce the sum of nums by at least half.

Example 1:

Input: nums = [5,19,8,1]
Output: 3
Explanation: The initial sum of nums is equal to 5 + 19 + 8 + 1 = 33.
The following is one of the ways to reduce the sum by at least half:
Pick the number 19 and reduce it to 9.5.
Pick the number 9.5 and reduce it to 4.75.
Pick the number 8 and reduce it to 4.
The final array is [5, 4.75, 4, 1] with a total sum of 5 + 4.75 + 4 + 1 = 14.75. 
The sum of nums has been reduced by 33 - 14.75 = 18.25, which is at least half of the initial sum, 18.25 >= 33/2 = 16.5.
Overall, 3 operations were used so we return 3.
It can be shown that we cannot reduce the sum by at least half in less than 3 operations.

Example 2:

Input: nums = [3,8,20]
Output: 3
Explanation: The initial sum of nums is equal to 3 + 8 + 20 = 31.
The following is one of the ways to reduce the sum by at least half:
Pick the number 20 and reduce it to 10.
Pick the number 10 and reduce it to 5.
Pick the number 3 and reduce it to 1.5.
The final array is [1.5, 8, 5] with a total sum of 1.5 + 8 + 5 = 14.5. 
The sum of nums has been reduced by 31 - 14.5 = 16.5, which is at least half of the initial sum, 16.5 >= 31/2 = 16.5.
Overall, 3 operations were used so we return 3.
It can be shown that we cannot reduce the sum by at least half in less than 3 operations.

Constraints:

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

Solution: Greedy + PriorityQueue/Max Heap

Always half the largest number, put all the numbers onto a max heap (priority queue), extract the largest one, and put reduced number back.

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

// Author: Huahua
class Solution {
public:
  int halveArray(vector<int>& nums) {
    double sum = accumulate(begin(nums), end(nums), 0.0);
    priority_queue<double> q;
    for (int num : nums) q.push(num);
    int ans = 0;
    for (double cur = sum; cur > sum / 2; ++ans) {    
      double num = q.top(); q.pop();
      cur -= num / 2;
      q.push(num / 2);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2208. Minimum Operations to Halve Array Sum appeared first on Huahua's Tech Road.

Example 1:

Input: nums = [5,2,3,1]
Output: [1,2,3,5]

Example 2:

Input: nums = [5,1,1,2,0,0]
Output: [0,0,1,1,2,5]

Constraints:

• 1 <= nums.length <= 50000
• -50000 <= nums[i] <= 50000

Since n <= 50000, any O(n^2) won’t pass, we need O(nlogn) or better

Solution 1: QuickSort

Time complexity: O(nlogn) ~ O(n^2)
Space complexity: O(logn) ~ O(n)

// Author: Huahua, 60 ms
class Solution {
public:
  vector<int> sortArray(vector<int>& nums) {
    function<void(int, int)> quickSort = [&](int l, int r) {
      if (l >= r) return;      
      int i = l;
      int j = r;
      int p = nums[l + rand() % (r - l + 1)];
      while (i <= j) {
        while (nums[i] < p) ++i;
        while (nums[j] > p) --j;
        if (i <= j)
          swap(nums[i++], nums[j--]);
      }
      quickSort(l, j);
      quickSort(i, r);
    };
    quickSort(0, nums.size() - 1);
    return nums;
  }
};

Solution 2: Counting Sort

Time complexity: O(n)
Space complexity: O(max(nums) – min(nums))

// Author: Huahua, 54 ms
class Solution {
public:
  vector<int> sortArray(vector<int>& nums) {
    auto [min_it, max_it] = minmax_element(begin(nums), end(nums));
    int l = *min_it, r = *max_it;
    vector<int> count(r - l + 1);
    for (int n : nums) ++count[n - l];
    int index = 0;
    for (int i = 0; i < count.size(); ++i)
      while (count[i]--) nums[index++] = i + l;
    return nums;
  }
};

Solution 2: HeapSort

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

// Author: Huahua, 72ms
class Solution {
public:
  vector<int> sortArray(vector<int>& nums) {
    priority_queue<int> q(begin(nums), end(nums));
    int i = nums.size();
    while (!q.empty()) {
      nums[--i] = q.top();
      q.pop();
    }
    return nums;
  }
};

// Author: Huahua
class Solution {
public:
  vector<int> sortArray(vector<int>& nums) {
    auto heapify = [&](int i, int e) {
      while (i <= e) {
        int l = 2 * i + 1;
        int r = 2 * i + 2;
        int j = i;
        if (l <= e && nums[l] > nums[j]) j = l;
        if (r <= e && nums[r] > nums[j]) j = r;
        if (j == i) break;
        swap(nums[i], nums[j]);
        swap(i, j);
      }
    };
    
    const int n = nums.size();
    
    // Init heap
    for (int i = n / 2; i >= 0; i--)
      heapify(i, n - 1);
    
    // Get min.
    for (int i = n - 1; i >= 1; i--) {
      swap(nums[0], nums[i]);
      heapify(0, i - 1);    
    }
    
    return nums;
  }
};

Solution 3: MergeSort

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

// Author: Huahua
class Solution {
public:
  vector<int> sortArray(vector<int>& nums) {
    vector<int> t(nums.size());
    function<void(int, int)> mergeSort = [&](int l, int r) {
      if (l + 1 >= r) return;
      int m = l + (r - l) / 2;
      mergeSort(l, m);
      mergeSort(m, r);
      int i1 = l;
      int i2 = m;
      int index = 0;
      while (i1 < m || i2 < r)
        if (i2 == r || (i1 < m && nums[i1] < nums[i2]))
          t[index++] = nums[i1++];
        else
          t[index++] = nums[i2++];      
      std::copy(begin(t), begin(t) + index, begin(nums) + l);
    };
    
    mergeSort(0, nums.size());
    return nums;
  }
};

Solution 4: BST

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

// Author: Huahua
class Solution {
public:
  vector<int> sortArray(vector<int>& nums) {
    multiset<int> s(begin(nums), end(nums));
    return {begin(s), end(s)};
  }
};

The post 花花酱 LeetCode 912. Sort an Array appeared first on Huahua's Tech Road.

The veganFriendly filter will be either true (meaning you should only include restaurants with veganFriendlyi set to true) or false (meaning you can include any restaurant). In addition, you have the filters maxPrice and maxDistance which are the maximum value for price and distance of restaurants you should consider respectively.

Return the array of restaurant IDs after filtering, ordered by rating from highest to lowest. For restaurants with the same rating, order them by id from highest to lowest. For simplicity veganFriendlyi and veganFriendly take value 1 when it is true, and 0 when it is false.

Example 1:

Input: restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]], veganFriendly = 1, maxPrice = 50, maxDistance = 10
Output: [3,1,5] 
Explanation: 
The restaurants are:
Restaurant 1 [id=1, rating=4, veganFriendly=1, price=40, distance=10]
Restaurant 2 [id=2, rating=8, veganFriendly=0, price=50, distance=5]
Restaurant 3 [id=3, rating=8, veganFriendly=1, price=30, distance=4]
Restaurant 4 [id=4, rating=10, veganFriendly=0, price=10, distance=3]
Restaurant 5 [id=5, rating=1, veganFriendly=1, price=15, distance=1] 
After filter restaurants with veganFriendly = 1, maxPrice = 50 and maxDistance = 10 we have restaurant 3, restaurant 1 and restaurant 5 (ordered by rating from highest to lowest). 

Example 2:

Input: restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]], veganFriendly = 0, maxPrice = 50, maxDistance = 10
Output: [4,3,2,1,5]
Explanation: The restaurants are the same as in example 1, but in this case the filter veganFriendly = 0, therefore all restaurants are considered.

Example 3:

Input: restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]], veganFriendly = 0, maxPrice = 30, maxDistance = 3
Output: [4,5]

Constraints:

• 1 <= restaurants.length <= 10^4
• restaurants[i].length == 5
• 1 <= idi, ratingi, pricei, distancei <= 10^5
• 1 <= maxPrice, maxDistance <= 10^5
• veganFriendlyi and veganFriendly are 0 or 1.
• All idi are distinct.

Solution

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

// Author: Huahua
class Solution {
public:
  vector<int> filterRestaurants(vector<vector<int>>& restaurants, int veganFriendly, int maxPrice, int maxDistance) {
    vector<pair<int, int>> rs; // <rating, id>
    for (auto& r : restaurants)
      if ((!veganFriendly || veganFriendly && r[2]) && r[3] <= maxPrice && r[4] <= maxDistance)
        rs.emplace_back(r[1], r[0]);
    
    sort(rbegin(rs), rend(rs));    
    vector<int> ans;
    for (const auto& r : rs) ans.push_back(r.second);
    return ans;
  }
};

The post 花花酱 LeetCode 1333. Filter Restaurants by Vegan-Friendly, Price and Distance appeared first on Huahua's Tech Road.

There is a one-dimensional garden on the x-axis. The garden starts at the point 0 and ends at the point n. (i.e The length of the garden is n).

There are n + 1 taps located at points [0, 1, ..., n] in the garden.

Given an integer n and an integer array ranges of length n + 1 where ranges[i] (0-indexed) means the i-th tap can water the area [i - ranges[i], i + ranges[i]] if it was open.

Return the minimum number of taps that should be open to water the whole garden, If the garden cannot be watered return -1.

Example 1:

Input: n = 5, ranges = [3,4,1,1,0,0]
Output: 1
Explanation: The tap at point 0 can cover the interval [-3,3]
The tap at point 1 can cover the interval [-3,5]
The tap at point 2 can cover the interval [1,3]
The tap at point 3 can cover the interval [2,4]
The tap at point 4 can cover the interval [4,4]
The tap at point 5 can cover the interval [5,5]
Opening Only the second tap will water the whole garden [0,5]

Example 2:

Input: n = 3, ranges = [0,0,0,0]
Output: -1
Explanation: Even if you activate all the four taps you cannot water the whole garden.

Example 3:

Input: n = 7, ranges = [1,2,1,0,2,1,0,1]
Output: 3

Example 4:

Input: n = 8, ranges = [4,0,0,0,0,0,0,0,4]
Output: 2

Example 5:

Input: n = 8, ranges = [4,0,0,0,4,0,0,0,4]
Output: 1

Constraints:

• 1 <= n <= 10^4
• ranges.length == n + 1
• 0 <= ranges[i] <= 100

Solution 1: Greedy

Reduce to 1024. Video Stitching

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

// Author: Huahua
class Solution {
public:
  int minTaps(int n, vector<int>& ranges) {
    vector<pair<int, int>> t;
    // O(n) reduction
    for (int i = 0; i <= n; ++i)
      t.emplace_back(max(0, i - ranges[i]), 
                     min(i + ranges[i], n));
    
    // 1024. Video Stiching
    sort(begin(t), end(t));
    int ans = 0;
    int i = 0;
    int l = 0;
    int e = 0;
    while (e < n) {
      // Extend to the right most w.r.t t[i].first <= l
      while (i <= n && t[i].first <= l)
        e = max(e, t[i++].second);
      if (l == e) return -1; // Can not extend
      l = e;
      ++ans;
    }
    return ans;
  }
};

Solution 2: Greedy

Reduce to 45. Jump Game II

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

// Author: Huahua
class Solution {
public:
  int minTaps(int n, vector<int>& ranges) {
    vector<int> nums(ranges.size());
    for (int i = 0; i <= n; ++i) {
      int s = max(0, i - ranges[i]);      
      nums[s] = max(nums[s], i + ranges[i]);
    }    
    // 45. Jump Game II
    int steps = 0;
    int l = 0;
    int e = 0;
    for (int i = 0; i <= n; ++i) {
      if (i > e) return -1;
      if (i > l) { ++steps; l = e; }
      e = max(e, nums[i]);
    }
    return steps;
  }
};

The post 花花酱 LeetCode 1326. Minimum Number of Taps to Open to Water a Garden appeared first on Huahua's Tech Road.

Return a list of two integers [A, B] where:

• A and B are No-Zero integers.
• A + B = n

It’s guarateed that there is at least one valid solution. If there are many valid solutions you can return any of them.

Example 1:

<strong>Input:</strong> n = 2
<strong>Output:</strong> [1,1]
<strong>Explanation:</strong> A = 1, B = 1. A + B = n and both A and B don't contain any 0 in their decimal representation.

Example 2:

<strong>Input:</strong> n = 11
<strong>Output:</strong> [2,9]

Example 3:

<strong>Input:</strong> n = 10000
<strong>Output:</strong> [1,9999]

Example 4:

<strong>Input:</strong> n = 69
<strong>Output:</strong> [1,68]

Example 5:

<strong>Input:</strong> n = 1010
<strong>Output:</strong> [11,999]

Constraints:

• 2 <= n <= 10^4

Solution: Brute Force

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

// Author: Huahua
class Solution {
public:
  vector<int> getNoZeroIntegers(int n) {
    auto valid = [](int x) {
      if (!x) return false;
      while (x) {
        if (x % 10 == 0) return false;
        x /= 10;
      }
      return true;
    };
    
    for (int i = 1; i <= n / 2; ++i)
      if (valid(i) && valid(n - i)) 
        return {i, n - i};
    return {};
  }
};

The post 花花酱 LeetCode 1317. Convert Integer to the Sum of Two No-Zero Integers appeared first on Huahua's Tech Road.

Return a list of pairs in ascending order(with respect to pairs), each pair [a, b] follows

• a, b are from arr
• a < b
• b - a equals to the minimum absolute difference of any two elements in arr

Example 1:

Input: arr = [4,2,1,3]
Output: [[1,2],[2,3],[3,4]]
Explanation: The minimum absolute difference is 1. List all pairs with difference equal to 1 in ascending order.

Example 2:

Input: arr = [1,3,6,10,15]
Output: [[1,3]]

Example 3:

Input: arr = [3,8,-10,23,19,-4,-14,27]
Output: [[-14,-10],[19,23],[23,27]]

Constraints:

• 2 <= arr.length <= 10^5
• -10^6 <= arr[i] <= 10^6

Solution: Sorting

The min abs difference could only happen between consecutive numbers in sorted form.

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

// Author: Huahua
class Solution {
public:
  vector<vector<int>> minimumAbsDifference(vector<int>& arr) {
    sort(begin(arr), end(arr));
    vector<vector<int>> ans;
    int best = INT_MAX;
    for (int i = 1; i < arr.size(); ++i) {
      int d = abs(arr[i] - arr[i - 1]);      
      if (d < best) {
        ans.clear();
        best = d;
      }
      if (d == best) ans.push_back({arr[i - 1], arr[i]});      
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1200. Minimum Absolute Difference appeared first on Huahua's Tech Road.

Problem

Assume you are an awesome parent and want to give your children some cookies. But, you should give each child at most one cookie. Each child i has a greed factor g_i, which is the minimum size of a cookie that the child will be content with; and each cookie j has a size s_j. If s_j >= g_i, we can assign the cookie j to the child i, and the child i will be content. Your goal is to maximize the number of your content children and output the maximum number.

Note:
You may assume the greed factor is always positive.
You cannot assign more than one cookie to one child.

Example 1:

Input: [1,2,3], [1,1]

Output: 1

Explanation: You have 3 children and 2 cookies. The greed factors of 3 children are 1, 2, 3. 
And even though you have 2 cookies, since their size is both 1, you could only make the child whose greed factor is 1 content.
You need to output 1.

Example 2:

Input: [1,2], [1,2,3]

Output: 2

Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2. 
You have 3 cookies and their sizes are big enough to gratify all of the children, 
You need to output 2.

Solution: Greedy + Two Pointers

Time complexity: O(mlogm + nlogn)

Space complexity: O(1)

// Author: Huahua
// Running time: 28 ms
class Solution {
public:
  int findContentChildren(vector<int>& g, vector<int>& s) {
    sort(begin(g), end(g));
    sort(begin(s), end(s));

    int ans = 0;
    int j = 0;
    for (int i = 0; i < g.size(); ++i) { 
      while (j < s.size() && s[j] < g[i]) {
        ++j;
      }
      if (j < s.size()) {
        ++ans;
        ++j;
        continue;
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 455. Assign Cookies appeared first on Huahua's Tech Road.