【LeetCode】堆 heap（共31題）

鏈接：https://leetcode.com/tag/heap/

【23】 Merge k Sorted Lists

【215】 Kth Largest Element in an Array （無序數組中最小/大的K個數）(2018年11月30日第一次復習)

給了一個無序數組，可能有重復數字，找到第 k 個最大的元素並且返回這個元素值。

題解：直接用直接用個堆保存數組中最大的 K 個數。時間復雜度是 O(NlogK)。

//時間復雜度是 O(NlogK), 用堆輔助。
class Solution {  3 public:  4     int findKthLargest(vector<int>& nums, int k) {  5         const int n = nums.size();  6         priority_queue<int, vector<int>, greater<int>> pq;  7         for (int i = 0; i < n; ++i) {  8             if (pq.size() < k) {  9  pq.push(nums[i]); 10             } else { 11                 if (pq.top() < nums[i]) { 12  pq.pop(); 13  pq.push(nums[i]); 14  } 15  } 16  } 17         return pq.top(); 18  } 19 };

本題可以有 O(N) 的解法，詳見《劍指offer》或者《程序員代碼面試指南》P336

做法是quickSelect。

 

【218】 The Skyline Problem（2019年2月5日，算法群打卡復習）

給了一個tuple list， 每個三元組 [a, b, h] 代表一個樓的x軸坐標是在[a, b]，樓的高度是 h，返回所有樓輪廓的左上角坐標。

題解：用了一個 multiset 來存這個樓是進來還是出去，如果是進來，就存[a, h], 如果是出去，就存[b, -h]。 然后遍歷這個 multiset，如果這個樓是進來的話，就看當前高度它是不是最高的，如果是，那么這個點在答案中，如果這個樓是出去的話，先把這個高度刪除，然后看當前這個高度是不是比剩下所有樓都高，如果是，就把當前坐標和剩下的最高的樓組成的坐標加入答案中。

class Solution {
public:
    vector<pair<int, int>> getSkyline(vector<vector<int>>& buildings) {
        for (auto& b : buildings) {
            record.insert(make_pair(b[0], b[2]));
            record.insert(make_pair(b[1], -b[2]));
        }
        vector<pair<int, int>> ret;
        for (auto& r : record) {
            bool entry = r.second > 0 ? true : false;
            int idx = r.first, h = abs(r.second);
            // printf("idx = %d, h = %d, entry = %d\n", idx, h, entry);
            if (entry) {
                if (h > getMaxHeight()) {
                    ret.push_back(make_pair(idx, h));
                }
                height.insert(h);
            } else {
                auto iter = height.find(h);
                height.erase(iter);
                if (h > getMaxHeight()) {
                    ret.push_back(make_pair(idx, getMaxHeight()));
                }
            }
        } 
        return ret;
    }
    struct kcmp {
        bool operator() (const pair<int, int>& p1, const pair<int, int>& p2) const {
            if (p1.first == p2.first) {
                return p1.second > p2.second;
            }
            return p1.first < p2.first;
        }
    };
    multiset<pair<int, int>, kcmp> record;    
    multiset<int> height;
    int getMaxHeight() {
        if (height.empty()) {return 0;}
        return *height.rbegin();
    }
};

 

【239】 Sliding Window Maximum （2019年2月18日復習）（用deque做）

求一個滑動窗口的最大值。

題解：用deque做。單調隊列。一開始還想錯了，需要多跑幾個case驗證一下正確性。時間復雜度是O(N)

class Solution {
public:
    // [1  3  -1] -3  5  3  6  7 
    // 0 1 2 
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        const int n = nums.size();
        deque<int> dq;
        vector<int> res;
        for (int i = 0; i < n; ++i) {
            if (!dq.empty() && i - dq.front() >= k) {
                dq.pop_front();
            }
            while (!dq.empty() && nums[dq.back()] < nums[i]) {
                dq.pop_back();
            }
            dq.push_back(i);
            if (i - k + 1 >= 0) {
                res.push_back(nums[dq.front()]);
            }
        }
        return res;
    }
};

 

【253】 Meeting Rooms II

題意是252的升級版，給了一個數組，數組里面的每個元素代表一個會議的開始時間和結束時間，問想安排下所有的會議，至少需要多少個會議室。

