树状数组 · 信息学学习手册2-离散化与逆序对

第 3 篇 · 离散化与逆序对

本篇例题（3 道，难度递增）：

编号题目来源主考

E 逆序对洛谷 P1908 离散化 + 权值树状数组计数

F Balanced Photo G 洛谷 P3608（USACO Gold）正反两遍扫描 + 严格大于

J 楼兰图腾洛谷 P10589 四组计数 + 乘法原理

编号	题目	来源	主考
E	逆序对	洛谷 P1908	离散化 + 权值树状数组计数
F	Balanced Photo G	洛谷 P3608（USACO Gold）	正反两遍扫描 + 严格大于
J	楼兰图腾	洛谷 P10589	四组计数 + 乘法原理

第五章离散化

5.1 为什么必须离散化

权值树状数组要求"下标 = 值"，而值域常和 nnn 差好几个数量级：P1908 的 n≤5×105n\le5\times10^5n≤5×105 却有 ai≤109a_i\le10^9ai≤109，直开值域数组约 4 GB；P3608 同理；P10589 给的是排列，值域本来就是 1..n1..n1..n。

代码对"值"只做两件事：add(rk,1) 插入、sum(rk) 问"不超过它的有几个"。两件事都只依赖大小关系 ，与具体数值无关，所以把 aia_iai 换成"第几小"，答案不变：

ai<aj ⟺ rki<rkj,ai=aj ⟺ rki=rkja_i<a_j\iff rk_i<rk_j,\qquad a_i=a_j\iff rk_i=rk_jai<aj⟺rki<rkj,ai=aj⟺rki=rkj

离散化后值域是 1..m⊆1..n1..m\subseteq1..n1..m⊆1..n，数组开 NNN 就够，add 的上界写 mmm。

5.2 三步法

复制：b[i]=a[i]（b 排序用，a 原样保留）；
排序去重 ：sort，m = unique(b+1,b+n+1)-(b+1)；
查排名 ：rk[i] = lower_bound(b+1,b+m+1,a[i])-b。

cpp 复制代码

#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, m, a[N], b[N], rk[N];
int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) { scanf("%d", &a[i]); b[i] = a[i]; }
    sort(b + 1, b + n + 1);
    m = unique(b + 1, b + n + 1) - (b + 1);
    for (int i = 1; i <= n; ++i) rk[i] = lower_bound(b + 1, b + m + 1, a[i]) - b;
    for (int i = 1; i <= n; ++i) printf("%d%c", rk[i], i == n ? '\n' : ' ');
    printf("m = %d\n", m);
    return 0;
}

6 / 5 4 2 6 3 1 → 5 4 2 6 3 1，m = 6；5 / 3 1 3 7 1 → 2 1 2 3 1，m = 3：两个 3 同为排名 222。

5.3 相等元素

逆序对与图腾都要求严格比较，ai=aja_i=a_jai=aj 不算。sort+unique+lower_bound 恰好保证"同值同排名"，于是"排名严格大于"就等价于"严格大于"。两种要避免的写法：

只 sort 不 unique ：lower_bound 仍返回首个相等位置，看着也对，但"不同值个数"与数组长度不再一致，把 nnn 当值域上界用就多出重复下标。属于埋雷。
拿排序后的下标当排名：相等的元素会拿到不同排名，每对相等被算成一次严格大于，答案偏大。这是最典型的错法。

5.4 `lower_bound` 的四个细节

右端写 b+m+1 ：半开区间 [first,last)[first,last)[first,last)，写 b+m 会把最大值排除在查找范围外。
减 b 而不是 b+1 ：b[0] 空闲，指针-b 正好落在 1..m1..m1..m，天然 1-based；写成 -b+1 会整体右移为 2..m+12..m+12..m+1，sum 全错。
m 取 unique 的返回值 ：写成 (b+n+1)-(b+1) 得到的是 nnn，不是不同值个数。
只在 a 上查排名 ：b 排序后不再写入，否则所有排名失效。

第六章逆序对

6.1 定义与朴素做法

满足 i<ji<ji<j 且 ai>aja_i>a_jai>aj 的下标对 (i,j)(i,j)(i,j) 是一个逆序对 ，计数单位是"对"。上界 n(n−1)2\dfrac{n(n-1)}{2}2n(n−1)：n=5×105n=5\times10^5n=5×105 时约 1.25×10111.25\times10^{11}1.25×1011，超 int，朴素枚举 O(n2)O(n^2)O(n2) 必然超时。

