Codeforces 1139F Dish Shopping 树状数组套平衡树 || 平衡树

最新推荐文章于 2019-12-03 19:56:20 发布
最新推荐文章于 2019-12-03 19:56:20 发布
阅读量144 收藏
点赞数
原文链接：http://www.cnblogs.com/CJLHY/p/10612071.html
版权

Dish Shopping

将每个物品拆成p 和 s 再加上人排序。 然后问题就变成了， 对于一个线段(L - R)，

问有多少个(li, ri)满足  L >= li && R >= ri， 这个东西可以直接树状数组套平衡树维护。

但是这个题目有个特殊性，因为排好序之后不会存在 li > L && ri > R的点， 所以可以直接

用平衡树， 或者线段树去维护这个东西。

 

平板电视

#include<bits/stdc++.h>
#include <bits/extc++.h>
#define LL long long
#define fi first
#define se second
#define mk make_pair
#define PLL pair<LL, LL>
#define PLI pair<LL, int>
#define PII pair<int, int>
#define SZ(x) ((int)x.size())
#define ull unsigned long long

using namespace std;
using namespace __gnu_pbds;

const int N = 1e5 + 7;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
const double PI = acos(-1);

int n, m, tot, ans[N * 3], hs[N], cnt;
int p[N], s[N], b[N], inc[N], pref[N];

struct event {
    int p, b, id, op, rp;
    bool operator < (const event& rhs) const {
        if(p == rhs.p) return op < rhs.op;
        else return p < rhs.p;
    }
} e[N * 3];

template <class T>
using Tree = tree<T, null_type, std::less<T>, rb_tree_tag,tree_order_statistics_node_update>;

struct Bit {
    Tree<PII> T[N];
    void add(int x, PII v) {
        for(int i = x; i <= cnt; i += i & -i)
            T[i].insert(v);
    }
    void del(int x, PII v) {
        for(int i = x; i <= cnt; i += i & -i)
            T[i].erase(v);
    }
    int sum(int x, int R) {
        int ans = 0;
        for(int i = x; i; i -= i & -i)
            ans += T[i].order_of_key(mk(R, INT_MAX));
        return ans;
    }
} bit;

int getPos(int x) {
    return upper_bound(hs + 1, hs + 1 + cnt, x) - hs - 1;
}

int main() {
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) scanf("%d", &p[i]);
    for(int i = 1; i <= n; i++) scanf("%d", &s[i]);
    for(int i = 1; i <= n; i++) scanf("%d", &b[i]);
    for(int i = 1; i <= n; i++) {
        e[++tot] = event{p[i], b[i], i, 0, p[i]};
        e[++tot] = event{s[i], b[i], i, 2, p[i]};
        hs[++cnt] = p[i] - b[i];
    }
    for(int i = 1; i <= m; i++) scanf("%d", &inc[i]);
    for(int i = 1; i <= m; i++) scanf("%d", &pref[i]);
    for(int i = 1; i <= m; i++) e[++tot] = event{inc[i], pref[i], n + i, 1, 0};

    sort(hs + 1, hs + 1 + cnt);
    cnt = unique(hs + 1, hs + 1 + cnt) - hs - 1;

    sort(e + 1, e + 1 + tot);
    for(int i = 1; i <= tot; i++) {
        int p = e[i].p, b = e[i].b, rp = e[i].rp;
        if(e[i].op == 0) {
            bit.add(getPos(rp - b), mk(rp + b, e[i].id));
        } else if(e[i].op == 1) {
            ans[e[i].id] = bit.sum(getPos(p - b), p + b);
        } else {
            bit.del(getPos(rp - b), mk(rp + b, e[i].id));
        }
    }
    for(int i = n + 1; i <= n + m; i++) printf("%d ", ans[i]);
    puts("");
    return 0;
 }

/*
*/
View Code

 

treap, 为啥我的treap好慢啊啊啊。

#include<bits/stdc++.h>
#define LL long long
#define fi first
#define se second
#define mk make_pair
#define PLL pair<LL, LL>
#define PLI pair<LL, int>
#define PII pair<int, int>
#define SZ(x) ((int)x.size())
#define ull unsigned long long

using namespace std;

const int N = 1e5 + 7;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
const double PI = acos(-1);

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

int n, m, tot, ans[N * 3], hs[N], cnt;
int p[N], s[N], b[N], inc[N], pref[N];

struct event {
    int p, b, id, op, rp;
    bool operator < (const event& rhs) const {
        if(p == rhs.p) return op < rhs.op;
        else return p < rhs.p;
    }
} e[N * 3];

struct node {
    node* ch[2];
    int key, fix, sz, cnt;
    void update() {
        sz = ch[0]->sz + ch[1]->sz + cnt;
    }
} base[N * 20];

typedef node* P_node;
P_node len = base;

struct Treap {
    node nil;
    P_node root, null;
    Treap() {
        root = null = &nil;
        null->key = null->fix = inf;
        null->sz = null->cnt = 0;
        null->ch[0] = null->ch[1] = null;
    }
    P_node newnode(int tkey) {
        len->key = tkey;
        len->fix = rng();
        len->ch[0] = len->ch[1] = null;
        len->sz = len->cnt = 1;
        return len++;
    }
    void rot(P_node &p, int d) {
        P_node k = p->ch[d ^ 1];
        p->ch[d ^ 1] = k->ch[d];
        k->ch[d] = p;
        p->update();
        k->update();
        p = k;
    }
    void _Insert(P_node &p, int tkey) {
        if(p == null) {
            p = newnode(tkey);
        } else if(p->key == tkey) {
            p->cnt++;
        } else {
            int d = tkey > p->key;
            _Insert(p->ch[d], tkey);
            if(p->ch[d]->fix > p->fix) {
                rot(p, d ^ 1);
            }
        }
        p->update();
    }

    void _Delete(P_node &p, int tkey) {
        if(p == null) return;
        if(p->key == tkey) {
            if(p->cnt > 1) p->cnt--;
            else if(p->ch[0] == null) p = p->ch[1];
            else if(p->ch[1] == null) p = p->ch[0];
            else {
                int d = p->ch[0]->fix > p->ch[1]->fix;
                rot(p, d);
                _Delete(p->ch[d], tkey);
            }
        } else {
            _Delete(p->ch[tkey > p->key], tkey);
        }
        p->update();
    }
    int _Kth(P_node p, int k) {
        if(p == null || k < 1 || k > p->sz) return 0;
        if(k < p->ch[0]->sz + 1) return _Kth(p->ch[0], k);
        if(k > p->ch[0]->sz + p->cnt) return _Kth(p->ch[1], k - p->ch[0]->sz - p->cnt);
        return p->key;
    }
    int _Rank(P_node p, int tkey, int res) {
        if(p == null) return -1;
        if(p->key == tkey) return p->ch[0]->sz + res + 1;
        if(tkey < p->key) return _Rank(p->ch[0], tkey, res);
        return _Rank(p->ch[1], tkey, res + p->ch[0]->sz + p->cnt);
    }
    int _Pred(P_node p, int tkey){
        if(p == null) return -inf;
        if(tkey <= p->key) return _Pred(p->ch[0], tkey);
        return max(p->key, _Pred(p->ch[1], tkey));
    }
    int _Succ(P_node p, int tkey){
        if(p == null) return inf;
        if(tkey >= p->key) return _Succ(p->ch[1], tkey);
        return min(p->key, _Succ(p->ch[0], tkey));
    }
    int _Query(P_node p, int tkey) {
        if(p == null) return 0;
        if(p->key > tkey) return _Query(p->ch[0], tkey);
        else if(p->key < tkey) return p->cnt + p->ch[0]->sz + _Query(p->ch[1], tkey);
        else return p->cnt + p->ch[0]->sz;
    }
    void Insert(int tkey){ _Insert(root,tkey); }
    void Delete(int tkey){ _Delete(root,tkey); }
    int Kth(int k){ return _Kth(root,k); }
    int Rank(int tkey){ return _Rank(root,tkey,0); }
    int Pred(int tkey){ return _Pred(root,tkey); }
    int Succ(int tkey){ return _Succ(root,tkey); }
    int Query(int tkey){ return _Query(root, tkey); }
}tp;


