【Leetcode刷题java之 3216. 交换后字典序最小的字符串】

Leetcode刷题java之 3216. 交换后字典序最小的字符串
解题思路
1. 数据结构设计
SegNode：代表线段树中的一个节点，其中 v00, v01, v10, v11 分别表示四种状态下的最大值：
v00：不选当前节点及其前一个节点时的最大和。
v01：不选当前节点但选其前一个节点时的最大和。
v10：选当前节点但不选其前一个节点时的最大和。
v11：选当前节点也选其前一个节点时的最大和（这里实际上不会使用，因为不允许相邻元素都选）。
SegTree：线段树类，用于维护区间信息。
初始化时创建足够数量的 SegNode 节点。
init 方法用于初始化线段树。
update 方法用于在线段树中更新指定位置的值。
query 方法用于查询整个区间的最大和。
2. 主要逻辑
初始化线段树：遍历 nums 数组，并在线段树中记录每个位置的最大子序列和。
处理查询：对于每个查询 [posi, xi]，在线段树中更新 nums[posi] 的值为 xi，并重新计算受影响的节点。
计算最大和：每次更新后，查询整个区间的最大和，并累加到最终结果中。

class SegNode {
    long v00, v01, v10, v11;
    SegNode() {
        v00 = v01 = v10 = v11 = 0;
    }

    void set(long v) {
        v00 = v01 = v10 = 0;
        v11 = Math.max(v, 0);
    }

    long best() {
        return v11;
    }
}

class SegTree {
    int n;
    SegNode[] tree;

    SegTree(int n) {
        this.n = n;
        tree = new SegNode[n * 4 + 1];
        for (int i = 0; i < tree.length; i++) {
            tree[i] = new SegNode();
        }
    }

    void init(int[] nums) {
        internalInit(nums, 1, 1, n);
    }

    void update(int x, int v) {
        internalUpdate(1, 1, n, x + 1, v);
    }

    long query() {
        return tree[1].best();
    }

    private void internalInit(int[] nums, int x, int l, int r) {
        if (l == r) {
            tree[x].set(nums[l - 1]);
            return;
        }
        int mid = (l + r) / 2;
        internalInit(nums, x * 2, l, mid);
        internalInit(nums, x * 2 + 1, mid + 1, r);
        pushup(x);
    }

    private void internalUpdate(int x, int l, int r, int pos, int v) {
        if (l > pos || r < pos) {
            return;
        }
        if (l == r) {
            tree[x].set(v);
            return;
        }
        int mid = (l + r) / 2;
        internalUpdate(x * 2, l, mid, pos, v);
        internalUpdate(x * 2 + 1, mid + 1, r, pos, v);
        pushup(x);
    }

    private void pushup(int x) {
        int l = x * 2, r = x * 2 + 1;
        tree[x].v00 = Math.max(tree[l].v00 + tree[r].v10, tree[l].v01 + tree[r].v00);
        tree[x].v01 = Math.max(tree[l].v00 + tree[r].v11, tree[l].v01 + tree[r].v01);
        tree[x].v10 = Math.max(tree[l].v10 + tree[r].v10, tree[l].v11 + tree[r].v00);
        tree[x].v11 = Math.max(tree[l].v10 + tree[r].v11, tree[l].v11 + tree[r].v01);
    }
}

class Solution {
    public static final int MOD = 1000000007;
    public int maximumSumSubsequence(int[] nums, int[][] queries) {
        int n = nums.length;
        SegTree tree = new SegTree(n);
        tree.init(nums);

        long ans = 0;
        for (int[] q : queries) {
            tree.update(q[0], q[1]);
            ans = (ans + tree.query()) % MOD;
        }
        return (int) ans;
    }
}