bzoj4605 崂山白花蛇草水

最新推荐文章于 2024-07-06 16:39:10 发布
最新推荐文章于 2024-07-06 16:39:10 发布
阅读量133 收藏
点赞数
文章标签： 数据结构与算法 php
原文链接：http://www.cnblogs.com/galaxies/p/bzoj4605.html
版权

传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=4605

【题解】

序列上的第k大我们可以用线段树内套一个能查询序列某些地方有多少数的数据结构来做。

那么平面上很显然就是kdtree。

然后我们要调调重构块大小，大概是2000.

然后发现这样还是很慢，发现一个可以优化的地方，线段树上如果这个节点是父亲的左孩子，那么不用存储。

因为我们只会查询右孩子来判断往那里走。

这样就能过啦！要跑50s啊。。。

# include <stdio.h>
# include <assert.h>
# include <string.h>
# include <iostream>
# include <algorithm>
// # include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const int M = 5e5 + 10, N = 5e6 + 10;
const int mod = 1e9+7;

# define RG register
# define ST static

int n, Q;
int REBUILD_SIZE = 2000;

inline int read() {
    int x = 0, f = 1; char ch = getchar();
    while(!isdigit(ch)) {
        if(ch == '-') f = -1;
        ch = getchar();
    }
    while(isdigit(ch)) {
        x = (x<<3) + (x<<1) + ch - '0';
        ch = getchar();
    }
    return f == 1 ? x : -x;
}

int D;
struct node {
    int d[2], mx[2], mi[2], l, r, siz, v, s;
    friend bool operator ==(node a, node b) {
        return a.d[0] == b.d[0] && a.d[1] == b.d[1];
    }
    friend bool operator <(node a, node b) {
        return a.d[D] < b.d[D];
    }
};

# define ls T[x].l
# define rs T[x].r

inline void gmax(int &x, int y) {
    if(x < y) x = y;
}
inline void gmin(int &x, int y) {
    if(x > y) x = y;
}

inline bool in(int x1, int y1, int x2, int y2, int xx1, int yy1, int xx2, int yy2) {
    return x1 <= xx1 && xx2 <= x2 && y1 <= yy1 && yy2 <= y2;    
}

inline bool out(int x1, int y1, int x2, int y2, int xx1, int yy1, int xx2, int yy2) {
    return x1 > xx2 || x2 < xx1 || y1 > yy2 || y2 < yy1;
}

inline bool cmp(int, int);

node tmp;
struct KDT {
    node T[N];
    int siz;
    int t[M], tn;
    inline void set() {
        siz = 0; T[0].siz = 0, T[0].s = 0;
    }
    inline void up(int x) {
        for (int i=0; i<2; ++i) {
            T[x].mi[i] = T[x].mx[i] = T[x].d[i];
            if(ls) gmin(T[x].mi[i], T[ls].mi[i]);
            if(rs) gmin(T[x].mi[i], T[rs].mi[i]);
            if(ls) gmax(T[x].mx[i], T[ls].mx[i]);
            if(rs) gmax(T[x].mx[i], T[rs].mx[i]);
        }
        T[x].s = T[x].v + T[ls].s + T[rs].s;
        T[x].siz = 1 + T[ls].siz + T[rs].siz;
    }
    inline void insert(int &x, int d) {
        if(!x) {
            x = ++siz;
            T[x].d[0] = T[x].mi[0] = T[x].mx[0] = tmp.d[0];
            T[x].d[1] = T[x].mi[1] = T[x].mx[1] = tmp.d[1];
            T[x].siz = 1;
        }
        if(tmp == T[x]) {
            T[x].v += tmp.v;
            T[x].s += tmp.v;
            return ;
        }
        if(tmp.d[d] < T[x].d[d]) insert(ls, d^1);
        else insert(rs, d^1);
        up(x);
    }
    inline int query(int x, int x1, int y1, int x2, int y2) {
        if(!x) return 0;
        int ret = 0;
        if(in(x1, y1, x2, y2, T[x].mi[0], T[x].mi[1], T[x].mx[0], T[x].mx[1])) return T[x].s;
        if(out(x1, y1, x2, y2, T[x].mi[0], T[x].mi[1], T[x].mx[0], T[x].mx[1])) return 0;
        if(in(x1, y1, x2, y2, T[x].d[0], T[x].d[1], T[x].d[0], T[x].d[1])) ret += T[x].v;
        ret += query(ls, x1, y1, x2, y2) + query(rs, x1, y1, x2, y2);
        return ret;
    }
    inline void getnode(int x) {
        if(!x) return ;
        getnode(ls);
        getnode(rs);
        t[++tn] = x;
    }
    inline int build(int l, int r, int d) {
        if(l>r) return 0;
        int mid = l+r>>1; D = d;
        nth_element(t+l, t+mid, t+r+1, cmp);
        int x = t[mid];
        T[x].l = build(l, mid-1, d^1);
        T[x].r = build(mid+1, r, d^1);
        up(x);
        return x;
    }
    inline int rebuild(int x, int d) {
        tn = 0;
        getnode(x);
        return build(1, tn, d);
    }
}T;

