Leetcode之Greedy和Heap

Heap

692. Top K Frequent Words

class Solution {
private:
    typedef pair<string,int>Node;
    typedef function<bool(const Node&, const Node&)>Compare;
public:
    vector<string> topKFrequent(vector<string>& words, int k) {
       unordered_map<string, int> count;
        for(const string str:words) {
            count[str]++;
        }
        Compare comparator = [](const Node& a, const Node& b) {
            if(a.second == b.second){
                return a.first < b.first;
            }
            return a.second>b.second;
        };

        priority_queue<Node,vector<Node>,Compare>q(comparator);

        for(const auto &kv: count) {
            q.push(kv);
            if(q.size()>k) {
                q.pop();
            }
        }

        vector<string> ans;
        while(!q.empty()) {
            ans.push_back(q.top().first);
            q.pop();
        }
        std::reverse(ans.begin(),ans.end());
        return ans;
    }
};

295. Find Median from Data Stream

class MedianFinder {
public:
    /** initialize your data structure here. */
    priority_queue<int, vector<int>, less<int> > smaller; // max heap
    priority_queue<int, vector<int>, greater<int> > larger; // min heap
    MedianFinder() {

    }

    void addNum(int num) {
        if(smaller.empty() || num <= smaller.top()) {
            smaller.push(num);
        }    
        else{
            larger.push(num);
        }
        if(smaller.size()+1<larger.size()) {
            smaller.push(larger.top());
            larger.pop();
        }
        else if(smaller.size()>larger.size()+1){
            larger.push(smaller.top());
            smaller.pop();
        }
    }

    double findMedian() {
        if(smaller.size() == larger.size()) {
            return (static_cast<double>(smaller.top() + larger.top()))/2.0;
        }
        else if(smaller.size() > larger.size()) {
            return static_cast<double>(smaller.top());
        }
        else {
            return static_cast<double>(larger.top());
        }
    }
};

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

class MedianFinder {
public:
    /** initialize your data structure here. */
    multiset<int> ms;
    multiset<int>::iterator left; // left pointer
    multiset<int>::iterator right; // right pointer
    MedianFinder(): left(ms.cend()), right(ms.cend()){

    }

    void addNum(int num) {
        if(ms.empty()) {
            left = right = ms.insert(num);
            return;
        }
        ms.insert(num);
        if(ms.size()&1) {
            if(num >= *right) {
                left = right;
            }
            else {
                left = --right;
            }
        }
        else {
            if(num >= *right) {
                right++;
            }
            else {
                left--;
            }
        }
    }

    double findMedian() {
        return static_cast<double>((*left) + (*right))/2.0;
    }
};

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

Greedy

321. Create Maximum Number

class Solution {
public:

    vector<int> maxNumber2(vector<int> nums1, vector<int> nums2) {
        vector<int> ans;
        int idx1 = 0;
        int idx2 = 0;
        while(idx1 < nums1.size() || idx2 < nums2.size()) { 
            if(lexicographical_compare(nums1.begin()+idx1,nums1.end(), nums2.begin()+idx2, nums2.end())) {
                ans.push_back(nums2[idx2++]);
            }
            else {
                ans.push_back(nums1[idx1++]);
            }
        }

        return ans;
    }

    vector<int> maxNumber3(vector<int>& nums, int k) {
        vector<int> ans(k,0);
        int j=0;
        for(int i=0;i<nums.size();i++){
            while(j>0 && nums[i]>ans[j-1] && nums.size()-i>k-j) {
                j--;
            }
            if(j<k)
                ans[j++]=nums[i];
        }
        return ans;
    }

    vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {
        int n1 = nums1.size();
        int n2 = nums2.size();
        vector<int> ans;
        for(int k1 = max(k-n2, 0); k1 <= min(n1, k); k1++) {
            ans=max(ans, maxNumber2(maxNumber3(nums1, k1), maxNumber3(nums2, k - k1)));
        }
        return ans;
    }
};

675. Cut Off Trees for Golf Event

