POJ 3225 Help with Intervals

最新推荐文章于 2022-12-31 12:32:35 发布
最新推荐文章于 2022-12-31 12:32:35 发布
阅读量678 收藏
点赞数
分类专栏： 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/speedcell4/article/details/11717095
版权

终于A了这题了，槽点略多：

  1. 开闭区间使用奇偶数来区分开，这点非常巧妙，自己在写的时候没有这样想过。
  2. 以前一直认为有多个lazy要维护的时候，在每次操作前就down掉就能避免掉矛盾操作的情况。这题发现是不行的，因为如果两次对同样的区间进行不同的操作，那子区间还是得到了两个操作的lazy，所以只能仔细分析每个操作的优先顺序。比如这题set操作明显是盖过xor的，如果要set了，那么下面的xor也就不用搞了。而如果要xor下面的set还是要搞，所以同时出现两个lazy的情况说明set一定是先来的，那就先set再xor。坑：如果操作再多一点是什么情况……
  3. 调试的时候出现一个问题，当时把display放到主循环最后一句，发现这样可以得到正确答案，但是拿出来就会出错。当时觉得很不可思议，因为这除了跳出主循环以为并没有做任何事情。后来各种脑残调试N久才发现每次都display了就每次都query到底了，所以不存在两个lazy的情况……
/*
 Author : Speedcell
 Update : 2013-05-30
Version : soppYcell 2.2(a)
*/

#include <algorithm>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>

#include <map>
#include <set>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <vector>
#include <string>
#include <bitset>
#include <memory>
#include <complex>
#include <numeric>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <ctype.h>
#include <locale.h>

using namespace std;

#pragma pack(4)

#ifndef __CONSTANT__
#define __CONSTANT__

typedef long long LONG;

const double pi = acos(-1.0);
const int   inf = 0x7f7f7f7f;
const LONG  INF = 0x7f7f7f7f7f7f7f7fll;

const int go[8][2] = {{0,1},{0,-1},{1,0},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1}};

#endif // __CONSTANT__

#ifndef __IO__
#define __IO__

inline bool RD(int    & a) {return scanf("%d",&a)!=EOF;}
inline bool RD(char   & a) {return scanf("%c",&a)!=EOF;}
inline bool RD(char   * a) {return scanf("%s", a)!=EOF;}
inline bool RD(double & a) {return scanf("%lf",&a)!=EOF;}
inline bool RD(LONG   & a) {return scanf("%I64d",&a)!=EOF;}

template<class T1> inline bool
    IN(T1 & a) {return RD(a);}
template<class T1,class T2> inline bool
    IN(T1 & a,T2 & b) {return RD(a)&&RD(b);}
template<class T1,class T2,class T3> inline bool
    IN(T1 & a,T2 & b,T3 & c) {return RD(a)&&RD(b)&&RD(c);}
template<class T1,class T2,class T3,class T4> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d) {return RD(a)&&RD(b)&&RD(c)&&RD(d);}
template<class T1,class T2,class T3,class T4,class T5> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d,T5 & e) {return RD(a)&&RD(b)&&RD(c)&&RD(d)&&RD(e);}
template<class T1,class T2,class T3,class T4,class T5,class T6> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d,T5 & e,T6 & f) {return RD(a)&&RD(b)&&RD(c)&&RD(d)&&RD(e)&&RD(f);}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d,T5 & e,T6 & f,T7 & g) {return RD(a)&&RD(b)&&RD(c)&&RD(d)&&RD(e)&&RD(f)&&RD(g);}

inline void PT(int    a) {printf("%d",a);}
inline void PT(char   a) {printf("%c",a);}
inline void PT(char * a) {printf("%s",a);}
inline void PT(double a) {printf("%f",a);}
inline void PT(LONG   a) {printf("%I64d",a);}
inline void PT(const char a[]) {printf("%s",a);}

template<class T1> inline void
    OT(T1 a) {PT(a);}
template<class T1,class T2> inline void
    OT(T1 a,T2 b) {PT(a),PT(' '),PT(b);}
template<class T1,class T2,class T3> inline void
    OT(T1 a,T2 b,T3 c) {PT(a),PT(' '),PT(b),PT(' '),PT(c);}
template<class T1,class T2,class T3,class T4> inline void
    OT(T1 a,T2 b,T3 c,T4 d) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d);}
template<class T1,class T2,class T3,class T4,class T5> inline void
    OT(T1 a,T2 b,T3 c,T4 d,T5 e) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e);}
