HOJ 2685 POJ 2777 Count Color

Chosen Problem Solving and Program design as an optional course, you are required to solve all kinds of problems. Here, we get a new problem.

There is a very long board with length L centimeter, L is a positive integer, so we can evenly divide the board into L segments, and they are labeled by 1, 2, ... L from left to right, each is 1 centimeter long. Now we have to color the board - one segment with only one color. We can do following two operations on the board:

1. "C A B C" Color the board from segment A to segment B with color C.

2. "P A B" Output the number of different colors painted between segment A and segment B (including).

In our daily life, we have very few words to describe a color (red, green, blue, yellow…), so you may assume that the total number of different colors T is very small. To make it simple, we express the names of colors as color 1, color 2, ... color T. At the beginning, the board was painted in color 1. Now the rest of problem is left to your.

Input

The input file for this problem contains several test cases. First line of each case contains L (1 ≤ L ≤ 100000), T (1 ≤ T ≤ 30) and O (1 ≤ O ≤ 100000). Here O denotes the number of operations. Following O lines, each contains "C A B C" or "P A B" (here A, B, C are integers, and A may be larger than B) as an operation defined previously.

Output

Ouput results of the output operation in order, each line contains a number.

Sample Input

2 2 4
C 1 1 2
P 1 2
C 2 2 2
P 1 2

Sample Output

2
1

 

呃，这真是一道好题……让我学会了lazy思想。（其实我在做这题超时的时候也萌生过这个想法，但是没有尝试，原来lazy思想只要很小改动即可）。另外就是位运算

 

本来应该如此：

每次paint：

把那个段和他的所有子段全都paint

然后把paint过的那些的颜色，返回给大的线段

 

每次查询：

如果前后对应了，就返回颜色，

如果还没对应好，就寻找子线段，并把两边子树的信息进行或操作。就是颜色的并集

 

但是这样的话每次都要递归很深。所以设一个lazy标记，表示他的子线段和他一样，都是同个颜色了。这样就需要在修改这个线段时把它再次标记去掉，并且把子树给标上

 

哎。今晚做这题做得太狗血了

#include <cstdio>
#include <algorithm>
using namespace std;
struct node{
	int l,r,cl;
	bool lz;
}t[300009];
void build(int st,int ed,int cr){
	t[cr].r=ed;
	t[cr].l=st;
	t[cr].cl=2;
	t[cr].lz=1;
	if(st==ed)
		return ;
	build(st,(st+ed)/2,2*cr);
	build((st+ed)/2+1,ed,cr*2+1);
	return ;
}
void insert(int st,int ed,int cr,int incl){
	if(t[cr].r==ed&&t[cr].l==st){
		t[cr].cl=(1<<incl);
		t[cr].lz=1;
		return ;//不用再递归了，这样子已经足够了
	}
	if(t[cr].lz){
		t[cr].lz=0;//插入的不是当前线段，而是子线段，那么把这个线段破开。并把这个点信息给子线段
		t[cr*2+1].cl=t[cr*2].cl=t[cr].cl;
		t[cr*2+1].lz=t[cr*2].lz=1;
	}
	int mid=(t[cr].r+t[cr].l)>>1;
	if(ed<=mid){
		insert(st,ed,2*cr,incl);
	}else if(st>mid){
		insert(st,ed,2*cr+1,incl);
	}else{
		insert(st,mid,2*cr,incl);
		insert(mid+1,ed,2*cr+1,incl);
	}
	t[cr].cl=t[cr*2].cl|t[cr*2+1].cl;
	return ;
}
int query(int st,int ed,int cr){
	if((t[cr].lz)||(t[cr].r==ed&&t[cr].l==st)){
		return t[cr].cl;
	}
	int mid=(t[cr].l+t[cr].r)>>1;
	if(ed<=mid){
		return query(st,ed,cr*2);
	}else if(st>mid){
		return query(st,ed,cr*2+1);
	}else{
		return query(st,mid,cr*2)|query(mid+1,ed,cr*2+1);
	}
}
int main(){
	int L,T,O,A,B,C,ret,ans;
	char op;
	while(scanf("%d%d%d",&L,&T,&O)==3){
		build(1,L,1);
		while(O--&&scanf(" %c",&op)){
			if(op=='C'){
				scanf("%d%d%d",&A,&B,&C);
				if(A>B)swap(A,B);
				insert(A,B,1,C);
			}else{
				scanf("%d%d",&A,&B);
				if(A>B)swap(A,B);
				ret=query(A,B,1);
				ans=0;
				for(int i=0;i<32;i++)
					if(ret&(1<<i))
						ans++;
				printf("%d\n",ans);
			}
		}
	}
}