线段树

于 2018-03-28 11:33:56 发布
阅读量167 收藏
点赞数
分类专栏： TOJ 文章标签： 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013662407/article/details/79725169
版权

HDU - 1166 敌兵布阵

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1166

点更新，区间查询

区间和，直接代模板

代码如下：
#include <stdio.h>
#include <math.h>

#define MAXN 50005

int a[MAXN];
int segment_tree[MAXN * 4];

void build_tree(int x, int l, int r) {
    if (l == r) {
        segment_tree[x] = a[l];
        return;
    }
    int mid = (l + r) >> 1;
    build_tree(x * 2, l, mid);
    build_tree(x * 2 + 1, mid + 1, r);
    segment_tree[x] = segment_tree[x * 2] + segment_tree[x * 2 + 1];
}

void update_tree(int x, int l, int r, int t, int val) {
    segment_tree[x] += val;
    if (segment_tree[x] < 0)
        segment_tree[x] = 0;
    if (l == t && r == t)
        return;
    int mid = (l + r) >> 1;
    if (mid >= t)
        update_tree(x * 2, l, mid, t, val);
    else
        update_tree(x * 2 + 1, mid + 1, r, t, val);
}

int query_tree(int x, int l, int r, int start, int end) {
    if (l == start && r == end)
        return segment_tree[x];
    int mid = (l + r) >> 1;
    if (end <= mid)
        return query_tree(x * 2, l, mid, start, end);
    else if (start > mid)
        return query_tree(x * 2 + 1, mid + 1, r, start, end);
    else
        return query_tree(x * 2, l, mid, start, mid) + query_tree(x * 2 + 1, mid + 1, r, mid + 1, end);
}

int main() {
    int cas, n, val1, val2;
    char command[10];
    scanf("%d", &cas);
    for (int t = 1; t <= cas; t++) {
        scanf("%d", &n);
        for (int i = 1; i <= n; i++)
            scanf("%d", a + i);
        build_tree(1, 1, n);
        printf("Case %d:\n", t);
        while (scanf("%s", command) && command[0] != 'E') {
            scanf("%d%d", &val1, &val2);
            if (command[0] == 'A')
                update_tree(1, 1, n, val1, val2);
            else if (command[0] == 'S')
                update_tree(1, 1, n, val1, -val2);
            else
                printf("%d\n", query_tree(1, 1, n, val1, val2));
        }
    }
}

HDU - 1754 I Hate It

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1754

点更新，区间查询

区间最大，直接代模板

代码如下：
#include <stdio.h>
#include <math.h>

#define MAXN 200005

int a[MAXN];
int segment_tree[MAXN * 4];

int max_val(int x, int y) {
    if (x < y) return y;
    else return x;
}

void build_tree(int x, int l, int r) {
    if (l == r) {
        segment_tree[x] = a[l];
        return;
    }
    int mid = (l + r) >> 1;
    build_tree(x * 2, l, mid);
    build_tree(x * 2 + 1, mid + 1, r);
    segment_tree[x] = max_val(segment_tree[x * 2], segment_tree[x * 2 + 1]);
}

void update_tree(int x, int l, int r, int t, int val) {
    if (segment_tree[x] < val)
        segment_tree[x] = val;
    if (l == t && r == t) {
        segment_tree[x] = val;
        return;
    }
    int mid = (l + r) >> 1;
    if (mid >= t)
        update_tree(x * 2, l, mid, t, val);
    else
        update_tree(x * 2 + 1, mid + 1, r, t, val);
}

int query_tree(int x, int l, int r, int start, int end) {
    if (l == start && r == end)
        return segment_tree[x];
    int mid = (l + r) >> 1;
    if (mid >= end)
        return query_tree(x * 2, l, mid, start, end);
    else if (mid < start)
        return query_tree(x * 2 + 1, mid + 1, r, start, end);
    else
        return max_val(query_tree(x * 2, l, mid, start, mid), 
                        query_tree(x * 2 + 1, mid + 1, r, mid + 1, end));
}

int main() {
    int n, m, val1, val2;
    char command;
    while (scanf("%d%d", &n, &m) != EOF) {
        for (int i = 1; i <= n; i++)
            scanf("%d", a + i);
        build_tree(1, 1, n);
        while (m--) {
            scanf(" %c%d%d", &command, &val1, &val2);
            if (command == 'U')
                update_tree(1, 1, n, val1, val2);
            else
                printf("%d\n", query_tree(1, 1, n, val1, val2));
        }
    }
}

POJ - 3468 A Simple Problem With Intergers

题目链接：http://poj.org/problem?id=3468

区间更新，区间查询

添加标记数组，每次访问子区间时，重新计算标记数组
记得以前训练时，每次碰到区间更新的线段树就跪，现在哪怕许久没碰这些东西，随便就写出来了，时间是捧猪饲料
设置四倍空间会RE，有点看不懂，懒了懒了

