デイ-03-貪欲Leetcode-445、376、402、55、45、452 POJ-2431

例1：LeetCode445

//已知一些孩子和一些糖果，每个孩子有需求因子g，每个糖果大小s
//当某个糖果的大小s>=某个孩子的需求因子时，代表该糖果可以满足
//该孩子，求使用这些糖果最多可以满足多少孩子。
#include <stdio.h>
#include <vector>
#include <algorithm>
class Solution {
public:
       int findContentChildren(std::vector <int>& g, std::vector <int>& s) {
              std::sort(g.begin(), g.end());
              std::sort(s.begin(), s.end());
              int child = 0;
              int cookie = 0;
              while (child < g.size() && cookie < s.size()) {
                     if (g[child] <= s[cookie]) {
                           child++;
                     }
                     cookie++;
              }
              return child;
       }
};
int main() {
       Solution solve;
       std::vector<int> g;
       std::vector<int> s;
       g.push_back(5);
       g.push_back(10);
       g.push_back(2);
       g.push_back(9);
       g.push_back(15);
       g.push_back(9);
       s.push_back(6);
       s.push_back(1);
       s.push_back(20);
       s.push_back(3);
       s.push_back(8);
       printf("%d\n", solve.findContentChildren(g, s));
       return 0;
}

例二：LeetCode376

//一个整数序列，如果两个相邻的元素的差恰好出现（负正）交替出现，则该序列被称
//为摇摆序。一个小于2个元素的序列直接为摇摆序列。
#include <stdio.h>
#include <vector>
class Solution {
public:
       int wiggleMaxLength(std::vector<int>& nums) {
              if (nums.size() < 2) {
                     return nums.size();
              }
              static const int BEGIN = 0;
              static const int UP = 1;
              static const int DOWN = 2;
              int STATE = BEGIN;
              int max_length = 1;
              for (int i = 1; i < nums.size(); i++) {
                     switch (STATE) {
                     case BEGIN:
                           if (nums[i] > nums[i - 1]) {
                                  STATE = UP;
                                  max_length++;
                           }
                           else if (nums[i - 1] > nums[i]) {
                                  STATE = DOWN;
                                  max_length++;
                           }
                           break;
                     case UP:
                           if (nums[i] < nums[i - 1]) {
                                  STATE = DOWN;
                                  max_length++;
                           }
                           break;
                     case DOWN:
                           if (nums[i] > nums[i - 1]) {
                                  STATE = UP;
                                  max_length++;
                           }
                           break;
                     }
              }
              return max_length;
       }
};
int main() {
       std::vector<int> nums;
       nums.push_back(1);
       nums.push_back(17);
       nums.push_back(5);
       nums.push_back(10);
       nums.push_back(13);
       nums.push_back(15);
       nums.push_back(10);
       nums.push_back(5);
       nums.push_back(16);
       nums.push_back(8);
       Solution solve;
       printf("%d\n", solve.wiggleMaxLength(nums));
       return 0;
}

例3：LeetCode402

//已知一个使用字符串表示的非负整数num，将num中的k个数字移除，求移除k个数字后
//可以获得的最小的新数字。
#include <stdio.h>
#include <string>
#include <vector>
class Solution {
public:
       std::string removeKdigits(std::string num, int k) {
              std::vector<int> S;
              std::string result = "";
              for (int i = 0; i < num.length(); i++) {
                     int number = num[i] - '0';
                     while (S.size() != 0 && S[S.size() - 1] > number && k > 0) {
                           S.pop_back();
                           k--;
                     }
                     if (number != 0 || S.size() != 0) {
                           S.push_back(number);
                     }
              }
              while (S.size() != 0 && k > 0) {
                     S.pop_back();
                     k--;
              }
              for (int i = 0; i < S.size(); i++) {
                     result.append(1, '0' + S[i]);
              }
              if (result == "") {
                     result = "0";
              }
              return result;
       }
};
int main() {
       Solution solve;
       std::string result = solve.removeKdigits("1432219", 3);
       printf("%s\n", result.c_str()); //https://blog.csdn.net/Jian_Yun_Rui/article/details/61916594
       std::string result2 = solve.removeKdigits("100200", 1);
       printf("%s\n", result2.c_str());
       return 0;
}

例4：LeetCode55

//一个数组存储了非负整型数据，数组中的第i个元素nums[i]，代表了可以从数组第i个
//位置最多向前跳跃nums[i]步；已知数组各元素的情况下，求是否可以从数组的第0个位置
//跳跃到数组的最后一个位置。
 
#include <stdio.h>
#include <vector>
 
class Solution {
public:
    bool canJump(std::vector<int>& nums) {
        std::vector<int> index;
        for (int i = 0; i < nums.size(); i++) {
            index.push_back(i + nums[i]);
        }
        int jump = 0;
        int max_index = index[0];
        while (jump < index.size() && jump <= max_index) {
            if (max_index < index[jump]) {
                max_index = index[jump];
            }
            jump++;
        }
        if (jump == nums.size()) {
            return true;
        }
        return false;
    }
};
 
