Master of GCD 1，线段树 2，差分数组

线段树，的 lazy 还是没搞明白，

虽然代码AC了，但是 感觉区间并没有做好，

因为题目是维护最小值，我写的是递归到叶子节点 返回的过程中维护最小值，所以前面的值即使有错也能在这个时候改过来

访问到确定的区间了，就更新自己和lazy ， 如果区间在下面就 先放下 lazy 。。。

跟着大佬好好学啊。励志脱离菜鸡的行列。

https://blog.csdn.net/huangzihaoal/article/details/81813454 

#include<bits/stdc++.h>
using namespace std;
typedef long long ll ;
const int max_num=100001;
pair<int,int> lazy[4*max_num];
pair<int,int> tree[4*max_num];
const ll mod=998244353;

ll qpow(ll a,ll b)
{
    ll ans=1,base=a;

    while(b)
    {
        if(b%2)
            ans=(ans* base)%mod;
        base=(base*base)%mod;
        b>>=1;
    }
    return ans;

}


void putdown(int o)
{
    if(lazy[o].first!=0)
    {
        
        lazy[o*2].first+=lazy[o].first;
        lazy[o*2+1].first+=lazy[o].first;
        lazy[o].first=0;
    }
    if(lazy[o].second!=0)
    {

        lazy[o*2].second+=lazy[o].second;
        lazy[o*2+1].second+=lazy[o].second;
        lazy[o].second=0;
    }
}



void update(int o,int l,int r,int L,int R,int x)
{

    if(L<=l&&r<=R)
    {
        if(l==r)
        {
            if(x==2){tree[o].first+=1;  }
            if(x==3){tree[o].second+=1; }
        }
        else
        {
            if(x==2){lazy[o].first+=1;tree[o].first+=1; }
            if(x==3){lazy[o].second+=1;tree[o].second+=1; }
        }

        return ;
    }
    putdown(o);

    int m=(l+r)/2;
    if(L<=m) update( o*2 , l , m , L , R , x );
    if(m<R)
        update(o*2+1 , m+1 , r , L , R , x);

}


void quiry(int o,int l,int r)
{
        if(l==r)
        {
            tree[o].first+=lazy[o].first;
            tree[o].second+=lazy[o].second;
            return ;
        }

    int m=(l+r)/2;
 putdown(o);
    quiry(o*2,l,m);
    quiry(o*2+1,m+1,r);

    tree[o].first=min(tree[o*2].first,tree[o*2+1].first);
    tree[o].second=min(tree[o*2].second,tree[o*2+1].second);
}

int main()
{
//     freopen("in.txt","r",stdin);

    int t;  cin>>t;

    while(t--)
    {
        int n,d;
        cin>>n>>d;

        for(int i=1;i<=4*n;i++){
            tree[i].first=0;
            tree[i].second=0;
            lazy[i].first=0;
            lazy[i].second=0;
        }


        while(d--)
        {
            int L,R,x;
            cin>>L>>R>>x;
            update(1,1,n,L,R,x);
        }
        quiry(1,1,n);


        ll a=tree[1].first;
  //  cout<<a<<endl;
       ll x = qpow(2,a);
        a=tree[1].second;
  //  cout<<a<<endl;
        ll y = qpow(3,a);

        cout<<(x*y)%mod<<endl;
    }
    return 0;
}

后来，我改了一下，不需要查询函数 了  ， 在每次更新的时候维护一下 最小次数就好，到A区间就先下放A的  lazy ，在进入A的左右子树，等回来的时候  取左右子树的最小值，

他的访问只需要访问到满足条件的区间就行了，，多向下走一层 都不想走，，怪不得叫  lazy

针对A区间 ，他的左子树 加了，右子树没加，那就是 左右取最小值，如果A 区间加了，那就 先下放，在维护，取左右子树的最小值，

 

没想到还能用差分数组，以前只是听说有这么个东西

#include <iostream>
using namespace std;
typedef long long ll;
const ll  mod =  998244353;
const int max_num=100005;
int f_2[max_num];
int f_3[max_num];
int n2[max_num];
int n3[max_num];
ll qpow(ll a,ll b)
{
    ll ans=1,base=a;
    while(b)
    {
        if( b&1)
            ans=(ans*base)%mod;
        base=(base*base)%mod;
        b>>=1;
    }
    return ans;
}

int main(){
    int t;  cin>>t;
    while(t--){
        int n,d;
        cin>>n>>d;

        f_2[1]=0;f_3[1]=0;          //这是两个差分数组，f    原数组是 d （记录乘二 ，3的次数的） 我没写 一开始次数都是0
        for(int i=2;i<=n+1;i++)
            f_2[i]=0,f_3[i]=0;

        while(d--){
            int l,r,x;
            cin>>l>>r>>x;
            if(x==2){
                f_2[l]+=1;
                f_2[r+1]-=1;
            }
            else{
                f_3[l]+=1;
                f_3[r+1]-=1;
            }
        }

         n2[1]=f_2[1],n3[1]=f_3[1];
        int min_2=n2[1];
        int min_3=n3[1];
        for(int i=2;i<=n;i++){
            n2[i]=f_2[i]+n2[i-1]; // n2 n3 是原始数组记录次数的，，f_2是差分数组，f_2[i]=na[i]-na[i-1];要求na 移项就行了
            n3[i]=f_3[i]+n3[i-1];
            min_2=min(min_2,n2[i]);
            min_3=min(min_3,n3[i]);
        }
//        cout<<min_2<<endl;
//        cout<<min_3<<endl;



    ll ans=qpow((ll)2,(ll)min_2)* qpow((ll)3,(ll)min_3)%mod;
        cout<<ans<<endl;


    }

    return 0;
}

 

我觉得帮助很大的话

/*可以用线段树维护的问题必须满足区间加法，否则是不可能将大问题划分成子问题来解决的。

什么是区间加法
一个问题满足区间加法，仅当对于区间[L,R]的问题的答案可以由[L,M]和[M+1,R]的答案合并得到。
经典的区间加法问题有：

区间求和

区间最大值

不满足区间加法的问题有：

区间的众数
区间的最长不下降子序列

通过一系列的玄学操作，我们成功地把修改区间分解成一段一段的。但问题来了：我们怎样修改这些区间呢？
最暴力的做法是每一次都像建树一样，遍历区间内的所有节点，一一修改。但是这样的时间复杂度显然O(n2log2n) O(n^2log_2n)O(n
2
 log
2
​
 n)，比暴力O(n2) O(n^2)O(n
2
 )还多了个log，我要这线段树有何用？
这里就要引入一样新的神奇的东西——懒惰标记！

懒惰标记
标记的含义：本区间已经被更新过了，但是子区间却没有被更新过，被更新的信息是什么（区间求和只用记录有没有被访问过，而区间加减乘除等多种操作的问题则要记录进行的是哪一种操作）
这里再引入两个很重要的东西：相对标记和绝对标记。

相对标记指的是可以共存的标记，且打标记的顺序与答案无关，即标记可以叠加。 比如说给一段区间中的所有数字都+a，我们就可以把标记叠加一下，比如上一次打了一个+1的标记，这一次要给这一段区间+2，那么就把+1的标记变成+3。
绝对标记是指不可以共存的标记，每一次都要先把标记下传，再给当前节点打上新的标记。这些标记不能改变次序，否则会出错。 比如说给一段区间的数字重新赋值，或是给一段区间进行多种操作。

标记的含义：本区间已经被更新过了，但是子区间却没有被更新过，被更新的信息是什么

*/

还是来自这位大佬：
https://blog.csdn.net/huangzihaoal/article/details/81813454