P1438 无聊的数列/P1253 扶苏的问题

news2025/6/6 2:26:23

因为这两天在写线性代数的作业，没怎么写题……

P1438 无聊的数列

题目背景

无聊的 YYB 总喜欢搞出一些正常人无法搞出的东西。有一天，无聊的 YYB 想出了一道无聊的题：无聊的数列。。。

题目描述

维护一个数列 ai​，支持两种操作：

  • 1 l r K D：给出一个长度等于 r−l+1 的等差数列，首项为 K，公差为 D，并将它对应加到 [l,r] 范围中的每一个数上。即：令 al​=al​+K,al+1​=al+1​+K+D…ar​=ar​+K+(r−l)×D。

  • 2 p：询问序列的第 p 个数的值 ap​。

输入格式

第一行两个整数数 n,m 表示数列长度和操作个数。

第二行 n 个整数，第 i 个数表示 ai​。

接下来的 m 行，每行先输入一个整数 opt。

若 opt=1 则再输入四个整数 l r K D；

若 opt=2 则再输入一个整数 p。

输出格式

对于每个询问，一行一个整数表示答案。

输入输出样例

输入 #1复制

5 2
1 2 3 4 5
1 2 4 1 2
2 3

输出 #1复制

6

说明/提示

数据规模与约定

对于 100% 数据，0≤n,m≤105,−200≤ai​,K,D≤200,1≤l≤r≤n,1≤p≤n。

思路：

最要注意的是他的结果会超过int型，所以要用 long long 来记录结果

  1. 等差数列的分解：

    • 等差数列可以分解为常数项和线性项：

      • 常数项：A = K - l × D

      • 线性项系数：D

    • 位置 i 的增加值：add(i) = (K - l × D) + (i - l) × D = A + D × i

  2. 两个树状数组维护：

    • 树状数组 tr1：维护常数项（A）

      • 在 l 处加 A

      • 在 r+1 处减 A（若 r+1 ≤ n）

    • 树状数组 tr2：维护线性项系数（D）

      • 在 l 处加 D

      • 在 r+1 处减 D（若 r+1 ≤ n）

  3. 查询计算：

    • 位置 p 的值 = 初始值 + tr1 的前缀和(p) + tr2 的前缀和(p) × p

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
struct ss {
    long long k, d;
    int l, r;
}a[400005];
int  b[100005];
void XiaFang(int i) {
    a[i * 2].k += a[i].k;
    a[i * 2].d += a[i].d;
    a[i * 2 + 1].k += a[i].k + (a[i * 2 + 1].l - a[i].l) * a[i].d;
    a[i * 2 + 1].d += a[i].d;
    a[i].k = 0;
    a[i].d = 0;
}
void Chu(int l, int r, int i) {
    a[i].l = l, a[i].r = r, a[i].d = 0;
    if (l == r) {
        a[i].k = b[a[i].l];
        return;
    }
    a[i].k = 0;
    int mid = (l + r) >> 1;
    Chu(l, mid, i * 2);
    Chu(mid + 1, r, i * 2 + 1);
}
void ChaRu(int l, int r, int k, int d,int i) {
    if (a[i].l >= l && a[i].r <= r) {
        a[i].k += k + (a[i].l - l) * d;
        a[i].d += d;
        return;
    }
    int mid = (a[i].l + a[i].r) >> 1;
    if (a[i].d != 0 || a[i].k != 0) {
        XiaFang(i);
    }
    if (l<=mid ) {
        ChaRu(l, r, k, d, i * 2);
    }
    if (mid+1 <= r) {
        ChaRu(l, r, k, d, i * 2 + 1);
    }
}
long long Cha(int p, int i) {
    if (a[i].l == p&&a[i].r==p) {
        return a[i].k;
    }
    int mid = (a[i].l + a[i].r) >> 1;
    if (a[i].d != 0 || a[i].k != 0) {
        XiaFang(i);
    }
    if ( p<=mid ) {
        return Cha(p, i * 2);
    }
    else {
        return Cha(p, i * 2 + 1);
    }
}
int p, l, r, k, d, n, m, q;
int main(){
	ios::sync_with_stdio(false);        // 禁用同步
    cin.tie(nullptr);                   // 解除cin与cout绑定
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> b[i];
    }
    Chu(1,n,1);
    for (int i = 0; i < m; i++) {
        cin >> q;
        if (q == 1) {
            cin >> l >> r >> k >> d;
            ChaRu(l, r, k, d, 1);
        }
        else {
            cin >> p;
            cout << Cha(p, 1) << endl;
        }
    }
    return 0;
}

 P1253 扶苏的问题

