线段树总结

最新推荐文章于 2024-07-04 11:00:16 发布
最新推荐文章于 2024-07-04 11:00:16 发布
阅读量413 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/czysjr/article/details/40370399


还是那句话， 知其然不知其所以然真的是一件容易引发伤痛的事情。

所以忍不住来一发线段树总结。。

因为当时学线段树的时候也就是刚学了几个月编程， 所以一直觉得它挺长的。

但现在再看一看实在是简洁易懂的， 一个线段树也就三十行而且思路非常的清晰写起来非常的快。

以前对于线段树的lazy思想一直没有系统地想过， 都是在什么时候遇到一道题然后自己YY出来的， 经常调不对， 但事实上lazy思想做的就是不把那些没有必要的细枝末节更新。 比如最后一个更新是把整个区间更新后询问整个区间维护的值， 如果单点修改的话就要把整棵树都修改了然后再询问， 但是这时的询问实际上只用到了tree[1]这一个节点的值， 所以那些更新都是没有意义的。 而我们要改进的就是把作用在一个点上的所有更新都合并起来， 然后等到需要用到这个点的时候再给它更新， 这样理论上的时间复杂度就还是nlogn 的。

注意它维护的那个改变的值 是代表着当前这个点已经更新过了， 但是它的子节点还没有更新过， 所以当访问一个点的子节点的时候先查询这个子节点需不需要改变， 改变了以后再访问这个子节点。

裸题 hdu1698， 做了好几遍了，，，但是这一遍做的自我感觉是最优美的！  四十行

#include <iostream>
#include <cstdio>
#define MAXN 100005
using namespace std;
int t, n, q;
struct Tree{
    int l, r, num, c;    
}tree[MAXN * 4];
void build(int t, int l, int r){
    tree[t].l = l; tree[t].r = r; tree[t].num = r - l + 1;  tree[t].c = 0;
    if(l == r)return;
    int mid = (l + r)>>1;
    build(t + t, l, mid); build(t + t + 1, mid + 1, r);    
}
void update(int l, int r, int z, int t){
    int tl = tree[t].l, tr = tree[t].r; int mid = (tl + tr)>>1;
    if(tl >= l && tr <= r){
        tree[t].c = z;  
        tree[t].num = (tr - tl + 1) * z;    return ;    
    }   
    if(tree[t].c){  int cc = tree[t].c; tree[t].c = 0;          //down
        tree[t + t].c = tree[t + t + 1].c = cc;
        tree[t + t + 1].num = cc * (tree[t + t + 1].r - tree[t + t + 1].l + 1);
        tree[t + t].num = cc * (tree[t + t].r - tree[t + t].l + 1);   
    }
    if(l <= mid)update(l, r, z, t + t);
    if(r >= mid + 1)update(l, r, z, t + t + 1);
    tree[t].num = tree[t + t].num + tree[t + t + 1].num;  //up
}
int main()
{
    scanf("%d", &t); for(int cas = 1; cas <= t; cas ++){
        scanf("%d%d", &n, &q);
       build(1, 1, n); 
        while(q --){
            int x, y, z; scanf("%d%d%d", &x, &y, &z);
            update(x, y, z, 1);
        }   printf("Case %d: The total value of the hook is %d.\n", cas, tree[1].num);
    }
    return 0;
}
另外值得一提的是看到这道题有人打了这样的暴力：

#include <iostream>
#include <cstdio>
using namespace std;
 
int data[100005][3];
 
int main()
{
     int t,q,n,i,j,sum,k,v;
     scanf ( "%d" ,&t);
     for (i=1;i<=t;i++)
     {
         scanf ( "%d%d" ,&n,&q);
         for (j=1;j<=q;j++)
             scanf ( "%d%d%d" ,&data[j][0],&data[j][1],&data[j][2]);
         sum=0;
         for (k=1;k<=n;k++)
         {
             v=1;
             for (j=q;j>=1;j--)
                 if (data[j][0]<=k && k<=data[j][1]) //寻找k所在的更新区间，若存在则更新，不存在v=1不变
                 {
                     v=data[j][2];                 //若找的最后面的更新区间，则停止，因为前面的会被覆盖
                     break ;
                 }
             sum+=v;
         }
         printf ( "Case %d: The total value of the hook is %d.\n" ,i,sum);
     }
     return 0;
}
然后它的速度竟然比线段树快T T ， 果然是它的数据出的太弱了， 但一般这种线段树的题都会有其它的解法的， 贪心二分什么的。


