hdu5828 Rikka with Sequence（线段树）

最新推荐文章于 2019-09-10 21:44:05 发布
最新推荐文章于 2019-09-10 21:44:05 发布
阅读量744 收藏
点赞数
分类专栏： 数据结构-线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21057881/article/details/52186751
版权

思路：HDU4027的升级版，多了一个区间add的操作，考虑一下显然开根号的递减速度是很快的，2^64最多不超过8次就能减到1，而且会出现很多区间的数字都是一样的情况，那么可以在线段树多维护一个flag值，表示区间里面是否所有数都是相等的，如果是的话那么开根号就只开到这里就行了，具体实现细节还是蛮多的....


后来HDU加数据了，比如2 3 2 3 2 3然后整体加6然后开根号，又会变回2 3 2 3 2 3相当于不会出现区间数字一样的情况了，这样就相当于没剪枝，变成了n^2...后来发现只有极差为1的时候才会出现这种情况，极差>1的话是不可能维持原来的序列的，那么就可以维护一个最大值和最小值，如果极差为1的话那么区间开根号其实相当于区间减去了x-sqrt(x)，再加上第一个版本的剪枝就可以2000MS左右过去了

第一版本（TLE）：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 100000+50;
#define LL long long
#define eps 1e-8
#define LL long long
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
LL sum[maxn<<2],lazy[maxn<<2],flag[maxn<<2];

void push_up(int i)
{
    sum[i]=sum[i<<1]+sum[i<<1|1];
	if(flag[i<<1]==flag[i<<1|1])
		flag[i]=flag[i<<1];
	else
		flag[i]=0;
}
void pushdown(int r,int m)
{
     if(flag[r])
	 {
		 flag[r<<1]=flag[r];
		 flag[r<<1|1]=flag[r];
		 sum[r<<1]=flag[r]*(m-m/2);
		 sum[r<<1|1]=flag[r]*(m/2);
		 lazy[r]=0;
	 }
	 if(lazy[r])
	 {
		 lazy[r<<1]+=lazy[r];
		 lazy[r<<1|1]+=lazy[r];
		 if(flag[r<<1])
			 flag[r<<1]+=lazy[r];
		 if(flag[r<<1|1])
			 flag[r<<1|1]+=lazy[r];
		 sum[r<<1]+=lazy[r]*(m-m/2);
		 sum[r<<1|1]+=lazy[r]*(m/2);
		 lazy[r]=0;
	 }
}
void build(int i,int l,int r)
{
     lazy[i]=0;
	 flag[i]=0;
	 if(l==r)
	 {
		 scanf("%d",&sum[i]);
		 flag[i]=sum[i];
		 return;
	 }
	 int mid = (l+r)>>1;
	 build(lson);
	 build(rson);
	 push_up(i);
}

void update(int ql,int qr,int v,int i,int l,int r)
{
     if(ql<=l && qr>=r)
	 {
		 sum[i]+=1LL*(r-l+1)*v;
		 lazy[i]+=v;
		 if(flag[i])
			 flag[i]+=v;
		 return;
	 }
	 pushdown(i,r-l+1);
	 int mid = (l+r)>>1;
	 if(ql<=mid)
		 update(ql,qr,v,lson);
	 if(qr>mid)
		 update(ql,qr,v,rson);
	 push_up(i);
}

void update1(int ql,int qr,int i,int l,int r)
{
     if(ql<=l && qr>=r && flag[i])
	 {
		 flag[i]=(sqrt(flag[i])+eps);
		 sum[i]=1LL*flag[i]*(r-l+1);
		 return;
	 }
	 pushdown(i,r-l+1);
	 int mid = (l+r)>>1;
	 if(ql<=mid)
		 update1(ql,qr,lson);
	 if(qr>mid)
		 update1(ql,qr,rson);
	 push_up(i);
}
LL query(int ql,int qr,int i,int l,int r)
{
    if(ql<=l && qr>=r)
		return sum[i];
	pushdown(i,r-l+1);
	int mid = (l+r)>>1;
	LL ans = 0;
	if(ql<=mid)
		ans+=query(ql,qr,lson);
	if(mid<qr)
		ans+=query(ql,qr,rson);
	return ans;
}

