操作格子（线段树）

最新推荐文章于 2024-06-03 12:11:58 发布
原创 最新推荐文章于 2024-06-03 12:11:58 发布 · 554 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

 算法训练 操作格子  
时间限制：1.0s   内存限制：256.0MB
       
问题描述

有n个格子，从左到右放成一排，编号为1-n。

共有m次操作，有3种操作类型：

1.修改一个格子的权值，

2.求连续一段格子权值和，

3.求连续一段格子的最大值。

对于每个2、3操作输出你所求出的结果。

输入格式

第一行2个整数n，m。

接下来一行n个整数表示n个格子的初始权值。

接下来m行，每行3个整数p,x,y，p表示操作类型，p=1时表示修改格子x的权值为y，p=2时表示求区间[x,y]内格子权值和，p=3时表示求区间[x,y]内格子最大的权值。

输出格式

有若干行，行数等于p=2或3的操作总数。

每行1个整数，对应了每个p=2或3操作的结果。

样例输入
4 3
1 2 3 4
2 1 3
1 4 3
3 1 4
样例输出
6
3
数据规模与约定

对于20%的数据n <= 100，m <= 200。

对于50%的数据n <= 5000，m <= 5000。

对于100%的数据1 <= n <= 100000，m <= 100000，0 <= 格子权值 <= 10000。

这题是看了别人的做的，代码几乎一样的 

#include <stdio.h>
#include <memory.h>
#include <malloc.h>
#include <stdlib.h>
typedef struct node
{
    struct node *lchild;
    struct node *rchild;
    int l;
    int r;
    int max;
    int sum;
    
}NODE, *PNODE;
int max(int a, int b)
{
    return a>b? a:b;
}
PNODE build(int left, int right)
{
    PNODE xt = (PNODE)malloc(sizeof(NODE));
    xt->l = left;
    xt->r = right;
    xt->sum = 0;
    xt->max = 0;
    if (left == right)
        return xt;
    else
    {
        int mid = (left+right)/2;
        xt->lchild = build(left, mid);
        xt->rchild = build(mid+1, right);
    }
    return xt;
}
void initVal(PNODE xt, int num, int val)
{
    if (num==xt->l && num==xt->r)
    {
        xt->max = val;
        xt->sum = val;
        return ;
    }   
    else
    {
        int mid = (xt->l+xt->r)/2;
        if (num <= mid)
            initVal(xt->lchild, num, val);
        else
            initVal(xt->rchild, num, val);
        xt->sum = xt->lchild->sum + xt->rchild->sum;
        xt->max = max(xt->lchild->max, xt->rchild->max);
    }
    return ;
}
void modify(PNODE xt, int x, int y)
{
    if (x==xt->l && x==xt->r)
    {
        xt->sum = y;
        xt->max = y;
        return ;
    }
    else
    {
        int mid = (xt->l+xt->r)/2;
        if (x <= mid)
            modify(xt->lchild, x, y);
        else
            modify(xt->rchild, x, y);
        xt->sum = xt->lchild->sum + xt->rchild->sum;
        xt->max = max(xt->lchild->max, xt->rchild->max);
    }
    return ;
}
int getSum(PNODE xt, int x, int y)
{
    if (x==xt->l && y==xt->r)
        return xt->sum;
    else
    {
        int mid = (xt->l+xt->r)/2;
        if (y <= mid)
            return getSum(xt->lchild, x, y);
        else
            if (x > mid)
                return getSum(xt->rchild, x, y);    
            else
                return getSum(xt->lchild, x, mid)+getSum(xt->rchild, mid+1, y);
    }
}
int getMax(PNODE xt, int x, int y)
{
    if (x==xt->l && y==xt->r)
        return xt->max;
    else
    {
        int mid = (xt->l+xt->r)/2;
        if (y <= mid)
            return getMax(xt->lchild, x, y);
        else
            if (x > mid)
                return getMax(xt->rchild, x, y);
            else
                return max(getMax(xt->lchild, x, mid), getMax(xt->rchild, mid+1, y));
    }   
}
int main()
{
    PNODE xt;
    int n,m;
    int i,j;
    int p,x,y;
    scanf("%d %d", &n, &m);
    int val;
    xt = build(1, n);
    for (i=1; i<=n; i++)
    {
        scanf("%d", &val);
        initVal(xt, i, val);
    }   
    for (i=1; i<=m; i++)
    {
        scanf("%d %d %d", &p, &x, &y);
        if (p == 1)
            modify(xt, x, y);
        else
            if (p == 2)
                printf("%d\n", getSum(xt, x, y));
            else
                if (p == 3)
                    printf("%d\n", getMax(xt, x, y));
    }   
    
    return 0;
}

