线段树 2016.4.13

最新推荐文章于 2021-08-11 22:04:32 发布
最新推荐文章于 2021-08-11 22:04:32 发布
阅读量414 收藏
点赞数 1
文章标签： 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Only_AiR/article/details/51126766
版权

一、定义

线段树（Segment Tree ）是一种二叉搜索树

不是真正的完全二叉树，但十分近似

它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点

对于线段树中的每一个非叶子节点[a, b]，它的左儿子表示的区间为[a, (a+b)/2]，右儿子表示的区间为[(a+b)/2+1 ,b]
因此线段树是平衡二叉树

由于二叉树结构的特性，它基本能保持每个操作的时间复杂度为O(logN)

线段树在数组存储的方式下需要占用的空间约为4N

这里写图片描述

二、创建线段树

如果当前结点记录的区间只有一个值，则直接赋值
否则递归构造左右子树
回溯的时候给当前结点赋值

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

struct SegTree {
    int left, right;
    int val;
};

const int maxn = 5 + 5;
int num[maxn];
SegTree Tree[maxn * 4];

void Build(int low, int high, int index);

int main()
{
    for (int i=1; i<=5; ++i) {
        num[i] = i;
    }
    Build(1, 5, 1);
    for (int i=1; i<=9; ++i) {
        printf("%d %d %d\n", Tree[i].left, Tree[i].right, Tree[i].val);
    }
    return 0;
}

void Build(int low, int high, int index)
{
    Tree[index].left = low;
    Tree[index].right = high;
    if (low == high) {
        Tree[index].val = num[low];
        return;
    } else {
        int mid = low + (high-low)/2;
        Build(low, mid, index*2);
        Build(mid+1, high, index*2+1);
    }
}

这里写图片描述

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

struct SegTree {
    int left, right;
    int Max;
};

const int maxn = 5 + 5;
int num[maxn];
SegTree Tree[maxn * 4];

void Build(int low, int high, int index);

int main()
{
    for (int i=1; i<=5; ++i) {
        num[i] = i;
    }
    Build(1, 5, 1);
    for (int i=1; i<=9; ++i) {
        printf("%d %d %d\n", Tree[i].left, Tree[i].right, Tree[i].Max);
    }
    return 0;
}

void Build(int low, int high, int index)
{
    Tree[index].left = low;
    Tree[index].right = high;
    if (low == high) {
        Tree[index].Max = num[low];
        return;
    } else {
        int mid = low + (high-low)/2;
        Build(low, mid, index*2);
        Build(mid+1, high, index*2+1);
        Tree[index].Max = max(Tree[index*2].Max, Tree[index*2+1].Max);
    }
}

这里写图片描述

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

struct SegTree {
    int left, right;
    int sum;
};

const int maxn = 5 + 5;
int num[maxn];
SegTree Tree[maxn * 4];

void Build(int low, int high, int index);

int main()
{
    for (int i=1; i<=5; ++i) {
        num[i] = i;
    }
    Build(1, 5, 1);
    for (int i=1; i<=9; ++i) {
        printf("%d %d %d\n", Tree[i].left, Tree[i].right, Tree[i].sum);
    }
    return 0;
}

void Build(int low, int high, int index)
{
    Tree[index].left = low;
    Tree[index].right = high;
    if (low == high) {
        Tree[index].sum = num[low];
        return;
    } else {
        int mid = low + (high-low)/2;
        Build(low, mid, index*2);
        Build(mid+1, high, index*2+1);
        Tree[index].sum = Tree[index*2].sum + Tree[index*2+1].sum;
    }
}

这里写图片描述

三、单结点更新 + 区间查询

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

struct SegTree {
    int left, right;
    int sum;
};

const int maxn = 5 + 5;
int num[maxn];
SegTree Tree[maxn * 4];

void Build(int low, int high, int index);
void Update(int target, int add, int index);
int Query(int low, int high, int index);

