【算法 - 数据结构】线段树 - 单点修改

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了【算法 - 数据结构】线段树 - 单点修改，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含3584字，纯文字阅读大概需要6分钟。

内容图文

struct SegmentTree {

#define ls (u << 1)
#define rs (u << 1 | 1)
#define mid ((l + r) >> 1)

    static const int MAXN = 2e5 + 10;
    static const ll LINF = 1e18 + 10;

    ll mi[MAXN << 2];
    ll mx[MAXN << 2];
    ll sum[MAXN << 2];

    void PushUp(int u) {
        mi[u] = min(mi[ls], mi[rs]);
        mx[u] = max(mx[ls], mx[rs]);
        sum[u] = sum[ls] + sum[rs];
    }

    void Build(int u, int l, int r) {
        if(l == r) {
            mi[u] = mx[u] = sum[u] = 0;
            return;
        }
        Build(ls, l, mid);
        Build(rs, mid + 1, r);
        PushUp(u);
    }

    void UpdateSet(int u, int l, int r, int P, ll v) {
        if(l == r) {
            mi[u] = mx[u] = sum[u] = v;
            return;
        }
        if(P <= mid) UpdateSet(ls, l, mid, P, v);
        if(P >= mid + 1) UpdateSet(rs, mid + 1, r, P, v);
        PushUp(u);
    }

    void UpdateAdd(int u, int l, int r, int P, ll v) {
        if(l == r) {
            mi[u] += v, mx[u] += v, sum[u] += v;
            return;
        }
        if(P <= mid) UpdateAdd(ls, l, mid, P, v);
        if(P >= mid + 1) UpdateAdd(rs, mid + 1, r, P, v);
        PushUp(u);
    }

    ll QueryMin(int u, int l, int r, int L, int R) {
        if(L <= l && r <= R)
            return mi[u];
        ll res = LINF;
        if(L <= mid) res = min(res, QueryMin(ls, l, mid, L, R));
        if(R >= mid + 1) res = min(res, QueryMin(rs, mid + 1, r, L, R));
        return res;
    }

    ll QueryMax(int u, int l, int r, int L, int R) {
        if(L <= l && r <= R)
            return mx[u];
        ll res = -LINF;
        if(L <= mid) res = max(res, QueryMax(ls, l, mid, L, R));
        if(R >= mid + 1) res = max(res, QueryMax(rs, mid + 1, r, L, R));
        return res;
    }

    ll QuerySum(int u, int l, int r, int L, int R) {
        if(L <= l && r <= R)
            return sum[u];
        ll res = 0;
        if(L <= mid) res += QuerySum(ls, l, mid, L, R);
        if(R >= mid + 1) res += QuerySum(rs, mid + 1, r, L, R);
        return res;
    }

#undef ls
#undef rs
#undef mid

} st;

超省心版：

struct SegmentTree {

private:

#define ls (u << 1)
#define rs (u << 1 | 1)
#define mid ((l + r) >> 1)

    static const int MAXN = 3e5 + 10;
    static const ll LINF = 1e18 + 10;

    int n;
    struct Node {
        ll sum, mi, ma;
        Node() {
            sum = 0, mi = LINF, ma = -LINF;
            return;
        }
        Node& operator=(ll val) {
            sum = val, mi = val, ma = val;
            return *this;
        }
        Node& operator+=(ll val) {
            sum += val, mi += val, ma += val;
            return *this;
        }
    } node[MAXN << 2];

    Node mergeFrom(const Node &x, const Node &y) {
        Node res;
        res.sum = x.sum + y.sum;
        res.mi = min(x.mi, y.mi);
        res.ma = min(x.ma, y.ma);
        return move(res);
    }

    void innerBuild(int u, int l, int r) {
        if (l > r)
            return;
        if (l == r) {
            node[u] = Node();
            return;
        }
        innerBuild(ls, l, mid);
        innerBuild(rs, mid + 1, r);
        node[u] = mergeFrom(node[ls], node[rs]);
        return;
    }

    void innerUpdateSet(int u, int l, int r, int pos, ll val) {
        if (l > r || pos > r || pos < l)
            return;
        if (l == r) {
            node[u] = val;
            return;
        }
        innerUpdateSet(ls, l, mid, pos, val);
        innerUpdateSet(rs, mid + 1, r, pos, val);
        node[u] = mergeFrom(node[ls], node[rs]);
        return;
    }

    void innerUpdateAdd(int u, int l, int r, int pos, ll val) {
        if (l > r || pos > r || pos < l)
            return;
        if (l == r) {
            node[u] += val;
            return;
        }
        innerUpdateAdd(ls, l, mid, pos, val);
        innerUpdateAdd(rs, mid + 1, r, pos, val);
        node[u] = mergeFrom(node[ls], node[rs]);
        return;
    }

    Node innerQuery(int u, int l, int r, int lpos, int rpos) {
        if (l > r || lpos > r || rpos < l)
            return Node();
        if (lpos <= l && r <= rpos)
            return node[u];
        Node resL = innerQuery(ls, l, mid, lpos, rpos);
        Node resR = innerQuery(rs, mid + 1, r, lpos, rpos);
        return mergeFrom(resL, resR);
    }

#undef ls
#undef rs
#undef mid

public:

    void build(int n) {
        this->n = n;
        innerBuild(1, 1, n);
    }

    void updateSet(int pos, ll val) {
        innerUpdateSet(1, 1, n, pos, val);
    }

    void updateAdd(int pos, ll val) {
        innerUpdateAdd(1, 1, n, pos, val);
    }

    Node query(int lpos, int rpos) {
        return innerQuery(1, 1, n, lpos, rpos);
    }

    ll querySum(int lpos, int rpos) {
        return query(lpos, rpos).sum;
    }

    ll queryMin(int lpos, int rpos) {
        return query(lpos, rpos).mi;
    }

    ll queryMax(int lpos, int rpos) {
        return query(lpos, rpos).ma;
    }

} st;

内容总结

以上是互联网集市为您收集整理的【算法 - 数据结构】线段树 - 单点修改全部内容，希望文章能够帮你解决【算法 - 数据结构】线段树 - 单点修改所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

---