Array on Jiang Yi(姜祎)'s Homepage

78. Subsets

Tue, 21 May 2024 22:16:49 +0800

Given an array, find all subsets in the array

Intuition

Use DFS to iterate over all subsets and record them.

Approach

A subset can be represented as a binary number of n digits. Each digit is either 0 or 1. We can use DFS to iterate over all possible such format of binary numbers.

Complexity

Time complexity: iterate all binary numbers of length n once.
$$O(2^n)$$
Space complexity:
$$O(2^n)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
 void dfs(const vector<int>& nums, int index, vector<vector<int>>& result,
 vector<int>& s) {
 if (index == nums.size()) {
 result.push_back(s);
 return;
 }
 // digit is 1
 s.push_back(nums[index]);
 dfs(nums, index + 1, result, s);
 s.pop_back();
 // digit is 0
 dfs(nums, index + 1, result, s);
 }

 vector<vector<int>> subsets(vector<int>& nums) {
 vector<vector<int>> result;
 vector<int> s;
 dfs(nums, 0, result, s);
 return result;
 }
};

Reference

Leetcode

786. K-th Smallest Prime Fraction

Fri, 10 May 2024 22:39:54 +0800

Given an integer array of size $n$ containing prime integers, it can form $n(n-1)/2$ fractions, we are required to find the $k$-th smallest prime fraction.

Intuition

We can use a priority queue to store prime integers, then we maintain the priority queue.

Approach1: Brute force

Complexity

Time complexity: iterate the array once and maintain the priority queue.
$$O(n^2\log k)$$
Space complexity: the size of the priority queue
$$O(k)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
 class Compare {
 public:
 bool operator()(const vector<int>& a, const vector<int>& b){
 return 1.0 * a[0] / a[1] < 1.0 * b[0] / b[1]; // the root is the biggest
 }
 };
public:
 vector<int> kthSmallestPrimeFraction(vector<int>& arr, int k) {
 priority_queue<vector<int>, vector<vector<int>>, Compare> pq;
 int n = arr.size();
 for (int r = 1; r <= k + 1; ++r) {
 for (int i = 0; i < n; ++i) {
 if (i + r >= n) break;
 pq.push(vector<int>{arr[i], arr[i + r]});
 if (pq.size() > k) {
 pq.pop();
 }
 }
 }
 return pq.top();
 }
};

Approach2: Simplification

Notice that Approach1 requires iterating over all fractions, can we reduce the time complexity?

The solution is by considering the relative order, if we write a matrix whose element a[i][j]=nums[i]/nums[j] (i<j), then we know that a[i][i+1]>...>a[n-1][n] since the array nums are increasing. So, the smallest fraction are in a[1][2], ..., a[n-1][n]. If we take the smallest fraction, and add its successive elements (same column, last row), then we can find the second smallest fraction and so on. This solution requires iterating over $\max(n, k)$ fractions and $O(n)$ spaces.

Complexity

Time complexity: iterate $\max(n, k)$ elements and maintain the priority queue.
$$O(\max(n, k)\log n)$$
Space complexity: the size of the priority queue
$$O(n)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class Solution {
public:
 vector<int> kthSmallestPrimeFraction(vector<int>& A, int K) {
 // (fraction, (i, j))
 priority_queue<pair<double, pair<int, int>>> pq;
 for (int i = 0; i < A.size(); ++i) {
 pq.push({-1.0 * A[i] / A.back(), {i, A.size() - 1}});
 }
 while (--K) {
 auto t = pq.top().second;
 q.pop();
 --t.second;
 pq.push({-1.0 * A[t.first] / A[t.second], {t.first, t.second}});
 }
 return {A[pq.top().second.first], A[pq.top().second.second]};
 }
};

Reference

leetcode

3075. Maximize Happiness of Selected Children

Thu, 09 May 2024 20:21:07 +0800

Given an integer array representing the happiness of the children, select $k$ children such that the sum of their happiness is maximized.

Intuition

Since happiness of all rest children after choosing one child will decrease by 1, their relative order will still the same. So this problem is actually requiring us to select $k$ most happy children.

Approach

Use sorting.

Complexity