int main()
{
    for (int i=1; i<=5; ++i) {
        num[i] = i;
    }
    Build(1, 5, 1);
    Update(2, 2, 1);
    printf("%d\n", Query(1, 4, 1));
    printf("%d\n", Query(4, 5, 1));
    for (int i=1; i<=9; ++i) {
        printf("%d %d %d\n", Tree[i].left, Tree[i].right, Tree[i].sum);
    }
    return 0;
}

void Build(int low, int high, int index)
{
    Tree[index].left = low;
    Tree[index].right = high;
    if (low == high) {
        Tree[index].sum = num[low];
        return;
    } else {
        int mid = low + (high-low)/2;
        Build(low, mid, index*2);
        Build(mid+1, high, index*2+1);
        Tree[index].sum = Tree[index*2].sum + Tree[index*2+1].sum;
    }
}

void Update(int target, int add, int index)
{
    if (Tree[index].left == Tree[index].right && Tree[index].left == target) {
        Tree[index].sum += add;
        return;
    } else {
        int mid = Tree[index].left + (Tree[index].right - Tree[index].left)/2;
        if (target <= mid) {
            Update(target, add, index*2);
        } else {
            Update(target, add, index*2+1);
        }
        Tree[index].sum = Tree[index*2].sum + Tree[index*2+1].sum;
    }
}

int Query(int low, int high, int index)
{
    if (Tree[index].left == low && Tree[index].right == high) {
        return Tree[index].sum;
    } else {
        int mid = Tree[index].left + (Tree[index].right-Tree[index].left)/2;
        if (high <= mid) {
            return Query(low, high, index*2);
        } else if (low > mid) {
            return Query(low, high, index*2+1);
        } else {
            return Query(low, mid, index*2) + Query(mid+1, high, index*2+1);
        }
    }
}
void Update(int target, int add, int index);

Update(2, 2, 1);

Query(1, 4, 1) = 12;
Query(4, 5, 1) = 9;

这里写图片描述

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

struct SegTree {
    int left, right;
    int Max;
};

const int maxn = 5 + 5;
int num[maxn];
SegTree Tree[maxn * 4];

void Build(int low, int high, int index);
void Update(int target, int val, int index);
int Query(int low, int high, int index);

int main()
{
    for (int i=1; i<=5; ++i) {
        num[i] = i;
    }
    Build(1, 5, 1);
    Update(3, 6, 1);
    printf("%d\n", Query(2, 5, 1));
    printf("%d\n", Query(3, 4, 1));
    for (int i=1; i<=9; ++i) {
        printf("%d %d %d\n", Tree[i].left, Tree[i].right, Tree[i].Max);
    }
    return 0;
}

void Build(int low, int high, int index)
{
    Tree[index].left = low;
    Tree[index].right = high;
    if (low == high) {
        Tree[index].Max = num[low];
        return;
    } else {
        int mid = low + (high-low)/2;
        Build(low, mid, index*2);
        Build(mid+1, high, index*2+1);
        Tree[index].Max = max(Tree[index*2].Max, Tree[index*2+1].Max);
    }
}

void Update(int target, int val, int index)
{
    if (Tree[index].left == Tree[index].right && Tree[index].left == target) {
        Tree[index].Max = val;
        return;
    } else {
        int mid = Tree[index].left + (Tree[index].right - Tree[index].left)/2;
        if (target <= mid) {
            Update(target, val, index*2);
        } else {
            Update(target, val, index*2+1);
        }
        Tree[index].Max = max(Tree[index*2].Max, Tree[index*2+1].Max);
    }
}

int Query(int low, int high, int index)
{
    if (Tree[index].left == low && Tree[index].right == high) {
        return Tree[index].Max;
    } else {
        int mid = Tree[index].left + (Tree[index].right-Tree[index].left)/2;
        if (high <= mid) {
            return Query(low, high, index*2);
        } else if (low > mid) {
            return Query(low, high, index*2+1);
        } else {
            return max(Query(low, mid, index*2), Query(mid+1, high, index*2+1));
        }
    }
}
void Update(int target, int val, int index);
Update(3, 6, 1);

