线段树水题几枚

最新推荐文章于 2024-07-28 09:45:27 发布
最新推荐文章于 2024-07-28 09:45:27 发布
阅读量58 收藏
点赞数
文章标签： c/c++ 数据结构与算法

最近接触了一下线段树，按理来说这个半年前就该看了，实际上自己却总想刷水题而躲避难题，不过，该来的还是要来的，既然选择了数据结构，就让各种树来的猛烈些吧。


以下为最初级的线段树，只更新点，没有delay操作


1.HDU 1166 敌兵布阵

这道题用线段树或者树状数组都可以做，HDU上的数据貌似很弱，模拟竟然都能过

首先是线段树版 ，线段树所带信息为当前区间所有点的值的和

/*
ID: sdj22251
PROG: subset
LANG: C++
*/
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#define LOCA
#define MAXN 50005
#define INF 100000000
#define eps 1e-7
#define L(x) x<<1
#define R(x) x<<1|1
using namespace std;
int a[MAXN];
struct node
{
    int left, right, mid;
    int sum;
}tree[4 * MAXN];
int ans;
void up(int C)
{
    tree[C].sum = tree[L(C)].sum + tree[R(C)].sum;
}
void make_tree(int s, int e, int C)
{
    tree[C].left = s;
    tree[C].right = e;
    tree[C].mid = (s + e) / 2;
    tree[C].sum = 0;
    if(s == e)
    {
        tree[C].sum = a[s];
        return;
    }
    make_tree(s, tree[C].mid, L(C));
    make_tree(tree[C].mid + 1, e, R(C));
    up(C);
}
void update(int C, int p, int v)
{
    if(tree[C].left == p && tree[C].right == p)
    {
        tree[C].sum += v;
        return;
    }
    if(p <= tree[C].mid)
    update(L(C), p, v);
    else update(R(C), p, v);
    up(C);
}
void search(int s, int e, int C)
{
    if(s <= tree[C].left && tree[C].right <= e)
    {
        ans += tree[C].sum;
        return;
    }
    if(tree[C].mid >= e) search(s, e, L(C));
    else if(tree[C].mid < s) search(s, e, R(C));
    else
    {
        search(s, tree[C].mid, L(C));
        search(tree[C].mid + 1, e, R(C));
    }
}
int main()
{
#ifdef LOCAL
    freopen("d:/data.in","r",stdin);
    freopen("d:/data.out","w",stdout);
#endif
    char s[20];
    int t, n, i, cas = 0, x, y;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        for(i = 1; i <= n; i++)
        scanf("%d", &a[i]);
        make_tree(1, n, 1);
        printf("Case %d:\n", ++cas);
        while(scanf("%s", s) != EOF)
        {
            if(s[0] == 'E') break;
            else if(s[0] == 'Q')
            {
                ans = 0;
                scanf("%d%d", &x, &y);
                search(x, y, 1);
                printf("%d\n", ans);
            }
            else if(s[0] == 'A')
            {
                scanf("%d%d", &x, &y);
                update(1, x, y);
            }
            else if(s[0] == 'S')
            {
                scanf("%d%d", &x, &y);
                update(1, x, -y);
            }
        }
    }
    return 0;
}



然后是树状数组版


/*
ID: sdj22251
PROG: lamps
LANG: C++
*/
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#define MAX 2000000000
#define LOCA
using namespace std;
int a[50005], n, b[50005];
int lowbit(int x)
{
    return x & -x;
}
void modify(int x)
{
    for(int i = x; i <= n; i += lowbit(i))
    a[i] += b[x];
}
void modify2(int x, int y)
{
    for(int i = x; i <= n; i += lowbit(i))
    a[i] += y;
}
int sum(int x)
{
    int ans = 0;
    for(int i = x; i >= 1; i -= lowbit(i))
    ans += a[i];
    return ans;
}
int main()
{
#ifdef LOCAL
    freopen("lamps.in","r",stdin);
    freopen("lamps.out","w",stdout);
#endif
    int t, cas = 0, i, x, y;
    char s[15];
    scanf("%d", &t);
    while(t--)
    {
        memset(a, 0, sizeof(a));
        memset(b, 0, sizeof(b));
        scanf("%d", &n);
        for(i = 1; i <= n; i++)
        {
            scanf("%d", &b[i]);
            modify(i);
        }
        printf("Case %d:\n", ++cas);
        while(scanf("%s", s) != EOF)
        {
            if(s[0] == 'E')
            break;
            else if(s[0] == 'Q')
            {
                scanf("%d%d", &x, &y);
                printf("%d\n", sum(y) - sum(x - 1));
            }
            else if(s[0] == 'A')
            {
                scanf("%d%d", &x, &y);
                modify2(x, y);
            }
            else if(s[0] == 'S')
            {
                scanf("%d%d", &x, &y);
                modify2(x, -y);
            }
        }
    }
    return 0;
}



