P3372 【模板】线段树 1

题

#include<cstdio>
#include<iostream>

using namespace std;


typedef long long LL;

LL n, m, ans, x, y, op, val;//因为下面有的函数需要用到x，y，val值，懒得传参，故直接写为全局变量 

const int N = 100000; 

struct Node{
    LL l, r, sum, lazy;//左孩子，右孩子，求和，懒惰标记 
}tree[N<<2];//一般会开为给定最大数组的4倍 

//构建树 
void Build(int k, int l, int r)
{
    //（l, r）为一个区间 类似于（1， 10）--》（1， 5）（6， 10）--》..... 
    tree[k].l = l;//l为该子树的最小值 
    tree[k].r = r;//r为该子树的最大值 
    
    if(tree[k].l==tree[k].r)
    {
        scanf("%lld",&tree[k].sum);
        return ;
    }
    
    LL mid=(tree[k].l+tree[k].r)>>1;
    
    Build(k<<1, l, mid);//构建左子树 即（2*k） 
    Build(k<<1|1, mid+1, r);//构建右子树 即(2*k+1)
    
    //因为是递归构造树，所以求该K节点的sum即可用以下式子直接求出（相当于递归到叶子结点，然后从叶子结点往上更新父节点的值） 
    tree[k].sum = tree[k<<1].sum+tree[k<<1|1].sum;
}


//向下传递懒惰标记，传递完后该节点的懒惰标记归0 
void PushDown(LL k)
{
    tree[k<<1].lazy += tree[k].lazy;
    tree[k<<1|1].lazy += tree[k].lazy;
    
    tree[k<<1].sum += (tree[k<<1].r-tree[k<<1].l+1)*tree[k].lazy;
    tree[k<<1|1].sum += (tree[k<<1|1].r-tree[k<<1|1].l+1)*tree[k].lazy;
    
    tree[k].lazy=0;
}

void Query(int k)//求某一区间的和 
{
    //（x，y） 完全包含该区间 
    if(x<=tree[k].l && y>=tree[k].r)
    {
        ans += tree[k].sum;
        return ;
    }
    //（x, y）不包含同一区间，则将懒惰标记向下传给左右孩子 
    if(tree[k].lazy)
        PushDown(k);
    
    LL mid = (tree[k].l+tree[k].r)>>1;
    
    if(x <= mid)//有一部分位于左子树 
        Query(k<<1);
    if(y>mid)//有一部分位于右子树 
        Query(k<<1|1);
}

//区间更新 
void UpdateSQ(LL k)
{
    //若(x, y)区间包含该节点的区间，则更新该节点的sum值和懒惰标记 
    if(tree[k].l>=x && tree[k].r<=y)
    {
        tree[k].sum += (tree[k].r-tree[k].l+1)*val;
        tree[k].lazy += val;
        return ;
    }
    
    //因为（x, y）不能完全包含该节点的区间，将懒惰标记传给他的孩子，继续向下更新 
    if(tree[k].lazy)
        PushDown(k);
    
    LL mid=(tree[k].l+tree[k].r)>>1;
    
    if(x <= mid)
        UpdateSQ(k<<1);
    if(y > mid)
        UpdateSQ(k<<1|1);
    
    //更新父节点方法与Build里的一样 
    tree[k].sum=tree[k<<1].sum+tree[k<<1|1].sum;
}

int main()
{
    //scanf("%lld%lld", &n, &m);
    cin >> n >> m;
     
//从上向下构建树    
    Build(1, 1, n);
    
    for(int i=1; i<=m; i++) {
        ans=0;
        
        cin >> op >> x >> y;
        
        if(op == 1) {
            
            cin >> val;
//从上开始查找是否在更新区间内，若能直接更新则更新，否则一直缩小区间 
            UpdateSQ(1);
        }        
        else {
//从上开始查找是否完全在要求区间内，若能直接加和，否则一直缩小区间，符合条件（完全在要求区间内）加和         	
            Query(1);
            
            cout << ans << endl;
        }
    }
    
    return 0;
}