请用C++ 实现计算 a 的 b 次方对 1e9+7 取模以后的结果

可以使用快速幂算法来计算 a 的 b 次方，然后再对 1e9+7 取模。具体代码实现如下：

#include <iostream>
using namespace std;

const int MOD = 1e9 + 7;

int powMod(int a, int b) {
    int res = 1;
    while (b) {
        if (b & 1) res = (long long) res * a % MOD;
        a = (long long) a * a % MOD;
        b >>= 1;
    }
    return res;
}

int main() {
    int a, b;
    cin >> a >> b;
    int ans = powMod(a, b);
    cout << ans << endl;
    return 0;
}

其中，`powMod` 函数使用了快速幂算法来计算 $a^b$ 对 1e9+7 取模的结果。时间复杂度为 $O(\log b)$。

相关问题

给你一个数字串，问你有多少个子序列构成的数字可以被3整除（子序列是在原来序列中找一部分组成的序列，不一定连续） 答案对1e9+7取模 输入格式: 输入一个字符串，由数字构成，长度小于等于50 输出格式: 输出一个整数c++

这是一个关于动态规划的问题，我们可以用C++来解决。首先，我们需要遍历给定的数字串，并维护两个辅助计数器：`dp0`表示当前子序列结束位置之前能被3整除的子序列数量，`dp1`表示当前子序列结束位置之前能被3除余1的子序列数量，`dp2`表示能被3除余2的子序列数量。

对于每个字符，我们更新计数器如下：

- 如果字符是3的倍数，`dp0`加1，同时将`dp1`和`dp2`清零，因为新的子序列开始可以覆盖掉之前的非3倍数部分。
- 如果字符是一次余1，`dp1`加1，`dp0`不变，因为新的子序列可以继续前一个余1的子序列。
- 如果字符是一次余2，`dp2`加1，`dp0`不变，同理。

最后，总的结果就是`dp0 + dp1 + dp2`，为了满足题目要求，结果需要对1e9 + 7取模。

C++伪代码示例：

#include <iostream>
#include <vector>

int solve(const std::string& digits) {
    int n = digits.size();
    std::vector<int> dp(3, 0);
    for (char c : digits) {
        int num = c - '0';
        dp[(num + dp[1]) % 3] = (dp[(num + dp[1]) % 3] + 1) % (1e9 + 7); // 取模操作
        dp[(num - dp[2]) % 3] = (dp[(num - dp[2]) % 3] + 1) % (1e9 + 7); // 取模操作
        dp[2] = (dp[2] + 1) % (1e9 + 7); // 如果不是3的倍数，dp2只增加1
    }
    return (dp[0] + dp[1] + dp[2]) % (1e9 + 7);
}

int main() {
    std::string input;
    std::cin >> input;
    int result = solve(input);
    std::cout << "可以被3整除的子序列数量：" << result << "\n";
    return 0;
}

输入两个数 a, b，其中 b 极大。计算 a 的 b 次方对 1337 取模的结果。数据保证 a 在 int 范围内，b 小于 100 位，每个样例输入两行分别表示 a 和 b，每个样例输出一行表示：a 的 b 次方对 1337 取模的结果，使用C++实现

可以使用快速幂算法来解决这个问题，时间复杂度为 O(log b)。

具体实现代码如下：

#include <iostream>
using namespace std;

int pow_mod(int a, string b, int c) {
    int res = 1;
    int len = b.size();
    for (int i = len - 1; i >= 0; i--) {
        int digit = b[i] - '0';
        int base = 1;
        for (int j = 0; j < 4; j++) {
            if (digit & 1) {
                res = (res * a) % c;
            }
            digit >>= 1;
            a = (a * a) % c;
        }
    }
    return res;
}

int main() {
    int a;
    string b;
    cin >> a >> b;
    int res = pow_mod(a, b, 1337);
    cout << res << endl;
    return 0;
}

在这个实现中，我们将 b 存储为字符串，然后从高位到低位依次计算幂。在每一位上，如果该位是 1，就累乘上 a 的相应幂次，同时更新 a 的幂次。注意，在计算过程中需要对每一步结果取模，以避免溢出。

另外，由于 1337 是一个较小的质数，我们可以用多位二进制数来表示 b 的每一位，从而在每一次循环中计算 4 次 a 的平方，进一步提高计算效率。