A Simple Problem with Integers （基础线段树）

最新推荐文章于 2022-08-09 17:16:44 发布
最新推荐文章于 2022-08-09 17:16:44 发布
阅读量633 收藏
点赞数 2
分类专栏： 线段树 文章标签： 数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acmDragon/article/details/52071871
版权

题意
给出了一个序列，你需要处理如下两种询问
“C a b c”表示给[a, b]区间中的值全部增加c (-10000 ≤ c ≤ 10000)。
“Q a b” 询问[a, b]区间中所有值的和。
本题很简单注意数据范围就可以了 （他是很直白的区域更新）lazy 标记要用 long long 在这错了很多次。

以下是AC代码

#include <iostream>
#include <stdio.h>
using namespace std;

const int maxn=100005;

struct node
{
    int l,r;
    long long lazy;
    long long sum;
} tree[maxn*4];

int a[maxn+5];

void pushdown(int id)
{
    if(tree[id].lazy!=0)
    {
        tree[id*2].lazy+=tree[id].lazy;
        tree[id*2+1].lazy+=tree[id].lazy;
        tree[id*2].sum+=(tree[id].lazy*(tree[id*2].r-tree[id*2].l+1));
        tree[id*2+1].sum+=(tree[id].lazy*(tree[id*2+1].r-tree[id*2+1].l+1));
        tree[id].lazy=0;
//注意把lazy标记计零
    }
}

//建树
void build (int left,int right,int id)
  
{
    tree[id].l=left;
    tree[id].r=right;
    tree[id].lazy=0;
    int mid=(left+right)/2;
    if(tree[id].l==tree[id].r)
    {
        tree[id].sum=a[tree[id].l];
        return ;
    }
    else
    {
        build(left,mid,id*2);
        build(mid+1,right,id*2+1);
    }
    tree[id].sum=tree[id*2].sum+tree[id*2+1].sum;
}

//给给定区间加上一个数
void add(int left,int right,int val,int id)
{
    int mid=(tree[id].l+tree[id].r)/2;
    if(left<=tree[id].l&&tree[id].r<=right)
    {
        tree[id].lazy+=val;
        tree[id].sum+=(val*(tree[id].r-tree[id].l+1));
        return ;
    }

        //增加的时候也要把lazy标记往下传
    pushdown(id);
    if(right<=mid)
    {
        add(left,right,val,id*2);
    }
    else if(left>=mid+1)
    {
        add(left,right,val,id*2+1);
    }
    else
    {
        add(left,mid,val,id*2);
        add(mid+1,right,val,id*2+1);
    }
    tree[id].sum=tree[id*2].sum+tree[id*2+1].sum;
}

//查询 
long long inquiry(int left,int right,int id)
{
    int mid=(tree[id].l+tree[id].r)/2;
    if(left<=tree[id].l&&tree[id].r<=right)
    {
        return tree[id].sum;
    }
//注意把lazy标记往下传
    pushdown(id);
    long long ans=0;
    if(right<=mid)
    {
        ans+=inquiry(left,right,id*2);
    }
    else if(left>=mid+1)
    {
        ans+=inquiry(left,right,id*2+1);
    }
    else
    {
        ans+=inquiry(left,mid,id*2);
        ans+=inquiry(mid+1,right,id*2+1);
    }
    return ans;
}
int main ()
{
    int n,m,i;
    scanf ("%d %d",&n,&m);
    for (i=1; i<=n; i++)
        scanf ("%d",&a[i]);
    build(1,n,1);
    while (m--)
    {
        char type[2];
        int x,y,val;
        scanf ("%s",&type);
        if(type[0]=='Q')
        {
            scanf ("%d %d",&x,&y);
            long long ans=inquiry(x,y,1);
            cout<<ans<<endl;
        }
        if(type[0]=='C')
        {
            scanf ("%d %d %d",&x,&y,&val);
            add(x,y,val,1);
        }
    }
    return 0;
}
追梦_人
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Printing Floating-Point Numbers Quickly and Accurately with Integers - 2010 (dtoa-pldi2010)-计算机科学
04-22
Printing Floating-Point Numbers Quickly and Accurately with IntegersFlorian Loitsch Inria Sophia Antipolis2004 Route des Lucioles - BP 93 - 06902 Sophia Antipolis Cedex florian.loitsch@inria....
Integers
03-17
同伦类型理论中的等价整数这是伴随[1]进行形式化的存储库。该存储库的内容GrpdHITs/ ：[2]随附的存储库。 Categories/ ：最初尝试直接为ℤh和ℤb创建预Categories/代数。 Prebicategories/ ：与谓词，伪函数和伪变换...
A Simple Problem with Integers
TherAndI的博客
01-26 1472
You have N integers, A1, A2, ... , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.The other is to ask f
A Simple Problem with Integers-线段树模板(入门)
Godblessuam的博客
05-13 1470
You have N integers, A1, A2, … , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the su...
A Simple Problem with Integers POJ - 3468
ashbringer233的博客
08-09 184
思路：构造树状数组，将一个区间分成两半，再将每一部分分成两半，直到每一部分只剩一个元素，每个父结点记录所有子节点的权值和，在询问是，只需查找在区间内的父结点的值，在进行修改时，我们只对操作区间内的点做标记，不用真的改变所有值，如果以后需要再访问这个节点的子节点，就再把标记和值向下传递。题目大意：给出一个有n个数的数组，每次询问查询一个区间内的元素和，每次修改将区间内所有元素加上一个值。...
A Simple Problem with Integers （线段树）
10-30 144
Description You haveNintegers,A1,A2, ... ,AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The othe...
Python解析json时提示“string indices must be integers”问题解决方法
09-18
主要介绍了Python解析json时提示“string indices must be integers”问题解决方法,结合实例形式分析了Python解析json字符串操作规范与相关使用技巧,需要的朋友可以参考下
UTM Integers Polynomials and Rings A Course in Algebra
03-05
This book will help a lot if you are studying discrete mathematics in college. The main content has been clearly illustrated in its title.
992. Subarrays with K Different Integers.cpp_Different_力扣992答案_源
09-30
力扣992答案
A Simple Problem with Integers----线段树
bless295的博客
06-02 3109
C - A Simple Problem with Integers Time Limit:5000MS     Memory Limit:131072KB     64bit IO Format:%I64d & %I64u Submit Status Practice POJ 3468 Description You have N integers, A1
A Simple Problem with Integers （叶子节点 循环节）
海绵的博客
08-06 332
链接：https://www.nowcoder.com/acm/contest/163/H 来源：牛客网   题目描述 You have N integers A1, A2, ... , AN. You are asked to write a program to receive and execute two kinds of instructions: 1. C a b means p...
A Simple Problem with Integers(线段树 成段更新)
略略略的博客
02-04 690
A Simple Problem with Integers Time Limit: 5000MS   Memory Limit: 131072K Total Submissions: 102892   Accepted: 32121 Case Time Limit: 2000MS Description You have N 
A Simple Problem with Integers(线段树之区间点的成段更新)
xdlove
02-12 1263
萌萌哒的传送门 线段树的另一个知识点,区间点的成段更新,此处需要学习一下一个新的知识点,延迟标记. 延迟标记是用来优化线段树的更新和查找的时间复杂度的,总的来说,就是对于当前找到的 这一段区间进行标记,然后覆盖其子区间,这样就可以节省时间,不必要去更新到叶子节点去; 不过如果下次需要修改到其子区间的话,在把延迟标记传给子区间就行,这就是pushup和pushdown 的意义;
POJ 3468 A Simple Problem with Integers
dhn37379的博客
03-09 131
一般说简单的题目不简单，但是有了线段树之后这些题都是简单题~~~ 题目大意： 给定N个数的序列，有Q个操作。操作分两种：1、将某个区间内的所有数都加上某个数。2、计算某个区间的所有数之和并输出。 解题思路： 简单的线段树。单点更新会TLE，只能区间更新。 下面是代码： #include <stdio.h> #include <...
A Simple Problem with Integers （线段树模板）
自渡的博客
04-10 185
You haveNintegers,A1,A2, ... ,AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the ...
A Simple Problem with Integers（线段树）
userluoxuan的专栏
08-14 482
解题思路： 区间更新，区间求和的模板题。 AC代码：
A Simple Problem with Integers (线段树区间更新区间求和)
galesaur_wcy
05-24 232
You have N integers, A1, A2, ... , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to...
poj 3468 A Simple Problem with Integers（线段树区间更新求和）
booyoungxu的专栏
10-31 271
题目地址 题目大意：给出n长度的数组 "C a b c" means adding c to each of Aa, Aa+1, ... , Ab. -10000 ≤ c ≤ 10000. "Q a b" means querying the sum of Aa, Aa+1, ... , Ab. 解题思路：裸线段树区间更新并求和，注意用long long #include #inclu
write a C++ program for constructing a heap (max heap) with integers and printing it in the rotated form.
最新发布
06-02
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、付费专栏及课程。

余额充值