• Swap the positions of two elements nums[i] and nums[j] if gcd(nums[i], nums[j]) > 1 where gcd(nums[i], nums[j]) is the greatest common divisor of nums[i] and nums[j].

Return true if it is possible to sort nums in non-decreasing order using the above swap method, or false otherwise.

Example 1:

Input: nums = [7,21,3]
Output: true
Explanation: We can sort [7,21,3] by performing the following operations:
- Swap 7 and 21 because gcd(7,21) = 7. nums = [21,7,3]
- Swap 21 and 3 because gcd(21,3) = 3. nums = [3,7,21]

Example 2:

Input: nums = [5,2,6,2]
Output: false
Explanation: It is impossible to sort the array because 5 cannot be swapped with any other element.

Example 3:

Input: nums = [10,5,9,3,15]
Output: true
We can sort [10,5,9,3,15] by performing the following operations:
- Swap 10 and 15 because gcd(10,15) = 5. nums = [15,5,9,3,10]
- Swap 15 and 3 because gcd(15,3) = 3. nums = [3,5,9,15,10]
- Swap 10 and 15 because gcd(10,15) = 5. nums = [3,5,9,10,15]

Constraints:

• 1 <= nums.length <= 3 * 104
• 2 <= nums[i] <= 105

Solution: Union-Find

Let nums[j]’s target position be i. In order to put nums[j] to pos i by swapping. nums[i] and nums[j] must be in the same connected component. There is an edge between two numbers if they have gcd > 1.

We union two numbers if their have gcd > 1. However, it will be TLE if we do all pairs . Thus, for each number, we union it with its divisors instead.

Time complexity: O(n²) TLE -> O(sum(sqrt(nums[i]))) <= O(n*sqrt(m))
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  bool gcdSort(vector<int>& nums) {
    const int m = *max_element(begin(nums), end(nums));
    const int n = nums.size();
    
    vector<int> p(m + 1);
    iota(begin(p), end(p), 0);
  
    function<int(int)> find = [&](int x) {
      return p[x] == x ? x : (p[x] = find(p[x]));
    };
  
    for (int x : nums)
      for (int d = 2; d <= sqrt(x); ++d)
        if (x % d == 0)
          p[find(x)] = p[find(x / d)] = find(d);

    vector<int> sorted(nums);
    sort(begin(sorted), end(sorted));
    
    for (int i = 0; i < n; ++i)
      if (find(sorted[i]) != find(nums[i])) 
        return false;

    return true;
  }
};

The post 花花酱 LeetCode 1998. GCD Sort of an Array appeared first on Huahua's Tech Road.

• 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 109 + 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 <= 109

Solution: Math

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

// 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;
  }
};

The post 花花酱 LeetCode 1808. Maximize Number of Nice Divisors appeared first on Huahua's Tech Road.

Return an integer array answer where answer.length == queries.length, and answer[i] is the answer to the ith query.

Example 1:

Input: queries = [[2,6],[5,1],[73,660]]
Output: [4,1,50734910]
Explanation: Each query is independent.
[2,6]: There are 4 ways to fill an array of size 2 that multiply to 6: [1,6], [2,3], [3,2], [6,1].
[5,1]: There is 1 way to fill an array of size 5 that multiply to 1: [1,1,1,1,1].
[73,660]: There are 1050734917 ways to fill an array of size 73 that multiply to 660. 1050734917 modulo 109 + 7 = 50734910.

Example 2:

Input: queries = [[1,1],[2,2],[3,3],[4,4],[5,5]]
Output: [1,2,3,10,5]

Constraints:

• 1 <= queries.length <= 104
• 1 <= ni, ki <= 104

Solution1: DP

let dp(n, k) be the ways to have product k of array size n.
dp(n, k) = sum(dp(n – 1, i)) where i is a factor of k and i != k.
base case:
dp(0, 1) = 1, dp(0, *) = 0
dp(i, 1) = C(n, i)
e.g.
dp(2, 6) = dp(1, 1) + dp(1, 2) + dp(1, 3)
= 2 + 1 + 1 = 4
dp(4, 4) = dp(3, 1) + dp(3, 2)
= dp(3, 1) + dp(2, 1)
= 4 + 6 = 10

Time complexity: O(sum(k_i))?
Space complexity: O(sum(k_i))?