class Solution {
public:
    int BFS(vector<vector<int>> forest, int ty, int tx, int cy, int cx) {
        int h = forest.size();
        int w = forest[0].size();
        int step = 0;
        queue<pair<int, int>> visited;
        visited.push(make_pair(cy, cx));
        int dirs[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
        while(visited.size()) {
            int tmp = visited.size();
            for(int idx = 0; idx < tmp; idx++) {
                auto tp = visited.front();
                int tmp_y = tp.first;
                int tmp_x = tp.second;

                if(tmp_y == ty && tmp_x == tx) {
                    return step;
                }

                visited.pop();
                forest[tmp_y][tmp_x] = 0;
                for(int i = 0; i < 4; i++) {
                    int tmp_y_ = tmp_y+dirs[i][0];
                    int tmp_x_ = tmp_x+dirs[i][1];
                    if(tmp_y_ >= 0 && tmp_y_< h) {
                        if(tmp_x_>= 0 && tmp_x_< w) {
                            if(forest[tmp_y_][tmp_x_] > 0) {
                                visited.push(make_pair(tmp_y_, tmp_x_));
                                forest[tmp_y_][tmp_x_] = 0;
                            }
                        }
                    }
                }
            }
            step++;
        }
        return INT_MAX;
    }

    int cutOffTree(vector<vector<int>>& forest) {
        int ans = 0;
        int h = forest.size();
        if(!h) {
            return ans;
        }
        int w = forest[0].size();
        vector<tuple<int, int, int> > trees;
        for(int idx1 = 0; idx1 < h; idx1++) {
            for(int idx2 = 0; idx2 < w; idx2++) {
                if(forest[idx1][idx2] > 1) {
                    trees.emplace_back(forest[idx1][idx2], idx1, idx2);
                }
            }
        }
        // cout << trees.size() << endl;
        sort(trees.begin(), trees.end());

        int len = trees.size();
        int cx = 0, cy = 0;
        for(int idx = 0; idx < len; idx++) {
            int ty = get<1>(trees[idx]);
            int tx = get<2>(trees[idx]);
            int steps = BFS(forest, ty, tx, cy, cx);
            // cout << steps << endl;
            if(steps == INT_MAX) {
                return -1;
            }
            ans += steps;
            cy = ty; 
            cx = tx; 
        }

        return ans;
    }
};

621. Task Scheduler

（k-1）*（n+1）+ p

class Solution {
public:
    int leastInterval(vector<char>& tasks, int n) {
        int num = tasks.size();
        vector<int> rec(26, 0);
        for(char c:tasks) {
            rec[c-'A']++;
        }
        sort(rec.begin(), rec.end(), std::greater<int>());
        int ans = (rec[0]-1)*(n+1);
        int idx = 0;
        int tmp = rec[0];
        while(idx < 26 && rec[idx] == tmp) {
            ans++;
            idx++;
        }
        return max(num, ans);
    }
};

409. Longest Palindrome

class Solution {
public:
    int longestPalindrome(string s) {
        int len = s.size();
        int letter[52] = {0};
        for(char c:s) {
            if(islower(c)) {
                letter[c-'a']++;
            }
            else {
                letter[c-'A'+26]++;
            }
        }
        int isOdd = 0;
        int ans = 0;
        for(int idx = 0; idx < 52; idx++) {
            ans += (letter[idx] >> 1) << 1;
            if(!isOdd) {
                isOdd = letter[idx] & 1; 
            }
        }
        return ans + isOdd;
    }
};

611. Valid Triangle Number

class Solution {
public:
    int triangleNumber(vector<int>& nums) {
        if(nums.size() < 3) {
            return 0;
        }
        sort(nums.begin(), nums.end());
        int len = nums.size();
        int ans = 0;
        for(int idx1 = len - 1; idx1 >= 2; idx1--) {
            int idx2 = idx1 - 1;
            int idx3 = 0;
            while(idx3 < idx2) {
                if(nums[idx2] + nums[idx3] > nums[idx1]) {
                    ans += idx2 - idx3;
                    idx2--;
                }
                else {
                    idx3++;
                }
            }
        }
        return ans;
    }
};

455. Assign Cookies

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        int res = 0;
        int len_g = g.size();
        int len_s = s.size();
        int idx_g = 0;
        int idx_s = 0;
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        while(idx_g < len_g && idx_s < len_s) {
            if(g[idx_g] <= s[idx_s]) {
                res++;
                idx_g++;
                idx_s++;
                continue;
            }
            else {
                idx_s++;
            }
        }
        return res;
    }
};

628. Maximum Product of Three Numbers

class Solution {
public:
    int maximumProduct(vector<int>& nums) {
        assert(nums.size() >= 3);
        int max1 = INT_MIN;
        int max2 = INT_MIN;
        int max3 = INT_MIN;
        int min1 = INT_MAX;
        int min2 = INT_MAX;
        for(int num:nums) {
            if(num > max1) {
                max3 = max2;
                max2 = max1;
                max1 = num;
            }
            else if(num > max2) {
                max3 = max2;
                max2 = num;
            }
            else if(num > max3) {
                max3 = num;
            }
            if(num < min1) {
                min2 = min1;
                min1 = num;
            }
            else if(num < min2) {
                min2 = num;
            }
        }

        return std::max(max1*max2*max3, min1*min2*max1);
    }
};

class Solution {
public:
    int maximumProduct(vector<int>& nums) {
        int len = nums.size();
        assert(len >= 3);
        sort(nums.begin(), nums.end(), std::greater<int>());
        long long int num1 = nums[0]*nums[1]*nums[2];
        long long int num2 = nums[0]*nums[len-2]*nums[len-1];
        return std::max(num1, num2);
    }
};

561. Array Partition I

class Solution {
public:
    int arrayPairSum(vector<int>& nums) {
        int maxIdx = 10000;
        int *arr = new int[(maxIdx << 1) + 1]();
        int res = 0;
        for(int num: nums) {
            arr[num+maxIdx]++;    
        }

        bool first = true;
        int idx = 0;
        int cont = 0;
        while(idx <= (maxIdx << 1) && cont <= nums.size()) {
            if(!arr[idx]) {
                idx++;
                continue;
            }
            if(first) {
                res += idx - maxIdx;
            }
            first = 1 - first;
            arr[idx]--;
            cont++;
        }
        delete[] arr;
        return res;
    }
};

class Solution {
public:
    int arrayPairSum(vector<int>& nums) {
        int maxIdx = 10000;
        int *arr = new int[(maxIdx << 1) + 1]();
        int res = 0;
        for(int num: nums) {
            arr[num+maxIdx]++;    
        }

        bool first = true;
        int idx = 0;
        while(idx <= (maxIdx << 1)) {
            if(!arr[idx]) {
                idx++;
                continue;
            }
            if(first) {
                res += idx - maxIdx;
            }
            first = 1 - first;
            arr[idx]--;
        }
        delete[] arr;
        return res;
    }
};

class Solution {
public:
    int arrayPairSum(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int len = nums.size();
        int res = 0;
        for(int idx = 0; idx < len; idx+=2) {
            res += nums[idx];
        }
        return res;
    }
};