inline bool cmp(int a, int b) {
    return T.T[a] < T.T[b];
}

# undef ls
# undef rs

int xs, ys, xx, yy;
int rt[N], L[N], R[N];
int rb[N], siz, root;

inline void modify(int &x, int l, int r, int v, bool b) {
    if(!x) x = ++siz, rb[x] = REBUILD_SIZE;
    if(b) {
        T.insert(rt[x], 0);
        if(T.T[rt[x]].siz == rb[x]) {
            rt[x] = T.rebuild(rt[x], 0);
            rb[x] += REBUILD_SIZE;
        }
    }
    if(l == r) return ;
    int mid = l+r>>1;
    if(v <= mid) modify(L[x], l, mid, v, 0);
    else modify(R[x], mid+1, r, v, 1);
}

inline int sum(int x, int l, int r, int k) {
    if(l == r) return l;
    int t = T.query(rt[R[x]], xs, ys, xx, yy);
    int mid = l+r>>1;
    if(k <= t) return sum(R[x], mid+1, r, k);
    else return sum(L[x], l, mid, k-t);
}

int main() {
//    freopen("4605.in", "r", stdin);
//    freopen("4605.out", "w", stdout);
    int opt, v, lst = 0;
    n = read(), Q = read();
    T.set();
    while(Q--) {
        opt = read();
        if(opt == 1) {
//            xs = read(), ys = read(), v = read();
            xs = read() ^ lst, ys = read() ^ lst, v = read() ^ lst;
            tmp.d[0] = xs, tmp.d[1] = ys, tmp.v = tmp.s = 1;
            modify(root, 1, 1e9, v, 1);
        }
        if(opt == 2) {
//            xs = read(), ys = read(), xx = read(), yy = read(), v = read();
            xs = read() ^ lst, ys = read() ^ lst, xx = read() ^ lst, yy = read() ^ lst, v = read() ^ lst;
            int t = T.query(rt[root], xs, ys, xx, yy);        
            if(t < v) puts("NAIVE!ORZzyz."), lst = 0;
            else printf("%d\n", lst = sum(root, 1, 1e9, v));
        }
//        if(Q % 10000 == 0) cerr << Q << endl;
    }
    return 0;
}
View Code

当然放在外面写不大好

正宗的替罪羊式kdtree，是在里面写的，插入的时候顺便记录深度。

取参数A约在0.7左右，然B=log(1.0/A)

那么当深度超过子树大小/B的时候就加入重构标志。

如果同时满足子树大小>总子树大小*A，那么就重构。

（记住就好啦。。。）

然后这复杂度就很优秀了。

# include <math.h>
# include <stdio.h>
# include <assert.h>
# include <string.h>
# include <iostream>
# include <algorithm>
// # include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const int M = 5e5 + 10, N = 5e6 + 10;
const int mod = 1e9+7;

# define RG register
# define ST static

int n, Q;
const double REBUILD_FAC = 0.713, REBUILD_LOG = log(1.0 - REBUILD_FAC);
const int REBUILD_SIZE = 2000;

inline int read() {
    int x = 0, f = 1; char ch = getchar();
    while(!isdigit(ch)) {
        if(ch == '-') f = -1;
        ch = getchar();
    }
    while(isdigit(ch)) {
        x = (x<<3) + (x<<1) + ch - '0';
        ch = getchar();
    }
    return f == 1 ? x : -x;
}

int D;
struct node {
    int d[2], mx[2], mi[2], l, r, siz, v, s;
    friend bool operator ==(node a, node b) {
        return a.d[0] == b.d[0] && a.d[1] == b.d[1];
    }
    friend bool operator <(node a, node b) {
        return a.d[D] < b.d[D];
    }
};

# define ls T[x].l
# define rs T[x].r

inline void gmax(int &x, int y) {
    if(x < y) x = y;
}
inline void gmin(int &x, int y) {
    if(x > y) x = y;
}

inline bool in(int x1, int y1, int x2, int y2, int xx1, int yy1, int xx2, int yy2) {
    return x1 <= xx1 && xx2 <= x2 && y1 <= yy1 && yy2 <= y2;    
}

