Sequence

最新推荐文章于 2024-08-08 15:12:59 发布
最新推荐文章于 2024-08-08 15:12:59 发布
阅读量335 收藏 5
点赞数 7
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lanthamum/article/details/140947211
版权

登录—专业IT笔试面试备考平台_牛客网 2020江西省H

主要是询问

答案是(X-L+1)*(R-X+1)

找到小于a[x]的第一个位置(1,x-1) L 

找到小于a[x]的第一个位置(x+1,n) R

有单调性，范围越大，最小值越小，因此可以二分

时间复杂度O(nlognlogn) 600ms

// Problem: Sequence
// Contest: NowCoder
// URL: https://ac.nowcoder.com/acm/contest/8827/H
// Memory Limit: 262144 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//线段树
#include<iostream>
using namespace std;
const int N=1e5+9;
int a[N];
struct SEG{
    #define INF (1<<31)
    #define ll long long
    #define tl(id) (id<<1)
    #define tr(id) (id<<1|1)
    #define li inline
    struct node{
        int l,r;
        ll mn,index;
    }seg[N<<2];
    li bool inrange(int L,int R,int l,int r){return l<=L && R<=r;}
    li bool outofrange(int L,int R,int l,int r){return L>r || R<l;}
    li void pushup(node &id,node &l,node &r){
    	id.mn=min(l.mn,r.mn);
    }
    li void pushup(const int id){
        pushup(seg[id],seg[tl(id)],seg[tr(id)]);
    }
    li void build(const int id,int l,int r){
    	seg[id]={l,r};
        if(l==r){
            seg[id].mn=a[l];
            seg[id].index=l;
            return;
        }
        int mid=(l+r)>>1;
        build(tl(id),l,mid);
        build(tr(id),mid+1,r);
        pushup(id);
    }
   	li auto query(int id,int l,int r){//一开始想直接找位置所以写了一个结构体...
   		if(inrange(seg[id].l,seg[id].r,l,r)){
   			return seg[id];
   		}else{
   			int mid=(seg[id].l+seg[id].r)>>1;
   			if(mid>=r){
   				return query(tl(id),l,r);
   			}else if(mid<l){
   				return query(tr(id),l,r);
   			}else{
   				node res;
   				node left=query(tl(id),l,mid);
   				node right=query(tr(id),mid+1,r);
   				pushup(res,left,right);
   				return res;
   			}
   		}
   	}
    li void update(int id,int l,int r,int pos,ll v){
		if(l==r){
			seg[id].mn=v;
			return;
		}
		int mid=(l+r)>>1;
		if(mid>=pos){
			update(tl(id),l,mid,pos,v);
		}else{
			update(tr(id),mid+1,r,pos,v);
		}
		pushup(id);
    }
    li ll ask(int id,int l,int r,int pos){
    	if(l==r){
    		return seg[id].mn;
    	}
    	int mid=(l+r)>>1;
    	if(mid>=pos){
    		return ask(tl(id),l,mid,pos);
    	}else{
    		return ask(tr(id),mid+1,r,pos);
    	}
    }
}t;
int main(){
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	t.build(1,1,n);
	for(int i=1;i<=m;i++){
		int opt;
		cin>>opt;
		if(opt==1){
			int x,y;
			cin>>x>>y;
			t.update(1,1,n,x,y);
		}else{
			ll x;
			cin>>x;
			int val=t.ask(1,1,n,x);
			int l=x;
			int r=n;
			ll R=0;
			while(l<=r){
				int mid=(l+r)>>1;
				if(t.query(1,x,mid).mn==val){
					l=mid+1;
					R=mid;
				}else{
					r=mid-1;
				}
			}
			ll L=0;
			l=1;
			r=x;
			while(l<=r){
				int mid=(l+r)>>1;
				if(t.query(1,mid,x).mn==val){
					r=mid-1;
					L=mid;
				}else{
					l=mid+1;
				}
			}
			// cout<<L<<" "<<R<<'\n';
			ll ans=(x-L+1)*(R-x+1);
			cout<<ans<<'\n';
		}
	}
}

