线段树的学习（2023.4.5）

今天学习线段树

线段树是一种二叉树，用于解决区间得修改和维护，从O(n)的时间复杂度变成O(logN)，使解决区间问题时，拥有更快的速度。

线段树是一种二叉树，也就是对于一个线段，我们会用一个二叉树来表示。比如说一个长度为4的线段，我们可以表示成这样：

对于每一个子节点而言，都表示线段的一个子区间，子节点会不断向自己的双亲结点传递信息，而双亲结点存储它所有子节点信息，而叶子节点都表示线段中的单个元素信息。

根据这个思路，我们就可以建树了，我们设一个结构体 tree，tree[i].l 与 tree[i].r 分别表示这个点代表的线段的左右下标，tree[i].sum 表示这个节点表示的线段和。

我们知道，一颗从 1 11 开始编号的二叉树，结点 i ii 的左儿子和右儿子编号分别是 2 × i 2\times i2×i 和 2 × i + 1 2\times i + 12×i+1。

再根据刚才的性质，得到式子：t r e e [ i ] . s u m = t r e e [ i ∗ 2 ] . s u m + t r e e [ i ∗ 2 + 1 ] . s u m ; tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;tree[i].sum=tree[i∗2].sum+tree[i∗2+1].sum; 就可以建一颗线段树了！代码如下：

inline void build(int i,int l,int r){//递归建树
    tree[i].l=l;tree[i].r=r;
    if(l==r){//如果这个节点是叶子节点
        tree[i].sum=input[l];
        return ;
    }
    int mid=(l+r)>>1;
    build(i*2,l,mid);//分别构造左子树和右子树
    build(i*2+1,mid+1,r);
    tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;//刚才我们发现的性质return ;
}

如果想求出一个 1 ∼ 100 1\sim 1001∼100 区间中，4∼67 这些元素的和，你会怎么做？朴素的做法是for(i=4;i<=67;i++) sum+=a[i]，这样固然好，但是算得太慢了。

我们想一种新的方法，先想一个比较好画图的数据，比如一个长度为 4的区间，分别是 1 、 2 、 3 、 4 ，我们想求出第 1 ∼ 3项的和。按照上一部说的，我们要建出一颗线段树，其中点权（也就是红色）表示和：

 

然后我们要求 1 ∼ 3 的和，我们先从根节点开始查询，发现她的左儿子1-2这个区间和答案区间1~3有交集，那么我们跑到左儿子这个区间。

然后，我们发现这个区间 1 ∼ 2被完全包括在答案区间 1 ∼ 3 这个区间里面，那就把她的值 3 返回。

我们回到了 1 ∼ 4 区间，发现她的右儿子 3 ∼ 4区间和答案区间 1 ∼ 3有交集，那么我们走到 3 ∼ 4 3区间

到了 3 ∼ 4 区间，我们发现她并没有完全包含在答案区间 1 ∼ 3 里面，但发现她的左儿子 3 ∼ 3 3区间和 1 ∼ 3  区间又交集，那么久走到 3 ∼ 3 区间

到了 3 ∼ 3区间，发现其被答案区间完全包含，就返回她的值 3 一直到最开始

3 ∼ 3 区间的 3  +  1∼2 区间的 3 = 6，我们知道了 1 ∼ 3 区间和为 6。

如果只是几个数，这会显得格外麻烦，但当数增加到几百万几千万，这回大大提高运行速度。

线段树的查询方法：

1. 如果这个区间被完全包括在目标区间里面，直接返回这个区间的值

2. 如果这个区间的左儿子和目标区间有交集，那么搜索左儿子

3. 如果这个区间的右儿子和目标区间有交集，那么搜索右儿子

书写代码：

inline int search(int i,int l,int r){
    if(tree[i].l>=l && tree[i].r<=r)

//如果这个区间被完全包括在目标区间里面，直接返回这个区间的值
        return tree[i].sum;
    if(tree[i].r<l || tree[i].l>r)  return 0;

//如果这个区间和目标区间毫不相干，返回0
    int s=0;
    if(tree[i*2].r>=l)  s+=search(i*2,l,r);

//如果这个区间的左儿子和目标区间又交集，那么搜索左儿子
    if(tree[i*2+1].l<=r)  s+=search(i*2+1,l,r);

//如果这个区间的右儿子和目标区间又交集，那么搜索右儿子
    return s;
}
 

然后修改这个区间的单点，要把区间的第dis位加上k。

从根节点开始，看这个dis是在左儿子还是在右儿子，在哪往哪跑，

然后返回的时候，还是按照tree[i].sum=tree[i*2].sum+tree[i*2+1].sum的原则，更新所有路过的点。

深蓝色是去的路径，浅蓝色是返回的路径，回来时候红色的+标记就是把这个点加上这个值。

inline void add(int i,int dis,int k){
    if(tree[i].l==tree[i].r){//如果是叶子节点，那么说明找到了
        tree[i].sum+=k;
        return ;
    }
    if(dis<=tree[i*2].r)  add(i*2,dis,k);//在哪往哪跑
    else  add(i*2+1,dis,k);
    tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;//返回更新
    return ;
}
 

区间修改和单点查询

区间查询贴标记

如果把这个区间加上 k ，相当于把这个区间涂上一个 k的标记，然后单点查询的时候，就从上跑到下，把沿路的标记加起来就好。

void modify(int p, int l, int r, int k) 
{
    if(tr[p].l >= l && tr[p].r <= r) {
        tr[p].num += k;
        return ;
    }
    int mid = tr[p].l + tr[p].r >> 1;
    if(l <= mid) modify(p << 1, l, r, k);
    if(r > mid) modify(p << 1 | 1, l, r, k);
}
/*
inline void add(int i,int l,int r,int k){
    if(tree[i].l>=l && tree[i].r<=r){//如果这个区间被完全包括在目标区间里面，讲这个区间标记k
        tree[i].sum+=k;
        return ;
    }
    if(tree[i*2].r>=l)
        add(i*2,l,r,k);
    if(tree[i*2+1].l<=r)
        add(i*2+1,l,r,k);
}
*/
 

单点查询

就是dis在哪往哪跑，把路径上所有的标价加上就行。

void query(int p, int x)
{
    ans += tr[p].num;//一路加起来
    if(tr[p].l == tr[p].r) return;
    int mid = tr[p].l + tr[p].r >> 1;
    if(x <= mid) query(p << 1, x);
    else query(p << 1 | 1, x); 
}
/*
void search(int i,int dis){
    ans+=tree[i].sum;//一路加起来
    if(tree[i].l==tree[i].r)
        return ;
    if(dis<=tree[i*2].r)
        search(i*2,dis);
    if(dis>=tree[i*2+1].l)
        search(i*2+1,dis);
}
*/