蓝桥杯--ALGO 8 操作格子

/*
 * 算法训练 操作格子  
时间限制：1.0s   内存限制：256.0MB

问题描述
有n个格子，从左到右放成一排，编号为1-n。
共有m次操作，有3种操作类型：
1.修改一个格子的权值，
2.求连续一段格子权值和，
3.求连续一段格子的最大值。
对于每个2、3操作输出你所求出的结果。
输入格式
第一行2个整数n，m。
接下来一行n个整数表示n个格子的初始权值。
接下来m行，每行3个整数p,x,y，p表示操作类型，p=1时表示修改格子x的权值为y，p=2时表示求区间[x,y]内格子权值和，p=3时表示求区间[x,y]内格子最大的权值。
输出格式
有若干行，行数等于p=2或3的操作总数。
每行1个整数，对应了每个p=2或3操作的结果。
样例输入
4 3
1 2 3 4
2 1 3
1 4 3
3 1 4
样例输出
6
3
数据规模与约定
对于20%的数据n <= 100，m <= 200。
对于50%的数据n <= 5000，m <= 5000。
对于100%的数据1 <= n <= 100000，m <= 100000，0 <= 格子权值 <= 10000。


线段树区间值更新，在回溯时更新本节点的值，自底向上
java版本运行超时，如果你有建议欢迎留言
 */
//操作格子  03-05 17:54 926B    JAVA    运行超时    50  运行超时

import java.util.Scanner;

public class ALGO_008 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int n,m,p,x,y;
        n=scan.nextInt();
        m=scan.nextInt();
        init(1,n,1);
        int value;
        for(int i=1;i<=n;i++){
            value=scan.nextInt();
            update(1,i,value);
        }
        for(int i=0;i<m;i++){
            p=scan.nextInt();
            x=scan.nextInt();
            y=scan.nextInt();
            switch(p){
            case 1:update(1,x,y);break;
            case 2:System.out.println(getSum(x,y,1));break;
            case 3:System.out.println(getMax(x,y,1));break;
            default:break;
            }
        }
    }
    static Node[] tree=new Node[1000000];
    static int n;
    public static void init(int left,int right,int index){
        if(tree[index]==null)tree[index]=new Node(left,right);
        if(left==right){
            return ;
        }
        int mid=(left+right)/2;
        init(left,mid,index*2);
        init(mid+1,right,index*2+1);
    }
    public static void update(int index,int x,int value){
        int left=tree[index].left;
        int right=tree[index].right;
        if(x>=left&&x<=right){
            if(left==right){
                tree[index].max=tree[index].sum=value;
                return ;
            }
            int mid=(left+right)/2;
            if(x<=mid){
                update(index*2,x,value);
            }else{
                update(index*2+1,x,value);
            }
            tree[index].max=Math.max(tree[index*2].max,tree[index*2+1].max);
            tree[index].sum=tree[index*2].sum+tree[index*2+1].sum;
        }
    }
    public static int getMax(int x,int y,int index){
        int left=tree[index].left;
        int right=tree[index].right;
        if(left==x&&y==right)return tree[index].max;
        int mid=(left+right)/2;
        if(x>mid){
            return getMax(x,y,index*2+1);
        }else if(y<=mid){
            return getMax(x,y,index*2);
        }else{
            return Math.max(getMax(x,mid,index*2), getMax(mid+1,y,index*2+1));
        }
    }
    public static int getSum(int x,int y,int index){
        int left=tree[index].left;
        int right=tree[index].right;
        if(left==x&&y==right)return tree[index].sum;
        int mid=(left+right)/2;
        if(x>mid){
            return getSum(x,y,index*2+1);
        }else if(y<=mid){
            return getSum(x,y,index*2);
        }else{
            return getSum(x,mid,index*2)+getSum(mid+1,y,index*2+1);
        }
    }


}
class Node{
    int left,right;
    int sum;
    int max;
    public Node(int left,int right){
        sum=0;
        max=0;
        this.left=left;
        this.right=right;
    }
}