template<class T1,class T2,class T3,class T4,class T5,class T6> inline void
    OT(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f);}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7> inline void
    OT(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f,T7 g) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f),PT(' '),PT(g);}

template<class T1> inline void
    OL(T1 a) {PT(a),PT('\n');}
template<class T1,class T2> inline void
    OL(T1 a,T2 b) {PT(a),PT(' '),PT(b),PT('\n');}
template<class T1,class T2,class T3> inline void
    OL(T1 a,T2 b,T3 c) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT('\n');}
template<class T1,class T2,class T3,class T4> inline void
    OL(T1 a,T2 b,T3 c,T4 d) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT('\n');}
template<class T1,class T2,class T3,class T4,class T5> inline void
    OL(T1 a,T2 b,T3 c,T4 d,T5 e) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT('\n');}
template<class T1,class T2,class T3,class T4,class T5,class T6> inline void
    OL(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f),PT('\n');}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7> inline void
    OL(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f,T7 g) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f),PT(' '),PT(g),PT('\n');}

#endif // __IO__

#ifndef __MACRO__
#define __MACRO__

#define ML(times) int tcase; IN(tcase); FOR(times,1,tcase)

#define FOR(i,a,b) for(int i=int(a),_##i=int(b);i<=_##i;i++)
#define DWN(i,b,a) for(int i=int(b),_##i=int(a);_##i<=i;i--)
#define ECH(i,u,pre,next) for(int i=int(pre[u]);i!=-1;i=int(next[i]))

#define MEM(a,v) memset(a,v,sizeof(a))
#define CLR(a,v) FOR(_i##a,0,sizeof(a)/sizeof(a[0])-1) a[_i##a]=v

