线段树的例题

最新推荐文章于 2022-04-04 04:36:15 发布
最新推荐文章于 2022-04-04 04:36:15 发布
阅读量369 收藏 1
点赞数
分类专栏： # 算法模板 # 0x40 数据结构进阶
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43772166/article/details/109053292
版权

文章目录

影子的宽度

题目描述

桌子上零散地放着若干个盒子，盒子都平行于墙。桌子的后方是一堵墙。如图所示。现在从桌子的前方射来一束平行光， 把盒子的影子投射到了墙上。问影子的总宽度是多少？

输入

第1行：3个整数L，R，N。-100000 <=L<=R<= 100000，表示墙所在的区间；1<=N<=100000，表示盒子的个数

接下来N行，每行2个整数BL, BR，-100000 <=BL<=BR<= 100000，表示一个盒子的左、右端点（左闭右开）

输出

第1行：1个整数W，表示影子的总宽度。

样例输入

Sample Input 1

0 7 2
1 2
4 5

Sample Output 1
2

Sample Input 2

-10 10 2
-5 2
-2 2

Sample Output 2
7

Sample Input 3

-10 10 3
-7 0
-4 9
-4 2

Sample Output 3
16

Sample Input 4

-100 100 3
-7 2
5 9
2 5

Sample Output 4
16

Sample Input 5

-50 50 4
-2 4
0 6
9 10
-5 30

Sample Output 5
35

大致就是一道考察懒标记的题，比较简单

因为下标是可能为负，需要加一个偏移量

#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
typedef long long ll;

ll a[N];

struct Node {
    int l, r;
    ll sum, maxv, lazy;
    void updade() {
        sum = r - l + 1;
        lazy = 1;
    }
} tree[N * 4];

void build(int p, int l, int r)
{
    tree[p].l = l, tree[p].r = r;
    tree[p].sum = tree[p].lazy = 0;
    if (l == r) {
        tree[p].sum = tree[p].maxv = a[l];
        return;
    }
    int mid = l + r >> 1;
    build(p << 1, l , mid);
    build(p << 1 | 1, mid + 1, r);
    tree[p].sum = tree[p << 1].sum + tree[p << 1 | 1].sum;
    tree[p].maxv = max(tree[p << 1].maxv, tree[p << 1 | 1].maxv);
}

void spread(int p)
{
    int lazy_val = tree[p].lazy;
    if (lazy_val) {
        tree[p << 1].updade();
        tree[p << 1 | 1].updade();
        tree[p].lazy = 0;
    }
}

void update(int p, int l, int r)
{
    if (l <= tree[p].l &&  tree[p].r <= r) {
        tree[p].updade();
    } else {
        spread(p);
        int mid = tree[p].l + tree[p].r  >> 1;
        if (l <= mid) 
			update(p << 1, l, r);
        if (r > mid) 
			update(p << 1 | 1, l, r);
        tree[p].sum = tree[p << 1].sum + tree[p << 1 | 1].sum;
        //tree[p].maxv = max(tree[p << 1].maxv , tree[p << 1 | 1].maxv);
    }
}

ll query(int p, int l, int r)
{
    if (l <= tree[p].l && tree[p].r <= r) 
		return tree[p].sum;

    spread(p);
    ll ans = 0;
    int mid = tree[p].l + tree[p].r >> 1;
    if (l <= mid) 
		ans = ans + query(p << 1, l, r);
    if (r > mid) 
		ans = ans + query(p << 1 | 1, l, r);
    return ans;
}

int main()
{
    int L, R, n, q, l, r, d;
    scanf("%d%d%d", &L, &R, &q);
    d = -L + 1; // 偏移量 
    build(1, L + d, R + d);
    while (q--) { 
        scanf("%d%d", &l, &r);
        
        update(1, l + d, r - 1 + d);
    }
    printf("%lld\n", query(1, L + d, R + d));
    
    return 0;
}

区间平方和问题：

给你一个长度为N的序列，之后有M次操作，操作包括两类：

A L R 为给区间[L,R]的所有数都加上一个A的值

S L R 为求区间[L,R]的所有数的平方的和

如果一个区间内的所有数字，都加上A，那么psum = 2 * sum * A + (r - l + 1) * A
注意要先更新psum，再更新sum

#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
typedef long long ll;

ll a[N];

struct Node {
    int l, r;
    ll sum, psum, maxv, lazy;
    void updade(ll x) {
        psum += (r - l + 1) * x * x + 2 * x * sum;
        sum += (r - l + 1) * x;
        lazy += x;
    }
} tree[N * 4];