拆成逐位置统计：

ans=∑i=1nci,ci=#{j<i:aj>ai}ans=\sum_{i=1}^{n}c_i,\qquad c_i=\#\{j<i:a_j>a_i\}ans=i=1∑nci,ci=#{j<i:aj>ai}

读作"扫到 iii 时，前面出现过的数里有多少个比 aia_iai 大"------时间负责 j<ij<ij<i，值域负责 aj>aia_j>a_iaj>ai。

6.2 两种扫描方向

正序（i=1→ni=1\to ni=1→n）：BIT 里是 a1..ai−1a_1..a_{i-1}a1..ai−1，共 i−1i-1i−1 个，sum(rk_i) 是其中 ≤ai\le a_i≤ai 的个数，故比它大的有 (i−1)−sum(rki)(i-1)-\mathrm{sum}(rk_i)(i−1)−sum(rki) 个。

倒序（i=n→1i=n\to1i=n→1）：BIT 里是 ai+1..ana_{i+1}..a_nai+1..an，共 n−in-in−i 个，直接问"后面比它小的"：sum(rk_i-1)。

	正序	倒序
BIT 里是	a1..ai−1a_1..a_{i-1}a1..ai−1（i−1i-1i−1 个）	ai+1..ana_{i+1}..a_nai+1..an（n−in-in−i 个）
每步新增	前面比它大的	后面比它小的
式子	(i−1)−sum(rki)(i-1)-\mathrm{sum}(rk_i)(i−1)−sum(rki)	sum(rki−1)\mathrm{sum}(rk_i-1)sum(rki−1)
顺手得到	LiL_iLi：左边比它大的	RiR_iRi：右边比它大的

两者结果相同：对逆序对 (p,q)(p,q)(p,q)，正序在 i=qi=qi=q 数到它、倒序在 i=pi=pi=p 数到它------同一集合，只是分类的端点不同。

但用途不同 ：只要总数（例题 E）任选一个方向；要每个位置的 Li,RiL_i,R_iLi,Ri（F、J）就按需要的方向各扫一遍------F 两份、J 四份。

6.3 为什么下标是值域

sum(x) 是"下标 ≤x\le x≤x 的那些位置上的权值之和"，所以下标代表什么，sum 就在对什么做前缀和：

下标放位置 iii：sum(x) 是 a1+⋯+axa_1+\dots+a_xa1+⋯+ax，区间和等于两个前缀相减。这是第 1、2 篇的用法。
下标放排名 rkirk_irki：第 kkk 位代表"第 kkk 小的值"，add(rk_i,1) 表示"这个值出现一次"，于是
sum(x)=#{j:rkj≤x}=#{j:aj≤bx}\mathrm{sum}(x)=\#\{j:rk_j\le x\}=\#\{j:a_j\le b_x\}sum(x)=#{j:rkj≤x}=#{j:aj≤bx}
配合已插入总数，得 #{aj>v}=(已插入个数)−sum(rk(v))\#\{a_j>v\}=(\text{已插入个数})-\mathrm{sum}(rk(v))#{aj>v}=(已插入个数)−sum(rk(v))。

这就是权值树状数组 ：外层 for 循环 = 时间（兑现 i<ji<ji<j），BIT 下标 = 值（兑现 ai>aja_i>a_jai>aj），BIT 里存的数 = 出现次数 （add 的 1）。一个条件落到时间维、一个落到值域维，两个条件都变成 O(log⁡n)O(\log n)O(logn) 能查的东西。

例题 E　逆序对（洛谷 P1908）

难度：基础　主考：离散化 + 权值树状数组

题意

求长度 nnn 的序列 aaa 的逆序对数。n≤5×105n\le5\times10^5n≤5×105，1≤ai≤1091\le a_i\le10^91≤ai≤109。样例：

复制代码

6
5 4 2 6 3 1

输出 11。

触发点

n≤5×105n\le5\times10^5n≤5×105 排除 O(n2)O(n^2)O(n2)，ai≤109a_i\le10^9ai≤109 排除开值域数组，答案 1.25×10111.25\times10^{11}1.25×1011 量级 → long long；纯计数、可减 → 树状数组够用。

★关键结论

ans=∑i=1n $(i-1)-sum(rki)$ ans=\sum_{i=1}^{n}\Bigl $(i-1)-\\mathrm{sum}(rk_i)\\Bigr$ ans=i=1∑n $(i-1)-sum(rki)$

