1. Find any two adjacent numbers in nums that are non-coprime.
2. If no such numbers are found, stop the process.
3. Otherwise, delete the two numbers and replace them with their LCM (Least Common Multiple).
4. Repeat this process as long as you keep finding two adjacent non-coprime numbers.

Return the final modified array. It can be shown that replacing adjacent non-coprime numbers in any arbitrary order will lead to the same result.

The test cases are generated such that the values in the final array are less than or equal to 108.

Two values x and y are non-coprime if GCD(x, y) > 1 where GCD(x, y) is the Greatest Common Divisor of x and y.

Example 1:

Input: nums = [6,4,3,2,7,6,2]
Output: [12,7,6]
Explanation: 
- (6, 4) are non-coprime with LCM(6, 4) = 12. Now, nums = [12,3,2,7,6,2].
- (12, 3) are non-coprime with LCM(12, 3) = 12. Now, nums = [12,2,7,6,2].
- (12, 2) are non-coprime with LCM(12, 2) = 12. Now, nums = [12,7,6,2].
- (6, 2) are non-coprime with LCM(6, 2) = 6. Now, nums = [12,7,6].
There are no more adjacent non-coprime numbers in nums.
Thus, the final modified array is [12,7,6].
Note that there are other ways to obtain the same resultant array.

Example 2:

Input: nums = [2,2,1,1,3,3,3]
Output: [2,1,1,3]
Explanation: 
- (3, 3) are non-coprime with LCM(3, 3) = 3. Now, nums = [2,2,1,1,3,3].
- (3, 3) are non-coprime with LCM(3, 3) = 3. Now, nums = [2,2,1,1,3].
- (2, 2) are non-coprime with LCM(2, 2) = 2. Now, nums = [2,1,1,3].
There are no more adjacent non-coprime numbers in nums.
Thus, the final modified array is [2,1,1,3].
Note that there are other ways to obtain the same resultant array.

Constraints:

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 105
• The test cases are generated such that the values in the final array are less than or equal to 108.

Solution: Stack

“””It can be shown that replacing adjacent non-coprime numbers in any arbitrary order will lead to the same result.”””

So that we can do it in one pass from left to right using a stack/vector.

Push the current number onto stack, and merge top two if they are not co-prime.

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

