给你一个整数数组 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
class Solution {
public:
bool solve(int num){
for(int i=2;i<=sqrt(num);i++){
if(num%i==0) return false;
}
return true;
}
bool checkPrimeFrequency(vector<int>& nums) {
unordered_map<int,int> mp;
for(auto& x:nums){
mp[x]++;
}
for(auto& x:mp){
int n=x.second;
if(solve(n)&&(n>=2)) return true;
}
return false;
}
};给你一个 从 1 开始计数 的整数数组 numWays，其中 numWays[i] 表示使用某些 固定 面值的硬币（每种面值可以使用无限次）凑出总金额 i 的方法数。每种面值都是一个 正整数 ，并且其值 最多 为 numWays.length。
然而，具体的硬币面值已经 丢失 。你的任务是还原出可能生成这个 numWays 数组的面值集合。
返回一个按从小到大顺序排列的数组，其中包含所有可能的 唯一 整数面值。
如果不存在这样的集合，返回一个 空 数组。
示例 1：
输入： numWays = [0,1,0,2,0,3,0,4,0,5]
输出： [2,4,6]
class Solution {
public:
vector<int> findCoins(vector<int>& numWays) {
int n=numWays.size();
vector<int> dp(n+1,0);
dp[0]=1;
vector<int> res;
for(int i=1;i<=n;i++){
int cur=dp[i];
int tar=numWays[i-1];
if(cur>tar) return {};
if(cur==tar) continue;
if(cur+1==tar){
res.push_back(i);
for(int j=i;j<=n;j++){
dp[j]+=dp[j-i];
}
}else{
return {};
}
}
return res;
}
};
// numWays[i]和i+1/numWays[i-1]和i
// 已知方法数, 求是由那些硬币构成的©leetcode给你一个整数 n，以及一个无向树，该树以节点 0 为根节点，包含 n 个节点，节点编号从 0 到 n - 1。这棵树由一个长度为 n - 1 的二维数组 edges 表示，其中 edges[i] = [ui, vi] 表示节点 ui 和节点 vi 之间存在一条边。
每个节点 i 都有一个关联的成本 cost[i]，表示经过该节点的成本。路径得分 定义为路径上所有节点成本的总和。
你的目标是通过给任意数量的节点 增加 成本（可以增加任意非负值），使得所有从根节点到叶子节点的路径得分 相等 。
返回需要增加成本的节点数的 最小值 。
示例 1：
输入： n = 3, edges = [[0,1],[0,2]], cost = [2,1,3]
输出： 1
using pii=pair<int,int>;
class Solution {
public:
int minIncrease(int n, vector<vector<int>>& edges, vector<int>& cost) {
vector<vector<int>> g(n);
for(auto& e:edges){
g[e[0]].push_back(e[1]);
g[e[1]].push_back(e[0]);
}
function<pii(int,int)> dfs=[&](int u, int p)->pii{
bool is_leaf=true;
int maxSum=0;
int total_adds=0;
vector<pii> ch;
for(int v:g[u]){
if(v==p) continue;
is_leaf=false;
auto[sum_v,adds_v]=dfs(v,u);
maxSum=max(maxSum,sum_v);
ch.push_back({sum_v,adds_v});
}
if(is_leaf) return {cost[u],0};
for(auto& c: ch){
auto [sum_v, adds_v]=c;
if (sum_v<maxSum){
total_adds+=adds_v+1;
} else {
total_adds += adds_v;
}
}
return {cost[u]+maxSum,total_adds};
};
auto [_, ans]=dfs(0,-1);
return ans;
}
};有 n 名人员在一个营地，他们需要使用一艘船过河到达目的地。这艘船一次最多可以承载 k 人。渡河过程受到环境条件的影响，这些条件以 周期性 的方式在 m 个阶段内变化。
每个阶段 j 都有一个速度倍率 mul[j]：如果 mul[j] > 1，渡河时间会变长。
如果 mul[j] < 1，渡河时间会缩短。
每个人 i 都有一个划船能力，用 time[i] 表示，即在中性条件下（倍率为 1 时）单独渡河所需的时间（以分钟为单位）。规则：
从阶段 j 出发的一组人 g 渡河所需的时间（以分钟为单位）为组内成员的 最大 time[i]，乘以 mul[j] 。
该组人渡河所需的时间为 d，阶段会前进 floor(d) % m 步。
如果还有人留在营地，则必须有一人带着船返回。设返回人的索引为 r，返回所需时间为 time[r] × mul[current_stage]，记为 return_time，阶段会前进 floor(return_time) % m 步。
返回将所有人渡河所需的 最少总时间 。如果无法将所有人渡河，则返回 -1。
示例 1：
输入： n = 1, k = 1, m = 2, time = [5], mul = [1.0,1.3]
输出： 5.00000
解释：
第 0 个人从阶段 0 出发，渡河时间 = 5 × 1.00 = 5.00 分钟。
所有人已经到达目的地，因此总时间为 5.00 分钟。
示例 2：输入： n = 3, k = 2, m = 3, time = [2,5,8], mul = [1.0,1.5,0.75]
输出： 14.50000
解释：
最佳策略如下：
第 0 和第 2 个人从阶段 0 出发渡河，时间为 max(2, 8) × mul[0] = 8 × 1.00 = 8.00 分钟。阶段前进 floor(8.00) % 3 = 2 步，下一个阶段为 (0 + 2) % 3 = 2。
第 0 个人从阶段 2 独自返回营地，返回时间为 2 × mul[2] = 2 × 0.75 = 1.50 分钟。阶段前进 floor(1.50) % 3 = 1 步，下一个阶段为 (2 + 1) % 3 = 0。
第 0 和第 1 个人从阶段 0 出发渡河，时间为 max(2, 5) × mul[0] = 5 × 1.00 = 5.00 分钟。阶段前进 floor(5.00) % 3 = 2 步，最终阶段为 (0 + 2) % 3 = 2。
所有人已经到达目的地，总时间为 8.00 + 1.50 + 5.00 = 14.50 分钟。
示例 3：输入： n = 2, k = 1, m = 2, time = [10,10], mul = [2.0,2.0]
输出： -1.00000
解释：
由于船每次只能载一人，因此无法将两人全部渡河，总会有一人留在营地。因此答案为 -1.00。
提示：
1 <= n == time.length <= 12
1 <= k <= 5
1 <= m <= 5
1 <= time[i] <= 100
m == mul.length
0.5 <= mul[i] <= 2.0
class Solution {
public:
double minTime(int n, int k, int m, vector<int>& time, vector<double>& mul) {
}
};感谢大家的点赞和关注，你们的支持是我创作的动力！