五月集训：DAY 04 [贪心]

1.分割平衡字符串

在一个 平衡字符串 中，‘L’ 和 ‘R’ 字符的数量是相同的。
给你一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。
注意：分割得到的每个字符串都必须是平衡字符串，且分割得到的平衡字符串是原平衡字符串的连续子串。
返回可以通过分割得到的平衡字符串的 最大数量。

输入：s = “RLRRLLRLRL”
输出：4
解释：s 可以分割为 “RL”、“RRLL”、“RL”、“RL” ，每个子字符串中都包含相同数量的 ‘L’ 和 ‘R’

输入：s = “RLLLLRRRLR”
输出：3
解释：s 可以分割为 “RL”、“LLLRRR”、“LR” ，每个子字符串中都包含相同数量的 ‘L’ 和 ‘R’ 。

输入：s = “LLLLRRRR”
输出：1
解释：s 只能保持原样 “LLLLRRRR”.

输入：s = “RLRRRLLRLL”
输出：2
解释：s 可以分割为 “RL”、“RRRLLRLL” ，每个子字符串中都包含相同数量的 ‘L’ 和 ‘R’ 。

• 1 <= s.length <= 1000
• s[i] = ‘L’ 或 ‘R’
• s 是一个 平衡 字符串

int balancedStringSplit(char * s){
    int i= 0; 
    int count = 0;
    int num = 0;
    while(s[i]){
        if(s[i] == 'R'){
            count++;
        }else{
            count--;
        }
        i++;
        if(0 == count){
            num++;
        }
    }
    return num;
}

解题思路:count如果是R则加，不是则减，统计加减平衡时的个数，就是平衡字符串的个数

2.最少操作数使数组递增

给你一个整数数组 nums （下标从 0 开始）。每一次操作中，你可以选择数组中一个元素，并将它增加 1 。
比方说，如果 nums = [1,2,3] ，你可以选择增加 nums[1] 得到 nums = [1,3,3] 。
请你返回使 nums 严格递增 的 最少 操作次数。
我们称数组 nums 是 严格递增的 ，当它满足对于所有的 0 <= i < nums.length - 1 都有 nums[i] < nums[i+1] 。一个长度为 1 的数组是严格递增的一种特殊情况。

输入：nums = [1,1,1]
输出：3
解释：你可以进行如下操作：

1. 增加 nums[2] ，数组变为 [1,1,2] 。
2. 增加 nums[1] ，数组变为 [1,2,2] 。
3. 增加 nums[2] ，数组变为 [1,2,3] 。

输入：nums = [1,5,2,4,1]
输出：14

输入：nums = [8]
输出：0

• 1 <= nums.length <= 5000
• 1 <= nums[i] <= 104

int minOperations(int* nums, int numsSize){
    int i = 1;
    int count = 0;
    while(i < numsSize) {
        if(nums[i] <= nums[i-1]) {
            count += nums[i-1] - nums[i] + 1;
            nums[i] = nums[i-1] + 1;
        }else{
            i++;
        }
    }
    return count;
}

解题思路:如果后数比前数小，则加到比前数大，统计加的数量。

3.打折购买糖果最小开销

一家商店正在打折销售糖果。每购买 两个 糖果，商店会 免费 送一个糖果。
免费送的糖果唯一的限制是：它的价格需要小于等于购买的两个糖果价格的 较小值 。
比方说，总共有 4 个糖果，价格分别为 1 ，2 ，3 和 4 ，一位顾客买了价格为 2 和 3 的糖果，那么他可以免费获得价格为 1 的糖果，但不能获得价格为 4 的糖果。
给你一个下标从 0 开始的整数数组 cost ，其中 cost[i] 表示第 i 个糖果的价格，请你返回获得 所有 糖果的 最小 总开销

输入：cost = [1,2,3]
输出：5
解释：我们购买价格为 2 和 3 的糖果，然后免费获得价格为 1 的糖果。
总开销为 2 + 3 = 5 。这是开销最小的 唯一 方案。
注意，我们不能购买价格为 1 和 3 的糖果，并免费获得价格为 2 的糖果。
这是因为免费糖果的价格必须小于等于购买的 2 个糖果价格的较小值。

输入：cost = [6,5,7,9,2,2]
输出：23
解释：最小总开销购买糖果方案为：

• 购买价格为 9 和 7 的糖果
• 免费获得价格为 6 的糖果
• 购买价格为 5 和 2 的糖果
• 免费获得价格为 2 的最后一个糖果
  因此，最小总开销为 9 + 7 + 5 + 2 = 23

输入：cost = [5,5]
输出：10
解释：由于只有 2 个糖果，我们需要将它们都购买，而且没有免费糖果。
所以总最小开销为 5 + 5 = 10 。

• 1 <= cost.length <= 100
• 1 <= cost[i] <= 100

int cmp(const void* a, const void* b){
    return *(int*)a - *(int*)b;
}
int minimumCost(int* cost, int costSize){
    qsort(cost, costSize, sizeof(int), cmp);
    int i = 0;
    int num = 0;
    int count = 0;
    for(i = costSize-1; i >= 0; i--){
        if(num != 2){
            count += cost[i];
        }
        num = (num + 1) % 3; //num 0 1 2 循环 
    }
    return count;
}

解题思路:从大到小排序，最贵的两个糖果买了之后可以免费送第三贵的糖果，此方案为最小开销。那么我定义一个从0 1 2 不断循环的数字，从后往前遍历，跳过免费送的糖果（num == 2）。合计糖果开销。

4.构造K个回文字符

给你一个字符串 s 和一个整数 k 。请你用 s 字符串中 所有字符 构造 k 个非空 回文串 。
如果你可以用 s 中所有字符构造 k 个回文字符串，那么请你返回 True ，否则返回 False 。

输入：s = “annabelle”, k = 2
输出：true
解释：可以用 s 中所有字符构造 2 个回文字符串。
一些可行的构造方案包括：“anna” + “elble”，“anbna” + “elle”，“anellena” + “b”

输入：s = “leetcode”, k = 3
输出：false
解释：无法用 s 中所有字符构造 3 个回文串。

输入：s = “true”, k = 4
输出：true
解释：唯一可行的方案是让 s 中每个字符单独构成一个字符串。

输入：s = “yzyzyzyzyzyzyzy”, k = 2
输出：true
解释：你只需要将所有的 z 放在一个字符串中，所有的 y 放在另一个字符串中。那么两个字符串都是回文串。

输入：s = “cr”, k = 7
输出：false
解释：我们没有足够的字符去构造 7 个回文串。

• 1 <= s.length <= 10^5
• s 中所有字符都是小写英文字母。
• 1 <= k <= 10^5

bool canConstruct(char * s, int k){
    int i = 0;
    int size = 0;
    int ret[26] = {0};
    int len = 0;
    while(s[i]){
        int j = s[i] - 'a';     //统计每个字符出现的次数
        ret[j]++;
        len++;                  //统计字符串长度;
        i++;
    }
    int num = 0;
    for(i = 0; i < 26; i++){
        if(ret[i] % 2 != 0){
            num++;             //有多少个中间字符
        }
    }
    if(num <= k && k <= len){
        return true;
    }else{
        return false;
    }

解题思路:字符出现偶数次，忽略不计。出现的奇数次，一定要放在回文字符串的中间，这样的中间字符个数一定要小于等于K。字符串长度要大于等于K。