题目描述

给定一个长度为 n 的序列 a，要求支持如下三个操作：

  1. 给定区间 [l,r]，将区间内每个数都修改为 x。
  2. 给定区间 [l,r]，将区间内每个数都加上 x。
  3. 给定区间 [l,r]，求区间内的最大值。

输入格式

第一行是两个整数，依次表示序列的长度 n 和操作的个数 q。
第二行有 n 个整数，第 i 个整数表示序列中的第 i 个数 ai​。
接下来 q 行，每行表示一个操作。每行首先有一个整数 op，表示操作的类型。

  • 若 op=1，则接下来有三个整数 l,r,x，表示将区间 [l,r] 内的每个数都修改为 x。
  • 若 op=2，则接下来有三个整数 l,r,x，表示将区间 [l,r] 内的每个数都加上 x。
  • 若 op=3，则接下来有两个整数 l,r，表示查询区间 [l,r] 内的最大值。

输出格式

对于每个 op=3 的操作，输出一行一个整数表示答案。

输入输出样例

输入 #1复制

6 6
1 1 4 5 1 4
1 1 2 6
2 3 4 2
3 1 4
3 2 3
1 1 6 -1
3 1 6

输出 #1复制

7
6
-1

输入 #2复制

4 4
10 4 -3 -7
1 1 3 0
2 3 4 -4
1 2 4 -9
3 1 4

输出 #2复制

0

说明/提示

数据规模与约定

  • 对于 10% 的数据，n=q=1。
  • 对于 40% 的数据，n,q≤103。
  • 对于 50% 的数据，0≤ai​,x≤104。
  • 对于 60% 的数据，op=1。
  • 对于 90% 的数据，n,q≤105。
  • 对于 100% 的数据，1≤n,q≤106，1≤l,r≤n，op∈{1,2,3}，∣ai​∣,∣x∣≤109。

提示

请注意大量数据读入对程序效率造成的影响。

思路：

  1. 线段树节点设计：

    • 每个节点包含三个字段：setv（区间赋值标记）、addv（区间加法标记）和 maxv（区间最大值）。

    • setv 为 LLONG_MIN 时表示该节点没有赋值标记。

    • addv 为 0 时表示没有加法标记。

  2. 标记下传）：

    • 如果当前节点有赋值标记（setv != LLONG_MIN），则将其下传到子节点，并清除子节点的加法标记。

    • 如果当前节点有加法标记（addv != 0），则根据子节点的标记类型进行更新：

      • 如果子节点有赋值标记，则将加法标记加到赋值标记上。

      • 否则，将加法标记加到子节点的加法标记上。

    • 更新子节点的最大值并清除当前节点的标记。

  3. 标记上传：

    • 用子节点的最大值更新当前节点的最大值。

  4. 区间赋值操作：

    • 当节点区间完全被目标区间覆盖时，设置节点的 setv 为指定值，清除 addv，并更新 maxv。

    • 否则，下传标记后递归处理子节点，最后更新当前节点的最大值。

  5. 区间加法操作：

    • 当节点区间完全被目标区间覆盖时：

      • 如果有赋值标记，则更新赋值标记。

      • 否则，更新加法标记。

    • 更新节点的最大值。

    • 否则，下传标记后递归处理子节点，最后更新当前节点的最大值。

  6. 区间最大值查询：

    • 当节点区间完全被查询区间覆盖时，直接返回 maxv。

    • 否则，下传标记后递归查询子节点，并返回子节点中的最大值。