代码如下：
#include <stdio.h>
#include <math.h>

#define MAXN 100005
#define int_64 long long

int_64 a[MAXN];
int_64 segment_tree[MAXN * 6];
int_64 segment_lazy[MAXN * 6];

void build_tree(int x, int l, int r) {
    if (l == r) {
        segment_tree[x] = a[l];
        segment_lazy[x] = 0;
        return;
    }
    int mid = (l + r) >> 1;
    build_tree(x * 2, l, mid);
    build_tree(x * 2 + 1, mid + 1, r);
    segment_tree[x] = segment_tree[x * 2] + segment_tree[x * 2 + 1];
}

void update_tree(int x, int l, int r, int start, int end, int_64 val) {
    int mid = (l + r) >> 1;
    if (segment_lazy[x]) {
        segment_tree[x * 2] += segment_lazy[x] * (mid - l + 1);
        segment_tree[x * 2 + 1] += segment_lazy[x] * (r - mid);
        segment_lazy[x * 2] += segment_lazy[x];
        segment_lazy[x * 2 + 1] += segment_lazy[x];
        segment_lazy[x] = 0;
    }

    if (l == start && r == end) {
        segment_lazy[x] = val;
        segment_tree[x] += val * (end - start + 1);
        return;
    }

    if (mid >= end) {
        update_tree(x * 2, l, mid, start, end, val);
    }
    else if (mid < start) {
        update_tree(x * 2 + 1, mid + 1, r, start, end, val);
    }
    else {
        update_tree(x * 2, l, mid, start, mid, val);
        update_tree(x * 2 + 1, mid + 1, r, mid + 1, end, val);
    }
    segment_tree[x] = segment_tree[x * 2] + segment_tree[x * 2 + 1];
}

int_64 query_tree(int x, int l, int r, int start, int end) {
    int mid = (l + r) >> 1;
    if (segment_lazy[x]) {
        segment_tree[x * 2] += segment_lazy[x] * (mid - l + 1);
        segment_tree[x * 2 + 1] += segment_lazy[x] * (r - mid);
        segment_lazy[x * 2] += segment_lazy[x];
        segment_lazy[x * 2 + 1] += segment_lazy[x];
        segment_lazy[x] = 0;
    }
    if (l == start && r == end)
        return segment_tree[x];

    if (mid >= end)
        return query_tree(x * 2, l, mid, start, end);
    else if (mid < start)
        return query_tree(x * 2 + 1, mid + 1, r, start, end);
    else
        return query_tree(x * 2, l, mid, start, mid) + 
                        query_tree(x * 2 + 1, mid + 1, r, mid + 1, end);
}

int main() {
    int n, m, val1, val2;
    int_64 val3;
    char command;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
        scanf("%lld", a + i);
    build_tree(1, 1, n);
    while (m--) {
        scanf(" %c%d%d", &command, &val1, &val2);
        if (command == 'Q') {
            printf("%lld\n", query_tree(1, 1, n, val1, val2));
        }
        else {
            scanf("%lld", &val3);
            update_tree(1, 1, n, val1, val2, val3);
        }
    }
}

POJ - 2528 Mayor’s Posters

题目链接：http://poj.org/problem?id=2528

离散化，区间更新

区间范围较大，而端点相对稀疏，因此可以重新定义区间
好久不用STL，排序写到一半才想起来

代码如下：
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <algorithm>

#define MAXN 20005
#define MAXT 10000005
int segment_tree[MAXN * 6];
int initial_data[MAXN];
int initial_sort[MAXN];
int hash_table[MAXT];
bool visible[MAXN / 2];


void build_tree() {
    memset(visible, false, sizeof(visible));
    memset(segment_tree, 0, sizeof(segment_tree));
}

void update_tree(int x, int l, int r, int start, int end, int val) {
    if (segment_tree[x]) {
        segment_tree[x * 2] = segment_tree[x * 2 + 1] = segment_tree[x];
        segment_tree[x] = 0;
    }

    if (l == start && r == end) {
        segment_tree[x] = val;
        return;
    }
    int mid = (l + r) >> 1;
    if (mid >= end) {
        update_tree(x * 2, l, mid, start, end, val);
    }
    else if (mid < start) {
        update_tree(x * 2 + 1, mid + 1, r, start, end, val);
    }
    else {
        update_tree(x * 2, l, mid, start, mid, val);
        update_tree(x * 2 + 1, mid + 1, r, mid + 1, end, val);
    }
    if (segment_tree[x * 2] && segment_tree[x * 2] == segment_tree[x * 2 + 1])
        segment_tree[x] = segment_tree[x * 2];
}

