广外oj 亚丝娜和桐人的战斗（线段树or树状数组）

最近市面出现了一款全新的游戏，Absolute Counter Online，简称ACO。Asuna跟她的男票Kirito也都跑去玩这个了。ACO有一个特殊的战斗模式，就是完全反击模式，在这个模式里，Boss跟小怪会来进攻Kirito他们的领地，在他们领地的前面，有N个魔法阵，这些魔法阵排成一条横线，从左往右第i个魔法阵有初始魔力M[i]，这些魔法阵会不停消耗魔力攻击接近领地的敌人，并且它们要进入领地必须经过魔法阵。而Kirito他们不会主动出击，也不能出去，只有当敌人突破魔法阵时，Kirito他才能对敌人进行攻击。Asuna的角色能力是精通各种魔法，在这个模式中，她有一项重要能力，就是修复魔法阵，当一个魔法阵魔力损耗时，她可以直接将这个魔法阵恢复到原先的状态，即填充满魔力。另外，她还有一项技能，就是将擅长二刀流的Kirito传送到任意一个魔法阵的位置，增加那里的战斗力，Kirito的战斗力固定为A，并且Kirito自己不会跑去别的魔法阵，因为妻管严。魔法阵的魔力损耗会实时反馈给Asuna，但是她已经来不及去计算了，所以她请了个外援，也就是你，来帮她算下，各个魔法阵的实时战斗力。一个魔法阵的战斗力计算很简单，如果Kirito在这个魔法阵，则战斗力等于M[i] + A，否则等于M[i]。
你会接收到Q次信息，信息类型如下，第一个为信息编码，后面根据信息操作码类型给出一个或多个参数：
1、MOVE X，表示把Kirito移动到第X个魔法阵。
2、REPAIR X, 表示Asuna修复了第X个魔法阵，请注意，这里只会修复到相应魔法阵的初始魔力，即把魔力修复到M[X]。
3、ATTACK X V，表示第X个魔法阵消耗了V魔力进行了攻击。
4、QUERY L R，表示查询第L个魔法阵到第R个魔法阵的战斗力总和。

Input
第一行输入一个T，表示有T组数据。
每组数据，第一行输入N, A, X，依次为魔法阵数量，Kirito的攻击力以及Kirito所在魔法阵编号。
接下来一行有N个数字，依次表示各个魔法阵的初始魔力。
接下来一行，一个整数Q，表示要接收处理的信息数量。
接着有Q行，每行先一个操作码，操作码只有4种（MOVE REPAIR ATTACK QUERY)，根据操作码类型后面跟着一个或两个参数，参数个数及意义请参照描述。
数据范围：
1 <= T <= 20
1 <= N <= 100000
1 <= Q <= 200000
1 <= A, M[i] <= 1000000000
对于操作MOVE和REPAIR，1 <= X <= N
对于操作ATTACK，1 <= X <= N，1 <= V <= 当前第X个魔法阵的魔力，即保证魔法阵的魔力不会小于0。
对于操作QUERY，1 <= L <= R <= N。
所有输入都是正整数。

Output
对于第k组数据，先输出一行“Case #k:”，k从1开始计数。
对于QUERY操作，输出一行表示查询的对应的战斗力总和。

线段树单点更新版本：

public class Asuna {
    static Node[] a = new Node[100005 << 2 | 1];
    static int[] mirr = new int[100005];
    static int index = 0;

    public static void main(String[] args) {
        // Scanner reader = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        InputReader reader = new InputReader();
        int t = reader.nextInt();
        int cases = 1;
        while (t-- > 0) {
            int n = reader.nextInt();
            int kiri = reader.nextInt();
            int x = reader.nextInt();
            for (int i = 0; i < n; i++) {
                mirr[i] = reader.nextInt();
            }

            for (int i = 0; i <= 100005 << 2; i++) {
                a[i] = new Node();
            }
            index = 0;
            build(1, 1, n);
            out.println("Case #" + (cases++) + ":");
            int q = reader.nextInt();
            while (q-- > 0) {
                String com = reader.next();
                int c = reader.nextInt();
                if (com.equals("QUERY")) {
                    int d = reader.nextInt();
                    long ans = query(1, c, d, 1, n);
                    if (x >= c && x <= d) {
                        ans += kiri;
                    }
                    out.println(ans);
                } else if (com.equals("ATTACK")) {
                    int v = reader.nextInt();
                    attack(1, c, c, 1, n, v);
                } else if (com.equals("MOVE")) {
                    x = c;
                } else {
                    repair(1, c, c, 1, n);
                }
            }
        }
        out.close();
    }

