区间问题笔记

成段修改RMQ

成段修改RMQ

注意update里面val和lazy都要加 因为val一定会变 然后我们在这里没有pushdown所以儿子们还没有处理

#include <cstdio>
#include <algorithm>
#include <climits>
using namespace std;
const int N=1e5+20;
inline int lson(int x){return x<<1;}
inline int rson(int x){return lson(x)|1;}
struct node{
    int lazy,val;
}segTree[N<<2];
int a[N];
void build(int t,int l,int r)
{
    segTree[t].lazy=0;
    if(l==r)
    {
        segTree[t].val=a[l];
        return;
    }
    int mid=(l+r)>>1;
    build(lson(t),l,mid);
    build(rson(t),mid+1,r);
    segTree[t].val=max(segTree[lson(t)].val,segTree[rson(t)].val);
}
void pushdown(int t,int l,int r)
{
    segTree[lson(t)].val+=segTree[t].lazy;
    segTree[rson(t)].val+=segTree[t].lazy;
    segTree[lson(t)].lazy+=segTree[t].lazy;
    segTree[rson(t)].lazy+=segTree[t].lazy;
    segTree[t].lazy=0;
}
void update(int t,int l,int r,int s,int e,int c)
{
    if(l>e||r<s)
        return;
    if(l>=s&&r<=e)
    {
        segTree[t].val+=c;
        segTree[t].lazy+=c;
        return;
    }
    pushdown(t,l,r);
    int mid=(l+r)>>1;
    update(lson(t),l,mid,s,e,c);
    update(rson(t),mid+1,r,s,e,c);
    segTree[t].val=max(segTree[lson(t)].val,segTree[rson(t)].val);
}
int query(int t,int l,int r,int s,int e)
{
    if(l>e||r<s)
        return INT_MIN;
    if(l>=s&&r<=e)
    {
        return segTree[t].val;
    }
    pushdown(t,l,r);
    int mid=(l+r)>>1;
    return max(query(lson(t),l,mid,s,e),query(rson(t),mid+1,r,s,e));
}
int main()
{
    int n,m,x,y,c,kase=0;
    char op[3];
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        printf("Case %d:\n",++kase);
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        build(1,1,n);
        while(m--)
        {
            scanf("%s",op);
            if(op[0]=='C')
            {
                scanf("%d%d%d",&x,&y,&c);
                update(1,1,n,x,y,c);
            }
            else
            {
                scanf("%d%d",&x,&y);
                printf("%d\n",query(1,1,n,x,y));
            }
        }
    }
    return 0;
}
成段修改区间和

成段修改区间和

先放一个wa和tle的 wa是因为没有想清楚不打lazy的时候不用pushdown但是其实实际上是需要修改儿子的 tle是因为把每次操作都做到底了 做完了就突然更明白了lazy的意义

#include <cstdio>
#include <algorithm>
#include <climits>
using namespace std;
const int N=1e5+20;
inline int lson(int x){return x<<1;}
inline int rson(int x){return lson(x)|1;}
int segTree[N<<2];
int a[N];
void build(int t,int l,int r)
{
    if(l==r)
    {
        segTree[t]=a[l];
        return;
    }
    int mid=(l+r)>>1;
    build(lson(t),l,mid);
    build(rson(t),mid+1,r);
    segTree[t]=segTree[lson(t)]+segTree[rson(t)];
}
void pushdown(int t,int l,int r,int c)
{
    int mid=(l+r)>>1;
    segTree[lson(t)]+=c*(mid-l+1);
    segTree[rson(t)]+=c*(r-mid);
}
void update(int t,int l,int r,int s,int e,int c)
{
    if(l>e||r<s)
        return;
    if(l>=s&&r<=e&&l==r)
    {
//        segTree[t]+=c*(r-l+1);
        segTree[t]+=c;
        return;
    }
//    pushdown(t,l,r,c);
    int mid=(l+r)>>1;
    update(lson(t),l,mid,s,e,c);
    update(rson(t),mid+1,r,s,e,c);
    segTree[t]=segTree[lson(t)]+segTree[rson(t)];
}
int query(int t,int l,int r,int s,int e)
{
    if(l>e||r<s)
        return 0;
    if(l>=s&&r<=e)
    {
        return segTree[t];
    }
//    pushdown(t,l,r);
    int mid=(l+r)>>1;
    return query(lson(t),l,mid,s,e)+query(rson(t),mid+1,r,s,e);
}
int main()
{
    int n,m,x,y,c,kase=0;
    char op[3];
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        printf("Case %d:\n",++kase);
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        build(1,1,n);
        while(m--)
        {
            scanf("%s",op);
            if(op[0]=='C')
            {
                scanf("%d%d%d",&x,&y,&c);
                update(1,1,n,x,y,c);
            }
            else
            {
                scanf("%d%d",&x,&y);
                printf("%d\n",query(1,1,n,x,y));
            }
        }
    }
    return 0;
}

ac的如下

中间又得到了一些经验

1.不要全换long long 所有运算的速度都会慢 所以又会tle

