Posts tagged as “binary search”

花花酱 LeetCode 74. Search a 2D Matrix

By zxi on February 13, 2019

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 from left to right.
The first integer of each row is greater than the last integer of the previous row.

Example 1:

Input:

matrix = [

[1, 3, 5, 7],

[10, 11, 16, 20],

[23, 30, 34, 50]

]

target = 3

Output: true

Example 2:

Input:

matrix = [

[1, 3, 5, 7],

[10, 11, 16, 20],

[23, 30, 34, 50]

]

target = 13

Output: false

Solution: Binary Search

Treat the 2D array as a 1D array. matrix[index / cols][index % cols]

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

C++

class Solution {

public:

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

if (matrix.empty()) return false;

int l = 0;

int r = matrix.size() * matrix[0].size();

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

while (l < r) {

const int m = l + (r - l) / 2;

if (matrix[m / cols][m % cols] == target) {

return true;

} else if (matrix[m / cols][m % cols] > target) {

r = m;

} else {

l = m + 1;

}

return false;

}

};

花花酱 LeetCode 981. Time Based Key-Value Store

By zxi on January 26, 2019

Create a timebased key-value store class TimeMap, that supports two operations.

1. set(string key, string value, int timestamp)

Stores the key and value, along with the given timestamp.

2. get(string key, int timestamp)

Returns a value such that set(key, value, timestamp_prev) was called previously, with timestamp_prev <= timestamp.
If there are multiple such values, it returns the one with the largest timestamp_prev.
If there are no values, it returns the empty string ("").

Example 1:

Input: inputs = ["TimeMap","set","get","get","set","get","get"], inputs = [[],["foo","bar",1],["foo",1],["foo",3],["foo","bar2",4],["foo",4],["foo",5]]
Output: [null,null,"bar","bar",null,"bar2","bar2"]
Explanation:   
TimeMap kv;   
kv.set("foo", "bar", 1); // store the key "foo" and value "bar" along with timestamp = 1   
kv.get("foo", 1);  // output "bar"   
kv.get("foo", 3); // output "bar" since there is no value corresponding to foo at timestamp 3 and timestamp 2, then the only value is at timestamp 1 ie "bar"   
kv.set("foo", "bar2", 4);   
kv.get("foo", 4); // output "bar2"   
kv.get("foo", 5); //output "bar2"

Example 2:

Input: inputs = ["TimeMap","set","set","get","get","get","get","get"], inputs = [[],["love","high",10],["love","low",20],["love",5],["love",10],["love",15],["love",20],["love",25]]
Output: [null,null,null,"","high","high","low","low"]

Note:

All key/value strings are lowercase.
All key/value strings have length in the range [1, 100]
The timestamps for all TimeMap.set operations are strictly increasing.
1 <= timestamp <= 10^7
TimeMap.set and TimeMap.get functions will be called a total of 120000 times (combined) per test case.

Solution: HashTable + Map

C++

// Author: Huahua, running time: 200 ms

class TimeMap {

public:

/** Initialize your data structure here. */

TimeMap() {}

void set(string key, string value, int timestamp) {

s_[key].emplace(timestamp, std::move(value));

}

string get(string key, int timestamp) {

auto m = s_.find(key);

if (m == s_.end()) return "";

auto it = m->second.upper_bound(timestamp);

if (it == begin(m->second)) return "";

return prev(it)->second;

}

private:

unordered_map<string, map<int, string>> s_;

};

花花酱 LeetCode 975. Odd Even Jump

By zxi on January 15, 2019

You are given an integer array A. From some starting index, you can make a series of jumps. The (1st, 3rd, 5th, …) jumps in the series are called odd numbered jumps, and the (2nd, 4th, 6th, …) jumps in the series are called even numbered jumps.

You may from index i jump forward to index j (with i < j) in the following way:

During odd numbered jumps (ie. jumps 1, 3, 5, …), you jump to the index j such that A[i] <= A[j] and A[j] is the smallest possible value. If there are multiple such indexes j, you can only jump to the smallest such index j.
During even numbered jumps (ie. jumps 2, 4, 6, …), you jump to the index j such that A[i] >= A[j] and A[j] is the largest possible value. If there are multiple such indexes j, you can only jump to the smallest such index j.
(It may be the case that for some index i, there are no legal jumps.)

A starting index is good if, starting from that index, you can reach the end of the array (index A.length - 1) by jumping some number of times (possibly 0 or more than once.)

Return the number of good starting indexes.

Example 1:

Input: [10,13,12,14,15] 
Output: 2

Example 2:

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

Example 3:

Input: [5,1,3,4,2] 
Output: 3

Note:

1 <= A.length <= 20000
0 <= A[i] < 100000

Solution: Binary Search + DP

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

C++

class Solution {

public:

int oddEvenJumps(vector<int>& A) {

const int n = A.size();

map<int, int> m;

vector<vector<int>> dp(n + 1, vector<int>(2));

dp[n - 1][0] = dp[n - 1][1] = 1;

m[A[n - 1]] = n - 1;

int ans = 1;

for (int i = n - 2; i >= 0; --i) {

auto o = m.lower_bound(A[i]);

if (o != m.end()) dp[i][0] = dp[o->second][1];

auto e = m.upper_bound(A[i]);

if (e != m.begin()) dp[i][1] = dp[prev(e)->second][0];

if (dp[i][0]) ++ans;

m[A[i]] = i;

}

return ans;

}

};

花花酱 LeetCode 962. Maximum Width Ramp

By zxi on December 25, 2018

