Posts tagged as “binary search”

花花酱 LeetCode 1508. Range Sum of Sorted Subarray Sums

By zxi on July 11, 2020

Given the array nums consisting of n positive integers. You computed the sum of all non-empty continous subarrays from the array and then sort them in non-decreasing order, creating a new array of n * (n + 1) / 2 numbers.

Return the sum of the numbers from index left to index right (indexed from 1), inclusive, in the new array. Since the answer can be a huge number return it modulo 10^9 + 7.

Example 1:

Input: nums = [1,2,3,4], n = 4, left = 1, right = 5
Output: 13 
Explanation: All subarray sums are 1, 3, 6, 10, 2, 5, 9, 3, 7, 4. After sorting them in non-decreasing order we have the new array [1, 2, 3, 3, 4, 5, 6, 7, 9, 10]. The sum of the numbers from index le = 1 to ri = 5 is 1 + 2 + 3 + 3 + 4 = 13.

Example 2:

Input: nums = [1,2,3,4], n = 4, left = 3, right = 4
Output: 6
Explanation: The given array is the same as example 1. We have the new array [1, 2, 3, 3, 4, 5, 6, 7, 9, 10]. The sum of the numbers from index le = 3 to ri = 4 is 3 + 3 = 6.

Example 3:

Input: nums = [1,2,3,4], n = 4, left = 1, right = 10
Output: 50

Constraints:

1 <= nums.length <= 10^3
nums.length == n
1 <= nums[i] <= 100
1 <= left <= right <= n * (n + 1) / 2

Solution 1: Brute Force

Find sums of all the subarrays and sort the values.

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

C++

// Author: Huahua

class Solution {

public:

int rangeSum(vector<int>& nums, int n, int left, int right) {

constexpr int kMod = 1e9 + 7;

vector<int> sums;

for (int i = 0; i < n; ++i)

for (int j = i, sum = 0; j < n; ++j)

sums.push_back(sum += nums[j]);

sort(begin(sums), end(sums));

return accumulate(begin(sums) + left - 1, begin(sums) + right, 0LL) % kMod;

}

};

Java

// Author: Huahua

