线段树

修改与与加减合并

import java.util.Scanner;

public class Main {

    static class SegmentTree {
        // arr[]为原序列的信息从0开始，但在arr里是从1开始的
        // sum[]模拟线段树维护区间和
        // lazy[]为累加懒惰标记
        // change[]为更新的值
        // update[]为更新慵懒标记
        private int n;
        private long[] arr;
        private long[] sum;
        private long[] lazy;
        private long[] change;
        private boolean[] update;

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

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

        // ln表示左子树元素结点个数，rn表示右子树结点个数
        private 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];
                sum[rt << 1] += lazy[rt] * ln;
                lazy[rt << 1 ^ 1] += lazy[rt];
                sum[rt << 1 ^ 1] += lazy[rt] * rn;
                lazy[rt] = 0;
            }
        }

        // 在初始化阶段，先把sum数组，填好
        // 在arr[l~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);
        }

        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] = C * (r - l + 1);
                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
        // l,r -> 表达的范围
        // 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] += C * (r - l + 1);
                lazy[rt] += C;
                return;
            }
            // 要把任务往下发
            // 任务  L, R  没有把本身表达范围 l,r 彻底包住
            int mid = (l + r) >> 1;
            // 下发之前的lazy add任务
            pushDown(rt, mid - l + 1, r - mid);
            // 左孩子是否需要接到任务
            if (L <= mid) {
                add(L, R, C, l, mid, rt << 1);
            }
            // 右孩子是否需要接到任务
            if (R > mid) {
                add(L, R, C, mid + 1, r, rt << 1 ^ 1);
            }
            // 左右孩子做完任务后，我更新我的sum信息
            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 void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = in.nextInt();
            int m = in.nextInt();
            long[] arr = new long[n];
            for (int i = 0; i < n; ++i) {
                arr[i] = in.nextInt();
            }
            SegmentTree segmentTree = new SegmentTree(arr);
            while (m-- > 0) {
                String command = in.next();
                int x = in.nextInt();
                int y = in.nextInt();
                if ("Add".equals(command)) {
                    int a = in.nextInt();
                    segmentTree.add(x, y, a, 1, n, 1);
                } else if ("Update".equals(command)) {
                    int a = in.nextInt();
                    segmentTree.update(x, y, a, 1, n, 1);
                } else {
                    System.out.println(segmentTree.query(x, y, 1, n, 1));
                }
            }
        }
    }

}

加减与乘法合并

import java.util.Arrays;

class Fancy {

    private SegmentTree segmentTree;

    public Fancy() {
        this.segmentTree = new SegmentTree(100000);
    }

    public void append(int val) {
        segmentTree.append(val);
    }

    public void addAll(int inc) {
        segmentTree.addAll(inc);
    }

    public void multAll(int m) {
        segmentTree.multAll(m);
    }

    public int getIndex(int idx) {
        return segmentTree.getIndex(idx);
    }
}

class SegmentTree {

    private static final int MOD = 1000000007;

    private int limit;

    private long[] sum;

    private long[] add;

    private long[] multiply;

    private int size;


    public SegmentTree(int limit) {
        this.limit = limit;
        this.sum = new long[limit << 2 | 1];
        this.add = new long[limit << 2 | 1];
        this.multiply = new long[limit << 2 | 1];
        Arrays.fill(multiply, 1);
    }

    private void pushUp(int rt) {
        this.sum[rt] = (this.sum[rt << 1] + this.sum[rt << 1 | 1]) % MOD;
    }

    private void pushDown(int rt, int ln, int rn) {
        if (add[rt] != 0 || multiply[rt] != 1) {
            sum[rt << 1] = (sum[rt << 1] * multiply[rt] + ln * add[rt]) % MOD;
            sum[rt << 1 | 1] = (sum[rt << 1 | 1] * multiply[rt] + rn * add[rt]) % MOD;
            multiply[rt << 1] = multiply[rt << 1] * multiply[rt] % MOD;
            multiply[rt << 1 | 1] = multiply[rt << 1 | 1] * multiply[rt] % MOD;
            add[rt << 1] = (add[rt << 1] * multiply[rt] + add[rt]) % MOD;
            add[rt << 1 | 1] = (add[rt << 1 | 1] * multiply[rt] + add[rt]) % MOD;
            multiply[rt] = 1;
            add[rt] = 0;
        }
    }

    private void multiply(int L, int R, int l, int r, int rt, int x) {
        if (L <= l && r <= R) {
            sum[rt] = sum[rt] * x % MOD;
            multiply[rt] = multiply[rt] * x % MOD;
            add[rt] = add[rt] * x % MOD;
            return;
        }
        int mid = (l + r) >> 1;
        pushDown(rt, mid - l + 1, r - mid);
        if (L <= mid) {
            multiply(L, R, l, mid, rt << 1, x);
        }
        if (mid < R) {
            multiply(L, R, mid + 1, r, rt << 1 | 1, x);
        }
        pushUp(rt);
    }

    private void add(int L, int R, int l, int r, int rt, int x) {
        if (L <= l && r <= R) {
            sum[rt] = (sum[rt] + (long) (r - l + 1) * x) % MOD;
            add[rt] = (add[rt] + x) % MOD;
            return;
        }
        int mid = (l + r) >> 1;
        pushDown(rt, mid - l + 1, r - mid);
        if (L <= mid) {
            add(L, R, l, mid, rt << 1, x);
        }
        if (mid < R) {
            add(L, R, mid + 1, r, rt << 1 | 1, x);
        }
        pushUp(rt);
    }

    private 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 = (ans + query(L, R, l, mid, rt << 1)) % MOD;
        }
        if (mid < R) {
            ans = (ans + query(L, R, mid + 1, r, rt << 1 | 1)) % MOD;
        }
        return ans;
    }

    public void append(int x) {
        this.size++;
        add(this.size, this.size, 1, limit, 1, x);
    }

    public void addAll(int x) {
        if (size == 0) {
            return;
        }
        add(1, this.size, 1, limit, 1, x);
    }


    public void multAll(int x) {
        if (size == 0) {
            return;
        }
        multiply(1, this.size, 1, limit, 1, x);
    }

    public int getIndex(int index) {
        if (index >= size) {
            return -1;
        }
        return (int) query(index + 1, index + 1, 1, limit, 1);
    }
}

/**
 * Your Fancy object will be instantiated and called as such:
 * Fancy obj = new Fancy();
 * obj.append(val);
 * obj.addAll(inc);
 * obj.multAll(m);
 * int param_4 = obj.getIndex(idx);
 */