poj 3468

还是最裸最裸的线段树， 不过我最开始还是调了好久。。。。。果然弱得不能忍。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#define MAXN 100005
using namespace std;
int a[MAXN], n, q;
struct Tree{
    int l, r; long long delta, sum;     
}tree[MAXN * 4];
void build(int t, int l, int r){
    tree[t].l = l; tree[t].r = r; tree[t].delta = 0;
    if(l == r){tree[t].sum = (long long)a[l]; return;}
    int mid = (l + r)>>1;
    build(t + t, l, mid); build(t + t + 1, mid + 1, r);
    tree[t].sum = tree[t + t].sum + tree[t + t + 1].sum;    
}
inline void pushdown(int t){
    if(tree[t].delta){  long long dd = tree[t].delta; tree[t].delta = 0;
        tree[t + t].delta += dd; tree[t + t + 1].delta += dd;
        tree[t + t].sum += dd * (tree[t + t].r - tree[t + t].l + 1);
        tree[t + t + 1].sum += dd * (tree[t + t + 1].r - tree[t + t + 1].l + 1);}    
}
void update(int t, int l, int r, int z){
    if(tree[t].l >= l && tree[t].r <= r){
        tree[t].delta += z;  
        tree[t].sum += (tree[t].r - tree[t].l + 1) * (long long)z; return;    
    }       pushdown(t);
    int mid = (tree[t].l + tree[t].r)>>1;
    if(mid >= l)update(t + t, l, r, z);
    if(mid + 1 <= r)update(t + t + 1, l, r, z);
    tree[t].sum = tree[t + t].sum + tree[t + t + 1].sum;
}
long long ask(int t, int l, int r){
    if(tree[t].l >= l && tree[t].r <= r)return tree[t].sum;   
    pushdown(t);
    int mid = (tree[t].l + tree[t].r)>>1;
    long long ret = 0;
    if(mid >= l) ret += ask(t + t, l, r);
    if(mid + 1 <= r) ret += ask(t + t + 1, l, r);   return ret;
}
int main()
{
    scanf("%d%d", &n, &q);
    for(int i = 1; i <= n; i ++)scanf("%d", &a[i]);
    build(1, 1, n);
    for(int i = 1; i <= q; i ++){   getchar();
        char c; int x, y; scanf("%c%d%d", &c, &x, &y);
        if(c == 'Q'){printf("%I64d\n", ask(1, x, y));}
        else {int z; scanf("%d", &z); update(1, x, y, z);}
    }
   // system("pause");
    return 0;
}
还有一点就是只看自己的代码的时候不觉得有什么， 但在同一道题下， 看一下别人的代码就会感慨自己写得有多丑 了！！

#include <cstdio>
#include <algorithm>
using namespace std;
 
#define lson l , m , rt << 1
#define rson m + 1 , r , rt << 1 | 1
#define LL long long
const int maxn = 111111;
LL add[maxn<<2];
LL sum[maxn<<2];
void PushUp(int rt) {
    sum[rt] = sum[rt<<1] + sum[rt<<1|1];
}
void PushDown(int rt,int m) {
    if (add[rt]) {
        add[rt<<1] += add[rt];
        add[rt<<1|1] += add[rt];
        sum[rt<<1] += add[rt] * (m - (m >> 1));
        sum[rt<<1|1] += add[rt] * (m >> 1);
        add[rt] = 0;
    }
}
void build(int l,int r,int rt) {
    add[rt] = 0;
    if (l == r) {
        scanf("%lld",&sum[rt]);
        return ;
    }
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUp(rt);
}
void update(int L,int R,int c,int l,int r,int rt) {
    if (L <= l && r <= R) {
        add[rt] += c;
        sum[rt] += (LL)c * (r - l + 1);
        return ;
    }
    PushDown(rt , r - l + 1);
    int m = (l + r) >> 1;
    if (L <= m) update(L , R , c , lson);
    if (m < R) update(L , R , c , rson);
    PushUp(rt);
}
LL query(int L,int R,int l,int r,int rt) {
    if (L <= l && r <= R) {
        return sum[rt];
    }
    PushDown(rt , r - l + 1);
    int m = (l + r) >> 1;
    LL ret = 0;
    if (L <= m) ret += query(L , R , lson);
    if (m < R) ret += query(L , R , rson);
    return ret;
}
int main() {
    int N , Q;
    scanf("%d%d",&N,&Q);
    build(1 , N , 1);
    while (Q --) {
        char op[2];
        int a , b , c;
        scanf("%s",op);
        if (op[0] == 'Q') {
            scanf("%d%d",&a,&b);
            printf("%lld\n",query(a , b , 1 , N , 1));
        } else {
            scanf("%d%d%d",&a,&b,&c);
            update(a , b , c , 1 , N , 1);
        }
    }system("pause");
    return 0;
}
这个代码也就比我的那个多了20行， 但是真的漂亮到不知道哪里去了。。。不过他用的是那种不开struct的线段树， 所以说变量名就都会显得比较短， 其实我这种线段树应该也可以define一下然后看起来就会漂亮多了！

