LeetCode 307. 区域和检索 - 数组可修改

307. 区域和检索 - 数组可修改题解

题目来源：307. 区域和检索 - 数组可修改

2022.04.04 每日一题

LeetCode 题解持续更新中GitHub仓库地址 CSDN博客地址

今天的题目可以使用线段树进行求解

创建一个线段树，树中的节点存放的是数组 nums 索引[s,e]的总和

• 如果 s=e ，该节点就是 叶子节点 ，其对应的值就是 nums[e]
• 如果 s<e ，该节点的左节点就保存区间[s,(int)(s+e)/2]的总和，右节点保存[(int)(s+e)/2+1,e]的总和 ，当前节点的值就是左右两个节点的值的和

如果需要修改数字，我们可以修改对应的叶子节点，然后使用递归的方法更新对应值

对于给定范围求值，我们可以将给定的范围 [left,right]进行拆分，拆成线段树中相对应的区间，然后相加取和

class NumArray {
public:
    vector<int> segmentTree;
    int n;

    NumArray(vector<int> &nums) {
        n = nums.size();
        segmentTree = vector<int>(4 * n);
        build(0, 0, n - 1, nums);
    }

    void update(int index, int val) {
        change(index, val, 0, 0, n - 1);
    }

    int sumRange(int left, int right) {
        return range(left, right, 0, 0, n - 1);
    }

    void build(int node, int s, int e, vector<int> &nums) {
        // 如果当前节点首尾相同，就说明当前的值是叶子节点
        if (s == e) {
            segmentTree[node] = nums[s];
            return;
        }
        // 将当前范围分成两部分
        int m = s + (e - s) / 2;
        // 左右两侧分别进行递归调用，进行推导
        build(node * 2 + 1, s, m, nums);
        build(node * 2 + 2, m + 1, e, nums);
        // 求解两个和
        segmentTree[node] = segmentTree[node * 2 + 1] + segmentTree[node * 2 + 2];
    }

    void change(int index, int val, int node, int s, int e) {
        // 更新节点的值，并且更新树
        if (s == e) {
            segmentTree[node] = val;
            return;
        }
        int m = s + (e - s) / 2;
        if (index <= m) {
            change(index, val, node * 2 + 1, s, m);
        } else {
            change(index, val, node * 2 + 2, m + 1, e);
        }
        segmentTree[node] = segmentTree[node * 2 + 1] + segmentTree[node * 2 + 2];
    }

    int range(int left, int right, int node, int s, int e) {
        // 如果 left 与 right 的范围 与我们所划分的范围相等，直接返回相应的节点值可以
        if (left == s && right == e) {
            return segmentTree[node];
        }
        // 反之就进行拆分，直到我们可以得到相应的节点值
        int m = s + (e - s) / 2;
        if (right <= m) {
            return range(left, right, node * 2 + 1, s, m);
        } else if (left > m) {
            return range(left, right, node * 2 + 2, m + 1, e);
        } else {
            return range(left, m, node * 2 + 1, s, m) + range(m + 1, right, node * 2 + 2, m + 1, e);
        }
    }
};

class NumArray {
    private int[] segmentTree;
    private int n;

    public NumArray(int[] nums) {
        n = nums.length;
        segmentTree = new int[nums.length * 4];
        build(0, 0, n - 1, nums);
    }

    public void update(int index, int val) {
        change(index, val, 0, 0, n - 1);
    }

    public int sumRange(int left, int right) {
        return range(left, right, 0, 0, n - 1);
    }

    private void build(int node, int s, int e, int[] nums) {
        // 如果当前节点首尾相同，就说明当前的值是叶子节点
        if (s == e) {
            segmentTree[node] = nums[s];
            return;
        }
        // 将当前范围分成两部分
        int m = s + (e - s) / 2;
        // 左右两侧分别进行递归调用，进行推导
        build(node * 2 + 1, s, m, nums);
        build(node * 2 + 2, m + 1, e, nums);
        // 求解两个和
        segmentTree[node] = segmentTree[node * 2 + 1] + segmentTree[node * 2 + 2];
    }

    private void change(int index, int val, int node, int s, int e) {
        // 更新节点的值，并且更新树
        if (s == e) {
            segmentTree[node] = val;
            return;
        }
        int m = s + (e - s) / 2;
        if (index <= m) {
            change(index, val, node * 2 + 1, s, m);
        } else {
            change(index, val, node * 2 + 2, m + 1, e);
        }
        segmentTree[node] = segmentTree[node * 2 + 1] + segmentTree[node * 2 + 2];
    }

    private int range(int left, int right, int node, int s, int e) {
        // 如果 left 与 right 的范围 与我们所划分的范围相等，直接返回相应的节点值可以
        if (left == s && right == e) {
            return segmentTree[node];
        }
        // 反之就进行拆分，直到我们可以得到相应的节点值
        int m = s + (e - s) / 2;
        if (right <= m) {
            return range(left, right, node * 2 + 1, s, m);
        } else if (left > m) {
            return range(left, right, node * 2 + 2, m + 1, e);
        } else {
            return range(left, m, node * 2 + 1, s, m) + range(m + 1, right, node * 2 + 2, m + 1, e);
        }
    }
}