HDU 4027 Can you answer these queries 线段树

最新推荐文章于 2021-11-15 22:13:06 发布
最新推荐文章于 2021-11-15 22:13:06 发布
阅读量928 收藏 1
点赞数
分类专栏： 线段树 文章标签： query build 优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tsaid/article/details/6768635
版权

题意：在一场战役中，敌方有一排编号为1至n的战舰。你的指挥官有两种命令: 1.下令使用秘密武器攻击敌方战舰，每次攻击使得敌方一定范围的所有战舰的耐久度降低至原来的平方根（若平方根不为整数，那么舍去后面的小数部分）。2.询问敌方一定范围内的所有战舰的耐久度之和。
题解：网赛卡在这道题上了。泪流满面呀。稍不注意就TL, 超时的代码也贴出来，吸取教训···。
640ms，把down函数内联可以到500几吧。

#include <cmath>
#include <iostream>
using namespace std;

#define lint __int64
#define L(u) (u<<1)
#define R(u) (u<<1|1)
#define max(a,b) (a>b?a:b)
#define N  200005

lint sum[N][10];
lint array[N][10];
lint maxNum, maxSqrt;

struct Node
{
    int l, r, v, add, flag; /* flag == 1说明节点内部所有点的v值一样，即受到攻击次数一样 */
} node[N*4];

void build ( int u, int l, int r )
{
    node[u].l = l;
    node[u].r = r;
    node[u].v = node[u].add = 0;
	node[u].flag = 1;
    if ( l == r ) return;
    lint mid = ( l + r ) >> 1;
    build ( L(u), l, mid );
    build ( R(u), mid+1, r );
}

void down ( int u )
{
	if ( node[u].add != 0 )
	{
		node[L(u)].v += node[u].add;
		node[R(u)].v += node[u].add;
		node[L(u)].add += node[u].add;
		node[R(u)].add += node[u].add;
		node[u].add = 0;
	}
	node[u].flag = -1; /* 每次向下更新时，因为节点内部的 v 不可能全部一样了，所以需要把 flag 置为 -1 */
}

void update ( int u, int l, int r )
{
    if ( (l == node[u].l && node[u].r == r) || node[u].l == node[u].r  )
    {
		node[u].v++;
		node[u].add++;
        return;
    }
	
	down(u);
	
    int mid = ( node[u].l + node[u].r ) >> 1;
    if ( r <= mid )
        update ( L(u), l, r );
    else if ( l > mid )
        update ( R(u), l, r );
    else
    {
        update ( L(u), l, mid );
        update ( R(u), mid+1, r );
    }
}

lint query ( int u, int l, int r )
{
    if ( l == node[u].l && node[u].r == r )
    {
		if ( node[u].v >= maxSqrt )
			node[u].v = maxSqrt;
		if ( node[u].v == maxSqrt || node[u].l == node[u].r || node[u].flag == 1 )
			return sum[r][node[u].v] - sum[l-1][node[u].v];
		
		down(u);
        return query( L(u), l, (l+r)/2 ) + query( R(u), (l+r)/2+1, r );
    }
	
	down(u);
	
    int mid = ( node[u].l + node[u].r ) >> 1;
    if ( r <= mid )
        return query ( L(u), l, r );
    else if ( l > mid )
        return query ( R(u), l, r );
    else
        return query ( L(u), l, mid ) + query ( R(u), mid+1, r );
}

int main()
{
    int n, m;
    int t, x, y, i, j;
    int test = 0;
    while ( scanf("%d",&n) != EOF )
    {
		maxNum = 0;
        for ( i = 1; i <= n; i++ )
        {
            scanf("%I64d", &array[i][0]);
			if ( array[i][0] > maxNum )
				maxNum = array[i][0];
		}
		
		maxSqrt = 0;
		while ( maxNum > 1 )
		{
			maxNum = (lint) sqrt(maxNum+0.0);
			maxSqrt++;
		}
		
		for ( i = 0; i < 10; i++ )
            sum[0][i] = 0;
		
		for ( i = 1; i <= n; i++ )
		{
            for ( j = 0; j <= maxSqrt; j++ )
			{
				if ( j == 0 )
					sum[i][0] = sum[i-1][0] + array[i][0];
				else
				{
                    array[i][j] = (lint) sqrt(array[i][j-1]+0.0);
                    sum[i][j] = sum[i-1][j] + array[i][j];
				}
            }
        }
		
        build ( 1, 1, n );
        scanf("%d",&m);
        printf("Case #%d:\n", ++test);
		
        while( m-- )
        {
            scanf("%d%d%d",&t,&x,&y);
            if ( x > y ) swap(x,y);
            if ( t == 0 )
                update ( 1, x, y );
            else         
                printf("%I64d\n", query ( 1, x, y ));
        }
		putchar('\n');
    }
    return 0;
}

