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

news2024/11/29 21:28:48

题目

 

示例

 

思路

  • 离线查询：
    •  输入的结果数组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;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/768872.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Go语言之接口（interface）

Go语言之接口（interface）

1.1 、多态的含义 在java里&#xff0c;多态是同一个行为具有不同表现形式或形态的能力&#xff0c;即对象多种表现形式的体现&#xff0c;就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定&#xff0c;而是在程序运行期间才确定&am…
阅读更多...
T5模型: Transfer Text-to-Text Transformer（谷歌）

T5模型: Transfer Text-to-Text Transformer（谷歌）

&#x1f525; T5由谷歌发表于2019&#xff0c;《Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer》&#xff0c;最终版本发布在&#xff1a;JMLR。 一句话总结T5: 大一统模型&#xff0c;seq2seq形式完成各类nlp任务&#xff0c;大数据集…
阅读更多...
Docker 的前世今生：从社区到市场，从领域到技术应用的全方位分析

Docker 的前世今生：从社区到市场，从领域到技术应用的全方位分析

博主 默语带您 Go to New World. ✍ 个人主页—— 默语 的博客&#x1f466;&#x1f3fb; 《java 面试题大全》 &#x1f369;惟余辈才疏学浅&#xff0c;临摹之作或有不妥之处&#xff0c;还请读者海涵指正。☕&#x1f36d; 《MYSQL从入门到精通》数据库是开发者必会基础之…
阅读更多...
下载编译Chromium

下载编译Chromium

参考&#xff1a;Mac上本地编译Chrome浏览器踩坑笔记&#xff08;2021.02最新&#xff09; - 掘金 For Mac: 一、下载编译工具链&#xff1a;deptool git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git export PATH"$PATH:/Users/yumlu/co…
阅读更多...
jib进行本地打包，并上传本地镜像仓库

jib进行本地打包，并上传本地镜像仓库

使用 Jib 进行本地打包和上传到本地镜像仓库是一种方便的方式&#xff0c;而无需编写 Dockerfile。Jib 是一个开源的 Java 容器镜像构建工具&#xff0c;它可以直接将 Java 项目打包为镜像&#xff0c;并将其推送到容器镜像仓库。 gradle 进行jib的配置 import java.time.Zon…
阅读更多...
第53步 深度学习图像识别：Bottleneck Transformer建模（Pytorch）

第53步 深度学习图像识别：Bottleneck Transformer建模（Pytorch）

基于WIN10的64位系统演示 一、写在前面 &#xff08;1&#xff09;Bottleneck Transformer "Bottleneck Transformer"&#xff08;简称 "BotNet"&#xff09;是一种深度学习模型&#xff0c;在2021年由Google的研究人员在论文"Bottleneck Transfor…
阅读更多...
MaxCompute与 Mysql 之单字段转多行

MaxCompute与 Mysql 之单字段转多行

在实际数据处理中&#xff0c;可能会遇到行列转换的数据处理&#xff0c;在 MaxCompute 与 AnalyticDB MySQL 数据处理与转换 介绍过如多行转一行&#xff0c;本篇主要介绍将逗号分割的字段转成多行。 一、MaxCompute 实现方式 在MaxCompute中有TRANS_ARRAY函数&#xff0c;可…
阅读更多...
显示一行或两行多出的文字用省略号代替

显示一行或两行多出的文字用省略号代替

以上就是一行的效果&#xff0c;超出宽度就用...代替 .recommendContainer .scrollItem text{/* 单行文本溢出隐藏 省略号代替 */display: block;white-space: nowrap; /*溢出不换行*/overflow: hidden; /*溢出隐藏*/text-overflow: ellipsis; /*溢出的内容已...代替*/} 多…
阅读更多...
watch中监听vuex中state改变监听不到

watch中监听vuex中state改变监听不到

watch中监听vuex中state改变监听不到 https://blog.csdn.net/aliven1/article/details/100581529?utm_mediumdistribute.pc_relevant.none-task-blog-2defaultbaidujs_baidulandingword~default-0-100581529-blog-122614448.t5_layer_targeting_sa&spm1001.2101.3001.4242…
阅读更多...
软通动力与华秋达成生态共创合作，共同推动物联网硬件创新

软通动力与华秋达成生态共创合作，共同推动物联网硬件创新

7月11日&#xff0c;在2023慕尼黑上海电子展现场&#xff0c;软通动力信息技术(集团)股份有限公司(以下简称“软通动力”)与深圳华秋电子有限公司(以下简称“华秋”)签署了生态共创战略合作协议&#xff0c;共同推动物联网硬件生态繁荣发展。当前双方主要基于软通动力的产品及解…
阅读更多...
从Vue2到Vue3【二】——Composition API（第二章）

