D. Progressions Covering

已于 2022-04-16 11:57:21 修改
阅读量379 收藏 1
点赞数 1
文章标签： 线段树 等差数列 逆元 数学
于 2022-04-16 11:55:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ATXTKS/article/details/124211098
版权

链接：

D. Progressions Covering

题意：

给定数组b，数组a一开始全部都是0，对数组a可以每次选定一个长为k的区间，区间加上一个公差为1，首项为1的等差数列。问最少操作几次，可以使数组a[i]>=b[i]。

做法：

线段树维护区间加等差数列。两个懒标记，一个首项，一个公差。
从数组a最后一个<b的数开始，以他为右端点开始区间加，这样一定最优。
只一个懒标记的是线段树维护差分数组，区间加等差数列，变成差分数组L加首项，L+1~R区间加公差，R+1-=刚刚加的值。
这里放上一道板子题的代码，区间加等差数列。
链接：洛谷-P1438

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e6 + 5, mod = 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23;
int a[N], b[N];
int inv = mod / 2 + 1;
struct node
{
    int l, r;
    int val;
    int a1, d;
#define l(x) tree[x].l
#define r(x) tree[x].r
} tree[N * 4];
void build(int p, int l, int r)
{
    tree[p].l = l, tree[p].r = r;
    if (l >= r)
    {
        tree[p].val = a[l];
        return;
    }
    int mid = (l + r) >> 1;
    int chl = p * 2, chr = p * 2 + 1;
    build(chl, l, mid);
    build(chr, mid + 1, r);
    tree[p].val = (tree[chl].val + tree[chr].val);
}
int calc(int a1, int d, int l, int r)
{
    int fir = a1, en = a1 + (r - l) * d;
    return (fir + en) * (r - l + 1) / 2;
}
void pushdown(int p)
{
    if (tree[p].a1 || tree[p].d)
    {
        int chl = p * 2, chr = p * 2 + 1;

        tree[chl].val = (tree[chl].val + calc(tree[p].a1, tree[p].d, l(chl), r(chl)));
        tree[chl].a1 = (tree[chl].a1 + tree[p].a1);
        tree[chl].d = (tree[chl].d + tree[p].d);

        int k = (tree[p].a1 + (l(chr) - l(chl)) * tree[p].d);
        tree[chr].val = (tree[chr].val + calc(k, tree[p].d, l(chr), r(chr)));
        tree[chr].a1 = (tree[chr].a1 + k);
        tree[chr].d = (tree[chr].d + tree[p].d);

        // sum[ls]=(1ll*sum[ls]+cal(l,mid,lx[cur],ld[cur]) )%mod;
        // lx[ls]=(1ll*lx[ls]+lx[cur])%mod;
        // ld[ls]=(1ll*ld[ls]+ld[cur])%mod;

        // lx[cur]=( 1ll*lx[cur]+1ll*(mid+1-l)*ld[cur]%mod )%mod;

        // sum[rs]=(1ll*sum[rs]+cal(mid+1,r,lx[cur],ld[cur]) )%mod;
        // lx[rs]=(1ll*lx[rs]+lx[cur])%mod;
        // ld[rs]=(1ll*ld[rs]+ld[cur])%mod;

        // lx[cur]=ld[cur]=0;
        tree[p].a1 = tree[p].d = 0;
    }
}
void up(int p, int l, int r, int a1, int d)
{
    if (l <= l(p) && r >= r(p))
    {
        int fir = (a1 + (l(p) - l) * d);
        int en = (a1 + (r(p) - l) * d);
        tree[p].val = (tree[p].val + (fir + en) * (r(p) - l(p) + 1) / 2);
        // tree[p].val %= mod;
        tree[p].a1 = (tree[p].a1 + fir);
        tree[p].d = (tree[p].d + d);
        return;
    }
    pushdown(p);
    int mid = (l(p) + r(p)) >> 1;
    int chl = p * 2, chr = p * 2 + 1;
    if (l <= mid)
        up(chl, l, r, a1, d);
    if (mid < r)
        up(chr, l, r, a1, d);
    tree[p].val = (tree[chl].val + tree[chr].val);
}
int que(int p, int l, int r)
{
    if (l <= l(p) && r >= r(p))
    {
        return tree[p].val;
    }
    pushdown(p);
    int mid = (l(p) + r(p)) >> 1;
    int chl = p * 2, chr = p * 2 + 1;
    int ret = 0;
    if (l <= mid)
        ret = (ret + que(chl, l, r));
    if (mid < r)
        ret = (ret + que(chr, l, r));
    return ret;
}
void solve()
{
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        scanf("%lld", &a[i]);
    }
    build(1, 1, n);
    while(m--)
    {
        int op;
        cin >> op;
        if (op == 2) {
            int x;
            cin >> x;
            printf("%lld\n", que(1, x, x));
        }
        else 
        {
            int l, r, a1, d;
            scanf("%lld%lld%lld%lld", &l, &r, &a1, &d);
            up(1, l, r, a1, d);
        }
    }
}
signed main()
{
    // freopen("data.in","r",stdin);
	// freopen("data.out","w",stdout);
    int tt = 1;
    // cin >> tt;
    while (tt--)
        solve();
    return 0;
}