812ms:

#include <cmath>
#include <iostream>
using namespace std;

#define lint __int64
#define L(u) (u<<1)
#define R(u) (u<<1|1)
#define N  200005

lint array[N];
lint maxNum;
int n, m, maxSqrt;

struct Node
{
    int l, r, v, add;
	lint sum[8];
} node[N*4];

void build ( int u, int l, int r )
{
    node[u].l = l;
    node[u].r = r;
    node[u].v = 0;
	node[u].add = 0;
    if ( l == r )
	{
		lint temp, i = 0;
		node[u].sum[0] = temp = array[l];
		if ( array[l] == 0 )
		{
			for ( i = 0; i <= maxSqrt; i++ )
				node[u].sum[i] = 0;
			return;
		}
		while ( temp > 1 )
		{
			temp = (lint) sqrt(temp+0.0);
			node[u].sum[++i] = temp;
		}
		while ( i <= maxSqrt )
			node[u].sum[++i] = 1;
		return;
	}
	
    int mid = ( l + r ) >> 1;
    build ( L(u), l, mid );
    build ( R(u), mid+1, r );
	for ( int i = 0; i <= maxSqrt; i++ )
		node[u].sum[i] = node[L(u)].sum[i] + node[R(u)].sum[i];
}

void update ( int u, int l, int r )
{
    if ( l == node[u].l && node[u].r == r )
    {
		node[u].v++;
		node[u].add++;
        return;
    }
	
	if ( node[u].add != 0 )
	{
		node[L(u)].v += node[u].add;
		node[R(u)].v += node[u].add;
	    node[L(u)].add += node[u].add;
		node[R(u)].add += node[u].add;
		node[u].add = 0;
	}
	
    int mid = ( node[u].l + node[u].r ) >> 1;
    if ( r <= mid )
        update ( L(u), l, r );
    else if ( l > mid )
        update ( R(u), l, r );
    else
    {
        update ( L(u), l, mid );
        update ( R(u), mid+1, r );
    }
}

lint query ( int u, int l, int r )
{
    if ( l == node[u].l && node[u].r == r )
    {
		if ( node[u].v > maxSqrt )
			node[u].v = maxSqrt;
		if ( node[u].v == maxSqrt || node[u].l == node[u].r  )
            return node[u].sum[node[u].v];
		
		if ( node[u].add != 0 )
		{
			node[L(u)].v += node[u].add;
			node[R(u)].v += node[u].add;
			node[L(u)].add += node[u].add;
			node[R(u)].add += node[u].add;
			node[u].add = 0;
		}
		int mid = ( node[u].l + node[u].r ) >> 1;
        return query ( L(u), l, mid ) + query ( R(u), mid+1, r );
    }
	
	if ( node[u].add != 0 )
	{
		node[L(u)].v += node[u].add;
		node[R(u)].v += node[u].add;
	    node[L(u)].add += node[u].add;
		node[R(u)].add += node[u].add;
		node[u].add = 0;
	}
	
    int mid = ( node[u].l + node[u].r ) >> 1;
    if ( r <= mid )
        return query ( L(u), l, r );
    else if ( l > mid )
        return query ( R(u), l, r );
    else
        return query ( L(u), l, mid ) + query ( R(u), mid+1, r );
}

int main()
{
    int t, x, y, test = 0;
    while ( scanf("%d",&n) != EOF )
    {
		maxNum = 0;
        for ( int i = 1; i <= n; i++ )
        {
            scanf("%I64d", &array[i]);
			maxNum = array[i] > maxNum ? array[i] : maxNum;
		}
		
		maxSqrt = 0;
		while ( maxNum > 1 )
		{
			maxNum = (lint) sqrt(maxNum+0.0);
			maxSqrt++;
		}
		
        build ( 1, 1, n );
        scanf("%d",&m);
        printf("Case #%d:\n", ++test);

        while( m-- )
        {
            scanf("%d%d%d",&t,&x,&y);
            if ( x > y ) swap(x,y);
            if ( t == 0 )
                update ( 1, x, y );
            else         
                printf("%I64d\n", query ( 1, x, y ));
        }
		putchar('\n');
    }
    return 0;
}