2.%d%lld 输入两个int 第二个输入会是0

(学好csapp的必要性。。。)

#include <cstdio>
#include <algorithm>
#include <climits>
#define ll long long
using namespace std;
const int N=1e5+20;
inline int lson(int x){return x<<1;}
inline int rson(int x){return lson(x)|1;}
struct node{
    ll lazy,val;
}segTree[N<<2];
ll a[N];
void build(int t,int l,int r)
{
    segTree[t].lazy=0;
    if(l==r)
    {
        segTree[t].val=a[l];
        return;
    }
    int mid=(l+r)>>1;
    build(lson(t),l,mid);
    build(rson(t),mid+1,r);
    segTree[t].val=segTree[lson(t)].val+segTree[rson(t)].val;
}
void pushdown(int t,int l,int r)
{
    int mid=(l+r)>>1;
    segTree[lson(t)].val+=segTree[t].lazy*(mid-l+1);
    segTree[rson(t)].val+=segTree[t].lazy*(r-mid);
    segTree[lson(t)].lazy+=segTree[t].lazy;
    segTree[rson(t)].lazy+=segTree[t].lazy;
    segTree[t].lazy=0;
}
void update(int t,int l,int r,int s,int e,ll c)
{
    if(l>e||r<s)
        return;
    if(l>=s&&r<=e)
    {
        segTree[t].val+=c*(r-l+1);
        segTree[t].lazy+=c;
        return;
    }
    pushdown(t,l,r);
    int mid=(l+r)>>1;
    update(lson(t),l,mid,s,e,c);
    update(rson(t),mid+1,r,s,e,c);
    segTree[t].val=segTree[lson(t)].val+segTree[rson(t)].val;
}
ll query(int t,int l,int r,int s,int e)
{
    if(l>e||r<s)
        return 0;
    if(l>=s&&r<=e)
    {
        return segTree[t].val;
    }
    pushdown(t,l,r);
    int mid=(l+r)>>1;
    return query(lson(t),l,mid,s,e)+query(rson(t),mid+1,r,s,e);
}
int main()
{
    ll c;
    int n,m,x,y,kase=0;
    char op[3];
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        printf("Case %d:\n",++kase);
        for(int i=1;i<=n;i++)
            scanf("%I64d",&a[i]);
        build(1,1,n);
        while(m--)
        {
            scanf("%s",op);
            if(op[0]=='C')
            {
                scanf("%d%d%I64d",&x,&y,&c);
                update(1,1,n,x,y,c);
            }
            else
            {
                scanf("%d%d",&x,&y);
                printf("%I64d\n",query(1,1,n,x,y));
            }
        }
    }
    return 0;
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,以下是一篇关于区间DP的学习笔记,希望对你有所帮助。 ### 什么是区间DP 区间 DP 是一种动态规划算法,用于解决一些区间上的问题。具体来说,区间 DP 通常用于解决如下问题: - 最长公共子序列(LCS) - 最长递增子序列(LIS) - 最大子段和 - 区间选数问题 区间 DP 通常采用分治或递推的方式进行求解,具体方法取决于问题的性质。 ### 区间 DP 的递推方法 区间 DP 的递推方法通常有两种,一种是自底向上的递推方法,一种是自顶向下的记忆化搜索方法。 自底向上的递推方法通常采用二维数组或三维数组来记录状态转移方程,具体的递推方式如下: ```cpp for (int len = 2; len <= n; len++) { for (int i = 1; i <= n - len + 1; i++) { int j = i + len - 1; for (int k = i; k < j; k++) { // 状态转移方程 } } } ``` 其中,len 表示区间长度,i 和 j 分别表示区间的左右端点,k 表示区间的划分点。 自顶向下的记忆化搜索方法通常采用记忆化数组来记录状态转移方程,具体的递推方式如下: ```cpp int dp(int i, int j) { if (i == j) return 0; if (memo[i][j] != -1) return memo[i][j]; memo[i][j] = INF; for (int k = i; k < j; k++) { memo[i][j] = min(memo[i][j], dp(i, k) + dp(k + 1, j) + ...); } return memo[i][j]; } ``` 其中,i 和 j 分别表示区间的左右端点,k 表示区间的划分点,memo 数组用于记忆化状态转移方程。 ### 区间 DP 的优化 对于一些区间 DP 问题,我们可以通过一些技巧和优化来减少时间和空间的消耗。 一种常见的优化方式是状态压缩,将二维或三维数组压缩成一维数组,从而减少空间的消耗。 另一种常见的优化方式是使用滚动数组,将数组的维度从二维或三维减少到一维,从而减少时间和空间的消耗。 此外,对于一些具有特殊性质的区间 DP 问题,我们还可以使用单调队列或单调栈等数据结构来进行优化,从而减少时间和空间的消耗。 ### 总结 区间 DP 是一种常用的动态规划算法,用于解决一些区间上的问题区间 DP 通常采用分治或递推的方式进行求解,具体方法取决于问题的性质。对于一些区间 DP 问题,我们可以通过一些技巧和优化来减少时间和空间的消耗。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值