线段树之：【洛谷P2417 [SCOI2007] 降雨量】【附上经典测试案例】【情况多，思维缜密】

8
-8 1
-2 2
0 6
1 5
2 7
13 1
18 10
19 14
1
0 4
false

8
-8 1
-2 2
0 6
1 5
2 7
13 1
18 10
19 14
6
-6 0
-2 19
13 18
2 19
-13 13
-19 14
maybe
false
false
false
false
maybe

9
-8 1
-2 2
0 6
1 5
2 3
4 6
13 1
18 10
19 14
1
0 4
maybe

9
-8 1
-2 2
0 6
1 5
2 6
4 6
13 1
18 10
19 14
1
0 4
false

9
-8 1
-2 2
0 6
1 5
2 6
4 6
13 1
18 10
19 14
1
0 4

false
 

 

8
-8 1
-2 2
0 6
1 5
2 6
13 1
18 10
19 14
1
0 4
false 

 

/*
这道题目的题意有点古怪：
A年是自B年以来降水量最多的，
那就必须A年的降水量<=B年的降水量，且是这段区间内最多的

并且B年到A年的年份中只要有一个年份的降水量没有输入，就应该是false; 
*/ 



/*


8
-8 1
-2 2
0 6
1 5
2 7
13 1
18 10
19 14
1
0 4
false

8
-8 1
-2 2
0 6
1 5
2 7
13 1
18 10
19 14
6
-6 0
-2 19
13 18
2 19
-13 13
-19 14
maybe
false
false
false
false
maybe





9
-8 1
-2 2
0 6
1 5
2 3
4 6
13 1
18 10
19 14
1
0 4
maybe

9
-8 1
-2 2
0 6
1 5
2 6
4 6
13 1
18 10
19 14
1
0 4
false


9
-8 1
-2 2
0 6
1 5
2 6
4 6
13 1
18 10
19 14
1
0 4



*/


#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
const int N=1e5+10,M=1e6;
vector<int> year;
unordered_map<int,int> mp;
LL sum[M];
int n,m;

struct Node
{
	int l,r;
	LL v;
}tr[4*N];

void pushup(int u)
{
	tr[u].v=max(tr[u<<1].v,tr[u<<1|1].v);
}


void build(int u,int l,int r)
{
	tr[u]={l,r};
	if(l==r)
	{
		tr[u]={l,r,0};
		return;
	}
	
	int mid=l+r>>1;
	build(u<<1,l,mid);
	build(u<<1|1,mid+1,r); 
	
	pushup(u);
}

void modify(int u,int x,int c)
{
	if(tr[u].l==x&&tr[u].r==x)
	{
		tr[u].v=c;
		return;
	}
	else
	{
		int mid=tr[u].l+tr[u].r>>1;
		if(x<=mid) modify(u<<1,x,c);
		if(x>mid) modify(u<<1|1,x,c);
		pushup(u);
	}
}


LL query(int u,int l,int r)
{
	if(tr[u].l>=l&&tr[u].r<=r)
	{
		return tr[u].v;
	}

		int mid=tr[u].l+tr[u].r>>1;
		LL v=0;
		if(l<=mid){
			v=query(u<<1,l,r);
		}
		if(r>mid){
			v=max(v,query(u<<1|1,l,r));
		}
		
		return v;
}


int find(int x)
{
	return lower_bound(year.begin(),year.end(),x)-year.begin()+1;
}

int main()
{
	int n;
	scanf("%d",&n);
	vector<PII> re,q;
	
	
	for(int i=1;i<=n;i++)
	{
		int y,r;
		scanf("%d%d",&y,&r);
		year.push_back(y);
		re.push_back({y,r});
	} 


    scanf("%d",&m);
    build(1,1,n+3*m);
    
    while(m--)
    {
    	int y,x;
    	scanf("%d%d",&y,&x);
    	q.push_back({y,x});
    	year.push_back(y);
    	year.push_back(x);
	}
	
	
	sort(year.begin(),year.end());
	year.erase(unique(year.begin(),year.end()),year.end());

	for(int i=0;i<re.size();i++)
	{
		int ye=re[i].first;
		int w=re[i].second;
		
		ye=find(ye);
		mp[ye]=w;
		sum[ye]=1;
		modify(1,ye,w);
	}
	
	for(int i=1;i<M;i++)
	{
		sum[i]=sum[i]+sum[i-1];
	}
  
	for(int i=0;i<q.size();i++)
	{
		int y,x;
		y=q[i].first;
		x=q[i].second;
		//x年是y年以来降水量最多的 
		int cc=x-y+1;
		
		y=find(y);
		x=find(x);
		 
		int c=sum[x]-sum[y-1];
		
		LL v=query(1,y+1,x);
		LL v2=1e18;
		if(x-1>=y+1)
		v2=query(1,y+1,x-1);

        /*
		先判断一定不可能的情况： 
        1.x年的降水量存在，但是不是y+1年（包括）后面最多的 
		2.x年的降水量存在，y年的降水量也存在。
		x年确实是y+1年后面中最多的，但是超过了y年的降水量 
		mp[year]=  存的是某个年份 的降水量 
		
		3.还有一种一定不可能的情况很难想到，
		就是0年：6
		    1年: 5
			2年: 7
		    13年:1
		问第4年的降水量是不是0年以来最多的，
		看起来好像是maybe的情况，但是超级无敌坑的是
		第2年已经超过0年了，第4年一定不会是<0年的最多的 
		
		
		4.
		y到x之间，如果想让x成为 <=y的降雨量的最大降雨量，
		（由于是自...以来，说明必须是第一次出现的最大降雨量，说明x不能做最后出现的
		最大降雨量，换句话说，x到y之间不能有其他重复的最大降雨量） 
		
		
		
		第四种情况也很难想到，就是
		左端点到右端点之间（不包括两个端点），求一个v2(最大值)
		以及左端点到右端点之间（不包括左端点），求一个v(最大值)
		如果v2和v相等，意味着有重复的相等的最大值
		那么右端点就不是自左端点以来的最大值，因为前面也有自左端点以来的
		最大值 
		v2就是y与x之间的阻挡，使得x不一定是第一次出现的最大降雨量 
         */ 
    
        
        if((v&&mp[y]&&v>mp[y])||(v&&v2==v&&mp[x])||(v2&&v2>=mp[y]))
		{	
			puts("false");
		} 
		
		else
		{
			/*第一种情况是可能真实
			这种情况是因为x,y之间还有未知年份降水量 
			*/ 
			
			if(cc!=c)
			{
				puts("maybe");
			}
			else puts("true");
		}
	}
	
	
	return 0;
}