Query(2, 5, 1) = 6;
Query(3, 4, 1) = 6;

这里写图片描述

四、区间更新 + 区间查询

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

struct SegTree {
    int left, right;
    int val;
};

const int maxn = 5 + 5;
SegTree Tree[maxn * 4];

void Build(int low, int high, int index);
void Update(int low, int high, int val, int index);
int Query(int low, int high, int index);

int main()
{
    Build(1, 5, 1);
//    Update(2, 3, 2, 1);
//    Update(4, 5, 3, 1);
//    printf("%d\n", Query(1, 3, 1));
    Update(1, 3, 2, 1);
    Update(4, 4, 3, 1);
    printf("%d\n", Query(1, 4, 1));
    printf("%d\n", Query(1, 2, 1));
    for (int i=1; i<=9; ++i) {
        printf("%d %d %d\n", Tree[i].left, Tree[i].right, Tree[i].val);
    }
    return 0;
}

void Build(int low, int high, int index)
{
    Tree[index].left = low;
    Tree[index].right = high;
    Tree[index].val = 1;
    if (low == high) {
        return;
    } else {
        int mid = low + (high-low)/2;
        Build(low, mid, index*2);
        Build(mid+1, high, index*2+1);
    }
}

void Update(int low, int high, int val, int index)
{
    if (Tree[index].val == val || (Tree[index].left == low && Tree[index].right == high)) {
        Tree[index].val = val;
        return;
    } else {
        if (Tree[index].val != 0) {
            Tree[index*2].val = Tree[index].val;
            Tree[index*2+1].val = Tree[index].val;
            Tree[index].val = 0;
        }
        int mid = Tree[index].left + (Tree[index].right - Tree[index].left)/2;
        if (high <= mid) {
            Update(low, high, val, index*2);
        } else if (low > mid) {
            Update(low, high, val, index*2+1);
        } else {
            Update(low, mid, val, index*2);
            Update(mid+1, high, val, index*2+1);
        }
    }
}

int Query(int low, int high, int index)
{
    int mid = Tree[index].left + (Tree[index].right - Tree[index].left)/2;
    if (Tree[index].left == low && Tree[index].right == high) {
        if (Tree[index].val != 0) {
            return Tree[index].val * (high-low+1);
        } else {
            return Query(low, mid, index*2) + Query(mid+1, high, index*2+1);
        }
    } else {
        if (high <= mid) {
            return Query(low, high, index*2);
        } else if (low > mid) {
            return Query(low, high, index*2+1);
        } else {
            return Query(low, mid, index*2) + Query(mid+1, high, index*2+1);
        }
    }
}

这里写图片描述

void Update(int low, int high, int val, int index);
Update(2, 3, 2, 1);
Update(4, 5, 3, 1);

Query(1, 3, 1) = 5;

这里写图片描述

Update(1, 3, 2, 1);
Update(4, 4, 3, 1);

Query(1, 4, 1) = 9;
Query(1, 2, 1) = 2;

这里写图片描述

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

struct SegTree {
    int left, right;
    int sum;
    int val;
};

const int maxn = 5 + 5;
int num[maxn];
SegTree Tree[maxn * 4];

void Build(int low, int high, int index);
void Update(int low, int high, int add, int index);
int Query(int low, int high, int index);

int main()
{
    for (int i=1; i<=5; ++i) {
        num[i] = i;
    }
    Build(1, 5, 1);
    Update(2, 3, 2, 1);
    printf("%d\n", Query(2, 2, 1));
    printf("%d\n", Query(3, 4, 1));
    Update(4, 5, 3, 1);
    printf("%d\n", Query(5, 5, 1));
    for (int i=1; i<=9; ++i) {
        printf("%d %d %d\n", Tree[i].left, Tree[i].right, Tree[i].sum);
    }
    return 0;
}