改了一会改不下去了。。但大概是这个效果：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#define MAXN 100005
#define ll long long
#define S(x) tree[x].sum
#define R(x) tree[x].r
#define L(x) tree[x].l
#define D(x) tree[x].delta
#define ls(x) x<<1
#define rs(x) (x<<1)+1
using namespace std;
int a[MAXN], n, q;
struct Tree{
    int l, r;
    long long delta, sum;     
}tree[MAXN * 4];
void build(int t, int l, int r){
    L(t) = l;
    R(t) = r;
    D(t) = 0;
    if(l == r){
        S(t) = (ll)a[l];
        return;
    }
    int mid = (l + r)>>1;
    build(ls(x), l, mid);
    build(rs(x), mid + 1, r);
    S(t) = S(ls(x)) + S(rs(x));    
}
inline void pushdown(int t){
    if(D(t)){  
        ll dd = D(t);
        D(t) = 0;
        D(ls(t)) += dd;
        D(rs(t)) += dd;
        S(ls(t)) += dd * (R(ls(t)) - L(ls(t)) + 1);
        S(rs(t)) += dd * (R(rs(t)) - L(rs(t)) + 1);
    }    
}
void update(int t, int l, int r, int z){
    if(L(t) >= l && R(t) <= r){
        D(t) += z;  
        S(t) += (R(t) - L(t) + 1) * (ll)z;
        return;    
    }       
    pushdown(t);
    int mid = (L(t) + R(t))>>1;
    if(mid >= l)update(ls(t), l, r, z);
    if(mid + 1 <= r)update(rs(t), l, r, z);
    S(t) = S(ls(t)) + S(rs(t));
}

风格很怪异啊。。。



还有这道题， 我还没写呢， 但是感觉还是有价值看一看的， 一下是一个人的题解

o    poj3225 Help with Intervals
题意:区间操作,交,并,补等
思路:
我们一个一个操作来分析:(用0和1表示是否包含区间,-1表示该区间内既有包含又有不包含)
U:把区间[l,r]覆盖成1
I:把[-∞,l)(r,∞]覆盖成0
D:把区间[l,r]覆盖成0
C:把[-∞,l)(r,∞]覆盖成0 ,且[l,r]区间0/1互换
S:[l,r]区间0/1互换

成段覆盖的操作很简单,比较特殊的就是区间0/1互换这个操作,我们可以称之为异或操作
很明显我们可以知道这个性质:当一个区间被覆盖后,不管之前有没有异或标记都没有意义了
所以当一个节点得到覆盖标记时把异或标记清空
而当一个节点得到异或标记的时候,先判断覆盖标记,如果是0或1,直接改变一下覆盖标记,不然的话改变异或标记

开区间闭区间只要数字乘以2就可以处理(偶数表示端点,奇数表示两端点间的区间)
线段树功能:update:成段替换,区间异或 query:简单hash

?View Code CPP

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

#include <cstdio>

#include <cstring>

#include <cctype>

#include <algorithm>

using namespace std;

#define lson l , m , rt << 1

#define rson m + 1 , r , rt << 1 | 1

 

const int maxn=131072;

bool hash[maxn];

int cover[maxn<<2];

int XOR[maxn<<2];

void FXOR(int rt){

         if (cover[rt]!=-1) cover[rt]^=1;

         else XOR[rt]^=1;

}

void PushDown(int rt){

         if (cover[rt]!=-1){

                 cover[rt<<1]= cover[rt<<1|1]= cover[rt];

                 XOR[rt<<1]= XOR[rt<<1|1]=0;

                 cover[rt]=-1;

         }

         if (XOR[rt]){

                 FXOR(rt<<1);

                 FXOR(rt<<1|1);

                 XOR[rt]=0;

         }

}

