leetcode：372. 超级次方

OceanStar的学习笔记

已于 2022-08-11 13:03:34 修改

阅读量260

点赞数

分类专栏：算法与数据结构文章标签： leetcode 算法职场和发展

于 2022-08-11 12:01:13 首次发布

原文链接：https://leetcode.cn/problems/super-pow/

版权

算法与数据结构专栏收录该内容

1121 篇文章 80 订阅

订阅专栏

题目来源

leetcode：372. 超级次方

题目描述

在这里插入图片描述

class Solution {
public:
    int superPow(int a, vector<int>& b) {

    }
};

题目解析

分析数据

最多可能有10^9个a相乘，一定不能暴力

思路

本题难点

第一：如何处理用数组表示的指数？现在b是一个数组，也就是说b可能非常大，没办法直接转成整型，否则可能溢出。应该怎么处理呢？
第二：如何得到求模之后的结果？按道理，起码应该先把幂运算结果算出来，然后做 % 1337 这个运算。但问题是，指数运算你懂得，真实结果肯定会大得吓人，也就是说，算出来真实结果也没办法表示，早都溢出报错了。
第三：如何高效进行冥运算？

下面我们一一解决

如何处理数组指数

首先明确问题：现在b是一个数组，不能直接表示成整型，而且数组的特点是随机访问，删除最后一个元素比较高效
不考虑求模的要求，以b = [1, 5, 6, 4]来举例，结合指数运算的法则，我们可以发现这样一个规律：

在这里插入图片描述

可以看到问题规模缩小了，因此可以写成递归

    superPow(a, [1,5,6,4])
=>  superPow(a, [1,5,6])

我们先整理出代码框架

class Solution {
    // 计算 a 的 k 次方的结果
    int mypow(int a, int k);
public:
    int superPow(int a, std::vector<int> & b){
        if(b.empty()){
            return 1;
        }
        // 取出最后一个数
        int last = b.back();
        b.pop_back();
        // 将原问题化简，缩小规模递归求解
        int part1 = mypow(a, last);
        int part2 = mypow(superPow(a, b), 10);
        // 合并出结果
        return part1 * part2;
    }
};

我们已经解决了 b 是一个数组的问题，现在来看看如何处理 mod，避免结果太大而导致的整型溢出。

如何处理 mod 运算

首先明确问题：由于计算机的编码方式，形如(a * b) % base这样的运算，其(a * b)可能会溢出。我们希望能够找到一种技巧，能够化简这种形式，避免溢出同时得到结果。
比如在二分查找宏，我们求中点索引(l+r)/2 转化成 l+(r-l)/2，避免溢出的同时得到正确的结果。
对于模运算有：(a * b) % k = (a % k)(b % k) % k
换句话说，对乘法的结果求模，等价于先对每个因子都求模，然后对因子相乘的结果再求模。
那么扩展到这道题，有：

class Solution {
      int base = 1337;
    // 计算 a 的 k 次方然后与 base 求模的结果
    int mypow(int a, int k) {
        // 对因子求模
        a %= base;
        int res = 1;
        for (int _ = 0; _ < k; _++) {
            // 这里有乘法，是潜在的溢出点
            res *= a;
            // 对乘法结果求模
            res %= base;
        }
        return res;
    }
public:
    int superPow(int a, std::vector<int> & b){
        if(b.empty()){
            return 1;
        }
        // 取出最后一个数
        int last = b.back();
        b.pop_back();
        // 将原问题化简，缩小规模递归求解
        int part1 = mypow(a, last);
        int part2 = mypow(superPow(a, b), 10);
        // 合并出结果
        return part1 * part2;
    }
};

至此，这个问题就已经完全解决了，已经可以通过 LeetCode 的判题系统了。

问题是有没有比较高效的求冥算法呢？

如何高效求幂

快速求幂的算法不止一个，就说一个我们应该掌握的基本思路吧。利用幂运算的性质，我们可以写出这样一个递归式：
在这里插入图片描述
这个思想肯定比直接用 for 循环求幂要高效，因为有机会直接把问题规模（b 的大小）直接减小一半，该算法的复杂度肯定是 log 级了。

既有：

int base = 1337;

int mypow(int a, int k) {
    if (k == 0) return 1;
    a %= base;

    if (k % 2 == 1) {
        // k 是奇数
        return (a * mypow(a, k - 1)) % base;
    } else {
        // k 是偶数
        int sub = mypow(a, k / 2);
        return (sub * sub) % base;
    }
}

思路二

在这里插入图片描述

class Solution {

    int mypow(int a, int k) {
        if(k == 0){
            return 1;
        }
        if(k == 1){
            return a % 1337;
        }
        return mypow(a % 1337, k / 2) * mypow(a % 1337, k - k / 2) % 1337;
    }
public:
    int superPow(int a, std::vector<int> & b){
        long long res = 1;
        for (int i = 0; i < b.size(); ++i) {
            res = mypow(res , 10) * mypow(a, b[i]) % 1337;
        }
        return res;
    }
};