// Author: Huahua
class Solution {
public:
  vector<int> waysToFillArray(vector<vector<int>>& queries) {
    constexpr int kMod = 1e9 + 7;
    int n = 0;
    unordered_map<int, int> c, dp;
    function<int(int, int)> cnk = [&](int n, int k) {
      if (k > n) return 0;
      if (k == 0 || k == n) return 1;      
      int& ans = c[(n << 16) | k];
      if (!ans) ans = (cnk(n - 1, k - 1) + cnk(n - 1, k)) % kMod; 
      return ans;      
    };
    
    function<int(int, int)> dfs = [&](int s, int k) -> int {
      if (s == 0) return k == 1;
      if (k == 1) return cnk(n, s);
      int& ans = dp[(s << 16) | k];
      if (ans) return ans;      
      for (int i = 1; i * i <= k; ++i) {
        if (k % i) continue;
        if (i != 1) 
          ans = (ans + dfs(s - 1, k / i)) % kMod;
        if (i * i != k)
          ans = (ans + dfs(s - 1, i)) % kMod;
      }
      return ans;
    };
    
    vector<int> ans;
    for (const auto& q : queries) {
      dp.clear();
      n = q[0];
      ans.push_back(dfs(n, q[1]));
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1735. Count Ways to Make Array With Product appeared first on Huahua's Tech Road.

(Recall that an integer is prime if and only if it is greater than 1, and cannot be written as a product of two positive integers both smaller than it.)

Since the answer may be large, return the answer modulo 10^9 + 7.

Example 1:

Input: n = 5
Output: 12
Explanation: For example [1,2,5,4,3] is a valid permutation, but [5,2,3,4,1] is not because the prime number 5 is at index 1.

Example 2:

Input: n = 100
Output: 682289015

Constraints:

• 1 <= n <= 100

Solution: Permutation

Count the number of primes in range [1, n], assuming there are p primes and n – p non-primes, we can permute each group separately.
ans = p! * (n – p)!

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

// Author: Huahua
class Solution {
public:
  int numPrimeArrangements(int n) {
    const int kMod = 1e9 + 7;
    int p = 0;
    for (int i = 1; i <= n; ++i)
      p += isPrime(i);
    long ans = 1;
    for (int i = 1; i <= p; ++i)
      ans = (ans * i) % kMod;
    for (int i = 1; i <= n - p; ++i)
      ans = (ans * i) % kMod;
    return ans;
  }
private:
  bool isPrime(int x) {
    if (x < 2) return false;
    if (x == 2) return true;
    for (int i = 2; i <= sqrt(x); ++i)
      if (x % i == 0) return false;
    return true;
  }
};

The post 花花酱 LeetCode 1175. Prime Arrangements appeared first on Huahua's Tech Road.

Super ugly numbers are positive numbers whose all prime factors are in the given prime list primes of size k.

Example:

Input: n = 12, primes = [2,7,13,19] 
Output: 32  
Explanation: [1,2,4,7,8,13,14,16,19,26,28,32] is the sequence of the first 12               super ugly numbers given primes = [2,7,13,19] of size 4.

Note:

• 1 is a super ugly number for any given primes.
• The given numbers in primes are in ascending order.
• 0 < k ≤ 100, 0 < n ≤ 10⁶, 0 < primes[i] < 1000.
• The n^th super ugly number is guaranteed to fit in a 32-bit signed integer.

Solution 1: Set

Maintain an ordered set of super ugly numbers, each time extract the smallest one, and multiply it with all primes and insert the new number into set.

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

// Author: Huahua, running time: 484 ms
class Solution {
public:
  int nthSuperUglyNumber(int n, vector<int>& primes) {
    if (n == 1) return 1;
    set<int> q{begin(primes), end(primes)};        
    for (int i = 0; i < n - 2; ++i) {      
      auto it = begin(q);
      int t = *it;
      q.erase(it);
      for (int p : primes) {
        if (INT_MAX / t < p) continue;        
        q.insert(p * t);
      }
      
    }
    return *begin(q);
  }
};

Solution 2: Priority Queue

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

// Author: Huahua, 40 ms
struct Node {
  int num;
  int index;
  int prime;
  
  bool operator>(const Node& o) const {
    if (this->num == o.num) return this->index > o.index;
    return this->num > o.num;
  }
};

class Solution {
public:
  int nthSuperUglyNumber(int n, vector<int>& primes) {
    if (n == 1) return 1;
    vector<int> nums(n, 1);
    priority_queue<Node, vector<Node>, greater<Node>> q;
    for (int p : primes)
      q.push({p, 1, p});
    for (int i = 1; i < n; ++i) {
      nums[i] = q.top().num;
      while (nums[i] == q.top().num) {
        Node node = std::move(q.top()); q.pop();
        node.num = nums[node.index++] * node.prime;
        q.push(std::move(node));
      }
    }    
    return nums.back();
  }
};

The post 花花酱 LeetCode 313. Super Ugly Number appeared first on Huahua's Tech Road.

Find the smallest prime palindrome greater than or equal to N.

Recall that a number is prime if it’s only divisors are 1 and itself, and it is greater than 1.

For example, 2,3,5,7,11 and 13 are primes.

Recall that a number is a palindrome if it reads the same from left to right as it does from right to left.

For example, 12321 is a palindrome.

Example 1:

Input: 6
Output: 7

Example 2:

Input: 8
Output: 11

Example 3:

Input: 13
Output: 101

Note:

• 1 <= N <= 10^8
• The answer is guaranteed to exist and be less than 2 * 10^8.

Solution: Math

All odd digits palindromes have a factor 11, they are not prime except 11 itself.

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua
// Running time: 8 ms
class Solution {
public:
  int primePalindrome(int N) {
    if (N <= 2) return 2;
    if (N % 2 == 0) ++N;
    while (true) {      
      if (reverse(N) == N && isPrime(N)) 
        return N;
      N += 2;
      if (N > 11 & (int)log10(N) % 2 == 1)
        // 13 -> 101
        // 1001 -> 10001                
        N = pow(10, (int)log10(N) + 1) + 1;
    }
    return -1;
  }
private:
  int reverse(int n) {
    int r = 0;
    while (n) {
      r = 10 * r + n % 10;
      n /= 10;
    }
    return r;
  }
  
  bool isPrime(int n) {
    if (n <= 1) return false;
    for (int i = 2; i <= sqrt(n); ++i)
      if (n % i == 0) return false;
    return true;
  }
};

The post 花花酱 LeetCode 867. Prime Palindrome appeared first on Huahua's Tech Road.

题目大意：求给定范围内，数的二进制形式中1的个数为素数个的数字的个数。

Given two integers L and R, find the count of numbers in the range [L, R] (inclusive) having a prime number of set bits in their binary representation.

(Recall that the number of set bits an integer has is the number of 1s present when written in binary. For example, 21 written in binary is 10101 which has 3 set bits. Also, 1 is not a prime.)

Example 1:

Input: L = 6, R = 10
Output: 4
Explanation:
6 -> 110 (2 set bits, 2 is prime)
7 -> 111 (3 set bits, 3 is prime)
9 -> 1001 (2 set bits , 2 is prime)
10->1010 (2 set bits , 2 is prime)

Example 2:

Input: L = 10, R = 15
Output: 5
Explanation:
10 -> 1010 (2 set bits, 2 is prime)
11 -> 1011 (3 set bits, 3 is prime)
12 -> 1100 (2 set bits, 2 is prime)
13 -> 1101 (3 set bits, 3 is prime)
14 -> 1110 (3 set bits, 3 is prime)
15 -> 1111 (4 set bits, 4 is not prime)

Note:

1. L, R will be integers L <= R in the range [1, 10^6].
2. R - L will be at most 10000.

Solution 1: Brute Force

C++

// Author: Huahua
// Running time: 22 ms
class Solution {
public:
  int countPrimeSetBits(int L, int R) {
    int ans = 0;
    for (int n = L; n <= R; ++n)
      if (isPrime(bits(n))) ++ans;
    return ans;
  }
private:
  bool isPrime(int n) {
    if (n <= 1) return false;
    if (n == 2) return true;      
    for (int i = 2; i <= sqrt(n); ++i)
      if (n % i == 0) return false;
    return true;
  }
  
  int bits(int n) {
    int s = 0;
    while (n) {
      s += n & 1;
      n >>= 1;
    }        
    return s;
  }
};

// Author: Huahua
// Running time: 16 ms
class Solution {
public:
  int countPrimeSetBits(int L, int R) {
    int ans = 0;
    set<int> primes{2, 3, 5, 7, 11, 13, 17, 19};
    for (int n = L; n <= R; ++n)
      if (primes.count(__builtin_popcountll(n))) ++ans;
    return ans;
  }
};

// Author: Huahua
// Running time: 30 ms
class Solution {
public:
  int countPrimeSetBits(int L, int R) {
    int ans = 0;
    unordered_set<int> primes{2, 3, 5, 7, 11, 13, 17, 19};
    for (int n = L; n <= R; ++n)
      if (primes.count(__builtin_popcountll(n))) ++ans;
    return ans;
  }
};

// Author: Huahua
// Running time: 9 ms
class Solution {
public:
  int countPrimeSetBits(int L, int R) {
    int ans = 0;
    vector<int> p(20, 0);
    p[2] = p[3] = p[5] = p[7] = p[11] = p[13] = p[17] = p[19] = 1;
    for (int n = L; n <= R; ++n)
      if (p[__builtin_popcountll(n)]) ++ans;
    return ans;
  }
};

// Author: Huahua
// Running time: 8 ms
class Solution {
public:
  int countPrimeSetBits(int L, int R) {
    constexpr int magic = 665772;
    int ans = 0;
    for (int n = L; n <= R; ++n)
      if (magic & (1 << __builtin_popcountll(n))) ++ans;
    return ans;
  }
};

Java

// Author: Huahua
// Running time: 39 ms
class Solution {
  public int countPrimeSetBits(int L, int R) {
    int ans = 0;
    for (int n = L; n <= R; ++n)
      if (isPrime(bits(n))) ++ans;
    return ans;
  }
  
  private boolean isPrime(int n) {
    if (n <= 1) return false;
    if (n == 2) return true;      
    for (int i = 2; i <= (int)Math.sqrt(n); ++i)
      if (n % i == 0) return false;
    return true;
  }
  
  private int bits(int n) {
    int s = 0;
    while (n != 0) {
      s += n & 1;
      n >>= 1;
    }        
    return s;
  }
}

Python2

"""
Author: Huahua
Running time: 1618 ms
"""
class Solution(object):
  def countPrimeSetBits(self, L, R):
    def isPrime(n):
      if n <= 1: return False
      if n == 2: return True
      for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0: return False
      return True

    def bits(n):
      s = 0
      while n != 0:
        s += n & 1
        n >>= 1
      return s

    ans = 0
    for n in range(L, R + 1):
      if isPrime(bits(n)): ans += 1
    return ans

Python2

"""
Author: Huahua
Running time: 1163 ms
"""
class Solution(object):
  def countPrimeSetBits(self, L, R):
    def bits(n):
      s = 0
      while n != 0:
        s += n & 1
        n >>= 1
      return s
    
    primes = set([2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31])

    ans = 0
    for n in range(L, R + 1):
      if bits(n) in primes: ans += 1
    return ans

"""
Author: Huahua
Running time: 667 ms
"""
class Solution(object):   
  def countPrimeSetBits(self, L, R):
    def bits(n):
      s = 0
      while n != 0:
        n &= n - 1;
        s += 1
      return s
        
    ans = 0
    while L <= R:
      if (665772 >> bits(L)) & 1 > 0: ans += 1
      L += 1

    return ans

The post 花花酱 LeetCode 762. Prime Number of Set Bits in Binary Representation appeared first on Huahua's Tech Road.

Problem:

Count the number of prime numbers less than a non-negative number, n.

Idea:

Sieve of Eratosthenes

Time Complexity:

O(nloglogn)

Space Complexity:

O(n)

Solution:

C++

// Author: Huahua
class Solution {
public:
    int countPrimes(int n) {
        if (n < 3) return 0;
        
        vector<unsigned char> f(n, 1);
        f[0] = f[1] = 0;
        for(long i=2;i<=sqrt(n);++i) {
            if(!f[i]) continue;
            for(long j=i*i;j<n;j+=i)
                f[j] = 0;
        }
        
        int ans = accumulate(f.begin(), f.end(), 0);
        return ans;
    }
};

Java

// Author: Huahua
// Running time: 16 ms
class Solution {
  public int countPrimes(int n) {
    int ans = 0;
    boolean[] isPrime = new boolean[n + 1];
    Arrays.fill(isPrime, true);
    isPrime[0] = false;
    if (n > 0) isPrime[1] = false;
    for (int i = 2; i < n; ++i) {
      if (!isPrime[i]) continue;
      ++ans;
      for (int j = 2 * i; j < n; j += i)
        isPrime[j] = false;
    }
    return ans;
  }
}

Python3

"""
Author: Huahua
Running time: 800 ms
"""
class Solution:
  def countPrimes(self, n):
    if n < 3: return 0
    isPrime = [True] * (n + 1)
    isPrime[0] = False
    isPrime[1] = False
    ans = 0
    for i in range(2, n):
      if not isPrime[i]: continue
      ans += 1
      for j in range(2 * i, n, i):
        isPrime[j] = False
    return ans

The post 花花酱 LeetCode 204. Count Primes appeared first on Huahua's Tech Road.