算法竞赛中的倍增思想与离散化技术详解-代码聚汇网

算法竞赛中的倍增思想与离散化技术详解

綺懷

1. 倍增思想与离散化：算法竞赛中的高效处理技巧

在算法竞赛和实际开发中，我们经常会遇到需要处理大规模数据的情况。当数据范围过大时，直接暴力计算往往会超出时间或空间限制。倍增思想和离散化就是两种能够有效解决这类问题的技术手段。

倍增思想通过"翻倍"的方式，将线性复杂度优化为对数级复杂度，典型应用包括快速幂和大整数乘法。而离散化则通过将大范围的稀疏数据映射到紧凑的连续空间，既节省了存储又提高了处理效率。这两种思想看似简单，但深入理解其原理并灵活运用，可以解决许多看似复杂的问题。

2. 倍增思想详解

2.1 快速幂算法

快速幂算法是倍增思想的经典应用，用于高效计算a的b次方对p取模的结果（a^b mod p）。当b的值非常大时（比如1e9），直接循环b次相乘的方法显然不可行。

2.1.1 算法原理

快速幂的核心思想是将指数b分解为二进制形式，然后利用幂的乘法性质，通过不断平方来减少计算次数。具体来说：

将b表示为二进制形式，例如b=10的二进制是1010
根据幂的性质，a^10 = a^(8+2) = a^8 × a^2
通过不断平方计算a的各次幂：a^1, a^2, a^4, a^8...
根据b的二进制位决定是否将当前幂次乘入结果

这种方法的复杂度从O(b)降低到O(logb)，效率提升显著。

2.1.2 代码实现与解析

cpp复制#include <iostream>
using namespace std;
typedef long long LL; // 使用64位整数防止溢出

LL qpow(LL a, LL b, LL p) {
    LL ret = 1;  // 初始化结果为1（任何数的0次方为1）
    while(b) {   // 当b不为0时循环
        if(b & 1) ret = ret * a % p; // 如果当前位为1，乘入结果
        a = a * a % p;  // a自乘（计算下一个幂次）
        b >>= 1;        // b右移一位
    }
    return ret;
}

int main() {
    LL a, b, p;
    cin >> a >> b >> p;
    cout << a << "^" << b << " mod " << p << "=" << qpow(a, b, p) << endl;
    return 0;
}

2.1.3 关键点说明

取模运算：每一步乘法后都立即取模，防止数值溢出
位运算：b & 1判断最低位是否为1，b >>= 1相当于b /= 2
初始化：ret初始为1，这是乘法的单位元

2.1.4 实际案例演示

以计算2^10 mod 9为例：

初始化：ret=1, a=2, b=10(1010), p=9
第一轮：b=10(1010)
- b&1=0，不乘入结果
- a=2*2=4 mod 9=4
- b=5
第二轮：b=5(0101)
- b&1=1，ret=1*4=4 mod 9=4
- a=4*4=16 mod 9=7
- b=2
第三轮：b=2(0010)
- b&1=0，不乘入结果
- a=7*7=49 mod 9=4
- b=1
第四轮：b=1(0001)
- b&1=1，ret=4*4=16 mod 9=7
- a=4*4=16 mod 9=7
- b=0
结束，返回ret=7

2.2 大整数乘法

当需要计算两个大整数a和b的乘积对p取模时，如果直接计算a*b可能会超出数据类型的表示范围。这时可以使用类似快速幂的倍增思想来解决。

2.2.1 算法原理

将乘法转化为加法，利用b的二进制分解：

a × b = a × (b的二进制表示各位的加权和)

例如：
a × 10 = a × (8 + 2) = 8a + 2a

通过不断将a翻倍（a += a），并根据b的二进制位决定是否将当前值加入结果，可以在O(logb)时间内完成计算。

2.2.2 代码实现

cpp复制#include<iostream>
using namespace std;

typedef long long LL;

LL qmul(LL a, LL b, LL p) {
    LL sum = 0;
    while(b) {
        if(b & 1) sum = (sum + a) % p;
        a = (a + a) % p;
        b >>= 1;
    }
    return sum;
}

int main() {
    LL a, b, p;
    cin >> a >> b >> p;
    cout << qmul(a, b, p) << endl;
    return 0;
}

2.2.3 与快速幂的对比

结构相似：都使用二进制分解和倍增思想
操作不同：快速幂是累乘，大整数乘法是累加
应用场景：快速幂用于幂运算，大整数乘法用于防止乘法溢出

3. 离散化技术详解

3.1 离散化基本概念

