力扣 第455场周赛(A~C)

A.检查元素频次是否为质数

签到题。

class Solution {
public:
    bool isprime(int x){
        if(x<=1) return false;
        for(int i=2;i<=x/i;i++){
            if(x%i==0)
                return false;
        }
        return true;
    }
    bool checkPrimeFrequency(vector<int>& nums) {
        vector<int> cnt(110,0);
        for(int i=0;i<nums.size();i++)
            cnt[nums[i]]++;
        for(int i=0;i<110;i++){
            if(isprime(cnt[i]))
                return true;
        }
        return false;
    }
};

B.硬币面值还原

假设目前有一个硬币集合，其中每个元素都不同的面值，现在给定这个集合表示每个数的方案数目nums，要求这个集合中的元素。

可以观察到，如果某个数x的方案数为1的话，这个数肯定在这个集合中，并且会为大于x的数y贡献 f [ y-x ]个方案，其中f[i]表示构成i有多少种方案，显然f[0]=1.

那么，进一步的，我们枚举i->1~n，当 f [ i ] == nums [ i ]时，表示以目前的coins已经可以拼出i了，直接continue。当f [ i ] == nums [ i ] - 1时我，我们直接加上i，使得i的方案数+1，同时使用i来更新大于i的所有f值。否则，表示无法拼出。

class Solution {
public:
    vector<int> findCoins(vector<int>& nums) {
        int n=nums.size();
        if(n<=0) return {};
        vector<int> f(n+1,0);//f[i]表示以目前的coins，i有多少种表示方式
        f[0]=1;
        vector<int> coins;
        for(int i=1;i<=n;i++){
            int target = nums[i-1];
            if(f[i]>target) return {};
            else if(f[i]==target) continue;
            else if(f[i]==target-1){
                coins.push_back(i);
                for(int j=i;j<=n;j++){
                    f[j]+=f[j-i];
                }
            }else{
                return {};
            }
        }
        return coins;
    }
};

C.使叶子路径成本相等的最小增量

给定一棵树，每个节点上有权值，每次操作能使得某个节点的值加上任意值，问最少多少次操作，使得从根到叶子节点的路径的路径权值都相等。

建树，然后每次dfs返回子树权值和子树需要的操作次数，那么当前树的权值即为子树权值最大值加上当前节点的值，操作次数则为子树操作次数之和加上当前使得所有子树相等的操作次数。

typedef long long LL;
class Solution {
public:
    pair<LL,int> dfs(int u,int parent,vector<vector<int>>& g,vector<int>& cost){
        vector<LL> child_v;
        int child_add=0;
        for(int i=0;i<g[u].size();i++){
            int v=g[u][i];
            if(v==parent) continue;
            auto tmp=dfs(v,u,g,cost);
            child_v.push_back(tmp.first);
            child_add+=tmp.second;
        }
        if(child_v.empty()) return {cost[u],0};
        LL maxx=*max_element(child_v.begin(),child_v.end());
        int total_add=child_add;
        for(int i=0;i<child_v.size();i++){
            if(child_v[i]<maxx)
                total_add++;
        }
        return {maxx+cost[u],total_add};
    }
    int minIncrease(int n, vector<vector<int>>& edges, vector<int>& cost) {
        vector<vector<int>> g(n,vector<int>());
        for(int i=0;i<edges.size();i++){
            int a=edges[i][0];
            int b=edges[i][1];
            g[a].push_back(b);
            g[b].push_back(a);
        }
        auto res=dfs(0,-1,g,cost);
        return res.second;
    }
};