《六月集训》（第二十一天）——堆（优先队列）

前言

        欢迎大家积极在评论区留言发表自己的看法，知无不言，言无不尽，养成每天刷题的习惯，也可以自己发布优质的解题报告，供社区一同鉴赏，吸引一波自己的核心粉丝。
        今天是六月集训第二十一天：堆（优先队列）🔥🔥🔥🔥🔥

一、练习题目

        2285. 道路的最大总重要性
        1405. 最长快乐字符串
        675. 为高尔夫比赛砍树
        659. 分割数组为连续子序列

二、算法思路

• 1、2285. 道路的最大总重要性：贪心加一个大顶堆:。fire:🔥
• 2、1405. 最长快乐字符串：贪心加大顶堆。🔥🔥
• 3、675. 为高尔夫比赛砍树：这题还不会。🔥🔥🔥🔥🔥
• 4、659. 分割数组为连续子序列：这道题自己想是没想到，看了一下题解还没彻底理解。🔥🔥🔥🔥

三、源码剖析

// 2285. 道路的最大总重要性
class Solution {
    struct Node{
        int v;
        int deg;
        Node() {}
        Node(int _v, int _d) : v(_v), deg(_d) {} 
        bool operator < (const Node & o) const {
            return deg < o.deg;
        }
    }; //(1)
public:
    long long maximumImportance(int n, vector<vector<int>>& roads) {
        int deg[50010], val[50010];
        int id = n;
        memset(deg, 0, sizeof(deg));
        for(int i = 0; i < roads.size(); ++i) {
            ++deg[roads[i][0]];
            ++deg[roads[i][1]];
        } 
        priority_queue<Node> q;
        for(int i = 0; i < n; ++i) {
            q.push(Node(i, deg[i]));
        }  //(2)

        while (!q.empty())
        {
            Node n = q.top();
            q.pop();
            val[n.v] = id;
            --id;
        } //(3)

        long long ans = 0;

        for(int i = 0; i < roads.size(); ++i) {
            ans += val[roads[i][0]] + val[roads[i][1]];
        } //(4)
        return ans;
    }
};

• 1、定义一个结构体，有结点的值和入度，重载小于按照入度大小排序；
• 2、统计每个结点的入度，并放入堆中，并且是一个大顶堆；
• 3、由于是一个大顶堆，那就好办了，贪心的将最开始的赋予权重最大的值，以此类推；
• 4、最后返回所有值的总和即可。

// 1405. 最长快乐字符串
class Solution {
        struct Node{
        char ch;
        int cnt;
        Node() {}
        Node(char _ch, int _c) : ch(_ch), cnt(_c) {} 
        bool operator < (const Node & o) const {
            return cnt < o.cnt;
        }
    }; //(1)
public:
    string longestDiverseString(int a, int b, int c) {
        priority_queue<Node> q;
        if(a) q.push(Node('a', a));
        if(b) q.push(Node('b', b));
        if(c) q.push(Node('c', c)); //(2)

        string ret = "", pre = "";
        while (!q.empty())
        {
            Node n = q.top();
            q.pop();
            if(pre == "aa" && n.ch == 'a' || pre == "bb" && n.ch == 'b' || pre == "cc" && n.ch == 'c') { //(3)
                if(q.empty()) {
                    return ret;
                }
                Node next = q.top();
                q.pop();
                ret.push_back(next.ch);
                if(--next.cnt) {
                    q.push(next);
                }
                q.push(n);
                pre = "";
                pre.push_back(next.ch);
            } else {
                ret.push_back(n.ch);
                pre.push_back(n.ch);

                if(--n.cnt) {
                    q.push(n);
                }

                if(pre.size() > 2) {
                    char pre1 = pre[pre.size() - 2];
                    char pre2 = pre[pre.size() - 1];
                    pre = "";
                    pre += pre1;
                    pre += pre2;
                }
            } //(4)

        }
        return ret;
    }
};

• 1、和上一题一样，没啥好说的；
• 2、把数字放入堆中，而且是一个大顶堆；
• 3、判断是不是“aaa”这种要重复三次的情况了，是的话换一个单词比如a要重复三次了，下一个多的可能是b，然后再判断下b是不是用完，没用完放回堆中，同理a也是没用完的需要放回去，然后pre进行更新，现在从a改为b了；
• 4、不是重复的情况，那就ret和pre都加一个字符，然后判断n有没有用完，没有的话放回堆继续循环，同时看下pre是不超过2个，因为最多看三个重，多了就删去其他留倒数两个。

// 675. 为高尔夫比赛砍树

• 1、

// 659. 分割数组为连续子序列

• 1、