    public static void pushUp(int i) {
        a[i].maigic = a[i << 1].maigic + a[i << 1 | 1].maigic;
    }

    public static void build(int i, int l, int r) {
        if (l == r) {
            a[i].id = index;
            a[i].maigic = mirr[index++];
            return;
        }
        int mid = (l + r) / 2;
        build(i << 1, l, mid);
        build(i << 1 | 1, mid + 1, r);
        pushUp(i);
    }

    public static void repair(int i, int L, int R, int l, int r) {
        if (l >= L && r <= R) {
            a[i].maigic = mirr[a[i].id];
            return;
        }
        int mid = (l + r) / 2;
        if (L <= mid) {
            repair(i << 1, L, R, l, mid);
        }
        if (R > mid) {
            repair(i << 1 | 1, L, R, mid + 1, r);
        }
        pushUp(i);
    }

    public static void attack(int i, int L, int R, int l, int r, int v) {
        if (l >= L && r <= R) {
            a[i].maigic -= v;
            return;
        }
        int mid = (l + r) / 2;
        if (L <= mid) {
            attack(i << 1, L, R, l, mid, v);
        }
        if (R > mid) {
            attack(i << 1 | 1, L, R, mid + 1, r, v);
        }
        pushUp(i);
    }

    public static long query(int i, int L, int R, int l, int r) {
        if (l >= L && r <= R) {
            return a[i].maigic;
        }
        int mid = (l + r) / 2;
        long ans = 0;
        if (L <= mid) {
            ans += query(i << 1, L, R, l, mid);
        }
        if (R > mid) {
            ans += query(i << 1 | 1, L, R, mid + 1, r);
        }
        return ans;
    }

    static class Node {
        long maigic;
        int id;
    }
}

贼长，手动再见。

树状数组版本：

public class AsunaBinaryIndex {
    static long[] a = new long[100005];
    static int[] mirr = new int[100005];
    static int n;

    public static void main(String[] args) {
        // Scanner reader = new Scanner(System.in);
        InputReader reader = new InputReader();
        PrintWriter out = new PrintWriter(System.out);
        int t = reader.nextInt();
        int cases = 1;
        while (t-- > 0) {
            System.out.println("Case #" + (cases++) + ":");
            n = reader.nextInt();
            int kiri = reader.nextInt();
            int x = reader.nextInt();
            Arrays.fill(a, 0);
            for (int i = 1; i <= n; i++) {
                mirr[i] = reader.nextInt();
                update(i, mirr[i]);
            }
            int q = reader.nextInt();
            while (q-- > 0) {
                String com = reader.next();
                int c = reader.nextInt();
                if (com.charAt(0) == 'Q') {
                    int d = reader.nextInt();
                    long ans = getSum(d) - getSum(c - 1);
                    if (x >= c && x <= d) {
                        ans += kiri;
                    }
                    System.out.println(ans);
                } else if (com.charAt(0) == 'A') {
                    int v = reader.nextInt();
                    update(c, v * -1);
                } else if (com.charAt(0) == 'M') {
                    x = c;
                } else {
                    update(c, (getSum(c) - getSum(c - 1)) * -1);
                    update(c, mirr[c]);
                }
            }
        }
    }

    public static int lowbit(int i) {
        return i & (-i);
    }

    public static void update(int i, long val) {
        while (i <= n) {
            a[i] += val;
            i += lowbit(i);
        }
    }

    public static long getSum(int i) {
        long sum = 0;
        while (i > 0) {
            sum += a[i];
            i -= lowbit(i);
        }
        return sum;
    }
}