线段树，，

线段树

线段树解决的问题

1.区间上的统一增加
2.区间上的统一更新
3.区间上的累加和统一查询

任何一个结点 i 的父结点是 i/2，任何一个结点 i 的左孩子是 2i，右孩子是 2i+1，因为下标从1开始算，有点像堆。

数组长度是2的几次方时候，最省空间，只需要准备2N长度的数组；
数组长度是2的几次方+1的时候，最浪费空间，但也只需要准备4N长度的数组就可以了。

左边可以得到某一个信息，右边可以得到某一个信息，父结点的信息可以由左右两个信息在O(1)时间内加工好，而且不用具体调研底层状况的，这一类区间查询，区间更新，区间增加问题，可以用线段树。

package com.harrison.class21;

/**
 * @author Harrison
 * @create 2022-03-31-22:40
 * @motto 众里寻他千百度，蓦然回首，那人却在灯火阑珊处。
 */
public class Code01_SegmentTree {
    public static class SegmentTree {
        /*
        arr[] 为原序列的信息从0开始，但在arr里是从1开始的
        sum[] 模拟线段树维护区间和
        lazy[] 累加和懒惰标记
        change[] 更新的值
        update[] 更新慵懒标记
        */
        private int MAXN;
        private int[] arr;
        private int[] sum;
        private int lazy[];
        private int change[];
        private boolean update[];

        public SegmentTree(int[] origin) {
            MAXN = origin.length + 1;
            arr = new int[MAXN];// arr[0]不用，从arr[1]开始使用
            for (int i = 1; i < arr.length; i++) {
                arr[i] = origin[i - 1];
            }
            sum = new int[MAXN << 2];// 用来支持脑部概念中，某一个范围的累加和信息
            lazy = new int[MAXN << 2];// 用来支持脑部概念中，某一个范围没有往下传递的累加任务
            change = new int[MAXN << 2];// 用来支持脑部概念中，某一个范围没有更新操作的任务
            update = new boolean[MAXN << 2];// 用来支持脑部概念中，某一个范围更新任务，更新成了什么
        }

        public void pushUp(int rt) {
            sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
        }

        /*
        之前的，所有懒加载，和懒更新，从父范围，发给左右两个子范围
        分发策略是什么
        ln表示左子树元素结点个数，rn表示右子树元素结点个数
         */
        public void pushDown(int rt, int ln, int rn) {
            if (update[rt]) {
                update[rt << 1] = true;
                update[rt << 1 | 1] = true;
                change[rt << 1] = change[rt];
                change[rt << 1 | 1] = change[rt];
                lazy[rt << 1] = 0;
                lazy[rt << 1 | 1] = 0;
                sum[rt << 1] = change[rt] * ln;
                sum[rt << 1 | 1] = change[rt] * rn;
                update[rt] = false;
            }
            if (lazy[rt] != 0) {
                lazy[rt << 1] += lazy[rt];
                lazy[rt << 1 | 1] += lazy[rt];
                sum[rt << 1] += lazy[rt] * ln;
                sum[rt << 1 | 1] += lazy[rt] * rn;
                lazy[rt] = 0;
            }
        }

        /*
        在初始化阶段，先把sum数组填好
        在arr[1~r]范围上，去build，1~N
        rt：这个范围在sum中的下标
         */
        public void build(int l, int r, int rt) {
            if (l == r) {
                sum[rt] = arr[l];
                return;
            }
            int mid = (l + r) >> 1;
            build(l, mid, rt << 1);
            build(mid + 1, r, rt << 1 | 1);
            pushUp(rt);
        }

        /*
        L~R：所有的值变成 C
        l~r：rt
         */
        public void update(int L, int R, int C, int l, int r, int rt) {
            if (L <= l && r <= R) {
                update[rt] = true;
                change[rt] = C;
                sum[rt] = (r - l + 1) * C;
                lazy[rt] = 0;
                return;
            }
            // 当前任务躲不掉，无法懒更新，要往下发
            int mid = (l + r) >> 1;
            pushDown(rt, mid - l + 1, r - mid);
            if (L <= mid) {
                update(L, R, C, l, mid, rt << 1);
            }
            if (R > mid) {
                update(L, R, C, mid + 1, r, rt << 1 | 1);
            }
            pushUp(rt);
        }

