【数据结构】线段树
区间加，区间和
P3372 【模板】线段树 1
封装版
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
template <typename T>
class LazySegmentTree
{
private:
int n; // 数组元素个数
vector<T> tree; // 线段树节点数组
vector<T> lazy; // 延迟标记数组
// 下推延迟标记
void push_down(int node, int l, int r)
{
if (lazy[node] == 0) return;
int mid = (l + r) >> 1;
int left_child = node << 1;
int right_child = node << 1 | 1;
// 更新左子树
tree[left_child] += lazy[node] * (mid - l + 1);
lazy[left_child] += lazy[node];
// 更新右子树
tree[right_child] += lazy[node] * (r - mid);
lazy[right_child] += lazy[node];
// 清除当前节点标记
lazy[node] = 0;
}
// 构建线段树
void build(int node, int l, int r, const vector<T>& data)
{
if (l == r)
{
tree[node] = data[l];
return;
}
int mid = (l + r) >> 1;
build(node << 1, l, mid, data);
build(node << 1 | 1, mid + 1, r, data);
tree[node] = tree[node << 1] + tree[node << 1 | 1];
}
// 区间更新
void update_range(int node, int l, int r, int ul, int ur, T val)
{
if (ul <= l && r <= ur)
{
tree[node] += val * (r - l + 1);
lazy[node] += val;
return;
}
push_down(node, l, r);
int mid = (l + r) >> 1;
if (ul <= mid) update_range(node << 1, l, mid, ul, ur, val);
if (ur > mid) update_range(node << 1 | 1, mid + 1, r, ul, ur, val);
tree[node] = tree[node << 1] + tree[node << 1 | 1];
}
// 区间查询
T query_range(int node, int l, int r, int ql, int qr)
{
if (ql <= l && r <= qr) return tree[node];
push_down(node, l, r);
int mid = (l + r) >> 1;
T sum = 0;
if (ql <= mid) sum += query_range(node << 1, l, mid, ql, qr);
if (qr > mid) sum += query_range(node << 1 | 1, mid + 1, r, ql, qr);
return sum;
}
public:
/* 构造函数
* 参数：数据数组（下标从1开始）
* 示例: LazySegmentTree<int> st(vector<int>(n+1));
*/
LazySegmentTree(const vector<T>& data) : n(data.size() - 1)
{
tree.resize(4 * n);
lazy.resize(4 * n, 0);
build(1, 1, n, data);
}
/* 区间加法更新
* 参数：左端点 l，右端点 r，增加值 val
* 注意：自动处理 l > r 的情况
*/
void update(int l, int r, T val)
{
if (l > r) swap(l, r);
update_range(1, 1, n, l, r, val);
}
/* 区间求和查询
* 参数：左端点 l，右端点 r
* 返回：区间 [l, r] 的元素和
*/
T query(int l, int r)
{
if (l > r) swap(l, r);
return query_range(1, 1, n, l, r);
}
};
void solve()
{
int n, m, op, x, y;
ll k;
cin >> n >> m;
vector<ll> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
LazySegmentTree<ll> tr(a);
while (m--)
{
cin >> op >> x >> y;
if (op == 1)
{
cin >> k;
tr.update(x, y, k);
}
else
{
cout << tr.query(x, y) << '\n';
}
}
}
int main()
{
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
数组版本（推荐默写）
// Problem: P3372 【模板】线段树 1
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P3372
// Memory Limit: 512 MB
// Time Limit: 1000 ms
#include <iostream>
#define lc u << 1
#define rc u << 1 | 1
using namespace std;
using ll = long long;
const int N = 1e5 + 10;
ll w[N];
ll sum[N << 2]; // 区间和
ll add[N << 2]; // 懒标记
void pushup(int u)
{
sum[u] = sum[lc] + sum[rc];
}
void pushdown(int u, int l, int r)
{
if (add[u])
{
int mid = (l + r) >> 1;
// 更新左子树
sum[lc] += add[u] * (mid - l + 1);
add[lc] += add[u];
// 更新右子树
sum[rc] += add[u] * (r - mid);
add[rc] += add[u];
// 清除当前节点标记
add[u] = 0;
}
}
void build(int u, int l, int r)
{
if (l == r)
{
sum[u] = w[l];
return;
}
int mid = (l + r) >> 1;
build(lc, l, mid);
build(rc, mid + 1, r);
pushup(u);
}
void update(int u, int l, int r, int x, int y, ll k)
{
if (x <= l && y >= r)
{
sum[u] += (r - l + 1) * k;
add[u] += k;
return;
}
pushdown(u, l, r);
int mid = (l + r) >> 1;
if (x <= mid) update(lc, l, mid, x, y, k);
if (y > mid) update(rc, mid + 1, r, x, y, k);
pushup(u);
}
ll query(int u, int l, int r, int x, int y)
{
if (x <= l && y >= r) return sum[u];
pushdown(u, l, r);
int mid = (l + r) >> 1;
ll sum = 0;
if (x <= mid) sum += query(lc, l, mid, x, y);
if (y > mid) sum += query(rc, mid + 1, r, x, y);
return sum;
}
void solve()
{
int n, m, op, x, y;
ll k;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> w[i];
build(1, 1, n);
while (m--)
{
cin >> op >> x >> y;
if (op == 1)
{
cin >> k;
update(1, 1, n, x, y, k);
}
else
{
cout << query(1, 1, n, x, y) << '\n';
}
}
}
int main()
{
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
结构体版本
// Problem: P3372 【模板】线段树 1
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P3372
// Memory Limit: 512 MB
// Time Limit: 1000 ms
#include <iostream>
#define lc u << 1
#define rc u << 1 | 1
using namespace std;
using ll = long long;
const int N = 1e5 + 10;
ll w[N];
struct Node
{
int l, r;
ll sum, add;
} t[N * 4];
void pushup(int u)
{
t[u].sum = t[lc].sum + t[rc].sum;
}
void pushdown(int u) // 下传懒标记
{
if (t[u].add)
{
t[lc].sum += t[u].add * (t[lc].r - t[lc].l + 1);
t[rc].sum += t[u].add * (t[rc].r - t[rc].l + 1);
t[lc].add += t[u].add;
t[rc].add += t[u].add;
t[u].add = 0;
}
}
void build(int u, int x, int y) // 从[x,y]建树
{
t[u] = {x, y, w[x], 0};
if (x == y) return;
int mid = (x + y) >> 1;
build(lc, x, mid);
build(rc, mid + 1, y);
pushup(u);
}
void update(int u, int x, int y, ll k) //[x,y]+=k
{
if (x <= t[u].l && y >= t[u].r)
{
t[u].sum += (t[u].r - t[u].l + 1) * k;
t[u].add += k;
return;
}
pushdown(u);
int mid = (t[u].l + t[u].r) >> 1;
if (x <= mid) update(lc, x, y, k);
if (y > mid) update(rc, x, y, k);
pushup(u);
}
ll query(int u, int x, int y) // 求[x,y]的和
{
if (x <= t[u].l && y >= t[u].r) return t[u].sum;
pushdown(u);
int mid = (t[u].l + t[u].r) >> 1;
ll sum = 0;
if (x <= mid) sum += query(lc, x, y);
if (y > mid) sum += query(rc, x, y);
return sum;
}
void solve()
{
int n, m, op, x, y;
ll k;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> w[i];
build(1, 1, n);
while (m--)
{
cin >> op >> x >> y;
if (op == 1)
{
cin >> k;
update(1, x, y, k);
}
else
{
cout << query(1, x, y) << '\n';
}
}
}
int main()
{
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
区间加，区间最大/小值
板子
template <typename T>
class MaxSegmentTree
{
private:
int n; // 数组元素个数
vector<T> tree; // 线段树节点数组（存储区间最大值）
vector<T> lazy; // 延迟标记（区间加法）
// 下推延迟标记（核心变化：最大值直接加）
void push_down(int node)
{
if (lazy[node] == 0) return;
// 更新左子节点
tree[node * 2] += lazy[node];
lazy[node * 2] += lazy[node];
// 更新右子节点
tree[node * 2 + 1] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
// 清除当前节点标记
lazy[node] = 0;
}
// 构建线段树（合并方式改为取最大值）
void build(int node, int l, int r, const vector<T>& data)
{
if (l == r)
{
tree[node] = data[l];
return;
}
int mid = (l + r) / 2;
build(node * 2, l, mid, data);
build(node * 2 + 1, mid + 1, r, data);
tree[node] = max(tree[node * 2], tree[node * 2 + 1]); // 关键修改点
}
// 区间加法更新（最大值直接加val）
void update_range(int node, int l, int r, int ul, int ur, T val)
{
if (ul <= l && r <= ur)
{
tree[node] += val; // 最大值直接加（不是乘区间长度）
lazy[node] += val;
return;
}
push_down(node);
int mid = (l + r) / 2;
if (ul <= mid) update_range(node * 2, l, mid, ul, ur, val);
if (ur > mid) update_range(node * 2 + 1, mid + 1, r, ul, ur, val);
tree[node] = max(tree[node * 2], tree[node * 2 + 1]); // 重新计算最大值
}
// 区间最大值查询
T query_max(int node, int l, int r, int ql, int qr)
{
if (ql <= l && r <= qr) return tree[node];
push_down(node);
int mid = (l + r) / 2;
T max_val = numeric_limits<T>::min(); // 初始化为最小值
if (ql <= mid)
max_val = max(max_val, query_max(node * 2, l, mid, ql, qr));
if (qr > mid)
max_val = max(max_val, query_max(node * 2 + 1, mid + 1, r, ql, qr));
return max_val;
}
public:
/* 构造函数
* 参数：数据数组（下标从1开始）
* 示例: MaxSegmentTree<int> st(vector<int>(n+1));
*/
MaxSegmentTree(const vector<T>& data) : n(data.size() - 1)
{
tree.resize(4 * n);
lazy.resize(4 * n, 0);
build(1, 1, n, data);
}
/* 区间加法更新
* 参数：左端点 l，右端点 r，增加值 val
*/
void update(int l, int r, T val)
{
if (l > r) swap(l, r);
update_range(1, 1, n, l, r, val);
}
/* 区间最大值查询
* 参数：左端点 l，右端点 r
*/
T getMax(int l, int r)
{
if (l > r) swap(l, r);
return query_max(1, 1, n, l, r);
}
};
使用示例
// int 类型示例
vector<int> data{0, 3, 1, 4, 1, 5}; // 有效数据[3,1,4,1,5]
MaxSegmentTree<int> st(data);
st.update(2, 4, 2); // 区间[2,4]加2 → [3,3,6,3,5]
cout << st.getMax(1,5); // 输出6（原4+2=6）
// long long 类型示例
vector<long long> data_ll{0, 1e18, 2e18, 3e18};
MaxSegmentTree<long long> st_ll(data_ll);
cout << st_ll.getMax(1,3); // 输出3000000000000000000
自定义类型示例（需重载运算符）
struct MyStruct {
int val;
MyStruct(int v = 0) : val(v) {}
// 必须重载运算符
MyStruct operator+(const MyStruct& rhs) const {
return MyStruct(val + rhs.val);
}
bool operator<(const MyStruct& rhs) const {
return val < rhs.val;
}
friend MyStruct max(const MyStruct& a, const MyStruct& b) {
return (a.val > b.val) ? a : b;
}
};
vector<MyStruct> custom_data{0, MyStruct(5), MyStruct(3), MyStruct(7)};
MaxSegmentTree<MyStruct> st_custom(custom_data);
st_custom.update(1, 3, MyStruct(2)); // 区间加2 → [7,5,9]
cout << st_custom.getMax(1,3).val; // 输出9
区间加，区间乘，区间和
板子
template <typename T>
class SegmentTree
{
private:
int n; // 数组元素个数（下标从1开始）
T mod; // 模数
vector<T> sum; // 区间和数组
vector<T> mul; // 乘法延迟标记
vector<T> add; // 加法延迟标记
// 更新子节点值并合并标记
void eval(int u, int l, int r, T m, T a)
{
sum[u] = (sum[u] * m + a * (r - l + 1)) % mod;
mul[u] = (mul[u] * m) % mod;
add[u] = (add[u] * m + a) % mod;
}
// 下推延迟标记
void pushdown(int u, int l, int r)
{
if (mul[u] == 1 && add[u] == 0) return;
int mid = (l + r) >> 1;
eval(u << 1, l, mid, mul[u], add[u]); // 更新左子节点
eval(u << 1 | 1, mid + 1, r, mul[u], add[u]); // 更新右子节点
mul[u] = 1;
add[u] = 0;
}
// 构建线段树
void build(int u, int l, int r, const vector<T>& data)
{
if (l == r)
{
sum[u] = data[l] % mod;
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid, data);
build(u << 1 | 1, mid + 1, r, data);
sum[u] = (sum[u << 1] + sum[u << 1 | 1]) % mod;
}
// 区间修改
void modify(int u, int l, int r, int ul, int ur, T m, T a)
{
if (ul <= l && r <= ur)
{
eval(u, l, r, m, a);
return;
}
pushdown(u, l, r);
int mid = (l + r) >> 1;
if (ul <= mid) modify(u << 1, l, mid, ul, ur, m, a);
if (ur > mid) modify(u << 1 | 1, mid + 1, r, ul, ur, m, a);
sum[u] = (sum[u << 1] + sum[u << 1 | 1]) % mod;
}
// 区间查询
T query(int u, int l, int r, int ql, int qr)
{
if (ql <= l && r <= qr) return sum[u];
pushdown(u, l, r);
int mid = (l + r) >> 1;
T res = 0;
if (ql <= mid) res = (res + query(u << 1, l, mid, ql, qr)) % mod;
if (qr > mid) res = (res + query(u << 1 | 1, mid + 1, r, ql, qr)) % mod;
return res;
}
public:
SegmentTree(const vector<T>& data, T m) : mod(m)
{
n = data.size() - 1; // 数据下标从1开始
sum.resize(4 * (n + 1));
mul.resize(4 * (n + 1), 1);
add.resize(4 * (n + 1), 0);
build(1, 1, n, data);
}
// 区间乘法 [l, r] *= k
void multiply(int l, int r, T k)
{
modify(1, 1, n, l, r, k % mod, 0);
}
// 区间加法 [l, r] += k
void add_val(int l, int r, T k)
{
modify(1, 1, n, l, r, 1, k % mod);
}
// 查询区间和 [l, r]
T get_sum(int l, int r)
{
return query(1, 1, n, l, r);
}
};
P3373 【模板】线段树 2
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
template <typename T>
class SegmentTree
{
private:
int n; // 数组元素个数（下标从1开始）
T mod; // 模数
vector<T> sum; // 区间和数组
vector<T> mul; // 乘法延迟标记
vector<T> add; // 加法延迟标记
// 更新子节点值并合并标记
void eval(int u, int l, int r, T m, T a)
{
sum[u] = (sum[u] * m + a * (r - l + 1)) % mod;
mul[u] = (mul[u] * m) % mod;
add[u] = (add[u] * m + a) % mod;
}
// 下推延迟标记
void pushdown(int u, int l, int r)
{
if (mul[u] == 1 && add[u] == 0) return;
int mid = (l + r) >> 1;
eval(u << 1, l, mid, mul[u], add[u]); // 更新左子节点
eval(u << 1 | 1, mid + 1, r, mul[u], add[u]); // 更新右子节点
mul[u] = 1;
add[u] = 0;
}
// 构建线段树
void build(int u, int l, int r, const vector<T>& data)
{
if (l == r)
{
sum[u] = data[l] % mod;
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid, data);
build(u << 1 | 1, mid + 1, r, data);
sum[u] = (sum[u << 1] + sum[u << 1 | 1]) % mod;
}
// 区间修改
void modify(int u, int l, int r, int ul, int ur, T m, T a)
{
if (ul <= l && r <= ur)
{
eval(u, l, r, m, a);
return;
}
pushdown(u, l, r);
int mid = (l + r) >> 1;
if (ul <= mid) modify(u << 1, l, mid, ul, ur, m, a);
if (ur > mid) modify(u << 1 | 1, mid + 1, r, ul, ur, m, a);
sum[u] = (sum[u << 1] + sum[u << 1 | 1]) % mod;
}
// 区间查询
T query(int u, int l, int r, int ql, int qr)
{
if (ql <= l && r <= qr) return sum[u];
pushdown(u, l, r);
int mid = (l + r) >> 1;
T res = 0;
if (ql <= mid) res = (res + query(u << 1, l, mid, ql, qr)) % mod;
if (qr > mid) res = (res + query(u << 1 | 1, mid + 1, r, ql, qr)) % mod;
return res;
}
public:
SegmentTree(const vector<T>& data, T m) : mod(m)
{
n = data.size() - 1; // 数据下标从1开始
sum.resize(4 * (n + 1));
mul.resize(4 * (n + 1), 1);
add.resize(4 * (n + 1), 0);
build(1, 1, n, data);
}
// 区间乘法 [l, r] *= k
void multiply(int l, int r, T k)
{
modify(1, 1, n, l, r, k % mod, 0);
}
// 区间加法 [l, r] += k
void add_val(int l, int r, T k)
{
modify(1, 1, n, l, r, 1, k % mod);
}
// 查询区间和 [l, r]
T get_sum(int l, int r)
{
return query(1, 1, n, l, r);
}
};
int main()
{
ios::sync_with_stdio(false), cin.tie(0);
int n, q, mod;
cin >> n >> q >> mod;
vector<ll> a(n + 1);
for (int i = 1; i <= n; ++i) cin >> a[i];
SegmentTree<ll> tr(a, mod);
while (q--)
{
int op, x, y;
ll k;
cin >> op >> x >> y;
if (op == 1)
{
cin >> k;
tr.multiply(x, y, k);
}
else if (op == 2)
{
cin >> k;
tr.add_val(x, y, k);
}
else
{
cout << tr.get_sum(x, y) << '\n';
}
}
return 0;
}
浙公网安备 33010602011771号