題解：這個題目在 sort 的分類里面說過，鏈接：https://www.cnblogs.com/zhangwanying/p/9914941.html 

 

【264】 Ugly Number II

返回第 N 個丑數，丑數的定義是因子只有2 ，3 ，5 的數。

題解：我們用三根指針指向ans中應該乘2， 3 ，5的位置，然后從中選出最小的元素。

 

class Solution {
public:
    int nthUglyNumber(int n) {
        vector<int> nums(n, INT_MAX);
        nums[0] = 1;
        int p1 = 0, p2 = 0, p3 = 0;
        for (int i = 1; i < n; ++i) {
            int minn = min(nums[p1] * 2, min(nums[p2] * 3, nums[p3] * 5));
            if (minn == nums[p1] * 2) {++p1;}
            if (minn == nums[p2] * 3) {++p2;}
            if (minn == nums[p3] * 5) {++p3;}
            nums[i] = minn;
        }
        return nums[n-1];
    }
};

 

 

【295】 Find Median from Data Stream （2018年11月30日，堆的題目）

給了一個數據流，設計api接口，addNum() 用於接收一個數，findMedian() 用於返回數據流的中位數。返回數據流的中位數。

Example:
addNum(1)
addNum(2)
findMedian() -> 1.5
addNum(3) 
findMedian() -> 2

題解：這題是今天看算法課看到的一個題，我們用一個大根堆存儲數據流比較小的一半數字，用一個小根堆存數據流的比較大的一半數字。（這兩個堆的元素個數要么相等，要么存小數的那個堆比存大數的那個堆多存一個數。）中位數如果兩個堆元素個數相差 1 ，那么就返回大根堆的堆頂。不然返回兩個堆頂的平均數。

class MedianFinder {
public:
    /** initialize your data structure here. */
    MedianFinder() {
        
    }
    void addNum(int num) {
        lowhalf.push(num);
        int k = lowhalf.top(); lowhalf.pop();
        highhalf.push(k);
        if (lowhalf.size() < highhalf.size()) {
            k = highhalf.top(); highhalf.pop();
            lowhalf.push(k);
        }
        return;
    }
    double findMedian() {
        if (lowhalf.size() == highhalf.size()) {
            return (double)(lowhalf.top() + highhalf.top()) / 2;
        }
        return (double)lowhalf.top();
    }
    priority_queue<int, vector<int>, greater<int>> lowhalf;  //小根堆存大的那邊
    priority_queue<int> highhalf; //大根堆存小的那邊 
};

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder obj = new MedianFinder();
 * obj.addNum(num);
 * double param_2 = obj.findMedian();
 */

 

【313】 Super Ugly Number （2019年2月9日，heap復習）

給了一個prime的數組（數組中 m 個元素），返回第 n 個 ugly number，ugly number 的定義是所有的因子都必須是 prime 數組中的元素。

題解：解法同因子是 2，3，5 的丑數，我們用 m 個指針分別指向prime數組中數應該乘的位置。然后同ugly number那題一樣。時間復雜度是 O(N*M)

 

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        const int m = primes.size();
        sort(primes.begin(), primes.end());
        vector<int> ptr(m, 0);
        vector<int> ans(n, INT_MAX);
        ans[0] = 1;
        for (int i = 1; i < n; ++i) {
            int minn = INT_MAX;
            for (int k = 0; k < m; ++k) {
                minn = min(minn, ans[ptr[k]] * primes[k]);
            }
            for (int k = 0; k < m; ++k) {
                if (minn == ans[ptr[k]] * primes[k]) {
                    ptr[k]++;
                }
            }
            ans[i] = minn;
        }
        return ans[n-1];
    }
};

 

【347】 Top K Frequent Elements

 

【355】 Design Twitter （2018年12月3日，heap專題）

實現四個 api。 

1. postTweet(userId, tweetId): Compose a new tweet.
2. getNewsFeed(userId): Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent.
3. follow(followerId, followeeId): Follower follows a followee.
4. unfollow(followerId, followeeId): Follower unfollows a followee.

Example:
Twitter twitter = new Twitter();

// User 1 posts a new tweet (id = 5).
twitter.postTweet(1, 5);

// User 1's news feed should return a list with 1 tweet id -> [5].
twitter.getNewsFeed(1);

