|
/* ******************************************************************************** */
#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; //
} //
//
//
//
/* ******************************************************************************** */
|
