1.何谓贪心算法

贪心算法，顾名思义，重点落在贪心的算法，即用最小的代价满足需求
常用于求最优解，贪心算法的特点是，通过求出局部的最优解来获得整体的最优解

2.分发饼干

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。
对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。
题目链接

题目分析：

int Compar(int *x,int *y)
{
    return *x-*y;
}

int findContentChildren(int* g, int gSize, int* s, int sSize){
   
   qsort(g,gSize,sizeof(int),Compar);
    qsort(s,sSize,sizeof(int),Compar);

    //先满足局部最优解，即用最小的饼干，满足胃口最小的孩子
    int count=0;//计数器，记录满足了多少个孩子
    int sub=0;//孩子数组下标

    for(int i=0;i<sSize;i++)
    {
        if(sub>=gSize)//没有孩子了
        return count;

        if(s[i]>=g[sub])//当前孩子满足了
        {
            count++;
            sub++;
        }     
    }
      return count;
}

3.跳跃游戏

给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
你的目标是使用最少的跳跃次数到达数组的最后一个位置。
题目链接

解析：

int jump(int* nums, int numsSize){
    if(numsSize==1)
    return 0;

    int count=0;//记录跳跃次数
    int max=0;//记录可以跳多远
    int sub=0;//记录最适宜的下标
    int i=0;

    while(i<numsSize)
    {
        if(nums[i]+i>=numsSize-1)//当前点可以直接跳往终点
           {    count++;//跳往终点也需要一步
                return count;
           }
        //不能直接跳往终点，则继续求一下个最优解

        sub=0;
        max=0;
        for(int j=1;j<=nums[i];j++)
        {
           if((nums[i+j]+j)>max)//下一步的距离加上当前步的距离达到最远处
            {
                max=nums[i+j]+j;//记录可以达到的最远距离
                sub=j;//记录跳多远
            }
        }

        count++;//跳一次
        i=i+sub;//更新到跳跃位置

    }
    return count;//更新完位置之后直接跳出了

}

4.避免重复字母的最小删除成本

给你一个字符串 s 和一个整数数组 cost ，其中 cost[i] 是从 s 中删除字符 i 的代价。
返回使字符串任意相邻两个字母不相同的最小删除成本。
请注意，删除一个字符后，删除其他字符的成本不会改变。
题目链接

解析：
给定以前以后两个指针，如果两个指针对应的值是相等的，则取对应下标的较小值(贪心思想)
需要注意的是连续一串的相同字符，在这里我们需要注意两个指针的位置，即前面的指针不能挪到已经删除的元素上面
又因为后面的指针总是往后走，即当两个指针位置的字符不相等是，前面的指针直接转移到后面的指针处

int minCost(char * s, int* cost, int costSize){
    int count=0;
    int prev_sub=0;
    int next_sub=1; 

    while(next_sub<costSize)
    {
        if(s[prev_sub]==s[next_sub])//相等
        {
            count+=(cost[prev_sub]>cost[next_sub]?cost[next_sub]:cost[prev_sub]);//删除最小的

            if(cost[prev_sub]<cost[next_sub])//删除的是前面的
            {
                prev_sub=next_sub;//防止到达中间已被删除字符
                next_sub++;
            }
            else//删除的是后面的
            {
                next_sub++;//只更新后面的坐标，防止连续多个字符出现
            }
        }
        else//不想等
        {
            prev_sub=next_sub;
            next_sub++;
        }
    }
    return count;
  

}