2.HDU 1754 I Hate It

同样是点更新，外加up操作即可，线段树所带信息是当前区间的最大值

/*
ID: sdj22251
PROG: subset
LANG: C++
*/
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#define LOCA
#define MAXN 200005
#define INF 100000000
#define eps 1e-7
using namespace std;
struct node
{
    int left, right, mid;
    int l, mx;
} tree[4 * MAXN];
int ans, num[MAXN];
void make_tree(int s, int e, int C)
{
    tree[C].left = s;
    tree[C].right = e;
    tree[C].mid = ((s + e) >> 1);
    tree[C].l = tree[C].right - tree[C].left + 1;
    tree[C].mx = 0;
    if(s == e) {tree[C].mx = num[s]; return;}
    make_tree(s, tree[C].mid, (C << 1));
    make_tree(tree[C].mid + 1, e, (C << 1) | 1);
    tree[C].mx = max(tree[C << 1].mx, tree[(C << 1) + 1].mx);
}
void update(int s, int v, int C)
{
    if(tree[C].left == s && tree[C].right == s)
    {
        tree[C].mx = v;
        return;
    }
    if(s > tree[C].mid)
    {
        update(s, v, (C << 1) | 1);
    }
    else update(s, v, C << 1);
    tree[C].mx = max(tree[C << 1].mx, tree[(C << 1) + 1].mx);
}
void search(int s, int e, int C)
{
    if(tree[C].left >= s && tree[C].right <= e)
    {
        if(tree[C].mx > ans)
        ans = tree[C].mx;
        return;
    }
    if(s > tree[C].mid)
    {
        search(s, e, (C << 1) | 1);
    }
    else if(e <= tree[C].mid)
    {
        search(s, e, C << 1);
    }
    else
    {
        search(s, tree[C].mid, C << 1);
        search(tree[C].mid + 1, e, (C << 1) | 1);
    }
}
int main()
{
#ifdef LOCAL
    freopen("d:/data.in","r",stdin);
    freopen("d:/data.out","w",stdout);
#endif
    int n, m, i, x, y;
    char s[5];
    while(scanf("%d%d", &n, &m) != EOF)
    {
        for(i = 1; i <= n; i++)
        scanf("%d", &num[i]);
        make_tree(1, n, 1);
        while(m--)
        {
            scanf("%s %d %d", s, &x, &y);
            if(s[0] == 'Q')
            {
                ans = 0;
                search(x, y, 1);
                printf("%d\n", ans);
            }
            else
            {
                update(x, y, 1);
            }
        }
    }
    return 0;
}

3.HDU 1394Minimum Inversion Number

题意就是求逆序数，然后每次把当前序列的第一个数放到序列末尾求一次逆序数，总共n次，求其中最小的逆序数

其实求出最初的逆序数就行了，因为随后的逆序数能推导出来，总共n个数，0到n-1都有，比a[i]小的数是a[i] 个，大的数是n-1-a[i]个。

求逆序数时所用的方法是先查询再更新，查询的是已经存在的比自己大的数的个数，而线段树中所带的信息就是这一区间有几个数存在。

