【问题描述】 输入一个长度为n的整数序列。 接下来输入m个操作，每个操作包含三个整数l,r,c，表示将序列中[l,r]之间的每个数加上c。 请你输出进行完所有操作后的序列。 【输入格式】 第一行包含两个整数n和m。 第二行包含n个整数，表示整数序列。 接下来m行，每行包含三个整数l，r，c表示一个操作。 【输出格式】 共一行，包含n个整数，表示最终序列。 【数据范围】 1≤n,m≤100000, 1≤l≤r≤n,

【样例输入】
5 3
1 2 3 4 5
1 3 2
3 5 -1
2 4 1
【样例输出】
3 4 5 6 5

【算法思路】
题目要求对序列进行多次修改，可以使用差分的思想，即将每次修改的区间[l,r]的左端点l加上c，右端点r+1加上-c。最后再对整个序列求前缀和，即可得到修改后的序列。

【Python代码】

n, m = map(int, input().split())
a = list(map(int, input().split()))

# 差分数组
d = [0] * (n + 1)
for i in range(1, n + 1):
    d[i] = a[i - 1] - a[i - 2]

# 执行m次操作
for i in range(m):
    l, r, c = map(int, input().split())
    d[l] += c
    if r < n:
        d[r + 1] -= c

# 求前缀和
for i in range(2, n + 1):
    d[i] += d[i - 1]

# 输出结果
for i in range(1, n + 1):
    print(d[i], end=' ')

相关问题

运用C++写一个代码：输入一个长度为n的整数序列，接下来输入m个操作，每个操作包含三个整数l,r,c表示将序列中[[l,r][l,r]]之间的每个数加上c。请你输出进行完所有操作后的序列

在C++中，你可以使用数组和循环结构来实现这个功能。首先，我们需要创建一个动态大小的数组来存储输入的序列，然后处理每一个操作并更新数组。以下是一个简单的示例代码：

#include <iostream>
#include <vector>

// 函数用于处理操作
void applyOperations(int* arr, int n, std::vector<std::tuple<int, int, int>>& operations) {
    for (const auto& op : operations) {
        int l = std::get<0>(op);
        int r = std::get<1>(op);
        int c = std::get<2>(op);

        // 确保索引在范围内
        if (l >= 0 && l <= n - 1 && r >= 0 && r <= n - 1) {
            for (int i = l; i <= r; ++i) {
                arr[i] += c;
            }
        }
    }
}

int main() {
    int n;
    std::cout << "请输入序列的长度: ";
    std::cin >> n;

    // 创建动态数组
    std::vector<int> arr(n);
    std::cout << "请输入序列元素: ";
    for (int i = 0; i < n; ++i) {
        std::cin >> arr[i];
    }

    int m;
    std::cout << "请输入操作的数量: ";
    std::cin >> m;

    std::vector<std::tuple<int, int, int>> operations(m);
    std::cout << "请输入每个操作(l, r, c): ";
    for (size_t i = 0; i < m; ++i) {
        std::cin >> std::get<0>(operations[i]) >> std::get<1>(operations[i]) >> std::get<2>(operations[i]);
    }

    applyOperations(arr.data(), n, operations);

    std::cout << "操作后序列: ";
    for (const auto& num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个程序中，用户会依次输入序列的长度、每个元素、操作的数量以及每个操作的具体细节。`applyOperations`函数负责根据提供的操作对序列进行更新。

用c语言解决以下问题：题目描述 给定一个序列，每次询问序列中第l个数到第r个数中第K大的数是哪个。 输入 第一行包含一个数n，表示序列长度。 第二行包含n个正整数，表示给定的序列。 第三个包含一个正整数m，表示询问个数。 接下来m行，每行三个数l,r,K，表示询问序列从左往右第l个数到第r个数中，从大往小第K大的数是哪个。序列元素从1开始标号。 输出 总共输出m行，每行一个数，表示询问的答案。

这道题可以使用线段树来解决。线段树是一种树形结构，用于处理具有区间性的问题。

对于这道题，我们可以建立一颗线段树，其中每个节点表示一个区间，区间内的数字都存储在该节点的数组中。对于每个询问，我们可以在线段树中查找第 l 到 r 个数字之间第 K 大的数字。

下面是一个可以解决这道题的 C 代码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define maxn 100005

int n, m;
int a[maxn];

struct SegmentTreeNode {
  int l, r;
  int cnt[maxn];
  int lazy;
} tree[maxn * 4];

void pushup(int u) {
  for (int i = 1; i <= maxn - 5; i++) tree[u].cnt[i] = tree[u << 1].cnt[i] + tree[u << 1 | 1].cnt[i];
}

void build(int u, int l, int r) {
  tree[u] = {l, r};
  if (l == r) {
    tree[u].cnt[a[l]] = 1;
    return;
  }
  int mid = l + r >> 1;
  build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
  pushup(u);
}

void pushdown(int u) {
  if (tree[u].lazy) {
    tree[u << 1].lazy += tree[u].lazy;
    tree[u << 1 | 1].lazy += tree[u].lazy;
    tree[u << 1].cnt[tree[u].lazy] += tree[u << 1].r - tree[u << 1].l + 1;
    tree[u << 1 | 1].cnt[tree[u].lazy] += tree[u << 1 | 1].r - tree[u << 1 | 1].l + 1;
    tree[u].lazy = 0;
  }
}

void modify(int u, int l, int r, int c) {
  if (tree[u].l >= l && tree[u].r <= r) {
    tree[u].lazy = c;
    tree[u