class Solution {

public int rangeSum(int[] nums, int n, int left, int right) {

final int kMod = (int)(1e9 + 7);

int[] sums = new int[n * (n + 1) / 2];

int idx = 0;

for (int i = 0; i < n; ++i)

for (int j = i, sum = 0; j < n; ++j, ++idx)

sums[idx] = sum += nums[j];

Arrays.sort(sums);

int ans = 0;

for (int i = left; i <= right; ++i)

ans = (ans + sums[i - 1]) % kMod;

return ans;

}

Python3

# Author: Huahua

class Solution:

def rangeSum(self, nums: List[int], n: int, left: int, right: int) -> int:

sums = []

for i in range(n):

s = 0

for j in range(i, n):

s += nums[j]

sums.append(s)

sums.sort()

return sum(sums[left - 1:right])

Solution 2: Priority Queue / Min Heap

For each subarray, start with one element e.g nums[i], put them into a priority queue (min heap). Each time, we have the smallest subarray sum, and extend that subarray and put the new sum back into priority queue. Thought it has the same time complexity as the brute force one in worst case, but space complexity can be reduce to O(n).

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

C++

struct Entry {

int sum;

int i;

bool operator<(const Entry& e) const { return sum > e.sum; }

};

class Solution {

public:

int rangeSum(vector<int>& nums, int n, int left, int right) {

constexpr int kMod = 1e9 + 7;

priority_queue<Entry> q; // Sort by e.sum in descending order.

for (int i = 0; i < n; ++i)

q.push({nums[i], i});

long ans = 0;

for (int j = 1; j <= right; ++j) {

const auto e = std::move(q.top()); q.pop();

if (j >= left) ans += e.sum;

if (e.i + 1 < n) q.push({e.sum + nums[e.i + 1], e.i + 1});

}

return ans % kMod;

}

};

Java

import java.util.AbstractMap;

class Solution {

public int rangeSum(int[] nums, int n, int left, int right) {

final int kMod = (int)(1e9 + 7);

var q = new PriorityQueue<Map.Entry<Integer, Integer>>((a, b) -> a.getKey() - b.getKey());

for (int i = 0; i < n; ++i)

q.offer(new AbstractMap.SimpleEntry<>(nums[i], i));

int ans = 0;

for (int k = 1; k <= right; ++k) {

var e = q.poll();

int sum = e.getKey();

int i = e.getValue();

if (k >= left)

ans = (ans + sum) % kMod;

if (i + 1 < n)

q.offer(new AbstractMap.SimpleEntry<>(sum + nums[i + 1], i + 1));

}

return ans;

}

Python3

# Author: Huahua

class Solution:

def rangeSum(self, nums: List[int], n: int, left: int, right: int) -> int:

q = [(num, i) for i, num in enumerate(nums)]

heapq.heapify(q)

ans = 0

for k in range(1, right + 1):

s, i = heapq.heappop(q)

if k >= left:

ans += s

if i + 1 < n:

heapq.heappush(q, (s + nums[i + 1], i + 1))

return ans % int(1e9 + 7)

Solution 3: Binary Search + Sliding Window

Use binary search to find S s.t. that there are at least k subarrys have sum <= S.

Given S, we can use sliding window to count how many subarrays have sum <= S and their total sum.

ans = sums_of_first(right) – sums_of_first(left – 1).

Time complexity: O(n * log(sum(nums))
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

int rangeSum(vector<int>& nums, int n, int left, int right) {

constexpr int kMod = 1e9 + 7;

// Returns number of subarrays that have

// sum <= target and their total sum.

auto countAndSum = [&](int target) -> pair<int, long> {

int count = 0;

long cur = 0;

long sum = 0;

long total_sum = 0;

for (long j = 0, i = 0; j < n; ++j) {

cur += nums[j];

sum += nums[j] * (j - i + 1);

while (cur > target) {

sum -= cur;

cur -= nums[i++];

}

count += j - i + 1;

total_sum += sum;

}

return {count, total_sum};

};

// Returns the total sums of smallest k subarrays.

// Use binary search to find the smallest sum l s.t.

// there are at least k of subarrays have sums <= l.

const int min_sum = *min_element(begin(nums), end(nums));

const int max_sum = accumulate(begin(nums), end(nums), 0) + 1;

auto sumOfFirstK = [&](int k) -> long {

int l = min_sum;

int r = max_sum;

while (l < r) {

int mid = l + (r - l) / 2;

if (countAndSum(mid).first >= k)

r = mid;

else

l = mid + 1;

}

const auto [count, sum] = countAndSum(l);

// There can be more subarrays have the same sum of l.

return sum - l * (count - k);

};

return (sumOfFirstK(right) - sumOfFirstK(left - 1)) % kMod;

}

};

花花酱 LeetCode 1488. Avoid Flood in The City

By zxi on June 20, 2020

Your country has an infinite number of lakes. Initially, all the lakes are empty, but when it rains over the nth lake, the nth lake becomes full of water. If it rains over a lake which is full of water, there will be a flood. Your goal is to avoid the flood in any lake.

Given an integer array rains where:

rains[i] > 0 means there will be rains over the rains[i] lake.
rains[i] == 0 means there are no rains this day and you can choose one lake this day and dry it.

Return an array ans where:

ans.length == rains.length
ans[i] == -1 if rains[i] > 0.
ans[i] is the lake you choose to dry in the ith day if rains[i] == 0.

If there are multiple valid answers return any of them. If it is impossible to avoid flood return an empty array.

Notice that if you chose to dry a full lake, it becomes empty, but if you chose to dry an empty lake, nothing changes. (see example 4)

Example 1:

Input: rains = [1,2,3,4]
Output: [-1,-1,-1,-1]
Explanation: After the first day full lakes are [1]
After the second day full lakes are [1,2]
After the third day full lakes are [1,2,3]
After the fourth day full lakes are [1,2,3,4]
There's no day to dry any lake and there is no flood in any lake.

Example 2:

Input: rains = [1,2,0,0,2,1]
Output: [-1,-1,2,1,-1,-1]
Explanation: After the first day full lakes are [1]
After the second day full lakes are [1,2]
After the third day, we dry lake 2. Full lakes are [1]
After the fourth day, we dry lake 1. There is no full lakes.
After the fifth day, full lakes are [2].
After the sixth day, full lakes are [1,2].
It is easy that this scenario is flood-free. [-1,-1,1,2,-1,-1] is another acceptable scenario.

Example 3:

Input: rains = [1,2,0,1,2]
Output: []
Explanation: After the second day, full lakes are  [1,2]. We have to dry one lake in the third day.
After that, it will rain over lakes [1,2]. It's easy to prove that no matter which lake you choose to dry in the 3rd day, the other one will flood.

Example 4:

Input: rains = [69,0,0,0,69]
Output: [-1,69,1,1,-1]
Explanation: Any solution on one of the forms [-1,69,x,y,-1], [-1,x,69,y,-1] or [-1,x,y,69,-1] is acceptable where 1 <= x,y <= 10^9

Example 5:

Input: rains = [10,20,20]
Output: []
Explanation: It will rain over lake 20 two consecutive days. There is no chance to dry any lake.

Constraints:

1 <= rains.length <= 10^5
0 <= rains[i] <= 10^9

Solution: Binary Search

Store the days we can dry a lake in a treeset.
Store the last day when a lake becomes full in a hashtable.
Whenever we encounter a full lake, try to find the first available day that we can dry it. If no such day, return no answer.

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

C++

// Author: Huahua

class Solution {

public:

vector<int> avoidFlood(vector<int>& rains) {

const int n = rains.size();

vector<int> ans(n, -1);

unordered_map<int, int> full; // lake -> day

set<int> dry; // days we can dry lakes.

for (int i = 0; i < n; ++i) {

const int lake = rains[i];

if (lake > 0) {

if (full.count(lake)) {

// Find the first day we can dry it.

auto it = dry.upper_bound(full[lake]);

if (it == end(dry)) return {};

ans[*it] = lake;

dry.erase(it);

}

full[lake] = i;

} else {

dry.insert(i);

ans[i] = 1;

}

return ans;

}

};

花花酱 LeetCode 1482. Minimum Number of Days to Make m Bouquets

By zxi on June 14, 2020

Given an integer array bloomDay, an integer m and an integer k.

We need to make m bouquets. To make a bouquet, you need to use k adjacent flowers from the garden.

The garden consists of n flowers, the ith flower will bloom in the bloomDay[i] and then can be used in exactly one bouquet.

Return the minimum number of days you need to wait to be able to make m bouquets from the garden. If it is impossible to make m bouquets return -1.

Example 1:

Input: bloomDay = [1,10,3,10,2], m = 3, k = 1
Output: 3
Explanation: Let's see what happened in the first three days. x means flower bloomed and _ means flower didn't bloom in the garden.
We need 3 bouquets each should contain 1 flower.
After day 1: [x, _, _, _, _]   // we can only make one bouquet.
After day 2: [x, _, _, _, x]   // we can only make two bouquets.
After day 3: [x, _, x, _, x]   // we can make 3 bouquets. The answer is 3.

Example 2:

Input: bloomDay = [1,10,3,10,2], m = 3, k = 2
Output: -1
Explanation: We need 3 bouquets each has 2 flowers, that means we need 6 flowers. We only have 5 flowers so it is impossible to get the needed bouquets and we return -1.

Example 3:

Input: bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3
Output: 12
Explanation: We need 2 bouquets each should have 3 flowers.
Here's the garden after the 7 and 12 days:
After day 7: [x, x, x, x, _, x, x]
We can make one bouquet of the first three flowers that bloomed. We cannot make another bouquet from the last three flowers that bloomed because they are not adjacent.
After day 12: [x, x, x, x, x, x, x]
It is obvious that we can make two bouquets in different ways.

Example 4:

Input: bloomDay = [1000000000,1000000000], m = 1, k = 1
Output: 1000000000
Explanation: You need to wait 1000000000 days to have a flower ready for a bouquet.

Example 5:

Input: bloomDay = [1,10,2,9,3,8,4,7,5,6], m = 4, k = 2
Output: 9

Constraints:

bloomDay.length == n
1 <= n <= 10^5
1 <= bloomDay[i] <= 10^9
1 <= m <= 10^6
1 <= k <= n

Solution: Binary Search

Find the smallest day D that we can make at least m bouquets using binary search.

at a given day, we can check how many bouquets we can make in O(n)

Time complexity: O(nlog(max(days))
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int minDays(vector<int>& bloomDay, int m, int k) {

const auto [lo, hi] = minmax_element(begin(bloomDay), end(bloomDay));

const int kInf = *hi + 1;

int l = *lo;

int r = kInf;

// Return the number of bouquets we can get at day D.

auto getBouquets = [&](int D) {

int ans = 0;

int cur = 0;

for (int d : bloomDay) {

if (d > D) {

cur = 0;

} else if (++cur == k) {

++ans;

cur = 0;

}

return ans;

};

while (l < r) {

int mid = l + (r - l) / 2;

// Find smallest day that bouquets >= m.

if (getBouquets(mid) >= m)

r = mid;

else

l = mid + 1;

}

return l >= kInf ? -1 : l;

}

};

花花酱 LeetCode 1385. Find the Distance Value Between Two Arrays

By zxi on March 21, 2020

Given two integer arrays arr1 and arr2, and the integer d, return the distance value between the two arrays.

The distance value is defined as the number of elements arr1[i] such that there is not any element arr2[j] where |arr1[i]-arr2[j]| <= d.

Example 1:

Input: arr1 = [4,5,8], arr2 = [10,9,1,8], d = 2
Output: 2
Explanation: 
For arr1[0]=4 we have: 
|4-10|=6 > d=2 
|4-9|=5 > d=2 
|4-1|=3 > d=2 
|4-8|=4 > d=2 
For arr1[1]=5 we have: 
|5-10|=5 > d=2 
|5-9|=4 > d=2 
|5-1|=4 > d=2 
|5-8|=3 > d=2
For arr1[2]=8 we have:
|8-10|=2 <= d=2
|8-9|=1 <= d=2
|8-1|=7 > d=2
|8-8|=0 <= d=2

Example 2:

Input: arr1 = [1,4,2,3], arr2 = [-4,-3,6,10,20,30], d = 3
Output: 2

Example 3:

Input: arr1 = [2,1,100,3], arr2 = [-5,-2,10,-3,7], d = 6
Output: 1

Constraints:

1 <= arr1.length, arr2.length <= 500
-10^3 <= arr1[i], arr2[j] <= 10^3
0 <= d <= 100

Solution 1: All pairs

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

C++

// Author: Huahua

class Solution {

public:

int findTheDistanceValue(vector<int>& arr1, vector<int>& arr2, int d) {

int ans = 0;

for (int x : arr1) {

bool flag = true;

for (int y : arr2)

if (abs(x - y) <= d) {

flag = false;

break;

}

ans += flag;

}

return ans;

}

};

Python3

# Author: Huahua

class Solution:

def findTheDistanceValue(self, arr1: List[int], arr2: List[int], d: int) -> int:

return sum(all(abs(x - y) > d for y in arr2) for x in arr1)

Solution 2: Two Pointers

Sort arr1 in ascending order and sort arr2 in descending order.
Time complexity: O(mlogm + nlogn + m + n)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int findTheDistanceValue(vector<int>& arr1, vector<int>& arr2, int d) {

sort(begin(arr1), end(arr1));

sort(rbegin(arr2), rend(arr2));

int ans = 0;

for (int a : arr1) {

while (arr2.size() && arr2.back() < a - d)

arr2.pop_back();

ans += arr2.empty() || arr2.back() > a + d;

}

return ans;

}

};

Solution 3: Binary Search

Sort arr2 in ascending order. and do two binary searches for each element to determine the range of [a-d, a+d], if that range is empty we increase the counter

Time complexity: O(mlogm + nlogm)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int findTheDistanceValue(vector<int>& arr1, vector<int>& arr2, int d) {

sort(begin(arr2), end(arr2));

int ans = 0;

for (int a : arr1) {

auto it1 = lower_bound(begin(arr2), end(arr2), a - d);

auto it2 = upper_bound(begin(arr2), end(arr2), a + d);

if (it1 == it2) ++ans;

}

return ans;

}

};

花花酱 LeetCode 240. Search a 2D Matrix II

By zxi on March 13, 2020

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

Integers in each row are sorted in ascending from left to right.
Integers in each column are sorted in ascending from top to bottom.

Example:

Consider the following matrix:

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]

Given target = 5, return true.

Solution 1: Two Pointers

Start from first row + last column, if the current value is larger than target, –column; if smaller then ++row.

e.g.
1. r = 0, c = 4, v = 15, 15 > 5 => –c
2. r = 0, c = 3, v = 11, 11 > 5 => –c
3. r = 0, c = 2, v = 7, 7 > 5 => –c
4. r = 0, c = 1, v = 4, 4 < 5 => ++r
5. r = 1, c = 1, v = 5, 5 = 5, found it!

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

C++

// Author: Huahua

class Solution {

public:

bool searchMatrix(vector<vector<int>>& matrix, int target) {

if (matrix.empty() || matrix[0].empty()) return false;

const int m = matrix.size();

const int n = matrix[0].size();

int r = 0;

int c = matrix[0].size() - 1;

while (r < m && c >= 0) {

if (matrix[r][c] == target) return true;

else if (matrix[r][c] > target) --c;

else ++r;

}

return false;

}

};