Posts tagged as “math”

花花酱 LeetCode 1823. Find the Winner of the Circular Game

By zxi on April 12, 2021

There are n friends that are playing a game. The friends are sitting in a circle and are numbered from 1 to n in clockwise order. More formally, moving clockwise from the i^th friend brings you to the (i+1)^th friend for 1 <= i < n, and moving clockwise from the n^th friend brings you to the 1^st friend.

The rules of the game are as follows:

Start at the 1^st friend.
Count the next k friends in the clockwise direction including the friend you started at. The counting wraps around the circle and may count some friends more than once.
The last friend you counted leaves the circle and loses the game.
If there is still more than one friend in the circle, go back to step 2 starting from the friend immediately clockwise of the friend who just lost and repeat.
Else, the last friend in the circle wins the game.

Given the number of friends, n, and an integer k, return the winner of the game.

Example 1:

Input: n = 5, k = 2
Output: 3
Explanation: Here are the steps of the game:
1) Start at friend 1.
2) Count 2 friends clockwise, which are friends 1 and 2.
3) Friend 2 leaves the circle. Next start is friend 3.
4) Count 2 friends clockwise, which are friends 3 and 4.
5) Friend 4 leaves the circle. Next start is friend 5.
6) Count 2 friends clockwise, which are friends 5 and 1.
7) Friend 1 leaves the circle. Next start is friend 3.
8) Count 2 friends clockwise, which are friends 3 and 5.
9) Friend 5 leaves the circle. Only friend 3 is left, so they are the winner.

Example 2:

Input: n = 6, k = 5
Output: 1
Explanation: The friends leave in this order: 5, 4, 6, 2, 3. The winner is friend 1.

Constraints:

1 <= k <= n <= 500

Solution 1: Simulation w/ Queue / List

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

C++/Queue

// Author: Huahua, 56 ms, 24.3 MB

class Solution {

public:

int findTheWinner(int n, int k) {

queue<int> q;

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

q.push(i);

while (q.size() != 1) {

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

int x = q.front();

q.pop();

q.push(x);

}

q.pop();

}

return q.front();

}

};

C++/List

// Author: Huahua, 12 ms, 6.8 MB

class Solution {

public:

int findTheWinner(int n, int k) {

list<int> l;

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

l.push_back(i);

auto it = l.begin();

while (l.size() != 1) {

for (int i = 1; i < k; ++i)

if (++it == l.end())

it = l.begin();

it = l.erase(it);

if (it == l.end())

it = l.begin();

}

return l.front();

}

};

花花酱 LeetCode 1822. Sign of the Product of an Array

By zxi on April 12, 2021

There is a function signFunc(x) that returns:

1 if x is positive.
-1 if x is negative.
0 if x is equal to 0.

You are given an integer array nums. Let product be the product of all values in the array nums.

Return signFunc(product).

Example 1:

Input: nums = [-1,-2,-3,-4,3,2,1]
Output: 1
Explanation: The product of all values in the array is 144, and signFunc(144) = 1

Example 2:

Input: nums = [1,5,0,2,-3]
Output: 0
Explanation: The product of all values in the array is 0, and signFunc(0) = 0

Example 3:

Input: nums = [-1,1,-1,1,-1]
Output: -1
Explanation: The product of all values in the array is -1, and signFunc(-1) = -1

Constraints:

1 <= nums.length <= 1000
-100 <= nums[i] <= 100

Solution: Sign Only

No need to compute the product, only track the sign changes. Flip the sign when encounter a negative number, return 0 if there is any 0 in the array.

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

C++

// Author: Huahua

class Solution {

public:

int arraySign(vector<int>& nums) {

int sign = 1;

for (int x : nums) {

if (x == 0) return 0;

else if (x < 0) sign = -sign;

}

return sign;

}

};

花花酱 LeetCode 1819. Number of Different Subsequences GCDs

By zxi on April 6, 2021

You are given an array nums that consists of positive integers.

The GCD of a sequence of numbers is defined as the greatest integer that divides all the numbers in the sequence evenly.

For example, the GCD of the sequence [4,6,16] is 2.

A subsequence of an array is a sequence that can be formed by removing some elements (possibly none) of the array.

For example, [2,5,10] is a subsequence of [1,2,1,2,4,1,5,10].

Return the number of different GCDs among all non-empty subsequences of nums.

Example 1:

Input: nums = [6,10,3]
Output: 5
Explanation: The figure shows all the non-empty subsequences and their GCDs.
The different GCDs are 6, 10, 3, 2, and 1.

Example 2:

Input: nums = [5,15,40,5,6]
Output: 7

Constraints:

1 <= nums.length <= 10⁵
1 <= nums[i] <= 2 * 10⁵

Solution: Math

Enumerate all possible gcds (1 to max(nums)), and check whether there is a subset of the numbers that can form a given gcd i.
If we want to check whether 10 is a valid gcd, we found all multipliers of 10 in the array and compute their gcd.
ex1 gcd(10, 20, 30) = 10, true
ex2 gcd(20, 40, 80) = 20, false

Time complexity: O(mlogm)
Space complexity: O(m)

C++

// Author: Huahua

class Solution {

public:

int countDifferentSubsequenceGCDs(vector<int>& nums) {

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

vector<int> s(kMax + 1);

for (int x : nums) s[x] = 1;

int ans = 0;

for (int i = 1; i <= kMax; ++i) {

int g = 0;

for (int j = i; j <= kMax; j += i)

if (s[j]) g = gcd(g, j);

ans += g == i;

}

return ans;

}

};

花花酱 LeetCode 1808. Maximize Number of Nice Divisors

By zxi on March 27, 2021

You are given a positive integer primeFactors. You are asked to construct a positive integer n that satisfies the following conditions:

The number of prime factors of n (not necessarily distinct) is at most primeFactors.
The number of nice divisors of n is maximized. Note that a divisor of n is nice if it is divisible by every prime factor of n. For example, if n = 12, then its prime factors are [2,2,3], then 6 and 12 are nice divisors, while 3 and 4 are not.

Return the number of nice divisors of n. Since that number can be too large, return it modulo 10⁹ + 7.

Note that a prime number is a natural number greater than 1 that is not a product of two smaller natural numbers. The prime factors of a number n is a list of prime numbers such that their product equals n.

Example 1:

Input: primeFactors = 5
Output: 6
Explanation: 200 is a valid value of n.
It has 5 prime factors: [2,2,2,5,5], and it has 6 nice divisors: [10,20,40,50,100,200].
There is not other value of n that has at most 5 prime factors and more nice divisors.

Example 2:

Input: primeFactors = 8
Output: 18

Constraints:

1 <= primeFactors <= 10⁹

Solution: Math

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

C++

// Author: Huahua

class Solution {

public:

int maxNiceDivisors(int n) {

constexpr int kMod = 1e9 + 7;

auto powm = [](long base, int exp) {

long ans = 1;

while (exp) {

if (exp & 1) ans = (ans * base) % kMod;

base = (base * base) % kMod;

exp >>= 1;

}

return ans;

};

if (n <= 3) return n;

switch (n % 3) {

case 0: return powm(3, n / 3);

case 1: return (powm(3, n / 3 - 1) * 4) % kMod;

case 2: return (powm(3, n / 3) * 2) % kMod;

}

return -1;

}

};

花花酱 LeetCode 1802. Maximum Value at a Given Index in a Bounded Array

By zxi on March 22, 2021

You are given three positive integers n, index and maxSum. You want to construct an array nums (0-indexed) that satisfies the following conditions:

nums.length == n
nums[i] is a positive integer where 0 <= i < n.
abs(nums[i] - nums[i+1]) <= 1 where 0 <= i < n-1.
The sum of all the elements of nums does not exceed maxSum.
nums[index] is maximized.

Return nums[index] of the constructed array.

Note that abs(x) equals x if x >= 0, and -x otherwise.

Example 1:

Input: n = 4, index = 2,  maxSum = 6
Output: 2
Explanation: The arrays [1,1,2,1] and [1,2,2,1] satisfy all the conditions. There are no other valid arrays with a larger value at the given index.

Example 2:

Input: n = 6, index = 1,  maxSum = 10
Output: 3

Constraints:

1 <= n <= maxSum <= 10⁹
0 <= index < n

Solution: Binary Search

To maximize nums[index], we can construct an array like this:
[1, 1, 1, …, 1, 2, 3, …, k – 1, k, k – 1, …,3, 2, 1, …., 1, 1, 1]

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

C++

// Author: Huahua

class Solution {

public:

int maxValue(int n, int index, int maxSum) {

int l = 1;

int r = maxSum + 1;

while (l < r) {

int64_t m = l + (r - l) / 2;

int64_t t1 = m - index;

int64_t t2 = m - (n - 1 - index);

int64_t s1 = (t1 + m) * (index + 1) / 2;

int64_t s2 = (m + t2) * (n - index) / 2;

if (t1 <= 0) s1 = (1 + m) * m / 2 + (index - m + 1);

if (t2 <= 0) s2 = (1 + m) * m / 2 + (n - index - m);

if (s1 + s2 - m > maxSum)

r = m;

else

l = m + 1;

}

return l - 1;

}

};