inline bool out(int x1, int y1, int x2, int y2, int xx1, int yy1, int xx2, int yy2) {
    return x1 > xx2 || x2 < xx1 || y1 > yy2 || y2 < yy1;
}

inline bool cmp(int, int);

int rt[N], psx;
node tmp;
struct KDT {
    node T[N];
    int siz;
    int t[M], tn;
    inline void set() {
        siz = 0; T[0].siz = 0, T[0].s = 0;
    }
    inline void up(int x) {
        for (int i=0; i<2; ++i) {
            T[x].mi[i] = T[x].mx[i] = T[x].d[i];
            if(ls) gmin(T[x].mi[i], T[ls].mi[i]);
            if(rs) gmin(T[x].mi[i], T[rs].mi[i]);
            if(ls) gmax(T[x].mx[i], T[ls].mx[i]);
            if(rs) gmax(T[x].mx[i], T[rs].mx[i]);
        }
        T[x].s = T[x].v + T[ls].s + T[rs].s;
        T[x].siz = 1 + T[ls].siz + T[rs].siz;
    }
    inline bool insert(int &x, int d, int dep) {
        if(!x) {
            x = ++siz;
            T[x].d[0] = T[x].mi[0] = T[x].mx[0] = tmp.d[0];
            T[x].d[1] = T[x].mi[1] = T[x].mx[1] = tmp.d[1];
            T[x].siz = 1; T[x].v = tmp.v, T[x].s = tmp.s;
            return dep > log(T[rt[psx]].siz)/REBUILD_LOG;
        }
        int id; bool ret;
        if(tmp.d[d] < T[x].d[d]) id = ls, ret = insert(ls, d^1, dep+1);
        else id = rs, ret = insert(rs, d^1, dep+1);
        up(x);
        if(ret) {
            if(T[id].siz > REBUILD_FAC * T[x].siz) {
                x = rebuild(x, d);
                return 0;
            }
            return 1;
        }
        return 0;
    }
    inline int query(int x, int x1, int y1, int x2, int y2) {
        if(!x) return 0;
        int ret = 0;
        if(in(x1, y1, x2, y2, T[x].mi[0], T[x].mi[1], T[x].mx[0], T[x].mx[1])) return T[x].s;
        if(out(x1, y1, x2, y2, T[x].mi[0], T[x].mi[1], T[x].mx[0], T[x].mx[1])) return 0;
        if(in(x1, y1, x2, y2, T[x].d[0], T[x].d[1], T[x].d[0], T[x].d[1])) ret += T[x].v;
        ret += query(ls, x1, y1, x2, y2) + query(rs, x1, y1, x2, y2);
        return ret;
    }
    inline void getnode(int x) {
        if(!x) return ;
        getnode(ls);
        getnode(rs);
        t[++tn] = x;
    }
    inline int build(int l, int r, int d) {
        if(l>r) return 0;
        int mid = l+r>>1; D = d;
        nth_element(t+l, t+mid, t+r+1, cmp);
        int x = t[mid];
        T[x].l = build(l, mid-1, d^1);
        T[x].r = build(mid+1, r, d^1);
        up(x);
        return x;
    }
    inline int rebuild(int x, int d) {
        tn = 0;
        getnode(x);
        return build(1, tn, d);
    }
}T;

inline bool cmp(int a, int b) {
    return T.T[a] < T.T[b];
}

# undef ls
# undef rs

int xs, ys, xx, yy;
int L[N], R[N];
int siz, root;

inline void modify(int &x, int l, int r, int v, bool b) {
    if(!x) x = ++siz;
    if(b) {
        psx = x; 
        T.insert(rt[x], 0, 0);
    }
    if(l == r) return ;
    int mid = l+r>>1;
    if(v <= mid) modify(L[x], l, mid, v, 0);
    else modify(R[x], mid+1, r, v, 1);
}

inline int sum(int x, int l, int r, int k) {
    if(l == r) return l;
    int t = T.query(rt[R[x]], xs, ys, xx, yy);
    int mid = l+r>>1;
    if(k <= t) return sum(R[x], mid+1, r, k);
    else return sum(L[x], l, mid, k-t);
}