void Build(int low, int high, int index)
{
    Tree[index].left = low;
    Tree[index].right = high;
    Tree[index].val = 0;
    if (low == high) {
        Tree[index].sum = num[low];
        return;
    } else {
        int mid = low + (high-low)/2;
        Build(low, mid, index*2);
        Build(mid+1, high, index*2+1);
        Tree[index].sum = Tree[index*2].sum + Tree[index*2+1].sum;
    }
}

void Update(int low, int high, int add, int index)
{
    if (Tree[index].left == low && Tree[index].right == high) {
        Tree[index].val += add;
        return;
    } else {
        Tree[index].sum += add * (high-low+1);
        int mid = Tree[index].left + (Tree[index].right - Tree[index].left)/2;
        if (high <= mid) {
            Update(low, high, add, index*2);
        } else if (low > mid) {
            Update(low, high, add, index*2+1);
        } else {
            Update(low, mid, add, index*2);
            Update(mid+1, high, add, index*2+1);
        }
    }
}

int Query(int low, int high, int index)
{
    if (Tree[index].left == low && Tree[index].right == high) {
        return Tree[index].sum + (high-low + 1) * Tree[index].val;
    } else {
        Tree[index].sum += (Tree[index].right-Tree[index].left + 1) * Tree[index].val;

        int mid = Tree[index].left + (Tree[index].right - Tree[index].left)/2;
        Update(Tree[index].left, mid, Tree[index].val, index*2);
        Update(mid+1, Tree[index].right, Tree[index].val, index*2+1);
        Tree[index].val = 0;

        if (high <= mid) {
            return Query(low, high, index*2);
        } else if (low > mid) {
            return Query(low, high, index*2+1);
        } else {
            return Query(low, mid, index*2) + Query(mid+1, high, index*2+1);
        }
    }
}
void Update(int low, int high, int add, int index);
Update(2, 3, 2, 1);

这里写图片描述

Query(2, 2, 1) = 4;
Query(3, 4, 1) = 9;
Update(4, 5, 3, 1);

这里写图片描述

Query(5, 5, 1)

这里写图片描述

