35 第八章 贪心算法

35 第八章 贪心算法

0860.柠檬水找零

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        unordered_map<int, int> umap;
        for (int i = 0; i < bills.size(); ++ i) {
            if (bills[i] == 5) {
                ++ umap[5]; 
            } else if (bills[i] == 10) {
                if (umap[5] > 0) {
                    ++ umap[10];
                    -- umap[5];
                } else {
                    return false;
                }
            } else if (bills[i] == 20) {
                if (umap[10] > 0 && umap[5] > 0) {
                    ++ umap[20];
                    -- umap[10];
                    -- umap[5];
                } else if (umap[5] >= 3) {
                    ++ umap[20];
                    umap[5] -= 3;
                } else {
                    return false;
                }
            }
        } // for
        return true;
    }
};

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        unsigned int cnt[3] = {0};
        for (int i = 0; i < bills.size(); ++ i) {
            if (bills[i] == 5) {
                ++ cnt[0]; 
            } else if (bills[i] == 10) {
                if (cnt[0] > 0) {
                    ++ cnt[1];
                    -- cnt[0];
                } else {
                    return false;
                }
            } else if (bills[i] == 20) {
                if (cnt[1] > 0 && cnt[0] > 0) {
                    ++ cnt[2];
                    -- cnt[1];
                    -- cnt[0];
                } else if (cnt[0] >= 3) {
                    ++ cnt[2];
                    cnt[0] -= 3;
                } else {
                    return false;
                }
            }
        } // for
        return true;
    }
};

0406.根据身高重建队列

// 版本一运行时间明显大于版本二，因为vector插入操作涉及到扩容。

#if 1     // 版本一
class Solution {
public:
    static bool cmp(const vector<int>& a, const vector<int>& b) {
        if (a[0] == b[0]) return a[1] < b[1];
        return a[0] > b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort (people.begin(), people.end(), cmp);
        vector<vector<int>> que;
        for (int i = 0; i < people.size(); i++) {
            int position = people[i][1];
            que.insert(que.begin() + position, people[i]);
        }
        return que;
    }
};

#else // 版本二
class Solution {
public:
    // 身高从大到小排（身高相同k小的站前面）
    static bool cmp(const vector<int>& a, const vector<int>& b) {
        if (a[0] == b[0]) return a[1] < b[1];
        return a[0] > b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort (people.begin(), people.end(), cmp);
        list<vector<int>> que; // list底层是链表实现，插入效率比vector高的多
        for (int i = 0; i < people.size(); i++) {
            int position = people[i][1]; // 插入到下标为position的位置
            std::list<vector<int>>::iterator it = que.begin();
            while (position--) { // 寻找在插入位置
                it++;   // 当it==que.end(), ++it之后仍然还是it==que.end()
            }
            que.insert(it, people[i]);
        }
        return vector<vector<int>>(que.begin(), que.end());
    }
};


#endif

// 排序算法稳定性测试

#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

static bool mycmp(const vector<int> &lhs, const vector<int> &rhs) {
	return lhs[0] < rhs[0];      // < 排序后从小到大
    // return lhs[0] <= rhs[0];     
}

int main() {
	vector<vector<int>> vec = {{3, 2}, {3, 1}, {1, 2}, {1, 1}, {2, 2}, {2, 1}};
	sort(vec.begin(), vec.end(), mycmp);
	for (auto &elem : vec) {
		cout << elem[0] << " " << elem[1] << endl;
	}
	return 0;
}

// < 输出结果 --> 保持稳定性

1 2
1 1
2 2
2 1
3 2
3 1

// <= 输出结果 --> 排序不在具有稳定性

1 1
1 2
2 1
2 2
3 1
3 2

// >稳定，>=不稳定

0452.用最少数量的箭引爆气球

class Solution {
    static bool cmp(const vector<int> &lhs, const vector<int> &rhs) {
        return lhs[0] < rhs[0];
    }
public:
    int findMinArrowShots(vector<vector<int>>& points) {
        if (points.empty()) return 0;
        sort(points.begin(), points.end(), cmp);
        int result = 1;   // points不为空至少需要一支箭
        for (int i = 1; i < points.size(); ++ i) {
            if (points[i][0] > points[i - 1][1]) {
                ++ result;
            } else {
                points[i][1] = min(points[i - 1][1], points[i][1]);
            }
        } // for
        return result;
    }
};