然后就是他这个题目的结构体还是有一点说法 的，如果你把x放进去记录那比较好些一点，但你一开始向我一样懒的话就只能在op1下滑时a[i * 2+1].Max0 = a[i].Max0-a[i].op2;（先op1在op2)

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
struct ss {
    int l, r;
    long long Max0;
    long long op2;
    bool op1;
}a[4000006];
long long b[1000006];
void Chu(int l, int r, int i) {
    a[i].l = l, a[i].r = r;
    a[i].op2 = 0, a[i].op1 = false;
    if (l == r) {
        a[i].Max0 = b[l];
        return;
    }
    int mid = (l + r) >> 1;
    Chu(l, mid, i * 2);
    Chu(mid + 1, r, i * 2 + 1);
    a[i].Max0 = max(a[i * 2].Max0, a[i * 2 + 1].Max0);
}
void OOp1(int i) {
    if(a[i].l!=a[i].r) {
        a[i * 2].Max0 = a[i].Max0-a[i].op2;
        a[i * 2].op2 = 0;
        a[i * 2].op1 = true;
        a[i * 2+1].Max0 = a[i].Max0-a[i].op2;
        a[i * 2+1].op2 = 0;
        a[i * 2+1].op1 = true;
    }
    a[i].op1 = false;
}
void OOp2(int i) {
    if (a[i].l != a[i].r) {
        a[i * 2].Max0 += a[i].op2;
        a[i * 2].op2 += a[i].op2;
        a[i * 2 + 1].Max0 += a[i].op2;
        a[i * 2 + 1].op2 += a[i].op2;
    }
    a[i].op2 = 0;
}
void Op1(int l, int r, long long x,int i) {
    if (a[i].l >= l && a[i].r <= r) {
        a[i].Max0 = x;
        a[i].op2 = 0;
        a[i].op1 = true;
        return;
    }
    if (a[i].op1) {
        OOp1(i);
    }
    if (a[i].op2 != 0) {//可能为负数
        OOp2(i);
    }
    int mid = (a[i].l + a[i].r) >> 1;
    if (l <= mid) {
        Op1(l, r,x, i * 2);
    }
    if (mid + 1 <= r) {
        Op1(l, r, x, i * 2 + 1);
    }
    a[i].Max0 = max(a[i * 2].Max0, a[i * 2 + 1].Max0);
}
void Op2(int l, int r, long long x, int i) {
    if (a[i].l >= l && a[i].r <= r) {
        a[i].Max0 += x;
        a[i].op2 += x;
        return;
    }
    if (a[i].op1) {
        OOp1(i);
    }
    if (a[i].op2 != 0) {//可能为负数
        OOp2(i);
    }
    int mid = (a[i].l + a[i].r) >> 1;
    if (l <= mid) {
        Op2(l, r, x, i * 2);
    }
    if (mid + 1 <= r) {
        Op2(l, r, x, i * 2 + 1);
    }
    a[i].Max0 = max(a[i * 2].Max0, a[i * 2 + 1].Max0);
}
long long Op3(int l, int r, int i) {
    if (a[i].l >= l && a[i].r <= r) {
        return a[i].Max0;
    }
    if (a[i].op1) {
        OOp1(i);
    }
    if (a[i].op2 != 0) {//可能为负数
        OOp2(i);
    }
    int mid = (a[i].l + a[i].r) >> 1;
    long long w = LLONG_MIN;
    if (l <= mid) {
        w = max(w, Op3(l, r, i * 2));
    }
    if (mid + 1 <= r) {
        w = max(w, Op3(l, r, i * 2 + 1));
    }
    return w;
}
int n, m, l, r, op;
long long x;
int main(){
	ios::sync_with_stdio(false);        // 禁用同步
    cin.tie(nullptr);                   // 解除cin与cout绑定
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> b[i];
    }
    Chu(1, n, 1);
    for (int i = 1; i <= m; i++) {
        cin >> op;
        switch (op)
        {case 1:
            cin >> l >> r >> x;
            Op1(l, r, x, 1);
            break;
        case 2:
            cin >> l >> r >> x;
            Op2(l, r, x, 1);
            break;
        case 3:
            cin >> l >> r;
            cout << Op3(l, r, 1) << endl;
            break;
        default:
            break;
        }
    }
    return 0;
}

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2398076.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

嵌入式学习笔记 - 新版Keil软件模拟时钟Xtal灰色不可更改的问题

嵌入式学习笔记 - 新版Keil软件模拟时钟Xtal灰色不可更改的问题

在新版Keil软件中&#xff0c;模拟时钟无法修改XTAL频率&#xff0c;默认只能使用12MHz时钟。‌这是因为Keil MDK从5.36版本开始&#xff0c;参数配置界面不再支持修改系统XTAL频率&#xff0c;XTAL选项变为灰色&#xff0c;无法修改。这会导致在软件仿真时出现时间错误的问题&…
阅读更多...
黑马Java面试笔记之 集合篇（算法复杂度+ArrayList+）

黑马Java面试笔记之 集合篇（算法复杂度+ArrayList+）

一. 算法复杂度分析 1.1 时间复杂度 时间复杂度分析&#xff1a;来评估代码的执行耗时的 常见的复杂度表示形式 常见复杂度 1.2 空间复杂度 空间复杂度全称是渐进空间复杂度&#xff0c;表示算法占用的额外存储空间与数据规模之间的增长关系 二. 数组 数组&#xff08;Array&a…
阅读更多...
Nginx+Tomcat负载均衡

