Question

1998. 数组的最大公因数排序

English Version

题目描述

给你一个整数数组 nums ，你可以在 nums 上执行下述操作 任意次 ：

• 如果 gcd(nums[i], nums[j]) > 1 ，交换 nums[i] 和 nums[j] 的位置。其中 gcd(nums[i], nums[j]) 是 nums[i] 和 nums[j] 的最大公因数。

如果能使用上述交换方式将 nums 按 非递减顺序 排列，返回 true ；否则，返回 false 。

 

示例 1：

输入：nums = [7,21,3]
输出：true
解释：可以执行下述操作完成对 [7,21,3] 的排序：
- 交换 7 和 21 因为 gcd(7,21) = 7 。nums = [_21_,_7_,3]
- 交换 21 和 3 因为 gcd(21,3) = 3 。nums = [_3_,7,_21_]

示例 2：

输入：nums = [5,2,6,2]
输出：false
解释：无法完成排序，因为 5 不能与其他元素交换。

示例 3：

输入：nums = [10,5,9,3,15]
输出：true
解释：
可以执行下述操作完成对 [10,5,9,3,15] 的排序：
- 交换 10 和 15 因为 gcd(10,15) = 5 。nums = [_15_,5,9,3,_10_]
- 交换 15 和 3 因为 gcd(15,3) = 3 。nums = [_3_,5,9,_15_,10]
- 交换 10 和 15 因为 gcd(10,15) = 5 。nums = [3,5,9,_10_,_15_]

 

提示：

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

解法

方法一

class Solution:
  def gcdSort(self, nums: List[int]) -> bool:
    n = 10**5 + 10
    p = list(range(n))
    f = defaultdict(list)
    mx = max(nums)
    for i in range(2, mx + 1):
      if f[i]:
        continue
      for j in range(i, mx + 1, i):
        f[j].append(i)

    def find(x):
      if p[x] != x:
        p[x] = find(p[x])
      return p[x]

    for i in nums:
      for j in f[i]:
        p[find(i)] = find(j)

    s = sorted(nums)
    for i, num in enumerate(nums):
      if s[i] != num and find(num) != find(s[i]):
        return False
    return True

class Solution {
  private int[] p;

  public boolean gcdSort(int[] nums) {
    int n = 100010;
    p = new int[n];
    Map<Integer, List<Integer>> f = new HashMap<>();
    for (int i = 0; i < n; ++i) {
      p[i] = i;
    }
    int mx = 0;
    for (int num : nums) {
      mx = Math.max(mx, num);
    }
    for (int i = 2; i <= mx; ++i) {
      if (f.containsKey(i)) {
        continue;
      }
      for (int j = i; j <= mx; j += i) {
        f.computeIfAbsent(j, k -> new ArrayList<>()).add(i);
      }
    }
    for (int i : nums) {
      for (int j : f.get(i)) {
        p[find(i)] = find(j);
      }
    }
    int[] s = new int[nums.length];
    System.arraycopy(nums, 0, s, 0, nums.length);
    Arrays.sort(s);
    for (int i = 0; i < nums.length; ++i) {
      if (s[i] != nums[i] && find(nums[i]) != find(s[i])) {
        return false;
      }
    }
    return true;
  }

  int find(int x) {
    if (p[x] != x) {
      p[x] = find(p[x]);
    }
    return p[x];
  }
}

class Solution {
public:
  vector<int> p;

  bool gcdSort(vector<int>& nums) {
    int n = 100010;
    p.resize(n);
    for (int i = 0; i < n; ++i) p[i] = i;
    int mx = 0;
    for (auto num : nums) mx = max(mx, num);
    unordered_map<int, vector<int>> f;
    for (int i = 2; i <= mx; ++i) {
      if (!f[i].empty()) continue;
      for (int j = i; j <= mx; j += i) f[j].push_back(i);
    }
    for (int i : nums) {
      for (int j : f[i]) p[find(i)] = find(j);
    }
    vector<int> s = nums;
    sort(s.begin(), s.end());
    for (int i = 0; i < nums.size(); ++i) {
      if (s[i] != nums[i] && find(s[i]) != find(nums[i])) return false;
    }
    return true;
  }

  int find(int x) {
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
  }
};

var p []int

func gcdSort(nums []int) bool {
  n := 100010
  p = make([]int, n)
  for i := 0; i < n; i++ {
    p[i] = i
  }
  mx := 0
  for _, num := range nums {
    mx = max(mx, num)
  }
  f := make([][]int, mx+1)
  for i := 2; i <= mx; i++ {
    if len(f[i]) > 0 {
      continue
    }
    for j := i; j <= mx; j += i {
      f[j] = append(f[j], i)
    }
  }
  for _, i := range nums {
    for _, j := range f[i] {
      p[find(i)] = find(j)
    }
  }
  s := make([]int, len(nums))
  for i, num := range nums {
    s[i] = num
  }
  sort.Ints(s)
  for i, num := range nums {
    if s[i] != num && find(s[i]) != find(num) {
      return false
    }
  }
  return true
}

func find(x int) int {
  if p[x] != x {
    p[x] = find(p[x])
  }
  return p[x]
}