题意：给一个array，有两种操作，(1)修改某一个位置的值，(2)询问区间[L,R]内的最大子段和，其中子段需满足相邻两个数的位置的奇偶性不同

思路：假设对于询问操作没有奇偶性的限制，那么记录区间的最大子段和就可以通过合并区间得到答案了。加上奇偶性的限制后，记录的信息必须更加具体，需要把子段的端点的奇偶性加进去，也就是说一个区间需要记录4个值， 分别是奇奇，奇偶，偶偶，偶奇，然后同样可以通过合并区间来得到答案。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
/* ******************************************************************************** */
#include <iostream>                                                                 //
#include <cstdio>                                                                   //
#include <cmath>                                                                    //
#include <cstdlib>                                                                  //
#include <cstring>                                                                  //
#include <vector>                                                                   //
#include <ctime>                                                                    //
#include <deque>                                                                    //
#include <queue>                                                                    //
#include <algorithm>                                                                //
using namespace std;                                                                //
                                                                                    //
#define pb push_back                                                                //
#define mp make_pair                                                                //
#define X first                                                                     //
#define Y second                                                                    //
#define all(a) (a).begin(), (a).end()                                               //
#define foreach(i, a) for (typeof(a.begin()) it = a.begin(); it != a.end(); it ++)  //
                                                                                    //
void RI(vector<int>&a,int n){a.resize(n);for(int i=0;i<n;i++)scanf("%d",&a[i]);}    //
void RI(){}void RI(int&X){scanf("%d",&X);}template<typename...R>                    //
void RI(int&f,R&...r){RI(f);RI(r...);}void RI(int*p,int*q){int d=p<q?1:-1;          //
while(p!=q){scanf("%d",p);p+=d;}}void print(){cout<<endl;}template<typename T>      //
void print(const T t){cout<<t<<endl;}template<typename F,typename...R>              //
void print(const F f,const R...r){cout<<f<<", ";print(r...);}template<typename T>   //
void print(T*p, T*q){int d=p<q?1:-1;while(p!=q){cout<<*p<<", ";p+=d;}cout<<endl;}   //
                                                                                    //
typedef pair<int, int> pii;                                                         //
typedef long long ll;                                                               //
typedef unsigned long long ull;                                                     //
                                                                                    //
/* -------------------------------------------------------------------------------- */
                                                                                    //
template<typename T>bool umax(T &a, const T &b) {
    return a >= b? false : (a = b, true);
}
 
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
 
const ll inf = (ll)1e18;
const int maxn = 1e5 + 7;
 
struct SegTree {
private:
    struct Node {
        ll a[4];
    };
    Node tree[maxn << 2];
    int n;
    bool chk(int i, int j) {
        return (i & 1) ^ (j >> 1);
    }
    int get(int i, int j) {
        return (i & 2) | (j & 1);
    }
    Node merge(const Node &nl, const Node &nr) {
        Node ans;
        for (int i = 0; i < 4; i ++) {
            ans.a[i] = nl.a[i];
            umax(ans.a[i], nr.a[i]);
        }
        for (int i = 0; i < 4; i ++) {
            for (int j = 0; j < 4; j ++) {
                if (chk(i, j)) {
                    umax(ans.a[get(i, j)], nl.a[i] + nr.a[j]);
                }
            }
        }
        return ans;
    }
    void build(int l, int r, int rt) {
        if (l == r) {
            int x;
            RI(x);
            int buf = (l & 1) << 1 | (l & 1);
            for (int i = 0; i < 4; i ++) tree[rt].a[i] = i == buf? x : -inf;
            return ;
        }
        int m = (l + r) >> 1;
        build(lson);
        build(rson);
        tree[rt] = merge(tree[rt << 1], tree[rt << 1 | 1]);
    }
    void update(int p, int x, int l, int r, int rt) {
        if (l == r) {
            tree[rt].a[(p & 1) << 1 | (p & 1)] = x;
            return ;
        }
        int m = (l + r) >> 1;
        if (p <= m) update(p, x, lson);
        else update(p, x, rson);
        tree[rt] = merge(tree[rt << 1], tree[rt << 1 | 1]);
    }
    Node query(int L, int R, int l, int r, int rt) {
        if (L <= l && r <= R) return tree[rt];
        int m = (l + r) >> 1;
        if (R <= m) return query(L, R, lson);
        if (L > m) return query(L, R, rson);
        return merge(query(L, R, lson), query(L, R, rson));
    }
public:
    void build(int nn) { n = nn; build(1, n, 1); }
    void update(int p, int x) { update(p, x, 1, n, 1); }
    ll query(int l, int r) {
        Node buf = query(l, r, 1, n, 1);
        ll ans = buf.a[0];
        for (int i = 1; i < 4; i ++) umax(ans, buf.a[i]);
        return ans;
    }
};
SegTree st;
int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif // ONLINE_JUDGE
    int T;
    cin >> T;
    while (T --) {
        int n, m;
        RI(n, m);
        st.build(n);
        for (int i = 0; i < m; i ++) {
            int t, a, b;
            RI(t, a, b);
            if (t) st.update(a, b);
            else printf("%I64d\n", st.query(a, b));
        }
    }
    return 0;                                                                       //
}                                                                                   //
                                                                                    //
                                                                                    //
                                                                                    //