sum(rk_i) 是已插入元素中排名 ≤rki\le rk_i≤rki 的个数，(i−1)(i-1)(i−1) 是已插入总数，相减得到排名 >rki>rk_i>rki 的个数，即严格大于 aia_iai 的个数。必须用 sum(rk_i) 而不是 sum(rk_i-1)：后者是"排名 <rki<rk_i<rki"，减出来会留下相等元素，而本题 aia_iai 可重复、相等不算逆序对。

步骤

读入 aaa，复制出 b；
sort + unique 得 mmm，用 lower_bound 求 rk1..rkn∈ $1,m$ rk_1..rk_n\in $1,m$ rk1..rkn∈ $1,m$ ；
从 i=1i=1i=1 扫到 nnn：ans += (i-1) - sum(rk[i])，然后 add(rk[i], 1)；
输出 ans。

代码骨架

cpp 复制代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 500005;
int n, m, a[N], b[N], rk[N];
ll c[N];
#define lowbit(x) ((x) & -(x))
void add(int x, ll v) { for (; x <= m; x += lowbit(x)) c[x] += v; }
ll sum(int x) { ll s = 0; for (; x > 0; x -= lowbit(x)) s += c[x]; return s; }
int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) { scanf("%d", &a[i]); b[i] = a[i]; }
    sort(b + 1, b + n + 1);
    m = unique(b + 1, b + n + 1) - (b + 1);
    for (int i = 1; i <= n; ++i) rk[i] = lower_bound(b + 1, b + m + 1, a[i]) - b;
    ll ans = 0;
    for (int i = 1; i <= n; ++i) {
        ans += (ll)(i - 1) - sum(rk[i]);
        add(rk[i], 1);
    }
    printf("%lld\n", ans);
    return 0;
}

复杂度

离散化与扫描合计 O(nlog⁡n)O(n\log n)O(nlogn) 时间、O(n)O(n)O(n) 空间。

易错点

ans 用 int：上界 1.25×10111.25\times10^{11}1.25×1011，小数据看不出来。
用 sum(rk-1) 求"比它大"，把相等元素算成逆序对。
离散化不去重，或拿排序下标当排名（见 5.3）。
lower_bound 右端写成 b+m，查不到最大值。

手算验证

b=(1,2,3,4,5,6)b=(1,2,3,4,5,6)b=(1,2,3,4,5,6)，m=6m=6m=6，rk=(5,4,2,6,3,1)rk=(5,4,2,6,3,1)rk=(5,4,2,6,3,1)。

iii	aia_iai	rkirk_irki	插入前 `sum`	cic_ici	累计
1	5	5	0	0	0
2	4	4	0	1	1
3	2	2	0	2	3
4	6	6	3	0	3
5	3	3	1	3	6
6	1	1	0	5	11

11 对是 (5,4),(5,2),(5,3),(5,1),(4,2),(4,3),(4,1),(2,1),(6,3),(6,1),(3,1)(5,4),(5,2),(5,3),(5,1),(4,2),(4,3),(4,1),(2,1),(6,3),(6,1),(3,1)(5,4),(5,2),(5,3),(5,1),(4,2),(4,3),(4,1),(2,1),(6,3),(6,1),(3,1)，与程序输出一致。

例题 F　Balanced Photo G（洛谷 P3608 / USACO Gold）

难度：进阶　主考：正反两遍扫描 + 严格大于

题意

nnn 头牛排成一列，第 iii 头身高 hih_ihi。记 LiL_iLi 为它左边比它高的牛数，RiR_iRi 为它右边比它高的牛数。若 max⁡(Li,Ri)>2min⁡(Li,Ri)\max(L_i,R_i)>2\min(L_i,R_i)max(Li,Ri)>2min(Li,Ri)，称这头牛不均衡；求不均衡的牛数。n≤105n\le10^5n≤105，身高值域远大于 nnn（必须离散化）。样例见题面。

触发点

每头牛都要问一次"左边有几个比它高"，逐个扫是 O(n2)=1010O(n^2)=10^{10}O(n2)=1010；只要个数不要最值 → 权值树状数组；同时要左右两份 → 正序、倒序各扫一遍。

★关键结论

设 SiS_iSi 为当前 BIT 中已插入的元素个数（正序 i−1i-1i−1，倒序 n−in-in−i），则

