寻找将整数表示为唯一自然数的n次幂的和的方法

给定两个数字x和n，找到许多方式x可以表示为唯一自然数的n次幂之和。

例子 ：

Input  : x = 10, n = 2
Output : 1
Explanation: 10 = 1² + 3², Hence total 1 possibility

Input  : x = 100, n = 2
Output : 3
Explanation: 
100 = 10² OR 6² + 8² OR 1² + 3² + 4² + 5² + 7² Hence total 3 possibilities

这个想法很简单。我们迭代从1开始的所有数字。对于每个数字，我们递归地尝试所有更大的数字，如果我们能够找到和，就增加结果

C++

// C++ program to count number of ways any
// given integer x can be expressed as n-th
// power of unique natural numbers.
#include 
using namespace std;
 
// Function to calculate and return the
// power of any given number
int power(int num, unsigned int n)
{
    if (n == 0)
        return 1;
    else if (n % 2 == 0)
        return power(num, n / 2) * power(num, n / 2);
    else
        return num * power(num, n / 2) * power(num, n / 2);
}
 
// Function to check power representations recursively
int checkRecursive(int x, int n, int curr_num = 1,
                   int curr_sum = 0)
{
    // Initialize number of ways to express
    // x as n-th powers of different natural
    // numbers
    int results = 0;
 
    // Calling power of 'i' raised to 'n'
    int p = power(curr_num, n);
    while (p + curr_sum < x) {
        // Recursively check all greater values of i
        results += checkRecursive(x, n, curr_num + 1,
                                  p + curr_sum);
        curr_num++;
        p = power(curr_num, n);
    }
 
    // If sum of powers is equal to x
    // then increase the value of result.
    if (p + curr_sum == x)
        results++;
 
    // Return the final result
    return results;
}
 
// Driver Code.
int main()
{
    int x = 10, n = 2;
    cout << checkRecursive(x, n);
    return 0;
}

Java

// Java program to count number of ways any
// given integer x can be expressed as n-th
// power of unique natural numbers.
 
class GFG {
 
    // Function to calculate and return the
    // power of any given number
    static int power(int num, int n)
    {
        if (n == 0)
            return 1;
        else if (n % 2 == 0)
            return power(num, n / 2) * power(num, n / 2);
        else
            return num * power(num, n / 2)
                * power(num, n / 2);
    }
 
    // Function to check power representations recursively
    static int checkRecursive(int x, int n, int curr_num,
                              int curr_sum)
    {
        // Initialize number of ways to express
        // x as n-th powers of different natural
        // numbers
        int results = 0;
 
        // Calling power of 'i' raised to 'n'
        int p = power(curr_num, n);
        while (p + curr_sum < x) {
            // Recursively check all greater values of i
            results += checkRecursive(x, n, curr_num + 1,
                                      p + curr_sum);
            curr_num++;
            p = power(curr_num, n);
        }
 
        // If sum of powers is equal to x
        // then increase the value of result.
        if (p + curr_sum == x)
            results++;
 
        // Return the final result
        return results;
    }
 
    // Driver Code.
    public static void main(String[] args)
    {
        int x = 10, n = 2;
        System.out.println(checkRecursive(x, n, 1, 0));
    }
}
 
// This code is contributed by mits

Python

# Python3 program to count number of ways any
# given integer x can be expressed as n-th
# power of unique natural numbers.
 
