BZOJ1067: [SCOI2007]降雨量

最新推荐文章于 2025-09-04 16:11:29 发布

weixin_30845171

最新推荐文章于 2025-09-04 16:11:29 发布

阅读量152

点赞数

CC 4.0 BY-SA版权

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/Yangrui-Blog/p/9937170.html

本文详细解析了BZOJ1067:[SCOI2007]降雨量问题，通过使用线段树实现区间最值查询，针对不同询问场景进行细致的真假判断，提供了完整的代码实现。

BZOJ1067: [SCOI2007]降雨量

Description

　　我们常常会说这样的话：“X年是自Y年以来降雨量最多的”。

它的含义是X年的降雨量不超过Y年，且对于任意Y＜Z＜X，Z年的降雨量严格小于X年。

例如2002，2003，2004和2005年的降雨量分别为4920，5901，2832和3890，则可以说“2005年是自2003年以来最多的”，但不能说“2005年是自2002年以来最多的”

由于有些年份的降雨量未知，有的说法是可能正确也可以不正确的。

Input

　　输入仅一行包含一个正整数n，为已知的数据。

以下n行每行两个整数yi和ri，为年份和降雨量，按照年份从小到大排列，即yi＜yi+1。

下一行包含一个正整数m，为询问的次数。

以下m行每行包含两个数Y和X，即询问“X年是自Y年以来降雨量最多的。”这句话是必真、必假还是“有可能”。

Output

　　对于每一个询问，输出true，false或者maybe。

Sample Input

6
2002 4920
2003 5901
2004 2832
2005 3890
2007 5609
2008 3024
5
2002 2005
2003 2005
2002 2007
2003 2007
2005 2008

Sample Output

false
true
false
maybe
false

HINT

100%的数据满足：1<=n<=50000, 1<=m<=10000, -10^9<=yi<=10^9, 1<=ri<=10^9

题解Here!

超级恶心的细节题。。。

首先求区间最值，直接$ST$表/线段树即可。

我用了线段树。

然后便是怎么判断各种情况。

首先读入时的年份是保证递增的。

所以对于每次询问$x,y$（当$x\geq y$直接输$false$不用多说），我们可以先二分找出第一个不小于$x$的位置，和$y$的位置，不妨假设为$l$和$r$。

然后判断边界的年份是否相等，并查询出$l+1$到$r-1$的最大值。

要取出中间一段的最大值，用其和两端比较，注意判断左端点年份不确定时要查询$l$到$r-1$的最大值。

首先判$false$：

当右端点年份确定，且中间年份最大降雨量大于等于右端点降雨量
当左端点年份确定，且中间年份最大降雨量大于等于左端点降雨量
当左右端点年份都确定，且左端点降雨量小于等于右端点降雨量

再判$maybe$:

当左右端点之差不等于左右端点年份之差（等价于年份不连续，也就是我前面所说的更好的判断区间连续的方法）
左端点年份不确定
右端点年份不确定

因为已经切掉$false$的情况了，那么剩下的情况中可以直接照上面的判断！

最后若上面情况都不满足，那么肯定是$true$。

附代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#define LSON rt<<1
#define RSON rt<<1|1
#define DATA(x) a[x].data
#define LSIDE(x) a[x].l
#define RSIDE(x) a[x].r
#define MAXN 50010
using namespace std;
int n,m,d=1;
int year[MAXN],val[MAXN];
struct node{
    int data,l,r;
}a[MAXN<<2];
inline int read(){
	int date=0,w=1;char c=0;
	while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
	while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
	return date*w;
}
inline void pushup(int rt){
    DATA(rt)=max(DATA(LSON),DATA(RSON));
}
void buildtree(int l,int r,int rt){
    LSIDE(rt)=l;RSIDE(rt)=r;DATA(rt)=0;
    if(l==r)return;
    int mid=l+r>>1;
    buildtree(l,mid,LSON);
    buildtree(mid+1,r,RSON);
}
void update(int l,int r,int c,int rt){
    if(l<=LSIDE(rt)&&RSIDE(rt)<=r){
        DATA(rt)=c;
        return;
    }
    int mid=LSIDE(rt)+RSIDE(rt)>>1;
    if(l<=mid)update(l,r,c,LSON);
    if(mid<r)update(l,r,c,RSON);
    pushup(rt);
}
int query(int l,int r,int rt){
    if(l>r)return 0;
    int ans=0;
    if(l<=LSIDE(rt)&&RSIDE(rt)<=r)return DATA(rt);
    int mid=LSIDE(rt)+RSIDE(rt)>>1;
    if(l<=mid)ans=max(ans,query(l,r,LSON));
    if(mid<r)ans=max(ans,query(l,r,RSON));
    return ans;
}
int get_id(int x){
    int l=1,r=n,mid;
    while(l<=r){
        mid=l+r>>1;
        if(year[mid]>=x)r=mid-1;
        else l=mid+1;
    }
    return l;
}
void work(){
    int x,y,k;
    m=read();
    while(m--){
        x=read();y=read();
        int idx=get_id(x),idy=get_id(y);
        k=query(idx+1,idy-1,1);
        bool flag1=(year[idx]==x?true:false),flag2=(year[idy]==y?true:false);
        if(flag1){
            if(flag2){
                if(val[idx]<val[idy])printf("false\n");
                else if(k<val[idy]){
                    if(idy-idx==y-x)printf("true\n");
                    else printf("maybe\n");
                }
                else printf("false\n");
            }
            else{
                if(k<val[idx])printf("maybe\n");
                else printf("false\n");
            }
        }
        else{
            if(flag2){
                k=query(idx,idy-1,1);
                if(k<val[idy])printf("maybe\n");
                else printf("false\n");
            }
            else printf("maybe\n");
        }
    }
}
void init(){
    n=read();
    buildtree(1,n,1);
    for(int i=1;i<=n;i++){
        year[i]=read();val[i]=read();
        update(i,i,val[i],1);
    }
}
int main(){
    init();
    work();
	return 0;
}

转载于:https://www.cnblogs.com/Yangrui-Blog/p/9937170.html