Li=Si−sum(rki) (正序),Ri=Si−sum(rki) (倒序)L_i=S_i-\mathrm{sum}(rk_i)\ (\text{正序}),\qquad R_i=S_i-\mathrm{sum}(rk_i)\ (\text{倒序})Li=Si−sum(rki) (正序),Ri=Si−sum(rki) (倒序)

形式完全相同，只差扫描方向。原因：sum(rk_i) 数的是"已插入中身高 ≤hi\le h_i≤hi"（包含等高 ），用总数减掉，剩下的才是严格高于 它的。判据一律写乘法 max⁡>2min⁡\max>2\minmax>2min：写成 max/min>2 在 min⁡=0\min=0min=0 时除零。

步骤

离散化得 rkrkrk 与 mmm；
清空 BIT，正序：L[i]=(i-1)-sum(rk[i])，再 add(rk[i],1)；
memset 清空 BIT，倒序：R[i]=(n-i)-sum(rk[i])，再 add(rk[i],1)；
统计 max(L[i],R[i]) > 2*min(L[i],R[i]) 的位置数。

代码骨架

cpp 复制代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 100005;
int n, m, h[N], b[N], rk[N], L[N], R[N];
ll c[N];
#define lowbit(x) ((x) & -(x))
void add(int x, ll v) { for (; x <= m; x += lowbit(x)) c[x] += v; }
ll sum(int x) { ll s = 0; for (; x > 0; x -= lowbit(x)) s += c[x]; return s; }
int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) { scanf("%d", &h[i]); b[i] = h[i]; }
    sort(b + 1, b + n + 1);
    m = unique(b + 1, b + n + 1) - (b + 1);
    for (int i = 1; i <= n; ++i) rk[i] = lower_bound(b + 1, b + m + 1, h[i]) - b;

    for (int i = 1; i <= n; ++i) {                 // 左 -> 右：求 L
        L[i] = (i - 1) - (int)sum(rk[i]);
        add(rk[i], 1);
    }
    memset(c, 0, sizeof(c));                       // 第二遍前必须清空
    for (int i = n; i >= 1; --i) {                 // 右 -> 左：求 R
        R[i] = (n - i) - (int)sum(rk[i]);
        add(rk[i], 1);
    }
    int ans = 0;
    for (int i = 1; i <= n; ++i) {
        int mx = max(L[i], R[i]), mn = min(L[i], R[i]);
        if (mx > 2 * mn) ++ans;                    // 不用除法，避开 mn == 0
    }
    printf("%d\n", ans);
    return 0;
}

复杂度

O(nlog⁡n)O(n\log n)O(nlogn) 时间（排序 + 两遍扫描），O(n)O(n)O(n) 空间。

易错点

第二遍前不清空 BIT，RiR_iRi 全错------本题最高频。
用 sum(rk-1) 求"比它高"：那是"身高严格小于"，减出来得到"≥\ge≥"，把等高的牛算成了更高。身高可重复，答案直接变。
mx/2 > mn 与 mx > 2*mn 不等价（mx=5,mn=2mx=5,mn=2mx=5,mn=2：前者不成立、后者成立）。
memset 第三参写错：m*sizeof(ll) 漏高位，sizeof(c[0]) 只清一个元素。
拿一个数组既当 LLL 又当 RRR：LLL 必须全部算完存好再清 BIT。

手算验证

h=(4,2,5,1)h=(4,2,5,1)h=(4,2,5,1)（自造小例子）。

iii	hih_ihi	LiL_iLi	RiR_iRi	max⁡\maxmax	2min⁡2\min2min	不均衡
1	4	0	1（5）	1	0	是
2	2	1（4）	1（5）	1	2	否
3	5	0	0	0	0	否
4	1	3（4,2,5）	0	3	0	是

输出 2：第 2 头 L=R=1L=R=1L=R=1、第 3 头 0>00>00>0，都不满足严格大于，是均衡的。

例题 J　楼兰图腾（洛谷 P10589）

难度：进阶　主考：四种计数 + 乘法原理

题意

给定 1..n1..n1..n 的排列 aaa，数下标三元组 i<j<ki<j<ki<j<k：V 形 ai>aj<aka_i>a_j<a_kai>aj<ak（中间最低）、∧ 形 ai<aj>aka_i<a_j>a_kai<aj>ak（中间最高）。n≤2×105n\le2\times10^5n≤2×105。样例见题面。

触发点