下面两个是用数组模拟二叉树的（都差不多，第二个注释多些）

其一：

#include<stdio.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<limits.h>
using namespace std;

struct node 
{
	int l, r;
	int sum, max;
}a[400001];

int Max(int x,int y)
{
	return x> y? x: y;
}


void Build(int l,int r, int n)// 构建一颗范围为L-R的线段树
{
	a[n].l= l;
	a[n].r= r;
	a[n]. sum= 0;
	a[n]. max= 0;
	if(l==r)
		return;
	Build(l , (l + r) /2 , 2*n);// 构建该结点左子树[1,(l+r)/2]		
	Build(1+(l+r) /2 , r, 2*n + 1);// 构建该结点右子树[1+(l+r)/2,r] 
}

 
void Change(int n, int v, int num) //改变结点[v,v]的值 
{
	if(v == a[n].l && v== a[n].r)
	{
		a[n].sum= num;
		a[n].max= num;
		return;
	}	
	int mid= (a[n].l + a[n].r) / 2;
	if(v <= mid)
		Change(2*n, v, num);// 说明结点[V,V]在第n个结点的左子树上 
	else
		Change(1+ 2*n, v, num);// 说明结点[V,V]在第n个结点的右子树上 
	a[n].sum= a[2*n].sum + a[ 1+2*n ].sum; //从下往上更新所有父亲结点的值 
	a[n].max= Max(a[2*n].max,a[ 1+2*n ].max);//从下往上更新所有父亲结点的值
}


int Qsum(int l, int r, int n) //求[l,r]之间权值的和 
{
	if(l == a[n].l && r == a[n].r)
		return a[n].sum;// 说明第n结点刚好为[l,r]； 
	int mid= (a[n].l + a[n].r)/2;
	//printf("%d\n",mid);
	if(r<= mid)
		return Qsum(l,r,2*n); //情况一：[l,r]全在第n个结点的左子树上
	else if(l> mid)
		return Qsum(l,r,1+2*n); //	情况二： [l,r]全在第n个结点的右子树上
	else 
		return Qsum(l,mid,2*n) + Qsum(mid+1,r,1+2*n); //情况三：左右子树都占有 
}


int Qmax(int l, int r, int n)//求[l,r]之间的最大权值
{
	if(l == a[n].l && r == a[n].r)
		return a[n].max;
	int mid= ( a[n].l + a[n].r) /2;
	if(r<= mid)
		return Qmax(l,r,2*n);
	else if(l> mid)
		return Qmax(l,r,1+2*n);
	else
		return Max(Qmax(l,mid,2*n), Qmax(mid+1,r,1+2*n));		 
} 

int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	Build(1,n,1);// 先建一颗1-n的线段树 
	for(int i= 1; i<= n; i++)
	{
		int t;
		scanf("%d",&t);
		Change(1,i,t);
	}
	while(m--)
	{
		int x,y,p;
		scanf("%d%d%d",&p,&x,&y);
		if(p == 1)
			Change(1,x,y);
		else if(p==2)
		{
			int sum= Qsum(x,y,1);
			printf("%d\n",sum);
		}
		else
		{
			int max= Qmax(x,y,1);
			printf("%d\n",max);
		}	
	}
