求高人优化代码

问题描述

有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。

package 算法训练;

import java.util.ArrayList;
import java.util.Scanner;

public class 操作格子线段树 {

	public static Node[] node = new Node[300000];

	// 初始化节点
	public static void init(int l, int r, int i) {
		node[i].l = l;
		node[i].r = r;
		node[i].max = 0;
		node[i].sum = 0;
		if (l != r) {
			int mid = (l + r) / 2;
			init(l, mid, 2 * i);
			init(mid + 1, r, 2 * i + 1);
		}
	}

	// 插入
	public static void insert(int i, int x, int m) {
		if (x >= node[i].l && x <= node[i].r) {
			node[i].max = m;
			node[i].sum = m;
		}
		if (node[i].l == node[i].r)
			return;
		int mid = (node[i].l + node[i].r) / 2;
		if (x > mid)
			insert(2 * i + 1, x, m);
		else
			insert(2 * i, x, m);
		node[i].sum = node[2 * i].sum + node[2 * i + 1].sum;
		node[i].max = Math.max(node[2 * i].max, node[2 * i + 1].max);
	}

	// 查找最大值
	public static int find_max(int x, int y, int i) {
		if (x == node[i].l && y == node[i].r)
			return node[i].max;
		int mid = (node[i].l + node[i].r) / 2;
		if (x > mid)
			return find_max(x, y, 2 * i + 1);
		else if (y <= mid)
			return find_max(x, y, 2 * i);
		else
			return Math.max(find_max(x, mid, 2 * i),
					find_max(mid + 1, y, 2 * i + 1));
	}

	// 计算区间和
	public static int find_sum(int x, int y, int i) {
		if (node[i].l == x && node[i].r == y)
			return node[i].sum;
		int mid = (node[i].l + node[i].r) / 2;
		if (x > mid)
			return find_sum(x, y, 2 * i + 1);
		else if (y <= mid)
			return find_sum(x, y, 2 * i);
		else
			return find_sum(x, mid, 2 * i) + find_sum(mid + 1, y, 2 * i + 1);
	}

	public static void main(String[] args) {

		for (int i = 0; i < 300000; i++) {
			node[i] = new Node();
		}
		int n, m, i, b, x, y, cas;
		Scanner scanner = new Scanner(System.in);
		n = scanner.nextInt();
		m = scanner.nextInt();
		init(1, n, 1);
		for (i = 1; i <= n; i++) {
			b = scanner.nextInt();
			insert(1, i, b);
		}
		ArrayList<Integer> arrayList=new ArrayList<Integer>();
		while (m > 0) {
			cas = scanner.nextInt();
			x = scanner.nextInt();
			y = scanner.nextInt();
			if (cas == 1) {
				insert(1, x, y);
			} else if (cas == 2) {
				arrayList.add(find_sum(x, y, 1));
			} else if (cas == 3) {
				arrayList.add(find_max(x, y, 1));
			}
			m--;
		}
		for(Integer integer:arrayList){
			System.out.println(integer);
		}
	}
}

// 构造一个结构体
class Node {
	public int l = 0;
	public int r = 0;
	public int max = 0;
	public int sum = 0;
}

算法根据http://blog.csdn.net/libin56842/article/details/19909975的C语言改编成的java语言，但是用时太长，不知道再如何优化了，求高人指点