#define LOOP(a,n)                                               \
    FOR(_i##a,0,(n)-1)                                          \
        OT(a[_i##a]),OT(_i##a!=__i##a?' ':'\n')
#define LOOP2(a,n,m)                                            \
    FOR(_i##a,0,(n)-1) FOR(_j##a,0,(m)-1)                       \
        OT(a[_i##a][_j##a]),OT(_j##a!=__j##a?' ':'\n')
#define LOOPG(G,n,pre,next)                                     \
    FOR(_i##a,0,(n)-1) ECH(_j##a,_i##a,pre,next)                \
        OL(_i##a,G[_j##a].v,G[_j##a].w)

#endif // __MACRO__

#ifndef __BIT__
#define __BIT__

template<class T> inline T lb(T i) {return i&-i;}
template<class T> inline T lc(T i) {return i<<1;}
template<class T> inline T rc(T i) {return i<<1|1;}
template<class T> inline T at(T a,int i) {return a& (T(1)<<i);}
template<class T> inline T nt(T a,int i) {return a^ (T(1)<<i);}
template<class T> inline T s1(T a,int i) {return a| (T(1)<<i);}
template<class T> inline T s0(T a,int i) {return a&~(T(1)<<i);}

#endif // __BIT__

#ifndef __DOUBLE__
#define __DOUBLE__

const double eps = 1e-8;

inline int cmp(double a,double b=0) {return fabs(a-b)<eps?0:((a-b)>eps?+1:-1);}

inline double fmax(double a,double b) {return cmp(a,b)>0?a:b;}
inline double fmin(double a,double b) {return cmp(a,b)<0?a:b;}

#endif // __DOUBLE__

const int MAXV = 140000;

class SegmentTree
{
private:
	int L,R,val[MAXV<<2],lxor[MAXV<<2],lset[MAXV<<2];

	#define ls l,(l+r)/2,lc(i)
	#define rs (l+r)/2+1,r,rc(i)

	void XOR(int l,int r,int i)
	{
		if(l<=r)
		{
			val[i]^=1;
			lxor[i]^=1;
		}
	}
	void SET(int v,int l,int r,int i)
	{
		if(l<=r)
		{
			val[i]=v;
			lset[i]=v;
			lxor[i]=0;
		}
	}
	void down(int l,int r,int i)
	{
		if(l<r)
		{
			if(lset[i]!=-1)
			{
				SET(lset[i],ls);
				SET(lset[i],rs);
				lset[i]=-1;
			}
			if(lxor[i])
			{
				XOR(ls);
				XOR(rs);
				lxor[i]=0;
			}
		}
	}
	void update_set(int x,int y,int v,int l,int r,int i)
	{
		if(x<=l&&r<=y) SET(v,l,r,i);
		else
		{
			down(l,r,i);
			if(x<=(l+r)/2) update_set(x,y,v,ls);
			if((l+r)/2<y) update_set(x,y,v,rs);
		}
	}
	void update_xor(int x,int y,int l,int r,int i)
	{
		if(x<=l&&r<=y) XOR(l,r,i);
		else
		{
			down(l,r,i);
			if(x<=(l+r)/2) update_xor(x,y,ls);
			if((l+r)/2<y) update_xor(x,y,rs);
		}
	}
	int query(int x,int l,int r,int i)
	{
		if(x==l&&r==x) return val[i];
		else
		{
			down(l,r,i);
			if(x<=(l+r)/2) return query(x,ls);
			else return query(x,rs);
		}
	}
public:
	void clear(int l=0,int r=MAXV-1)
	{
		L=l;
		R=r;
		MEM(val,0);
		MEM(lxor,0);
		MEM(lset,-1);
	}
	void update_set(int x,int y,int v)
	{
		if(x<=y) update_set(x,y,v,L,R,1);
	}
	void update_xor(int x,int y)
	{
		if(x<=y) update_xor(x,y,L,R,1);
	}
	int query(int x)
	{
		return query(x,L,R,1);
	}
}st;

int x,y;
char o,a,b;

void display(void)
{
	char a,b;
	int x,y,left=-1,right=-1;
	bool flag=false,tot=false;

	FOR(i,0,MAXV-1)
	{
		if(st.query(i))
		{
			if(!flag)
			{
				flag=true;
				left=right=i;
			}
			else right++;
		}
		else if(flag)
		{
			if(tot) printf(" ");
			if(left%2==0) a='[',left=left/2;
			else a='(',left=(left-1)/2;
			if(right%2==0) b=']',right=right/2;
			else b=')',right=(right+1)/2;
			printf("%c%d,%d%c",a,left,right,b);
			flag=false;
			tot=true;
		}
	}
	if(!tot) printf("empty set");
	printf("\n");
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("Help with Intervals.txt","r",stdin);
    #else
    #endif

    st.clear();
    while(scanf("%c %c%d,%d%c\n",&o,&a,&x,&y,&b)!=EOF)
	{
		x*=2;
		y*=2;
		if(a=='(') x++;
		if(b==')') y--;
		if(o=='U')
		{
			st.update_set(x,y,1);
		}
		else if(o=='I')
		{
			st.update_set(0,x-1,0);
			st.update_set(y+1,MAXV-1,0);
		}
		else if(o=='D')
		{
			st.update_set(x,y,0);
		}
		else if(o=='C')
		{
			st.update_set(0,x-1,0);
			st.update_set(y+1,MAXV-1,0);
			st.update_xor(x,y);
		}
		else if(o=='S')
		{
			st.update_xor(x,y);
		}
	}
	display();

    return 0;
}

Speedcell
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ2996-Help Me with the Game
07-29
【标题】"POJ2996-Help Me with the Game"是一道源自北京大学在线判题系统POJ的编程竞赛题目。这道题目的主要目标是编写程序来解决一个特定的游戏策略问题，要求参赛者具备扎实的算法基础和编程能力。 【描述】...
POJ1716-Integer Intervals【Difference Constraints】
07-31
【标题】"POJ1716-Integer Intervals【Difference Constraints】" 是一个编程竞赛题目，来源于北京大学的在线评测系统POJ（Problem Online Judge）。这个题目主要涉及到差分约束系统（Difference Constraints）的...
poj 3225 Help with Intervals
最新发布
weixin_46266058的博客
12-31 709
线段树
POJ 3225 Help with Intervals（线段树）
weixin_30383279的博客
06-16 64
POJ 3225 Help with Intervals 题目链接 集合数字有的为1，没有为0，那么几种操作相应就是置为0或置为1或者翻转，这个随便推推就能够了，然后开闭区间的处理方式就是把区间扩大成两倍，偶数存点，奇数存线段就可以 代码： #include <cstdio> #include <cstring> #defin...
POJ3225 Help with Intervals
Circus
12-14 439
线段树
POJ 3225 Help with Intervals (线段树 成段更新, 懒惰标记*2)
Gatevin的专栏
08-17 458
题目大意： 就是现在模拟实现区间的交并补差一系列操作, 输出最后得到的区间 大致思路： 首先对于区间开出两倍长度用奇数位表示区间(a, a + 1)偶数段表示端点a, a + 1之类 然后对于区间上的操作用0表示这一段在区间中, 用1表示不在 那么对于交和并不难映射到对应的区间更改为0和1的操作中 但是在处理差的时候需要用到区间取异或值的操作 于是需要用到两个懒惰标记, 一个
poj3225 Help with Intervals
A Cube Master
09-25 483
题意：全集是[0,65535]，初始集合为空集，进行各种集合运算，区间she输出最后的集合。
POJ 3225 Help with Intervals 【线段树】
a18235146924的博客
10-26 68
题目链接 segment tree 题意 给定集合S，S最初是空集。现对其进行一些操作：与一个集合求交、并、补、对称差。用区间表示出最终的S 分析 这个题有许多注意的地方（当然可能是我写法不太好），肝了一上午…… 那么首先想到用线段树来解决这个区间覆盖的问题。虽然是实数区间，但注意到区间端点始终是整数。于是我们整体乘2，用偶数来代表整数点，用奇数来...
poj3225 Help with Intervals 线段树，成段更新，TLE，求指教。。本人提供测试数据～
basement_boy
06-07 845
题目链接：http://poj.org/problem?id=3225 搞了
POJ3225Help with Intervals
GXwar の Code library
08-25 687
开始没看懂题，看懂了之后也不知道如何用线段树来做这题，百度了一下思路 思路: 我们一个一个操作来分析:(用0和1表示是否包含区间,-1表示该区间内既有包含又有不包含) U:把区间[l,r]覆盖成1 I:把[-∞,l)(r,∞]覆盖成0 D:把区间[l,r]覆盖成0 C:把[-∞,l)(r,∞]覆盖成0 , 且[l,r]区间0/1互换 S:[l,r]区间0/1互换 还有要注意的地
【线段树】POJ3225 Help with intervals
a18523440518的博客
04-23 95
【Problem】 　　LogLoader, Inc. is a company specialized in providing products for analyzing logs. While Ikki is working on graduation design, he is also engaged in an internship at LogLoader. Among...
POJ1201-Intervals
07-31
【标题】"POJ1201-Intervals" 是北京大学在线编程平台POJ上的一道题目，这道题目主要涉及计算机科学中的算法设计与分析，尤其是数据结构和时间复杂度优化方面的知识。 【描述】"北大POJ1201-Intervals 解题报告+AC...
PKU POJ 1162 Building with Blocks解题报告
10-30
### PKU POJ 1162 Building with Blocks 解题报告 #### 题目概述 本题名为“Building with Blocks”，属于经典的积木搭建问题。题目要求利用一定数量的基本单位积木，搭建出特定的三维形状。积木的种类不超过12种，...
poj.rar_poj
09-23
标题中的"poj.rar_poj"暗示了这是一个与POJ（Programming Online Judge）相关的压缩文件，POJ是一个在线编程竞赛平台，主要供程序员们练习和提交算法解决方案。在这个压缩包中，很可能包含了用户在POJ上参与编程挑战...
HDU 4737 A Bit Fun
09-15 1310
开始写的时候是用的O(n*(logn)^2)的复杂度，固定起点二分最远能到多远然后累加，但是这样TLE了，然后直接在树上二分完事。 这里顺序是倒着来的，因为这个写法是查最右点，是为了修正不能区间修改而固定最左点的做法，所以去右子树的话一定要带上左子树的状态去。 这题交G++跑1000MS+，但据说数据乱搞直接平方级暴力可以100MS+…… /* Author : Speedcell
POJ 2528 Mayor's posters
09-26 742
需求：区间替换，单点查询。 这题按NotOnlySuccess的做法是离散化线段，这样会造成他博客上说得问题，他的解决方案是加上微小的偏移量。我这里提出一个自认为更好的做法： 不要离散化线段，而是离散化坐标点，因为线段树其实是点段数，不管什么操作其实都是最一个区间上的点集的得操作，而不是区间本身，解法如下： 离散化坐标点，区间替换成当前海报的标号，然后线扫坐标点，hash海报标号统计不同个数
Codeforces 52C Circular RMQ
03-06 624
不想说什么了，这两天脑袋被门夹了…… #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include
POJ编程题解资源集合
"这些题目是来自POJ (Programming Online Judge) 的一系列算法练习题，涵盖了基础到中等难度的编程问题。题目涉及了各种算法和数据结构，包括但不限于数学计算、字符串处理、逻辑推理、递归、动态规划、位运算等。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值