您现在的位置是:首页 > 正文

LeetCode·每日一题·1851. 包含每个查询的最小区间·优先队列(小顶堆)

2024-02-01 05:34:27阅读 3

题目

 

示例

 

思路

  • 离线查询:
    •  输入的结果数组queries[]是无序的。如果我们按照输入的queries[]本身的顺序逐个查看,时间复杂度会比较高。 于是,我们将queries[]数组按照数值大小,由小到大逐个查询,这种方法称之为离线查询。
  • 位运算:
    •  离线查询的时候,queries[]可以按照数值大小逐个查看,但最终返回的结果数组,是需要按照queries[]相同的顺序输出的,也就是说,queries[]数组的下标信息不能被丢失。 此时,我们可以考虑,将每一个queries[x]放在一个long int数值的高32位,将下标x放在这个long int数值的低32位。 由此,我们可以看出,这些新的long int数值,它们之间的相互大小关系,取决于高32位的数值,只有在高32位相等的时候,才需要比较低32位。如此,我们在比较大小时,优先看高32位,然后想要获取其下标信息时,直接取低32位。 类似的,我们在处理输入的intervals[]数组时也类似处理。将每一个intervals[x]的左边缘放在一个long int数值的高32位,右边缘放在这个long int数值的低32位。这样,这些long int数值,它们之间的相互大小关系,就取决于左边缘的大小关系,而想要获取右边缘时,直接取低32位即可。
  • 小根堆(优先队列):
    • ​​​​​​​ 我们要由小到大处理queries[]数组和intervals[]数组,可以考虑排序,也可以考虑小根堆,这里采用小根堆。

【具体实现】

  1. 将输入的intervals[]数组,每一个intervals[x]的左边缘放在一个long int数值的高32位,右边缘放在这个long int数组的低32位,然后long int数值push入小根堆intervalsHeap。
  2. 将输入的queries[]数组,每一个queries[x]的数值放在一个long int数值的高32位,下标x放在这个long int数值的低32位,然后long int数值push入小根堆queriesHeap。
  3. 逐个从queriesHeap中pop出堆顶元素,这个堆顶元素的高32位就是上面第2步push入堆时,每一个queries[x]的数值,赋值给变量position,低32位就是下标x。
    1. 3.1 从intervalsHeap中pop出所有左边缘(高32位)小于等于position的区间。
    2. 3.2 上面3.1中pop出的每一个区间,把所有右边缘(低32位)大于等于position的区间,都push入一个有效区间小根堆validHeap中。这个validHeap中,以区间的range为高32位,右边缘为低32位,以保证堆顶的区间range始终是最小的。
    3. 3.3 如果validHeap堆顶区间的右边缘(低32位)小于当前的position,则将其弹出。
    4. 3.4 经过上面3.3的操作后,如果validHeap仍然非空,则说明存在包含这个position的区间,且validHeap的堆顶区间的range(高32位)就是题目要求的结果。

代码

/* 几个全局定义的说明。
  INVALID_VALUE:            无效值-1。小根堆中,根节点的父节点使用这个无效值。题目中结果数组里的无效值也是这个-1。
  FATHER_NODE(x):           小根堆中,每一个节点的父节点。其中,根节点的父节点是无效值。
  LEFT_NODE(x):             小根堆中,每一个节点的左子节点。当它大于等于堆size的时候无效。
  RIGHT_NODE(x):            小根堆中,每一个节点的右子节点。当它大于等于堆size的时候无效。
  MERGE_LONG(x, y):         两个int数值合并成一个long int数值,其中x占据高32位,y占据低32位。
  GET_HIGHER32(x):          获取一个long int数值的高32位值。
  GET_LOWER32(x):           获取一个long int数值的低32位值。 */
#define INVALID_VALUE       -1
#define FATHER_NODE(x)      ((0 == (x)) ? INVALID_VALUE : ((x) - 1 >> 1))
#define LEFT_NODE(x)        (((x) << 1) + 1)
#define RIGHT_NODE(x)       (((x) << 1) + 2)
#define MERGE_LONG(x, y)    ((long int)(x) << 32 | (long int)(y))
#define GET_HIGHER32(x)     ((x) >> 32)
#define GET_LOWER32(x)      ((x) & 0xFFFFFFFF)

