Posts published in “Array”

花花酱 LeetCode 75. Sort Colors

By zxi on October 1, 2019

Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

Note: You are not suppose to use the library’s sort function for this problem.

Example:

Input: [2,0,2,1,1,0]
Output: [0,0,1,1,2,2]

Follow up:

A rather straight forward solution is a two-pass algorithm using counting sort.
First, iterate the array counting number of 0’s, 1’s, and 2’s, then overwrite array with total number of 0’s, then 1’s and followed by 2’s.
Could you come up with a one-pass algorithm using only constant space?

Solution 1: Counting sort

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

C++

// Author: Huahua

class Solution {

public:

void sortColors(vector<int>& nums) {

vector<int> c(3);

for (int x : nums)

++c[x];

auto it = begin(nums);

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

while (c[i]--)

*it++ = i;

}

};

Solution 2: Two pointers

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

C++

// Author: Huahua

class Solution {

public:

void sortColors(vector<int>& nums) {

const int n = nums.size();

int l = 0;

int r = n - 1;

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

if (nums[i] == 0) {

swap(nums[i], nums[l++]);

} else if (nums[i] == 2 && i < r) {

swap(nums[i--], nums[r--]);

}

};

花花酱 LeetCode 80. Remove Duplicates from Sorted Array II

By zxi on September 30, 2019

Given a sorted array nums, remove the duplicates in-place such that duplicates appeared at most twice and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

Example 1:

Given nums = [1,1,1,2,2,3],

Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.

It doesn't matter what you leave beyond the returned length.

Example 2:

Given nums = [0,0,1,1,1,1,2,3,3],

Your function should return length = 7, with the first seven elements of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively.

It doesn't matter what values are set beyond the returned length.

Solution:

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

C++

// Author: Huahua

class Solution {

public:

int removeDuplicates(vector<int>& nums) {

const int n = nums.size();

if (n <= 2) return n;

int index = 1;

int len = 1;

int last = nums[0];

while (index < n) {

int count = 1;

while (index < n && nums[index] == last) {

++count;

++index;

}

if (count >= 2) nums[len++] = last;

if (index < n) {

last = nums[index++];

nums[len++] = last;

}

return len;

}

};

花花酱 LeetCode 1184. Distance Between Bus Stops

By zxi on September 7, 2019

A bus has n stops numbered from 0 to n - 1 that form a circle. We know the distance between all pairs of neighboring stops where distance[i] is the distance between the stops number i and (i + 1) % n.

The bus goes along both directions i.e. clockwise and counterclockwise.

Return the shortest distance between the given start and destination stops.

Example 1:

Input: distance = [1,2,3,4], start = 0, destination = 1
Output: 1
Explanation: Distance between 0 and 1 is 1 or 9, minimum is 1.

Example 2:

Input: distance = [1,2,3,4], start = 0, destination = 2
Output: 3
Explanation: Distance between 0 and 2 is 3 or 7, minimum is 3.

Example 3:

Input: distance = [1,2,3,4], start = 0, destination = 3
Output: 4
Explanation: Distance between 0 and 3 is 6 or 4, minimum is 4.

Constraints:

1 <= n <= 10^4
distance.length == n
0 <= start, destination < n
0 <= distance[i] <= 10^4

Solution: Summation

compute the total sum
compute the sum from s to d, c
ans = min(c, sum – c)

Time complexity: O(d-s)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int distanceBetweenBusStops(vector<int>& ds, int s, int d) {

if (s > d) swap(s, d);

int sum = accumulate(begin(ds), end(ds), 0);

int d1 = accumulate(begin(ds) + s, begin(ds) + d, 0);

return min(d1, sum - d1);

}

};

花花酱 LeetCode 1157. Online Majority Element In Subarray

By zxi on August 10, 2019

Implementing the class MajorityChecker, which has the following API:

MajorityChecker(int[] arr) constructs an instance of MajorityChecker with the given array arr;
int query(int left, int right, int threshold) has arguments such that:
- 0 <= left <= right < arr.length representing a subarray of arr;
- 2 * threshold > right - left + 1, ie. the threshold is always a strict majority of the length of the subarray

Each query(...) returns the element in arr[left], arr[left+1], ..., arr[right]that occurs at least threshold times, or -1 if no such element exists.

Example:

MajorityChecker majorityChecker = new MajorityChecker([1,1,2,2,1,1]);
majorityChecker.query(0,5,4); // returns 1
majorityChecker.query(0,3,3); // returns -1
majorityChecker.query(2,3,2); // returns 2

Constraints:

1 <= arr.length <= 20000
1 <= arr[i] <= 20000
For each query, 0 <= left <= right < len(arr)
For each query, 2 * threshold > right - left + 1
The number of queries is at most 10000

Solution 0: Brute Force TLE

For each range, find the majority element in O(n) time / O(n) or O(1) space.

Solution 1: Cache the range result

Cache the result for each range: mode and frequency

Time complexity:
init: O(1)
query: O(|right – left|)
total queries: O(sum(right_i – left_i)), right_i, left_i are bounds of unique ranges.
Space complexity:
init: O(1)
query: O(20000)

C++

// Author: Huahua, 568ms, 39.6 MB

class MajorityChecker {

public:

MajorityChecker(vector<int>& arr):nums(arr) {}

int query(int left, int right, int threshold) {

int key = left * 20000 + right;

if (!seen.count(key)) {

int c[20001] = {0};

int best = (right - left) / 2;

int best_num = -1;

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

if (++c[nums[i]] > best) {

best = c[nums[i]];

best_num = nums[i];

}

seen[key] = {best_num, best};

}

return seen[key].second >= threshold ? seen[key].first : -1;

}

private:

unordered_map<int, pair<int, int>> seen;

const vector<int>& nums;

};

Solution 2: HashTable + binary search

Preprocessing: use a hashtable to store the indices of each element. And sort by frequency of the element in descending order.
Query: iterator over (total_freq, num) pair, if freq >= threshold do a binary search to find the frequency of the given range for num in O(logn).

Time complexity:
Init: O(nlogn)
Query: worst case: O(nlogn), best case: O(logn)

C++

// Author: Huahua, 156 ms, 44.7MB

class MajorityChecker {

public:

MajorityChecker(vector<int>& arr):nums(arr) {

const int max_n = *max_element(begin(nums), end(nums));

m = vector<vector<int>>(max_n + 1);

for (int i = 0; i < nums.size(); ++i) m[nums[i]].push_back(i);

for (int n = 1; n <= max_n; ++n) {

if (m[n].size()) f.emplace_back(m[n].size(), n);

}

sort(rbegin(f), rend(f));

}

int query(int left, int right, int threshold) {

for (const auto& p : f) {

if (p.first < threshold) return -1;

int n = p.second;

const auto& idx = m[n];

int count = upper_bound(begin(idx), end(idx), right) - lower_bound(begin(idx), end(idx), left);

if (count >= threshold) return n;

}

return -1;

}

private:

const vector<int>& nums;

vector<vector<int>> m; // num -> {indices}

vector<pair<int, int>> f; // {freq, num}

};

Solution 2+: Randomization

Randomly pick a num in range [left, right] and check its freq, try k (e.g. 30) times. If a majority element exists, you should find it with error rate 1/2^k.

Time complexity:
Init: O(n)
Query: O(30 * logn)
Space complexity: O(n)

C++

// Author: Huahua, 240ms, 45.6MB

class MajorityChecker {

public:

MajorityChecker(vector<int>& arr):nums(arr) {

for (int i = 0; i < nums.size(); ++i) m[nums[i]].push_back(i);

}

int query(int left, int right, int threshold) {

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

int n = nums[rand() % (right - left + 1) + left];

const auto& idx = m[n];

int count = upper_bound(begin(idx), end(idx), right) - lower_bound(begin(idx), end(idx), left);

if (count >= threshold) return n;

}

return -1;

}

private:

unordered_map<int, vector<int>> m; // num -> {indices}

const vector<int>& nums;

};

