计蒜客 2238 礼物 期望 + 线段树 + 归并

最新推荐文章于 2022-06-14 18:09:53 发布
最新推荐文章于 2022-06-14 18:09:53 发布
阅读量89 收藏
点赞数
原文链接：http://www.cnblogs.com/guangheli/p/11344603.html
版权

题目链接：T2238   礼物  

考虑 $[l,r]$ 区间中哪些二元组是优秀二元组：
发现将二元组的 $x$ 按照从大到小排序，若 $y[i]$ 是这个前缀的最大值，则该二元组是优秀的.
因为数据是随机的，所以前缀最大值期望是 $log(n)$ 个的.
所以，我们可以用线段树来暴力存这些优秀的二元组.
区间合并 $pushup$ 时运用类似归并排序的方式来进行合并即可.
由于优秀二元组期望的数量是 $log$ 的，所以空间最多只会在原基础上乘一个 $log$.
我的归并写的好丑~

#include <cstdio> 
#include <algorithm>
#include <cstring>    
#include <vector> 
#define N 200006
#define ll long long   
#define mod 1000000007
#define lson t[now].ls 
#define rson t[now].rs 
#define siz (t[now].v.size() - 1)
#define setIO(s) freopen(s".in", "r" , stdin) , freopen(s".out", "w", stdout)     
using namespace std;             
int n ;           
struct P 
{ 
    ll x , y;   
    P(ll x = 0, ll y = 0) : x(x), y(y) {}  
}p[N]; 
struct Node 
{    
    int ls, rs ;          
    vector <P> v; 
}t[N << 2];   
vector <P> G, V, A;               
inline void pushup(int L, int R, int now) 
{      
    if(!rson) 
    {
        t[now].v = t[lson].v;        
    }
    else 
    {
        int p1 = 0, p2 = 0;      
        while(p1 < t[lson].v.size() && p2 < t[rson].v.size()) 
        { 
            if(t[lson].v[p1].x == t[rson].v[p2].x && t[lson].v[p1].y == t[rson].v[p2].y) ++p1, ++p2;   
            else if(t[lson].v[p1].x >= t[rson].v[p2].x && t[lson].v[p1].y >= t[rson].v[p2].y || t[lson].v[p1].x > t[rson].v[p2].x)    
            {          
                if(t[now].v.empty() || t[lson].v[p1].y > t[now].v[t[now].v.size() - 1].y) 
                {
                    t[now].v.push_back(t[lson].v[p1]);      
                }           
                ++ p1;         
            }     
            else if(t[rson].v[p2].x >= t[lson].v[p1].x && t[rson].v[p2].y >= t[lson].v[p1].y || t[rson].v[p2].x > t[lson].v[p1].x) 
            {
                if(t[now].v.empty() || t[rson].v[p2].y > t[now].v[t[now].v.size() - 1].y) 
                {
                    t[now].v.push_back(t[rson].v[p2]);    
                } 
                ++ p2; 
            }         
        }                  
        while(p1 < t[lson].v.size()) 
        {        
            if(t[now].v.empty() || (t[lson].v[p1].x <= t[now].v[siz].x && t[lson].v[p1].y > t[now].v[siz].y)) 
                t[now].v.push_back(t[lson].v[p1]); 
            ++p1; 
        }
        while(p2 < t[rson].v.size()) 
        {
            if(t[now].v.empty() || (t[rson].v[p2].x <= t[now].v[siz].x && t[rson].v[p2].y > t[now].v[siz].y)) 
                t[now].v.push_back(t[rson].v[p2]); 
            ++p2; 
        }
    }        
}
void build(int l, int r, int now) 
{ 
    if(l == r) 
    {      
        t[now].v.push_back(P(p[l].x, p[l].y));            
        return ;    
    } 
    int mid = (l + r) >> 1;        
    build(l, mid, now << 1), t[now].ls = now << 1; 
    if(r > mid)  build(mid + 1, r, now << 1 | 1), t[now].rs = now << 1 | 1;      
    pushup(l, r, now);             
} 
inline void query(int l, int r, int now, int L, int R) 
{         
    if(l >= L && r <= R)  
    {     
        if(G.empty()) 
        {
            G = t[now].v;         
        }
        else 
        {          
            V = G, A = t[now].v;              
            G.clear();   
            // merge(V, A)     
            int p1 = 0, p2 = 0;      
            while(p1 < V.size() && p2 < A.size()) 
            { 
                if(V[p1].x == A[p2].x && V[p1].y == A[p2].y) ++p1, ++p2; 
                else if(V[p1].x >= A[p2].x && V[p1].y >= A[p2].y || V[p1].x > A[p2].x)    
                {          
                    if(G.empty() || V[p1].y > G[G.size() - 1].y) 
                    {
                        G.push_back(V[p1]);      
                    }           
                    ++ p1;         
                }     
                else if(A[p2].x >= V[p1].x && A[p2].y >= V[p1].y || A[p2].x > V[p1].x) 
                {
                    if(G.empty() || A[p2].y > G[G.size() - 1].y) 
                    {
                        G.push_back(A[p2]);    
                    } 
                    ++ p2; 
                }          
            }    
            while(p1 < V.size()) 
            {
                if(G.empty() || (V[p1].x <= G[G.size() - 1].x && V[p1].y > G[G.size() - 1].y)) 
                    G.push_back(V[p1]); 
                ++p1; 
            }
            while(p2 < A.size()) 
            {
                if(G.empty() || (A[p2].x <= G[G.size() - 1].x && A[p2].y > G[G.size() - 1].y)) 
                    G.push_back(A[p2]); 
                ++p2; 
            }
        }   
        return; 
    } 
    int mid = (l + r) >> 1; 
    if(L <= mid) query(l, mid, now << 1, L, R);   
    if(R > mid) query(mid + 1, r, now << 1 | 1, L, R);    
}
int main() 
{  
    int i , j, q;  
    scanf("%d" , &n);      
    for(i = 1; i <= n ; ++i)
    {
        scanf("%lld%lld", &p[i].x, &p[i].y);                  
    }
    build(1, n, 1), scanf("%d", &q);         
    for(int cas = 1; cas <= q; ++cas) 
    {
        int l, r; 
        scanf("%d%d", &l, &r);      
        G.clear();   
        query(1, n, 1, l, r);    
        ll w = 1; 
        for(j = 0; j < G.size(); ++j) 
        {
            w *= (1ll * (ll) (G[j].x ^ G[j].y)) % mod, w %= mod;    
        }     
        printf("%lld\n", w);      
    }              
    return 0;     
}

　　