return 0;
}
其二： 

#include<stdio.h>
int Testmax(int a,int b)//判断大小的函数 
{return a>b?a:b;}
typedef struct node//构造一个线段树的结构体 
{
   int l,r;
   int sum,max;
}node;
node a[400010];//申请线段树节点空间 
void Build(int n,int l,int r);//构建一棵范围在l至r范围的线段树 
void Insert(int n, int v, int num);//为线段树插入一个值 
void Change(int n, int v, int num);//为线段树改变一个权值 
int QSum(int n, int l, int r);//求一个范围内的权值总和 
int QMax(int n, int l, int r);//求一个范围内的最大值 
int main()
{
    int i,j,n,m,value,que,b,c;
    scanf("%d%d",&n,&m);
    Build(1,1,n);//构建一个范围为1至n的线段树 
    for(i=1;i<=n;i++)
    {
       scanf("%d",&value);
       Insert(1,i,value);//向已有线段树中插入权值 
    }
    while(m--)
    {
      scanf("%d%d%d",&que,&b,&c);
      switch(que)
      {
         case 1:Change(1,b,c);break;//改变节点b的权值为c 
         case 2:printf("%d\n", QSum(1,b,c));break;//计算b至c范围内的权值和 
         case 3:printf("%d\n", QMax(1,b,c));break;//计算b至c范围内的最大权值 
      }
    }
    return 0;
}
void Build(int n,int l,int r)//构建一棵范围在l至r范围的线段树 
{
     a[n].l=l;//左边距 
     a[n].r=r;//右边距 
     a[n].sum=0;//范围在l至r之间权值和 
     a[n].max=0;//范围在l至r之间权值最大值 
     if(l==r)//如果左右边距相同不再构建孩子 
     return;
     Build(n*2,l,(l+r)/2);//构建范围为l至(l+r)/2的左孩子 
     Build(n*2+1,(l+r)/2+1,r);//构建范围为l至(l+r)/2的右孩子 
}
void Insert(int n, int v, int num)//为线段树插入一个值 
{
    a[n].sum += num;//总和加入新数 
    if(a[n].max < num)
    a[n].max = num;//更新最大值 
    if(a[n].l == a[n].r)//左右边距相等不再插入更新 
    return;
    if(v <= (a[n].l + a[n].r) / 2)
    Insert(n*2, v, num);//更新左孩子 
    else
    Insert(n*2+1, v, num);//更新右孩子 
}
void Change(int n, int v, int num)//为线段树改变一个权值  
{
    if(v == a[n].l && v == a[n].r)//下标与左右范围相等 ，存本数 
    {
        a[n].sum = num;
        a[n].max = num;
        return;
    }
    int middle = (a[n].l + a[n].r) / 2;
    if(v <= middle)
    Change(n*2, v, num);//更改左孩子 
    else
    Change(n*2+1, v, num);//更改右孩子 
    a[n].sum = a[n*2].sum + a[n*2+1].sum;//更新总和 
    a[n].max = Testmax(a[n*2].max,a[n*2+1].max);//更新最大值 
}
int QSum(int n, int l, int r)//求一个范围内的权值总和 
{
    if(l == a[n].l && r == a[n].r)//所求范围与左右范围相等 ，直接输出总和 
    return a[n].sum;
    int middle = (a[n].l + a[n].r) / 2;
    if(r <= middle)
    return QSum(n*2, l, r);//若所求范围在左孩子范围内，从左孩子寻找 
    else if(l > middle)
    return QSum(n*2+1, l, r);//若所求范围在右孩子范围内，从右孩子寻找 
    else return QSum(n*2,l,middle) + QSum(n*2+1,middle+1,r);//若范围在左右孩子之间，分别求总和 
}
int QMax(int n, int l, int r)//计算b至c范围内的最大权值 
{
    if(l == a[n].l && r == a[n].r)//所求范围与左右范围相等 ，直接输出最大值 
    return a[n].max;
    int middle = (a[n].l + a[n].r) / 2;
    if(r <= middle)
    return QMax(n*2, l, r);//若所求范围在左孩子范围内，从左孩子寻找 
    else if(l > middle)
    return QMax(n*2+1, l, r);//若所求范围在右孩子范围内，从右孩子寻找
    else 
    return Testmax(QMax(n*2, l, middle), QMax(n*2+1, middle+1, r));//若范围在左右孩子之间，分别求最大值，然后求最终最大值 
}




