LeetCode第344场周赛

最新推荐文章于 2024-07-20 23:08:39 发布

Meet.

最新推荐文章于 2024-07-20 23:08:39 发布

阅读量75

点赞数

文章标签： leetcode 算法深度优先

本文链接：https://blog.csdn.net/qq_44867112/article/details/130540550

版权

2023.5.7LeetCode第344场周赛

A. 找出不同元素数目差数组

思路

枚举区间内所有数，使用集合统计不同的数目

代码

class Solution {
public:
    vector<int> distinctDifferenceArray(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n);
        for (int i = 0; i < n; i ++ ) {
            unordered_set<int> a, b;
            for (int j = 0; j <= i; j ++ ) a.insert(nums[j]);
            for (int j = i + 1; j < n; j ++ ) b.insert(nums[j]);
            ans[i] = (int)a.size() - (int)b.size();
        }
        return ans;
    }
};

B. 频率跟踪器

思路

使用两个哈希表统计，一个记录数出现的次数，一个记录频率出现的次数

代码

class FrequencyTracker {
public:
    unordered_map<int, int> mp, cnt;
    
    FrequencyTracker() {

    }
    
    void add(int number) {
        mp[number] ++ ;
        if (mp[number] > 1)
            cnt[mp[number] - 1] -- ;
        cnt[mp[number]] ++ ;
    }
    
    void deleteOne(int number) {
        if (mp[number] > 0) {
            mp[number] -- ;
            cnt[mp[number] + 1] -- ;
            if (mp[number] > 0)
                cnt[mp[number]] ++ ;
        }
    }
    
    bool hasFrequency(int frequency) {
        return cnt[frequency] > 0;
    }
};

/**
 * Your FrequencyTracker object will be instantiated and called as such:
 * FrequencyTracker* obj = new FrequencyTracker();
 * obj->add(number);
 * obj->deleteOne(number);
 * bool param_3 = obj->hasFrequency(frequency);
 */

C. 有相同颜色的相邻元素数目

思路

枚举每次操作，判断对相邻数的影响

代码

class Solution {
public:
    vector<int> colorTheArray(int n, vector<vector<int>>& queries) {
        int cur = 0;
        vector<int> ans, a(n);
        for (auto x : queries) {
            int i = x[0], color = x[1];
            if (i && a[i] == a[i - 1] && a[i]) cur -- ;
            if (i + 1 < n && a[i] == a[i + 1] && a[i]) cur -- ;
            a[i] = color;
            if (i && a[i] == a[i - 1] && a[i]) cur ++ ;
            if (i + 1 < n && a[i] == a[i + 1] && a[i]) cur ++ ;
            ans.push_back(cur);
        }
        return ans;
    }
};

D. 使二叉树所有路径值相等的最小代价

思路

从下往上dfs，求出每个点到叶节点的最长路径值
以根节点的最长路径值为目标
再从上往下dfs，记录已经走过的路径值，和到叶节点的最大路径值进行比较，小于目标则加到目标

代码

class Solution {
public:
    vector<int> d, c;
    int n;
    int ans;
    
    void dfs(int u) {
        if (u > n) return;
        dfs(u * 2);
        dfs(u * 2 + 1);
        if (u * 2 <= n) {
            d[u] += max(d[u * 2], d[u * 2 + 1]);
        }
    }
    
    void dfs2(int u, int sum, int m) {
        if (u > n) return;
        if (sum + d[u] < m) {
            c[u - 1] += m - (sum + d[u]);
            ans += m - (sum + d[u]);
        } 
        sum += c[u - 1];
        dfs2(u * 2, sum, m);
        dfs2(u * 2 + 1, sum, m);
    }
    
    int minIncrements(int _n, vector<int>& cost) {
        c = cost;
        n = _n;
        d.resize(n + 1);
        for (int i = 0; i < n; i ++ )
            d[i + 1] = cost[i];
        dfs(1);
        int m = d[1];
        ans = 0;
        dfs2(1, 0, m);
        return ans;
    }
};