int total_num = 0;
void query_tree(int x, int l, int r) {
    if (segment_tree[x] || l == r) {
        if (!visible[segment_tree[x]]) {
            visible[segment_tree[x]] = true;
            total_num++;
        }
        return;
    }
    int mid = (l + r) >> 1;
    query_tree(x * 2, l, mid);
    query_tree(x * 2 + 1, mid + 1, r);
}
int n;
int main() {
    int cas, n, cur_interval;
    scanf("%d", &cas);
    while (cas--) {
        build_tree();
        scanf("%d", &n);
        for (int i = 0; i < n; i++) {
            scanf("%d%d", initial_data + 2 * i, initial_data + 2 * i + 1);
            initial_sort[2 * i] = initial_data[2 * i];
            initial_sort[2 * i + 1] = initial_data[2 * i + 1];
        }
        std::sort(initial_sort, initial_sort + 2 * n);
        cur_interval = std::unique(initial_sort, initial_sort + 2 * n) - initial_sort;
        for (int i = 0; i < cur_interval; i++)
            hash_table[initial_sort[i]] = i + 1;
        for (int i = 0; i < n; i++)
            update_tree(1, 1, cur_interval, hash_table[initial_data[2 * i]], hash_table[initial_data[2 * i + 1]], i + 1);
        total_num = 0;
        visible[0] = true;
        query_tree(1, 1, cur_interval);
        printf("%d\n", total_num);
    }
}

HDU - 1698 Just A Hook

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1698

区间更新，查询

没什么新意，模板

代码如下：
#include <stdio.h>
#include <math.h>

#define MAXN 100005

int segment_tree[MAXN * 6];
int segment_lazy[MAXN * 6];

void build_tree(int x, int l, int r) {
    segment_lazy[x] = 0;
    if (l == r) {
        segment_tree[x] = 1;
        return;
    }
    int mid = (l + r) >> 1;
    build_tree(x * 2, l, mid);
    build_tree(x * 2 + 1, mid + 1, r);
    segment_tree[x] = segment_tree[x * 2] + segment_tree[x * 2 + 1];
}

void update_tree(int x, int l, int r, int start, int end, int val) {

    if (l == start && r == end) {
        segment_lazy[x] = val;
        segment_tree[x] = (r - l + 1) * val;
        return;
    }
    int mid = (l + r) >> 1;
    if (segment_lazy[x]) {
        segment_tree[x * 2] = (mid - l + 1) * segment_lazy[x];
        segment_tree[x * 2 + 1] = (r - mid) * segment_lazy[x];
        segment_lazy[x * 2] = segment_lazy[x * 2 + 1] = segment_lazy[x];
        segment_lazy[x] = 0;
    }
    if (mid >= end) {
        update_tree(x * 2, l, mid, start, end, val);
    }
    else if (mid < start) {
        update_tree(x * 2 + 1, mid + 1, r, start, end, val);
    }
    else {
        update_tree(x * 2, l, mid, start, mid, val);
        update_tree(x * 2 + 1, mid + 1, r, mid + 1, end, val);
    }
    segment_tree[x] = segment_tree[x * 2] + segment_tree[x * 2 + 1];
}

