zoukankan      html  css  js  c++  java
  • [hdu5316]线段树

    题意:给一个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<intint> 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 ", st.query(a, b));
            }
        }
        return 0;                                                                       //
    }                                                                                   //
                                                                                        //
                                                                                        //
                                                                                        //
    /* ******************************************************************************** */
  • 相关阅读:
    Lodop实现web套打
    oracle监听文件 内容
    【数据存储】【Redis】第四章:高并发下实现分布式锁
    Demo:第二章:Java实现随机图像生成(人像,汽车,房屋等等)
    【数据存储】【Redis】第五章:Redis缓存String类型的使用场景
    【数据存储】【Redis】第三章: Redis五大数据类型实现原理
    【Java面试】:第三章:P6级面试
    【数据存储】【Redis】第二章:底层数据结构
    实战:第二十二章:i18n国际化(已实现中文,英文,波兰文)
    Demo:第三章:权限框架spring security oauth2
  • 原文地址:https://www.cnblogs.com/jklongint/p/4684138.html
Copyright © 2011-2022 走看看