int main() {
//    freopen("4605.in", "r", stdin);
//    freopen("4605.out", "w", stdout);
    int opt, v, lst = 0;
    n = read(), Q = read();
    T.set();
    while(Q--) {
        opt = read();
        if(opt == 1) {
//            xs = read(), ys = read(), v = read();
            xs = read() ^ lst, ys = read() ^ lst, v = read() ^ lst;
            tmp.d[0] = xs, tmp.d[1] = ys, tmp.v = tmp.s = 1;
            modify(root, 1, 1e9, v, 1);
        }
        if(opt == 2) {
//            xs = read(), ys = read(), xx = read(), yy = read(), v = read();
            xs = read() ^ lst, ys = read() ^ lst, xx = read() ^ lst, yy = read() ^ lst, v = read() ^ lst;
            int t = T.query(rt[root], xs, ys, xx, yy);        
            if(t < v) puts("NAIVE!ORZzyz."), lst = 0;
            else printf("%d\n", lst = sum(root, 1, 1e9, v));
        }
//        if(Q % 10000 == 0) cerr << Q << endl;
    }
    return 0;
}
View Code

贴两张lemon的测的图

上面这张是第一份代码

下面是第二张代码，在bzoj跑19s。

（我的老爷机比bzoj的老爷机快呀。。。）

 

转载于:https://www.cnblogs.com/galaxies/p/bzoj4605.html