void query_tree(int x, int l, int r) {
    if (segment_lazy[x]) {
        segment_tree[x] = (r - l + 1) * segment_lazy[x];
        segment_lazy[x] = 0;
        return;
    }
    if (l == r) {
        return;
    }
    int mid = (l + r) >> 1;
    query_tree(x * 2, l, mid);
    query_tree(x * 2 + 1, mid + 1, r);
    segment_tree[x] = segment_tree[x * 2] + segment_tree[x * 2 + 1];
}
int main() {
    int cas, n, m;
    scanf("%d", &cas);
    int start, end, val;
    for (int t = 1; t <= cas; t++) {
        scanf("%d%d", &n, &m);
        build_tree(1, 1, n);
        while (m--) {
            scanf("%d%d%d", &start, &end, &val);
            update_tree(1, 1, n, start, end, val);
        }
        query_tree(1, 1, n);
        printf("Case %d: The total value of the hook is %d.\n", t, segment_tree[1]);
    }
}
凉粥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树详解
orz
05-20 9969
1. 什么是线段树 顾名思义 ， 线段树是一棵二叉树 ， 但不同的是这棵树的结点储存的值是一个数列中 [l,r][l,r][l,r] 的某个需要的值 （例如，求和，求最大值，求最小值） 这是一棵典型的线段树 ，其性质是 ： 若其中一子节点编号为 aaa ， 则该节点左儿子编号为 2a2a2a ， 其右儿子编号为 2a+12a+12a+1 2. 线段树的用处 线段树的用处就是，对编号连续的一些点进行修改或者统计操作，修改和统计的复杂度都是 O(log2n)O(log_2 n)O(log2​n). 3.
线段树 从入门到进阶（超清晰，简单易懂）
热门推荐
繁凡さん的博客
02-12 8万+
目录第一部 概念引入第二部 简单（无pushdown）的线段树1、单点修改，区间查询2、区间修改，单点查询第三部 进阶线段树第四部 乘法（根号）线段树1、乘法线段树2、根号线段树模板题与代码：单点修改，区间查询：洛谷树状数组模板1区间修改，单点查询：洛谷树状数组模板2区间加法，洛谷线段树模板1区间乘法：洛谷线段树模板2区间根号，bzoj3211 线段树是什么？？线段树怎么写？？ 如果你在考提高组前...
线段树建树
12-14
线段树是一种二叉树，也就是说，每个线段都可以用一二叉树表示 比如一个长度为4的线段可以如此表示： ——————————————-4 1————-2————-3————4 1 2 3 4 如果你要表示线段上的和，最上面的根...
线段树模板
02-03
手打了一份线段树代码，用于c++编程， 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的...
线段树解题报告
01-03
H Moving Points 题目链接：...思路：树状数组维护，类似于树状数组求逆序对+思维（思维量很小） #include using namespace std; const int N = 2e5+9; typedef long long ll; struct node{ ...ll c1[N
C语言线段树讲解
最新发布
06-15
线段树是一种数据结构，主要用于高效地处理一系列区间或线段上的操作，如查询、更新等。在C语言中，线段树同样可以被用来实现这些功能。下面将详细解释线段树的基本概念、结构以及常见操作。 1. **线段树的定义**：...
TOJ：3225. Clock
世界在身后，观我背影辽阔
03-15 948
通过公式会发现，时针与分针的角度分数时分母只有2. #include #include #include #include #include using namespace std; char s[10]; int main() { int cas, hour, minute, tt; cin >> cas; while (cas--) { scanf( "%d:%d"
TOJ：2407. 4 Values whose Sum is 0
世界在身后，观我背影辽阔
03-15 740
http://acm.tju.edu.cn/toj/showp2407.html 二分，先将前面两个数组的和求出排序，然后是后面两个求和逆序； #include #include using namespace std; typedef long long ll; int n, arr[4010][4]; int b[4010 * 4010], c[4010 * 4010]; in
TOJ：1746. How many sums
世界在身后，观我背影辽阔
03-16 665
http://acm.tju.edu.cn/toj/showp1746.html 开始的时候没有想到会是大数，用了unsigned long long 然后就发现，数据范围不够，输出有负值 #include #include #include #define Base 1e8 #define MAXN 601 using namespace std; int dp[MAX
TOJ：3210. Moon Mooing
世界在身后，观我背影辽阔
03-14 593
总是“死不悔改”，经常因为type的缘故，WA，一开始是用int，转的long long，果断错 #include #include #include #include #include #include #define MAXN 4000010 #define eps 1e-7 using namespace std; typedef long long ll; ll c, N,
TOJ-3499. Network
世界在身后，观我背影辽阔
02-14 576
//基础太差，做题就像脑筋急转弯一样，想到了才能AC #include #include #define M 10005 using namespace std; int map[M], num[M]; int main() { int n, m, k, t1, t2, cnt; while (scanf("%d%d%d", &n, &m, &k) != EOF) { cnt =
TOJ：2870. The K-th City
世界在身后，观我背影辽阔
03-15 536
#include #include #include #include #define MAXN 205 #define MAX 500000 using namespace std; int map[MAXN][MAXN]; int N, M, K, a, b, dis; struct Road { int city; int len; } road[MAXN]; bool c
TOJ：Prairie dogs
世界在身后，观我背影辽阔
03-15 533
2192.   Prairie dogs I #include #include #include #define MAXN 10 using namespace std; char s[MAXN][MAXN]; bool v[MAXN][MAXN]; int m, n, room, cirs, area; void search(int x, int y) { if (x >= 0
TOJ-1409 - Equations
世界在身后，观我背影辽阔
02-14 454
//感觉做这种题，错了便只能无限WA，不知道错在哪里 #include #include #include #include #include #include #include #include using namespace std; char s1[800], s2[800]; int num[2][5]; int gcd(int a, int b) { if (a
TOJ-3135- Giant Screen
世界在身后，观我背影辽阔
02-14 435
#include #include #include using namespace std; int rh0, rv0, sh0, sv0; int main() { int rh, rv, sh, sv, n, price, ans, tmp, l, m; scanf("%d%d%d%d", &rh0, &rv0, &sh0, &sv0); scanf("%d", &n);
线段树详解与应用
"线段树基础" 线段树是一种数据结构，主要用于处理区间或段上的数据查询和更新操作，常用于解决动态区间统计问题。它是由二叉树结构实现的，每个节点代表一个特定的区间，而这个区间在树的不同层级被不断细分。线段...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值