void push_up(int p)
{
	tree[p].sum = tree[p << 1].sum + tree[p << 1 | 1].sum;
    tree[p].psum = tree[p << 1].psum + tree[p << 1 | 1].psum;
}

void build(int p, int l, int r)
{
    tree[p].l = l, tree[p].r = r;
    tree[p].psum = tree[p].sum = tree[p].lazy = 0;
    if (l == r) {
        tree[p].sum = tree[p].maxv = a[l];
        tree[p].psum = a[l] * a[l];
        return;
    }
    int mid = l + r >> 1;
    build(p << 1, l , mid);
    build(p << 1 | 1, mid + 1, r);
    push_up(p);
    //tree[p].maxv = max(tree[p << 1].maxv, tree[p << 1 | 1].maxv);
}

void spread(int p)
{
    int lazy_val = tree[p].lazy;
    if (lazy_val) {
        tree[p << 1].updade(lazy_val);
        tree[p << 1 | 1].updade(lazy_val);
        tree[p].lazy = 0;
    }
}

void update(int p, int l, int r, int val)
{
    if (l <= tree[p].l &&  tree[p].r <= r) {
        tree[p].updade(val);
    } else {
        spread(p);
        int mid = tree[p].l + tree[p].r  >> 1;
        if (l <= mid) 
			update(p << 1, l, r, val);
        if (r > mid) 
			update(p << 1 | 1, l, r, val);
        push_up(p);
    }
}

ll query(int p, int l, int r)
{
    if (l <= tree[p].l && tree[p].r <= r) 
		return tree[p].psum;

    spread(p);
    ll ans = 0;
    int mid = tree[p].l + tree[p].r >> 1;
    if (l <= mid) 
		ans = ans + query(p << 1, l, r);
    if (r > mid) 
		ans = ans + query(p << 1 | 1, l, r);
    return ans;
}

int main()
{
    int n, q, l, r, val, opt;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) 
		scanf("%lld", a + i);
    build(1, 1, n);
    scanf("%d", &q);
    while (q--) {
        scanf("%d", &opt);
        if (opt == 2) {
            scanf("%d %d", &l, &r);
            printf("%lld\n", query(1, l, r));
        } else {
            scanf("%d %d %d", &l, &r, &val);
            update(1, l, r, val);
        }
    }
    return 0;
}

区间开根号问题

还有bug没有调出来QAQ

stars

题目传送门：poj 2352

需要注意线段树的大小，还有因为 x 坐标是从 0 开始的，需要对x++

#include <cstdio>
#include <algorithm>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 3e4 + 10;
typedef long long ll;

ll a[N];
ll res[N];

struct Node {
    int l, r;
    ll sum, maxv, lazy;
    void updade(ll x) {
        sum += (r - l + 1) * x;
        maxv += x;
        lazy += x;
    }
} tree[N * 4];

void build(int p, int l, int r)
{
    tree[p].l = l, tree[p].r = r;
    tree[p].sum = tree[p].lazy = 0;
    if (l == r) {
        tree[p].sum = tree[p].maxv = a[l];
        return;
    }
    int mid = l + r >> 1;
    build(p << 1, l , mid);
    build(p << 1 | 1, mid + 1, r);
    tree[p].sum = tree[p << 1].sum + tree[p << 1 | 1].sum;
    tree[p].maxv = max(tree[p << 1].maxv, tree[p << 1 | 1].maxv);
}

void spread(int p)
{
    int lazy_val = tree[p].lazy;
    if (lazy_val) {
        tree[p << 1].updade(lazy_val);
        tree[p << 1 | 1].updade(lazy_val);
        tree[p].lazy = 0;
    }
}

void update(int p, int x, int val)
{
    if (tree[p].l == tree[p].r) {
        tree[p].updade(val);
    } else {
        //spread(p);
        int mid = tree[p].l + tree[p].r >> 1;
        if (x <= mid) 
			update(p << 1, x, val);
        if (x > mid) 
			update(p << 1 | 1, x, val);
        tree[p].sum = tree[p << 1].sum + tree[p << 1 | 1].sum;
        tree[p].maxv = max(tree[p << 1].maxv , tree[p << 1 | 1].maxv);
    }
}

ll query(int p, int l, int r)
{
    if (l <= tree[p].l && tree[p].r <= r) 
		return tree[p].sum;

    //spread(p);
    ll ans = 0;
    int mid = tree[p].l + tree[p].r >> 1;
    if (l <= mid) 
		ans = ans + query(p << 1, l, r);
    if (r > mid) 
		ans = ans + query(p << 1 | 1, l, r);
    return ans;
}