Time complexity: Sort the array.
$$O(n\log n)$$
Space complexity: No extra spaces are needed.
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Solution {
public:
 long long maximumHappinessSum(vector<int>& happiness, int k) {
 sort(happiness.begin(), happiness.end());
 int n = happiness.size();
 long long result = 0;
 for (int i = 0; i < k; ++i) {
 result += max(happiness[n - 1 - i] - i, 0);
 }
 return result;
 }
};

Reference

Leetcode

506. Relative Ranks

Wed, 08 May 2024 20:17:53 +0800

Given an array of scores, assign different ranks based on their position in the sorted array

Intuition

Sort the array and assign based on the sorted array.

Approach

in C++, we can use the property of the container map to solve this problem, the map is constructed so that the key is the score and the value is the index of the score.

Complexity

Time complexity: construct the map
$$O(n\log n)$$
Space complexity: store the scores and indexes
$$O(n)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class Solution {
public:
 vector<string> findRelativeRanks(vector<int>& score) {
 map<int, int> m;
 for (int i = 0; i < score.size(); ++i) {
 m[score[i]] = i;
 }
 vector<string> result(score.size());
 int index = 1;
 for (auto iter = m.rbegin(); iter != m.rend(); ++iter, ++index) {
 if (index == 1) result[iter->second] = "Gold Medal";
 else if (index == 2) result[iter->second] = "Silver Medal";
 else if (index == 3) result[iter->second] = "Bronze Medal";
 else result[iter->second] = to_string(index);
 }
 return result;
 }
};

Reference

leetcode 506

881. Boats to Save People

Sat, 04 May 2024 09:06:48 +0800

Given an array weight where weight[i] representing the weight of person i, now given the capacity of the boat and the constraint that each boat can carry at most two people, find the minimum number of boats to carry all people.

Intuition

Always pair the lightest person abd the heaviest person to a boat.

Approach

We first sort the array weight in ascending order. Then we use two pointers left=0 and right=n-1 to iterate through the array. In each step, there are two cases:

If weight[left]+weight[right] > limit, then we cannot find a peer who can take one boat with right, in this case, right occupies a single boat alone.
If weight[left]+weight[right] <= limit, then these two people can take one boat.

Complexity

Time complexity: sort the array and iterate the array once.
$$ O(n\log n) $$
Space complexity: no extra space needed.
$$ O(1) $$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Solution {
public:
 int numRescueBoats(vector<int>& people, int limit) {
 sort(people.begin(), people.end());
 int left = 0, right = people.size() - 1;
 int num = 0;
 while (left <= right){
 if (people[right] + people[left] <= limit)
 ++left;
 --right;
 ++num;
 }

 return num;
 }
};

References

Leetcode

2997. Minimum Number of Operations to Make Array XOR Equal to K

Mon, 29 Apr 2024 21:16:53 +0800

Given an integer array, we can flip one bit of one element of the array at every step, we asked to compute the minimum flips, such that the XOR of all elements of the array is equal to the given integer $k$.

Intuition

XOR of multiple bits is always equal to either 1 or 0, and changes one of the input bits will cause the result change to the other one.

Approach

We first compute the XOR of all elements of the array, then we compare bit by bit with the XOR result and the given k, utils all bits becomes the same.

Complexity

Time complexity: compute the XOR result
$$O(n)$$
Space complexity: No extra spaces are needed.
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Solution {
public:
 int minOperations(vector<int>& nums, int k) {
 int result = nums[0];
 for (int i = 1; i < nums.size(); ++i) {
 result ^= nums[i];
 }
 vector<int> bits_result, bits_k;
 while (k) {
 bits_k.push_back(k % 2);
 k /= 2;
 }
 while (result) {
 bits_result.push_back(result % 2);
 result /= 2;
 }
 int count = 0;
 int i = 0;
 for (; i < bits_result.size() && i < bits_k.size(); ++i) {
 if (bits_result[i] != bits_k[i])
 ++count;
 }
 for (; i < bits_result.size(); ++i) {
 if (bits_result[i] == 1)
 ++count;
 }
 for (; i < bits_k.size(); ++i) {
 if (bits_k[i] == 1)
 ++count;
 }
 return count;
 }
};