// User 1 follows user 2.
twitter.follow(1, 2);

// User 2 posts a new tweet (id = 6).
twitter.postTweet(2, 6);

// User 1's news feed should return a list with 2 tweet ids -> [6, 5].
// Tweet id 6 should precede tweet id 5 because it is posted after tweet id 5.
twitter.getNewsFeed(1);

// User 1 unfollows user 2.
twitter.unfollow(1, 2);

// User 1's news feed should return a list with 1 tweet id -> [5],
// since user 1 is no longer following user 2.
twitter.getNewsFeed(1);

題解：用個 unordered_map 標記用戶關系，然后一個 vector 存儲 twitter post

class Twitter {
public:
    /** Initialize your data structure here. */
    Twitter() {
        
    }
    
    /** Compose a new tweet. */
    void postTweet(int userId, int tweetId) {
        twit.push_back(make_pair(userId, tweetId));
    }
    
    /** Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent. */
    vector<int> getNewsFeed(int userId) {
        set<int> people = followRelation[userId];
        people.insert(userId);
        vector<int> ret;
        int idx = twit.size() - 1, cnt = 0;;
        while (cnt < 10 && idx >= 0) {
            auto p = twit[idx--];
            int uid = p.first, tid = p.second;
            if (people.find(uid) != people.end()) {
                ret.push_back(tid);
                cnt++;
            }
        }
        return ret;
    }
    
    /** Follower follows a followee. If the operation is invalid, it should be a no-op. */
    void follow(int followerId, int followeeId) {
        followRelation[followerId].insert(followeeId);
    }
    
    /** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */
    void unfollow(int followerId, int followeeId) {
        if (followRelation.find(followerId) == followRelation.end()) { return; }
        if (followRelation[followerId].find(followeeId) == followRelation[followerId].end()) {return;}
        followRelation[followerId].erase(followeeId);
    }
    
    unordered_map<int, set<int>> followRelation;
    vector<pair<int, int>> twit;  // (user, id)
};

/**
 * Your Twitter object will be instantiated and called as such:
 * Twitter obj = new Twitter();
 * obj.postTweet(userId,tweetId);
 * vector<int> param_2 = obj.getNewsFeed(userId);
 * obj.follow(followerId,followeeId);
 * obj.unfollow(followerId,followeeId);
 */

  

【358】 Rearrange String k Distance Apart

 

【373】 Find K Pairs with Smallest Sums （2018年12月1日）

給了兩個整數數組 nums1 和 nums2， 和一個整數 k，求 nums1 和 nums2 的笛卡爾積中（就是 nums1 中選擇一個數字 n1，nums2 中選擇一個數字 n2 組成pair），sum 最小的 k 個pair。

題解：本題就是自定義排序的大根堆，pair排序的規則是 sum 大的在堆頂。

class Solution {
public:
    vector<pair<int, int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k) {
        if (nums1.empty() || nums2.empty()) {return vector<pair<int, int>>();}
        priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> pq;
        for (auto n1 : nums1) {
            for (auto n2 : nums2) {
                pq.push(make_pair(n1, n2));
                if (pq.size() > k) { pq.pop(); }
            }
        }
        vector<pair<int, int>> ret; //可能nums1和nums2的組合的pair不夠 k 個，所以不能一開始初始化為 k 個結果。
        while (!pq.empty()) {
            ret.push_back(pq.top());
            pq.pop();
        }
        return ret;
    }
    struct cmp{
        bool operator()(const pair<int, int>& p1, const pair<int, int>& p2) {
            return p1.first + p1.second < p2.first + p2.second;
        }
    };
};

  

【378】 Kth Smallest Element in a Sorted Matrix

【407】 Trapping Rain Water II

【451】 Sort Characters By Frequency

 

【502】 IPO （2019年2月9日，算法群打卡）

給了一個 n 個項目，每個項目都有一個能力值 capital[i] 和一個利益值 profits[i]，一開始有一個初始的能力值 W，要求是從這 n 個項目中選取 k 個項目，每次選取的項目的能力值capital[i]必須小於等於當前的人的能力值。每次做完一個項目，這個項目的利益值就會加在現在的能力值上面。問做完 k 個項目之后，最后能力值最大是多少。

