洛谷 P3372 【模板】线段树 1

合集 - 3.26~4.13 蓝桥杯省赛备赛(28)

1.P8687 [蓝桥杯 2019 省 A] 糖果2024-03-252.洛谷 P1115 最大子段和2024-03-253.写模板， 并查集。2024-03-254.洛谷 P1656 炸铁路2024-03-265.写模板，树状数组。2024-03-266.洛谷 P3374 【模板】树状数组 12024-03-267.洛谷 P3368 【模板】树状数组 22024-03-268.洛谷 P9237 [蓝桥杯 2023 省 A] 像素放置2024-03-269.洛谷 P5937 [CEOI1999] Parity Game2024-03-2710.洛谷 P8306 【模板】字典树2024-03-2711.写模板，kmp。2024-03-2712.写模板， LCA。2024-03-2813.洛谷 P1967 [NOIP2013 提高组] 货车运输2024-03-2814.写模板，线段树2024-03-2815.蓝桥杯-百亿富翁2024-03-29

16.洛谷 P3372 【模板】线段树 12024-03-29

17.模拟比赛-14届研究生组C++省赛2024-04-0118.写模板， 线性筛2024-04-0119.写模板-质数的简单应用2024-04-0220.洛谷 P1196 [NOI2002] 银河英雄传说2024-04-0421.洛谷 P1004 [NOIP2000 提高组] 方格取数2024-04-0422.蓝桥杯 计算方程2024-04-0423.洛谷 P1006 [NOIP2008 提高组] 传纸条2024-04-0524.蓝桥杯-算法赛第9场强者：贝贝的2.02024-04-0825.P1002 [NOIP2002 普及组] 过河卒2024-04-0826.蓝桥杯，推导部分和2024-04-0827.牛客，小红不想做完全背包2024-04-0928.蓝桥杯-岛屿个数2024-04-10

收起

题意： 区间更新区间查询

思路：直接线段树实现就行，难点还是手撕线段树的结构跟细节。 说一下merge：直接对两个区间的sum求和。applyLazy：lazy值*区间长度。

struct Node{
    bool is_lazy;
    long long sum = 0;
    long long lazy_val = 0;

    Node(): is_lazy(false){}

    Node operator + (const Node& other){
        Node res = *this;
        res.sum += other.sum;
        return res;
    }

    void operator |= (const Node& other){
        this->lazy_val += other.lazy_val;
        this->is_lazy = true;
    }

    void applyLazy(Node& lazy, int length){
        this->sum += lazy.lazy_val * length;
    }
};




template <typename T>
class SegmentTree{
public:
    SegmentTree(int sz): sz_(sz), flag_{}{
        st_.resize(4 * sz_);
        lazy_.resize(4 * sz_);
    }

    SegmentTree(const vector<T>& s): SegmentTree(int(s.size() - 1)){
        function<void(int, int, int)> build = [&](int p, int l, int r){
            if (l == r){
                st_[p] = s[l];
            }
            else{
                int mid = (l + r) >> 1;
                build(p << 1, l, mid);
                build(p << 1 | 1, mid + 1, r);
                st_[p] = merge(st_[p << 1], st_[p << 1 | 1]);
            }
        };
        build(1, 1, sz_);
    }

    void update(int i, int j, T val){
        update(1, 1, sz_, i, j, val);
    }

    T query(int i, int j){
        return query(1, 1, sz_, i, j);
    }


private:
    int sz_;
    vector<T> st_;
    vector<T> lazy_;
    const T flag_;

    T merge(T a, T b){
        return a + b;
    }

    void pushDown(int p, int l, int r){
        if (lazy_[p].is_lazy){
            st_[p].applyLazy(lazy_[p], r - l + 1);
            if (l != r){
                lazy_[p << 1] |= lazy_[p];
                lazy_[p << 1 | 1] |= lazy_[p];
            }
            lazy_[p] = flag_;
        }
    }

    void update(int p, int l, int r, int i, int j, T val){
        pushDown(p, l, r);
        if (i > j){
            return;
        }
        if (l >= i && r <= j){
            lazy_[p] = val;
            lazy_[p].is_lazy = true;
            pushDown(p, l, r);
        }
        else{
            int mid = (l + r) >> 1;
            update(p << 1, l, mid, i, min(mid, j), val);
            update(p << 1 | 1, mid + 1, r, max(i, mid + 1), j, val);
            st_[p] = merge(st_[p << 1], st_[p << 1 | 1]);
        }
    }

    T query(int p, int l, int r, int i, int j){
        pushDown(p, l, r);
        if (l >= i && r <= j){
            return st_[p];
        }
        int mid = (l + r) >> 1;
        if (j <= mid){
            return query(p << 1, l, mid, i, j);
        }
        else if (i > mid){
            return query(p << 1 | 1, mid + 1, r, i, j);
        }
        return merge(query(p << 1, l, mid, i, mid), query(p << 1 | 1, mid + 1, r, mid + 1, j));
    }
};


void solve(){
    int n, q;
    cin >> n >> q;

    vector<Node> a(n + 1);
    for (int i = 1; i <= n; ++i){
        cin >> a[i].sum;
    }
    SegmentTree<Node> st(a);

    while (q --){
        int t;
        cin >> t;
        int x, y;
        cin >> x >> y;
        if (t & 1){
            Node k;
            cin >> k.lazy_val;
            st.update(x, y, k);
        }
        else{
            cout << st.query(x, y).sum << '\n';
        }
    }
}

总结：
1 build里面忘记合并子区间。
2 query忘记写返回值
3 |=重载多写了返回值，导致lazy_val没有有向下传递到子区间

感觉在空间复杂度上还可以优化，室友有更好的存储lazy值的方式