# Function to calculate and return the
# power of any given number
 
 
def power(num, n):
 
    if(n == 0):
        return 1
    elif(n % 2 == 0):
        return power(num, n // 2) * power(num, n // 2)
    else:
        return num * power(num, n // 2) * power(num, n // 2)
 
# Function to check power representations recursively
 
 
def checkRecursive(x, n, curr_num=1, curr_sum=0):
 
    # Initialize number of ways to express
    # x as n-th powers of different natural
    # numbers
    results = 0
 
    # Calling power of 'i' raised to 'n'
    p = power(curr_num, n)
    while(p + curr_sum < x):
 
        # Recursively check all greater values of i
        results += checkRecursive(x, n, curr_num + 1, p + curr_sum)
        curr_num = curr_num + 1
        p = power(curr_num, n)
 
    # If sum of powers is equal to x
    # then increase the value of result.
    if(p + curr_sum == x):
        results = results + 1
 
    # Return the final result
    return results
 
 
# Driver Code.
if __name__ == '__main__':
    x = 10
    n = 2
    print(checkRecursive(x, n))
 
 
# This code is contributed by
# Sanjit_Prasad

C#

// C# program to count number of ways any
// given integer x can be expressed as
// n-th power of unique natural numbers.
using System;
 
class GFG {
 
    // Function to calculate and return
    // the power of any given number
    static int power(int num, int n)
    {
        if (n == 0)
            return 1;
        else if (n % 2 == 0)
            return power(num, n / 2) * power(num, n / 2);
        else
            return num * power(num, n / 2)
                * power(num, n / 2);
    }
 
    // Function to check power
    // representations recursively
    static int checkRecursive(int x, int n, int curr_num,
                              int curr_sum)
    {
        // Initialize number of ways to express
        // x as n-th powers of different natural
        // numbers
        int results = 0;
 
        // Calling power of 'i' raised to 'n'
        int p = power(curr_num, n);
        while (p + curr_sum < x) {
            // Recursively check all greater values of i
            results += checkRecursive(x, n, curr_num + 1,
                                      p + curr_sum);
            curr_num++;
            p = power(curr_num, n);
        }
 
        // If sum of powers is equal to x
        // then increase the value of result.
        if (p + curr_sum == x)
            results++;
 
        // Return the final result
        return results;
    }
 
    // Driver Code.
    public static void Main()
    {
        int x = 10, n = 2;
        System.Console.WriteLine(
            checkRecursive(x, n, 1, 0));
    }
}
 
// This code is contributed by mits

Javascript

// javascript program to count number of ways any
// given integer x can be expressed as n-th
// power of unique natural numbers.
 
    // Function to calculate and return the
    // power of any given number
    function power(num , n)
    {
        if (n == 0)
            return 1;
        else if (n % 2 == 0)
            return power(num, parseInt(n / 2)) * power(num, parseInt(n / 2));
        else
            return num * power(num,parseInt(n / 2)) * power(num, parseInt(n / 2));
    }
 
    // Function to check power representations recursively
    function checkRecursive(x , n , curr_num , curr_sum)
    {
     
        // Initialize number of ways to express
        // x as n-th powers of different natural
        // numbers
        var results = 0;
 
        // Calling power of 'i' raised to 'n'
        var p = power(curr_num, n);
        while (p + curr_sum < x)
        {
         
            // Recursively check all greater values of i
            results += checkRecursive(x, n, curr_num + 1, p + curr_sum);
            curr_num++;
            p = power(curr_num, n);
        }
 
        // If sum of powers is equal to x
        // then increase the value of result.
        if (p + curr_sum == x)
            results++;
 
        // Return the final result
        return results;
    }
 
    // Driver Code.
        var x = 10, n = 2;
        document.write(checkRecursive(x, n, 1, 0));
 
// This code is contributed by gauravrajput1

输出

1

替代解决方案：

下面是Shivam Kanodia提供的另一个更简单的解决方案。

C++

// C++ program to find number of ways to express
// a number as sum of n-th powers of numbers.
#include
using namespace std;
 
int res = 0;
int checkRecursive(int num, int x, int k, int n)
{
    if (x == 0)
        res++;
     
    int r = (int)floor(pow(num, 1.0 / n));
 
    for (int i = k + 1; i <= r; i++)
    {
        int a = x - (int)pow(i, n);
        if (a >= 0)
            checkRecursive(num, x -
                          (int)pow(i, n), i, n);
    }
    return res;
}
 
// Wrapper over checkRecursive()
int check(int x, int n)
{
    return checkRecursive(x, x, 0, n);
}
 
// Driver Code
int main()
{
    cout << (check(10, 2));
    return 0;
}
 
// This code is contributed by mits

Java

// Java program to find number of ways to express a
// number as sum of n-th powers of numbers.
import java.io.*;
import java.util.*;
 
public class Solution {
 
    static int res = 0;
    static int checkRecursive(int num, int x, int k, int n)
    {
        if (x == 0)
            res++;
         
        int r = (int)Math.floor(Math.pow(num, 1.0 / n));
 
        for (int i = k + 1; i <= r; i++) {
            int a = x - (int)Math.pow(i, n);
          if (a >= 0)
            checkRecursive(num,
                   x - (int)Math.pow(i, n), i, n);
        }
        return res;
    }
     
    // Wrapper over checkRecursive()
    static int check(int x, int n)
    {
        return checkRecursive(x, x, 0, n);
    }
 
    public static void main(String[] args)
    {
        System.out.println(check(10, 2));
    }
}

Python3

# Python 3 program to find number of ways to express
# a number as sum of n-th powers of numbers.
 
 
def checkRecursive(num, rem_num, next_int, n, ans=0):
 
    if (rem_num == 0):
        ans += 1
 
    r = int(num**(1 / n))
 
    for i in range(next_int + 1, r + 1):
        a = rem_num - int(i**n)
        if a >= 0:
            ans += checkRecursive(num, rem_num - int(i**n), i, n, 0)
    return ans
 
# Wrapper over checkRecursive()
 
 
def check(x, n):
    return checkRecursive(x, x, 0, n)
 
 
# Driver Code
if __name__ == '__main__':
    print(check(10, 2))
 
# This code is contributed by
# Surendra_Gangwar

C＃

// C# program to find number of
// ways to express a number as sum
// of n-th powers of numbers.
using System;
 
class Solution {
 
    static int res = 0;
    static int checkRecursive(int num, int x,
                                int k, int n)
    {
        if (x == 0)
            res++;
         
        int r = (int)Math.Floor(Math.Pow(num, 1.0 / n));
 
        for (int i = k + 1; i <= r; i++)
        {
            int a = x - (int)Math.Pow(i, n);
        if (a >= 0)
            checkRecursive(num, x -
                          (int)Math.Pow(i, n), i, n);
        }
        return res;
    }
     
    // Wrapper over checkRecursive()
    static int check(int x, int n)
    {
        return checkRecursive(x, x, 0, n);
    }
     
    // Driver code
    public static void Main()
    {
        Console.WriteLine(check(10, 2));
    }
}
 
// This code is contributed by vt_m.

的PHP

= 0)
            checkRecursive($num, $x -
                    (int)pow($i, $n),
                             $i, $n);
    }
    return $res;
}
 
// Wrapper over
// checkRecursive()
function check($x, $n)
{
    return checkRecursive($x, $x,
                          0, $n);
}
 
// Driver Code
echo (check(10, 2));
 
// This code is contributed by ajit
?>

Java脚本

 
// JavaScript program for the above approach
  
    let res = 0;
    function checkRecursive(num, x, k, n)
    {
        if (x == 0)
            res++;
          
        let r = Math.floor(Math.pow(num, 1.0 / n));
  
        for (let i = k + 1; i <= r; i++) {
            let a = x - Math.pow(i, n);
          if (a >= 0)
            checkRecursive(num,
                   x - Math.pow(i, n), i, n);
        }
        return res;
    }
      
    // Wrapper over checkRecursive()
    function check(x, n)
    {
        return checkRecursive(x, x, 0, n);
    }
 
// Driver Code
      document.write(check(10, 2));
 
// This code is contributed by splevel62.

输出

1