題解：題目不難，重點在於利用heap實現。我們想着把 capital 數組 和 profits 數組綜合成一個數組，然后給新的數組排序，排序的方式按照capital從小到大，然后 profits 隨意。

然后利用一個 heap， 每次選擇一個項目的時候，都把小於當前能力值的項目放進heap，然后從 heap 中彈出一個當前利益值最大的項目，作為當前項目的選擇。

時間復雜度是 nlog(n)

class Solution {
public:
    int findMaximizedCapital(int k, int W, vector<int>& Profits, vector<int>& Capital) {
        const int n = Profits.size();
        vector<pair<int, int>> project(n);
        for (int i = 0; i < n; ++i) {
            project[i] = make_pair(Capital[i], Profits[i]);
        }
        sort(project.begin(), project.end());
        priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> pq;
        int idx = 0;
        for (int i = 0; i < k; ++i) {
            while (idx < n && project[idx].first <= W) {
                pq.push(project[idx]);
                ++idx;
            }
            if (pq.empty()) { break; }
            pair<int, int> p = pq.top();
            pq.pop();
            W += p.second;
        }
        return W;
    }
    struct cmp {
        bool operator() (const pair<int, int>& p1, const pair<int, int>& p2) const {
            return p1.second < p2.second;
        }  
    };
};

 

【659】 Split Array into Consecutive Subsequences

 

【692】 Top K Frequent Words （2018年11月30日）

給了一個string類型的數組 words，在給定整數k，請嚴格按照出現頻率順序打印出現次數前 k 名的字符串。（出現頻率相同的按照字典順序打印）

題解：用個 unordered_map 存儲每個單詞出現的次數，然后建立一個小根堆，里面存 k 個pair，（小根堆自定義排序class），然后遍歷一遍map，把最后剩下在堆里的 k 個pair的字符串提取出來。 

class Solution {
public:
    vector<string> topKFrequent(vector<string>& words, int k) {
        const int n = words.size();
        unordered_map<string, int> mp;
        for (auto w : words) { mp[w]++; }

        priority_queue<pair<string, int>, vector<pair<string, int>>, cmp> pq;  
        for (auto ele : mp) {
            pq.push(ele);
            if (pq.size() > k) { pq.pop(); }
        }
        vector<string> ret(k, "");
        int idx = k-1;
        while (!pq.empty()) {
            auto p = pq.top();
            pq.pop();
            ret[idx--] = p.first;
        }
        return ret;
    }
    //自定義比較函數，為啥我想小的排前面要寫大於。。
    struct cmp {
        bool operator()(const pair<string, int> a, const pair<string, int>& b) {
            if (a.second == b.second) {
                return a.first < b.first;
            }
            return a.second > b.second;
        }
    };
};

    //自定義比較函數，為啥我想小的排前面要寫大於。。（優先隊列的自定義比較函數要搞明白，還是不懂啊） 

 

【703】 Kth Largest Element in a Stream

給個數字流，總是返回最大的第K個元素

解法就是用一個只有K個元素的堆，維護這這些數字里面從最大的第K個到最大的元素。

[最小元素...第K大的元素..最大元素]， 這個堆總維護后半段的K個

【719】 Find K-th Smallest Pair Distance

 

【743】 Network Delay Time （2018年12月4日）

一個社交網絡里面有 N 個結點，標號為 1 ～ N，給了一個 times 數組，里面的元素 t(u, v, w) 代表從 u結點 到 v結點需要 w 的時間，給了一個源點 K， 問從 K 開始傳播一條信息，到每個結點需要至少多少時間，如果從 K 到一個結點不可達，就返回 -1。

題解：floyed求最短路。

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        vector<vector<int>> g(N+1, vector<int>(N+1, INT_MAX));
        for (auto t : times) {
            int u = t[0], v = t[1], cost = t[2];
            g[u][v] = cost;
        }
        //floyed
        for (int f = 1; f <= N; ++f) {
            for (int i = 1; i <= N; ++i) {
                g[i][i] = 0;
                for (int j = 1; j <= N; ++j) {
                    if (g[i][f] != INT_MAX && g[f][j] != INT_MAX) {
                        g[i][j] = min(g[i][f] + g[f][j], g[i][j]);
                    }
                }
            }
        }
        int ret = INT_MIN;
        for (int i = 1; i <= N; ++i) {
            if (i == K) {continue;}
            if (g[K][i] == INT_MAX) {
                ret = -1;
                break;
            }
            ret = max(ret, g[K][i]);
        }             
        return ret;            
    }
};