卡常版： 

#include <cstdio> 
#include <algorithm>
#include <cstring>    
#include <vector> 
#define N 200006
#define ll long long   
#define mod 1000000007        
#define lson t[now].ls 
#define rson t[now].rs 
#define siz (t[now].v.size() - 1)
#define setIO(s) freopen(s".in", "r" , stdin) , freopen(s".out", "w", stdout)     
using namespace std;             
namespace IO 
{
    char *p1, *p2, buf[100000]; 
    #define nc() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2) ? EOF : *p1 ++ )
    int rd() {
    int x = 0;
    char  c = nc();
        while (c < 48) {
            c = nc();
        }
        while (c > 47) {
            x = (((x << 2) + x) << 1) + (c ^ 48), c = nc();
        }
        return x;
    } 
    char pbuf[100000],*pp=pbuf;
    void push(const char c) {
        if(pp-pbuf==100000) fwrite(pbuf,1,100000,stdout),pp=pbuf;
        *pp++=c;
    }
    void write(int x) {
        static int sta[35];
        int top=0;
        do{sta[top++]=x%10,x/=10;}while(x);
        while(top) push(sta[--top]+'0');
        push('\n');
    }
}
int n ;           
struct P 
{ 
    ll x , y;   
    P(ll x = 0, ll y = 0) : x(x), y(y) {}  
}p[N]; 
struct Node 
{    
    int ls, rs ;          
    vector <P> v; 
}t[N << 2];   
vector <P> G, V, A;               
inline void pushup(int L, int R, int now) 
{     
    if(!rson) 
    {
        t[now].v = t[lson].v;        
    }
    else 
    {
        int p1 = 0, p2 = 0;      
        while(p1 < t[lson].v.size() && p2 < t[rson].v.size()) 
        { 
            if(t[lson].v[p1].x == t[rson].v[p2].x && t[lson].v[p1].y == t[rson].v[p2].y) ++p1, ++p2;   
            else if(t[lson].v[p1].x >= t[rson].v[p2].x && t[lson].v[p1].y >= t[rson].v[p2].y || t[lson].v[p1].x > t[rson].v[p2].x)    
            {          
                if(t[now].v.empty() || t[lson].v[p1].y > t[now].v[t[now].v.size() - 1].y) 
                {
                    t[now].v.push_back(t[lson].v[p1]);      
                }           
                ++ p1;         
            }     
            else if(t[rson].v[p2].x >= t[lson].v[p1].x && t[rson].v[p2].y >= t[lson].v[p1].y || t[rson].v[p2].x > t[lson].v[p1].x) 
            {
                if(t[now].v.empty() || t[rson].v[p2].y > t[now].v[t[now].v.size() - 1].y) 
                {
                    t[now].v.push_back(t[rson].v[p2]);    
                } 
                ++ p2; 
            }         
        }                  
        while(p1 < t[lson].v.size()) 
        {        
            if(t[now].v.empty() || (t[lson].v[p1].x <= t[now].v[siz].x && t[lson].v[p1].y > t[now].v[siz].y)) 
                t[now].v.push_back(t[lson].v[p1]); 
            ++p1; 
        }
        while(p2 < t[rson].v.size()) 
        {
            if(t[now].v.empty() || (t[rson].v[p2].x <= t[now].v[siz].x && t[rson].v[p2].y > t[now].v[siz].y)) 
                t[now].v.push_back(t[rson].v[p2]); 
            ++p2; 
        }
    }        
}
void build(int l, int r, int now) 
{ 
    if(l == r) 
    {      
        t[now].v.push_back(P(p[l].x, p[l].y));            
        return ;    
    } 
    int mid = (l + r) >> 1;        
    build(l, mid, now << 1), t[now].ls = now << 1; 
    if(r > mid)  build(mid + 1, r, now << 1 | 1), t[now].rs = now << 1 | 1;      
    pushup(l, r, now);             
} 
inline void query(int l, int r, int now, int L, int R) 
{         
    if(l >= L && r <= R)  
    {     
        if(G.empty()) 
        {
            G = t[now].v;         
        }
        else 
        {          
            V = G, A = t[now].v;              
            G.clear();   
            // merge(V, A)     
            int p1 = 0, p2 = 0;      
            while(p1 < V.size() && p2 < A.size()) 
            { 
                if(V[p1].x == A[p2].x && V[p1].y == A[p2].y) ++p1, ++p2; 
                else if(V[p1].x >= A[p2].x && V[p1].y >= A[p2].y || V[p1].x > A[p2].x)    
                {          
                    if(G.empty() || V[p1].y > G[G.size() - 1].y) 
                    {
                        G.push_back(V[p1]);      
                    }           
                    ++ p1;         
                }     
                else if(A[p2].x >= V[p1].x && A[p2].y >= V[p1].y || A[p2].x > V[p1].x) 
                {
                    if(G.empty() || A[p2].y > G[G.size() - 1].y) 
                    {
                        G.push_back(A[p2]);    
                    } 
                    ++ p2; 
                }          
            }    
            while(p1 < V.size()) 
            {
                if(G.empty() || (V[p1].x <= G[G.size() - 1].x && V[p1].y > G[G.size() - 1].y)) 
                    G.push_back(V[p1]); 
                ++p1; 
            }
            while(p2 < A.size()) 
            {
                if(G.empty() || (A[p2].x <= G[G.size() - 1].x && A[p2].y > G[G.size() - 1].y)) 
                    G.push_back(A[p2]); 
                ++p2; 
            }
        }   
        return; 
    } 
    int mid = (l + r) >> 1; 
    if(L <= mid) query(l, mid, now << 1, L, R);   
    if(R > mid) query(mid + 1, r, now << 1 | 1, L, R);    
}
int main() 
{ 
    // setIO("input"); 
    using namespace IO;      
    int i , j, q;  
    n = rd();   
    for(i = 1; i <= n ; ++i)
    {
        p[i].x = (ll) rd(); 
        p[i].y = (ll) rd();        
    }
    build(1, n, 1);          
    q = (ll) rd();   
    for(int cas = 1; cas <= q; ++cas) 
    {
        int l, r;  
        l = rd(), r = rd();    
        G.clear();   
        query(1, n, 1, l, r);    
        ll w = 1; 
        for(j = 0; j < G.size(); ++j) 
        {
            w *= (1ll * (ll) (G[j].x ^ G[j].y)) % mod, w %= mod;    
        }     
        write(w);   
    }            
    fwrite(pbuf,1,pp-pbuf,stdout);  
    return 0;     
}

　　

