HDU 5316 Magician(线段树区间合并)

Problem Description

Fantasy magicians usually gain their ability through one of three usual methods: possessing it as an innate talent, gaining it through study and practice, or receiving it from another being, often a god, spirit, or demon of some sort. Some wizards are depicted as having a special gift which sets them apart from the vast majority of characters in fantasy worlds who are unable to learn magic.

Magicians, sorcerers, wizards, magi, and practitioners of magic by other titles have appeared in myths, folktales, and literature throughout recorded history, with fantasy works drawing from this background.

In medieval chivalric romance, the wizard often appears as a wise old man and acts as a mentor, with Merlin from the King Arthur stories representing a prime example. Other magicians can appear as villains, hostile to the hero.



Mr. Zstu is a magician, he has many elves like dobby, each of which has a magic power (maybe negative). One day, Mr. Zstu want to test his ability of doing some magic. He made the elves stand in a straight line, from position 1 to position n, and he used two kinds of magic, Change magic and Query Magic, the first is to change an elf’s power, the second is get the maximum sum of beautiful subsequence of a given interval. A beautiful subsequence is a subsequence that all the adjacent pairs of elves in the sequence have a different parity of position. Can you do the same thing as Mr. Zstu ?

 

Input

The first line is an integer T represent the number of test cases.
Each of the test case begins with two integers n, m represent the number of elves and the number of time that Mr. Zstu used his magic.
(n,m <= 100000)
The next line has n integers represent elves’ magic power, magic power is between -1000000000 and 1000000000.
Followed m lines, each line has three integers like 
type a b describe a magic.
If type equals 0, you should output the maximum sum of beautiful subsequence of interval [a,b].(1 <= a <= b <= n)
If type equals 1, you should change the magic power of the elf at position a to b.(1 <= a <= n, 1 <= b <= 1e9)

 

Output

For each 0 type query, output the corresponding answer.

 

Sample Input

  
  

   
   1
1 1
1
0 1 1
  
  

 

Sample Output

  
  

   
   1
  
  

 

Author

ZSTU

 

Source

2015 Multi-University Training Contest 3

 

看一句：A beautiful subsequence is a subsequence that all the adjacent pairs of elves in the sequence have a different parity of position。

意思是说定义美丽子序列是区间里面的一个子序列，这个子序列中任意相邻的两个数在原序列中的具有不同的奇偶性

两种操作，1.把序列x位置的值变成y；2.询问区间[x,y]里面的最大美丽子序列（即序列和最大）

区间合并的时候要满足当左子的美丽子序列如果是以奇位置结尾，那么右子的美丽子序列要以偶开头

若左边以偶结尾，右边则以奇开头

那么只需要保存区间内“偶始偶终”、“偶始奇终”、“奇始偶终”、“奇始奇终”四种美丽子序列，合并的时候奇偶配对着合并

用一个二维数组s[2][2]表示起点和终点的奇偶性，其中0表示偶，1表示奇

还有，其中最大的美丽子序列不可以是空集（意思是说，当最大美丽子序列为负的时候不要取0 。。。。）

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 100000;
const ll inf = 1LL<<30LL;
struct Node
{
    int l,r;
    ll s[2][2];//0偶1奇
}q[4*N];
#define ls i<<1
#define rs i<<1|1
void pushup(int i)
{
    for (int j = 0;j <= 1;++j)
    {
        for (int k = 0;k <= 1;++k)
        {
            q[i].s[j][k] = max(q[ls].s[j][k],q[rs].s[j][k]);
            q[i].s[j][k] = max(max(q[ls].s[j][0]+q[rs].s[1][k],q[ls].s[j][1]+q[rs].s[0][k]),q[i].s[j][k]);
        }
    }
}
void build(int i,int l,int r)
{
    q[i].l = l,q[i].r = r;
    if (l == r)
    {
        ll y;
        scanf("%I64d",&y);
        for (int j = 0;j <= 1;++j)
        {
            for (int k = 0;k <= 1;++k)
            {
                q[i].s[j][k] = -inf;
            }
        }
        if (l&1) //奇数
        {
            q[i].s[1][1] = y;
        }
        else q[i].s[0][0] = y;
        return ;
    }
    int mid = (l+r)>>1;
    build(ls,l,mid);
    build(rs,mid+1,r);
    pushup(i);
}
void update(int i,int x,ll y)
{
    if (x == q[i].l &&x == q[i].r)
    {
        if (x&1) //奇数
        {
            q[i].s[1][1] = y;
        }
        else q[i].s[0][0] = y;
        return;
    }
    if (x <= q[ls].r) update(ls,x,y);
    else update(rs,x,y);
    pushup(i);
}
Node query(int i,int l,int r)
{
    if (l<=q[i].l&&q[i].r<=r) return q[i];
    int mid = (q[i].l+q[i].r)>>1;
    if (r <= mid) return query(ls,l,r);
    else if (l > mid) return query(rs,l,r);
    else
    {
        Node ql = query(ls,l,mid);
        Node qr = query(rs,mid+1,r);
        Node ans;
        for (int j = 0;j <= 1;++j)
        {
            for (int k = 0;k <= 1;++k)
            {
                ans.s[j][k] = max(ql.s[j][k],qr.s[j][k]);
                ans.s[j][k] = max(max(ql.s[j][0]+qr.s[1][k],ql.s[j][1]+qr.s[0][k]),ans.s[j][k]);
            }
        }
        return ans;
    }
}
int main()
{
    int T;scanf("%d",&T);
    while (T--)
    {
        int n,m;scanf("%d %d",&n,&m);
        build(1,1,n);
        int op;ll a,b;
        for (int i = 0;i < m;++i)
        {
            scanf("%d",&op);
            scanf("%I64d %I64d",&a,&b);
            if (op == 0)
            {
                Node ans = query(1,(int)a,(int)b);
                ll mx = - inf;
                for (int j = 0;j <= 1;++j)
                {
                    for (int k = 0;k <= 1;++k)
                    {
                        mx = max(ans.s[j][k],mx);
                    }
                }
                printf("%I64d\n",mx);
            }
            else if (op == 1)
            {
                update(1,(int)a,(ll)b);
            }
        }
    }
    return 0;
}