可以把二分放到线段树里，时间复杂度O(nlogn) 300ms

// Problem: Sequence
// Contest: NowCoder
// URL: https://ac.nowcoder.com/acm/contest/8827/H
// Memory Limit: 262144 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

//线段树
#include<iostream>
using namespace std;
const int N=1e5+9;
int a[N];
int n,m;
struct SEG{
    #define INF (1<<31)
    #define ll long long
    #define tl(id) (id<<1)
    #define tr(id) (id<<1|1)
    #define li inline
    struct node{
        int l,r;
        ll mn,index;
    }seg[N<<2];
    li bool inrange(int L,int R,int l,int r){return l<=L && R<=r;}
    li bool outofrange(int L,int R,int l,int r){return L>r || R<l;}
    li void pushup(node &id,node &l,node &r){
    	id.mn=min(l.mn,r.mn);
    }
    li void pushup(const int id){
        pushup(seg[id],seg[tl(id)],seg[tr(id)]);
    }
    li void build(const int id,int l,int r){
    	seg[id]={l,r};
        if(l==r){
            seg[id].mn=a[l];
            seg[id].index=l;
            return;
        }
        int mid=(l+r)>>1;
        build(tl(id),l,mid);
        build(tr(id),mid+1,r);
        pushup(id);
    }
   	li auto query(int id,int l,int r){
   		if(inrange(seg[id].l,seg[id].r,l,r)){
   			return seg[id];
   		}else{
   			int mid=(seg[id].l+seg[id].r)>>1;
   			if(mid>=r){
   				return query(tl(id),l,r);
   			}else if(mid<l){
   				return query(tr(id),l,r);
   			}else{
   				node res;
   				node left=query(tl(id),l,mid);
   				node right=query(tr(id),mid+1,r);
   				pushup(res,left,right);
   				return res;
   			}
   		}
   	}
    li void update(int id,int l,int r,int pos,ll v){
		if(l==r){
			seg[id].mn=v;
			return;
		}
		int mid=(l+r)>>1;
		if(mid>=pos){
			update(tl(id),l,mid,pos,v);
		}else{
			update(tr(id),mid+1,r,pos,v);
		}
		pushup(id);
    }
    li ll ask(int id,int l,int r,int pos){
    	if(l==r){
    		return seg[id].mn;
    	}
    	int mid=(l+r)>>1;
    	if(mid>=pos){
    		return ask(tl(id),l,mid,pos);
    	}else{
    		return ask(tr(id),mid+1,r,pos);
    	}
    }
    li ll lquery(int id,int l,int r,int pos,int v){
    	if(l==r){
    		return l;
    	}
    	int mid=(l+r)>>1;
    	ll ans=l;
    	if(seg[tr(id)].mn<v && mid<pos){
    		ans=lquery(tr(id),mid+1,r,pos,v);
    		if(ask(1,1,n,ans)<v){
    			return ans;
    		}else{
    			ans=l;
    		}
    	}
    	if(seg[tl(id)].mn<v){
    		ans=lquery(tl(id),l,mid,pos,v);
    	}
    	return ans;
    }
    li ll rquery(int id,int l,int r,int pos,int v){
    	if(l==r){
    		return l;
    	}
    	int mid=(l+r)>>1;
    	ll ans=r;
    	if(seg[tl(id)].mn<v && mid>=pos){
    		ans=rquery(tl(id),l,mid,pos,v);
    		if(ask(1,1,n,ans)<v){
    			return ans;
    		}else{
    			ans=r;
    		}
    	}
    	if(seg[tr(id)].mn<v){
    		ans=rquery(tr(id),mid+1,r,pos,v);
    	}
    	return ans;
    }
}t;
int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	t.build(1,1,n);
	for(int i=1;i<=m;i++){
		int opt;
		cin>>opt;
		if(opt==1){
			int x,y;
			cin>>x>>y;
			t.update(1,1,n,x,y);
		}else{
			ll x;
			cin>>x;
			int val=t.ask(1,1,n,x);
			ll L=t.lquery(1,1,n,x-1,val);
			ll R=t.rquery(1,1,n,x+1,val);
			// cout<<L<<" "<<R<<'\n';
			int val1=t.ask(1,1,n,L);
			int val2=t.ask(1,1,n,R);
			// cout<<val1<<" "<<val2<<'\n';
			if(val1<val){
				L++;
			}
			if(val2<val){
				R--;
			}
			// cout<<L<<" "<<R<<'\n';
			ll ans=(x-L+1)*(R-x+1);
			cout<<ans<<'\n';
		}
	}
}