int main()
{
    int T;
	scanf("%d",&T);
	while(T--)
	{
		int n,q;
		scanf("%d%d",&n,&q);
		build(1,1,n);
		while(q--)
		{
			int x,y,w,op;
			scanf("%d",&op);
			if(op==1)
			{
				scanf("%d%d%d",&x,&y,&w);
				update(x,y,w,1,1,n);
			}
			if(op==2)
			{
				scanf("%d%d",&x,&y);
				update1(x,y,1,1,n);
			}
			if(op==3)
			{
				scanf("%d%d",&x,&y);
				printf("%lld\n",query(x,y,1,1,n));
			}
		}
	}
}


更新版：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 100000+50;
#define LL long long
#define eps 1e-8
#define LL long long
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
LL sum[maxn<<2],lazy[maxn<<2],maxx[maxn<<2],minn[maxn<<2];
const int read()
{
	char ch = getchar();
	while (ch<'0' || ch>'9') ch = getchar();
	int x = ch - '0';
	while ((ch = getchar()) >= '0'&&ch <= '9') x = x * 10 + ch - '0';
	return x;
}

void push_up(int i)
{
	maxx[i]=max(maxx[i<<1],maxx[i<<1|1]);
	minn[i]=min(minn[i<<1],minn[i<<1|1]);
    sum[i]=sum[i<<1]+sum[i<<1|1];
}
void pushdown(int r,int m)
{
	 if(lazy[r])
	 {
		 lazy[r<<1]+=lazy[r];
		 maxx[r<<1]+=lazy[r];
		 maxx[r<<1|1]+=lazy[r];
		 minn[r<<1]+=lazy[r];
		 minn[r<<1|1]+=lazy[r];
		 lazy[r<<1|1]+=lazy[r];
		 sum[r<<1]+=lazy[r]*(m-m/2);
		 sum[r<<1|1]+=lazy[r]*(m/2);
		 lazy[r]=0;
	 }     
     if(minn[r]==maxx[r])
	 {
		 minn[r<<1]=maxx[r<<1]=minn[r<<1|1]=maxx[r<<1|1]=minn[r];
		 sum[r<<1]=minn[r]*(m-m/2);
		 sum[r<<1|1]=maxx[r]*(m/2);
	 }
}
void build(int i,int l,int r)
{
     lazy[i]=0;
	 if(l==r)
	 {
		 scanf("%d",&sum[i]);
		 minn[i]=sum[i];
		 maxx[i]=sum[i];
		 return;
	 }
	 int mid = (l+r)>>1;
	 build(lson);
	 build(rson);
	 push_up(i);
}

void update(int ql,int qr,int v,int i,int l,int r)
{
     if(ql<=l && qr>=r)
	 {
		 minn[i]+=v;
		 maxx[i]+=v;
		 sum[i]+=1LL*(r-l+1)*v;
		 lazy[i]+=v;
		 return;
	 }
	 pushdown(i,r-l+1);
	 int mid = (l+r)>>1;
	 if(ql<=mid)
		 update(ql,qr,v,lson);
	 if(qr>mid)
		 update(ql,qr,v,rson);
	 push_up(i);
}

void update1(int ql,int qr,int i,int l,int r)
{
     if(ql<=l && qr>=r)
	 {
		 if((int)sqrt(minn[i]) == (int)sqrt(maxx[i]))
		 {
			 minn[i]=maxx[i]=(int)sqrt(minn[i]);
			 sum[i]=minn[i]*(r-l+1);
		 }
		 else if(minn[i]+1==maxx[i])
		 {
			 int k = maxx[i]-(int)sqrt(maxx[i]);
			 update(ql,qr,-k,i,l,r);
		 }
		 else
		 {
	         pushdown(i,r-l+1);
			 int mid = (l+r)>>1;
			 if(ql<=mid)update1(ql,qr,lson);
			 if(qr>mid)update1(ql,qr,rson);
			 push_up(i);
		 }
		 return;
	 }
	 pushdown(i,r-l+1);
	 int mid = (l+r)>>1;
	 if(ql<=mid)
		 update1(ql,qr,lson);
	 if(qr>mid)
		 update1(ql,qr,rson);
	 push_up(i);
}
LL query(int ql,int qr,int i,int l,int r)
{
    if(ql<=l && qr>=r)
		return sum[i];
	pushdown(i,r-l+1);
	int mid = (l+r)>>1;
	LL ans = 0;
	if(ql<=mid)
		ans+=query(ql,qr,lson);
	if(mid<qr)
		ans+=query(ql,qr,rson);
	return ans;
}

