• 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.

An integer m is a divisor of n if there exists an integer k such that n = k * m.

Example 1:

Input: n = 2
Output: false
Explantion: 2 has only two divisors: 1 and 2.

Example 2:

Input: n = 4
Output: true
Explantion: 4 has three divisors: 1, 2, and 4.

Constraints:

• 1 <= n <= 104

Solution: Enumerate divisors.

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

// Author: Huahua
class Solution {
public:
  bool isThree(int n) {
    int c = 0;
    for (int i = 1; i <= n; ++i)
      if (n % i == 0) ++c;        
    return c == 3;
  }
};

Optimization

Only need to enumerate divisors up to sqrt(n). Special handle for the d * d == n case.

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

// Author: Huahua
class Solution {
public:
  bool isThree(int n) {
    int c = 0;
    for (int i = 1; i <= sqrt(n); ++i)
      if (n % i == 0)
        c += 1 + (i * i != n);
    return c == 3;
  }
};

The post 花花酱 LeetCode 1952. Three Divisors appeared first on Huahua's Tech Road.

If there is no such integer in the array, return 0.

Example 1:

Input: nums = [21,4,7]
Output: 32
Explanation:
21 has 4 divisors: 1, 3, 7, 21
4 has 3 divisors: 1, 2, 4
7 has 2 divisors: 1, 7
The answer is the sum of divisors of 21 only.

Constraints:

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

Solution: Math

If a number is a perfect square (e.g. 9 = 3 * 3), it will have odd number of divisors. (9: 1, 3, 9).