转载于:https://www.cnblogs.com/guangheli/p/11344603.html

weixin_30419799
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【算法】线段树详解
_Alexander_的博客
08-20 5万+
线段树，是一种二叉搜索树。它功能强大，支持区间求和，区间最大值，区间修改，单点修改等操作。 它的时间复杂度是O(nlogn)的。 十分良心，欢迎阅读！
LDUOJ 时间锁链 （状压+线段树 ）
01-06
时间锁链 时间限制: 1 Sec 内存限制: 128 MB [命题人:admin] [ Edit] [ TestData] 题目描述 当墨老师找到封闭时间环中最小的逆序对数后，他就可以将时间环展开成一个长L的时间锁链（我们可以将之看成是一根很长的...
找质数（（
wwenddy的博客
08-15 112
一天蒜头君猜想，是不是所有的偶数（除了22），都可以用两个质数相加得到呢？于是聪明的蒜头君就找你来验证了。 输入格式 第一行输入一个整数tt表示测试组数。 接下来tt行，每行一个整数nn。 输出格式 输出两个整数，因为答案可能有多个，所有要求输出的这两个整数是所有答案中字典序最小的。 数据范围 对于30\%30%的数据1 \le t \le 10^31≤t≤103。 对于60\%60%的数据1 \le t \le 10^51≤t≤105。 对于100\%100%...
[计蒜客T2238]礼物_线段树_归并排序_概率期望
dianan0938的博客
07-27 109
礼物 题目大意： 数据范围： 题解： 这题有意思啊（$md$卡常 直接做怎么做？ 随便上个什么东西，维护一下矩阵乘和插入，比如说常数还算小的$KD-Tree$（反正我是没见人过过 我们漏掉了一个条件，就是所有二元组都是随机的。 这个条件很好，它几乎就保证了，任选一个区间的话，优秀二元组只有$log$个。 这是为什么呢？ 其实区间内，优秀二元组的个数，就相当...
计蒜客T1010计算线段长度
m0_62171651的博客
01-08 779
已知线段的两个端点的坐标 A(X_a,Y_a),B(X_b,Y_b)A(Xa​,Ya​),B(Xb​,Yb​)，求线段 ABAB 的长度。 蒜头君老师告诉了你计算公式如下： 输入格式 共两行。 第一行是两个实数 X_a, Y_aXa​,Ya​，即 AA 的坐标。 第二行是两个实数 X_b, Y_bXb​,Yb​，即 BB 的坐标。 输入中所有实数的绝对值均不超过 1000010000。 输出格式 一个实数，即线段ABAB的长度，保留到小数点后3位。 #include<st...
计蒜客T1010输出线段长度
qq_35832227的博客
07-01 589
#include <stdio.h> #include <math.h>//要开方平方所以要用到这个math头文件 void main(){ double Xa,Ya,Xb,Yb; double length; scanf("%lf %lf \n%lf %lf",&Xa,&Ya,&Xb,&Yb);//注意double...
计蒜客T1010 c++
m0_67741519的博客
06-14 92
计蒜客 c++ 计算线段长度
[ZJOI2015] 幻想乡战略游戏（树链剖分 + 线段树二分 + 带权重心）
03-15 3932
点分治不可能这一辈子都不可能，高举我树剖大旗！
CodeForces_1348EF – Phoenix and Memory 贪心+线段树找区间最小值
01-03
这题如果没有输出2个解就很简单。 是个之前做过的类型： 把所有限制按R排序， 然后每次取出R最小的，然后从其L开始选，尽量选能选的中最小的。 这样选如果能选完，就说明有解。 贪心正确性显然：R大的至少可以选则R...
线段树（模板+例题——郭神）
02-17
线段树（模板+例题——郭神） 私用，随意拿！
线段树+面积并.cpp
04-19
线段树+面积并
线段树（单点查询+区间求和）无lazy标记
01-20
原理就大概如图所示，线段树的每个节点都是原数组的一段区间和，而叶子节点就是原数组对应 的值 建树代码： void build(int p,int lf,int rt){//建树 ans[p]=0; if(lf==rt) { ans[p]=A[lf]; return ; } int mid...
计蒜客 T1010反向输出一个三位数
Iskt21的博客
01-13 130
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int m = sc.nextInt(); if (m >= 100 && m <= 999) { //个位:g //十位:s .
vb+SQL车辆管理系统设计(论文+源代码).zip
06-16
vb+SQL车辆管理系统设计(论文+源代码)
基于C#编程实现事件总线源码+项目说明.zip
06-16
事件总线这个概念对你来说可能很陌生，但提到观察者（发布-订阅）模式，你也许就很熟悉。事件总线是对发布-订阅模式的一种实现。它是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。
request-validator.cpython-37
06-16
request-validator.cpython-37
PatchNavicat是一个用于po姐Navicat数据库管理工具的插件或工具
06-16
Navicat是一款流行的数据库前端用户界面工具，支持多种数据库系统，如MySQL、SQL Server、SQLite、Oracle和PostgreSQL等。以下是关于PatchNavicat的使用步骤和相关信息： 1. 将下载的PatchNavicat.exe文件复制到Navicat的安装目录下，确保与navicat.exe文件位于同一目录。 2. 在安装Navicat后，确保Navicat程序已经完全关闭。 3. 双击PatchNavicat.exe文件运行它。在某些情况下，可能需要选择Navicat的安装目录或navicat.exe文件作为目标进行po姐。 如果PatchNavicat运行成功并显示“Patch Success!”或类似的消息，则表示Navicat已经被成功po姐。此时，可以重新启动Navicat并检查是否需要注册或输入激活码。如果不需要，则说明po姐成功。使用po姐工具可能存在法律和道德风险。尽管许多用户选择使用po姐版软件来节省成本，但这可能违反了软件的使用协议和版权法。
苹果cms v8漂亮精品动漫风格网站模板
06-16
苹果CMS精品动漫风格网站模板，新春喜气自适应模板视频影视网站模板，复制文件template目录，后台设置模板为2016new目录刷新即可。
【课件】1.2.2（补充）_各个硬件的工作原理.pdf
最新发布
06-16
【课件】1.2.2（补充）_各个硬件的工作原理
Python 线段树
10-06
Python中的线段树是一种用于解决区间查询问题的数据结构。线段树可以被看作是一棵二叉树，其中每个节点代表了一个区间。每个内部节点都有两个子节点，左子节点代表区间的左半部分，右子节点代表区间的右半部分。叶...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值