贪心算法练习day.5

435.无重叠区间

链接：. - 力扣（LeetCode）

题目描述：

给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。

示例 1:

输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。

示例 2:

输入: intervals = [ [1,2], [1,2], [1,2] ]
输出: 2
解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

示例 3:

输入: intervals = [ [1,2], [2,3] ]
输出: 0
解释: 你不需要移除任何区间，因为它们已经是无重叠的了。

提示:

• 1 <= intervals.length <= 105
• intervals[i].length == 2
• -5 * 104 <= starti < endi <= 5 * 104

贪心思路：

先对区间进行排序，让区间尽可能的重叠，这就是局部最优，当发现区间不重叠时什么也不做，当发现区间重叠时，更新重叠区间的最小右区间，并且记录要删除的区间，为了下一次的区间比较，看看是否有联系重叠的情况

代码实现：

int cmp(const void *a, const void *b)
{
    // 按照每个区间的起始位置进行比较
    return (*((int **)a))[0] - (*((int **)b))[0];
}

int eraseOverlapIntervals(int** intervals, int intervalsSize, int* intervalsColSize) {
    // 使用qsort对intervals数组进行排序，按照每个区间的起始位置
    qsort(intervals,intervalsSize,sizeof(intervals[0]),cmp);

    // 初始化计数器
    int count = 0;
    
    // 遍历区间数组
    for(int i = 1; i < intervalsSize; i++)
    {
        // 若当前区间的起始位置小于前一个区间的结束位置，表示发生重叠
        if(intervals[i][0] < intervals[i-1][1])
        {
            // 增加重叠计数
            count++;
            // 更新当前区间的结束位置为两区间结束位置的较小值
            intervals[i][1] = intervals[i][1] < intervals[i-1][1] ? intervals[i][1] : intervals[i-1][1];
        }
    }
    // 返回重叠区间数量
    return count;
}

763.划分字母区间

链接：. - 力扣（LeetCode）

题目描述：

给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。

注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。

返回一个表示每个字符串片段的长度的列表。

示例 1：

输入：s = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：
划分结果为 "ababcbaca"、"defegde"、"hijhklij" 。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 这样的划分是错误的，因为划分的片段数较少。 

示例 2：

输入：s = "eccbbbbdec"
输出：[10]

提示：

• 1 <= s.length <= 500
• s 仅由小写英文字母组成

贪心思路：

当我们遍历时字符串进行划分时，如果包含了一个字母，那么就要将这个字符串中所有的这个字母都包含到我们划分的区间中，我们可以统计每个字符出现的最远位置，因为我们遇到一个字符时，要将所有想同的字符都包含在一个区间内，这样我们就得到了一个初步划分的区间，在这个区间内，我们继续去查找其余不同字母的最远位置，通过比较所有字母不同的最远位置，找到最大的一个，就能划分出一个区间（局部最优），最后就能划分出所有的区间（全局最优）

代码实现：

/**
 * 注意：返回的数组必须通过malloc分配内存，调用者需要负责释放内存。
 */
int* partitionLabels(char* s, int* returnSize) {
    // 哈希表用于记录字符最后出现的位置（a-z共26个字母）
    int hash[27];
    // 遍历字符串，记录每个字符最后出现的位置
    for(int i = 0; i < strlen(s); i++)
        hash[s[i] - 'a'] = i;

    // 初始化左右指针和结果数组
    int left = 0, right = 0;
    int *result = (int *)malloc(sizeof(int) * strlen(s));
    *returnSize = 0;

    // 遍历字符串
    for(int i = 0; i < strlen(s); i++)
    {
        // 更新右边界，取当前字符的最后出现位置和当前右边界的较大值
        right = right > hash[s[i] - 'a'] ? right : hash[s[i] - 'a'];
        
        // 如果当前位置等于右边界，说明找到一个分割点
        if(right == i)
        {
            // 计算当前段的长度并存入结果数组
            result[(*returnSize)++] = right - left + 1;
            // 更新左指针为下一个段的起始位置
            left = i + 1;
        }
    }
    // 返回结果数组
    return result;
}

56.合并区间

链接：. - 力扣（LeetCode）

题目描述：

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

提示：

• 1 <= intervals.length <= 104
• intervals[i].length == 2
• 0 <= starti <= endi <= 104

贪心思路：

主要也是判断一个重叠区间，当区间重叠时，则让他们进行合并，我们先对所有区间进行左边界排序，排序过后遍历数组，当我们发现区间重叠时，我们进行区间合并的操作，如果没有重叠，则直接进行存储

代码实现：

#define max(a, b) ((a) > (b) ? (a) : (b)) // 定义宏，返回两个数中较大的值

int cmp(const void * var1, const void * var2){ // 定义比较函数
    int *v1 = *(int **) var1; // 将var1转换为int型指针的指针，再取值赋给v1
    int *v2 = *(int **) var2; // 将var2转换为int型指针的指针，再取值赋给v2
    return v1[0] - v2[0]; // 比较两个区间的左端点大小
}

int** merge(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize, int** returnColumnSizes) { // 合并重叠区间的函数
    int ** result = malloc(sizeof (int *) * intervalsSize); // 分配存储结果区间的内存空间
    * returnColumnSizes = malloc(sizeof (int ) * intervalsSize); // 分配存储每个结果区间列数的内存空间
    for(int i = 0; i < intervalsSize; i++){ // 遍历结果区间数组
        result[i] = malloc(sizeof (int ) * 2); // 为每个结果区间分配存储空间
    }
    qsort(intervals, intervalsSize, sizeof (int *), cmp); // 对区间数组按左端点进行排序
    int count = 0;//确定当前应该存储合并后区间的位置，以及在合并时更新合并后的结果区间数量
    for(int i = 0; i < intervalsSize; i++){ // 遍历排序后的区间数组
        int L = intervals[i][0], R = intervals[i][1]; // 获取当前区间的左右端点
        if (count == 0 || result[count - 1][1] < L) { // 如果当前结果为空或者当前区间的左端点大于前一个结果的右端点
            returnColumnSizes[0][count] = 2; // 设置当前结果区间的列数为2
            result[count][0] = L; // 存储当前区间的左端点到结果数组
            result[count][1] = R; // 存储当前区间的右端点到结果数组
            count++; // 结果区间数量加1
        } 
        else
        { 
            result[count - 1][1] = max(R, result[count - 1][1]); // 合并重叠的区间，更新前一个结果区间的右端点为当前区间右端点和前一个结果区间右端点的较大值
        }
    }
    *returnSize = count; // 存储结果区间数量
    return result; // 返回合并后的结果数组
}