NO1——线段树

 /*    数组存储    */
 /*    预处理        */
 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <climits>
 using namespace std;
 const int maxn = 2e5+;
 int arr[maxn];                    //存储数据的原始数组
 struct segTreeNode{                //节点的结构体
     int val;                    //线段树节点对应的值
     int addMark;                //标记域，只在区间更新起作用
 };
 segTreeNode segTree[*maxn];    //线段树节点的空间应该为原始数据空间的4倍 

 /*    线段树的建立    */
 //    此处以求区间最大值为例
 //    root：当前线段树根节点下标
 //    [L,R]：当前数组的区间
 void build(int root, int L, int R)
 {
     segTree[root].addMark = ;         //设置标记域的值
     if(L == R){                        //叶结点
         segTree[root].val = arr[L];    //叶结点存储原始数据
         return ;                    //结束此次调用
     }
     else{
         int mid = (L+R)/;
         build(*root,L,mid);        //递归构造左子树
         build(*root+,mid+,R);    //递归构造右子树
         //根据左右子树根节点的值，更新当前根节点的值
         segTree[root].val = max(segTree[*root].val, segTree[*root+].val);
     }
 }

 /*    当前节点的标记域向孩子节点传递    */
 void pushDown(int root)
 {
     if(segTree[root].addMark != ){
         segTree[*root].addMark += segTree[root].addMark;    //可能多次延迟标记没有向下传递，使用“+=”
         segTree[*root+].addMark += segTree[root].addMark;
         segTree[*root].val += segTree[root].addMark;
         segTree[*root+].val += segTree[root].addMark;
         segTree[root].addMark = ;            //传递后，当前节点标记域清空
     }
 } 

 /*    区间查询函数    */
 //    此处以求区间最大值为例
 //    [L,R]：当前数组的区间
 //    [l,r]：查询区间
 int query_max(int root, int L, int R, int l, int r)
 {
     if(l>R || r<L){                    //无交集，返回一个对结果无影响的值
         return INT_MIN;                //需包含头文件<climits>
     }
     if(l<=L && r>=R){                //当前区间被包含进查询区间
         return segTree[root].val;
     }
     pushDown(root);                //标记域向下传递
     int mid = (L+R)/;
     //分别从左右子树中查询，返回两者查询结果的较大值
     return max( query_max(*root, L, mid, l, r), query_max(*root+, mid+, R, l, r) );
 } 

 /*    区间查询函数    */
 //    此处以求区间和为例
 //    [L,R]：当前数组的区间
 //    [l,r]：查询区间
 int query_sum(int root, int L, int R, int l, int r)
 {
     if(l>R || r<L){                    //无交集，返回一个对结果无影响的值
         return ;                    //0对结果无影响
     }
     if(l<=L && r>=R){                //当前区间被包含进查询区间
         return segTree[root].val;
     }
     pushDown(root);                //标记域向下传递
     int mid = (L+R)/;
     //分别从左右子树中查询，将和加起来
     int ret = ;
     if(l<=mid){
         ret += query_sum(*root, L, mid, l, r);
     }
     if(r>mid){
         ret += query_sum(*root+, mid+, R, l, r);
     }
     return ret;
 }

 /*    单节点的更新    */
 //    此处以改变节点值为例
 //    index：要更改数据在数组中的下标
 //    value：变化后的值
 void updateNode(int root, int L, int R, int index, int value)
 {
     if(L == R){                            //找到相应的节点
         segTree[root].val = value;
         return ;
     }
     int mid = (L+R)/;
     if(index <= mid){                    //在左子树中更新
         updateNode(*root, L, mid, index, value);
     }
     else{                                //在右子树中更新
         updateNode(*root+, mid+, R, index, value);
     }
     segTree[root].val = max(segTree[*root].val, segTree[*root+].val);    //回溯更新当前节点的值
 }

 /*    区间更新    */
 //    此处以增加某个值为例
 //    此处以求区间最大值为例
 //    addVal：增加的值的大小
 void update(int root, int L, int R, int l, int r,int addVal)
 {
     if(l>R || r<L){                //两区间无交集
         return ;
     }
     if(l<=L && r>=R){            //查询区间包含当前区间
         segTree[root].addMark += addVal;    //标记域赋值，此后此节点的孩子都将要赋值，只不过延迟了
         segTree[root].val += addVal;
         return ;
     }
     pushDown(root);                //向孩子节点传递标记值
     int mid = (L+R)/;
     update(*root, L, mid, l, r, addVal);        //继续更新左子树
     update(*root+, mid+, R, l, r, addVal);    //继续更新右子树
     segTree[root].val = max(segTree[*root].val, segTree[*root+].val);    //由左子树和右子树的新值回溯改变它们根节点的值
 } 

 /*    主函数调用    */
 int main()
 {
     int N;
     cin>>N;
     for(int i=; i<=N; i++){
         scanf("%d",&arr[i]);
     }
     build(, , N);        //根节点为1，当前区间为[1，N]
     return ;
 }