aklm45097
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[BZOJ4605]崂山白花蛇草水（主席树套kd-tree）
AZUI _ oi memories
05-24 1979
题意：两种操作，在二维平面插入一个点及其权值，查询矩形区间第k大，强制在线。 之前考试考过一个矩形区间第k大的题。。当时想了各种树套树套树，算了算复杂度都没有暴力快。。后来憋了个kd-tree套主席树，就是把若干个kd-tree上的节点上的主席树弄来一起走，时间复杂度logn*sqrt(n)，空间复杂度俩log（由于那个题是离线的，我当时写的kd-tree上自底向上的线段树合并，所以实际空间复杂
【线段树套KD树】[BZOJ4605]崂山白花蛇草水
weixin_30568715的博客
06-20 139
题目描述 Description 神犇Aleph在SDOI Round2前立了一个flag：如果进了省队，就现场直播喝崂山白花蛇草水。凭借着神犇Aleph的实 力，他轻松地进了山东省省队，现在便是他履行诺言的时候了。蒟蒻Bob特地为他准备了999,999,999,999,999,999 瓶崂山白花蛇草水，想要灌神犇Aleph。神犇Aleph求（跪着的）蒟蒻Bob不要灌他...
bzoj 4605: 崂山白花蛇草水
weixin_30715523的博客
05-26 123
Description 神犇Aleph在SDOI Round2前立了一个flag：如果进了省队，就现场直播喝崂山白花蛇草水。凭借着神犇Aleph的实 力，他轻松地进了山东省省队，现在便是他履行诺言的时候了。蒟蒻Bob特地为他准备了999,999,999,999,999,999 瓶崂山白花蛇草水，想要灌神犇Aleph。神犇Aleph求（跪着的）蒟蒻Bob不要灌他，由于神犇Aleph是神犇，...
bzoj4605 崂山白花蛇草水 权值线段树套kd树
olahiuj的博客
12-18 174
Description Q次操作，要求资瓷 在(x,y)处放一个数字x 查询(x1,y1)到(x2,y2)矩形内第k大 Solution 非常裸的权值线段树套kd树，为了保证复杂度可以定期重构也可以平衡因子搞搞 Code #include &lt;stdio.h&gt; #include &lt;string.h&gt; #include &lt;algorithm&gt; #defin...
bzoj4605: 崂山白花蛇草水（权值线段树套k-dtree）
xumingyang0的博客
02-21 240
题目 #include&lt;bits/stdc++.h&gt; using namespace std; #define mid (l+r&gt;&gt;1) const int N=100002,M=3000002; struct seg{ int l,r,id; }a[M]; struct kd{ int l,r,mn[2],mx[2],sz,p[2]; }b[M]; int q,op,...
BZOJ全代码
02-05
【标题】"BZOJ全代码"所指的是一份包含BZOJ（BestCoder Zhijiang Online Judge）平台所有编程题目解决方案的压缩文件。BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力...
BZOJ第一部分
11-03
【BZOJ第一部分】 BZOJ，全称为“北京邮电大学在线评测系统”（Beijing Zhiyuan Online Judge），是中国最早的一批在线编程竞赛平台之一，它为编程爱好者提供了一个练习和检验编程技能的环境。在这个系统中，用户...
BZOJ3230相似子串测试数据
08-19
标题"BZOJ3230相似子串测试数据"指的是一个与在线判题平台BZOJ（BestCoder ZOJ，中国大学算法竞赛在线评测系统）相关的编程问题，具体问题编号为3230，涉及的主要知识点是"相似子串"的搜索和处理。在编程竞赛中，...
BZOJ上面的题目以及数据
10-13
【BZOJ】全称是“北京邮电大学在线评测系统”，它是一个为编程爱好者和参赛者提供在线编程练习和比赛的平台。该平台涵盖了多种算法和编程问题，旨在提升用户的编程技能和解决复杂问题的能力。BZOJ支持C、C++、Java等...
bzoj problem
08-21
【标题】"bzoj problem" 指的是“八中OJ（Online Judge）问题集”，这是一个在线编程竞赛平台的题目合集。八中OJ可能是某所中学的在线编程训练系统，它提供了大量的编程题目供用户练习和挑战，以提升编程能力和算法...
[BZOJ]4605 崂山白花蛇草水 线段树套KD-Tree
Le Petit Prince
12-04 424
4605: 崂山白花蛇草水 Time Limit: 80 Sec  Memory Limit: 512 MB Submit: 527  Solved: 153 [Submit][Status][Discuss] Description 神犇Aleph在SDOI Round2前立了一个flag：如果进了省队，就现场直播喝崂山白花蛇草水。凭借着神犇Aleph的实 力，他轻松地进了山东省
bzoj4605: 崂山白花蛇草水 //替罪羊式重构k-d树
蒟蒻名曰Starria
02-24 532
bzoj4605: 崂山白花蛇草水 题意 Q(&lt;=100000)次操作，支持： 在二维平面上插入一个坐标(x,y)(x,y&lt;=500000)，点权为v(&lt;=1e9)的点； 查询矩形区域内第K大点权。 强制在线。 题解 今天neither问我在做什么题，我说是一个kdt模板题 双log的话空间似乎会炸？ 所...
bzoj4605 崂山白花蛇草水（动态开点线段树逃替罪羊重构K-D tree）
Icefox的博客
06-14 235
首先我们发现它是一个三维的问题而且还强制在线 囧 我们可以考虑在外面来一个权值线段树，然后每次查询时在线段树二分即可，这样我们每个节点再套一棵K-D tree，用来查询有多少个点被框住了，然后因为是不断往里插点，所以还要替罪羊式重构维护一下K-D tree。 最后复杂度就是O(qlogwn−−√)O(qlogwn)O(qlogw\sqrt n) #include &lt;bits/stdc+...
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 672
后缀表示法。
IODD简介（1）
了不起的小白君的博客
07-04 486
XML文件通常是以纯文本形式存储的，通过标签、元素、属性等概念来组织和表达数据结构及其内容。这些标签可以是用户自定义的，允许创建符合特定数据结构的标签，XML相比HTML更加灵活，可以通过用户自定义的标签来描述更复杂的结构。IODD文件内容由XML（Extensible Markup Language）可扩展标记语言实现，用于描述文档的结构和数据的含义，其设计目的是用于数据传输和存储，以及在不同系统和应用之间进行数据交换。生成IODD文件，需要先熟悉协议栈所规定的数据类型（用于自定义各种参数的数据类型）。
【算法】插入排序
贱贱的剑
07-03 1008
介绍了两种不同的插入排序算法，以及效率对比
数据结构笔记之时间复杂度
weixin_67855163的博客
07-06 115
数据结构笔记之时间复杂度
【遥感语义分割】UNetFormer
m0_53700832的博客
07-05 1136
原文：UNetFormer: An UNet-like Transformer for Efficient Semantic Segmentation of Remotely Sensed Urban Scene Imagery Libo Wang1, 2, Rui Li1, Ce Zhang3, 4, Shenghui Fang1*, Chenxi Duan5, Xiaoliang Meng1, 2 and Peter M. Atkinson3, 6, 7 1) School of Remote Se
GT口接收数据为啥会发生字节偏移，如何判断是字节偏移而不是传输错误
最新发布
weixin_41230430的博客
07-06 875
在高速串行通信中，字节偏移可能会对数据的解析和处理产生负面影响，因为数据的顺序和位置是重要的，特别是在需要精确同步和数据完整性的应用中（如网络通信、存储系统等）。：在硬件设计和软件开发过程中，进行充分的调试和验证，特别是在数据接收和处理部分进行详细的测试，以发现和解决可能导致字节偏移的问题。总之，字节偏移是指数据在传输或处理过程中发生的位置错位现象，解决这一问题需要细致的设计和严格的验证步骤来确保数据的准确性和完整性。：确保接收端使用准确的时钟信号来恢复数据，并正确地识别和解析每个数据帧的起始和结束位置。
bzoj.org俄罗斯方块
05-06
bzoj.org是一个在线的编程题库，其中包含了很多经典算法问题和实际应用中的编程问题。其中包括了很多有趣的游戏算法问题，比如Puzzle，Tetris等。 而bzoj.org俄罗斯方块就是在该平台上的一个经典的俄罗斯方块游戏。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值