Return the minimum total distance between each house and its nearest mailbox.

The answer is guaranteed to fit in a 32-bit signed integer.

Example 1:

Input: houses = [1,4,8,10,20], k = 3
Output: 5
Explanation: Allocate mailboxes in position 3, 9 and 20.
Minimum total distance from each houses to nearest mailboxes is |3-1| + |4-3| + |9-8| + |10-9| + |20-20| = 5 

Example 2:

Input: houses = [2,3,5,12,18], k = 2
Output: 9
Explanation: Allocate mailboxes in position 3 and 14.
Minimum total distance from each houses to nearest mailboxes is |2-3| + |3-3| + |5-3| + |12-14| + |18-14| = 9.

Example 3:

Input: houses = [7,4,6,1], k = 1
Output: 8

Example 4:

Input: houses = [3,6,14,10], k = 4
Output: 0

Constraints:

• n == houses.length
• 1 <= n <= 100
• 1 <= houses[i] <= 10^4
• 1 <= k <= n
• Array houses contain unique integers.

Solution: DP

First, we need to sort the houses by their location.

This is a partitioning problem, e.g. optimal solution to partition first N houses into K groups. (allocating K mailboxes for the first N houses).

The key of this problem is to solve a base case, optimally allocating one mailbox for houses[i~j], The intuition is to put the mailbox in the middle location, this only works if there are only tow houses, or all the houses are evenly distributed. The correct location is the “median position” of a set of houses. For example, if the sorted locations are [1,2,3,100], the average will be 26 which costs 146 while the median is 2, and the cost becomes 100.

dp[i][k] := min cost to allocate k mailboxes houses[0~i].

base cases:

1. dp[i][1] = cost(0, i), min cost to allocate one mailbox.
2. dp[i][k] = 0 if k > i, more mailboxes than houses. // this is actually a pruning.

transition:

dp[i][k] = min(dp[p][k-1] + cost(p + 1, i)) 0 <= p < i,

allocate k-1 mailboxes for houses[0~p], and allocate one for houses[p+1~i]

ans:

dp[n-1][k]

Time complexity: O(n^3)
Space complexity: O(n^2) -> O(n)

// Author: Huahua
class Solution {
public:
  int minDistance(vector<int>& houses, int k) {
    constexpr int kInf = 1e9;
    const int n = houses.size();
    sort(begin(houses), end(houses));
    vector<vector<int>> dp(n + 1, vector<int>(n + 1, kInf));
    vector<vector<int>> costs(n + 1, vector<int>(n + 1, kInf));
    // min cost to allocate one mailbox for houses[i~j].
    auto cost = [&](int i, int j) {
      int& ans = costs[i][j];
      if (ans != kInf) return ans;
      const int m = i + (j - i) / 2;
      int box = 0;
      if ((j - i + 1) & 1) // odd number of houses.
        box = houses[m];
      else // even number of houses.
        box = (houses[m] + houses[m + 1]) / 2;
      ans = 0;
      for (int h = i; h <= j; ++h)
        ans += abs(houses[h] - box);
      return ans;
    };
    // min cost to allocate k mailboxes for houses[0~i].
    function<int(int, int)> solve = [&](int i, int k) {
      if (k > i) return 0; // more mailboxs than houses.
      if (k == 1) return cost(0, i);
      int& ans = dp[i][k];
      if (ans != kInf) return ans;
      for (int p = 0; p < i; ++p)
        ans = min(ans, solve(p, k - 1) + cost(p + 1, i));
      return ans;
    };
    return solve(n - 1, k);
  }
};

O(1) time to compute cost. O(n) Time and space for pre-processing.

// Author: Huahua
vector<int> sums(n + 1);
for (int i = 1; i <= n; ++i)
  sums[i] = sums[i - 1] + houses[i - 1];
// min cost to allocate one mailbox for houses[i~j].
auto cost = [&](int i, int j) {      
  const int m1 = (i + j) / 2;
  const int m2 = (i + j + 1) / 2;
  const int center = (houses[m1] + houses[m2]) / 2;
  return (m1 - i + 1) * center - (sums[m1 + 1] - sums[i])
       + (sums[j + 1] - sums[m2]) - (j - m2 + 1) * center;
};

The post 花花酱 LeetCode 1478. Allocate Mailboxes appeared first on Huahua's Tech Road.

Given an array A, partition it into two (contiguous) subarrays left and right so that:

• Every element in left is less than or equal to every element in right.
• left and right are non-empty.
• left has the smallest possible size.

Return the length of left after such a partitioning.  It is guaranteed that such a partitioning exists.

Example 1:

Input: [5,0,3,8,6]
Output: 3
Explanation: left = [5,0,3], right = [8,6]

Input: [1,1,1,0,6,12]
Output: 4
Explanation: left = [1,1,1,0], right = [6,12]

Note:

1. 2 <= A.length <= 30000
2. 0 <= A[i] <= 10^6
3. It is guaranteed there is at least one way to partition A as described.

Solution 1: BST

Time complexity: O(nlogn)

Space complexity: O(n)

// Author: Huahua, 100 ms
class Solution {
public:
  int partitionDisjoint(vector<int>& A) {
    multiset<int> s(begin(A) + 1, end(A));
    int left_max = A[0];
    for (int i = 1; i < A.size(); ++i) {      
      if (*begin(s) >= left_max) return i;
      s.erase(s.equal_range(A[i]).first);
      left_max = max(left_max, A[i]);      
    }
    return -1;
  }
};

Solution 2: Greedy

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua, 28 ms
class Solution {
public:
  int partitionDisjoint(vector<int>& A) {    
    int left_max = A[0];
    int cur_max = A[0];
    int left_len = 1;
    for (int i = 1; i < A.size(); ++i) {
      if (A[i] < left_max) {
        left_max = cur_max;
        left_len = i + 1;        
      } else {
        cur_max = max(cur_max, A[i]);
      }
    }
    return left_len;
  }
};

The post 花花酱 LeetCode 915. Partition Array into Disjoint Intervals appeared first on Huahua's Tech Road.