TL代码。与上面的代码相比，仅仅是节点内少了一个add变量。但是这样一来，每次向下更新时会把 v 置为 0, 那么 node[u].v > maxSqrt这个优化条件就被减弱了。悲剧由此产生，唉·· 
#include <cmath>
#include <iostream>
using namespace std;

#define lint __int64
#define L(u) (u<<1)
#define R(u) (u<<1|1)
#define max(a,b) (a>b?a:b)
#define N  200005

lint sum[N][10];
lint array[N][10];
lint maxNum, maxSqrt;

struct Node
{
    int l, r, v, flag;
} node[N*4];

void build ( int u, int l, int r )
{
    node[u].l = l;
    node[u].r = r;
    node[u].v = 0;
	node[u].flag = 1;
    if ( l == r ) return;
    lint mid = ( l + r ) >> 1;
    build ( L(u), l, mid );
    build ( R(u), mid+1, r );
}

void down ( int u )
{
	if ( node[u].v != 0 )
	{
		node[L(u)].v += node[u].v;
		node[R(u)].v += node[u].v;
		node[u].v = 0;
	}
	node[u].flag = -1;
}

void update ( int u, int l, int r )
{
    if ( (l == node[u].l && node[u].r == r) || node[u].l == node[u].r  )
    {
		node[u].v++;
        return;
    }
	
	down(u);
	
    int mid = ( node[u].l + node[u].r ) >> 1;
    if ( r <= mid )
        update ( L(u), l, r );
    else if ( l > mid )
        update ( R(u), l, r );
    else
    {
        update ( L(u), l, mid );
        update ( R(u), mid+1, r );
    }
}

lint query ( int u, int l, int r )
{
    if ( l == node[u].l && node[u].r == r )
    {
		if ( node[u].v >= maxSqrt )
			node[u].v = maxSqrt;
		if ( node[u].v == maxSqrt || node[u].l == node[u].r || node[u].flag == 1 )
			return sum[r][node[u].v] - sum[l-1][node[u].v];
		
		down(u);
        return query( L(u), l, (l+r)/2 ) + query( R(u), (l+r)/2+1, r );
    }
	
	down(u);
	
    int mid = ( node[u].l + node[u].r ) >> 1;
    if ( r <= mid )
        return query ( L(u), l, r );
    else if ( l > mid )
        return query ( R(u), l, r );
    else
        return query ( L(u), l, mid ) + query ( R(u), mid+1, r );
}

int main()
{
    int n, m;
    int t, x, y, i, j;
    int test = 0;
    while ( scanf("%d",&n) != EOF )
    {
		maxNum = 0;
        for ( i = 1; i <= n; i++ )
        {
            scanf("%I64d", &array[i][0]);
			if ( array[i][0] > maxNum )
				maxNum = array[i][0];
		}
		
		maxSqrt = 0;
		while ( maxNum > 1 )
		{
			maxNum = (lint) sqrt(maxNum+0.0);
			maxSqrt++;
		}
		
		for ( i = 0; i < 10; i++ )
            sum[0][i] = 0;
		
		for ( i = 1; i <= n; i++ )
		{
            for ( j = 0; j <= maxSqrt; j++ )
			{
				if ( j == 0 )
					sum[i][0] = sum[i-1][0] + array[i][0];
				else
				{
                    array[i][j] = (lint) sqrt(array[i][j-1]+0.0);
                    sum[i][j] = sum[i-1][j] + array[i][j];
				}
            }
        }
		
        build ( 1, 1, n );
        scanf("%d",&m);
        printf("Case #%d:\n", ++test);
		
        while( m-- )
        {
            scanf("%d%d%d",&t,&x,&y);
            if ( x > y ) swap(x,y);
            if ( t == 0 )
                update ( 1, x, y );
            else         
                printf("%I64d\n", query ( 1, x, y ));
        }
		putchar('\n');
    }
    return 0;
}