Query(5, 5, 1) = 8;
__AiR_H
关注
专栏目录
线段树 2016.4.15
追风蹑影
04-13 345
1、HDU 1166 敌兵布阵 单点更新 #include #include #include using namespace std; typedef long long LL; struct SegTree { int left, right; LL sum; }; const int maxn = 50000 + 5; int num[maxn]; SegT
2016.4.10 线段树练习
weixin_30763397的博客
04-10 52
1.codevs1081 线段树练习 2 1081 线段树练习 2 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 大师 Master 题目描述Description 给你N个数，有两种操作 1：给区间[a,b]的所有数都增加X 2：询问第i个数是什么？ 输...
【NOIP模拟题】【线段树】2016.11.10第三题题解
It's Maverick.
11-11 480
c 一看这么多修改询问就可以猜到是线段树，但是我们没有办法直接搞线段树，于是我们对树做一次dfs生成一个2*N的序列,L[u],R[u]分别表示刚进入子树u时的dfs序列位置和刚处理完子树u时的dfs序列位置。则l[u]到r[u]这一段便是子树u的所有节点。我们对每个节点记录两个值cnt，k，每个节点v的实际值w = cnt *dep[v] + k,则原操作add u x可以看成是对每个子
有趣的线段树模板合集（线段树，最短/长路，单调栈，线段树合并，线段树分裂，树上差分，Tarjan-LCA，势能线段树，李超线段树）...
a83229442的博客
09-15 247
线段树分裂 以某个键值为中点将线段树分裂成左右两部分，应该类似Treap的分裂吧（我菜不会Treap）。一般应用于区间排序。 方法很简单，就是把分裂之后的两棵树的重复的\(\log\)个节点新建出来，单次时间复杂度严格\(O(\log n)\)。 至于又有合并又有分裂的复杂度，蒟蒻一直不会比较有说服力的证明，直到看见SovietPower巨佬的题解 对于只有合并：合并两棵线段树的过程，是...
2016.7.13 树形动规
NULL
10-14 270
RMQ算法讲完没几个小时，我们就开始了小紫中的一节（足见这个算法很重要）——树形动归； 参考资料：     1.焦作一中信息学oy（http://www.cnblogs.com/gq-ouyang/archive/2013/02/26/2933431.html     2.小黄（信息学奥赛一本通）     3.小紫（算法竞赛入门经典第二版） 题型总结：（来自资料1     1、加分二叉
2016.7.9 线段树（未完成版）
NULL
10-14 207
可能是直到几天前的那天晚上时间不够，今天老师几乎给了我们一整天来刷题，不过......感觉不太妙orz;     参考资料：     1.线段树课件（来自buctears;     2.线段树讲义（未注名     3.线段树+位总结（http://blog.csdn.net/byijie/article/details/8586499     4.poj2777题解 （http://bl
Urozero Autumn 2016. NCPC 2016
weixin_34233421的博客
04-21 167
A. Artwork 倒过来并查集维护即可。 #include&lt;cstdio&gt; #include&lt;algorithm&gt; using namespace std; const int N=1111; int n,m,q,i,j,ce; bool black[N][N]; bool v[N*N]; int f[N*N]; int res; int an...
2016.9.4
weixin_30662109的博客
09-04 61
1 　　好久没做CodeForces了，今天做了下#368，D题不会做。一开始想的是用线段树，结果仔细一看题人家要每个点的状态，结果就萎了。上网查了一下貌似要用到主席树这种东东。打开了好几个介绍细节的博客，却一直没耐心看下去。我总是这样，YY的巨人，行动上的矮子。 2 　　楼下的原汤番茄似乎没以前好吃了，汤变得好酸。现在那里的人看到我都不用问我要什么了......上次去的时候想着以后换...
2016.4.23 浙江省赛题解
热门推荐
Eminem1147的博客
04-23 1万+
Apples and Ideas Time Limit: 2 Seconds      Memory Limit: 65536 KB "If you have an apple and I have an apple and we exchange these apples then you and I will still each have one apple. But if
NOIP模拟题 2016.11.14 [动态规划] [线段树优化DP] [字符串的复制粘贴DP]
C'est la vie.
11-14 1159
复制&粘贴2(A.c/cpp/pas/in/out) (Time Limit:1s Memory Limit:256MB) 【Description】 文本编辑器的一个最重要的机能就是复制&粘贴。JOI社现在正在开发一款能够非常高速地进行复制&粘贴的文本编辑器，作为JOI社一名优秀的程序猿，你担负起了复制&粘贴功能的测试这一核心工作。整个JOI社的命运都系在你的身上，因此你无论如何都想写出一个
NOIP模拟题 2016.11.9 [动态规划] [数论] [二分答案] [启发式合并] [线段树] [树链剖分]
C'est la vie.
11-09 1071
子序列 描述 给定3 个字符串，求它们的最长公共子序列。 输入 第一行一个整数n，表示三个字符串的长度 接下来三行，每行是一个长度为n 只包含小写字母的字符串。 输出 输出最长公共子序列的长度。 输入样例 4 abac abbc cbca 输出样例 2 提示 30% n<=10 100% n<=120T1： 三个串的LCS。。直接DP。。#include<iost
【学习笔记】吉司机线段树
Miniqwq的博客
08-11 3784
本文同步在洛谷博客上进行发表。 这是一篇刚开始学习线段树的小白都能看懂的良心学习笔记！ 前置知识：含有懒标记的线段树（没别的了）。 总述 什么是吉司机线段树？ 就是维护区间最值和区间历史最值的线段树，它的名字来源于吉如一老师，他在 201620162016 年发表了一篇集训队论文。 不过为啥这位老师被称为吉司机我也不知道…… 废话不多说，马上进入正题吧。 正题 例题：Luogu 6242 读完题我们发现，一般线段树题目只需要用到一个数组，而这道题用了两个，多出来了个 BBB 数组，是不是要拆成两棵树？ 通过
[线段树练习4] 线段颜色条数 - 统计标记总数
Bill_Yang_2016的博客
02-05 1052
题目描述X轴上从下向上依次叠放一定长度的某种颜色的线段。问从上向下看X轴，它被分成了不同颜色的多少段？输入格式第1行：2个整数XC，N。XC表示X轴的颜色，1<=N<=100000，表示线段的条数，其中X轴的范围为[-100000,100000]。。 接下来N行，每行3个整数L，R，C，-100000 <=L<=R<= 100000，表示一线段的左、右端点；1<=C<=100000，表示线段的颜色
0x43.数据结构进阶 - 线段树
繁凡さん的博客
06-08 695
目录线段树的建树线段树的单点修改线段树的区间查询POJ3486A Simple Problem with Integers 声明： 本系列博客是《算法竞赛进阶指南》+《算法竞赛入门经典》+《挑战程序设计竞赛》的学习笔记，主要是因为我三本都买了 按照《算法竞赛进阶指南》的目录顺序学习，包含书中的少部分重要知识点、例题解题报告及我个人的学习心得和对该算法的补充拓展，仅用于学习交流和复习，无任何商业用途。博客中部分内容来源于书本和网络（我尽量减少书中引用），由我个人整理总结（习题和代码可全都是我自己敲哒）部分
实现朴素贝叶斯分类器对西瓜书数据集3.0进行分类_Naive-Bayesian-classifier.zip
最新发布
10-01
实现朴素贝叶斯分类器对西瓜书数据集3.0进行分类_Naive-Bayesian-classifier
基于Python与Shell的system-design-primer大型系统设计源码学习指南
10-01
该项目是一个大型系统设计源码学习指南，采用Python和Shell编程语言编写，包含127个文件，其中包括54个PNG图像文件、23个Markdown文档、17个Graffle文件、14个Python源代码文件、6个Jupyter Notebook文件、5个JPG图片文件、3个Android应用程序包文件，以及各类型的配置和忽略文件。该指南旨在帮助用户深入理解如何设计和构建复杂系统。
【超强组合】基于matlab金枪鱼算法TSO-BP-Adaboost数据分类预测【含Matlab源码 8154期】.zip
10-01
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2023b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化-BP-Adaboost数据分类预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化-BP-Adaboost数据分类预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化-BP-Adaboost数据分类预测 4.4.3 灰狼算法GWO/狼群算法WPA优化-BP-Adaboost数据分类预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化-BP-Adaboost数据分类预测 4.4.5 萤火虫算法FA/差分算法DE优化-BP-Adaboost数据分类预测 4.4.6 其他优化算法优化-BP-Adaboost数据分类预测
【SCI2区】北方苍鹰算法NGO-BiTCN-BiGRU-Attention风电预测【含Matlab源码 8076期】.zip
10-01
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2023b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化-BiTCN-BiGRU-Attention风电预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化-BiTCN-BiGRU-Attention风电预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化-BiTCN-BiGRU-Attention风电预测 4.4.3 灰狼算法GWO/狼群算法WPA优化-BiTCN-BiGRU-Attention风电预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化-BiTCN-BiGRU-Attention风电预测 4.4.5 萤火虫算法FA/差分算法DE优化-BiTCN-BiGRU-Attention风电预测 4.4.6 其他优化算法优化-BiTCN-BiGRU-Attention风电预测
线段树基础讲解与应用
"框架建树-线段树入门" 线段树是一种数据结构，用于高效地处理区间上的操作，如查询、更新等。在【标题】中提到的“框架建树”是指构建线段树的过程，它通过递归的方式将线段进行分割，最终形成一棵树形结构。 在...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值