三元组共 (n3)≈1.3×1015\binom{n}{3}\approx1.3\times10^{15}(3n)≈1.3×1015 个，不能枚举；输入是排列 ，值域就是 1..n1..n1..n，不需要离散化（J 与 E、F 的实质区别）；固定中间点可把三元组拆成两侧的二元计数。

★关键结论：为什么 ansV=∑jleftGreaterj⋅rightGreaterjans_V=\sum_j \mathrm{leftGreater}_j\cdot\mathrm{rightGreater}_jansV=∑jleftGreaterj⋅rightGreaterj

① 按中间点分类。 每个三元组 i<j<ki<j<ki<j<k 有唯一的中间点 jjj，所以"按 jjj 分类"是不重不漏的划分，每个三元组只被算一次。

② 固定 jjj，看两侧各有多少候选。 V 形要求 aja_jaj 最低：左边的 iii 需 i<ji<ji<j 且 ai>aja_i>a_jai>aj，共 leftGreaterj\mathrm{leftGreater}_jleftGreaterj 个；右边的 kkk 需 k>jk>jk>j 且 ak>aja_k>a_jak>aj，共 rightGreaterj\mathrm{rightGreater}_jrightGreaterj 个。

③ 两侧独立，用乘法。 iii 的候选只由 jjj 左侧决定，kkk 的候选只由 jjj 右侧决定，选中哪个 iii 不会减少 kkk 的选择，由乘法原理得 leftGreaterj×rightGreaterj\mathrm{leftGreater}_j\times\mathrm{rightGreater}_jleftGreaterj×rightGreaterj。

④ 求和即答案。 由 ① 的不重不漏：

ansV=∑j=1nleftGreaterj⋅rightGreaterjans_V=\sum_{j=1}^{n}\mathrm{leftGreater}_j\cdot\mathrm{rightGreater}_jansV=j=1∑nleftGreaterj⋅rightGreaterj

同理，∧ 形中间最高、两侧都低：ans∧=∑jleftLessj⋅rightLessjans_\wedge=\sum_j\mathrm{leftLess}_j\cdot\mathrm{rightLess}_jans∧=∑jleftLessj⋅rightLessj。

记忆法：式子里的数组名描述两侧相对中间点的位置 ------V 的两侧在上方用 Greater，∧ 的两侧在下方用 Less。把 ansVans_VansV 写成 lLess*rLess 是最常见的错。

四种计数的式子：

量	含义	式子
leftLessj\mathrm{leftLess}_jleftLessj	左边比它小的	`sum(a[j]-1)`（正序扫）
leftGreaterj\mathrm{leftGreater}_jleftGreaterj	左边比它大的	(j−1)−sum(a $j$ )(j-1)-\mathrm{sum}(a $j$ )(j−1)−sum(a $j$ )（正序扫）
rightLessj\mathrm{rightLess}_jrightLessj	右边比它小的	`sum(a[j]-1)`（倒序扫）
rightGreaterj\mathrm{rightGreater}_jrightGreaterj	右边比它大的	(n−j)−sum(a $j$ )(n-j)-\mathrm{sum}(a $j$ )(n−j)−sum(a $j$ )（倒序扫）

排列无重复，sum(a[j]) 与 sum(a[j]-1) 相等，可省一次查询；但保留完整写法，题目改成"值可重复"时不必重写。

步骤

读入 nnn 与排列，BIT 上界取 nnn；
清空 BIT，正序求 lLess[i]、lGtr[i]，倒序求 rLess[i]、rGtr[i]，每步 add(a[i],1)；
V += 1LL*lGtr[i]*rGtr[i]，A += 1LL*lLess[i]*rLess[i]，按题面顺序输出。

代码骨架

cpp 复制代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 200005;
int n, a[N], lLess[N], lGtr[N], rLess[N], rGtr[N];
ll c[N];
#define lowbit(x) ((x) & -(x))
void add(int x, ll v) { for (; x <= n; x += lowbit(x)) c[x] += v; }   // 值域就是 1..n
ll sum(int x) { ll s = 0; for (; x > 0; x -= lowbit(x)) s += c[x]; return s; }
int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
    for (int i = 1; i <= n; ++i) {
        lLess[i] = (int)sum(a[i] - 1);            // 左边比它小的
        lGtr[i]  = (i - 1) - (int)sum(a[i]);      // 左边比它大的
        add(a[i], 1);
    }
    memset(c, 0, sizeof(c));
    for (int i = n; i >= 1; --i) {
        rLess[i] = (int)sum(a[i] - 1);            // 右边比它小的
        rGtr[i]  = (n - i) - (int)sum(a[i]);      // 右边比它大的
        add(a[i], 1);
    }
    ll V = 0, A = 0;
    for (int i = 1; i <= n; ++i) {
        V += (ll)lGtr[i] * rGtr[i];               // 中间最低：V 形
        A += (ll)lLess[i] * rLess[i];             // 中间最高：∧ 形
    }
    printf("%lld %lld\n", V, A);
    return 0;
}

