GSS3 - Can you answer these queries III

GSS3 - Can you answer these queries III

no tags 

You are given a sequence A of N (N <= 50000) integers between -10000 and 10000. On this sequence you have to apply M (M <= 50000) operations: 
modify the i-th element in the sequence or for given x y print max{Ai + Ai+1 + .. + Aj | x<=i<=j<=y }.

Input

The first line of input contains an integer N. The following line contains N integers, representing the sequence A1..AN. 
The third line contains an integer M. The next M lines contain the operations in following form:
0 x y: modify Ax into y (|y|<=10000).
1 x y: print max{Ai + Ai+1 + .. + Aj | x<=i<=j<=y }.

Output

For each query, print an integer as the problem required.

Example

Input:
4
1 2 3 4
4
1 1 3
0 3 -3
1 2 4
1 3 3

Output:
6
4
-3

########################################CODE###################################################

#include<iostream>
using namespace std;
typedef long long int lli;
lli  qs,qe;
lli arr[5000100];
lli pos,val;
#include<bits/stdc++.h>
long long int read_int(){
 char r;
 bool start=false,neg=false;
 long long int ret=0;
 while(true){
  r=getchar();
  if((r-'0'<0 || r-'0'>9) && r!='-' && !start){
   continue;
  }
  if((r-'0'<0 || r-'0'>9) && r!='-' && start){
   break;
  }
  if(start)ret*=10;
  start=true;
  if(r=='-')neg=true;
  else ret+=r-'0';
 }
 if(!neg)
  return ret;
 else
  return -ret;
}
struct node 
 {
  lli pf,sf,max_sum,tot_sum;
  
 } seg[1000100];
 
 void build(int index ,int start,int end)
  {
   if(start==end)
    {
     seg[index].pf=arr[start];
     seg[index].sf=arr[start];
     seg[index].max_sum=arr[start];
     seg[index].tot_sum=arr[start];
    }
    else if(start>end) return ;
    else
    {
     build(2*index,start,(start+end)/2);
     build(2*index+1,(start+end)/2+1,end);
     seg[index].pf=max(seg[2*index].pf,seg[2*index].tot_sum+seg[2*index+1].pf);
     seg[index].sf=max(seg[2*index+1].sf,seg[2*index+1].tot_sum+seg[2*index].sf);
     seg[index].tot_sum=seg[2*index].tot_sum+seg[2*index+1].tot_sum;
     seg[index].max_sum=max(seg[2*index].max_sum,max(seg[2*index+1].max_sum,seg[2*index].sf+seg[2*index+1].pf));
    }
  }
   node  query(int index ,int start,int end)
   {
    
      if(start>end || start>qe || end<qs)
   {
     node inf;
 inf.pf=-999999999;
 inf.sf=-999999999;
 inf.max_sum=-999999999;
 inf.tot_sum=-999999999;
    return inf;
   } 
      else if(qs<=start && qe>=end) 
       {
        
  return seg[index];    
       }
       
        
         node node1= query(2*index,start,(start+end)/2);
         node node2= query(2*index+1,(start+end)/2+1,end);
         node rnode;
        
     rnode.pf=max(node1.pf,node1.tot_sum+node2.pf);
     rnode.sf=max(node2.sf,node2.tot_sum+node1.sf);
     rnode.tot_sum=node1.tot_sum+node2.tot_sum;
     rnode.max_sum=max(node1.max_sum,max(node2.max_sum,node1.sf+node2.pf));
     return rnode;
        
   }
   
   
    void update(int index,int start,int  end )
    {
    //  cout<<start<<" "<<end<<endl;
     if(pos<start ||  pos>end) return;
     if(start==end && start==pos)
      {
        //cout<<start<<endl;
         seg[index].pf=val;
         seg[index].sf=val;
         seg[index].tot_sum=val;
         seg[index].max_sum=val;
         return;
   }
   
   update(2*index,start,(start+end)/2);
     update(2*index+1,(start+end)/2+1,end);
     seg[index].pf=max(seg[2*index].pf,seg[2*index].tot_sum+seg[2*index+1].pf);
     seg[index].sf=max(seg[2*index+1].sf,seg[2*index+1].tot_sum+seg[2*index].sf);
     seg[index].tot_sum=seg[2*index].tot_sum+seg[2*index+1].tot_sum;
     seg[index].max_sum=max(seg[2*index].max_sum,max(seg[2*index+1].max_sum,seg[2*index].sf+seg[2*index+1].pf));
    }
      
    
int main()
 {
   int n;
    cin>>n;
     for(int i=0;i<n;i++)
      arr[i]=read_int();
      build(1,0,n-1);
 /*     for(int i=1;i<2*n+10;i++)
       cout<<i<<" "<<seg[i].tot_sum<<" "<<seg[i].pf<<" "<<seg[i].sf<<" "<<seg[i].max_sum<<endl;*/
       lli q;
      //   cin>>q;
      q=read_int();
         while(q--)
          {
           //cin>>qs>>qe;
           int op;
            cin>>op;
            if(op==1)
            {
              qs=read_int();
           qe=read_int();
           qs-=1;
           qe-=1;
            node ans=query(1,0,n-1);
            //cout<<ans.max_sum<<endl;
            printf("%lld\n",ans.max_sum);
            }
            else
             {
               
               
      //           cin>>pos>>val;
               pos=read_int();
               val=read_int();
               pos-=1;
                 update(1,0,n-1);
             }
          
          }
      return 0;
      
 }