/* 小根堆的结构定义,里面包括堆空间数组arr[],和堆size。 */
typedef struct
{
    long int *arr;
    int arrSize;
}
HeapStruct;

static void heapPush(HeapStruct *heap, long int t);
static void heapPop(HeapStruct *heap);

/* 主函数的几个变量说明:
  x:                循环下标。
  position:         queries数组中的数值。因为这个数组会带着下标一起入堆,在出堆时,把它的实际数值取出到这个position。
  range:            题目中定义的一个左闭右闭区间的大小,等于“右边缘 - 左边缘 + 1”。
  t:                long int临时数值。
  arr1,arr2,arr3:   几个小根堆中要用到的堆空间数组。
  intervalsHeap:    将输入的intervals数组加入到这个小根堆中,左边缘放高32位,右边缘放低32位。
  queriesHeap:      将输入的queries数组加入到这个小根堆中,数值放高32位,下标放低32位。
  validHeap:        包含着当前position的有效区间的小根堆,区间range放高32位,右边缘放低32位。 */
int *minInterval(int **intervals, int intervalsSize, int *intervalsColSize, int *queries, int queriesSize, int *returnSize)
{
    int x = 0, position = 0, range = 0;
    long int t = 0;
    long int arr1[intervalsSize], arr2[queriesSize], arr3[intervalsSize];
    HeapStruct intervalsHeap, queriesHeap, validHeap;
    int *result = NULL;
    /* 申请结果数组的内存空间。 */
    result = (int *)malloc(sizeof(int) * queriesSize);
    if(NULL == result)
    {
        *returnSize = 0;
        return result;
    }
    /* 堆空间定义,初始化一开始堆都为空。 */
    intervalsHeap.arr = arr1;
    intervalsHeap.arrSize = 0;
    queriesHeap.arr = arr2;
    queriesHeap.arrSize = 0;
    validHeap.arr = arr3;
    validHeap.arrSize = 0;
    /* 把所有的区间放入堆中,左边缘为高优先级,右边缘为低优先级。 */
    while(intervalsSize > x)
    {
        t = MERGE_LONG(intervals[x][0], intervals[x][1]);
        heapPush(&intervalsHeap, t);
        x++;
    }
    /* 把所有的查询放入堆中,位置为高优先级,下标为低优先级。 */
    x = 0;
    while(queriesSize > x)
    {
        t = MERGE_LONG(queries[x], x);
        heapPush(&queriesHeap, t);
        x++;
    }
    /* 一个个查询逐个出堆。 */
    while(0 < queriesHeap.arrSize)
    {
        /* 把下标和位置列出,然后出堆。 */
        x = GET_LOWER32(queriesHeap.arr[0]);
        position = GET_HIGHER32(queriesHeap.arr[0]);
        heapPop(&queriesHeap);
        /* 把所有左边缘小于等于position的区间弹出。 */
        while(0 < intervalsHeap.arrSize && position >= GET_HIGHER32(intervalsHeap.arr[0]))
        {
            /* 右边缘大于等于position的区间放到有效堆中(右边缘小于position的不可能包含当前position)。
            这个有效堆以range为第一优先级,确保堆顶的区间是range最小的。 */
            if(position <= GET_LOWER32(intervalsHeap.arr[0]))
            {
                range = GET_LOWER32(intervalsHeap.arr[0]) - GET_HIGHER32(intervalsHeap.arr[0]) + 1;
                t = MERGE_LONG(range, GET_LOWER32(intervalsHeap.arr[0]));
                heapPush(&validHeap, t);
            }
            heapPop(&intervalsHeap);
        }
        /* 有效堆中,如果堆顶的右边缘小于position,则弹出。这里用到了延迟删除的思想。因为最小堆的pop操作只能针对堆顶。
        上面对validHeap进行push操作之后,堆顶的区间右边缘值可能已经小于当前的位置了,这种情况必须pop出去。 */
        while(0 < validHeap.arrSize && position > GET_LOWER32(validHeap.arr[0]))
        {
            heapPop(&validHeap);
        }
        /* 如果此时的有效堆非空,则当前查询的取值就是堆顶的区间大小,否则就是题目要求的-1。 */
        result[x] = (0 < validHeap.arrSize) ? GET_HIGHER32(validHeap.arr[0]) : INVALID_VALUE;
    }
    /* 返回数组长度等于queriesSize。 */
    *returnSize = queriesSize;
    return result;
}

