这是一道大水题

简介: 笔记

Description


15.png


Input


16.png


Output


对于每一个询问操作,输出不包含xx号电影的评分时的总评分。


Sample Input 1


10 5

0 4 6 3

0 1 2 2

0 4 5 2

1 4

1 1


Sample Output 1


4

13


Hint


17.png


思路

这题主要要解决的问题就在,对于每一点,需要知道多少个区间包含了该点,并求出这些区间的和。但显然这不是很好求。


所以思路转为,包含该点的区间,该点对应的做出了多少贡献(即这个点对应的这些区间的和)。那么很容易知道,我们需要对区间中的每点,都赋予其这段区间的和值。也就是这个单点加区间段的大小。


代码

差分,能过应该是数据点“假”了。

int a[N];
void solve() {
  int n, m; cin >> n >> m;
  for (int i = 1; i <= m; i++) {
    int op; cin >> op;
    int l, r, x;
    if(op == 0) {
      cin >> l >> r >> x;
      a[1] += (r - l + 1) * x;
      a[l] -= (r - l + 1) * x;
      a[r + 1] += (r - l + 1) * x;
      a[N - 1] -= (r - l + 1) * x;
    } else {
      cin >> x;
      int ans = 0;
      for (int i = 1; i <= x; i++) ans += a[i];
      cout << ans << endl;
    }
  }
}
  • 线段树(用不到两颗线段树,第一份代码就不改了,作为多颗线段树的板子)
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
#define int long long
#define ls u<<1
#define rs u<<1|1
struct node {
  int l, r;
  int v, add;
} tr[2][N << 2];
int n, m;
void pushup(int _, int u) {
  tr[_][u].v = tr[_][ls].v + tr[_][rs].v;
}
void pushdown(int _, int u) {
  if(tr[_][u].add) {
    tr[_][ls].add += tr[_][u].add, tr[_][ls].v += (tr[_][ls].r - tr[_][ls].l + 1) * tr[_][u].add;
    tr[_][rs].add += tr[_][u].add, tr[_][rs].v += (tr[_][rs].r - tr[_][rs].l + 1) * tr[_][u].add;
    tr[_][u].add = 0;
  }
}
void build(int _, int u, int l, int r) {
  tr[_][u] = {l, r};
  if(l == r) { return ; }
  int mid = (l + r) >> 1;
  build(_, ls, l, mid), build(_, rs, mid + 1, r);
  pushup(_, u);
}
void modify(int _, int u, int l, int r, int v) {
  if(tr[_][u].l >= l && tr[_][u].r <= r) { tr[_][u].v += (tr[_][u].r - tr[_][u].l + 1) * v; tr[_][u].add += v; return ; }
  int mid = (tr[_][u].l + tr[_][u].r) >> 1;
  pushdown(_, u);
  if(l <= mid) modify(_, ls, l, r, v);
  if(r > mid) modify(_, rs, l, r, v);
  pushup(_, u);
  return ;
}
int query(int _, int u, int l, int r){
  if(tr[_][u].l >= l && tr[_][u].r <= r) { return tr[_][u].v; }
  int mid = (tr[_][u].l + tr[_][u].r) >> 1;
  pushdown(_, u);
  int res = 0;
  if(l <= mid) res = query(_, ls, l, r);
  if(r > mid) res += query(_, rs, l, r);
  return res;
}
signed main() {
  cin >> n >> m;
  build(0, 1, 1, n), build(1, 1, 1, n);
  for (int i = 1; i <= m; i++) {
    int op, l, r, x;
    cin >> op;
    if(op == 0) {
      cin >> l >> r >> x;
      modify(0, 1, l, r, x);
      modify(1, 1, l, r, (r - l + 1) * x);
    } else {
      cin >> x;
      cout << query(0, 1, 1, n) - query(1, 1, x, x) << endl;
    }
  }
  return 0;
}
const int N = 2e6 + 10;
const int mod = 1e9 + 7; //*/ 998244353;
const int inf = 1e9;
int n, m;
struct node {
    int l, r;
    int val;
    int lz;
}tr[N * 2];
void pushup(int u) {
    tr[u].val = tr[u << 1].val + tr[u << 1 | 1].val;
    return;
}
void pushdown(int u) {
    if (tr[u].lz) {
        tr[u << 1].val += tr[u].lz * (tr[u << 1].r - tr[u << 1].l + 1);
        tr[u << 1 | 1].val += tr[u].lz * (tr[u << 1 | 1].r - tr[u << 1 | 1].l + 1);
        tr[u << 1].lz += tr[u].lz;
        tr[u << 1 | 1].lz += tr[u].lz;
        tr[u].lz = 0;
    } else return;
}
void build(int u, int l, int r) {
    tr[u].l = l, tr[u].r = r;
    if (l == r) return;
    int mid = l + r >> 1;
    build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
    pushup(u);
}
void modify(int u, int l, int r, int x) {
    if (tr[u].l >= l && tr[u].r <= r) {
        tr[u].val += (tr[u].r - tr[u].l + 1) * x;
        tr[u].lz += x;
        return;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid) modify(u << 1, l, r, x);
    if (r > mid) modify(u << 1 | 1, l, r, x);
    pushup(u);
}
int query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) {
        return tr[u].val;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    int ans = 0;
    if (l <= mid) ans += query(u << 1, l, r);
    if (r > mid) ans += query(u << 1 | 1, l, r);
    return ans;
}
void solve()
{
    rd(n), rd(m);
    build(1, 1, n);
    int ans = 0;
    for (int i = 1; i <= m; i++) {
        int op; rd(op);
        if (op == 0) {
            int l, r;
            rd(l), rd(r);
            int x; rd(x);
            ans += (r - l + 1) * x;
            modify(1, l, r, (r - l + 1) * x);
        }
        else {
            int x; rd(x);
            pf(ans - query(1, x, x), 1);
        }
    }
}
相关文章
|
16天前
|
人工智能 自然语言处理 文字识别
阿里云百炼Qwen3.7-Max简介:能力、优势、支持订阅计划参考
Qwen3.7-Max是阿里云百炼面向智能体时代推出的新一代旗舰模型,对标GPT-5.5、Claude Opus 4.7等闭源旗舰。该模型支持百万级token上下文窗口,具备顶级推理能力、多模态搜索与视觉理解增强、流式输出低延迟响应等核心优势,覆盖编程、办公、长周期自主执行等复杂场景。同时支持OpenAI接口兼容,便于系统快速迁移。用户可通过Token Plan团队或节省计划等订阅方式灵活调用,适合企业级高要求场景使用。
6022 30
阿里云百炼Qwen3.7-Max简介:能力、优势、支持订阅计划参考
|
1天前
|
数据采集 人工智能 前端开发
让 Coding Agent 从黑盒到透明:阿里云 Agent 观测审计数据采集实践
AI Agent 规模化落地带来执行黑盒、行为难追溯、成本难度量三大难题。阿里云基于 OTel 标准,面向 Coding Agent、个人通用助理和框架型 Agent,推出 LoongSuite Pilot、插件及探针等无侵入采集方案,让 Agent 实现可看见、可分析、可审计、可治理。
573 135
|
11天前
|
存储 定位技术 数据库
CodeGraph 如何让 Claude Code减少 7 成工具调用?
CodeGraph 为 Coding Agent 提供本地代码知识图谱,把函数、类、调用链和框架路由提前整理成“项目地图”,减少盲目搜索和文件读取。它不是新 Agent,而是上下文基础设施,让 Agent 更快找到正确代码路径,平均减少 7 成工具调用。
1190 3
|
8天前
|
人工智能 安全 定位技术
CodeGraph深度解析 让Claude Code工具调用直降七成的核心原理与实操教程
如今以Claude Code为代表的AI编程智能体已经成为开发者日常编码、项目重构、漏洞修复的必备工具。但在长期使用过程中,几乎所有开发者都会遇到同一个明显痛点:AI虽然具备强大的代码生成与分析能力,却常常陷入盲目探索的循环中。
993 1
|
18天前
|
人工智能 自然语言处理 供应链
|
9天前
|
人工智能 弹性计算 安全
阿里云618活动时间、活动入口、优惠活动详细解读
2026年阿里云618创新加速季已全面开启,作为年度力度最大的云产品促销活动,本次大促覆盖轻量应用服务器、ECS云服务器、GPU云服务器、数据库、AI算力、安全服务、CDN等全品类产品,推出5亿元算力补贴、新用户限时秒杀、普惠满减、企业专享、免费试用、云大使返佣等多重福利,个人开发者、中小企业、AI团队均可享受专属低价。本文将系统梳理2026年阿里云618活动的完整时间节点、官方参与入口、各类优惠细则、使用规则、热门产品推荐及实操代码,帮助用户精准参与、高效省钱,以最低成本完成上云部署。
819 5
|
9天前
|
运维
欢迎报名|2026 Agentic AICon—智能体基础设施与AgentOps专场,邀您参会
欢迎报名|2026 Agentic AICon—智能体基础设施与AgentOps专场,邀您参会
1443 0