P3863 序列 题解

合集 - 题解散记1(65)

1.P9933 [NFLSPC #6] 9.pop_book(); 题解2024-01-012.U390630 分考场题解2024-01-013.P9989 [Ynoi Easy Round 2023] TEST_69 题解2024-01-024.P9993 [Ynoi Easy Round 2024] TEST_133 题解2024-01-025.P10009 [集训队互测 2022] 线段树 题解2024-01-026.P9474 [yLOI2022] 长安幻世绘题解2024-01-027.P8078 [WC2022] 秃子酋长题解2024-01-038.P4402 [Cerc2007] robotic sort 机械排序题解2024-01-049.P9247 [集训队互测 2018] 完美的队列题解2024-01-0410.CF1270G Subset with Zero Sum2024-01-0511.P8575 「DTOI-2」星之河 题解2024-01-0512.P7907 [Ynoi2005] rmscne题解2024-01-0713.P4149 [IOI2011] Race 题解2024-01-0814.P5309 [Ynoi2011] 初始化 题解2024-01-0915.P3730 曼哈顿交易 题解2024-01-1016.P4093 [HEOI2016/TJOI2016] 序列 题解2024-01-1017.P9549 「PHOI-1」路虽远 题解2024-01-1118.P4103 [HEOI2014] 大工程 题解2024-01-1119.P5501 [LnOI2019] 来者不拒，去者不追 题解2024-01-1420.P9816 少项式复合幂 题解2024-01-1421.P5047 [Ynoi2019 模拟赛] Yuno loves sqrt technology II 题解2024-01-1522.P2572 [SCOI2010] 序列操作 题解2024-01-1623.P2216 [HAOI2007] 理想的正方形 题解2024-01-1724.P7167 [eJOI2020 Day1] Fountain 题解2024-01-1725.P4396 [AHOI2013] 作业 题解2024-01-1826.P3509 [POI2010] ZAB-Frog 题解2024-01-1827.2022年“腾讯杯”大学生程序设计竞赛 死去的 Elo 突然开始攻击我 题解2024-01-1828.P8512 [Ynoi Easy Round 2021] TEST_152 题解2024-01-1929.P4747 [CERC2017] Intrinsic Interval 题解2024-01-2030.CF452F Permutation 与 P2757 [国家集训队] 等差子序列 题解2024-01-2331.P8659 [蓝桥杯 2017 国 A] 数组操作 题解2024-01-2532.P10114 [LMXOI Round 1] Size 题解2024-01-2933.P6824 「EZEC-4」可乐 题解2024-01-2934.P10120 『STA - R4』冰红茶 题解2024-02-0135.P3604 美好的每一天 题解2024-02-0436.U405333 帕鲁大陆迷路的一天 题解2024-02-0637.P5398 [Ynoi2018] GOSICK 题解2024-02-0738.P5524 [Ynoi2012] NOIP2015 充满了希望 题解2024-02-1139.P4559 [JSOI2018] 列队 题解2024-02-1240.P5350 序列 与 P5586 序列 (加强版) 题解2024-02-1341.P4113 [HEOI2012] 采花 题解2024-02-1442.P3527 [POI2011] MET-Meteors 题解2024-02-1643.P3157 [CQOI2011] 动态逆序对 题解2024-02-1644.P2042 [NOI2005] 维护数列 题解2024-02-1745.P5344 【XR-1】逛森林 题解2024-02-2146.P6466 分散层叠算法(Fractional Cascading) 题解2024-02-2247.P4983 忘情 题解2024-02-2348.P1975 [国家集训队] 排队 题解2024-02-2549.P2487 [SDOI2011] 拦截导弹 题解2024-02-2850.P4690 [Ynoi2016] 镜中的昆虫 题解2024-03-0151.P3722 [AH2017/HNOI2017] 影魔 题解2024-03-0652.P3960 [NOIP2017 提高组] 列队 题解2024-03-1353.P2824 [HEOI2016/TJOI2016] 排序 与 ABC297_g Range Sort Query 题解2024-03-1554.P2633 Count on a tree 题解2024-03-1755.P3302 [SDOI2013] 森林 题解2024-03-1756.P2163 [SHOI2007] 园丁的烦恼 题解2024-03-1757.P2746 [USACO5.3] 校园网Network of Schools 题解2024-03-1758.P3939 数颜色 题解2024-03-17

59.P3863 序列 题解2024-03-18

60.P4867 Gty的妹子序列 题解2024-03-2261.P10268 符卡对决 题解2024-03-2362.P4551 最长异或路径 题解2024-04-0663.P4587 [FJOI2016] 神秘数 题解2024-04-1764.P6018 [Ynoi2010] Fusion tree 题解2024-04-1965.P10604 BZOJ4317 Atm 的树 题解2024-07-04

收起

题目链接：序列

挺神仙的好题

关于时间维上的贡献处理，之前做过一些类似的题，这题是很不错的体现题。

对于一个数的查询来说，我们暴力地看看它的变化：

时间维有个很重要的特点，当前时间点的修改只会影响后续的所有时间点。对于某个时间点 $i$，如果它的修改 $[l,r]+val$ 包括了 $pos$ 当前讨论的点。那么翻译一下意思：

$$\mathrm{从}\mathrm{当}\mathrm{前}\mathrm{时}\mathrm{间}\mathrm{点}\mathrm{到}\mathrm{后}\mathrm{续},pos\mathrm{处}\mathrm{的}\mathrm{值}\mathrm{都}\mathrm{应}\mathrm{该}+val,\mathrm{这}\mathrm{个}\mathrm{影}\mathrm{响}\mathrm{持}\mathrm{续}\mathrm{到}\mathrm{结}\mathrm{束}$$

如图所示，每个时间点仅仅只会影响它的后续时间点，在后续时间点单点查询时，都会受到前面的修改影响。

引入一个好玩的东西

这里为了帮助你理解这类跟时间维上的贡献有关的题，我们引入一个新概念----时间数组，这个概念是我为了帮助读者理解这类知识点在本文中提出。

关于时间数组，个人给出定义：

类似常见的序列维作为轴即为常见的序列数组。数轴作为轴，即为所谓的权值数组，桶之类的称呼。这里我们以时间作为轴，即时间作为下标，那么它的值即为当前时间点处的值：

$$\mathrm{定}\mathrm{义}tim\mathrm{表}\mathrm{示}x\mathrm{的}\mathrm{时}\mathrm{间}\mathrm{数}\mathrm{组},\mathrm{那}\mathrm{么}tim[i]\mathrm{表}\mathrm{示}\mathrm{当}\mathrm{时}\mathrm{间}\mathrm{点}\mathrm{为}i\mathrm{时},x\mathrm{的}\mathrm{值}\mathrm{为}\mathrm{多}\mathrm{少}$$

那么暴力的，对于每个数它的时间数组可以写成一个二维的表：

如图所示，每一行都表示一个元素的时间数组，比如蓝色块表示的含义即为：在 $time=4$ 时刻时，$x_2$ 的值。那么如果我们能维护这个时间表的变化，就能知道每个需要查的答案了。

我们将 $[x2,x3]$ 上的点在 $i=4$ 这个时刻进行修改 $+val$，如图所示，很显然，从 $i=4$ 这个时刻到最后一个时刻都应该 $+val$，这个显然是一个二维区域上的 $+val$ 操作。查询，查什么？其实查什么咱都能查的。询问：

对于某个 $x$，$time<queryTime\mathrm{\&}\mathrm{\&}val\ge queryValue$ 的数量。

翻译成我们的时间数组：

查找 $x$ 在时间表的所在行，即它所对应的时间数组下标小于 $queryTime$，值大于等于 $queryValue$ 的个数，这个是不是就很形象了。

先考虑直接暴力搞下怎么搞，二维树状数组/线段树维护区间加算法，查询外层对元素限制，内层对时间限制，然后再查权值，这岂不是：二维数据结构套权值树，一看就是三支 $\log$ 空间也巨大。回忆下，这个问题本质是什么？权值计数类问题，也是经典可差性问题。

可差性问题普及

对于一类问题的答案我们是满足这样的式子：

$$ans(\mathrm{限}\mathrm{制}\mathrm{条}\mathrm{件},l\le x\le r)=ans(\mathrm{限}\mathrm{制}\mathrm{条}\mathrm{件},x\le r)-ans(\mathrm{限}\mathrm{制}\mathrm{条}\mathrm{件},x\le l-1)$$

这类问题我们称之为可差性问题。

回到题目

这玩意带修，而且这个修改不好拆分，但是这个修改仔细观察是一个怎样的问题：

$$[i,lastTime]\mathrm{与}[l,r]\mathrm{维}\mathrm{持}\mathrm{的}\mathrm{矩}\mathrm{形}+val,\mathrm{典}\mathrm{型}\mathrm{的}\mathrm{可}\mathrm{差}\mathrm{分}\mathrm{问}\mathrm{题}$$

直接做二维差分？当你看到 $n=1e5,q=1e5$，就知道这个矩形大小为 $1e10$，一定不怎么能直接二维去做，空间一定不够。这里安利一道题：P3960 [NOIP2017 提高组] 列队 题解。

这种二维问题，离线算法最经典，想想离线算法里面降维的神器：维度扫描线降维。

维度扫描线降维普及

给出一个简单的常见模型，$[l,r]$ 上查询 $\le x$ 的个数，并且查询共 $q$ 个，直接做显然树套树啊，由于不带修且可差性，主席树也可以的。这里讲讲怎么离线扫描线降维：

对于一个查询 $[l,r]$ 这是一个可差性问题：

$$ans(val\le x,l\le i\le r)=ans(val\le x,i\le r)-ans(val\le x,i\le l)$$

这意味着一个询问我们可以拆成两个，且偏序限制从原来的三个变成了两个：

三个偏序分别为下标左右限制，值的限制，共三个限制。

两个偏序限制分别为下标的限制和值的限制，共两个限制。

所以一个常见的偏序条件限制，我们可以通过不断地可差性问题减少限制条件。两个偏序限制就是一个最纯粹的二维偏序问题，这类问题想必你一定不陌生，你在学习逆序对的时候有过这种类似写法。

对于 $i\le idx$ 的这个限制是属于序列维度上的限制，对于 $val\le x$，这个是属于值域维度上的限制，这是两个维度限制，比较暴力的做法就是直接二维数据结构做，讲讲离线扫描线怎么降维：

1. 选择一个维度进行正确的行驶方向。

2. 将另一个维度的查询挂载在这个维度的限制最大点上。

3. 选择的维度开始更新，每次到一个点就进行挂载点的更新与询问回答。

实战：

方案1:

1. 选择序列维作为我们的扫描线维，我们从下标 $1$ 到 $n$ 的方向走，因为询问的限制是 $i\le idx$，所以我们应该从小往大更新。

2. 如果一个查询的限制为 $i\le idx$，那么我们将这个询问挂载在 $i=idx$ 的点上，这样当我们从小到大更新到 $i=idx$ 时，这个时候所以的满足这个限制的点都已经进入我们的维护当中。

3. 从下标 $1$ 开始更新与查询，我们选择权值树状数组或者权值线段树维护当前情况，我们每访问一个数，我们就加入到权值数据结构中，对于一个挂载查询，我们发现：它的第一个限制一定满足，我们只需要关注第二个值域限制，并且所有满足权值限制的数已经进入权值 ds 中，正确查询即可。

代码描述

constexpr int N = 1e5 + 10;
typedef pair<int, int> pii; //(val<=v,queryId)
vector<pii> seg[N];
int n;
int a[N];
void add(int x); //权值ds加入一个数
int query(int x); //权值dds查询<=x的数的个数
int ans[N];
 
inline void solve()
{
    forn(i, 1, n)
    {
        add(a[i]);
        for (const auto [val,queryId] : seg[i])ans[queryId] += query(val);
    }
}

这样一来我们就完成了所有查询，当然可以根据实际需求增加更多参数，比如需要 $-$ 之类的。我们发现降维是降了我们选择的序列维，序列维的限制没了，只有值域限制了。当然我们还有一种写法，不需要挂载，直接记录所有查询，按照查询下标进行排序即可。

代码描述

constexpr int N = 1e5 + 10;
typedef tuple<int, int, int> tii; //(queryIdx,val<=v,queryId)
vector<tii> seg;
int n;
int a[N];
void add(int x); //权值ds加入一个数
int query(int x); //权值ds查询<=x的数的个数
int ans[N];
 
inline void solve()
{
    sort(seg.begin(), seg.end()); //按照查找的下标排序
    int curr = 1;
    forn(i, 1, n)
    {
        add(a[i]);
        while (curr < seg.size())
        {
            auto [queryIdx,val,id] = seg[curr];
            if (queryIdx > i)break;
            ans[id] += query(val);
            curr++;
        }
    }
}

是不是感觉有双指针的味道了，这个降维大大降低了空间维护和时间复杂度。

方案2:

考虑权值维作为扫描线轴，我们采用刚刚说的第二种，按照值域把原数组带着下标排序，即当前数组元素 $a[1]$ 表示值为最小的元素的下标，可以不用离散化。我们按照值域从小到大加入下标贡献，然后令一维按照值域双指针限制，进行下标限制查询，完全与上述一致。

代码描述

constexpr int N = 1e5 + 10;
typedef tuple<int, int, int> tii; //(val,queryId,queryId)
vector<tii> seg;
int n;
pii a[N]; //(值,下标)
void add(int x); //权值ds加入一个数
int query(int x); //权值dds查询<=x的数的个数
int ans[N];
 
inline void solve()
{
    sort(a + 1, a + n + 1); //按照值排序
    sort(seg.begin(), seg.end()); //按照查找的值排序
    int curr = 1;
    forn(i, 1, n)
    {
        const auto [v,idx] = a[i];
        add(idx); //加入下标贡献
        while (curr < seg.size())
        {
            auto [val,queryIdx,id] = seg[curr];
            if (val > v)break;
            ans[id] += query(queryIdx); //查找下标限制
            curr++;
        }
    }
}

这就是离线扫描线的降维思想，通过思想，我们可以很轻松地降维。

回到本题

查询几个维度？三个，对下标的限制，对时间的限制，对值域的限制。选哪个维？都差不多，我们选择最好写的序列维。序列维限制没了，剩个啥？时间维上的值域维查询。先写出原问题：

查询序列维 $=idx$ 的时间维 $<time$ 的值域维 $\ge val$ 的数量。

降维后的问题，查询当前数据结构中，时间维 $<time$，值域维 $\ge val$ 的数量。

嚯，很简单吧。现在来处理最棘手的区间修改的影响。区间修改我们也翻译成：

对序列维在 $[l,r]$ 上且时间维为 $[time,lastTime]$ 的时间数组 $+val$。这咋做，这玩意可以差分，这是可差性问题，对于可差性问题的修改而言，我们常常考虑差分修改：

对 $idx=l$ 做时间维的修改增加，对 $idx=r+1$ 做时间维的修改减少：

扫描线是序列维，我们从上往下更新，当前的数据结构即为 $i=idx$ 这一时刻的时间数组信息，我们将原来的区改拆成了：两个序列时刻的变化，挂载在对应的序列点上就行。这样问题就变为了：

时间数组上的：

区间增加 $+val$，区间查询 $[l,r]$ 上 $\ge x$ 的数量。这个就是比较经典的分块入门题教主的魔法：每个块维护有序数组，然后逐块二分就行了，区改就维护一个标记永久化就行了。时间复杂度为。$1e5$ 根号带 $\log$ 跑满差不多 $2e8$ 左右，$2s$ 绰绰有余。

细节

查询是从 $0$ 时刻开始，我们时间数组分块维护喜欢从 $1$ 开始，可以整体时间点右移一位，减少查询常数的一些方式：

同时维护块的 $max$ 和 $min$ 来辅助查询跑不跑二分，减少重构常数可以使用布尔数组，当需要查询的时候再重构块。

参照代码

#include <bits/stdc++.h>
 
// #pragma GCC optimize(2)
// #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
 
#define isPbdsFile
 
#ifdef isPbdsFile
 
#include <bits/extc++.h>
 
#else
 
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/list_update_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/exception.hpp>
#include <ext/rope>
 
#endif
 
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tii;
typedef tuple<ll, ll, ll> tll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef __int128 i128;
#define hash1 unordered_map
#define hash2 gp_hash_table
#define hash3 cc_hash_table
#define stdHeap std::priority_queue
#define pbdsHeap __gnu_pbds::priority_queue
#define sortArr(a, n) sort(a+1,a+n+1)
#define all(v) v.begin(),v.end()
#define yes cout<<"YES"
#define no cout<<"NO"
#define Spider ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
#define MyFile freopen("..\\input.txt", "r", stdin),freopen("..\\output.txt", "w", stdout);
#define forn(i, a, b) for(int i = a; i <= b; i++)
#define forv(i, a, b) for(int i=a;i>=b;i--)
#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
#define endl '\n'
//用于Miller-Rabin
[[maybe_unused]] static int Prime_Number[13] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
 
template <typename T>
int disc(T* a, int n)
{
    return unique(a + 1, a + n + 1) - (a + 1);
}
 
template <typename T>
T lowBit(T x)
{
    return x & -x;
}
 
template <typename T>
T Rand(T l, T r)
{
    static mt19937 Rand(time(nullptr));
    uniform_int_distribution<T> dis(l, r);
    return dis(Rand);
}
 
template <typename T1, typename T2>
T1 modt(T1 a, T2 b)
{
    return (a % b + b) % b;
}
 
template <typename T1, typename T2, typename T3>
T1 qPow(T1 a, T2 b, T3 c)
{
    a %= c;
    T1 ans = 1;
    for (; b; b >>= 1, (a *= a) %= c)if (b & 1)(ans *= a) %= c;
    return modt(ans, c);
}
 
template <typename T>
void read(T& x)
{
    x = 0;
    T sign = 1;
    char ch = getchar();
    while (!isdigit(ch))
    {
        if (ch == '-')sign = -1;
        ch = getchar();
    }
    while (isdigit(ch))
    {
        x = (x << 3) + (x << 1) + (ch ^ 48);
        ch = getchar();
    }
    x *= sign;
}
 
template <typename T, typename... U>
void read(T& x, U&... y)
{
    read(x);
    read(y...);
}
 
template <typename T>
void write(T x)
{
    if (typeid(x) == typeid(char))return;
    if (x < 0)x = -x, putchar('-');
    if (x > 9)write(x / 10);
    putchar(x % 10 ^ 48);
}
 
template <typename C, typename T, typename... U>
void write(C c, T x, U... y)
{
    write(x), putchar(c);
    write(c, y...);
}
 
 
template <typename T11, typename T22, typename T33>
struct T3
{
    T11 one;
    T22 tow;
    T33 three;
 
    bool operator<(const T3 other) const
    {
        if (one == other.one)
        {
            if (tow == other.tow)return three < other.three;
            return tow < other.tow;
        }
        return one < other.one;
    }
 
    T3() { one = tow = three = 0; }
 
    T3(T11 one, T22 tow, T33 three) : one(one), tow(tow), three(three)
    {
    }
};
 
template <typename T1, typename T2>
void uMax(T1& x, T2 y)
{
    if (x < y)x = y;
}
 
template <typename T1, typename T2>
void uMin(T1& x, T2 y)
{
    if (x > y)x = y;
}
 
constexpr int N = 1e5 + 10;
//块下标,块开始,块结束
int pos[N], s[N], e[N];
int n, q;
//原数组,时间数组,时间数组分块后每个块整体加的数量,每个块的有序数组
ll a[N], tim[N], tag[N], ord[N];
bool vis[N]; //减少常数,该块是否发生变化,需要重构
 
//重构有序块
inline void rebuild(const int id)
{
    if (!vis[id])return;
    forn(i, s[id], e[id])ord[i] = tim[i];
    sort(ord + s[id], ord + e[id] + 1);
    vis[id] = false;
}
 
//[l,r]+val
inline void add(const int l, const int r, const int val)
{
    const int L = pos[l], R = pos[r];
    if (L == R)
    {
        forn(i, l, r)tim[i] += val;
        vis[L] = true;
        return;
    }
    forn(i, l, e[L])tim[i] += val;
    forn(i, s[R], r)tim[i] += val;
    forn(i, L+1, R-1)tag[i] += val;
    vis[L] = vis[R] = true;
}
 
//二分有序块>=val的个数,记得tag表示整个块+了多少,需要去掉
inline int binarySize(const int id, const int val)
{
    rebuild(id);
    const ll v = val - tag[id];
    if (v > ord[e[id]])return 0;
    return e[id] - (ranges::lower_bound(ord + s[id], ord + e[id] + 1, v) - ord) + 1;
}
 
//[l,r]>=val的数量
inline int query(const int l, const int r, const ll val)
{
    if (l > r)return 0;
    const int L = pos[l], R = pos[r];
    int ans = 0;
    if (L == R)
    {
        forn(i, l, r)ans += tim[i] >= val - tag[L];
        return ans;
    }
    forn(i, l, e[L])ans += tim[i] >= val - tag[L];
    forn(i, s[R], r)ans += tim[i] >= val - tag[R];
    forn(i, L+1, R-1)ans += binarySize(i, val);
    return ans;
}
 
//修改和查询分别挂载在序列扫描线上
vector<pii> segUpdate[N];
vector<tii> segQuery[N];
int ans[N];
int ansIdx;
 
inline void solve()
{
    cin >> n >> q;
    q++; //查询时间点右移从1开始
    //时间数组分块
    const int siz = sqrt(q);
    const int cnt = (q + siz - 1) / siz;
    forn(i, 1, n)cin >> a[i];
    forn(i, 1, q)pos[i] = (i - 1) / siz + 1;
    forn(i, 1, cnt)s[i] = (i - 1) * siz + 1, e[i] = i * siz;
    e[cnt] = q;
    //第一次修改时间点从2开始
    forn(i, 2, q)
    {
        int op;
        cin >> op;
        if (op == 1)
        {
            int l, r, val;
            cin >> l >> r >> val;
            //差分挂载在序列扫描线上,[i,q]上时间数组修改
            segUpdate[l].emplace_back(i, val);
            segUpdate[r + 1].emplace_back(i, -val);
        }
        else
        {
            int pos, val;
            cin >> pos >> val;
            //查询挂载在序列扫描线上,<i <=> <=i-1,即查询[1,i-1]上<=val的数量
            segQuery[pos].emplace_back(++ansIdx, i - 1, val);
        }
    }
    forn(i, 1, n)
    {
        //当前数加入当前行所在时间数组
        add(1, q, a[i]);
        for (const auto [curr,val] : segUpdate[i])add(curr, q, val); //先修改
        for (const auto [id,curr,val] : segQuery[i])ans[id] = query(1, curr, val); //再查询另外两个限制
        add(1, q, -a[i]);
        //当前数从当前行所在时间数组删除
    }
    forn(i, 1, ansIdx)cout << ans[i] << endl;
}
 
signed int main()
{
    // MyFile
    Spider
    //------------------------------------------------------
    // clock_t start = clock();
    int test = 1;
    //    read(test);
    // cin >> test;
    forn(i, 1, test)solve();
    //    while (cin >> n, n)solve();
    //    while (cin >> test)solve();
    // clock_t end = clock();
    // cerr << "time = " << double(end - start) / CLOCKS_PER_SEC << "s" << endl;
}

$$\mathrm{时}\mathrm{间}\mathrm{复}\mathrm{杂}\mathrm{度}\mathrm{为}:O((n+q)\sqrt{q}\log \sqrt{q})$$

最后的一个普及

常见的二维数点实用方法总结：

常见的模型：

求 $x\le idx,l\le y\le r$ 的点的数量，其他模型都能通过可差性问题差分转变为这个模型。可差性问题：

$ans(\mathrm{限}\mathrm{制}\mathrm{条}\mathrm{件},l\le x\le r)=ans(\mathrm{限}\mathrm{制}\mathrm{条}\mathrm{件},x\le r)-ans(\mathrm{限}\mathrm{制}\mathrm{条}\mathrm{件},x\le l-1)$

二维数点不带修，询问离线，将 $x$ 序列扫描线转化 $+$ 权值树状数组统计 $y$ 贡献。

二维数点不带修，询问在线，主席树维护 $[0,x]$ 上关于 $y$ 权值树。

二维数点带修，询问离线，将 $time$ 作为第一序，$x$ 作为第二序，cdq 分治算 $y$ 的贡献。

二维数点带修，询问在线，树套树，对 $x$ 为第一维，$y$ 为第二维。

如果要带根号：

二维数点不带修，询问离线，序列扫描线转化 $+$ 值域分块计数。

其他情况，序列分块套值域分块。当然也有 $KD-Tree$、多叉树、$bitset$、归并树等等的一些其他解法。

PS：离线扫描线还有诸多应用，它对可差性问题的离线是出奇的好用，比如著名的莫队二次离线算法，就是借助可差性问题的差分，将查询再次挂载在扫描线上去进行二次离线地更优查询。