Skip to content
Related Articles

Related Articles

Minimum Players required to win the game

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 14 Jun, 2021

Given N questions and K options for each question, where 1\leq N \leq 1000000000      and 1\leq K \leq 1000000000      . The task is to determine sum of total number of player who has attempted ith question for all 1 \leq i \leq N      to win the game anyhow. You have to minimize the sum of total number of player and output it modulo 109+7.
Note: Any wrong answer leads to elimination of the player.

Examples: 

Input: N = 3, K = 3
Output: 39

Input: N = 5, K = 2
Output: 62

Approach: 

  • To solve Nth question K players are needed.
  • To solve (N-1)th question K2 players are needed.
  • Similarly moving onwards, To solve 1st question KN players are needed.

So, our problem reduces to finding the sum of GP terms K + K2 + … + KN which is equal to \frac{K(K^{N}-1)}{K-1}
Now we can use Fermat’s Little Theorem to get the required answer modulo with 109+7.

Below is the implementation of above approach:  

C++




// C++ program to find minimum players
// required to win the game anyhow
#include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
 
// function to calculate (a^b)%(10^9+7).
long long int power(long long int a, long long int b)
{
    long long int res = 1;
    while (b) {
        if (b & 1) {
            res *= a;
            res %= mod;
        }
        b /= 2;
        a *= a;
        a %= mod;
    }
    return res;
}
 
// function to find the minimum required player
long long int minPlayer(long long int n, long long int k)
{
 
    // computing the nenomenator
    long long int num = ((power(k, n) - 1) + mod) % mod;
 
    // computing modulo inverse of denominator
    long long int den = (power(k - 1, mod - 2) + mod) % mod;
 
    // final result
    long long int ans = (((num * den) % mod) * k) % mod;
 
    return ans;
}
 
// Driver code
int main()
{
 
    long long int n = 3, k = 3;
 
    cout << minPlayer(n, k);
 
    return 0;
}

Java




//Java program to find minimum players
//required to win the game anyhow
public class TYU {
     
    static long  mod =  1000000007;
 
    //function to calculate (a^b)%(10^9+7).
     static long power(long a, long b)
     {
      long res = 1;
      while (b != 0) {
          if ((b & 1) != 0) {
              res *= a;
              res %= mod;
          }
          b /= 2;
          a *= a;
          a %= mod;
      }
      return res;
     }
 
     //function to find the minimum required player
     static long minPlayer(long n, long k)
     {
 
      // computing the nenomenator
      long num = ((power(k, n) - 1) + mod) % mod;
 
      // computing modulo inverse of denominator
      long den = (power(k - 1, mod - 2) + mod) % mod;
 
      // final result
      long ans = (((num * den) % mod) * k) % mod;
 
      return ans;
     }
 
     //Driver code
    public static void main(String[] args) {
         
         long n = 3, k = 3;
 
         System.out.println(minPlayer(n, k));
    }
}

Python 3




# Python 3 Program  to find minimum players
#  required to win the game anyhow
 
# constant
mod = 1000000007
 
# function to calculate (a^b)%(10^9+7).
def power(a, b) :
    res = 1
 
    while(b) :
        if (b & 1) :
            res *= a
            res %= mod
 
        b //= 2
        a *= a
        a %= mod
 
    return res
 
# function to find the minimum required player
def minPlayer(n, k) :
 
    # computing the nenomenator
    num = ((power(k, n) - 1) + mod) % mod
 
    # computing modulo inverse of denominator
    den = (power(k - 1,mod - 2) + mod) % mod
 
    # final result
    ans = (((num * den) % mod ) * k) % mod
 
    return ans
 
# Driver Code
if __name__ == "__main__" :
 
    n, k = 3, 3
 
    print(minPlayer(n, k))
 
# This code is contributed by ANKITRAI1

C#




// C# program to find minimum players
// required to win the game anyhow
using System;
class GFG
{
 
static long mod = 1000000007;
 
// function to calculate (a^b)%(10^9+7).
static long power(long a, long b)
{
long res = 1;
while (b != 0)
{
    if ((b & 1) != 0)
    {
        res *= a;
        res %= mod;
    }
    b /= 2;
    a *= a;
    a %= mod;
}
return res;
}
 
// function to find the minimum
// required player
static long minPlayer(long n, long k)
{
 
    // computing the nenomenator
    long num = ((power(k, n) - 1) + mod) % mod;
     
    // computing modulo inverse
    // of denominator
    long den = (power(k - 1, mod - 2) + mod) % mod;
     
    // final result
    long ans = (((num * den) % mod) * k) % mod;
     
    return ans;
}
 
// Driver code
public static void Main()
{
    long n = 3, k = 3;
 
    Console.WriteLine(minPlayer(n, k));
}
}
 
// This code is contributed
// by Shashank

PHP




<?php
// PHP program to find minimum players
// required to win the game anyhow
 
// function to calculate (a^b)%(10^9+7).
function power($a, $b)
{
    $mod = 1000000007;
    $res = 1;
    while ($b)
    {
        if ($b & 1)
        {
            $res *= $a;
            $res %= $mod;
        }
        $b /= 2;
        $a *= $a;
        $a %= $mod;
    }
    return $res;
}
 
// function to find the minimum
// required player
function minPlayer($n, $k)
{
    $mod =1000000007;
     
    // computing the nenomenator
    $num = ((power($k, $n) - 1) +
                   $mod) % $mod;
 
    // computing modulo inverse
    // of denominator
    $den = (power($k - 1, $mod - 2) +
                  $mod) % $mod;
 
    // final result
    $ans = ((($num * $den) % $mod) *
                       $k) % $mod;
 
    return $ans;
}
 
// Driver code
$n = 3;
$k = 3;
 
echo minPlayer($n, $k);
 
// This code is contributed
// by Shivi_Aggarwal
?>

Javascript




<script>
//javascript program to find minimum players
//required to win the game anyhow
 
 
    var mod = 107;
 
    // function to calculate (a^b)%(10^9+7).
    function power(a , b) {
        var res = 1;
        while (b != 0) {
            if ((b & 1) != 0) {
                res *= a;
                res = res%mod;
            }
            b = parseInt(b/2);
            a *= a;
            a %= mod;
        }
        return res;
    }
 
    // function to find the minimum required player
    function minPlayer(n , k) {
 
        // computing the nenomenator
        var num = ((power(k, n) - 1) + mod) % mod;
 
        // computing modulo inverse of denominator
        var den = (power(k - 1, mod - 2) + mod) % mod;
 
        // final result
        var ans = (((num * den) % mod) * k) % mod;
 
        return ans;
    }
 
    // Driver code
     
 
        var n = 3, k = 3;
 
        document.write(minPlayer(n, k));
 
// This code contributed by gauravrajput1
</script>

Output: 

39

 

Time Complexity: O(log(n))
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!