Nginx+Tomcat负载均衡

目录 Tomcat简介 Tomcat 的核心功能 Tomcat架构 Tomcat 的特点 Tomact配置 关闭防火墙及系统内核 Tomcar 主要文件信息 配置文件说明 案例一&#xff1a;Java的Web站点 案例二&#xff1a;NginxTomcat负载均衡、动静分离 Tomcat简介 Tomcat 是由 Apache 软件基金会&am…
阅读更多...
【论文解读】ReAct：从思考脱离行动, 到行动反馈思考

【论文解读】ReAct：从思考脱离行动, 到行动反馈思考

认识从实践开始&#xff0c;经过实践得到了理论的认识&#xff0c;还须再回到实践去。 ——《实践论》,毛泽东 1st author: About – Shunyu Yao – 姚顺雨 paper [2210.03629] ReAct: Synergizing Reasoning and Acting in Language ModelsReAct: Synergizing Reasoning and…
阅读更多...
简单配置RHEL9.X

简单配置RHEL9.X

切换默认运行级别 将系统默认启动模式从多用户的图形界面调整为多用户的文本界面&#xff0c;适用于优化系统资源占用或进行远程服务器管理的场景。 注意&#xff1a;安装选择“带GUI的服务器”部分常用命令默认安装&#xff1b;如果选择“最小安装”时&#xff0c;部分常用命…
阅读更多...
下载并运行自制RAG框架

下载并运行自制RAG框架

项目部署 https://github.com/huangjia2019/rag-project01-framework git clone https://github.com/huangjia2019/rag-project01-framework.git 一 、 前端分部分部署 在 Ubuntu 系统 上安装 Node.js 和 npm&#xff08;Node Package Manager&#xff09;&#xff0c;并初始…
阅读更多...
Rust 学习笔记：Cargo 工作区

Rust 学习笔记：Cargo 工作区

Rust 学习笔记&#xff1a;Cargo 工作区 Rust 学习笔记&#xff1a;Cargo 工作区创建工作区在工作区中创建第二个包依赖于工作区中的外部包向工作区添加测试将工作区中的 crate 发布到 crates.io添加 add_two crate 到工作区总结 Rust 学习笔记&#xff1a;Cargo 工作区 随着项…
阅读更多...
颈部的 “异常坚持”

颈部的 “异常坚持”

生活中&#xff0c;有些人的颈部会突然变得 “异常坚持”—— 头部不受控制地偏向一侧&#xff0c;或是不自主地旋转、后仰&#xff0c;仿佛被无形的力量牵引着。这种情况不仅影响外观&#xff0c;还会带来强烈的不适感&#xff0c;颈部肌肉紧绷、酸痛&#xff0c;像被一根绳索…
阅读更多...
Ubuntu22.04安装MinkowskiEngine

Ubuntu22.04安装MinkowskiEngine

MinkowskiEngine简介 Minkowski引擎是一个用于稀疏张量的自动微分库。它支持所有标准神经网络层&#xff0c;例如对稀疏张量的卷积、池化和广播操作。 MinkowskiEngine安装 官方源码链接&#xff1a;GitHub - NVIDIA/MinkowskiEngine: Minkowski Engine is an auto-diff neu…
阅读更多...
【计算机网络】第2章：应用层—应用层协议原理

【计算机网络】第2章：应用层—应用层协议原理

目录 1. 网络应用的体系结构 2. 客户-服务器&#xff08;C/S&#xff09;体系结构 3. 对等体&#xff08;P2P&#xff09;体系结构 4. C/S 和 P2P 体系结构的混合体 Napster 即时通信 5. 进程通信 6. 分布式进程通信需要解决的问题 7. 问题1&#xff1a;对进程进行编址…
阅读更多...
【Zephyr 系列 6】使用 Zephyr + BLE 打造蓝牙广播与连接系统（STEVAL-IDB011V1 实战）

【Zephyr 系列 6】使用 Zephyr + BLE 打造蓝牙广播与连接系统（STEVAL-IDB011V1 实战）

🧠关键词：Zephyr、BLE、广播、连接、GATT、低功耗蓝牙、STEVAL-IDB011V1 📌适合人群：希望基于 Zephyr 实现 BLE 通信的嵌入式工程师、蓝牙产品开发人员 🧭 前言：为什么选择 Zephyr 开发 BLE？ 在传统 BLE 开发中，我们大多依赖于厂商 SDK（如 Nordic SDK、BlueNRG SD…
阅读更多...
利用 Scrapy 构建高效网页爬虫：框架解析与实战流程