/* 小根堆的push操作。
为确保其保持为一棵完整二叉树,新push入的数值初始放到堆尾,然后,根据父子节点的大小关系调整位置。 */
static void heapPush(HeapStruct *heap, long int t)
{
    int son = heap->arrSize, father = FATHER_NODE(son);
    heap->arrSize++;
    while(INVALID_VALUE != father && heap->arr[father] > t)
    {
        heap->arr[son] = heap->arr[father];
        son = father;
        father = FATHER_NODE(son);
    }
    heap->arr[son] = t;
    return;
}

/* 小根堆的pop操作。
堆顶弹出后,堆顶空缺,为确保其保持为一棵完整二叉树,将堆尾的数值补充到堆顶,然后,根据父子节点的大小关系调整位置。 */
static void heapPop(HeapStruct *heap)
{
    int father = 0, left = LEFT_NODE(father), right = RIGHT_NODE(father), son = 0;
    long int t = heap->arr[heap->arrSize - 1];
    heap->arrSize--;
    while((heap->arrSize > left && heap->arr[left] < t)
        || (heap->arrSize > right && heap->arr[right] < t))
    {
        son = (heap->arrSize > right && heap->arr[right] < heap->arr[left]) ? right : left;
        heap->arr[father] = heap->arr[son];
        father = son;
        left = LEFT_NODE(father);
        right = RIGHT_NODE(father);
    }
    heap->arr[father] = t;
    return;
}

作者:恒等式
链接:https://leetcode.cn/problems/minimum-interval-to-include-each-query/solutions/2026632/bao-han-mei-ge-cha-xun-de-zui-xiao-qu-ji-lxkj/
来源:力扣(LeetCode)
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。/* 几个全局定义的说明。
  INVALID_VALUE:            无效值-1。小根堆中,根节点的父节点使用这个无效值。题目中结果数组里的无效值也是这个-1。
  FATHER_NODE(x):           小根堆中,每一个节点的父节点。其中,根节点的父节点是无效值。
  LEFT_NODE(x):             小根堆中,每一个节点的左子节点。当它大于等于堆size的时候无效。
  RIGHT_NODE(x):            小根堆中,每一个节点的右子节点。当它大于等于堆size的时候无效。
  MERGE_LONG(x, y):         两个int数值合并成一个long int数值,其中x占据高32位,y占据低32位。
  GET_HIGHER32(x):          获取一个long int数值的高32位值。
  GET_LOWER32(x):           获取一个long int数值的低32位值。 */
#define INVALID_VALUE       -1
#define FATHER_NODE(x)      ((0 == (x)) ? INVALID_VALUE : ((x) - 1 >> 1))
#define LEFT_NODE(x)        (((x) << 1) + 1)
#define RIGHT_NODE(x)       (((x) << 1) + 2)
#define MERGE_LONG(x, y)    ((long int)(x) << 32 | (long int)(y))
#define GET_HIGHER32(x)     ((x) >> 32)
#define GET_LOWER32(x)      ((x) & 0xFFFFFFFF)

/* 小根堆的结构定义,里面包括堆空间数组arr[],和堆size。 */
typedef struct
{
    long int *arr;
    int arrSize;
}
HeapStruct;

static void heapPush(HeapStruct *heap, long int t);
static void heapPop(HeapStruct *heap);

/* 主函数的几个变量说明:
  x:                循环下标。
  position:         queries数组中的数值。因为这个数组会带着下标一起入堆,在出堆时,把它的实际数值取出到这个position。
  range:            题目中定义的一个左闭右闭区间的大小,等于“右边缘 - 左边缘 + 1”。
  t:                long int临时数值。
  arr1,arr2,arr3:   几个小根堆中要用到的堆空间数组。
  intervalsHeap:    将输入的intervals数组加入到这个小根堆中,左边缘放高32位,右边缘放低32位。
  queriesHeap:      将输入的queries数组加入到这个小根堆中,数值放高32位,下标放低32位。
  validHeap:        包含着当前position的有效区间的小根堆,区间range放高32位,右边缘放低32位。 */