void update(char op,int L,int R,int l,int r,int rt) {

         if (L <= l && r<= R){

                 if (op == 'U'){

                          cover[rt]=1;

                          XOR[rt]=0;

                 } else if (op=='D'){

                          cover[rt]=0;

                          XOR[rt]=0;

                 } else if (op=='C' || op == 'S'){

                          FXOR(rt);

                 }

                 return ;

         }

         PushDown(rt);

         int m = (l + r)>>1;

         if (L <= m) update(op , L , R , lson);

         else if (op =='I'|| op == 'C') {

                 XOR[rt<<1]= cover[rt<<1]=0;

         }

         if (m < R) update(op , L , R , rson);

         else if (op =='I'|| op == 'C') {

                 XOR[rt<<1|1]= cover[rt<<1|1]=0;

         }

}

void query(int l,int r,int rt){

         if (cover[rt]==1){

                 for (int it = l; it<= r ; it ++){

                          hash[it]=true;

                 }

                 return ;

         } else if (cover[rt]==0)return;

         if (l == r) return ;

         PushDown(rt);

         int m = (l + r)>>1;

         query(lson);

         query(rson);

}

int main(){

         cover[1]= XOR[1]=0;

         char op , l , r;

         int a , b;

         while ( ~scanf("%c %c%d,%d%c\n",&op ,&l , &a , &b ,&r)){

                 a <<= 1 , b <<= 1;

                 if (l == '(') a++;

                 if (r == ')') b--;

                 if (a > b) {

                          if (op == 'C' || op == 'I'){

                                   cover[1]= XOR[1]=0;

                          }

                 } else update(op , a , b , 0 , maxn , 1);

         }

         query(0 , maxn ,1);

         bool flag = false;

         int s = -1 , e;

         for (int i = 0 ; i <= maxn; i++){

                 if (hash[i]){

                          if (s == -1) s= i;

                          e = i;

                 } else {

                          if (s != -1) {

                                   if(flag)printf(" ");

                                   flag = true;

                                   printf("%c%d,%d%c",s&1?'(':'[' , s>>1 , (e+1)>>1 , e&1?')':']');

                                   s =-1;

                          }

                 }

         }

         if (!flag)printf("empty set");

         puts("");

         return 0;

}


然后就是区间合并的啦！

·        区间合并
这类题目会询问区间中满足条件的连续最长区间,所以PushUp的时候需要对左右儿子的区间进行合并

就是像小白逛公园那样的题了， 话说小白逛公园是我A的第一道线段树的题。。。深感被cy欺骗了。。。她应该先让我做单点修改的题啊，还记得当时我做那题做得很困难。

 

poj3667

今天poj上不去是什么情况。。T T， 一会再交

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <cstdlib>
#include <time.h>
#include <queue>
#define MAXN 50005
using namespace std;
struct Tree{
	int lmax, rmax, mmax, l, r, c;
}tree[MAXN * 4];
inline void pushdown(int x){
	if(tree[x].c != -1){
		tree[x<<1].c = tree[x<<1|1].c = tree[x].c;
		tree[x<<1].lmax = tree[x<<1].rmax = tree[x<<1].mmax = tree[x].c * (tree[x<<1].r - tree[x<<1].l + 1);
		tree[x<<1|1].lmax = tree[x<<1|1].rmax = tree[x<<1|1].mmax = tree[x].c * (tree[x<<1|1].r - tree[x<<1|1].l + 1);
		tree[x].c = -1;
	}
}
inline void pushup(int t){
	tree[t].lmax = tree[t<<1].lmax;
	tree[t].rmax = tree[t<<1|1].rmax;
	if(tree[t<<1].lmax == tree[t<<1].r - tree[t<<1].l + 1) tree[t].lmax += tree[t<<1|1].lmax;
	if(tree[t<<1|1].rmax == tree[t<<1|1].r - tree[t<<1|1].l + 1) tree[t].rmax += tree[t<<1].rmax;
	tree[t].mmax = max(max(tree[t<<1].mmax, tree[t<<1|1].mmax), tree[t<<1].rmax + tree[t<<1|1].lmax);
}
void build(int t, int l, int r){
	tree[t].lmax = tree[t].rmax = tree[t].mmax = r - l + 1;
	tree[t].l = l; tree[t].r = r; tree[t].c = -1;
	if(l == r)return;
	int mid = l + r>>1;
	build(t<<1, l, mid); build(t<<1|1, mid + 1, r);
}
int ask(int t, int w){
	int l = tree[t].l, r = tree[t].r;
	if(l == r)return l;
	pushdown(t);
	int mid = l + r >>1;
	if(tree[t<<1].mmax >= w)return ask(t<<1, w);
	if(tree[t<<1].rmax + tree[t<<1|1].lmax >= w) return mid - tree[t<<1].rmax + 1;
	return ask(t<<1|1, w);
}
void update(int l, int r, int t, int c){
	if(tree[t].l >= l && tree[t].r <= r){
		tree[t].lmax = tree[t].rmax = tree[t].mmax = c * (tree[t].r - tree[t].l + 1);
		tree[t].c = c; return;
	}
	pushdown(t);
	int mid = (tree[t].l + tree[t].r)>>1;
	if(l <= mid)update(l, r, t<<1, c);
	if(r >= mid + 1)update(l, r, t<<1|1, c);
	pushup(t);
}
int main()
{
	int n, m; scanf("%d%d", &n, &m);
	build(1, 1, n);
	while(m --){
		int z, a, b; scanf("%d%d", &z, &a);
		if(z == 1){
			if(tree[1].mmax < a)puts("0");
			else{
				int p = ask(1, a);
				printf("%d\n", p);
				update(p, p + a - 1, 1, 0);
			}
		}
		else{
			scanf("%d", &b);
			update(a, a + b - 1, 1, 1);
		}
	}//system("pause");
	return 0;
}