花花酱 1054. Distant Barcodes

By zxi on May 28, 2019

In a warehouse, there is a row of barcodes, where the i-th barcode is barcodes[i].

Rearrange the barcodes so that no two adjacent barcodes are equal. You may return any answer, and it is guaranteed an answer exists.

Example 1:

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

Example 2:

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

Note:

1 <= barcodes.length <= 10000
1 <= barcodes[i] <= 10000

Soluton: Sorting

Sort the element by their frequency in descending order. Fill the most frequent element first in even positions, if reach the end of the array, start from position 1 then 3, 5, …

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

C++

// Author: Huahua, 216 ms, 18.2 MB

class Solution {

public:

vector<int> rearrangeBarcodes(vector<int>& barcodes) {

const int n = barcodes.size();

vector<int> f(10001);

for (int v : barcodes) ++f[v];

sort(begin(barcodes), end(barcodes), [&](const int a, const int b){

return f[a] == f[b] ? a > b : f[a] > f[b];

});

vector<int> ans(n);

int pos = 0;

for (int v : barcodes) {

ans[pos] = v;

if ((pos += 2) >= n) pos = 1;

}

return ans;

}

};

Solution 2: Find the most frequent

Actually, we only need to find the most frequent element and put in the even positions, then put the rest of the groups of elements in any order.

e.g. [1, 1, 2, 2, 2, 2, 2, 3, 4]
Can be
5*2 [2 – 2 – 2 – 2 – 2]
4*1 [2 4 2 – 2 – 2 – 2]
3*1 [2 4 2 3 2 – 2 – 2]
1*2 [ 2 3 2 3 2 1 2 1 2]

if we start with any other groups rather than 2, if will become:
[3 2 2 – 2 – 2 – 2 ] which is wrong…

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

C++

// Author: Huahua, 172 ms (99.89%), 18 MB (< 100%)

class Solution {

public:

vector<int> rearrangeBarcodes(vector<int>& barcodes) {

constexpr int kMaxV = 10001;

const int n = barcodes.size();

vector<int> f(kMaxV);

int max_f = 0;

int max_v = 0;

for (int v : barcodes)

if (++f[v] > max_f) {

max_f = f[v];

max_v = v;

}

vector<int> ans(n);

int pos = 0;

while (f[max_v]-- > 0) {

ans[pos] = max_v;

if ((pos += 2)>= n) pos = 1;

}

for (int v = 1; v < kMaxV; ++v) {

while (f[v]-- > 0) {

ans[pos] = v;

if ((pos += 2) >= n) pos = 1;

}

return ans;

}

};

Posts published in “Array”

花花酱 LeetCode 75. Sort Colors

Solution 1: Counting sort

C++

Solution 2: Two pointers

C++

花花酱 LeetCode 80. Remove Duplicates from Sorted Array II

Solution:

C++

Related Problems

花花酱 LeetCode 1184. Distance Between Bus Stops

C++

花花酱 LeetCode 1157. Online Majority Element In Subarray

Solution 0: Brute Force TLE

Solution 1: Cache the range result

C++

Solution 2: HashTable + binary search

C++

Solution 2+: Randomization

C++

花花酱 1054. Distant Barcodes

Soluton: Sorting

C++

Solution 2: Find the most frequent

C++