int *minInterval(int **intervals, int intervalsSize, int *intervalsColSize, int *queries, int queriesSize, int *returnSize)
{
    int x = 0, position = 0, range = 0;
    long int t = 0;
    long int arr1[intervalsSize], arr2[queriesSize], arr3[intervalsSize];
    HeapStruct intervalsHeap, queriesHeap, validHeap;
    int *result = NULL;
    /* 申请结果数组的内存空间。 */
    result = (int *)malloc(sizeof(int) * queriesSize);
    if(NULL == result)
    {
        *returnSize = 0;
        return result;
    }
    /* 堆空间定义,初始化一开始堆都为空。 */
    intervalsHeap.arr = arr1;
    intervalsHeap.arrSize = 0;
    queriesHeap.arr = arr2;
    queriesHeap.arrSize = 0;
    validHeap.arr = arr3;
    validHeap.arrSize = 0;
    /* 把所有的区间放入堆中,左边缘为高优先级,右边缘为低优先级。 */
    while(intervalsSize > x)
    {
        t = MERGE_LONG(intervals[x][0], intervals[x][1]);
        heapPush(&intervalsHeap, t);
        x++;
    }
    /* 把所有的查询放入堆中,位置为高优先级,下标为低优先级。 */
    x = 0;
    while(queriesSize > x)
    {
        t = MERGE_LONG(queries[x], x);
        heapPush(&queriesHeap, t);
        x++;
    }
    /* 一个个查询逐个出堆。 */
    while(0 < queriesHeap.arrSize)
    {
        /* 把下标和位置列出,然后出堆。 */
        x = GET_LOWER32(queriesHeap.arr[0]);
        position = GET_HIGHER32(queriesHeap.arr[0]);
        heapPop(&queriesHeap);
        /* 把所有左边缘小于等于position的区间弹出。 */
        while(0 < intervalsHeap.arrSize && position >= GET_HIGHER32(intervalsHeap.arr[0]))
        {
            /* 右边缘大于等于position的区间放到有效堆中(右边缘小于position的不可能包含当前position)。
            这个有效堆以range为第一优先级,确保堆顶的区间是range最小的。 */
            if(position <= GET_LOWER32(intervalsHeap.arr[0]))
            {
                range = GET_LOWER32(intervalsHeap.arr[0]) - GET_HIGHER32(intervalsHeap.arr[0]) + 1;
                t = MERGE_LONG(range, GET_LOWER32(intervalsHeap.arr[0]));
                heapPush(&validHeap, t);
            }
            heapPop(&intervalsHeap);
        }
        /* 有效堆中,如果堆顶的右边缘小于position,则弹出。这里用到了延迟删除的思想。因为最小堆的pop操作只能针对堆顶。
        上面对validHeap进行push操作之后,堆顶的区间右边缘值可能已经小于当前的位置了,这种情况必须pop出去。 */
        while(0 < validHeap.arrSize && position > GET_LOWER32(validHeap.arr[0]))
        {
            heapPop(&validHeap);
        }
        /* 如果此时的有效堆非空,则当前查询的取值就是堆顶的区间大小,否则就是题目要求的-1。 */
        result[x] = (0 < validHeap.arrSize) ? GET_HIGHER32(validHeap.arr[0]) : INVALID_VALUE;
    }
    /* 返回数组长度等于queriesSize。 */
    *returnSize = queriesSize;
    return result;
}

/* 小根堆的push操作。
为确保其保持为一棵完整二叉树,新push入的数值初始放到堆尾,然后,根据父子节点的大小关系调整位置。 */
static void heapPush(HeapStruct *heap, long int t)
{
    int son = heap->arrSize, father = FATHER_NODE(son);
    heap->arrSize++;
    while(INVALID_VALUE != father && heap->arr[father] > t)
    {
        heap->arr[son] = heap->arr[father];
        son = father;
        father = FATHER_NODE(son);
    }
    heap->arr[son] = t;
    return;
}

