检查一个数字是否可以表示为两个完美幂之和

给定一个正数N ，任务是检查给定的数N是否可以表示为a ^x + b ^y 其中 x 和 y > 1 且 a 和 b > 0。如果 N 可以用给定的形式表示，则打印true否则打印false 。

例子：

Input:  N = 5
Output: true
Explanation:
5 can be expressed as 2²+1² 

Input: N = 15
Output: false

方法：这个想法是使用完全幂的概念来确定和是否存在。以下是步骤：

1. 创建一个数组（比如perfectPower[] ）来存储是否为完美幂的数字。
2. 现在数组PerfectPower[]存储了所有完美幂的元素，因此我们生成该数组中所有元素的所有可能对和。
3. 将上一步计算的总和的标记保存在数组isSum[]中，因为它可以用a ^x + b ^y的形式表示  .
4. 在上述步骤之后，如果isSum[N]为 true 则打印true否则打印false 。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function that returns true if n
// can be written as a^m+b^n
bool isSumOfPower(int n)
{
    // Taking isSum boolean array
    // for check the sum exist or not
    bool isSum[n + 1];
 
    // To store perfect squares
    vector perfectPowers;
 
    perfectPowers.push_back(1);
 
    for (int i = 0; i < (n + 1); i++) {
 
        // Initially all sums as false
        isSum[i] = false;
    }
 
    for (long long int i = 2;
         i < (n + 1); i++) {
 
        if (isSum[i] == true) {
 
            // If sum exist then push
            // that sum into perfect
            // square vector
            perfectPowers.push_back(i);
            continue;
        }
 
        for (long long int j = i * i;
             j > 0 && j < (n + 1);
             j *= i) {
            isSum[j] = true;
        }
    }
 
    // Mark all perfect powers as false
    for (int i = 0;
         i < perfectPowers.size(); i++) {
        isSum[perfectPowers[i]] = false;
    }
 
    // Traverse each perfectPowers
    for (int i = 0;
         i < perfectPowers.size(); i++) {
 
        for (int j = i;
             j < perfectPowers.size(); j++) {
 
            // Calculating Sum with
            // perfect powers array
            int sum = perfectPowers[i]
                      + perfectPowers[j];
 
            if (sum < (n + 1))
                isSum[sum] = true;
        }
    }
    return isSum[n];
}
 
// Driver Code
int main()
{
    // Given Number n
    int n = 9;
 
    // Function Call
    if (isSumOfPower(n)) {
        cout << "true\n";
    }
    else {
        cout << "false\n";
    }
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function that returns true if n
// can be written as a^m+b^n
static boolean isSumOfPower(int n)
{
     
    // Taking isSum boolean array
    // for check the sum exist or not
    boolean []isSum = new boolean[n + 1];
 
    // To store perfect squares
    Vector perfectPowers = new Vector();
 
    perfectPowers.add(1);
 
    for(int i = 0; i < (n + 1); i++)
    {
         
        // Initially all sums as false
        isSum[i] = false;
    }
 
    for(int i = 2; i < (n + 1); i++)
    {
        if (isSum[i] == true)
        {
             
            // If sum exist then push
            // that sum into perfect
            // square vector
            perfectPowers.add(i);
            continue;
        }
 
        for(int j = i * i;
                j > 0 && j < (n + 1);
                j *= i)
        {
            isSum[j] = true;
        }
    }
 
    // Mark all perfect powers as false
    for(int i = 0;
            i < perfectPowers.size();
            i++)
    {
        isSum[perfectPowers.get(i)] = false;
    }
 
    // Traverse each perfectPowers
    for(int i = 0;
            i < perfectPowers.size();
            i++)
    {
        for(int j = i;
                j < perfectPowers.size();
                j++)
        {
             
            // Calculating Sum with
            // perfect powers array
            int sum = perfectPowers.get(i) +
                      perfectPowers.get(j);
 
            if (sum < (n + 1))
                isSum[sum] = true;
        }
    }
    return isSum[n];
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given number n
    int n = 9;
 
    // Function call
    if (isSumOfPower(n))
    {
        System.out.print("true\n");
    }
    else
    {
        System.out.print("false\n");
    }
}
}
 
// This code is contributed by amal kumar choubey

Python3

# Python3 program for the above approach
 