hdu3308

同区间合并裸题，，但是调了好久，，这两天一直在调代码有点疲惫了呜呜呜~~~~(>_<)~~~~

很快打完的代码总是调不出来，，还是做的题太少了，，加油吧一直敲代码我的代码能力一定会上去的！ >_<


扫描线

这算是线段树的一个经典应用吧，，前几天做题还遇到了，，当时好像现场没调出来~~~~(>_<)~~~~


poj 1177

所有线段树的总结中都有这个！ 

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#define MAXN 50010
using namespace std;
int n; 
int x[2 * MAXN], end;
struct node{
    int l, r;
    int len, lenall;
    int num, seg;
    bool lcover, rcover;   
}tree[MAXN * 8];
struct line{
    int s, e;
    int y;
    bool down;    
}xline[2 * MAXN];
void build(int l, int r, int t){
    tree[t].l = l;
    tree[t].r = r;
    tree[t].len = x[r] - x[l];
    tree[t].lenall = tree[t].num = tree[t].seg = 0;
    tree[t].lcover = tree[t].rcover = 0;
    if(r - l > 1){
        int mid = (l + r)>>1;
        build(l, mid, t + t), 
        build(mid, r, t + t + 1);    
    }    
}

void update(int r){
    if(tree[r].num > 0){
        tree[r].lenall = tree[r].len;
        tree[r].seg = 1;
        tree[r].lcover = tree[r].rcover = 1;    
    }    
    else if(tree[r].r - tree[r].l > 1){
            tree[r].lenall = tree[2 * r].lenall + tree[2 * r + 1].lenall;
            tree[r].lcover = tree[2 * r].lcover;
            tree[r].rcover = tree[2 * r + 1].rcover;
            tree[r].seg = tree[2 * r].seg + tree[2 * r + 1].seg
                            - tree[2 * r].rcover * tree[2 * r + 1].lcover; 
    } 
    else{
        tree[r].lenall = tree[r].seg = 0;
        tree[r].lcover = tree[r].rcover = 0;    
    }
}

void insert(int l, int r, int t){
    if(l == tree[t].l && r == tree[t].r)
        tree[t].num ++;
    else {
        int mid = (tree[t].l + tree[t].r) >> 1;
        if(r <= mid) insert(l, r, 2 * t);
        else if(l >= mid) insert(l, r, 2 * t + 1);
        else insert(l, mid, 2 * t), insert(mid, r, 2 * t + 1); 
    }    
    update(t);
}

void deletee(int l, int r, int t){
    if(l == tree[t].l && r == tree[t].r)
        tree[t].num --;
    else {
        int mid = (tree[t].l + tree[t].r)>>1;
        if(r <= mid)    deletee(l, r, 2 * t);
        else if(l >= mid)   deletee(l, r, 2 * t + 1);
        else deletee(l, mid, 2 * t), deletee(mid, r, 2 * t + 1);    
    }    
    update(t);
}

int find(int key){
    return lower_bound(x + 1, x + end + 1, key) - x;    
}

bool cmp(const line &l1, const line &l2){
    return l1.y < l2.y;    
}
int main()
{
    scanf("%d", &n);
    int x1, x2, y1, y2;
    end = 1;
    for(int i = 0; i < n; i ++){
        scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
        x[end ++] = x1;
        x[end ++] = x2;
        xline[2 * i].s = xline[2 * i + 1].s = x1;
        xline[2 * i].e = xline[2 * i + 1].e = x2;
        xline[2 * i].y = y1; xline[2 * i + 1].y = y2;
        xline[2 * i].down = 1; xline[2 * i + 1].down = 0;
    }
    sort(x + 1, x + end) ;
    end = unique(x + 1, x + end) - (x + 1);
    build (1, end, 1);
    int ans = 0, pre = 0;
    sort(xline, xline + 2 * n, cmp);
    for(int i = 0; i < 2 * n - 1; i ++){
        if(xline[i].down){
            insert(find(xline[i].s), find(xline[i].e), 1);    
        }    
        else
            deletee(find(xline[i].s), find(xline[i].e), 1);
            
        ans += tree[1].seg * (xline[i + 1].y - xline[i].y) * 2;
        ans += abs(tree[1].lenall - pre);
        pre = tree[1].lenall;
    }
    deletee(find(xline[2 * n - 1].s), find(xline[2 * n - 1].e), 1);
    ans += abs(tree[1].lenall - pre);
    printf("%d\n",ans);
  //  system("pause");
    return 0;    
}



czysjr
关注
线段树总结[经典、权值、动态开点]
Xm_wy的博客
05-11 1126
ps:这是本蒟蒻的第一篇数据类型博客。   线段树，这是一种非常常用、普遍的信息统计技术。其基本思想是分治（二分），该数据类型本质上是一个储存区间数据二叉树
线段树基本操作
qq_40005800的博客
07-15 288
自己以前学了线段树，感到很懵逼，大概用了一个月的时间才能熟练地打出模板。现在看来，线段树是万能的，这是一个不可不学的数据结构，线段树的应用范围，很广尽管写起来稍微有点烦，代码稍微长了一点。 线段树，顾名思义，就是一棵由线段组成的树他利用了二分的思想，将一个线段以递归的形式二分下去，形成了一棵二叉树。 下面是一棵线段树的模型(本人喜欢左右都闭)： 以求和为例，（朴素易懂）代码如下： s...
线段树知识总结
2301_80475191的博客
07-04 574
线段树这个东西，这次是第二次学习，怎么说呢，感觉理解还是不是特别的透彻，因此，在后面彻底完学习之后这个东西再改成公开。
线段树总结（题目合集）
常胜将军的博客
08-19 1407
1、POJ 3321 题意：给出一个苹果树，每个节点一开始都有苹果。C X，如果X点有苹果，则拿掉，如果没有，则新长出一个。Q X，查询X点与它的所有后代分支一共有几个苹果。 分析：利用dfs序将子树节点变成连续区间，然后利用线段树进行单点修改、区间求和就好了。注意vector<int> g[N]会超时，改成vector<vector<int> > g就好了...
leetcode-线段树总结
Less is More
04-06 345
TODO----------
线段树总结-超级详细版
08-08
线段树总结以及线段树一些经典的例题，代码写的非常简洁和漂亮。
logback-classic-1.4.11.jar中文文档.zip
08-09
1、压缩文件中包含： 中文文档、jar包下载地址、Maven依赖、Gradle依赖、源代码下载地址。 2、使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 3、特殊说明： （1）本文档为人性化翻译，精心制作，请放心使用； （2）只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； （3）不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 4、温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件。 5、本文件关键字： jar中文文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册。
elasticsearch-0.14.3.jar中文文档.zip
08-09
1、压缩文件中包含： 中文文档、jar包下载地址、Maven依赖、Gradle依赖、源代码下载地址。 2、使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 3、特殊说明： （1）本文档为人性化翻译，精心制作，请放心使用； （2）只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； （3）不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 4、温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件。 5、本文件关键字： jar中文文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册。
虚拟同步电机Simulink仿真与并电网模型仿真：参数设置完毕，可直接使用 - 电力电子
08-09
如何利用Simulink对虚拟同步电机(Virtual Synchronous Generator,VSG)及其并电网模型进行仿真。首先概述了Simulink作为MATLAB的一部分，在电力电子仿真中的重要地位。接着阐述了虚拟同步电机的建模步骤，涵盖机械、电气和控制三个部分，并强调了参数设置对仿真精度的影响。然后讨论了并电网模型的构建方法，涉及电网结构、电压等级、线路阻抗等要素。随后讲解了参数设置的具体流程，包括电机初始状态、控制策略、并电网电压电流等。最后探讨了通过MATLAB编写控制策略和数据分析代码的方法，以及如何基于仿真结果评估电机性能和电网稳定性。 适合人群：从事电力电子领域研究的专业人士，尤其是那些对虚拟同步电机和并电网仿真感兴趣的工程师和技术人员。 使用场景及目标：适用于需要深入了解虚拟同步电机工作原理和并电网运行规律的研究项目。目标是在掌握Simulink仿真技巧的基础上，优化电机性能，提高电网稳定性。 阅读建议：由于涉及到大量的理论知识和技术细节，建议读者先熟悉Simulink的基本操作和相关电力电子基础知识，再逐步深入理解和实践文中提到的各种仿真技术和方法。
elasticsearch-5.6.0.jar中文文档.zip
08-09
1、压缩文件中包含： 中文文档、jar包下载地址、Maven依赖、Gradle依赖、源代码下载地址。 2、使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 3、特殊说明： （1）本文档为人性化翻译，精心制作，请放心使用； （2）只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； （3）不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 4、温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件。 5、本文件关键字： jar中文文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册。
电动汽车充放电调度优化：全局与局部策略性能比较及其实际应用 - 分布式优化
最新发布
08-09
内容概要：本文探讨了电动汽车（EV）充放电调度优化的问题，特别是全局与局部调度策略之间的性能比较及其实际应用挑战。文中指出，虽然全局调度能够提供理论上最低的成本，但它假设所有车辆的到达时间和充电需求是预先已知的，在现实生活中难以实现。相比之下，局部调度策略更加实用，它仅考虑当前在充电桩的车辆，采用分布式方式优化充电计划，不仅适应大规模车辆群体，还能灵活应对动态变化。仿真结果显示，局部调度方案在成本上接近全局最优解，同时显著减少了计算时间，使其更适合实际应用场景。此外，文章还提到在电价高峰期，局部调度策略可能会促使某些车辆放电以减轻电网负担，从而形成一种自组织的微电网生态系统。 适用人群：对电动汽车充放电调度优化感兴趣的科研人员、工程师以及相关领域的学生。 使用场景及目标：①理解电动汽车充放电调度的基本概念和技术背景；②掌握全局与局部调度策略的区别和优劣；③探索如何将理论应用于实际，解决现实世界中的复杂问题。 其他说明：文章提供了具体的Python代码示例来解释两种调度方法的工作原理，有助于读者更好地理解和实践所讨论的内容。
基于MATLAB的机器人路径规划算法设计
08-09
资源下载链接为： https://pan.quark.cn/s/67c535f75d4c 在机器人技术中，轨迹规划是实现机器人从一个位置平稳高效移动到另一个位置的核心环节。本资源提供了一套基于 MATLAB 的机器人轨迹规划程序，涵盖了关节空间和笛卡尔空间两种规划方式。MATLAB 是一种强大的数值计算与可视化工具，凭借其灵活易用的特点，常被用于机器人控制算法的开发与仿真。 关节空间轨迹规划主要关注机器人各关节角度的变化，生成从初始配置到目标配置的连续路径。其关键知识点包括： 关节变量：指机器人各关节的旋转角度或伸缩长度。 运动学逆解：通过数学方法从末端执行器的目标位置反推关节变量。 路径平滑：确保关节变量轨迹连续且无抖动，常用方法有 S 型曲线拟合、多项式插值等。 速度和加速度限制：考虑关节的实际物理限制，确保轨迹在允许的动态范围内。 碰撞避免：在规划过程中避免关节与其他物体发生碰撞。 笛卡尔空间轨迹规划直接处理机器人末端执行器在工作空间中的位置和姿态变化，涉及以下内容： 工作空间：机器人可到达的所有三维空间点的集合。 路径规划：在工作空间中找到一条从起点到终点的无碰撞路径。 障碍物表示：采用二维或三维网格、Voronoi 图、Octree 等数据结构表示工作空间中的障碍物。 轨迹生成：通过样条曲线、直线插值等方法生成平滑路径。 实时更新：在规划过程中实时检测并避开新出现的障碍物。 在 MATLAB 中实现上述规划方法，可以借助其内置函数和工具箱： 优化工具箱：用于解决运动学逆解和路径规划中的优化问题。 Simulink：可视化建模环境，适合构建和仿真复杂的控制系统。 ODE 求解器：如 ode45，用于求解机器人动力学方程和轨迹执行过程中的运动学问题。 在实际应用中，通常会结合关节空间和笛卡尔空间的规划方法。先在关节空间生成平滑轨迹，再通过运动学正解将关节轨迹转换为笛卡
Matlab中点云重建与三角剖分技术及其在三维建模的应用
08-09
内容概要：本文介绍了Matlab在点云重建与三角剖分方面的技术和应用。点云数据来源于三维扫描设备或图像处理系统，经过预处理（如去噪和平滑）后，利用插值和曲面拟合技术重建表面几何形状。三角剖分则通过划分成三角形面片来增强模型的真实感。Matlab提供的多种算法使这一过程更为精准和高效。 适合人群：从事计算机图形学、三维建模的研究人员、工程师以及设计师。 使用场景及目标：适用于需要从原始点云数据创建高精度三维模型的情况，旨在提高模型的质量和真实性。 其他说明：文中详细解释了点云重建的具体流程，包括预处理阶段的技术手段，以及不同类型的三角剖分方法的选择依据。
基于STM32F103的Modbus主站源码：串口通信读取多个从机功能码，无需定时器，简单移植的Modbus RTU通信方案
08-09
如何在STM32F103平台上实现Modbus RTU主站的功能。作者分享了一个仅由单个C文件构成的简洁实现方法，利用串口2进行通信，能够读取多个从机的功能码。文中不仅提供了具体的硬件配置指导，还展示了关键代码段，包括初始化设置、动态改变从机地址的方法以及发送和接收数据的具体流程。此外，作者还提到了一些实际应用中的注意事项，如超时检测、CRC校验的重要性，并强调了代码的易移植性和稳定性。 适合人群：熟悉嵌入式系统开发，尤其是对STM32系列微控制器有一定了解的研发人员。 使用场景及目标：适用于需要构建稳定可靠的Modbus RTU主站系统的工程项目，旨在帮助开发者快速理解和掌握STM32平台下Modbus协议的应用技巧。 其他说明：文中提供的解决方案已经在多个实际项目中得到验证，表现出良好的性能和可靠性。对于希望深入了解Modbus协议内部机制及其在工业自动化领域的具体应用的读者来说，是一份非常有价值的参考资料。
基于Matlab Simulink的无迹扩展卡尔曼滤波用于路面附着系数估计的技术解析与应用 - 汽车电子控制系统
08-09
内容概要：本文档深入探讨了利用无迹扩展卡尔曼滤波（UKF）和扩展卡尔曼滤波（EKF）在Matlab/Simulink环境下进行路面附着系数估计的方法和技术。文中详细介绍了7自由度整车模型的构建，包括横摆、侧倾、四轮旋转及纵向运动等多个方面。同时，文档还展示了UKF的具体实现方式，特别是sigma点的选择及其对非线性特性的保持。此外，文档提供了丰富的实例验证，如对开路面工况测试，证明了该方法的有效性和优越性。最后，文档强调了模型的灵活性和实用性，如参数调整简便、支持多种测试工况等。 适用人群：从事车辆动力学研究、汽车电子控制系统开发的专业人士，以及希望深入了解卡尔曼滤波算法应用于实际工程的学生和研究人员。 使用场景及目标：本模型主要用于提高车辆稳定性控制系统的性能，尤其是在复杂路况下（如冰雪路面、湿滑路面等）。通过精确估计路面附着系数，能够显著提升ESP系统和其他主动安全系统的响应速度和准确性。 其他说明：文档不仅提供详细的理论推导和代码实现，还包括了大量实用技巧和注意事项，确保用户能够在实际项目中顺利应用这些技术。
jfoenix-8.0.2.jar中文文档.zip
08-09
1、压缩文件中包含： 中文文档、jar包下载地址、Maven依赖、Gradle依赖、源代码下载地址。 2、使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 3、特殊说明： （1）本文档为人性化翻译，精心制作，请放心使用； （2）只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； （3）不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 4、温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件。 5、本文件关键字： jar中文文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册。
Flutter 微信支付插件
08-09
资源下载链接为： https://pan.quark.cn/s/34283258e97c Flutter 微信支付插件（最新、最全版本！打开链接下载即可用！）
线段树详解与应用
"更新线段树-线段树学习ppt" ...总结来说，线段树是一种强大的数据结构，尤其适用于处理区间上的动态查询和修改。它的构造和操作复杂度较低，可以灵活地适应各种问题，是算法竞赛和实际编程中解决区间问题的利器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值