/*
ID: sdj22251
PROG: subset
LANG: C++
*/
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#define LOCA
#define MAXN 50005
#define INF 100000000
#define eps 1e-7
#define L(x) x<<1
#define R(x) x<<1|1
using namespace std;
struct node
{
    int left, right, mid;
    int sum;
}tree[4 * MAXN];
int tmp, a[MAXN];
void up(int C)
{
    tree[C].sum = tree[L(C)].sum + tree[R(C)].sum;
}
void make_tree(int s, int e, int C)
{
    tree[C].left = s;
    tree[C].right = e;
    tree[C].mid = (s + e) / 2;
    tree[C].sum = 0;
    if(s == e) return;
    make_tree(s, tree[C].mid, L(C));
    make_tree(tree[C].mid + 1, e, R(C));
}
void search(int s, int e, int C)
{
    if(s <= tree[C].left && e >= tree[C].right)
    {
        tmp += tree[C].sum;
        return;
    }
    if(tree[C].mid >= e) search(s, e, L(C));
    else if(tree[C].mid < s) search(s, e, R(C));
    else
    {
        search(s, tree[C].mid, L(C));
        search(tree[C].mid + 1, e, R(C));
    }
}
void update(int p, int s, int e, int C)
{
    if(s == e && s == p) {tree[C].sum++; return;}
    if(tree[C].mid >= p) update(p, s, tree[C].mid, L(C));
    else update(p, tree[C].mid + 1, e, R(C));
    up(C);
}
int main()
{
#ifdef LOCAL
    freopen("d:/data.in","r",stdin);
    freopen("d:/data.out","w",stdout);
#endif
    int n, i;
    while(scanf("%d", &n) != EOF)
    {
        make_tree(0, n - 1, 1);
        int sum = 0;
        for(i = 0; i < n; i++)
        {
            scanf("%d", &a[i]);
            tmp = 0;
            search(a[i], n - 1, 1);
            sum += tmp;
            update(a[i], 0, n - 1, 1);
        }
        int ret = sum;
        for(i = 0; i < n; i++)
        {
            sum = sum + n - a[i] - a[i] - 1;
            ret = min(ret, sum);
        }
        printf("%d\n", ret);
    }
    return 0;
}


4.HDU 2795 Billboard

题意是给出一个 高为h宽为w的木板，然后往上贴高度为1，宽度wi的纸条，每次帖优先找到最高的帖，高度相同的要尽量往左边贴。

其实把板子横过来的话就好理解了，横坐标是h，然后尽量往左边贴条子

数据范围貌似挺大的，其实也不大，因为n只有20万，也就是说线段树的范围1到20万够用了

然后线段树的附加信息是这个区间内每一段h的剩余空间的最大值，查询的时候最终查到叶子节点，减掉消耗的长度就行了。

/*
ID: sdj22251
PROG: subset
LANG: C++
*/
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cmath>
#include <ctime>
#define LOCA
#define MAXN 200005
#define INF 100000000
#define eps 1e-7
#define L(x) x<<1
#define R(x) x<<1|1
using namespace std;
int h, w, n;
struct node
{
    int left, right, mid;
    int mx;
}tree[4 * MAXN];
void make_tree(int s, int e, int C)
{
    tree[C].left = s;
    tree[C].right = e;
    tree[C].mid = (s + e) / 2;
    tree[C].mx = w;
    if(s == e) return;
    make_tree(s, tree[C].mid, L(C));
    make_tree(tree[C].mid + 1, e, R(C));
}
int insert(int C, int v)
{
    if(tree[C].mx < v) return -1;
    if(tree[C].left == tree[C].right)
    {
        tree[C].mx -= v;
        return tree[C].left;
    }
    int ans = -1;
    if(v <= tree[L(C)].mx)
    ans = insert(L(C), v);
    else if(v <= tree[R(C)].mx)
    ans = insert(R(C), v);
    tree[C].mx = max(tree[L(C)].mx, tree[R(C)].mx);
    return ans;
}
int main()
{
#ifdef LOCAL
    freopen("d:/data.in","r",stdin);
    freopen("d:/data.out","w",stdout);
#endif
    int i, x;
    while(scanf("%d%d%d", &h, &w, &n) != EOF)
    {
        if(h > n) h = n;
        make_tree(1, h, 1);
        for(i = 0; i < n; i++)
        {
            scanf("%d", &x);
            printf("%d\n", insert(1, x));
        }
    }
    return 0;
}


然后做了这几个初级题目后，发现查询的时候，一种是需要自定义查询范围的，还有一种是不需要自定义查询范围， 直接从祖先开始查的，查询函数的参数的个数自然就不同了