Lanthanmum
关注
  • 7
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Kotlin】Sequence简介
little_fat_sheep
03-30 1008
序列（Sequence）是 Kotlin 中为方便操作集合及其元素而定制的接口，是一个延迟获取数据的集合，只有需要元素时才会生产元素。在处理大量数据时，序列可以显著地提升性能。Sequence 类似 Java 中的 Stream，详见 →。Sequence 有中间操作和终端操作，如下。中间操作终端操作。
sequence基础
Sisyphus415的博客
03-31 1499
sequence基础用法及相关宏的使用
sequence进阶
Sisyphus415的博客
03-31 4072
sequence进阶应用
sqlalchemy sequence
雨禾
03-08 1215
1 序列对象 1.1 创建连接 import sqlalchemy uri = "postgresql://test:123456@127.0.0.1:5432/test" engine = sqlalchemy.create_engine( uri, pool_size = 80, max_overflow = 20, pool_recycle = 3600 ) 1.2 创建序列 from sqlalchemy import Sequence seq = Sequence('SEQ_01') # 创建名
数据库Sequence创建与使用
AndroidOrCsharp
02-28 5443
Oracle的sequence序列号，一般用于类似 自增ID 等值增长的字段； 在Oracle中sequence就是序号，每次提取完都会自动增加，步幅固定，它与表没有直接关系！ 创建sequence语句： CREATESEQUENCE seq_name--seq_name为计数器的名字，自定； INCREMENTBY1--每次加幅度:1,2,3,....； STARTWITH1--起始序号，以实际生产情况而定； NOMAXvalue--不设置最大值，或设定最大值： maxva...
SequenceDiagram
02-06
序列图（Sequence Diagram）是UML（统一建模语言）中的一个重要工具，它主要用于描述系统中对象间的交互顺序，展示了对象如何以时间顺序进行通信。序列图通过垂直线表示对象，水平箭头表示消息传递，以此来清晰地...
SequenceDiagram.zip
03-06
**序号图（Sequence Diagram）**是统一建模语言（UML）中的一种图形表示，用于描述系统中对象之间的交互顺序。它清晰地展现了不同对象如何通过消息传递进行通信，以及这些消息的时间顺序。在软件设计和分析阶段，...
sequence-diagram.zip
08-27
《序列图绘制工具sequence-diagram-js的深度解析与应用》 序列图，作为一种重要的系统建模工具，广泛应用于软件设计和开发中，它清晰地展示了系统内各对象间交互的顺序。sequence-diagram-js是一个基于JavaScript的...
sqlserver实现oracle的sequence方法
09-10
在Oracle数据库中，Sequence是一种非常方便的对象，用于生成序列化的唯一数字，通常用于主键或者唯一标识符。然而，SQL Server并不直接支持Sequence对象。在SQL Server中，开发者经常使用Identity列来达到类似的效果...
SequenceDiagram-3.0.5.zip
05-25
SequenceDiagram-3.0.5.zip 是一个包含 Sequence Diagram 相关工具或资源的压缩包文件，主要用于绘制序列图，这是UML（统一建模语言）中的一种图表，用于描述对象之间的交互和消息传递顺序。在软件开发过程中，序列...
CSP 2020 第三题：表达式
m0_46183615的博客
08-03 536
CSP 2020 第三题：表达式
VRF 算法流程及代码实现
smilejiasmile的博客
08-03 230
Verifiable Random Functions (VRFs) 是一种密码学原语，能够为给定输入生成一个随机输出，并提供一个可以验证的证明，证明输出是由特定输入生成的。VRFs 具有许多应用，包括区块链、分布式系统和安全协议。使用secp256k1曲线可以产生确定性签名，适用于 VRF 实现。通过使用 HMAC-SHA256 生成确定性随机数k，可以确保签名过程对相同的输入始终产生相同的结果，从而满足 VRF 的要求。
day 9 回溯算法
最新发布
m0_73924943的博客
08-08 122
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
【算法】动态规划解决背包问题
2302_78914800的博客
08-04 441
1.动态规划算法的核心是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法2.动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解3.与分治算法不同的是，适合于用动态规划求解的问题，经分解得到的子问题往往不是相互独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）4.动态规划可以通过填表的方式来逐步推进，得到最优解。
学习笔记--算法（双指针）5
weixin_71085457的博客
08-04 649
学习自用！！
【算法】分治算法以及用分治算法解决汉诺塔问题
2302_78914800的博客
08-04 235
分治算法的思想是 “ 分而治之 ” ，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题......知道最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础。
HDU - 2057 (纯C语言模拟16进制加减法)
qq_62224565的博客
08-05 312
首先将16进制转成10进制，再将10进制转成16进制。有个问题就是题目说输入不超过15位，但是。第二，使用abs函数时注意，当数爆int时，用long long 储存使用abs会有误。第一，多组输入注意清空字符数组，令每个字符等于’\0’即可。纯模拟，过了后发现可以用%x，直接输入输出。第三，模拟时记得用long long。以前做题没有怎么用C写过HDU的题。就是求16进制的加法。
代码随想录算法训练营day36：动态规划04：1049.最后一块石头的重量II；494.目标和；474.一和零
weixin_65180740的博客
08-07 785
力扣题目链接(opens new window)有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x!= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。输入：[2,7,4,1,8,1]输出：1。
网络流算法：最大流问题
qq_40254606的博客
08-05 623
在一个流网络中，每条边有一个容量，表示该边能够承载的最大流量。容量限制：流量不能超过边的容量。流量守恒：除源点和汇点外，每个顶点的流入量等于流出量。Ford-Fulkerson算法是一种贪心算法，用于解决最大流问题。其核心思想是不断寻找增广路径，直到找不到新的增广路径为止。Edmonds-Karp算法是Ford-Fulkerson算法的一个具体实现，使用广度优先搜索（BFS）来寻找增广路径。该算法的时间复杂度为 (O(VE^2))，其中 (V) 是顶点数，(E) 是边数。
ply sequence
12-02
Ply sequence 是指多层序列的概念，通常用于描述需要多次迭代或循环操作的数据结构。在计算机科学领域，ply sequence 可以被理解为一个包含多个子序列的序列。这种数据结构可以用来表示不同级别的层次结构或者复杂的嵌套关系。 举个例子，我们可以将一部小说分为章节、段落和句子。这样的层次关系就可以用 ply sequence 来表示，其中最外层是章节，然后是段落，再是句子。这种结构可以帮助我们更好地管理和组织数据，方便进行迭代操作和数据访问。 在编程中，我们经常会用到 ply sequence 这样的数据结构来处理复杂的问题。比如在处理树形结构、图形结构或者嵌套列表的时候，ply sequence 可以为我们提供一种更灵活的数据表示方式。有了 ply sequence，我们就可以更方便地对数据进行操作，例如搜索、遍历、过滤等等。 总而言之，ply sequence 是一种非常有用的数据结构，可以帮助我们更好地组织和管理数据，在处理复杂问题时提供更灵活的解决方案。通过 ply sequence，我们可以更高效地进行数据操作和处理，从而提高编程效率和代码质量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值