离散化是一种将大范围稀疏数据映射到紧凑连续空间的技术。当数据的值范围很大但实际数据点较少时，通过离散化可以显著减少存储空间和提高处理效率。

3.1.1 离散化的基本步骤

收集所有需要离散化的值
排序
去重
建立原始值到离散化后索引的映射

3.1.2 离散化的两种实现方式

方式一：排序+去重+二分查找

cpp复制#include<iostream>
#include<algorithm>
using namespace std;

const int N = 1e5 + 10;
typedef long long LL;
LL n, pos;
LL a[N], disc[N];

LL find(LL x) {
    LL l = 1, r = pos;
    while(l < r) {
        LL mid = (l + r) / 2;
        if(disc[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return l;
}

int main() {
    cin >> n;
    for(int i = 1; i <= n; i++) {
        cin >> a[i];
        disc[++pos] = a[i];
    }
    // 步骤1：排序
    sort(disc + 1, disc + 1 + pos);
    // 步骤2：去重
    pos = unique(disc + 1, disc + 1 + pos) - (disc + 1);
    // 步骤3：建立映射
    for(int i = 1; i <= n; i++) {
        cout << a[i] << "离散化之后：" << find(a[i]) << endl;
    }
    return 0;
}

方式二：排序+哈希表

cpp复制#include<iostream>
#include<algorithm>
#include<unordered_map>
using namespace std;

const int N = 1e5 + 10;
typedef long long LL;
LL n, pos;
LL a[N], disc[N];
unordered_map<LL, LL> id;

int main() {
    cin >> n;
    for(int i = 1; i <= n; i++) {
        cin >> a[i];
        disc[++pos] = a[i];
    }
    sort(disc + 1, disc + 1 + pos);
    LL cnt = 0;
    for(int i = 1; i <= pos; i++) {
        LL x = disc[i];
        if(id.count(x)) continue; // 去重
        cnt++;
        id[x] = cnt; // 建立映射
    }
    for(int i = 1; i <= n; i++) {
        cout << a[i] << "离散化后：" << id[a[i]] << endl;
    }
    return 0;
}

3.1.3 两种方式的对比

特性	排序+二分法	哈希表法
时间复杂度	O(nlogn)预处理，O(logn)查询	O(nlogn)预处理，O(1)查询
空间复杂度	O(n)	O(n)
适用场景	需要有序访问离散化后的值	需要快速查找，不关心顺序
实现难度	中等	简单
额外功能	支持范围查询	仅支持点查询

3.2 离散化的应用案例

3.2.1 火烧赤壁问题

问题描述：
给定n个区间，计算这些区间覆盖的总长度。区间范围可能很大（如1e9），但区间数量n较小（如2e4）。

解题思路：

将所有区间的端点收集起来进行离散化
在离散化后的坐标上使用差分数组标记区间覆盖
通过前缀和还原覆盖情况
统计被覆盖的区间长度

完整代码：

cpp复制#include<iostream>
#include<algorithm>
#include<unordered_map>
using namespace std;

const int N = 2e4 + 10;
typedef long long LL;
unordered_map<LL, LL> id;
int n, pos;
LL a[N], b[N];
LL disc[N * 2];
LL f[N * 2];

int main() {
    cin >> n;
    for(int i = 1; i <= n; i++) {
        cin >> a[i] >> b[i];
        disc[++pos] = a[i]; 
        disc[++pos] = b[i];
    }
    // 排序
    sort(disc + 1, disc + 1 + pos);
    // 去重
    pos = unique(disc + 1, disc + 1 + pos) - (disc + 1);
    // 建立映射
    for(int i = 1; i <= pos; i++) {
        id[disc[i]] = i;
    }
    // 差分标记
    for(int i = 1; i <= n; i++) {
        LL l = id[a[i]], r = id[b[i]];
        f[l]++; 
        f[r]--;
    }
    // 还原
    for(int i = 1; i <= pos; i++) {
        f[i] += f[i - 1];
    }
    // 统计结果
    LL ret = 0;
    for(int i = 1; i <= pos; i++) {
        int j = i;
        while(j <= pos && f[j] > 0) j++;
        ret += disc[j] - disc[i];
        i = j;
    }
    cout << ret << endl;
    return 0;
}

关键点说明：

离散化处理了原始的大范围坐标，使其变为连续的索引
差分数组f标记了每个区间的开始和结束
通过前缀和还原后，f[i]>0表示该位置被覆盖
统计连续被覆盖的区间时，要注意离散化坐标与实际长度的对应关系

3.2.2 贴海报问题

问题描述：
有一面很长的墙，要在上面贴n张海报，后贴的海报会覆盖之前的海报。问最后能看到多少张不同的海报。