iteye_6233
关注
《英雄编程体验课》第 15 课 | C语言中的数学库
英雄哪里出来
07-05 5万+
C语言中的数学库
OI做题总结
dingxingdi的博客
07-16 1079
数学竞赛蓝书上与OI/ICPC有关内容也可阅读OI考前注意事项见川外团队骗分导论见腾讯微云。
线段树水题
weixin_30782331的博客
05-06 112
1.洛谷p1351https://www.luogu.org/problem/show?pid=1531 //单点修改区间询问 #include<iostream> #include<cstdio> #include<cstring> #define maxn 200001 using namespace std; int n,m,...
POJ 2828 线段树 水题
09-05 796
线段树部分很简单 重点是处理的思想 对数据从后往前插入队列 #include "stdio.h" #include "string.h" #include "math.h" #include "stdlib.h" struct comp { int l,r,mid,sum,w; } data[800008]; int first; int a[200001],b[20000
HDU 2795 线段树 水题
09-05 856
水题 从左至右找到位置就插入即可   #include "stdio.h" #include "string.h" #include "math.h" #include "stdlib.h" #include "algorithm" #include "iostream" using namespace std; int w; struct comp {  int l,r
POJ3321 线段树水题
Free Loop~~~跳动的恒星
05-29 1007
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <iostream> #include <algorithm> #include <set> #include <map> #include <stack> #include <queue> #include <vector> using namespace std; #defi
【LeetCode:699. 掉落的方块 + 线段树】
Coder_ljw的博客
07-28 1335
【LeetCode:699. 掉落的方块 + 线段树】在二维平面上的 x 轴上，放置着一些方块。 给你一个二维整数数组 positions ，其中 positions[i] = [lefti, sideLengthi] 表示：第 i 个方块边长为 sideLengthi ，其左侧边与 x 轴上坐标点 lefti 对齐。 每个方块都从一个比目前所有的落地方块更高的高度掉落而下。方块沿 y 轴负方向下落，直到着陆到 另一个正方形的顶边 或者是 x 轴上 。一个方块仅仅是擦过另一个方块的左侧边或右侧边不算着陆
Stars（区间线段树）
Helinshan的博客
05-18 262
题目： Stars vjudge提交链接 题意： ——给出一个n，代表下面有n个星星的坐标，星星按Y坐标的升序排列，Y坐标相等的星星按X坐标的升序排列。现在需要对每一颗星星进行能级判断。一个星星的偏左偏下（算边界，不算自己）有几个星星，该星星的能级就为几。输出n行，能级为0，1，2…的个数。 题解： 给出的数据上y已经是从小到大排序了，所以弃y留x 这一题相当于求每个数(x)的逆序数，但不能用归并排序来写，归并排序只能求整个序列的逆序数之和，不能求单个数的逆序数。 暴力思维：开一个数组把x存起来嘛，然后枚
黑科技知识
Yu Gi Oh!
02-28 1001
前言 这里记录&amp;amp;amp;总结一些平常 OIOIOI 竞赛中并不是很常用的毒瘤玩意。 黑科技 黑科技数据结构 1. 李超线段树 一种线段树维护某一类信息的方法。 支持区间加入一次函数,询问区间的一次函数最值。 修改复杂度为 O(log2n)O(log^2n)O(log2n) , 如果是全局加入就是O(log&amp;amp;nbsp;n)O(log\ n)O(log&amp;amp;nbsp;n) 查询复杂度为 O(log&amp;amp;nbs
POJ 2777 线段树水题
just_water
07-19 1056
题意： 给你一个长度为N的线段数，一开始每个树的颜色都是1，然后有2个操作。 第一个操作，将区间[a , b ]的颜色换成c。 第二个操作，输出区间[a , b ]不同颜色的总数。 直接线段树搞之。不过输入有个坑，a 可能大于b ，所以要判断一下。 #include #include #include #include #include #include #include
线段树水题集锦（持续更新）
air_wanfang的博客
07-08 2587
只是普通线段树，并非什么可持久化，主席树。。。。ORZ最近写了些水题，挑了其中的几道，发一下。感觉对我这样的蒟蒻来说，线段树的某些模型还是需要学习的。。。（XX根本想不到）cogs:182. [USACO Jan07] 均衡队形农夫约翰的 N (1 ≤ N ≤ 50,000) 头奶牛，每天挤奶时总会按同样的顺序站好。一日，农夫约翰决定为奶牛们举行一个“终极飞盘”比赛。为简化问题，他将从奶牛队列中选...
线段树 水题----今天先写点初学者的基础
qq_24664053的博客
03-02 436
hdu 1556 上来就可以直接讲题省略头文件 using namespace std; #define MAXN 100005 struct ST { int l,r,sum; //线段树的节点 l，r就是端点，sum用来记录被上过多少次色 }st[MAXN*3]; int nn; void build(int L,int R,int n) //建树的函数，一看就能明白，递归而
hdu4107 线段树水题
zxf654073270的专栏
10-29 816
线段树
kuangbin带我飞 专题七 线段树专题（一波线段树水题，难题还不会做）
Miracle_ma的专栏
07-09 2221
第一次学习线段树，树状数组RMQ等，努力学习，加油。 HDU 1166 题意：很清楚吧 题解：用树状数组求连续和，非常快。 #include #include #include #include #include #include #include #include #include #include #include #include #include #inc
线段树水题区间最大值，最小值，求和CDOJ1921
路漫漫其修远兮，吾将上下而求索
07-23 325
饺子发现身边危机四伏！有nn个人站在一维平面上，每个人的坐标为Ai，能量值为Bi。饺子有cc种方法可以推测出有多少人想吃饺子，请你求出每种方法可以得出的想吃饺子的人数。 Input 第一行两个值 n（n≤105),c(c≤10)n 接下来n行每行两个值Ai,Bi(1≤Ai≤109,1≤Bi≤104,Ai≤Aj)  if Q__Q题目链接 接下来c行，每行包含三个数K,function 其中  ...
ACM算法列表
11-07 8254
ACM 所有算法 数据结构 栈，队列，链表 哈希表，哈希数组 堆，优先队列 双端队列 可并堆 左偏堆 二叉查找树 Treap 伸展树 并查集 集合计数问题 二分图的识别 平衡二叉树 二叉排序树 线段树 一维线段树 二维线段树 树状数组 一维树状数组 N维树状数组 字典树 后缀数组，后缀树 块状链表 哈夫曼树 桶，跳跃表
HDU-4027-Can you answer these queries?(暴力线段树)
永远鲜红の幼月的博客
02-09 286
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4027 题目大意：n个数，两种操作，0.将[l,r]内的所有数开平方（四舍五入取ll），1.求[l,r]内的sum 思路：线段树板子，首先需要更新到最下面，1开平方还是1，所以一个数最多更新64次，然后记录一下是否需要开平发即可。 ACCode： #include<stdlib.h&gt...
线段树专辑(转)
黄廉政的专栏
08-04 1568
线段树专辑<br />这几天陆陆续续更新了下边几道我所能找到得具有一些代表性的线段树题目<br />从最最简单的区间求和到对区间的各种操作都包涵在这些题目里了<br />相信对一些准备学习线段树的人有一定得帮助<br />突然发现自己对数据结构的题目非常有感觉,所以在刷下边的题的同时也生出灵感出了好几道线段树题目<br />等比赛结束后也会陆续加进里边<br /><br />快半年过去代码风格也有很大的改变，感觉以前写的代码很不规范，用自己在预定义中定义的一些函数，但后来感觉作用不是很大，所以又删去了，所以
【线段树】线段树练习题六
最新发布
02-01
### 关于线段树的第六道练习题 对于线段树的应用，在多个平台和资料中有丰富的练习题供学习者挑战。具体到第六道练习题的选择，这取决于具体的课程设置或在线评测系统的安排[^1]。 通常情况下，线段树相关的练习会逐步增加难度，从基础操作如单点更新、区间查询开始，逐渐过渡到更复杂的懒惰传播（Lazy Propagation）、多维线段树等问题上。考虑到这一点，假设在一个典型的训练序列中，“智乃酱的平方数列”可能作为一道中级偏上的题目出现，该题不仅涉及到了基本的线段树构建与维护，还加入了对等差数列以及多项式的处理[^2]。 为了更好地理解这类问题并找到特定编号的题目，建议访问专门提供此类资源的网站，比如牛客网或其他知名编程竞赛平台。这些平台上往往会有详细的分类标签帮助定位目标题目。例如，在牛客网上可以通过搜索关键词“线段树”，然后按照推荐顺序浏览直到找到所需的第六题[^3]。 另外值得注意的是，不同平台之间的题目编排可能存在差异，因此所谓的“第六题”并不是绝对固定的，而是相对而言的一个位置概念。如果希望获得最准确的结果，可以直接查阅所使用的教材或者在线课程的具体章节来确定哪一题被指定为第六题[^4]。 ```cpp // 下面是一个简单的线段树节点定义示例，用于解决某些类型的区间查询问题 struct Node { int l, r; long long sum; // 区间总和 long long sum2; // 区间每个数字的平方和 long long add; // 加法懒标记 long long mul; // 乘法懒标记 }; ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值