int main()
{
    int T;
	scanf("%d",&T);
	while(T--)
	{
		int n,q;
		scanf("%d%d",&n,&q);
	//	n = Scan();
	//	q = Scan();
		build(1,1,n);
		while(q--)
		{
			int x,y,w,op;
			scanf("%d",&op);
			if(op==1)
			{
				scanf("%d%d%d",&x,&y,&w);
			//	x = Scan();
			//	y = Scan();
			//	w = Scan();
				update(x,y,w,1,1,n);
			}
			if(op==2)
			{
				scanf("%d%d",&x,&y);
			//	x = Scan();
			//	y = Scan();
				update1(x,y,1,1,n);
			}
			if(op==3)
			{
				scanf("%d%d",&x,&y);
			//	x = Scan();
			//	y = Scan();
				printf("%lld\n",query(x,y,1,1,n));
			}
		}
	}
}


Problem Description
As we know, Rikka is poor at math. Yuta is worrying about this situation, so he gives Rikka some math tasks to practice. There is one of them:

Yuta has an array A with n numbers. Then he makes m operations on it. 

There are three type of operations:

1 l r x : For each i in [l,r], change A[i] to A[i]+x
2 l r : For each i in [l,r], change A[i] to  ⌊A−−√[i]⌋
3 l r : Yuta wants Rikka to sum up A[i] for all i in [l,r]

It is too difficult for Rikka. Can you help her?
 

Input
The first line contains a number t(1<=t<=100), the number of the testcases. And there are no more than 5 testcases with n>1000.

For each testcase, the first line contains two numbers n,m(1<=n,m<=100000). The second line contains n numbers A[1]~A[n]. Then m lines follow, each line describe an operation.

It is guaranteed that 1<=A[i],x<=100000.
 

Output
For each operation of type 3, print a lines contains one number -- the answer of the query.
 

Sample Input 
  
  

   
   1
5 5
1 2 3 4 5
1 3 5 2
2 1 4
3 2 4
2 3 5
3 1 5
 

Sample Output 
  
  

   
   5
6
 

Author
学军中学
 