此外，我沒看出來跟 heap 有啥關系。

 

【759】 Employee Free Time

【767】 Reorganize String

【778】 Swim in Rising Water

【786】 K-th Smallest Prime Fraction

 

【787】 Cheapest Flights Within K Stops （2019年2月9日）

2019年4月6日更新。heap 是個好東西。

給定了一張有向圖，還有邊的權重，問最多經過K個結點的情況下，從 src 到 dst 的最小花費。

題解：可以用 dijkstra 的思路，只不過這個題多了一個條件是最多經過 K 個結點，那么我們就可以在放入heap的結點中，新增一個緯度，叫做經過的站數。

 

//dijkstra 的思路，加上一個K站的條件
class Solution {
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int K) {
        vector<vector<int>> graph(n, vector<int>(n, -1));
        for (int u = 0; u < n; ++u) { graph[u][u] = 0; }
        for (auto& f : flights) {
            int u = f[0], v = f[1], w = f[2];
            graph[u][v] = w;
        }
        priority_queue<vector<int>, vector<vector<int>>, greater<vector<int>>> pq; //{cost, city, how many stops visited}
        pq.push({0, src, 0});
        while (!pq.empty()) {
            auto temp = pq.top(); pq.pop();
            int price = temp[0], city = temp[1], stops = temp[2]; 
            if (city == dst) {return price;}
            for (int v = 0; v < n; ++v) {
                if (graph[city][v] == -1 || city == v) {continue;}
                if (stops <= K) {
                    pq.push({price + graph[city][v], v, stops + 1});
                }
            }
        }
        return -1;
    }
};

 

 

 

【818】 Race Car

 

【857】 Minimum Cost to Hire K Workers （2019年3月15日，google tag）

題目給了兩個規則讓我們設計一個花費最小的辦法雇佣K個工人。

1. Every worker in the paid group should be paid in the ratio of their quality compared to other workers in the paid group. 必須按照unitWage最大的那個工人的unitWage來付所有人的錢。
2. Every worker in the paid group must be paid at least their minimum wage expectation.

題解：我們考慮如果將wage[i]/quality[i]作為評價指標來進行排序意味着什么？unitWage從小到大排序。 （wisdompeak大佬的題解）

wage[i]/quality[i]最高的那位,意味着最不實惠的工人，它拉高了unitWage，使得其他工人都必須按照這個unitWage乘以各自的quality拿工資．但轉念一想，如果我們必須雇佣這個最不實惠的工人的話，那么剩下的工人該如何選擇呢？顯然我們只要選K-1個quality最低的工人，他們可以拉高那個＂最不實惠工人＂的quality比重，從而減少其他工人的quality比重，從而降低總工資．

我們再考慮，如果選擇了wage[i]/quality[i]第二高的那位，那么我們就在接下來的 N-2 個人里面選擇 K-1 個quality最底的工人即可．

由此貪心法的最優策略就出來了．實際操作中，我們根據 wage[i]/quality[i] 從低到高進行處理．

class Solution {
public:
    double mincostToHireWorkers(vector<int>& quality, vector<int>& wage, int K) {
        int n = quality.size();
        vector<pair<double, int>> workers(n);
        for (int i = 0; i < n; ++i) {
            workers[i] = {(double)wage[i]/quality[i], quality[i]};
        }
        sort(workers.begin(), workers.end());
        int totQuality = 0;
        double res = DBL_MAX;
        priority_queue<int, vector<int>, less<int>> pq;
        for (int i = 0; i < n; ++i) {
            double unitWage = workers[i].first;
            int qua = workers[i].second;
            if (pq.size() == K) {
                totQuality -= pq.top();
                pq.pop();
            }
            totQuality += qua;
            pq.push(qua);
            if (pq.size() == K) {
                res = min(res, unitWage * totQuality);
            }
        }
        return res;
    }
};

 

【864】 Shortest Path to Get All Keys

【871】 Minimum Number of Refueling Stops

【882】 Reachable Nodes In Subdivided Graph