/* 小根堆的pop操作。
堆顶弹出后,堆顶空缺,为确保其保持为一棵完整二叉树,将堆尾的数值补充到堆顶,然后,根据父子节点的大小关系调整位置。 */
static void heapPop(HeapStruct *heap)
{
    int father = 0, left = LEFT_NODE(father), right = RIGHT_NODE(father), son = 0;
    long int t = heap->arr[heap->arrSize - 1];
    heap->arrSize--;
    while((heap->arrSize > left && heap->arr[left] < t)
        || (heap->arrSize > right && heap->arr[right] < t))
    {
        son = (heap->arrSize > right && heap->arr[right] < heap->arr[left]) ? right : left;
        heap->arr[father] = heap->arr[son];
        father = son;
        left = LEFT_NODE(father);
        right = RIGHT_NODE(father);
    }
    heap->arr[father] = t;
    return;
}

网站文章

  • Rest_Assured接口测试-配置环境信息

    整合代码 ,多环境测试 切换测试环境地址

    2024-02-01 05:33:57
  • typescript基本数据类型

    ts共有7种基本数据类型分别为: Boolean Number String Array Enum Any Void对各种数据类型的声明以及注意事项都浓缩在如下代码块,为了方便您可以可自行粘贴运行:如果您还不会编译ts文件请点击这里看我的另一篇文章《typescript安装及如何编译运行》/** * ts基本数据类型 * Boolean * Number *...

    2024-02-01 05:33:50
  • Linux——设备树 最新发布

    Linux——设备树 最新发布

    包括linux设备树的由来,使用设备树的目的,怎样去使用设备树以及用一个简单小例子进行举例。

    2024-02-01 05:33:42
  • 深度学习&amp;图像处理(色彩编辑4)

    深度学习&amp;图像处理(色彩编辑4)

    1.YUV转换 YUV,是一种颜色编码方法。“Y”表示明亮度(Luminance或Luma),也就是灰阶值,“U”和“V”表示的则是色度(Chrominance或Chroma),作用是描述影像色彩及饱...

    2024-02-01 05:33:14
  • 单链表与双链表(C语言)

    单链表的创建(头插法、尾插法),单链表的插入、删除等双链表的创建(头插法、尾插法),单链表的插入、删除等#include <stdio.h>#include <iostream>using names...

    2024-02-01 05:33:07
  • FTP的工作方式:Active FTP 及 Passive FTP

    FTP的工作方式:Active FTP 及 Passive FTP

    <br />為何常常連上 FTP 站台後,進去後就停留且無法列表?<br /><br />防火牆有很多種,其中有一些會禁止那些不是從內部網路IP發出的連接請求。而FTP協議是個很老的東東,沒有考慮這個...

    2024-02-01 05:33:00
  • /usr/lib64/libstdc++.so.6: version `GLIBCXX_3.4.9' not found

    问题:./a.out: /usr/lib64/libstdc++.so.6: version `GLIBCXX_3.4.9' not found (required by /home/ycai/x10/stdlib/lib/libx10.so)可能的解决方案:第一种方案:执行strings /usr/lib64/libstdc++.so.6 | grep GLIBC

    2024-02-01 05:32:33
  • 相对(relative)定位和绝对(absolute)定位

    相对(relative)定位和绝对(absolute)定位

    首先,position的这两个属性一般是不使用的,因为有了浮动,所以我们才需要position属性来实现我们想要的布局。 1.相对定位(relative):相对于原来位置(原来位置指在文档流中默认的位置,若加上了浮动时,那么这个原来位置就是你设定浮动时的位置)的偏移,原来位置依然占据空间。 (1)box1和box2都没有设置position属性(没有设置float属性时) 效果图:我...

    2024-02-01 05:32:28
  • 威胁驱动的网络安全方法论

    威胁驱动的网络安全方法论

    本文主要内容取自洛克希德·马丁公司的论文:A Threat-Driven Approach to Cyber Security,想要全面准确了解论文内容的朋友建议阅读原文。希望能够抛砖引玉,为相关领域...

    2024-02-01 05:32:20
  • 解决eclipse集成maven插件 add dependencies搜索不到jar包的问题

    解决eclipse集成maven插件 add dependencies搜索不到jar包的问题

    背景: 新建了maven项目,要添加jar包,但有不想去网上一个一个搜索再写到pom.xml里 所以想在add dependencies中搜索添加,奈何搜索出来只有本地的那几个jar包(默认) 尝试: 去百度查了很多解决方法... 如:1、配置阿里的远程仓库,但...又报错-找不到xxx.zip文件~ 2、设置eclipse的属性啊...没有效果 3、删除...

    2024-02-01 05:32:13