A Simple Problem with Integers

题目大意:

给定一个长度为N的数列,输入Q行操作指令。指令有两种:
1.“C l r d”,区间A[l~r]都加上d
2.“Q l r”,查询区间A[l~r]每个数的和并输出

解题思路:

线段树模板啊~~~~

Accepted code:

#include<cstdio>
#include<algorithm>
#define ls (now<<1)
#define rs (now<<1|1)
#define l(x) tree[x].l
#define r(x) tree[x].r
#define S(x) tree[x].sum
#define A(x) tree[x].lazy
#define N 100010
#define mid(x,y) ((x+y)>>1)
using namespace std;
struct Segment_Tree {
    int l,r;
    long long sum,lazy;
}tree[N<<2];
int a[N],n,m;
void build(int now,int l,int r) {
    l(now)=l; r(now)=r;
    if (l==r) {scanf("%lld",&S(now));return;}
    build(ls,l,mid(l,r));
    build(rs,mid(l,r)+1,r);
    S(now)=S(ls)+S(rs);
}
void down_update(int now) {
    if (A(now)) {
        S(ls)+=A(now)*(r(ls)-l(ls)+1); A(ls)+=A(now);
        S(rs)+=A(now)*(r(rs)-l(rs)+1); A(rs)+=A(now);
        A(now)=0;
    }
}
void change(int now,int l,int r,int d) {
    if (l<=l(now)&&r>=r(now)) {
        S(now)+=(long long)d*(r(now)-l(now)+1);
        A(now)+=d; return;
    }
    down_update(now); int mi=mid(l(now),r(now));
    if(l<=mi) change(ls,l,r,d);
    if(r>mi) change(rs,l,r,d);
    S(now)=S(ls)+S(rs);
}
long long ask(int now,int l,int r) {
    if (l<=l(now)&&r>=r(now)) return S(now);
    down_update(now);
    int mi=mid(l(now),r(now));
    long long All=0;
    if (l<=mi) All+=ask(ls,l,r);
    if (r>mi) All+=ask(rs,l,r);
    return All;
}
int main() {
    scanf("%d%d",&n,&m);
    build(1,1,n);
    while (m--) {
        char c[2];int x,y,dat;
        scanf("%s%d%d",c,&x,&y);
        if (c[0]=='C') {
            scanf("%d",&dat);
            change(1,x,y,dat);
        } else printf("%lld\n",ask(1,x,y));
    }
}
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Here is a C++ program that constructs a max heap with integers and prints it in the rotated form: ```cpp #include <iostream> #include <vector> using namespace std; // function to swap two integers void swap(int& a, int& b) { int temp = a; a = b; b = temp; } // function to heapify the given vector void heapify(vector<int>& arr, int n, int i) { int largest = i; // initialize largest as root int left = 2*i + 1; // left child index int right = 2*i + 2; // right child index // if left child is larger than root if (left < n && arr[left] > arr[largest]) largest = left; // if right child is larger than largest so far if (right < n && arr[right] > arr[largest]) largest = right; // if largest is not root if (largest != i) { // swap the root with largest element swap(arr[i], arr[largest]); // recursively heapify the affected sub-tree heapify(arr, n, largest); } } // function to build max heap void buildMaxHeap(vector<int>& arr, int n) { // start from the last non-leaf node and heapify each node for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i); } // function to print the heap in the rotated form void printRotatedHeap(vector<int>& arr, int n) { int height = log2(n) + 1; // height of the heap int index = 0; // current index in the heap int spaces = pow(2, height - 1) - 1; // number of spaces before the first element of the current level // print each level of the heap in the rotated form for (int i = 0; i < height; i++) { // print the spaces before the first element of the current level for (int j = 0; j < spaces; j++) cout << " "; // print the elements of the current level for (int j = 0; j < pow(2, i) && index < n; j++) { cout << arr[index++] << " "; // print the spaces between elements of the current level for (int k = 0; k < 2 * spaces + 1; k++) cout << " "; } // move to the next line and adjust the number of spaces for the next level cout << endl; spaces /= 2; } } int main() { int n; cout << "Enter the number of elements: "; cin >> n; vector<int> arr(n); cout << "Enter the elements: "; for (int i = 0; i < n; i++) cin >> arr[i]; // build max heap buildMaxHeap(arr, n); // print the heap in the rotated form cout << "Max heap in the rotated form:\n"; printRotatedHeap(arr, n); return 0; } ``` In this program, we first define a `swap` function to swap two integers, and a `heapify` function to heapify the sub-tree rooted at a given index `i` in the given vector `arr`. We then define a `buildMaxHeap` function to build the max heap from the given vector `arr`. Finally, we define a `printRotatedHeap` function to print the max heap in the rotated form. In the `main` function, we first read the number of elements and the elements themselves from the user using `cin`. We then build the max heap using `buildMaxHeap` function, and print the heap in the rotated form using `printRotatedHeap` function. The `printRotatedHeap` function uses the height of the heap to determine the number of levels, and the number of spaces before the first element of each level. It then prints each level of the heap in the rotated form, by printing the elements of the level followed by the spaces between elements.

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值