C语言学习--练习3(贪心)

目录

贪心算法

1. 两数对之间的最大乘积差

2.三角形的最大周长

3.数组拆分

4.救生艇

5.发送饼干

6.摆动数组

---

贪心算法

概念定义
        所谓贪心，总是做出在当前看来是最好的选择。也就是说，不从整体最优上进行考虑，算法得到的是在某种意义上的局部最优解。
        比如，对于一个全是正整数的数组，我要找到其中两个数，使得它们的乘积最大，毫无疑问，一定是取最大和次大的两个数进行相乘，得到的结果最大。这个就是贪心思想。
那么接下来，让我们做几道例题，来真正了解一下贪心。

1. 两数对之间的最大乘积差

int cmp(const void *a,const void *b){
    return *(int*)a-*(int*)b;
}
int maxProductDifference(int* nums, int numsSize){
    qsort(nums,numsSize,sizeof(int),cmp);//排序
    int n=numsSize;
    return abs(nums[n-1]*nums[n-2]-nums[0]*nums[1]);//贪心，直接取最前最后两个乘积差
}

/*
//直接找最大的两个数ab和最小的两数cd
int maxProductDifference(int* nums, int numsSize) {
    int a = 0, b = 0, c = 10001, d = 10001, i, t;
    for (i = 0; i < numsSize; i++) {
        t = nums[i];
        if (t > a)
            b = a, a = t;
        else if (t > b)
            b = t;
        if (t < d)
            c = d, d = t;
        else if (t < c)
            c = t;
    }
    return a * b - c * d;
}
*/

 2.三角形的最大周长

//遇到数组题目的第一件事就是先排序！！！
int cmp(const void *a,const void *b){
    return *(int*)a-*(int*)b;
}
//有些时候不要想太复杂了
int largestPerimeter(int* nums, int numsSize) {
    qsort(nums,numsSize,sizeof(int),cmp);
    //贪心找出边长最大的三个边
    for(int i=numsSize-1;i>1;i--){
        if(nums[i]<nums[i-1]+nums[i-2]){
            return nums[i]+nums[i-1]+nums[i-2];
        }
    }
    return 0;
}

3.数组拆分

//想想思路，在数对中取min后之和要最大，
//是不是感觉直接排序后取欸者的两个为一对就可以了
//直接试试（贪心）
//为什么证明过程相当复杂，
int cmp(const void*a,const void*b){
    return *(int*)a-*(int*)b;
}
int arrayPairSum(int* nums, int numsSize) {
    qsort(nums,numsSize,sizeof(int),cmp);
    int ans=0;
    for(int i=0;i<numsSize;i=i+2){//数对左边的是较小的min
        ans=ans+nums[i];
    }
    return ans;
}

 证明过程如下：. - 力扣（LeetCode）

4.救生艇

int cmp(const void *a,const void *b){
    return *(int*)a-*(int*)b;
}
//贪心算法，两个人一条船，船少，
/*
方法一：贪心
要使需要的船数尽可能地少，应当使载两人的船尽可能地多。

设 people\textit{people}people 的长度为 nnn。考虑体重最轻的人：

若他不能与体重最重的人同乘一艘船，那么体重最重的人无法与任何人同乘一艘船，
此时应单独分配一艘船给体重最重的人。从 people 中去掉体重最重的人后，
我们缩小了问题的规模，变成求解剩余 n−1个人所需的最小船数，将其加一即为原问题的答案。

若他能与体重最重的人同乘一艘船，那么他能与其余任何人同乘一艘船，
为了尽可能地利用船的承载重量，选择与体重最重的人同乘一艘船是最优的。
从people 中去掉体重最轻和体重最重的人后，
我们缩小了问题的规模，变成求解剩余 n−2个人所需的最小船数，将其加一即为原问题的答案。

*/
int numRescueBoats(int* people, int peopleSize, int limit) {
    qsort(people,peopleSize,sizeof(int),cmp);
    int ans=0;
    int light=0,heavy=peopleSize-1;
    for(;light<=heavy;){
        if(people[heavy]+people[light]<=limit){//可以坐下最重的一个人+一个人
            ans++;
            light++;
            heavy--;
        }else{//坐不下
            ans++;
            heavy--;
        }//我看谁能和现在最轻的人一起
    }
    return ans;
}

 5.发送饼干

//不管不管，拿到数组先排序
int cmp(const void*a,const void *b){
    return *(int *)a-*(int*)b;
}

int findContentChildren(int* g, int gSize, int* s, int sSize) {
    qsort(g,gSize,sizeof(int),cmp);
    qsort(s,sSize,sizeof(int),cmp);
    int ans=0,i=0,j=0;

    while(i<gSize&&j<sSize){
        if(g[i]<=s[j]){
            ans++;
            i++;
            j++;
        }else{
            j++;
            }
    }
    return ans;
}

6.摆动数组

// 1 2 3 4 5 6 7 8 
//4  3  2  1
//  8  7  6  5
static int cmp(const void *pa, const void *pb) {
    return *(int *)pa - *(int *)pb;
}

void wiggleSort(int* nums, int numsSize) {
    int * arr = (int *)malloc(sizeof(int) * numsSize);
    memcpy(arr, nums, sizeof(int) * numsSize);
    qsort(arr, numsSize, sizeof(int), cmp);
    int x = (numsSize + 1) / 2;
    for (int i = 0, j = x - 1, k = numsSize - 1; i < numsSize; i += 2, j--, k--) {
        nums[i] = arr[j];
        if (i + 1 < numsSize) {
            nums[i + 1] = arr[k];
        }
    }
    free(arr);
}

 这题相当复杂，原理就是把前一半数重大到小插入偶数位，后一半的数重大到小插入奇数位，然后可以实现中间的数大于左右两边的数。具体为什么我也不晓得，证明过程太复杂不想看