Given an array A of integers, a ramp is a tuple (i, j) for which i < j and A[i] <= A[j]. The width of such a ramp is j - i.

Find the maximum width of a ramp in A. If one doesn’t exist, return 0.

Example 1:

Input: [6,0,8,2,1,5] 
Output: 4 
Explanation:  The maximum width ramp is achieved at (i, j) = (1, 5): A[1] = 0 and A[5] = 5.

Example 2:

Input: [9,8,1,0,1,9,4,0,4,1] 
Output: 7 
Explanation:  The maximum width ramp is achieved at (i, j) = (2, 9): A[2] = 1 and A[9] = 1.

Note:

2 <= A.length <= 50000
0 <= A[i] <= 50000

Solution: Stack

Using a stack to store start candidates’ (decreasing order) index
Scan from right to left, compare the current number with the one on the top of the stack, pop if greater.

e.g.
A = [6,0,8,2,1,5]
stack = [0, 1] => [6, 0]
cur: A[5] = 5, stack.top = A[1] = 0, ramp = 5, stack.pop()
cur: A[4] = 1, stack.top = A[0] = 6
cur: A[3] = 2, stack.top = A[0] = 6
cur: A[2] = 8, stack.top = A[0] = 6, ramp = 2, stack.pop()
stack.isEmpty() => END

C++

// Author: Huahua, running time: 44 ms

class Solution {

public:

int maxWidthRamp(vector<int>& A) {

stack<int> s;

for (int i = 0; i < A.size(); ++i)

if (s.empty() || A[i] < A[s.top()])

s.push(i);

int ans = 0;

for (int i = A.size() - 1; i >= 0; --i)

while (!s.empty() && A[i] >= A[s.top()]) {

ans = max(ans, i - s.top());

s.pop();

}

return ans;

}

};

Python3

# Author: Huahua, running time: 92 ms

class Solution:

def maxWidthRamp(self, A):

s = []

for i in range(len(A)):

if not s or A[i] < A[s[-1]]: s.append(i)

ans = 0

for i in range(len(A) - 1, -1, -1):

while s and A[i] >= A[s[-1]]:

ans = max(ans, i - s.pop())

return ans

花花酱 LeetCode 18. 4Sum

By zxi on September 19, 2018

Problem

Given an array nums of n integers and an integer target, are there elements a, b, c, and d in nums such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.

Note:

The solution set must not contain duplicate quadruplets.

Example:

Given array nums = [1, 0, -1, 0, -2, 2], and target = 0.

A solution set is:
[
  [-1,  0, 0, 1],
  [-2, -1, 1, 2],
  [-2,  0, 0, 2]
]

Solution 1: Sorting + Binary Search

Time complexity: O(n^3 log n + klogk)

Space complexity: O(k)

C++

// Author: Huahua

class Solution {

public:

vector<vector<int>> fourSum(vector<int> &num, int target) {

set<vector<int>> h;

sort(num.begin(), num.end());

int n = num.size();

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

for (int j = i + 1; j < n; j++) {

for(int k = j + 1; k < n; k++) {

int t = target - num[i] - num[j] - num[k];

if (t < num[k]) break;

if (!std::binary_search(num.begin() + k + 1, num.end(), t)) continue;

h.insert({num[i], num[j], num[k], t});

}

return vector<vector<int>>(begin(h), end(h));

}

};

C++ opt

// Author: Huahua

class Solution {

public:

vector<vector<int>> fourSum(vector<int> &num, int target) {

sort(num.begin(), num.end());

if (target > 0 && target > 4 * num.back()) return {};

if (target < 0 && target < 4 * num.front()) return {};

set<vector<int>> h;

int n = num.size();

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

for (int j = i + 1; j < n; j++) {

for(int k = j + 1; k < n; k++) {

int t = target - num[i] - num[j] - num[k];

if (t < num[k]) break;

if (!std::binary_search(num.begin() + k + 1, num.end(), t)) continue;

h.insert({num[i], num[j], num[k], t});

}

return vector<vector<int>>(begin(h), end(h));

}

};

Solution 2: Sorting + HashTable

Time complexity: O(n^3 + klogk)

Space complexity: O(n + k)

C++

// Author: Huahua

class Solution {

public:

vector<vector<int>> fourSum(vector<int> &num, int target) {

sort(num.begin(), num.end());

if (target > 0 && target > 4 * num.back()) return {};

if (target < 0 && target < 4 * num.front()) return {};

unordered_map<int, int> index;

for (int i = 0; i < num.size(); ++i)

index[num[i]] = i;

set<vector<int>> h;

int n = num.size();

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

for (int j = i + 1; j < n; j++) {

for(int k = j + 1; k < n; k++) {

int t = target - num[i] - num[j] - num[k];

if (t < num[k]) break;

auto it = index.find(t);

if (it == index.end() || it->second <= k) continue;

h.insert({num[i], num[j], num[k], t});

}

return vector<vector<int>>(begin(h), end(h));

}

};

Posts tagged as “binary search”

花花酱 LeetCode 74. Search a 2D Matrix

Solution: Binary Search

C++

花花酱 LeetCode 981. Time Based Key-Value Store

Solution: HashTable + Map

C++

花花酱 LeetCode 975. Odd Even Jump

Solution: Binary Search + DP

C++

花花酱 LeetCode 962. Maximum Width Ramp

Solution: Stack

C++

Python3

花花酱 LeetCode 18. 4Sum

Problem

Solution 1: Sorting + Binary Search

C++

C++ opt

Solution 2: Sorting + HashTable

C++

Related Problems