从Vue2到Vue3【二】——Composition API（第二章）

系列文章目录 内容链接从Vue2到Vue3【零】Vue3简介及创建从Vue2到Vue3【一】Composition API&#xff08;第一章&#xff09; 文章目录 系列文章目录前言一、 生命周期二、hook三、toRef以及toRefs总结 前言 Vue3作为Vue.js框架的最新版本&#xff0c;引入了许多令人激动的新…
阅读更多...
vue项目部署自动检测更新

vue项目部署自动检测更新

前言 当我们重新部署前端项目的时候&#xff0c;如果用户一直停留在页面上并未刷新使用&#xff0c;会存在功能使用差异性的问题&#xff0c;因此&#xff0c;当前端部署项目后&#xff0c;需要提醒用户有去重新加载页面。 在以往解决方案中&#xff0c;不少人会使用websocke…
阅读更多...
C#基础--委托

C#基础--委托

C#基础–委托 C#基础–委托 简单说它就是一个能把方法当参数传递的对象，而且还知道怎么调用这个方法，同时也是粒度更小的“接口”（约束了指向方法的签名） 一、什么是委托，委托的本质是什么？ 跟方法有点类似，有参数，返回值，访问修饰符+ delegate public delegate void …
阅读更多...
Python 算法基础篇：哈希表与散列函数

Python 算法基础篇：哈希表与散列函数

Python 算法基础篇&#xff1a;哈希表与散列函数 引用 1. 哈希表的概念2. 散列函数的概念 a ) 一致性 b ) 均匀性 c ) 高效性 3. 散列函数的实现4. 哈希表的实现5. 哈希表的冲突解决 a ) 链地址法 b ) 开放地址法 6. 实例演示实例&#xff1a;电话簿 总结 引用 哈希表是一种高…
阅读更多...
[计算机入门] 文件夹(目录)及路径

[计算机入门] 文件夹(目录)及路径

2.7 文件夹(目录)及路径 文件夹&#xff08;folder、目录&#xff09;是一种用于存储和组织文件和其他文件夹的容器。它可以包含任意数量的文件和子文件夹&#xff0c;并且可以通过拖放、复制和粘贴等操作来移动、复制和管理这些文件和子文件夹。 Windows文件夹可以帮助用户更…
阅读更多...
spring复习：（43）使用TransactionProxyFactoryBean来实现事务时，事务是怎么开启的？

spring复习：（43）使用TransactionProxyFactoryBean来实现事务时，事务是怎么开启的？

一、配置文件&#xff1a; <bean id"myFactoryBean"class"org.springframework.transaction.interceptor.TransactionProxyFactoryBean"><property name"transactionManager" ref"transactionManager" /><property nam…
阅读更多...
可以替代微软 Exchange 的 几个开源软件分享给你

可以替代微软 Exchange 的 几个开源软件分享给你

微软Exchange是一个功能强大的邮件和群件解决方案&#xff0c;但对于一些用户来说&#xff0c;寻找替代方案可能是必要的。幸运的是&#xff0c;有几个开源软件提供了可靠而且功能丰富的替代选项。这些开源软件不仅可以满足组织和个人的邮件和协作需求&#xff0c;还具有灵活性…
阅读更多...
quartus18.0如何下载安装Cyclone V器件库

quartus18.0如何下载安装Cyclone V器件库

文章目录 前言一、下载流程二、添加步骤三、总结四、参考资料 前言 在我们使用不同版本的板子的时候&#xff0c;我们需要在quartus下安装不同型号的器件库才能对板子进行选型并进行下一步操作。 一、下载流程 官网下载地址 这里我们点击支持选中下载中心&#xff1a; 选择FPGA…
阅读更多...
reggie优化04-Nginx

reggie优化04-Nginx

官方网站下载&#xff1a;http://nginx.org/en/download.html 1、Nginx安装 这里需要在Linux系统下&#xff1a; 安装wget工具&#xff1a;yum install wget&#xff08;或者官网下载直接上传到Linux&#xff09; 安装树形结构tree&#xff1a;yum install tree 2、Nginx命令 …
阅读更多...
在云计算环境中，保护Java应用程序可用的有效措施和工具

在云计算环境中，保护Java应用程序可用的有效措施和工具

云计算&#xff08;Cloud&#xff09;技术是近年来计算机科学的一个重要突破。大多数组织已经通过将自己的应用程序移入云平台而获益。不过&#xff0c;如何保证应用程序在第三方服务器上的安全性&#xff0c;是一项艰巨的挑战。 在本文中&#xff0c;我们将重点讨论Java&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023