ConwayTian
关注
专栏目录
【线段树单点更新优化】H - Can you answer these queries? HDU - 4027
BlessingXRY的博客
08-16 300
Think: 1知识点：线段树单点更新优化(优化条件(开根后平方数为1的结点不需要再次开根)) 2题意：两种操作：对一个区间所有数取其平方数；对一个区间所有数求和 3反思： 1>注意数据范围 2>注意输入区间是否合法，是否L一定会小于Rvjudge题目链接以下为Time Limit Exceeded代码——未加优化条件#include <cstdio> #include <cstring>
HDU 4027 【线段树区间开根号】
Y390d的博客
01-12 1417
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4027 这道线段树的题目我并没有按照线段树的模板写，这里把要点讲出来就行了。 第一：区间开根号不像区间乘或者除，能通过区间和然后一次性乘除求出一个区间的乘除，所以区间开根号只能一个一个的开，但是如果一个一个的开不会超时吗？ 假设一个数在long long的范围里面，也就是2^63这个范围内，那么对这...
HDU 4027 Can you answer these queries?（线段树+思维）
T.J的博客
08-20 172
题目链接：https://cn.vjudge.net/problem/HDU-4027 /********* 线段树： 战舰的耐久度 不超过2的63次方 说明只要对某一区间的数 最多开根号64次向下取整 值就变成1，不在变化 这个就是该题的优化部分 ************/ #include<iostream> #include<cstdio> #incl...
HDU4027 Can you answer these queries?【线段树】
海岛Blog
08-01 671
Can you answer these queries? Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65768/65768 K (Java/Others) Total Submission(s): 23332    Accepted Submission(s): 5550   Problem Description A ...
HDU4027：Can you answer these queries?
SEIZE THE DAY
07-24 190
  题目大意就是给你n个数，然后进行m次操作，区间更新，然后查询区间和。   这题有点特别，因为更新[l,r]时，不是常规的那种更新例如把[l,r]内的每个数换成v或把[l,r]里的每个数都增加v,而是[l,r]内的每个数都更新为其本身的二分之一次方。这样子的话我们就不能通过使用lazy标记来达到不更新到叶子节点偷懒的目的，因为一个sqrt(segtree[i].sum)不一定等于sqrt(se...
5.3 线段树
weixin_55835175的博客
11-15 555
5.3 线段树 如雷贯耳的一种数据结构。主要用于优化反复对序列某段区间进行运算求值和修改区间内点的值的问题的时间复杂度。 5.3.1 线段树的概念 线段树是用于处理区间问题的数据结构，其中每个结点代表一段区间[L,R] (一条线段)，下图即是线段[1,10]的线段树结构。 对于每个结点[L,R]： 1.L=R，说明这个区间内只有一个点，它就是叶结点。 2.L<R，说明这个区间内至少有两个点，同时这个区间可以被对折分成两个子节点，左子节点对应的区间为[L,M]，右子节点对应的区间为[M+1,R]，其
线段树专题
far away
08-16 767
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1166 敌兵布阵 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 97473    Accepted Submi
线段树总结
11-27 2万+
之前做了些线段树相关的题目，开学一段时间后，想着把它整理下，完成了大牛NotOnlySuccess的博文“完全版线段树”里的大部分题目，其博文地址Here，然后也加入了自己做过的一些题目。整理时，更新了之前的代码风格，不过旧的代码仍然保留着。       同样分成四类，不好归到前四类的都分到了其他。树状数组能做，线段树都能做（如果是内存限制例外），所以也有些树状数组的题目，会标示出来，并且放到其
数据结构专题——线段树
热门推荐
MetalSeed
10-04 12万+
线段树 转载请注明出处，谢谢！http://blog.csdn.net/metalseed/article/details/8039326  持续更新中··· 一：线段树基本概念 1：概述 线段树，类似区间树，是一个完全二叉树，它在各个节点保存一条线段（数组中的一段子数组），主要用于高效解决连续区间的动态查询问题，由于二叉结构的特性，它基本能保持每个操作的复杂度为O(lg
POJ 1151 Atlantis 线段树/矩形面积并
08-21 2106
题意：求矩形的面积并。 题解： 求矩形的并，由于矩形的位置可以多变，因此矩形的面积一下子不好求 这个时候，可以采用“分割”的思想，即把整块的矩形面积分割成几个小矩形的面积，然后求和就行了 这里我们可以这样做，把每个矩形投影到 y 坐标轴上来 然后我们可以枚举矩形的 x 坐标，然后检测当前相邻 x 坐标上 y 方向的合法长度，两种相乘就是面积   然后关键就
POJ 2528 Mayor's posters 线段树+离散化
08-06 1996
题意： 在墙壁上贴海报，计算出看得见的张数。 题解：        线段树基础知识 从简单说起，线段树其实可以理解成一种特殊的二叉树。但是这种二叉树较为平衡，和静态二叉树一样，都是提前已经建立好的树形结构。针对性强，所以效率要高。这里又想到了一句题外话：动态和静态的差别。动态结构较为灵活，但是速度较慢；静态结构节省内存，速度较快。 接着回到线段树上来，线段树是建立在线段的基础上，每
线段树模板（lazy标记）ZOJ 3686
04-03 1539
题解：先搜索用将树上的点给定时间戳，以此当做该节点的区间。 #include #include #include using namespace std; #define N 150005 bool vis[N], check[N]; int dep, k, n; struct treeNode { int id; treeNode *brother; treeNode *son;
HDU 1255 覆盖的面积 线段树
08-22 1503
题意：给定平面上若干矩形,求出被这些矩形覆盖过至少两次的区域的面积. 题解：和 poj1151 类似，不过要求的是面积的交，同样是先离散化然后枚举x坐标。此题更新时求y方向的“合法长度”相对于 poj1151 还有些区别, 值得比较比较。并且用lazy貌似也不合适，必须跟新至单元，因为每个节点既受父节点影响，也受子节点影响。 len[1]是覆盖一次的长度，len[2]是覆盖次数>= 2的长
HDU 1823 Luck and Love 二维线段树 / 矩形树
08-16 1427
题意： 本题有多个测试数据，第一个数字M，表示接下来有连续的M个操作，当M＝0时处理中止。接下来是一个操作符C。当操作符为‘I’时，表示有一个MM报名，后面接着一个整数，H表示身高，两个浮点数，A表示活泼度，L表示缘分值。 （100 题解： 注意浮点数的处理，一般来说可以离散化，或者化作整数处理。 二维线段树，第一维度的每一个节点都包含第二维度的一颗线段树。这种方式对于更高的维度就不是
POJ 2104 K-th Number 划分树
10-14 1183
题意:求区间[l,r]中第k小的数 题解： #include #include #include #include using namespace std; #define MAXN 100001 #define L(u) (u<<1) #define R(u) (u<<1|1) #define MID(l, r) ((l+r)>>1) struct SegTree { int l
归并树 第K大值
04-03 1146
/* 1.O(n*(logn)^2) 2.树的节点node从1开始（方便位运算） 3.树的层数h从0开始（节约空间） 4.数组a的下标从1开始 5.我们在queryVal中二分的是[1,n]整个区间，而不是[l,r]区间，这似乎是不正确的。因为假如[l,r]区间 中的值为[2,10,22,23]，我们要求第3大的值，如果二分到的值是11，他的在[l,r]中的rank为3，这不就错了么？
POJ 2482 Stars in Your Window 线段树
08-14 1066
题意：每一颗星星有一定的亮度值，现在坐标系中有许多星星，每个星星的坐标及亮度值已经给定，求一个矩形能够框住的最大值。Lazy 标记。 题解：对每一颗星星，画出以它为左下角的矩形，这个矩形就是它的影响范围。为了方便处理，我们将每一颗星分作两颗， frist_star ( x, y, val ),  second_star ( x + w, y, -val )，这样当我们不断插入星星的时候，其
HDU 3974 Assign the task 线段树（树映射到区间）
05-18 946
题意.... 题解： #include #include #include #include using namespace std; #define MAXN 100001 #define L(u) (u<<1) #define R(u) (u<<1|1) struct A_NODE { A_NODE *sun, *bro; int num; } anode[MAXN],
NotOnlySuccess的线段树完全解析
3. HDU 1394 最小逆序数：此问题需要在线段树中实现单点增减，并进行区间求和。通过线段树，可以在O(n log n)的时间复杂度内预处理初始逆序数，然后以O(1)的时间复杂度递推出其他解。 4. HDU 2795 Billboard：这是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值