# Count of groups among N people having only one leader in each group

• Last Updated : 06 May, 2021

Given N number of people, the task is to count the number of ways to form groups of size? N where, in each group, the first element of the group is the leader of the group.
Note:

• Groups with same people having different leaders are treated as a different group. For Example: The group {1, 2, 3} and {2, 1, 3} are treated as different group as they have different leader 1 and 2 respectively.
• Groups with same leader having same people are treated as a same group. For Example: The groups {1, 3, 2} and {1, 2, 3} are treated as same group as they have same leader and same people.
• The answer can be very large, take modulo to (1e9+7).

Examples:

Input: N = 3
Output: 12
Explanation:
1. {1}
2. {1, 2}
3. {1, 3}
4. {1, 2, 3}
5. {2}
6. {2, 1}
7. {2, 3}
8. {2, 1, 3}
9. {3}
10. {3, 1}
11. {3, 2}
12. {3, 1, 2}
Input: N = 5
Output: 80

Approach: This problem can be solved using the concept of Binomial coefficients and modular exponentiation. Below are the observations to this problem statement:

• The number of ways to select one leader among N persons is C(N, 1).
• For every leader we can select a group of size K where 0 â‰¤ K â‰¤ N-1 to make the possible number of grouping.
• So the total number ways is given by the product of N and the summation of selection K elements from the remaining (N – 1) elements as:

Total Ways =

By using Binomial Theorem, the summation of the Binomial Coefficient can be written as:

Therefore the number of ways of selecting groups having only one leader is

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach     #include  using namespace std;     long long mod = 1000000007;     // Function to find 2^x using  // modular exponentiation  int exponentMod(int A, int B)  {      // Base cases      if (A == 0)          return 0;      if (B == 0)          return 1;         // If B is even      long long y;      if (B % 2 == 0) {          y = exponentMod(A, B / 2);          y = (y * y) % mod;      }         // If B is odd      else {          y = A % mod;          y = (y * exponentMod(A, B - 1)               % mod)              % mod;      }         return (int)((y + mod) % mod);  }     // Function to count the number of  // ways to form the group having  // one leader  void countWays(int N)  {         // Find 2^(N-1) using modular      // exponentiation      long long select = exponentMod(2,                                     N - 1);         // Count total ways      long long ways          = ((N % mod)             * (select % mod));         ways %= mod;         // Print the total ways      cout << ways;  }     // Driver Code  int main()  {         // Given N number of peoples      int N = 5;         // Function Call      countWays(N);  }

## Java

 // Java program for the above approach  import java.util.*;  class GFG{     static long mod = 1000000007;     // Function to find 2^x using  // modular exponentiation  static int exponentMod(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 = exponentMod(A, B / 2);          y = (y * y) % mod;      }         // If B is odd      else      {          y = A % mod;          y = (y * exponentMod(A, B - 1) %                                     mod) % mod;      }         return (int)((y + mod) % mod);  }     // Function to count the number of  // ways to form the group having  // one leader  static void countWays(int N)  {         // Find 2^(N-1) using modular      // exponentiation      long select = exponentMod(2, N - 1);         // Count total ways      long ways = ((N % mod) * (select % mod));         ways %= mod;         // Print the total ways      System.out.print(ways);  }     // Driver Code  public static void main(String[] args)  {         // Given N number of peoples      int N = 5;         // Function Call      countWays(N);  }  }     // This code is contributed by sapnasingh4991

## Python3

 # Python3 program for the above approach  mod = 1000000007    # Function to find 2^x using  # modular exponentiation  def exponentMod(A, B):             # Base cases      if (A == 0):          return 0;      if (B == 0):          return 1;         # If B is even      y = 0;             if (B % 2 == 0):          y = exponentMod(A, B // 2);          y = (y * y) % mod;         # If B is odd      else:          y = A % mod;          y = (y * exponentMod(A, B - 1) %                                   mod) % mod;                                      return ((y + mod) % mod);     # Function to count the number of  # ways to form the group having  # one leader  def countWays(N):             # Find 2^(N-1) using modular      # exponentiation      select = exponentMod(2, N - 1);         # Count total ways      ways = ((N % mod) * (select % mod));         ways %= mod;         # Print the total ways      print(ways)         # Driver code          if __name__=='__main__':             # Given N number of people      N = 5;         # Function call      countWays(N);     # This code is contributed by rutvik_56

## C#

 // C# program for the above approach  using System;  class GFG{      static long mod = 1000000007;      // Function to find 2^x using  // modular exponentiation  static int exponentMod(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 = exponentMod(A, B / 2);          y = (y * y) % mod;      }          // If B is odd      else     {          y = A % mod;          y = (y * exponentMod(A, B - 1) %                                     mod) % mod;      }          return (int)((y + mod) % mod);  }      // Function to count the number of  // ways to form the group having  // one leader  static void countWays(int N)  {          // Find 2^(N-1) using modular      // exponentiation      long select = exponentMod(2, N - 1);          // Count total ways      long ways = ((N % mod) * (select % mod));          ways %= mod;          // Print the total ways      Console.Write(ways);  }      // Driver Code  public static void Main(String[] args)  {          // Given N number of peoples      int N = 5;          // Function Call      countWays(N);  }  }     // This code is contributed by sapnasingh4991

## Javascript

 

Output:

80

Time Complexity: O(log N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :