Kn +(K(n-1)*(K-1)1)+(K(n-2)*(K-1)2)+……的和。 (K-1)n

给定值K和n，任务是找到以下序列的总和：

Kⁿ + ( K^(n-1) * (K-1)¹ ) + ( K^(n-2) * (K-1)² ) + ……. (K-1)ⁿ

例子：

Input:  n = 3, K = 3
Output: 65
Explanation:
(3*3*3) + (3*3*2) + (3*2*2) + (2*2*2)
= 27 + 18 + 12 + 8
= 65 


Input: n = 4, k = 2
Output: 31
Explanation:
(2*2*2*2) + (2*2*2*1)+ (2*2*1*1) + (2*1*1*1) + (1*1*1*1)
= 16 + 8 + 4 + 2 + 1
= 31

1. 简单方法：O(n ² )
   1. 序列中的项总数= n + 1
   2. 分别计算每个术语，并将其相加：

   下面是上述方法的实现：

   C++

   // C++ implementation of the approach
     
   #include 
   using namespace std;
     
   // Function to return sum
   int sum(int k, int n)
   {
     
       int sum = 0;
       for (int i = 0; i <= n; i++) {
           int p = 1;
     
           for (int j = 0; j < n - i; j++) {
               p = p * k;
           }
     
           for (int j = 0; j < i; j++) {
               p = p * (k - 1);
           }
     
           sum = sum + p;
       }
       return sum;
   }
     
   // Driver code
   int main()
   {
       int n = 3;
       int K = 3;
       cout << sum(K, n);
   }

   Java

   // Java implementation of the approach
   class GFG {
       // Function to return sum
       static int sum(int k, int n)
       {
     
           int sum = 0;
           for (int i = 0; i <= n; i++) {
               int p = 1;
     
               for (int j = 0; j < n - i; j++) {
                   p = p * k;
               }
     
               for (int j = 0; j < i; j++) {
                   p = p * (k - 1);
               }
     
               sum = sum + p;
           }
           return sum;
       }
     
       // Driver code
       public static void main(String[] args)
       {
           int n = 3;
           int K = 3;
           System.out.println(sum(K, n));
       }
   }
     
   // This code is contributed by Code_Mech

   Python3

   # Python3 implementation of the approach
     
   # Function to return sum
   def Sum(k, n):
     
       Summ = 0
       for i in range(n + 1):
           p = 1
     
           for j in range(n - i):
               p = p * k
     
           for j in range(i):
               p = p * (k - 1)
             
           Summ = Summ + p
         
       return Summ
     
   # Driver code
   n = 3
   K = 3
   print(Sum(K, n))
     
   # This code is contributed by mohit kumar

   C#

   // C# implementation of the approach
     
   using System;
     
   class GFG {
       // Function to return sum
       static int sum(int k, int n)
       {
     
           int sum = 0;
           for (int i = 0; i <= n; i++) {
               int p = 1;
     
               for (int j = 0; j < n - i; j++) {
                   p = p * k;
               }
     
               for (int j = 0; j < i; j++) {
                   p = p * (k - 1);
               }
     
               sum = sum + p;
           }
           return sum;
       }
     
       // Driver code
       public static void Main()
       {
           int n = 3;
           int K = 3;
           Console.WriteLine(sum(K, n));
       }
       // This code is contributed by Ryuga
   }

   ---

   输出：

   65
   

   时间复杂度：O(n ^ 2)

2. 第二种方法：O(n)

   可以看到，给定级数为几何级数，公共比率=(K – 1)/ K
   因此，以上表达式可以简化为：

   

   下面是上述方法的实现：

   C++

   #include 
   using namespace std;
     
   // Function to return sum
   int sum(int k, int n)
   {
       int sum
           = pow(k, n + 1)
             - pow(k - 1, n + 1);
     
       return sum;
   }
     
   // Driver code
   int main()
   {
       int n = 3;
       int K = 3;
       cout << sum(K, n);
   }
   

   Java

   // Java implementation of above approach
   class GFG
   {
     
   // Function to return sum
   static int sum(int k, int n)
   {
       int sum = (int)(Math.pow(k, n + 1) - 
                       Math.pow(k - 1, n + 1));
     
       return sum;
   }
     
   // Driver code
   public static void main(String args[])
   {
       int n = 3;
       int K = 3;
       System.out.print(sum(K, n));
   }
   }
     
   // This code is contributed
   // by Akanksha Rai
   

   Python3

   # Function to return sum 
   def sum(k, n):
       sum = (pow(k, n + 1) - 
              pow(k - 1, n + 1)); 
     
       return sum; 
     
   # Driver code 
   n = 3; 
   K = 3; 
   print(sum(K, n)); 
     
   # This code is contributed by mits
   

   C＃

   // C# implementation of above approach
   using System;
     
   class GFG
   {
     
   // Function to return sum
   static int sum(int k, int n)
   {
       int sum = (int)(Math.Pow(k, n + 1) - 
                       Math.Pow(k - 1, n + 1));
     
       return sum;
   }
     
   // Driver code
   public static void Main()
   {
       int n = 3;
       int K = 3;
       Console.Write(sum(K, n));
   }
   }
     
   // This code is contributed
   // by Akanksha Rai
   

   输出：

   65
   

   时间复杂度：O(n)