int main() {
    std::vector<int> nums;
    nums.push_back(2);
    nums.push_back(3);
    nums.push_back(1);
    nums.push_back(1);
    nums.push_back(4);
    Solution solve;
    printf("%d\n", solve.canJump(nums));
    return 0;
}

例5：LeetCode45

//一个数组存储了非负整型数据，数组中的第i个元素nums[i]，代表了可以从数组第i个
//位置最多向前跳跃nums[i]步；已知数组各元素的情况下，确认可以从数组的第0个位置
//跳跃到数组的最后一个位置，求最少需要跳跃几次。
#include <stdio.h>
#include <vector>
class Solution {
public:
       int jump(std::vector<int>& nums) {
              if (nums.size() < 2) {
                     return 0;
              }
              int current_max_index = nums[0];
              int pre_max_max_index = nums[0];
              int jump_min = 1;
              for (int i = 1; i < nums.size(); i++) {
                     if (i > current_max_index) {
                           jump_min++;
                           current_max_index = pre_max_max_index;
                     }
                     if (pre_max_max_index < nums[i] + i) {
                           pre_max_max_index = nums[i] + i;
                     }
              }
              return jump_min;
       }
};
int main() {
       std::vector<int> nums;
       nums.push_back(2);
       nums.push_back(3);
       nums.push_back(1);
       nums.push_back(1);
       nums.push_back(4);
       Solution solve;
       printf("%d\n", solve.jump(nums));
       return 0;
}

六例：LeetCode452

//已知在一个平面上有一定数量的气球，平面可以看作一个坐标系，在平面的x轴
//的不同位置安排不同弓箭手向y轴方向射箭，弓箭可以射无限远；
//给定气球宽度xstart <= x <= xend，问至少需要多少弓箭手才能将气球全部打爆？
#include <stdio.h>
#include <vector>
#include <algorithm>
bool cmp(const std::pair<int, int>& a, const std::pair<int, int>& b) {
       return a.first < b.first;
}
class Solution {
public:
       int findMinArrowShots(std::vector<std::pair<int, int>>& points) {
              if (points.size() == 0) {
                     return 0;
              }
              std::sort(points.begin(), points.end(), cmp);
              int shoot_num = 1;
              int shoot_begin = points[0].first;
              int shoot_end = points[0].second;
              for (int i = 1; i < points.size(); i++) {
                     if (points[i].first <= shoot_end) {
                           shoot_begin = points[i].first;
                           if (shoot_end > points[i].second) {
                                  shoot_end = points[i].second;
                           }
                     }
                     else {
                           shoot_num++;
                           shoot_begin = points[i].first;
                           shoot_end = points[i].second;
                     }
              }
              return shoot_num;
       }
};
int main() {
       std::vector<std::pair<int, int>> points;
       points.push_back(std::make_pair(10, 16));
       points.push_back(std::make_pair(2, 8));
       points.push_back(std::make_pair(1, 6));
       points.push_back(std::make_pair(7, 12));
       Solution solve;
       printf("%d\n", solve.findMinArrowShots(points));
       return 0;
}

例7：POJ2431

//已知在一条公路上，有一个起点和终点，这之间有n个加油站；
//已知从这n个加油站到终点的距离d与各个加油站可以加油的量l
//起点位置至终点位置的距离L与起始时刻油箱中的油量P；假设使用
//1个单位的汽油即走1ge单位的距离，油箱没有上限，最少加几次油
//可以从起点开至终点？（如果无法到达终点，返回-1）
#include <stdio.h>
#include <algorithm>
#include <queue>
bool cmp(const std::pair<int, int>& a, const std::pair<int, int>& b) {
       return a.first > b.first;
}
       int get_minimum(int L, int P, std::vector<std::pair<int, int>>& stop) {
              std::priority_queue<int> Q;
              int result = 0;
              stop.push_back(std::make_pair(0, 0));
              std::sort(stop.begin(), stop.end(), cmp);
              for (int i = 0; i < stop.size(); i++) {
                     int dis = L - stop[i].first;
                     while (!Q.empty() && P < dis ) {
                           P += Q.top();
                           Q.pop();
                           result++;
                     }
                     if ( Q.empty()&& P < dis ) {
                           return -1;
                     }
                     P = P - dis;
                     L = stop[i].first;
                     Q.push(stop[i].second);
              }
              return result;
       }
int main() {
       std::vector<std::pair<int, int>> stop;
       int N;
       int L;
       int P;
       int distance;
       int fuel;
       ~scanf("%d", &N);
       for (int i = 0; i < N; i++) {
              ~scanf("%d %d", &distance, &fuel);
              stop.push_back(std::make_pair(distance, fuel));
       }
       ~scanf("%d %d", &L, &P);
       printf("%d\n", get_minimum(L, P, stop));
       return 0;
}