利用 Scrapy 构建高效网页爬虫：框架解析与实战流程

目录 前言1 Scrapy 框架概述1.1 Scrapy 的核心优势1.2 Scrapy 的典型应用场景 2 Scrapy 工作原理解析2.1 框架结构图2.2 Spider&#xff1a;定义数据采集策略2.3 Scheduler&#xff1a;调度请求与去重2.4 Downloader&#xff1a;网页下载器2.5 Item&#xff1a;结构化数据容器2…
阅读更多...
RPG20.创建敌人的初始能力和加载武器

RPG20.创建敌人的初始能力和加载武器

1. 基于StartUpAbilitiy基类创建专门用于敌人数据的DAStartUpABility&#xff0c;然后再基于新创建的DA再创建一个蓝图 2.打开 DataAsset_EnemyStartUpData.h // Fill out your copyright notice in the Description page of Project Settings.#pragma once#include "Cor…
阅读更多...
自适应移动平均（Adaptive Moving Average, AMA）

自适应移动平均（Adaptive Moving Average, AMA）

文章目录 1. 考夫曼自适应移动平均 (KAMA)算法推导及Python实现2. 对 (KAMA)算法参数进行优化及实现 自适应移动平均&#xff08;Adaptive Moving Average, AMA&#xff09;由Perry Kaufman在其著作《Trading Systems and Methods》中提出&#xff0c;它通过动态调整平滑系数来…
阅读更多...
涨薪技术|0到1学会性能测试第95课-全链路脚本开发实例

涨薪技术|0到1学会性能测试第95课-全链路脚本开发实例

至此关于系统资源监控、apache监控调优、Tomcat监控调优、JVM调优、Mysql调优、前端监控调优、接口性能监控调优的知识已分享完，今天学习全链路脚本开发知识。后续文章都会系统分享干货，带大家从0到1学会性能测试。 前面章节介绍了如何封装.h头文件，现在通过一个实例来介绍…
阅读更多...
Spring AI Alibaba + Nacos 动态 MCP Server 代理方案

Spring AI Alibaba + Nacos 动态 MCP Server 代理方案

作者&#xff1a;刘宏宇&#xff0c;Spring AI Alibaba Contributor 文章概览 Spring AI Alibaba MCP 可基于 Nacos 提供的 MCP server registry 信息&#xff0c;建立一个中间代理层 Java 应用&#xff0c;将 Nacos 中注册的服务信息转换成 MCP 协议的服务器信息&#xff0c…
阅读更多...
MCP：让AI工具协作变得像聊天一样简单 [特殊字符]

MCP：让AI工具协作变得像聊天一样简单 [特殊字符]

想象一下，你正在处理一个项目，需要从A平台查看团队讨论，从B平台获取客户信息，还要在GitHub上检查代码进度。传统做法是什么？打开三个不同的网页，在各个平台间来回切换，复制粘贴数据，最后还可能因为信息分散而遗漏重要细节。 听起来很熟悉？这正是当前工作流程的痛点所…
阅读更多...
AI炼丹日志-27 - Anubis 通过 PoW工作量证明的反爬虫组件 上手指南 原理解析

AI炼丹日志-27 - Anubis 通过 PoW工作量证明的反爬虫组件 上手指南 原理解析

点一下关注吧&#xff01;&#xff01;&#xff01;非常感谢&#xff01;&#xff01;持续更新&#xff01;&#xff01;&#xff01; Java篇&#xff1a; MyBatis 更新完毕目前开始更新 Spring&#xff0c;一起深入浅出&#xff01; 大数据篇 300&#xff1a; Hadoop&…
阅读更多...
阿姆达尔定律的演进：古斯塔夫森定律

阿姆达尔定律的演进：古斯塔夫森定律

前言 在上一篇文章《使用阿姆达尔定律来提升效率》中提到的阿姆达尔定律前提是假设问题的规模保持不变&#xff0c;并且给定一台速度更快的机器&#xff0c;目标是更快地解决问题。然而&#xff0c;在大多数情况下&#xff0c;这并不完全正确。当有一台更快的机器时&#xff0…
阅读更多...
JavaScript极致性能优化全攻略

JavaScript极致性能优化全攻略

JavaScript性能优化深度指南 1 引言 JavaScript性能优化在现代Web开发中至关重要。随着Web应用日益复杂，性能直接影响用户体验、搜索引擎排名和业务转化率。研究表明，页面加载时间每增加1秒，转化率下降7%，跳出率增加32%。通过优化JavaScript性能，开发者可以： 提升用户满…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023