牛牛的等差数列

牛客还有一题类似的，稍微不同的是输出，区间和要输出对3~25中的某个质数取模结果。
直接定义模数为3 * 5 * 7 * 11 * 13 * 17 * 19 * 23;还要用到2的逆元，因为这个模数并不是质数，所以费马小定理不适用，inv = mod / 2 + 1;这才是2的逆元。
因为n % num % d == n % d，当d是num的因子时。这样这题也就好做了。

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e6 + 5, mod = 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23;
int a[N], b[N];
int inv = mod / 2 + 1;
struct node
{
    int l, r;
    int val;
    int a1, d;
    #define l(x) tree[x].l
    #define r(x) tree[x].r
} tree[N * 4];
void build(int p, int l, int r)
{
    tree[p].l = l, tree[p].r = r;
    if (l >= r) {
        tree[p].val = a[l]%mod;
        return;
    }
    int mid = (l + r) >> 1;
    int chl = p * 2, chr = p * 2 + 1;
    build(chl, l, mid);
    build(chr, mid + 1, r);
    tree[p].val = (tree[chl].val + tree[chr].val) % mod;
}
int calc(int a1, int d, int l, int r)
{
    int fir = a1, en = a1 + (r - l) * d;
    en %= mod;
    return (fir + en) * (r - l + 1) % mod * inv % mod;
}
void pushdown(int p)
{
    if (tree[p].a1 || tree[p].d) {
        int chl = p * 2, chr = p * 2 + 1;

        tree[chl].val = (tree[chl].val + calc(tree[p].a1, tree[p].d, l(chl), r(chl) ) ) % mod;
        tree[chl].a1 = (tree[chl].a1 + tree[p].a1) % mod;
        tree[chl].d = (tree[chl].d + tree[p].d) % mod;

        int k = (tree[p].a1 + (l(chr) - l(chl)) * tree[p].d % mod) % mod;
        tree[chr].val = (tree[chr].val + calc(k, tree[p].d, l(chr), r(chr) ) ) % mod;
        tree[chr].a1 = (tree[chr].a1 + k) % mod;
        tree[chr].d = (tree[chr].d + tree[p].d) % mod;
    
    
        // sum[ls]=(1ll*sum[ls]+cal(l,mid,lx[cur],ld[cur]) )%mod;
        // lx[ls]=(1ll*lx[ls]+lx[cur])%mod;
        // ld[ls]=(1ll*ld[ls]+ld[cur])%mod;

        // lx[cur]=( 1ll*lx[cur]+1ll*(mid+1-l)*ld[cur]%mod )%mod;

        // sum[rs]=(1ll*sum[rs]+cal(mid+1,r,lx[cur],ld[cur]) )%mod;
        // lx[rs]=(1ll*lx[rs]+lx[cur])%mod;
        // ld[rs]=(1ll*ld[rs]+ld[cur])%mod;

        // lx[cur]=ld[cur]=0;
        tree[p].a1 = tree[p].d = 0;
    }
}
void up(int p, int l, int r, int a1, int d)
{   
    if (l <= l(p) && r >= r(p)) {
        int fir = (a1 + (l(p) - l) * d % mod)%mod;
        int en = (a1 + (r(p) - l) * d % mod)%mod;
        tree[p].val = (tree[p].val+(fir + en) * (r(p) - l(p) + 1)%mod*inv%mod)%mod;
        // tree[p].val %= mod;
        tree[p].a1 = (tree[p].a1 + fir) % mod;
        tree[p].d = (tree[p].d + d) % mod;
        return;
    }
    pushdown(p);
    int mid = (l(p) + r(p)) >> 1;
    int chl = p * 2, chr = p * 2 + 1;
    if (l <= mid) up(chl, l, r, a1, d);
    if (mid < r) up(chr, l, r, a1, d);
    tree[p].val = (tree[chl].val + tree[chr].val)%mod;
}
int que(int p, int l, int r)
{
    if (l <= l(p) && r >= r(p)) {
        return tree[p].val;
    }
    pushdown(p);
    int mid = (l(p) + r(p)) >> 1;
    int chl = p * 2, chr = p * 2 + 1;
    int ret = 0;
    if (l <= mid) ret =( ret + que(chl, l, r))%mod;
    if (mid < r) ret = (ret+que(chr, l, r))%mod;
    return ret;
}
int qpow (int x, int n)
{
    int ret = 1;
    while (n) {
        if (n & 1) ret = ret * x % mod;
        x = x* x % mod;
        n >>= 1;
    }
    return ret;
}
void solve()
{
    // inv = qpow(2, mod - 2);
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        scanf("%lld", &a[i]);
    }
    build(1, 1, n);
    int m;
    cin >> m;
    while(m--)
    {
        int op;
        cin >> op;
        if (op == 2) {
            int l, r, mod;
            scanf("%lld%lld%lld", &l, &r, &mod);
            printf("%lld\n", que(1, l, r) % mod);
        }
        else 
        {
            int l, r, a1, d;
            scanf("%lld%lld%lld%lld", &l, &r, &a1, &d);
            up(1, l, r, a1 % mod, d % mod);
        }
    }
}
signed main()
{
    int tt = 1;
    // cin >> tt;
    while (tt--) solve();
    return 0;
}
朴小明
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Arithmetic Progressions.cpp
01-05
西工大noj
D. Progressions Covering（思维 + 贪心 + 线段树 + 差分）
qq_53398102的博客
08-01 127
具体的次数就是cnt=(b[i]-a[i])/k+((b[i]-a[i])%k?然后可以发现当i-k+1b[i]的数中，所需要加的最大次数，算一下就行。从后往前遍历，如果a[i]=b[i]；等差数列的范围[i-k+1,i]，首项为1，公差为1；范围[i-k+1,i]，首项为cnt，公差为cnt；...
CodeForces 1661D Progressions Covering（思维，线段树）
羊驼的博客
04-10 575
题目链接：点击这里 题目大意： 给定一个长度为 nnn 的序列 aia_iai​ ，你可以执行一个操作： 选定一个区间 [l,r]（长度小于等于k）[l,r]（长度小于等于 k）[l,r]（长度小于等于k） ，然后让 a[l]−=1,a[l+1]−=2,...,a[r]−=(r−l+1)a[l]-=1,a[l+1]-=2,...,a[r]-=(r-l+1)a[l]−=1,a[l+1]−=2,...,a[r]−=(r−l+1) ，即区间减去一个首项为 111 公差为 111 的等差数列 求最小操作次数使得所有
Progressions Covering 题解
UnderTheTimeの博客
02-27 849
此时发现我们只需要修改两处二次差分后的增加量数组，就可以实现区间加公差为一的等差序列。我们选择一个前面所说的最优区间进行操作，直到该元素满足条件。注意到我们是从后往前进行操作，所以我们可以动态的计算当前元素增加的量。的操作区间尽量末尾处。这样操作可以使操作区间产生的影响最大化，且。不会对当前和还未被扫描的元素产生影响，所以我们不用太在意这个。，即没有满足条件，则最优的操作方案显然为将。维护区间加的过程考虑差分。个元素，且该元素没有满足条件，的区间，区间左端点大于。因为我们是从后往前做的，
CF 1661D Progressions Covering(差分+线段树)
weixin_43823753的博客
04-12 465
题目链接:点击跳转 题意: 有两个长度相等的序列a,b，a序列开始全为0，b序列有题目给出，每次可以选择a中一段长度为k的序列，将该范围的数依次加上1，2，3…k，问最少多少次操作，能使对于任意i，使得ai >= bi。 思路: 最后一位只能够使用k来消除，而用k消除也恰好是最快的，那么可以从后往前开始处理，但是要怎么更新序列呢，可以使用差分来给修改的每位都加上i(操作次数)，用线段树来维护差分序列，求出的前缀和就是该点的值，从后往前处理一遍即可。 代码如下: #include<bits/std
POJ3006-Dirichlet's Theorem on Arithmetic Progressions
07-29
北大POJ3006-Dirichlet's Theorem on Arithmetic Progressions 解题报告+AC代码
Musical-chord-progressions, hooktheory的数据库分析，表示为 sankey plot.zip
09-18
Musical-chord-progressions, hooktheory的数据库分析，表示为 sankey plot Musical-chord-progressionshooktheory的数据库分析，表示为 sankey plot这表示了 hooktheory数据库中所有规范化和弦级数的可视化。...
数学手册--积分--序列.pdf
06-13
0.11 Progressions .................................... 1 0.12 Sums of powers of natural numbers ........................ 1 0.13 Sums of reciprocals of natural numbers ..................
西工大noj答案完整版.doc
07-12
6.Arithmetic Progressions 7.Bee 8.Checksum algorithm 9.Coin Test 10.Dexter need help 11.Double 12.Easy problem 13.Favorite number 14.Graveyard 15.Hailstone 16.Hanoi Ⅱ 17.Houseboat 18.Music Composer ...
node-v4.2.2-headers.tar.xz
05-21
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
独栋别墅图纸D020-两层-10.00&11.00米- 施工图.dwg
05-21
独栋别墅图纸D020-两层-10.00&11.00米- 施工图.dwg
ndnav主题1.1-haiyong.zip
05-21
内容概要： "ndnav主题1.1-haiyong.zip"是一个针对特定导航需求设计的主题包，提供了一套优化的界面元素和布局，旨在增强用户体验和导航效率。这个主题可能包含了图标、色彩方案、字体样式等视觉元素的自定义，以及可能的操作流程优化，确保用户能够快速找到所需信息。 适用人群： 此主题适合需要高效导航解决方案的用户群体，比如专业领域的工作者、研究人员或是对特定领域有深入了解并追求高效率的信息检索者。它也可能适合那些喜欢定制化界面并希望根据个人喜好或工作需求调整导航工具外观和功能的用户。 使用场景及目标： 该主题可用于多种场合，如图书馆、研究机构、学术会议、企业内部信息系统等，任何需要快速而准确导航大量信息资源的环境都会受益。其目标是减少用户在查找和访问信息时的认知负担，通过直观的设计和布局简化用户路径，从而提高工作效率和满意度。 其他说明： 由于没有具体的文件内容，无法提供更详细的功能描述。不过，一般来说，此类主题包的安装和使用可能需要一定的技术知识，用户在安装前应确保理解如何应用主题，并遵循相关的安装指南。同时，用户也应该注意检查主题包的兼容性，确保它能够与现有的导航系统无缝协作。
grpcio-1.12.0-cp35-cp35m-manylinux1_i686.whl
最新发布
05-21
Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
xmlpull-1.1.3.1.jar
05-21
javaee/javaweb常用jar包，亲测可用，导入到java工程中即可使用
nutz-1.b.52.jar
05-21
javaee/javaweb常用jar包，亲测可用，导入到java工程中即可使用
xmlbeans-2.3.0.jar
05-21
javaee/javaweb常用jar包，亲测可用，导入到java工程中即可使用
f103系列启动文件 各种都有
05-21
startup_stm32f10系列的startup_stm32f10x_cl.s startup_stm32f10x_hd.s startup_stm32f10x_hd_vl.s startup_stm32f10x_ld.s startup_stm32f10x_ld_vl.s startup_stm32f10x_md.s startup_stm32f10x_md_vl.s startup_stm32f10x_xl.s
Coppersmith-Winograd算法的相关资料
07-11
Matrix multiplication via arithmetic progressions. Journal of Symbolic Computation, 9(3), 251-280. 2. Coppersmith, D., & Winograd, S. (1987). Matrix multiplication via arithmetic progressions. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值