Time complexity: O(sum(sqrt(num_i))
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int sumFourDivisors(vector<int>& nums) {
    int ans = 0;
    for (int n : nums) {
      int r = sqrt(n);
      if (n <= 4 || r * r == n) continue;
      int count = 2;
      int sum = 1 + n;
      for (int d = 2; d <= r; ++d)
        if (n % d == 0) {
          count += 2;
          sum += n / d + d;
        }      
      if (count == 4) ans += sum;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1390. Four Divisors appeared first on Huahua's Tech Road.

Return the two integers in any order.

Example 1:

Input: num = 8
Output: [3,3]
Explanation: For num + 1 = 9, the closest divisors are 3 & 3, for num + 2 = 10, the closest divisors are 2 & 5, hence 3 & 3 is chosen.

Example 2:

Input: num = 123
Output: [5,25]

Example 3:

Input: num = 999
Output: [40,25]

Constraints:

• 1 <= num <= 10^9

Solution: Brute Force

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

// Author: Huahua
class Solution {
public:
  vector<int> closestDivisors(int num) {
    auto divisors = [](int n) {
      for (int i = sqrt(n); i >= 2; --i)
        if (n % i == 0) return vector<int>{i, n / i};
      return vector<int>{1, n};
    };
    
    auto ans1 = divisors(num + 1);
    auto ans2 = divisors(num + 2);
    return ans1[1] - ans1[0] < ans2[1] - ans2[0] ? ans1 : ans2;
  }
};

# Author: Huahua
class Solution:
  def closestDivisors(self, num: int) -> List[int]:
    def divisors(n: int) -> List[int]:
      for i in range(int(math.sqrt(n)), 1, -1):
        if n % i == 0: return [i, n // i]
      return [1, n]
    
    a1, a2 = divisors(num + 1), divisors(num + 2)
    return a1 if a1[1] - a1[0] < a2[1] - a2[0] else a2

The post 花花酱 LeetCode 1362. Closest Divisors appeared first on Huahua's Tech Road.

Problem

Given a non-negative integer c, your task is to decide whether there’re two integers a and b such that a² + b² = c.

Example 1:

Input: 5
Output: True
Explanation: 1 * 1 + 2 * 2 = 5

Example 2:

Input: 3
Output: False

Solution: Math

Time complexity: O(sqrt(c))

Space complexity: O(1)

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  bool judgeSquareSum(int c) {
    int m = sqrt(c);
    for (int a = 0; a <= m; ++a) {
      int b = round(sqrt(c - a * a));
      if (a * a + b * b == c) return true;
    }
    return false;
  }
};

The post 花花酱 LeetCode 633. Sum of Square Numbers appeared first on Huahua's Tech Road.

For a web developer, it is very important to know how to design a web page’s size. So, given a specific rectangular web page’s area, your job by now is to design a rectangular web page, whose length L and width W satisfy the following requirements:

1. The area of the rectangular web page you designed must equal to the given target area.

2. The width W should not be larger than the length L, which means L >= W.

3. The difference between length L and width W should be as small as possible.

You need to output the length L and the width W of the web page you designed in sequence.

Example:

Input: 4
Output: [2, 2]
Explanation: The target area is 4, and all the possible ways to construct it are [1,4], [2,2], [4,1]. 
But according to requirement 2, [1,4] is illegal; according to requirement 3,  [4,1] is not optimal compared to [2,2]. So the length L is 2, and the width W is 2.

Note:

1. The given area won’t exceed 10,000,000 and is a positive integer
2. The web page’s width and length you designed must be positive integers.

Solution

Time complexity: O(sqrt(n))

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 3 ms (<98.48%)
class Solution {
public:
  vector<int> constructRectangle(int area) {    
    for (int i = sqrt(area); i >= 1; --i)
      if (area % i == 0) return {area / i, i};    
  }
};

The post 花花酱 LeetCode 492. Construct the Rectangle appeared first on Huahua's Tech Road.

题目大意：判断一个数的因数和是不是等于它本身。

https://leetcode.com/problems/perfect-number/description/

We define the Perfect Number is a positive integer that is equal to the sum of all its positive divisors except itself.

Now, given an integer n, write a function that returns true when it is a perfect number and false when it is not.

Example:

Input: 28
Output: True
Explanation: 28 = 1 + 2 + 4 + 7 + 14

Note: The input number n will not exceed 100,000,000. (1e8)

Solution: Brute Force

Try allnumbers from 1 to n – 1.

Time complexity: O(n) TLE for prime numbers

Space complexity: O(1)

Solution: Math

Try all numbers from 2 to sqrt(n).

If number i is a divisor of n then n/i is another one.

Be careful about the case when i == n/i, only one should be added to the sum.

Time complexity: O(sqrt(n))

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 6 ms
class Solution {
public:
  bool checkPerfectNumber(int num) {
    if (num <= 1) return false;    
    int sum = 1;
    for (int i = 2; i <= sqrt(num); ++i)
      if (num % i == 0) sum += i + ((i == num / i) ? 0 : num / i);   
    return sum == num;
  }
};

The post 花花酱 LeetCode 507. Perfect Number appeared first on Huahua's Tech Road.

题目大意：让你实现开根号函数，只需要返回整数部分。

Problem:

Implement int sqrt(int x).

Compute and return the square root of x.

x is guaranteed to be a non-negative integer.

Example 1:

Input: 4
Output: 2

Example 2:

Input: 8
Output: 2
Explanation: The square root of 8 is 2.82842...

Solution 1: Brute force

Time complexity: sqrt(x)

// Author: Huahua
// Running time: 40 ms
class Solution {
public:
  int mySqrt(int x) {
    if (x <= 1) return x;
    for (long long s = 1; s <= x; ++s)
      if (s * s > x) return s - 1;
    return -1;
  }
};

// Author: Huahua
// Running time: 162 ms
class Solution {
public:
  int mySqrt(int x) {
    if (x <= 1) return x;
    for (int s = 1; s <= x; ++s)
      if (s > x / s) return s - 1;
    return -1;
  }
};

// Author: Huahua
// Running time: 71 ms
class Solution {
  public int mySqrt(int x) {
    if (x <= 1) return x;
    for (long s = 1; s <= x; ++s)
      if (s * s > x) return (int)s - 1;
    return -1;
  }
}

"""
Author: Huahua
TLE: 602 / 1017 test cases passed.
"""
class Solution:
  def mySqrt(self, x):
    if x <= 1: return x
    s = 1
    while True:
      if s*s > x: return s - 1
      s += 1
    return -1

Solution 2: Binary search

Time complexity: O(logn)

// Author: Huahua
// Running time: 12 ms
class Solution {
public:
  int mySqrt(int x) {      
    long l = 1;
    long r = static_cast<long>(x) + 1;
    while (l < r) {
      long m = l + (r - l) / 2;
      if (m * m > x) { 
        r = m;
      } else {
        l = m + 1;
      }
    }
    // l: smallest number such that l * l > x
    return l - 1;
  }
};

// Author: Huahua
// Running time: 47 ms
class Solution {
  public int mySqrt(int x) {      
    int l = 1;
    int r = x;
    while (l <= r) {
      int m = l + (r - l) / 2;
      if (m > x / m) {
        r = m - 1;
      } else {
        l = m + 1;
      }
    }
    return r;
  }
}

"""
Author: Huahua
Running time: 119 ms
"""
class Solution:
  def mySqrt(self, a):
    l = 1
    r = a
    while l <= r:
      m = l + (r - l) // 2
      if m * m > a:
        r = m - 1
      else:
        l = m + 1
    return r;

Solution 3: Newton’s method

// Author: Huahua
// Running time: 28 ms
class Solution {
public:
    int mySqrt(int a) {
      constexpr double epsilon = 1e-2;
      double x = a;
      while (x * x - a > epsilon) {
        x = (x + a / x) / 2.0;
      }
      return x;
    }
};

// Author: Huahua
// Running time: 27 ms
class Solution {
public:
  int mySqrt(int a) {
    // f(x) = x^2 - a, find root of f(x)
    // Newton's method
    // f'(x) = 2x
    // x' = x - f(x) / f'(x) = x - (1/2*x - a/(2*x))
    //    = (x + a / x) / 2
    int x = a;
    while (x > a / x)
      x = (x + a / x) / 2;
    return x;
  }
};

// Author: Huahua
// Running time: 44 ms
class Solution {
  public int mySqrt(int a) {    
    long x = a;
    while (x * x > a)
      x = (x + a / x) / 2;    
    return (int)x;
  }
}

"""
Author: Huahua
Running time: 100 ms
"""
class Solution:
  def mySqrt(self, a):
    x = a
    while x * x > a:
      x = (x + a // x) // 2
    return x

The post 花花酱 LeetCode. 69 Sqrt(x) 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.