第一题：检查元素频次是否为质数

给你一个整数数组 nums。

如果数组中任一元素的频次是质数，返回 true；否则，返回 false。

元素 x 的频次是它在数组中出现的次数。

质数是一个大于 1 的自然数，并且只有两个因数：1 和它本身。

示例 1：

输入： nums = [1,2,3,4,5,4]

输出： true

解释：

数字 4 的频次是 2，而 2 是质数。

示例 2：

输入： nums = [1,2,3,4,5]

输出： false

解释：

所有元素的频次都是 1。

示例 3：

输入： nums = [2,2,2,4,4]

输出： true

解释：

数字 2 和 4 的频次都是质数。

提示：

1 <= nums.length <= 100
0 <= nums[i] <= 100

方法一：暴力求解

统计数组中每个元素的出现频率，遍历这些频率值并判断是否存在质数，若存在则返回true，否则返回false。

GO版

func checkPrimeFrequency(nums []int) bool {m := make(map[int]int)for _, value := range nums {m[value]++}for _, value := range m {if isPrime(value) {return true}}return false
}
//判断质数
func isPrime(n int) bool {if n < 2 {return false}if n == 2 {return true}for i := 2; i*i <= n; i++ {if n%i == 0 {return false}}return true
}

Java版

class Solution {public static boolean checkPrimeFrequency(int[] nums) {Map<Integer, Integer> frequencyMap = new HashMap<>();for (int num : nums) {frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);}for (int frequency : frequencyMap.values()) {if (isPrime(frequency)) {return true;}}return false;}//判断质数private static boolean isPrime(int n) {if (n < 2) {return false;}if (n == 2) {return true;}for (int i = 2; i * i <= n; i++) {if (n % i == 0) {return false;}}return true;}
}

方法二：使用质数筛

用埃氏筛（或者欧拉筛）预处理一个布尔数组，表示哪些数是质数。
用哈希表（或者数组）统计每个元素的出现次数，如果有出现次数为质数的数，返回 true。否则返回 false。

GO版

const mx = 101var np = [mx]bool{1: true}func init() {// 质数=false，非质数=truefor i := 2; i*i < mx; i++ {if !np[i] {for j := i * i; j < mx; j += i {np[j] = true}}}
}func checkPrimeFrequency(nums []int) bool {cnt := map[int]int{}for _, x := range nums {cnt[x]++}for _, c := range cnt {if !np[c] {return true}}return false
}

Java版

class Solution {private static final int MX = 101;private static final boolean[] NOT_PRIME = new boolean[MX];private static boolean initialized = false;// 这样写比 static block 更快private void init() {if (initialized) {return;}initialized = true;NOT_PRIME[1] = true;for (int i = 2; i * i < MX; i++) {if (NOT_PRIME[i]) {continue;}for (int j = i * i; j < MX; j += i) {NOT_PRIME[j] = true; // j 是质数 i 的倍数}}}public boolean checkPrimeFrequency(int[] nums) {init();Map<Integer, Integer> cnt = new HashMap<>();for (int x : nums) {cnt.merge(x, 1, Integer::sum);}for (int c : cnt.values()) {if (!NOT_PRIME[c]) {return true;}}return false;}
}

第二题：硬币面值还原

遍历数组，处理值为0的情况：计算当前已选硬币能组成当前索引值的方式数，若大于0则返回空列表。
处理值不为0的情况：计算方式数，若等于当前值则跳过，若等于当前值减1则加入当前索引硬币，否则返回空列表。
使用动态规划计算组成目标值的方式数，更新dp数组。

GO版

func findCoins(numWays []int) []int {len := len(numWays)ans := []int{}for i := 0; i < len; i++ {if numWays[i] == 0 {sum := cal(ans, i+1)//若当前的方法数大于0，则不满足numWays[i]为0的条件，返回空列表if sum > 0 {return []int{}}}if numWays[i] != 0 {sum := cal(ans, i+1)if sum == numWays[i] {continue} else if sum+1 == numWays[i] {//将当前的面值加入列表ans = append(ans, i+1)} else {return []int{}}}}return ans
}
//计算当前的能完成target的方法数
func cal(list []int, target int) int {dp := make([]int, target+1)dp[0] = 1for _, coin := range list {for j := coin; j <= target; j++ {dp[j] = dp[j] + dp[j-coin]}}return dp[target]
}

Java版

class Solution {public List<Integer> findCoins(int[] numWays) {int len = numWays.length;List<Integer> ans = new ArrayList<>();for (int i = 0; i < len; i++) {if (numWays[i] == 0) {int sum = cal(ans, i + 1);//若当前的方法数大于0，则不满足numWays[i]为0的条件，返回空列表if (sum > 0) {return new ArrayList<>();}}if (numWays[i] != 0) {int sum = cal(ans, i + 1);if (sum == numWays[i]) {continue;} else if (sum + 1 == numWays[i]) {//将当前的面值加入列表ans.add(i + 1);} else {return new ArrayList<>();}}}return ans;}//计算当前的能完成target的方法数public int cal(List<Integer> list, int target) {int[] dp = new int[target + 1];dp[0] = 1;for (int coin : list) {for (int j = coin; j <= target; j++) {dp[j] = dp[j] + dp[j - coin];}}return dp[target];}
}