围巾的ACM
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
03-05
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
HDU 5828 Rikka with Sequence（线段树+小优化）
CerberuX's Life
08-11 777
Problem Description As we know, Rikka is poor at math. Yuta is worrying about this situation, so he gives Rikka some math tasks to practice. There is one of them:Yuta has an array A with n numbers. Th
【HDU 5828】Rikka with Sequence（线段树）
ACMer'
08-22 1783
【HDU 5828】Rikka with Sequence（线段树）Rikka with SequenceTime Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 2311    Accepted Submission(s): 391 Problem
HDU5828 区间开根加法求和 线段树
HbFS-
09-19 875
先需要想到一个结论： 对于线段树上的一块，进行整体开根和加法（加法不影响结果）的次数越多，区间的最大值与最小值的差越小。 利用这个性质，我们维护一棵线段树，线段树上维护区间最大值、最小值、和、元素个数。 对于建树、区间加法（修改）、区间查询，写法就是朴素的线段树 对于区间开根： 1、若区间最大值和最小值的差为0，即整个区间的所有元素相等。此时开根相当于区间覆盖同一个值。 2、若区间最大
Rikka with Sequence
weixin_30776863的博客
03-17 185
题意： 给一长度为n的序列，维护三个操作：区间开根，区间加，区间求和。 解法： 注意到本题关键在于区间开根： 对于一个数字，只要进行$O(loglogT)$次开根即会变为1。 考虑线段树，对于线段数上的点维护$maxv$，$minv$。 对于$[\sqrt{maxv}] = [\sqrt{minv}]$的点我们直接执行区间染色。 如果我们在开根时经过这个点则有$maxv - m...
【线段树】 HDU 5828
g21wcr的博客
10-24 126
传送门 【题目大意】支持区间开根，区间加，区间求和。 【思路】维护区间的最大最小值。对于开根操作。如果极差==0，那么就相当于区间加一个负数。如果极差==1，考虑开根后的极差。如果开根后极差仍为1，就还是一个区间加。如果开根后极差为0，那么就是区间覆盖。代码如下。 #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;iost...
hdu acm1166线段树
05-03
hdu 1166线段树代码
【题解】「HDU1166」敌兵布阵(线段树)
01-20
题面 【题目描述】 有nnn个营地，已知每个营地的人数，有四条命令： (1)Add(1) Add(1)Add iii jjj，iii和jjj为正整数,表示第iii个营地增加jjj个人（jjj不超过303030） (2)Sub(2)Sub(2)Sub iii jjj ，iii和jjj为正...
线段树入门
08-05
线段树入门资料，有利于初学者学习，让他们详细了解线段树。
[HDU5828]Rikka with Sequence
weixin_34096182的博客
03-13 105
题意：维护一个数列，支持区间加，区间开根下取整，区间求和 最暴力的想法当然是用线段树维护，对于开根，如果当前区间内的数全相同，那么打一个覆盖标记，否则递归处理 这样当然是会被卡掉的：对于数列$\{2,3,2,3,\cdots\}$，重复$+6$和开根操作，这样就可以把上面那种暴力做法卡掉了 但其实这种暴力已经离正解很近了，考虑维护区间极差，如果递归到当前区间的极差$\geq2$，那么按暴力的...
Hdu5828-Rikka with Sequence(线段树区间开方)
bairui0504的博客
10-22 222
写在前面ldx神犇今讲线段树，然后就涉及到了本题目的一个骚操作。 传送门Solution注意到本题实际上要求的是区间加，区间求和，区间开根号。前两个是常规操作，学了都会，然而怎样开根号？显然我们应该暴力修改开方这个操作本身进行考虑。那么注意到，开一次方，一个序列中的每个数逐步接近其他的数，所以说我们可以考虑这么干：对序列维护一个最大值与最小值，如果说他们开方以后最大值减去最小值的差大于...
省选专练之数据结构HDU5828
dingwufu9301的博客
07-23 110
Rikka with Sequence Time Limit: 6000/3000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Problem Description As we know, Rikka is poor at math. Yuta is worry...
hdu 5828
nare123的博客
02-11 265
维护区间和+最大最小值就行了.#include<stdio.h> #include<iostream> #include<algorithm> #include<string> #include<string.h> #include<math.h> using namespace std; #define INF 99999999 #define ll long long struct p{ i
【HDU 6087】—Rikka with Sequence（可持久化平衡树）
Stargazer的博客
09-10 325
传送门 可持久化平衡树 第三个操作只需要记录一个最开始版本的根就可以了 第二个操作实际上是把[l−k,l−1][l-k,l-1][l−k,l−1]复制多次 可以倍增复制 由于卡空间，定期重构平衡树 我写的非旋treaptreaptreap #include<bits/stdc++.h> using namespace std; const int RLEN=1<<20|1;...
HDU 5828 Rikka with Sequence（线段树 开根号）
weixin_34237596的博客
05-02 75
Rikka with Sequence Time Limit: 6000/3000 MS (Java/Others)Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 2777Accepted Submission(s): 503 Problem Description As we know, Rikka...
HDU5828 Rikka with Sequence
ShadyPi的IT笔记
08-17 332
原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=5828 Rikka with Sequence Problem Description As we know, Rikka is poor at math. Yuta is worrying about this situation, so he gives Rikka some math t...
hihoCoder挑战赛19 A Rikka with Sequence
dnvtmf的专栏
03-22 609
数位dp的题, 难
[HDU 5828] Rikka with Sequence （线段树）
生活不易，多才多艺
07-23 176
[HDU 5828] Rikka with Sequence U盘丢了不开心…励志以后每道题都要写博客…谁知道下一次什么丢了呢 【再见】 题意 三个操作：区间加、区间开方、区间求和 题解 考虑没有区间加怎么做（bzoj3211） 每个数最多开方 6 次，记录这个区间开方了几次，超过6就不做了 那么加上区间加的话，这样就会 t 了 然后我们考虑这一个区间数值一样的话，就维护这个一...
hdu1969 java
最新发布
10-17
好的，我明白了。针对你的问题，我猜测你是在问如何使用Java解决hdu1969这道题目。如果我的猜测正确，那么我可以给你一些思路和代码实现。 首先，我们需要明确题目的意思。题目要求我们求出一个多边形的面积，这个多边形由若干个点组成。我们可以使用海龙公式来计算多边形的面积，具体实现如下： ```java import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); while (n-- > 0) { int m = scanner.nextInt(); double x1 = scanner.nextDouble(); double y1 = scanner.nextDouble(); double x2 = scanner.nextDouble(); double y2 = scanner.nextDouble(); double x3 = scanner.nextDouble(); double y3 = scanner.nextDouble(); double a = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); double b = Math.sqrt((x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3)); double c = Math.sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3)); double p = (a + b + c) / 2; double s = Math.sqrt(p * (p - a) * (p - b) * (p - c)); System.out.printf("%.2f\n", s); } } } ``` 以上代码实现了对hdu1969题目的求解，你可以将其复制到你的Java IDE中进行编译和运行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值