int main()
{
    int n, q, x, y, val, opt;
    scanf("%d", &n);
    build(1, 1, 32005);
    for (int i = 1; i <= n; i++) {
        scanf("%d%d", &x, &y); 
        x++;
        int k = query(1, 1, x);
        res[k]++;
        update(1, x, 1);
    }
    for (int i = 0; i <= n - 1; i++) {
    	printf("%lld\n", res[i]);
    }
    
    return 0;
}

逆序对

题目传送门：逆序对

需要进行离散化

离散化之后从右向左依次遍历，假设当前数是 x ，查询有多少之前出现过的（即在 x 右边的）数字

#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 5e5 + 10;
typedef long long ll;

ll a[N], b[N];
int n, m;

struct Node {
    int l, r;
    ll sum, maxv, lazy;
    void updade(ll x) {
        sum += (r - l + 1) * x;
        maxv += x;
        lazy += x;
    }
} tree[N * 4];

void push_up(int p)
{
	tree[p].sum = tree[p << 1].sum + tree[p << 1 | 1].sum;
    tree[p].maxv = max(tree[p << 1].maxv, tree[p << 1 | 1].maxv);
}

void build(int p, int l, int r)
{
    tree[p].l = l, tree[p].r = r;
    tree[p].sum = tree[p].lazy = 0;
    if (l == r) {
        tree[p].sum = tree[p].maxv = a[l];
        return;
    }
    int mid = l + r >> 1;
    build(p << 1, l , mid);
    build(p << 1 | 1, mid + 1, r);
    push_up(p);
}

void spread(int p)
{
    int lazy_val = tree[p].lazy;
    if (lazy_val) {
        tree[p << 1].updade(lazy_val);
        tree[p << 1 | 1].updade(lazy_val);
        tree[p].lazy = 0;
    }
}

void update(int p, int l, int r, int val)
{
    if (l <= tree[p].l &&  tree[p].r <= r) {
        tree[p].updade(val);
    } else {
        spread(p);
        int mid = tree[p].l + tree[p].r  >> 1;
        if (l <= mid) 
			update(p << 1, l, r, val);
        if (r > mid) 
			update(p << 1 | 1, l, r, val);
        push_up(p);
    }
}

ll query(int p, int l, int r)
{
    if (l <= tree[p].l && tree[p].r <= r) 
		return tree[p].sum;

    spread(p);
    ll ans = 0;
    int mid = tree[p].l + tree[p].r >> 1;
    if (l <= mid) 
		ans = ans + query(p << 1, l, r);
    if (r > mid) 
		ans = ans + query(p << 1 | 1, l, r);
    return ans;
}

void discrete()
{
	sort(b + 1, b + n + 1);
	for (int i = 1; i <= n; i++) {
		if (i == 1 || b[i] != b[i - 1])
			b[++m] = b[i];
	}
}

