P整数生成问题 | 豆包MarsCode AI刷题

import java.util.Arrays;

public class Main {

public static int[] solution(int x, int y, int m) {
    boolean[] strongIntegers = new boolean[m + 1];
    
    // 计算 x 的所有幂次
    int i = 0;
    while (Math.pow(x, i) <= m) {
        int xPower = (int) Math.pow(x, i);

        // 计算 y 的所有幂次
        int j = 0;
        while (xPower + Math.pow(y, j) <= m) {
            int result = xPower + (int) Math.pow(y, j);
            strongIntegers[result] = true;
            j++;
            if (y == 1) {  // 防止 y=1 的死循环
                break;
            }
        }

        i++;
        if (x == 1) {  // 防止 x=1 的死循环
            break;
        }
    }

    // 计算结果的大小
    int count = 0;
    for (boolean value : strongIntegers) {
        if (value) {
            count++;
        }
    }

    // 将标记的数值收集到结果数组
    int[] resultArray = new int[count];
    int index = 0;
    for (int k = 0; k <= m; k++) {
        if (strongIntegers[k]) {
            resultArray[index++] = k;
        }
    }

    return resultArray;
}

public static void main(String[] args) {
    System.out.println(Arrays.equals(solution(2, 3, 10), new int[]{2, 3, 4, 5, 7, 9, 10}));
    System.out.println(Arrays.equals(solution(3, 5, 15), new int[]{2, 4, 6, 8, 10, 14}));
    System.out.println(Arrays.equals(solution(2, 1, 20), new int[]{2, 3, 5, 9, 17}));
    System.out.println(Arrays.equals(solution(1, 1, 10), new int[]{2}));
}

}

这段代码的目的是计算并返回所有可以表示为 x^i + y^j 的强整数，其中 i 和 j 是非负整数，而 x 和 y 是给定的基数。这个结果的范围是从 0 到 m。以下是代码的逐步解释：

1. 初始化布尔数组：strongIntegers 是一个布尔数组，长度为 m + 1，用于标记哪些整数是强整数。

2. 计算 x 的幂次：

   • 使用 i 变量从 0 开始，逐步计算 x 的幂（x^i），直到 x^i 大于 m。
   • 对于每个 x^i，再计算 y 的幂次。

3. 计算 y 的幂次：

   • 使用 j 变量从 0 开始，逐步计算 y 的幂（y^j），直到 x^i + y^j 超过 m。
   • 每次计算出 x^i + y^j ，就将对应的 strongIntegers[result] 设为 true，表示这个强整数存在。
   • 额外处理当 y 或 x 为 1 的情况，以避免无限循环。

4. 计数强整数：

   • 遍历 strongIntegers 数组，通过计数 true 值来确定有多少个强整数。

5. 收集结果：

   • 最后，创建一个整数数组 resultArray，将所有标记为 true 的数值收集到这个数组中，并返回它。

这段代码实现了强整数的计算，确保在指定范围内的所有可能强整数都被找出。

这段代码的目的是找出所有强整数（strong integers），即能够表示为 x^i + y^j 的整数，其中 i 和 j 为非负整数，且结果不超过给定的最大值 m。下面是对这段代码的详细分析和解释：

代码逻辑分析

1. 强整数的定义：

   • 强整数是可以表示为 x^i + y^j 的数，其中 i 和 j 是非负整数，且 x 和 y 是输入的底数。

2. 创建数组：

   • 创建一个布尔类型的数组 strongIntegers，大小为 m + 1，用于标记哪些数字是强整数。初始时，所有值均为 false。

3. 计算 x 的幂：

   • 使用一个 while 循环来计算 x 的非负幂，条件是 Math.pow(x, i) <= m。这里的 i 从0开始逐步递增。
   • 计算的结果存储在 xPower 变量中，这个变量表示当前的 x 的幂值，即 x^i。

4. 计算 y 的幂：

   • 对于每个 xPower，再用一个 while 循环来计算 y 的非负幂，条件是 xPower + Math.pow(y, j) <= m。这里的 j 也是从0开始逐步递增。
   • 计算的结果 result = xPower + (int) Math.pow(y, j)。如果这个结果小于或等于 m，则将 strongIntegers[result] 设置为 true。

5. 防止循环的特殊情况：

   • 如果 y 等于1，将会导致 Math.pow(y, j) 始终返回1，从而进入无限循环。因此在这种情况下如果满足条件，程序直接 break 退出此循环。
   • 类似地，如果 x 等于1，则 x^i 也始终为1，因此需要做同样的处理来避免死循环。

6. 计算有效的强整数数量：

   • 遍历 strongIntegers 数组，统计其中为 true 的数量，将其存储在 count 变量中。

7. 收集结果：

   • 创建一个结果数组 resultArray，大小为有效强整数的数量 count。
   • 再次遍历 strongIntegers 数组，将所有为 true 的索引（即强整数）填入 resultArray 中。

8. 返回结果：

   • 最后，返回填充好的 resultArray。

总结

该代码完整地实现了找出所有强整数的逻辑，通过双重循环遍历了所有可能的 x 和 y 的幂值组合并进行了有效的标记，最后统计并返回了所有有效的强整数。

复杂度

• 由于二维循环的性质，这段代码中的复杂性主要取决于 x 和 y 能生成的幂范围。因此时间复杂度为 O(x^i * y^j)，具体时间复杂度取决于输入的值和 m。