        // L~R C 任务！
        // rt, l~r
        public void add(int L, int R, int C, int l, int r, int rt) {
            // 任务如果把此时的范围全包了
            if (L <= l && r <= R) {
                sum[rt] += (r - l + 1) * C;
                lazy[rt] += C;
                return;
            }
            // 任务没有把你全包！
            int mid = (l + r) >> 1;
            pushDown(rt, mid - l + 1, r - mid);
            // L~R
            if (L <= mid) {
                add(L, R, C, l, mid, rt << 1);
            }
            if (R > mid) {
                add(L, R, C, mid + 1, r, rt << 1 | 1);
            }
            pushUp(rt);
        }

        public long query(int L, int R, int l, int r, int rt) {
            if (L <= l && r <= R) {
                return sum[rt];
            }
            int mid = (l + r) >> 1;
            pushDown(rt, mid - l + 1, r - mid);
            long ans = 0;
            if (L <= mid) {
                ans += query(L, R, l, mid, rt << 1);
            }
            if (R > mid) {
                ans += query(L, R, mid + 1, r, rt << 1 | 1);
            }
            return ans;
        }
    }

    public static class Right{
        public int[] arr;

        public Right(int[] origin){
            arr=new int[origin.length+1];
            for(int i=0; i<origin.length; i++){
                arr[i+1]=origin[i];
            }
        }

        public void update(int L,int R,int C){
            for(int i=L; i<=R; i++){
                arr[i]=C;
            }
        }

        public void add(int L,int R,int C){
            for(int i=L; i<=R; i++){
                arr[i]+=C;
            }
        }

        public long query(int L,int R){
            long ans=0;
            for(int i=L; i<=R; i++){
                ans+=arr[i];
            }
            return ans;
        }
    }

    public static int[] genarateRandomArray(int len, int max) {
        int size = (int) (Math.random() * len) + 1;
        int[] origin = new int[size];
        for (int i = 0; i < size; i++) {
            origin[i] = (int) (Math.random() * max) - (int) (Math.random() * max);
        }
        return origin;
    }

    public static boolean test(){
        int len=100;
        int max=100;
        int testTimes=5000;
        int addOrUpdateTimes=1000;
        int queryTimes=500;
        for(int i=0; i<testTimes; i++){
            int[] origin=genarateRandomArray(len,max);
            SegmentTree seg=new SegmentTree(origin);
            int S=1;
            int N=origin.length;
            int root=1;
            seg.build(S,N,root);
            Right right=new Right(origin);
            for(int j=0; j<addOrUpdateTimes; j++){
                int num1=(int)(Math.random()*N)+1;
                int num2=(int)(Math.random()*N)+1;
                int L=Math.min(num1,num2);
                int R=Math.max(num1,num2);
                int C=(int)(Math.random()*max)-(int)(Math.random()*max);
                if(Math.random()<0.5){
                    seg.add(L,R,C,S,N,root);
                    right.add(L,R,C);
                }else{
                    seg.update(L,R,C,S,N,root);
                    right.update(L,R,C);
                }
            }
            for(int k=0; k<queryTimes; k++){
                int num1=(int)(Math.random()*N)+1;
                int num2=(int)(Math.random()*N)+1;
                int L=Math.min(num1,num2);
                int R=Math.max(num1,num2);
                long ans1=seg.query(L,R,S,N,root);
                long ans2=right.query(L,R);
                if(ans1!=ans2){
                    return false;
                }
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int[] origin = { 2, 1, 1, 2, 3, 4, 5 };
        SegmentTree seg = new SegmentTree(origin);
        int S = 1; // 整个区间的开始位置，规定从1开始，不从0开始 -> 固定
        int N = origin.length; // 整个区间的结束位置，规定能到N，不是N-1 -> 固定
        int root = 1; // 整棵树的头节点位置，规定是1，不是0 -> 固定
        int L = 2; // 操作区间的开始位置 -> 可变
        int R = 5; // 操作区间的结束位置 -> 可变
        int C = 4; // 要加的数字或者要更新的数字 -> 可变
        // 区间生成，必须在[S,N]整个范围上build
        seg.build(S, N, root);
        // 区间修改，可以改变L、R和C的值，其他值不可改变
        seg.add(L, R, C, S, N, root);
        // 区间更新，可以改变L、R和C的值，其他值不可改变
        seg.update(L, R, C, S, N, root);
        // 区间查询，可以改变L和R的值，其他值不可改变
        long sum = seg.query(L, R, S, N, root);
        System.out.println(sum);

        System.out.println("对数器测试开始...");
        System.out.println("测试结束："+(test()?"通过":"未通过"));
    }
}