struct Bit {
    Treap T[N];
    void add(int x, int v) {
        for(int i = x; i <= cnt; i += i & -i)
            T[i].Insert(v);
    }
    void del(int x, int v) {
        for(int i = x; i <= cnt; i += i & -i)
            T[i].Delete(v);
    }
    int sum(int x, int R) {
        int ans = 0;
        for(int i = x; i; i -= i & -i)
            ans += T[i].Query(R);
        return ans;
    }
} bit;

int getPos(int x) {
    return upper_bound(hs + 1, hs + 1 + cnt, x) - hs - 1;
}

int main() {
    srand(time(NULL));
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) scanf("%d", &p[i]);
    for(int i = 1; i <= n; i++) scanf("%d", &s[i]);
    for(int i = 1; i <= n; i++) scanf("%d", &b[i]);
    for(int i = 1; i <= n; i++) {
        e[++tot] = event{p[i], b[i], i, 0, p[i]};
        e[++tot] = event{s[i], b[i], i, 2, p[i]};
        hs[++cnt] = p[i] - b[i];
    }
    for(int i = 1; i <= m; i++) scanf("%d", &inc[i]);
    for(int i = 1; i <= m; i++) scanf("%d", &pref[i]);
    for(int i = 1; i <= m; i++) e[++tot] = event{inc[i], pref[i], n + i, 1, 0};

    sort(hs + 1, hs + 1 + cnt);
    cnt = unique(hs + 1, hs + 1 + cnt) - hs - 1;

    sort(e + 1, e + 1 + tot);
    for(int i = 1; i <= tot; i++) {
        int p = e[i].p, b = e[i].b, rp = e[i].rp;
        if(e[i].op == 0) {
            bit.add(getPos(rp - b), rp + b);
        } else if(e[i].op == 1) {
            ans[e[i].id] = bit.sum(getPos(p - b), p + b);
        } else {
            bit.del(getPos(rp - b), rp + b);
        }
    }
    for(int i = n + 1; i <= n + m; i++) printf("%d ", ans[i]);
    puts("");
    return 0;
 }

/*
*/
View Code

 

转载于:https://www.cnblogs.com/CJLHY/p/10612071.html