/* ******************************************************************************** */

[hdu5316]线段树的更多相关文章

  1. 2015 多校联赛 ——HDU5316（线段树）

    Fantasy magicians usually gain their ability through one of three usual methods: possessing it as an ...

  2. 2018.07.08 hdu5316 Magician（线段树）

    Magician Problem Description Fantasy magicians usually gain their ability through one of three usual ...

  3. bzoj3932--可持久化线段树

    题目大意: 最近实验室正在为其管理的超级计算机编制一套任务管理系统,而你被安排完成其中的查询部分.超级计算机中的 任务用三元组(Si,Ei,Pi)描述,(Si,Ei,Pi)表示任务从第Si秒开始,在第 ...

  4. codevs 1082 线段树练习 3（区间维护）

    codevs 1082 线段树练习 3  时间限制: 3 s  空间限制: 128000 KB  题目等级 : 大师 Master 题目描述 Description 给你N个数,有两种操作: 1:给区 ...

  5. codevs 1576 最长上升子序列的线段树优化

    题目:codevs 1576 最长严格上升子序列 链接:http://codevs.cn/problem/1576/ 优化的地方是 1到i-1 中最大的 f[j]值,并且A[j]<A[i] .根 ...

  6. codevs 1080 线段树点修改

    先来介绍一下线段树. 线段树是一个把线段,或者说一个区间储存在二叉树中.如图所示的就是一棵线段树,它维护一个区间的和. 蓝色数字的是线段树的节点在数组中的位置,它表示的区间已经在图上标出,它的值就是这 ...

  7. codevs 1082 线段树区间求和

    codevs 1082 线段树练习3 链接:http://codevs.cn/problem/1082/ sumv是维护求和的线段树,addv是标记这歌节点所在区间还需要加上的值. 我的线段树写法在运 ...

  8. PYOJ 44. 【HNSDFZ2016 #6】可持久化线段树

    #44. [HNSDFZ2016 #6]可持久化线段树 统计 描述 提交 自定义测试 题目描述 现有一序列 AA.您需要写一棵可持久化线段树,以实现如下操作: A v p x:对于版本v的序列,给 A ...

  9. CF719E（线段树+矩阵快速幂）

    题意:给你一个数列a,a[i]表示斐波那契数列的下标为a[i],求区间对应斐波那契数列数字的和,还要求能够维护对区间内所有下标加d的操作 分析:线段树 线段树的每个节点表示(f[i],f[i-1])这 ...

随机推荐

  1. OkHttp 优雅封装 HttpUtils 之 上传下载解密

    曾经在代码里放荡不羁,如今在博文中日夜兼行,只为今天与你分享成果.如果觉得本文有用,记得关注我,我将带给你更多. 还没看过第一篇文章的欢迎移步:OkHttp 优雅封装 HttpUtils 之气海雪山初 ...

  2. python3+selenium3自动化1——元素定位

    1.selenium的webdriver提供了八种基本的元素定位方法 打开浏览器 driver = webdriver.Chrome() driver.get('https://www.baidu.c ...

  3. [php] 简单的实现一个错误接管类

    自己弄的一个错误接管类: <?php //---------------------------------- // Leephp 错误接管类 // 2017-07-06 // Pengchon ...

  4. HTTP 前世今生

    HTTP 协议在我们身边随处可见,只要上网就离不开它.不论是用浏览器还是 App,不论是看新闻.短视频还是听音乐.玩游戏,后面总会有 HTTP 在默默为你服务. Http 协议是怎么来的?最开始是什么 ...

  5. thinkphp5.1+ 使用 Redis 缓存

    修改 config/cache.php 将其配置成多个缓存类型,示例 <?php // +---------------------------------------------------- ...

  6. wait,waitpid的学习使用

    man wait man waitpid 从中可知 函数原型 pid_t wait(int* status); pid_t waitpid(pid_t pid, int* status, int op ...

  7. QString 转换成 wchar 的一个小陷阱

    QString::toWCharArray(wchar_t * array) 其中 wchar_t * array 除了要分配内存之外,必须用 wmemset 初始化. 环境是 Visual Stud ...

  8. 利用python画出SJF调度图

    最先发布在csdn.本人原创. https://blog.csdn.net/weixin_43906799/article/details/105510046 SJF算法: 最短作业优先(SJF)调度 ...

  9. Scala教程之:Enumeration

    Enumeration应该算是程序语言里面比较通用的一个类型,在scala中也存在这样的类型, 我们看下Enumeration的定义: abstract class Enumeration (init ...

  10. office 365 激活

    将以下代码复制到记事本 @echo off title Activate Microsoft Office ALL versions &echo - Microsoft Office Prof ...