Leetcode-贪心算法

贪心算法

贪心算法的核心就是先达到局部最优，最后结合起来一步一步达到全局最优。

题目

分配题目

题目1:有一群孩子和一堆饼干，每个孩子有一个饥饿度，每个饼干都有一个大小。每个孩子只能吃最多一个饼干，且只有饼干的大小大于孩子的饥饿度时，这个孩子才能吃饱。求解最多有多少孩子可以吃饱？

int assign_cookie(vector<int> childen, vector<int> cookie){
    //先满足饥饿度小的孩子，这样就能让吃饱的孩子更多。
    sort(childen.begin(), childen.end());
    sort(cookie.begin(), cookie.end());
    int count = 0;
    int i=0, j=0;
    while(i<childen.size() && j<cookie.size()){
        if(childen[i] < cookie[j]){
            count++;
            i++;
            j++;
        }
        else{
            j++;
        }
    }
    return count;
}

int main() {
    vector<int> child = {2,4};
    vector<int> cookie = {1,2,3};
    int result = 0;
    result = assign_cookie(child,cookie);
    cout << result << endl;
    return 0;
}

题目2:一群孩子站成一排，每一个孩子有自己的评分。现在需要给这些孩子发糖果，规则是如果一个孩子的评分比自己身旁的一个孩子要高，那么这个孩子就必须得到比身旁孩子更多的糖果；所有孩子至少要有一个糖果。求解最少需要多少个糖果？

#include <iostream>
#include <string>
#include <vector>
#include <numeric>
using namespace std;

int assign_candy(vector<int> scores){
    if(scores.size()==0){
        return 0;
    }
    else if(scores.size()==1){
        return 1;
    }
    else if(scores.size()==2){
        if(scores[0]==scores[1]){
            return 2;
        }
        else{
            return 3;
        }
    }
    int len = scores.size();
    vector<int> arr(len, 1);
    //从左到右遍历，右>左
    for(int i=1; i<len; i++){
        if(scores[i-1]<scores[i]){
            arr[i] = arr[i-1]+1;
        }
    }
    //从右到左遍历，左>右
    for(int j=len-1; j>0; j--){
        if(scores[j-1]>scores[j]){
            arr[j-1] = arr[j]+1;
        }
    }
    int result = 0;
    result = accumulate(arr.begin(), arr.end(), 0);
//    for(int i=0; i<len; i++){
//        result += arr[i];
//    }
    return result;
}

int main() {
    vector<int> scores = {1,0,2};
    int result = 0;
    result = assign_candy(scores);
    cout << result << endl;
    return 0;
}

区间题目

题目1:给定多个区间，计算让这些区间互不重叠所需要移除区间的最少个数。起止相连不算重叠。

#include <iostream>
#include <string>
#include <vector>
#include <numeric>
using namespace std;

bool cmp(vector<int> a, vector<int> b){
    return a[1] < b[1];
}
//优先保留结尾小且不相交的区间。
int non_overlap(vector<vector<int>> arr){
    int len = arr.size();
    int result = 0;
    sort(arr.begin(), arr.end(), cmp);
    int End = arr[0][1];
    for(int i=1; i<len; i++){
        if(arr[i][0]<End){
            result++;
        }
        else{
            End = arr[i][1];
        }
    }
    return result;
}

int main() {
    vector<vector<int>> arr={{1,2},{2,4},{1,3}};
    int result = non_overlap(arr);
    cout << result << endl;
    return 0;
}