// Author: Huahua
class Solution {
public:
  vector<int> replaceNonCoprimes(vector<int>& nums) {
    vector<int> ans;
    for (int x : nums) {
      ans.push_back(x);
      while (ans.size() > 1) {
        const int n1 = ans[ans.size() - 1]; 
        const int n2 = ans[ans.size() - 2]; 
        const int d = gcd(n1, n2);
        if (d == 1) break;
        ans.pop_back();
        ans.pop_back();
        ans.push_back(n1 / d * n2);
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2197. Replace Non-Coprime Numbers in Array appeared first on Huahua's Tech Road.

• 0 <= i < j <= n - 1 and
• nums[i] * nums[j] is divisible by k.

Example 1:

Input: nums = [1,2,3,4,5], k = 2
Output: 7
Explanation: 
The 7 pairs of indices whose corresponding products are divisible by 2 are
(0, 1), (0, 3), (1, 2), (1, 3), (1, 4), (2, 3), and (3, 4).
Their products are 2, 4, 6, 8, 10, 12, and 20 respectively.
Other pairs such as (0, 2) and (2, 4) have products 3 and 15 respectively, which are not divisible by 2.    

Example 2:

Input: nums = [1,2,3,4], k = 5
Output: 0
Explanation: There does not exist any pair of indices whose corresponding product is divisible by 5.

Constraints:

• 1 <= nums.length <= 105
• 1 <= nums[i], k <= 105

Solution: Math

a * b % k == 0 <=> gcd(a, k) * gcd(b, k) == 0

Use a counter of gcd(x, k) so far to compute the number of pairs.

Time complexity: O(n*f), where f is the number of gcds, f <= 128 for x <= 1e5
Space complexity: O(f)

// Author: Huahua
class Solution {
public:
  long long countPairs(vector<int>& nums, int k) {
    unordered_map<int, int> m;
    long long ans = 0;
    for (int x : nums) {
      long long d1 = gcd(x, k);
      for (const auto& [d2, c] : m)
        if (d1 * d2 % k == 0) ans += c;
      ++m[d1];
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2183. Count Array Pairs Divisible by K appeared first on Huahua's Tech Road.

• 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 greatest common divisor of two numbers is the largest positive integer that evenly divides both numbers.

Example 1:

Input: nums = [2,5,6,9,10]
Output: 2
Explanation:
The smallest number in nums is 2.
The largest number in nums is 10.
The greatest common divisor of 2 and 10 is 2.

Example 2:

Input: nums = [7,5,6,8,3]
Output: 1
Explanation:
The smallest number in nums is 3.
The largest number in nums is 8.
The greatest common divisor of 3 and 8 is 1.

Example 3:

Input: nums = [3,3]
Output: 3
Explanation:
The smallest number in nums is 3.
The largest number in nums is 3.
The greatest common divisor of 3 and 3 is 3.

Constraints:

• 2 <= nums.length <= 1000
• 1 <= nums[i] <= 1000

Solution:

Use std::minmax_element and std::gcd

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

// Author: Huahua
class Solution {
public:
  int findGCD(vector<int>& nums) {
    auto p = minmax_element(begin(nums), end(nums));     
    return gcd(*p.first, *p.second);
  }
};

The post 花花酱 LeetCode 1979. Find Greatest Common Divisor of Array appeared first on Huahua's Tech Road.

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 <= 105
• 1 <= nums[i] <= 2 * 105

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)

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

The post 花花酱 LeetCode 1819. Number of Different Subsequences GCDs appeared first on Huahua's Tech Road.

Example 1:

Input: n = 2
Output: ["1/2"]
Explanation: "1/2" is the only unique fraction with a denominator less-than-or-equal-to 2.

Example 2:

Input: n = 3
Output: ["1/2","1/3","2/3"]

Example 3:

Input: n = 4
Output: ["1/2","1/3","1/4","2/3","3/4"]
Explanation: "2/4" is not a simplified fraction because it can be simplified to "1/2".

Example 4:

Input: n = 1
Output: []

Constraints:

• 1 <= n <= 100

Solution: GCD

if gcd(a, b) == 1 then a/b is a simplified frication.

std::gcd is available since c++17.

Time complexity: O(n^2logn)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  vector<string> simplifiedFractions(int n) {
    vector<string> ans;
    for (int i = 1; i < n; ++i)
      for (int j = i + 1; j <= n; ++j)
        if (gcd(i, j) == 1)
          ans.push_back(to_string(i) + "/" + to_string(j));
    return ans;
  }
};

The post 花花酱 LeetCode 1447. Simplified Fractions appeared first on Huahua's Tech Road.

If z liters of water is measurable, you must have z liters of water contained within one or both buckets by the end.

Operations allowed:

• Fill any of the jugs completely with water.
• Empty any of the jugs.
• Pour water from one jug into another till the other jug is completely full or the first jug itself is empty.

Example 1: (From the famous “Die Hard” example)

Input: x = 3, y = 5, z = 4
Output: True

Example 2:

Input: x = 2, y = 6, z = 5
Output: False

Solution: Math

special case 1: x == z or y == z or x + y == z: return True
special case 2: x + y < z: return False
normal case: z must be a factor of gcd(x, y)

Time complexity: O(log(min(x, y))
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  bool canMeasureWater(int x, int y, int z) {
    if (x == z || y == z || x + y == z) return true;
    if (x + y < z) return false;
    return z % gcd(x, y) == 0;
  }
};

The post 花花酱 LeetCode 365. Water and Jug Problem appeared first on Huahua's Tech Road.

Return True if the array is good otherwise return False.

Example 1:

Input: nums = [12,5,7,23]
Output: true
Explanation: Pick numbers 5 and 7.
5*3 + 7*(-2) = 1

Example 2:

Input: nums = [29,6,10]
Output: true
Explanation: Pick numbers 29, 6 and 10.
29*1 + 6*(-3) + 10*(-1) = 1

Example 3:

Input: nums = [3,6]
Output: false

Constraints:

• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^9

Solution: Math

Bézout’s lemma: b[1] * A[1] + b[2] * A[2] + …. + b[n] * A[n] = 1 <==> gcd(A[1], A[2], …, A[n]) = 1 <=> at least two numbers are co-prime

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

// Author: Huahua
class Solution {
public:
  bool isGoodArray(vector<int>& nums) {
    int g = nums[0];
    for (int x : nums)
      g = gcd(g, x);    
    return g == 1;
  }
};

The post 花花酱 LeetCode 1250. Check If It Is a Good Array appeared first on Huahua's Tech Road.

Write a program to find the n-th ugly number.

Ugly numbers are positive integers which are divisible by a or b or c.

Example 1:

Input: n = 3, a = 2, b = 3, c = 5
Output: 4
Explanation: The ugly numbers are 2, 3, 4, 5, 6, 8, 9, 10... The 3rd is 4.

Example 2:

Input: n = 4, a = 2, b = 3, c = 4
Output: 6
Explanation: The ugly numbers are 2, 3, 4, 6, 8, 9, 12... The 4th is 6.

Example 3:

Input: n = 5, a = 2, b = 11, c = 13
Output: 10
Explanation: The ugly numbers are 2, 4, 6, 8, 10, 11, 12, 13... The 5th is 10.

Example 4:

Input: n = 1000000000, a = 2, b = 217983653, c = 336916467
Output: 1999999984

Constraints:

• 1 <= n, a, b, c <= 10^9
• 1 <= a * b * c <= 10^18
• It’s guaranteed that the result will be in range [1, 2 * 10^9]

Solution: Binary Search

Number of ugly numbers that are <= m are:

m / a + m / b + m / c – (m / LCM(a,b) + m / LCM(a, c) + m / LCM(b, c) + m / LCM(a, LCM(b, c))

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

// Author: Huahua
class Solution {
public:
  int nthUglyNumber(int n, long a, long b, long c) {    
    long l = 1;
    long r = INT_MAX;
    long ab = lcm(a, b);
    long ac = lcm(a, c);
    long bc = lcm(b, c);
    long abc = lcm(a, bc);
    while (l < r) {
      long m = l + (r - l) / 2;
      long k = m / a + m / b + m / c - m / ab - m / ac - m / bc + m / abc;      
      if (k >= n) r = m;
      else l = m + 1;
    }
    return l;
  }
};

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

n a deck of cards, each card has an integer written on it.

Return true if and only if you can choose X >= 2 such that it is possible to split the entire deck into 1 or more groups of cards, where:

• Each group has exactly X cards.
• All the cards in each group have the same integer.

Example 1:

Input: [1,2,3,4,4,3,2,1]
Output: true
Explanation: Possible partition [1,1],[2,2],[3,3],[4,4]

Input: [1,1,1,2,2,2,3,3]
Output: false
Explanation: No possible partition.

Input: [1]
Output: false
Explanation: No possible partition.

Input: [1,1]
Output: true
Explanation: Possible partition [1,1]

Input: [1,1,2,2,2,2]
Output: true
Explanation: Possible partition [1,1],[2,2],[2,2]

// Author: Huahua, 16 ms
class Solution {
public:
  bool hasGroupsSizeX(vector<int>& deck) {
    unordered_map<int, int> counts;
    for (int card : deck) ++counts[card];
    for (int i = 2; i <= deck.size(); ++i) {
      if (deck.size() % i) continue;
      bool ok = true;
      for (const auto& pair : counts)
        if (pair.second % i) {
          ok = false;
          break;
        }
      if (ok) return true;
    }
    return false;
  }
};

// Author: Huahua, 16 ms
class Solution {
public:
  bool hasGroupsSizeX(vector<int>& deck) {
    unordered_map<int, int> counts;
    for (int card : deck) ++counts[card];
    int X = deck.size();
    for (const auto& p : counts) 
      X = __gcd(X, p.second);
    return X >= 2;
  }
};

// Author: Somebody
class Solution {
    public boolean hasGroupsSizeX(int[] deck) {
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i=0; i<deck.length; i++) {
            int curr = deck[i];
            if (map.containsKey(curr)) {
                map.put(curr, map.get(curr) + 1);
            } else {
                map.put(curr, 1);
            }
        }
        
        // O(nLogn)
        int gcd = 0;
        for(Integer key: map.keySet()) {
            gcd = findGCDOfTwoNumbers(map.get(key), gcd);
        }
        
        return gcd >= 2;      
    }
    
    // O(Log n)
    public static int findGCDOfTwoNumbers (int a, int b) {
        if (b == 0) {
            return a;
        }
        return findGCDOfTwoNumbers(b, a%b);
    }
}

The post 花花酱 LeetCode 914. X of a Kind in a Deck of Cards appeared first on Huahua's Tech Road.

Input:"-1/2+1/2"
Output: "0/1"

Input:"-1/2+1/2+1/3"
Output: "1/3"

Input:"1/3-1/2"
Output: "-1/6"

Input:"5/3+1/3"
Output: "2/1"

Solution: Math

a/b+c/d = (a*d + b * c) / (b * d)

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  string fractionAddition(string expression) {
    int a = 0;
    int b = 1;    
    int c;
    int d;
    char slash;
    istringstream in(expression);
    while (in >> c >> slash >> d) {
      a = a * d + b * c;
      b *= d;
      int gcd = abs(__gcd(a, b));
      a /= gcd;
      b /= gcd;      
    }
    return to_string(a) + "/" + to_string(b);
  }
};

// Author: Huahua
// Running time: 0 ms
class Fraction {
public:
  Fraction(int a, int b): a_(a), b_(b) {}
  Fraction& operator+=(const Fraction& f) {
    a_ = a_ * f.b_ + b_ * f.a_;
    b_ = b_ * f.b_;
    int d = abs(__gcd(a_, b_));
    a_ /= d;
    b_ /= d;
    return *this;
  }
  
  string toString() {
    return to_string(a_) + "/" + to_string(b_);
  }
private:
  int a_; // hold the sign, e.g. can be +-.
  int b_; // always > 0.
};

class Solution {
public:
    string fractionAddition(string expression) {
      Fraction f(0, 1);
      int a;
      int b;
      char op;
      istringstream in(expression);
      while (in >> a >> op >> b)
        f += Fraction(a, b);  
      return f.toString();
    }
};

The post 花花酱 LeetCode 592. Fraction Addition and Subtraction appeared first on Huahua's Tech Road.

A positive integer is magical if it is divisible by either A or B.

Return the N-th magical number.  Since the answer may be very large, return it modulo 10^9 + 7.

Input: N = 1, A = 2, B = 3
Output: 2

Input: N = 4, A = 2, B = 3
Output: 6

Input: N = 5, A = 2, B = 4
Output: 10

Input: N = 3, A = 6, B = 4
Output: 8

// Author: Huahua
// Running time: 0 ms
class Solution {
public:
  int nthMagicalNumber(int N, int A, int B) {
    const int kMod = 1000000007;
    long l = 2;
    long r = static_cast<long>(1e9 * 4e5);
    int d = gcd(A, B);
    while (l < r) {
      long m = (r - l) / 2 + l;
      if (m / A + m / B - m / (A * B / d) < N)
        l = m + 1;
      else
        r = m;
    }
    return l % kMod;
  }
private:
  int gcd(int a, int b) {
    if (a % b == 0) return b;
    return gcd(b, a % b);
  }
};

The post 花花酱 LeetCode 878. Nth Magical Number appeared first on Huahua's Tech Road.