int main()
{
    int q, l, r, val, opt;
    scanf("%d", &n);
    build(1, 1, n);
    
    for (int i = 1; i <= n; ++i) {
		scanf("%lld", a + i);
		b[i] = a[i];
	}
	ll idx, res = 0;
    discrete();
    for (int i = n; i >= 1; i--) {
    	idx = lower_bound(b + 1, b + m + 1, a[i]) - b;
        res += query(1, 1, idx - 1);
        update(1, idx, idx, 1);
    }
    printf("%lld\n", res);
    
    return 0;
}
默_silence
关注
专栏目录
线段树 (经典题目合集)
繁凡さん的博客
02-11 1505
P3372 【模板】线段树 1 #include<bits/stdc++.h> using namespace std; typedef long long ll; const ll N=1e5+7; const ll mod=2147483647; ll n,m; struct node { ll l,r,sum,lz; }tree[N]; ll arr[N]; void b...
线段树 例题
ZCY的博客
07-30 283
A - 敌兵布阵 C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手,但这些都逃不过C国的监视。 中央情报局要研究敌人...
线段树习题集
天亮说晚安
02-17 3854
线段树习题集 大部分来源于@NotOnlySuccess  一、点修改 最最基础的线段树,只更新叶子节点,然后把信息用PushUp(int rt)这个函数更新上来 hdu1166 敌兵布阵 线段树功能:update:单点增减 query:区间求和 解题报告 hdu1754 I Hate It 线段树功能:update:单点替换 query:区间最值 解
线段树例题
Tom~~~
08-16 699
线段树是一种二叉搜索树，将原始数据都存在叶节点，依次表示出每个叶节点的根节点。 一般数组开到叶节点数量的4倍。 关于线段树的例题 。HDU1166 敌兵布阵 按照指示来就可以 代码 #include &lt;stdio.h&gt; #include &lt;algorithm&gt; #include &lt;iostream&gt; #include &lt;string&gt; u...
线段树（例题）
CUCUC1的博客
07-11 217
线段树tq（巨佬太强了）l 题目链接 1、hdu1166敌兵布阵 最基础的线段树应用，这里没有用上区间修改，但是这个题可以当个板子 /*递归方法*/ #include <iostream> #include <cstring> #include <string> #include <cstdio> using namespace std; const int maxn = 50000 + 5;//元素总个数 int p[4 * maxn],add[4 *
线段树例题 题解
日居月诸的博客
09-11 467
文章目录T1题目链接解题思路详细代码T2题目链接解题思路详细代码T3题目链接解题思路详细代码 T1 题目链接 LOJ#10128. 「一本通 4.3 练习 2」花神游历各国 解题思路 首先，由于是区间问题，我们很容易想到使用线段树来维护区间和，完成区间修改操作。 但是区间修改操作并不好处理。如果对于区间里每个数都暴力地开平方，这一次操作的时间复杂度可是会退化成为O(n)O(n)O(n)的！ 怎么办...
线段树习题
06-15 298
维护什么 bzoj1798维护序列 原理lazy标记 一个是乘，一个是加 加不影响乘 乘要让加的标记也乘 开longlong bzoj1858 先维护1和0的数量即和 在区间内左侧1和右侧1及区间内最多1 覆盖标记和取反标记，覆盖可以覆盖取反。 bzoj3888 对于每个时间段按y从小到大往里覆盖 如果为空就加一 不为空就返回 用离散化 联想到一道求城市轮廓线的题
c++线段树例题亚特兰蒂斯
07-06
有几个古希腊书籍中包含了对传说中的亚特兰蒂斯岛的描述。 其中一些甚至包括岛屿部分地图。 但不幸的是，这些地图描述了亚特兰蒂斯的不同区域。 您的朋友 Bill 必须知道地图的总面积。...你自告奋勇写了一个计算这个...
线段树例题之——sort.cpp
03-18
T1 本题极其无聊，3T强行捏成1T，差最大 显然是 前一半后一半，差最小显然是间隔着放，方案数显然是卡特兰数列 ...关于卡特兰数列，直接放公式了h(n)=C(2n,n)/(n+1) (n=0,1,2,...) or h(n)=c(2n,n)-c(2n,n-1)...
线段树例题分析——————
05-31
几个方便理解的线段树例子··················
线段树（模板+例题——郭神）
02-17
线段树（模板+例题——郭神） 私用，随意拿！
线段树的各种题目
A_Thinking_Reed_的博客
03-16 800
目录 类型：单点更新、区间查询 题目：敌兵布阵——https://vjudge.net/contest/285952#problem/A 题目：I hate it——https://vjudge.net/contest/285952#problem/B 题目：Balanced Lineup——https://vjudge.net/contest/285952#problem/E 类型...
线段树练习题一
这是一个很懒（handsome）的人，所以什么也没有留下
12-07 330
线段树练习题一 Time Limit:10000MS  Memory Limit:65536K Total Submit:119 Accepted:44 Case Time Limit:1000MS Description 桌子上零散地放着若干个盒子，桌子的后方是一堵墙。如右图所示。现在从桌子的前方射来一束平行光， 把盒子的影子投射到了墙上。问影子的总宽度是多少？  Input   O...
【例题】【线段树】
ANG
07-08 1079
NKOJ 1321 数列操作问题 时间限制 : 10000 MS 空间限制 : 165536 KB 问题描述 假设有一列数{Ai}(1≤i≤n)，支持如下两种操作： 将Ak的值加D。（k, D是输入的数） 输出As+As+1+…+At。（s, t都是输入的数，S≤T）输入格式 第一行一个整数n， 第二行为n个整数，表示{Ai}的初始值≤10000。 第三行为一个整数m
线段树及经典习题
weixin_42034081的博客
04-04 1141
线段树（Segment Tree） 首先我们知道二叉树，balanced 二叉树可以保证查找的复杂度是logn的复杂度。理解起来十分直观：大概这样子： 如你所见，底层的就是单个的元素，每往上走一层，就会根据底层的元素做一个范围查询（rangeQuery）操作，这个操作可以是求和，求最小，求最大，同时上一层就会cover all the union of the children's range there are four operations in total: build(start,e
洛谷上除了可持久化线段树的模板题，还有哪些经典的可持久化线段树例题？
最新发布
08-22
洛谷网站上除了持久化线段树的经典模板题之外，还有一些其他常见的经典题目涉及到这种数据结构的应用，包括但不限于： 1. **区间更新并查询**：如维护区间内的最大值、最小值、求和等问题，可以利用持久化线段树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值