复杂度

两遍扫描各 nnn 次操作，O(nlog⁡n)O(n\log n)O(nlogn) 时间；四个数组加 BIT，O(n)O(n)O(n) 空间。

易错点

用 int 存答案：(2×1053)≈1.3×1015\binom{2\times10^5}{3}\approx1.3\times10^{15}(32×105)≈1.3×1015，V 或 ∧ 单独都可能到 101410^{14}1014 量级；乘法写 1LL*x*y。
V 与 ∧ 记反（V 用 Greater）。
以为要离散化，结果把 m 和 n 混用。
两遍之间没清空 BIT，或清空时把 lLess/lGtr 一起覆盖掉。
换成"值可重复"后，leftGreater 必须用 (j−1)−sum(aj)(j-1)-\mathrm{sum}(a_j)(j−1)−sum(aj)，不能用 sum(a[j]-1)。

手算验证

a=(2,4,1,3)a=(2,4,1,3)a=(2,4,1,3)。四个三元组中 (2,4,1)(2,4,1)(2,4,1)、(2,4,3)(2,4,3)(2,4,3) 中间最高为 ∧，(2,1,3)(2,1,3)(2,1,3)、(4,1,3)(4,1,3)(4,1,3) 中间最低为 V，故 V=2V=2V=2、A=2A=2A=2。

jjj	aja_jaj	lLess	lGtr	rLess	rGtr	lGtr·rGtr	lLess·rLess
1	2	0	0	1	1	0	0
2	4	1	0	2	0	0	2
3	1	0	2	0	1	2	0
4	3	1	1	0	0	0	0

两列之和都是 222，与穷举一致，程序输出 2 2。

本篇易错点

严格与不严格 。"比它大"是"总数减 sum(rk)"，只有"不小于"才减 sum(rk-1)；它同时决定 E、F、J 三题的对错。
离散化忘了 1-based 。-b 得 1..m1..m1..m，-(b+1) 得 0..m−10..m-10..m−1：add(0,v) 死循环（lowbit(0)=0），sum(0) 又"正常"返回 0，小数据被蒙过去。
计数不加 long long 。1.25×10111.25\times10^{11}1.25×1011 与 1.3×10151.3\times10^{15}1.3×1015 都超 int，乘法前先转 ll。
两遍扫描之间不清空 BIT （F、J），以及 mmm 与 nnn 混用。
lower_bound 右端写 b+m+1 ，写 b+m 会漏掉最大值并越界。
读入规模 ：n≥105n\ge10^5n≥105 用 scanf 或关同步，本篇最大 5×1055\times10^55×105。

树状数组 · 信息学学习手册2-离散化与逆序对

第 3 篇 · 离散化与逆序对

第五章 离散化

5.1 为什么必须离散化

5.2 三步法

5.3 相等元素

5.4 lower_bound 的四个细节

第六章 逆序对

6.1 定义与朴素做法

6.2 两种扫描方向

6.3 为什么下标是值域

例题 E 逆序对（洛谷 P1908）

题意

触发点

★关键结论

步骤

代码骨架

复杂度

易错点

手算验证

例题 F Balanced Photo G（洛谷 P3608 / USACO Gold）

题意

触发点

★关键结论

步骤

代码骨架

复杂度

易错点

手算验证

例题 J 楼兰图腾（洛谷 P10589）

题意

触发点

★关键结论：为什么 ansV=∑jleftGreaterj⋅rightGreaterjans_V=\sum_j \mathrm{leftGreater}_j\cdot\mathrm{rightGreater}_jansV=∑jleftGreaterj⋅rightGreaterj

步骤

代码骨架

复杂度

易错点

手算验证

本篇易错点

第五章离散化

5.4 `lower_bound` 的四个细节

第六章逆序对

例题 E　逆序对（洛谷 P1908）

例题 F　Balanced Photo G（洛谷 P3608 / USACO Gold）

例题 J　楼兰图腾（洛谷 P10589）