# Function that returns true if n
# can be written as a^m+b^n
def isSumOfPower(n):
     
    # Taking isSum boolean array
    # for check the sum exist or not
    isSum = [0] * (n + 1)
 
    # To store perfect squares
    perfectPowers = []
 
    perfectPowers.append(1)
 
    for i in range(n + 1):
 
        # Initially all sums as false
        isSum[i] = False
     
    for i in range(2, n + 1):
        if (isSum[i] == True):
 
            # If sum exist then push
            # that sum into perfect
            # square vector
            perfectPowers.append(i)
            continue
         
        j = i * i
        while(j > 0 and j < (n + 1)):
            isSum[j] = True
            j *= i
         
    # Mark all perfect powers as false
    for i in range(len(perfectPowers)):
        isSum[perfectPowers[i]] = False
     
    # Traverse each perfectPowers
    for i in range(len(perfectPowers)):
        for j in range(len(perfectPowers)):
 
            # Calculating Sum with
            # perfect powers array
            sum = (perfectPowers[i] +
                   perfectPowers[j])
 
            if (sum < (n + 1)):
                isSum[sum] = True
         
    return isSum[n]
 
# Driver Code
 
# Given Number n
n = 9
 
# Function call
if (isSumOfPower(n)):
    print("true")
else:
    print("false")
 
# This code is contributed by sanjoy_62

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function that returns true if n
// can be written as a^m+b^n
static bool isSumOfPower(int n)
{
     
    // Taking isSum bool array
    // for check the sum exist or not
    bool []isSum = new bool[n + 1];
 
    // To store perfect squares
    List perfectPowers = new List();
 
    perfectPowers.Add(1);
 
    for(int i = 0; i < (n + 1); i++)
    {
         
        // Initially all sums as false
        isSum[i] = false;
    }
 
    for(int i = 2; i < (n + 1); i++)
    {
        if (isSum[i] == true)
        {
             
            // If sum exist then push
            // that sum into perfect
            // square vector
            perfectPowers.Add(i);
            continue;
        }
 
        for(int j = i * i;
                j > 0 && j < (n + 1);
                j *= i)
        {
            isSum[j] = true;
        }
    }
 
    // Mark all perfect powers as false
    for(int i = 0;
            i < perfectPowers.Count;
            i++)
    {
        isSum[perfectPowers[i]] = false;
    }
 
    // Traverse each perfectPowers
    for(int i = 0;
            i < perfectPowers.Count;
            i++)
    {
        for(int j = i;
                j < perfectPowers.Count;
                j++)
        {
             
            // Calculating Sum with
            // perfect powers array
            int sum = perfectPowers[i] +
                      perfectPowers[j];
 
            if (sum < (n + 1))
                isSum[sum] = true;
        }
    }
    return isSum[n];
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given number n
    int n = 9;
 
    // Function call
    if (isSumOfPower(n))
    {
        Console.Write("true\n");
    }
    else
    {
        Console.Write("false\n");
    }
}
}
 
// This code is contributed by amal kumar choubey

Javascript

 
// JavaScript  program to implement
// the above approach
 
// Function that returns true if n
// can be written as a^m+b^n
function isSumOfPower(n)
{
       
    // Taking isSum boolean array
    // for check the sum exist or not
    let isSum = Array(n+1).fill(0);
   
    // To store perfect squares
    let perfectPowers = [];
   
    perfectPowers.push(1);
   
    for(let i = 0; i < (n + 1); i++)
    {
           
        // Initially all sums as false
        isSum[i] = false;
    }
   
    for(let i = 2; i < (n + 1); i++)
    {
        if (isSum[i] == true)
        {
               
            // If sum exist then push
            // that sum leto perfect
            // square vector
            perfectPowers.push(i);
            continue;
        }
   
        for(let j = i * i;
                j > 0 && j < (n + 1);
                j *= i)
        {
            isSum[j] = true;
        }
    }
   
    // Mark all perfect powers as false
    for(let i = 0;
            i < perfectPowers.length;
            i++)
    {
        isSum[perfectPowers[i]] = false;
    }
   
    // Traverse each perfectPowers
    for(let i = 0;
            i < perfectPowers.length;
            i++)
    {
        for(let j = i;
                j < perfectPowers.length;
                j++)
        {
               
            // Calculating Sum with
            // perfect powers array
            let sum = perfectPowers[i] +
                      perfectPowers[j];
   
            if (sum < (n + 1))
                isSum[sum] = true;
        }
    }
    return isSum[n];
}
 
// Driver Code
 
    // Given number n
    let n = 9;
   
    // Function call
    if (isSumOfPower(n))
    {
        document.write("true\n");
    }
    else
    {
        document.write("false\n");
    }
 

输出：

true

时间复杂度： O(N)
辅助空间： O(N)