c++ - 惰性传播

标签 c++ algorithm segment-tree lazy-propagation

<分区>

我正在解决 GSS3 in spoj在线段树中使用惰性传播。我引用了这个博客: Lazy Propagation

我应该如何使用惰性传播来解决这个问题,我不明白这个博客中是如何使用惰性数组的?

#include<iostream>
#include<iomanip>
#include<stdio.h>
#include<algorithm>
#include<math.h>
#include<vector>
using namespace std;
int tree[(2*MAX)+1],arr[MAX],lazy[(2*MAX)+1];

void build_tree(int node ,int a,int b)
{
    if(a > b) return;
    if(a==b)
    {
        tree[node] = arr[a];
        return;
    }

    build_tree(node*2,a,(a+b)/2);
    build_tree(node*2+1,((a+b)/2)+1,b);
    tree[node] = max(tree[node*2],tree[node*2+1]);

}
void update_tree(int node,int a,int b,int i,int j,int value)
{
    if(lazy[node]!=0)
    {
        tree[node]+=lazy[node];
        if(a!=b)
        {
            lazy[node*2]+= lazy[node];
            lazy[node*2+1]+= lazy[node];
        }
        lazy[node] = 0;
    }
    if(a > b || a > j || b < i)
         return;
    if(a>=i && b<=j)
    {
        tree[node]+=value;
        if(a!=b)
        {
            lazy[node*2]+= value;
            lazy[node*2+1]+= value;
        }
        return;
    }
    update_tree(node*2,a,((a+b)/2),i,j,value);
    update_tree(node*2+1,((a+b)/2)+1,b,i,j,value);
    tree[node] +=(tree[node*2]+tree[node*2+1]);
}
int query_tree(int node,int a,int b,int i,int j)
{
    if(a > b || a > j || b < i) return -inf;
    if(lazy[node]!=0)
    {
        tree[node]+=lazy[node];
        if(a!=b)
        {
            lazy[node*2]+= lazy[node];
            lazy[node*2+1]+= lazy[node];
        }
        lazy[node] = 0;
    }
    if(a>=i && b<=j) return tree[node];
    int q1 = query_tree(node*2,a,((a+b)/2),i,j);
    int q2 = query_tree(node*2+1,((a+b)/2)+1,b,i,j);
    int res = max(q1,q2);
    return res;

}
int main()
{
   int n,m;
   scanf("%d",&n);
   memset(lazy, 0, sizeof lazy);
   for(int i=0;i<n;i++)
      scanf("%d",&arr[i]);
   build_tree(1, 0, n-1);
   scanf("%d",&m);
   for(int i=0;i<m;i++)
   {
       int q;
       scanf("%d",&q);
       if(q==0)
       {
           int x,y;
           scanf("%d",&x);
           scanf("%d",&y);
           update_tree(1,0,n-1,x,y);
        // What Should i do here ?

       }
       if(q==1)
       {
           int x,y;
           scanf("%d",&x);
           scanf("%d",&y);
           query_tree(1,0,n-1,x-1,y-1,);

       }
   }

    return 0;

}

最佳答案

lazy 数组用于指示节点有待处理的更新,并且必须尽可能处理它。

什么时候设置lazy

当更新递归到达一个完全代表范围的节点时,它不会继续更新子节点,它只是在惰性数组中设置它们的期望值,表明在未来的某个时间它的子节点也必须更新。然后它从递归中返回,避开其子树的其余部分。

什么时候使用lazy

每当在更新或查询期间访问节点时,递归首先检查是否有待处理的惰性更新并首先应用它(将惰性值传播到节点的子节点)。

关于c++ - 惰性传播,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/27964687/

相关文章:

C++:将 double 转换为字符串的最佳方法是什么?

algorithm - top-k选择/合并

java - 为数组实现撤销和重做

algorithm - 是否可以查询 O(lg N) 范围内不同整数的数量?

java - GSS1 -SPOJ - 线段树 TLE

algorithm - SPOJ "Card Trick": unable to understand how to apply binary index tree

c++ - CUDA 模板内核包装器

c++ - 仅当给出超过 n 个参数时,如何启用可变参数模板构造函数?

python - 如何通过 list = None 验证迭代?

c++ - 为什么 token 连接在 C++ 中不起作用?