算法训练 操作格子 线段树 单点修改，求区间和，区间最大值
.
03-14 3178
算法训练 操作格子   时间限制：1.0s   内存限制：256.0MB        问题描述 有n个格子，从左到右放成一排，编号为1-n。 共有m次操作，有3种操作类型： 1.修改一个格子的权值， 2.求连续一段格子权值和， 3.求连续一段格子的最大值。 对于每个2、3操作输出你所求出的结果。 输入格式 第一
线段树模板（Java）
Easenyang的博客
12-06 3015
  线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。它的主要优势是对于区间求和、区间求最大值、区间修改和单点修改的速度快，时间复杂度能达到O(logN)O(logN)O(logN)。   若以常规的方法在数组中进行区间求和等操作，时间复杂度会达到O(n)O(n)O(n)，若操作的次数量非常大，那么就很容易超时。线段树的优势就体现出来了   线段树的实现基于一维数组，用数组下标 2∗k+12 * k +12∗k+1 的元素代表左儿子，用下标 2∗k+
蓝桥杯 - 操作格子 （线段树）
Never say never
05-14 1079
题目传送：操作格子 思路：简单线段树，单点更新，区间求和以及最值 AC代码： #include #include #include #include #include #include #include #include #include #include #include #include #define LL long long #define
Algo-8-操作格子
fattiger520的博客
02-04 321
问题描述 有n个格子，从左到右放成一排，编号为1-n。 共有m次操作，有3种操作类型： 1.修改一个格子的权值， 2.求连续一段格子权值和， 3.求连续一段格子的最大值。 对于每个2、3操作输出你所求出的结果。 输入格式 第一行2个整数n，m。 接下来一行n个整数表示n个格子的初始权值。 接下来m行，每行3个整数p,x,y，p表示操作类型，p=1时表示修改格子x的权值为y，p=2时表示求区间[x...
java实现 蓝桥杯 算法训练 操作格子
热门推荐
南 墙
07-22 1万+
问题描述 有n个格子，从左到右放成一排，编号为1-n。 共有m次操作，有3种操作类型： 1.修改一个格子的权值， 2.求连续一段格子权值和， 3.求连续一段格子的最大值。 对于每个2、3操作输出你所求出的结果。 输入格式 第一行2个整数n，m。 接下来一行n个整数表示n个格子的初始权值。 接下来m行，每行3个整数p,x,y，p表示操作类型，p=1时表示修改格子x的权值为y，p=2时表示求区间[x,...
蓝桥杯-算法训练 操作格子
程序猿之洞
01-22 8489
算法训练 操作格子   时间限制：1.0s   内存限制：256.0MB        问题描述 有n个格子，从左到右放成一排，编号为1-n。 共有m次操作，有3种操作类型： 1.修改一个格子的权值， 2.求连续一段格子权值和， 3.求连续一段格子的最大值。 对于每个2、3操作输出你所求出的结果。 输入格式 第一行2个整数n，m。 接下来一行n个整数表示n个格子的初始权值。
蓝桥杯-操作格子（java）
好好学java
03-31 639
算法训练 操作格子 时间限制：1.0s 内存限制：256.0MB 问题描述 有n个格子，从左到右放成一排，编号为1-n。 共有m次操作，有3种操作类型： 1.修改一个格子的权值， 2.求连续一段格子权值和， 3.求连续一段格子的最大值。 对于每个2、3操作输出你所求出的结果。 输入格式 第一行2个整数n，m。 接下来一行n个整...
蓝桥杯：操作格子（线段树）
08-14
蓝桥杯是全国性的计算机科学和信息技术竞赛，操作格子（线段树）是蓝桥杯中的一个题目。这道题目一般是要求用线段树的思想解决某种操作格子的问题。 具体来说，操作格子问题通常给出一个二维矩阵，矩阵中的每个格子...
24.6.2（动态开点线段树）
最新发布
breath_of_yuan的博客
06-03 1501
注意二分配线段树 O(log^2 * q)的复杂度会T，但结果一直显示的re，所以一直以为是空间没开够，但N*207已经是极限了（实测，一度怀疑动态开点线段树的空间复杂度到底怎么算（现在也还没明白），后来试了下线段树上二分，就过了。有几个需要注意下的点，第一是传送门设置的传送位置不同方案也不同，所以放置传送门时转移需乘上 ( i-1)，第二是内存限制很小，第一维需要滚动，第三是多组样例，记得输出换行符。19届东南校赛 B。23百度之星 切蛋糕。百度之星20年 chess。23年百度之星 第五维度。
操作格子
amnpxlp3049的博客
03-17 191
一、题目分析 　　刚刚看完题目的时候，我立马想到的是用数组来存储 n 个格子的权值，但是，这样做的话，没有办法在时间限制的 1s 完成操作，出现运行超时。 　　这是因为题目的数据规模与约定是：对于 100% 的数据 1 <= n <= 100000，m <= 100000，0 <= 格子权值 <= 10000。详细分析如下： 　　由题目可知：...
蓝桥杯 操作格子
zyq_19960204的博客
04-13 342
问题描述 有n个格子，从左到右放成一排，编号为1-n。 共有m次操作，有3种操作类型： 1.修改一个格子的权值， 2.求连续一段格子权值和， 3.求连续一段格子的最大值。 对于每个2、3操作输出你所求出的结果。 输入格式 第一行2个整数n，m。 接下来一行n个整数表示n个格子的初始权值。 接下来m行，每行3个整数p,x,y，p表示操作类型，p=1
蓝桥杯 操作格子（单点更新）
BorntoDo的博客
04-02 668
算法训练 操作格子   时间限制：1.0s   内存限制：256.0MB        问题描述 有n个格子，从左到右放成一排，编号为1-n。 共有m次操作，有3种操作类型： 1.修改一个格子的权值， 2.求连续一段格子权值和， 3.求连续一段格子的最大值。 对于每个2、3操作输出你所求出的结果。 输入格式 第一
蓝桥杯-操作格子（线段树）
Jaster_wisdom的专栏
03-19 508
题目大意：多次求出定区间上的最大值和区间上元素之和。因为这里可能求解的次数达到100000次，而数组长度最大也为100000，我们知道求最大值和元素之和，若是用数组存储，最快也要O(n)的时间才能完成，这样的话，必然超时。题目分析：根据提示，我们使用线段树来解决，使得在区间上求和、求最大值的时间复杂度在O(logn)建立线段树、插值、查询最大值、查询和都需要递归操作，对一个树的操作，就是分别对于左...
蓝桥杯《操作格子》
Uncle_Xiang的博客
04-17 640
解题过程：题意通俗易懂，看完题目以为是普通的对数组进行操作的题目，但是看到输入的数据范围后，发现并不是。但是因为没有好的想法，只能用最简单的方式做，毫无意外的超时了。然后找到这篇博文：http://blog.csdn.net/qq_33245342/article/details/54892576   问题描述  有n个格子，从左到右放成一排，编号为1-n。 共有m次操作，有3种操作类型： 1
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值