afd5154
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Codeforces 785 E. Anton and Permutation （树套树）
qq_43900769的博客
04-20 2365
http://codeforces.com/problemset/problem/785/E 题意： 给定一个 1-n的排列， 现在有m次操作， 每次操作交换 a[l]，a[r] 求交换完之后整个序列的逆序对数是多少。 E. Anton and Permutation Anton likes permutations, especially he likes to permute their el...
[Codeforces]849E Goodbye Souvenir
L183287669的博客
09-14 209
　　又是一道比较新的模板题吧，即使是在Codeforces上小C还是贴了出来。 Description 　　给定一个长度为n的序列a1~an，每个元素代表一种颜色。m次操作，每次操作为两种中的一种： 　　　　1 p x：将第p个位置上的颜色修改为x； 　　　　2 l r：询问[l,r]区间，求该区间内的每种颜色的“最大出现位置-最小出现位置”之和。 Input 　　第一...
树状数组整理（4.冒牌平衡树）
00000000
03-31 1109
算是一种应用吧……水过某些题的时候可以一试？ 平衡树一般支持插入、删除、查找、排名、k小、前驱、后继什么的…… 单看插入删除查找，都是离散一下计数就可以做到的；排名可以转化为求比查询元素小的数有多少个；k小也许可以利用排名来搞；至于前驱后继也可以转化为先排名后k小的问题 因为可以离散嘛，不妨直接讨论所有参与操作的数字都在1..n的状况： 前三样加加减减白给的，一个a[1..n]++--搞定
二逼平衡树（树套树）
ChrysanDog的博客
12-29 1040
题目描述 您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作： 1.1.1.查询kkk在区间内的排名 2.2.2.查询区间内排名为kkk的值 3.3.3.修改某一位值上的数值 4.4.4.查询kkk在区间内的前驱(前驱定义为小于xxx，且最大的数) 5.5.5.查询kkk在区间内的后继(后继定义为大于xxx，且最小的数) 输入格式 第一行两个数 n,mn,mn,m 表...
codeforces 19D D. Points 树套树
weixin_34220834的博客
04-21 98
D. Points Time Limit: 1 Sec  Memory Limit: 256 MB 题目连接 http://codeforces.com/contest/19/problem/D Description Pete and Bob invented...
Codeforces 1324 F. Maximum White Subtree (树形dp) /详解
01-03
F. Maximum White Subtree time limit per test2 seconds memory limit per test256 megabytes inputstandard input outputstandard output You are given a tree consisting of n vertices. A tree is a connected ...
CodeForces_1348EF – Phoenix and Memory 贪心+线段树找区间最小值
01-03
这题如果没有输出2个解就很简单。 是个之前做过的类型： 把所有限制按R排序， 然后每次取出R最小的，然后从其L开始选，尽量选能选的中最小的。 这样选如果能选完，就说明有解。 贪心正确性显然：R大的至少可以选则R...
Codeforces 1083 A. The Fair Nut and the Best Path（树形DP）
01-03
回头重新看了一下题意，这不就是求最长链的树形dp裸题吗？ 代码如下： #include #define ll long long #define inf 0x3f3f3f3f #define mod 1000000007 #define PI acos(-1) #define fi first #define se second #...
Python库 | codeforces_api-0.3.3.tar.gz
05-13
资源分类：Python库 所属语言：Python 资源全名：codeforces_api-0.3.3.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
CodeForces – 1328F Make k Equal(模拟)
01-03
题目大意：给出一个数列 a ，现在有两种操作： 找到一个最小值，使其值加一 找到一个最大值，使其...因为两种操作无非是从最小值往上一直加一，或者是从最大值一直往下减一，不难想到前缀和，所以这里我定义四个数组：
codeforces 1042d Petya and Array 线段树|树状数组|平衡树
KIDGIN7439的专栏
01-21 284
D. Petya and Array time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Petya has an array aa consisting of nn integers. He has learne...
[模板]二逼平衡树（树套树）
C202044zxy的博客
12-03 131
一、题目 点此看题 二、解法 所谓树套树呢？就是把两棵不同的树套在一起，以达到意想不到的效果。 对于这道题，可以线段树套平衡树，也就是每个点维护一个平衡树，下面我来分别讲解一下每种操作。 查询k在区间内的排名 把区间分解成线段树上的点，查询kkk在每个点上的排名-1然后累加，最后在加上1。 查询区间内排名为k的值 先二分一个值，然后用拿到这个值的最大排名（我没有把相同的点合并为一个点），然后找到...
[均摊 平衡树 || 线段树] Codeforces 438D #250 (Div. 1) D. The Child and Sequence
雯舞
01-19 500
传说中的cf250 china场 题意就是区间取模 区间求和 单点修改 每个数被取模了 肯定会减小一半 一个数最多只要log次就能不动 把相同的数缩成一段 每一段最多被修改O(log n) 次 每一次修改会增加O(1) 段 用平衡树维护 复杂度是 nlog2n 的 对应的势能函数是每一段的log值的和 总势能是(n+m)logn 每次操作log复杂度 能够降1 那么就是两个lo
【CodeForces - 746F】：Music in Car【平衡树模板】
KobeDuu
08-29 212
题目： CodeForces - 746F: Music in Car 题意： 给定a[]，b[]，你要选一段连续的区间，使得区间b[]之和小于等于K，并且区间a[]之和最大，同时也有W次机会将b[i]=ceil(b[i]/2) 分析： 假设没有修改的机会，因为a[]，b[]都是正整数，区间具有单调性，所以可以用尺取法找到所有合法的区间，更新答案；现在有修改的机会，贪心的想，肯定要修改区...
codeforces 702F 可持久化平衡树
make_it_for_good的博客
08-19 1812
题意：有n种T恤，每种有一个价格ci和品质qi。有m个人要买T恤，第i个人有vi块钱，每个人每次都买一件能买得起的qi最大的T恤。一个人只能买一种T恤一件，所有人互不影响。求最后每个人买了多少件T恤。将T恤排序。用可持久化平衡树维护所有人。扫一遍T恤，将钱数大于当前T恤价值的人拿出来，把他们的钱数减当前价格，再塞回去。当减完价格后这个集合的最小元素不一定大于另一个集合的最大元素。这样就不能merge
【CodeForces1139F】Dish Shopping
cz_xuyixuan的博客
04-05 385
【题目链接】 点击打开链接 【思路要点】 将一个人 (inc,pref)(inc,pref)(inc,pref) 看做平面上一点 (x,y)(x,y)(x,y) ，一件物品即为对于一个对称轴与 XXX 轴平行的等腰三角形的 +1+1+1 操作。 考虑扫描线，在 x=px=px=p 处加入一对直线，并在 x=s+1x=s+1x=s+1 处删除它们，我们需要在这个过程中支持询问某一点在多少...
codeforces#1139F. Dish Shopping （离散化数组数组+ 扫描线）
diandu7489的博客
04-21 140
膜拜大佬：https://blog.csdn.net/xyz32768/article/details/88831233 题目链接： http://codeforces.com/contest/1139/problem/F 题意： 有n个物品，物品有三个属性分别是$p_i，s_i，b_i$ 有m个人，人有两个属性分别是$pref_j$，$inc_j$ 一个人能买某...
Codeforces 1139F（树状数组+扫描线）
04-09 169
题目传送 做法 对于每个人，inc为x，pref为y；对于每道菜，p和s为x，b为y 于是根据题意有\[p[i]<=x<=s[i]\]\[p[i]+b[i]<=x+y\]\[p[i]-b[i]<=x-y\] 把所有出现的点都离散化一下，然后开始扫x轴 对于x+y和x-y这两个函数，分别开一个树状数组去维护合法点的个数 #include <cstdio&g...
codeforces 树状数组
最新发布
07-28
树状数组（Fenwick Tree）是一种用于高效处理区间和查询的数据结构，常用于解一维数组的前缀和、区间更新和查询等问题。 在 Codeforces 上，树状数组常被用来解决一些与区间和查询有关的问题。它可以在 O(logn) 的时间内完成单点更新和查询，以及区间求和等操作。 下面是一个简单的示例代码，展示了如何实现一个基本的树状数组： ```cpp #include <iostream> #include <vector> using namespace std; // 获取最低位的 1 int getLowbit(int x) { return x & -x; } // 树状数组的单点更新操作 void update(vector<int>& fenwick, int index, int delta) { while (index < fenwick.size()) { fenwick[index] += delta; index += getLowbit(index); } } // 树状数组的前缀和查询操作 int query(vector<int>& fenwick, int index) { int sum = 0; while (index > 0) { sum += fenwick[index]; index -= getLowbit(index); } return sum; } int main() { int n; cin >> n; vector<int> fenwick(n + 1, 0); // 初始化树状数组 for (int i = 1; i <= n; i++) { int val; cin >> val; update(fenwick, i, val); } // 进行查询操作 int q; cin >> q; while (q--) { int type; cin >> type; if (type == 1) { int index, delta; cin >> index >> delta; update(fenwick, index, delta); } else if (type == 2) { int l, r; cin >> l >> r; int sum = query(fenwick, r) - query(fenwick, l - 1); cout << sum << endl; } } return 0; } ``` 在这个示例中，我们使用了一个长度为 n 的数组 `fenwick` 来表示树状数组。`update` 函数用于更新树状数组中的某个元素，`query` 函数用于查询树状数组中某个区间的和。 你可以根据具体问题的要求进行相应的修改和扩展。希望对你有所帮助！如果有任何疑问，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值