3. 第三种方法(有效)：O(log n)

   注意：通过计算log(n)复杂度的幂，可以进一步将时间复杂度降低为O(log(n))。

   下面是上述方法的实现：

   C++

   #include 
   using namespace std;
     
   // Recursive C program to compute modular power
   int exponent(int A, int B)
   {
       // Base cases
       if (A == 0)
           return 0;
       if (B == 0)
           return 1;
     
       // If B is even
       long y;
       if (B % 2 == 0) {
           y = exponent(A, B / 2);
           y = (y * y);
       }
     
       // If B is odd
       else {
           y = A;
           y = (y * exponent(A, B - 1));
       }
     
       return y;
   }
     
   // Function to return sum
   int sum(int k, int n)
   {
       int sum = exponent(k, n + 1)
                 - exponent(k - 1, n + 1);
     
       return sum;
   }
     
   // Driver code
   int main()
   {
       int n = 3;
       int K = 3;
       cout << sum(K, n);
   }
   

   Java

   import java.lang.Math;
     
   class GFG
   {
         
   // Recursive C program to compute modular power
   static int exponent(int A, int B)
   {
       // Base cases
       if (A == 0)
           return 0;
       if (B == 0)
           return 1;
     
       // If B is even
       int y;
       if (B % 2 == 0) 
       {
           y = exponent(A, B / 2);
           y = (y * y);
       }
     
       // If B is odd
       else 
       {
           y = A;
           y = (y * exponent(A, B - 1));
       }
     
       return y;
   }
     
   // Function to return sum
   static int sum(int k, int n)
   {
       int sum = exponent(k, n + 1)
               - exponent(k - 1, n + 1);
     
       return sum;
   }
     
   // Driver code
   public static void main(String[] args)
   {
       int n = 3;
       int K = 3;
       System.out.println(sum(K, n));
   }
   }
     
   // This code is contributed by Code_Mech.
   

   Python3

   # Recursive python3 program to compute modular power
     
   def exponent(A, B):
       # Base cases
       if (A == 0):
           return 0;
       if (B == 0):
           return 1;
     
       # If B is even
       if (B % 2 == 0):
           y = exponent(A, B / 2);
           y = (y * y);
     
       # If B is odd
       else:
           y = A;
           y = (y * exponent(A, B - 1));
     
       return y;
     
   # Function to return sum
   def sum(k, n):
       sum = exponent(k, n + 1) - exponent(k - 1, n + 1);
     
       return sum;
     
   # Driver code
   n = 3;
   K = 3;
   print(sum(K, n));
     
   # This code has been contributed by 29AjayKumar
   

   C＃

   // C# program of above approach
   using System;
     
   class GFG
   {
         
   // Recursive C program to compute modular power
   static int exponent(int A, int B)
   {
       // Base cases
       if (A == 0)
           return 0;
       if (B == 0)
           return 1;
     
       // If B is even
       int y;
       if (B % 2 == 0) 
       {
           y = exponent(A, B / 2);
           y = (y * y);
       }
     
       // If B is odd
       else
       {
           y = A;
           y = (y * exponent(A, B - 1));
       }
     
       return y;
   }
     
   // Function to return sum
   static int sum(int k, int n)
   {
       int sum = exponent(k, n + 1)
               - exponent(k - 1, n + 1);
     
       return sum;
   }
     
   // Driver code
   public static void Main()
   {
       int n = 3;
       int K = 3;
       Console.WriteLine(sum(K, n));
   }
   }
     
   // This code is contributed by Code_Mech.
   

   输出：

   65