Open In App

Count of distinct graphs that can be formed with N vertices

Improve
Improve
Like Article
Like
Save
Share
Report

Given an integer N which is the number of vertices. The task is to find the number of distinct graphs that can be formed. Since the answer can be very large, print the answer % 1000000007.
Examples: 
 

Input: N = 3 
Output: 8
Input: N = 4 
Output: 64 
 

 

Approach: 
 

  • The maximum number of edges a graph with N vertices can contain is X = N * (N – 1) / 2.
  • The total number of graphs containing 0 edge and N vertices will be XC0
  • The total number of graphs containing 1 edge and N vertices will be XC1
  • And so on from a number of edges 1 to X with N vertices
  • Hence, the total number of graphs that can be formed with n vertices will be:
    XC0 + XC1 + XC2 + … + XCX = 2X.

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
const int MOD = 1e9 + 7;
 
// Function to return (x^y) % MOD
// in O(log(y))
long long power(long long x,
                long long y,
                const int& MOD)
{
    long long res = 1;
    while (y > 0) {
        if (y & 1)
            res = (res * x) % MOD;
        x = (x * x) % MOD;
        y /= 2;
    }
    return res;
}
 
// Function to return the count of distinct
// graphs possible with n vertices
long long countGraphs(int n)
{
 
    // Maximum number of edges for a
    // graph with n vertices
    long long x = n * (n - 1) / 2;
 
    // Function to calculate
    // (2^x) % mod
    return power(2, x, MOD);
}
 
// Driver code
int main()
{
    int n = 5;
 
    cout << countGraphs(n);
 
    return 0;
}


Java




// Java implementation of the approach
class GFG
{
    static final int MOD = (int)1e9 + 7;
     
    // Function to return (x^y) % MOD
    // in O(log(y))
    static long power(long x,
                      long y)
    {
        long res = 1;
        while (y > 0)
        {
            if ((y & 1) != 0)
                res = (res * x) % MOD;
            x = (x * x) % MOD;
            y /= 2;
        }
        return res;
    }
     
    // Function to return the count of distinct
    // graphs possible with n vertices
    static long countGraphs(int n)
    {
     
        // Maximum number of edges for a
        // graph with n vertices
        long x = n * (n - 1) / 2;
     
        // Function to calculate
        // (2^x) % mod
        return power(2, x);
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int n = 5;
     
        System.out.println(countGraphs(n));
    }
}
 
// This code is contributed by AnkitRai01


Python




MOD = int(1e9 + 7)
 
# Function to return the count of distinct
# graphs possible with n vertices
def countGraphs(n):
 
    # Maximum number of edges for a
    # graph with n vertices
    x = (n *( n - 1 )) //2
     
    # Return 2 ^ x
    return (pow(2, x, MOD))
 
# Driver code
n = 5
print(countGraphs(n))


C#




// C# implementation of the approach
using System;
 
class GFG
{
    static int MOD = (int)1e9 + 7;
     
    // Function to return (x^y) % MOD
    // in O(log(y))
    static long power(long x, long y)
    {
        long res = 1;
        while (y > 0)
        {
            if ((y & 1) != 0)
                res = (res * x) % MOD;
            x = (x * x) % MOD;
            y /= 2;
        }
        return res;
    }
     
    // Function to return the count of distinct
    // graphs possible with n vertices
    static long countGraphs(int n)
    {
     
        // Maximum number of edges for a
        // graph with n vertices
        long x = n * (n - 1) / 2;
     
        // Function to calculate
        // (2^x) % mod
        return power(2, x);
    }
     
    // Driver code
    static public void Main ()
    {
        int n = 5;
     
        Console.Write(countGraphs(n));
    }
}
 
// This code is contributed by ajit.


Javascript




<script>
 
// Javascript implementation of the approach
 
const MOD = 1000000000 + 7;
 
// Function to return (x^y) % MOD
// in O(log(y))
function power(x, y, MOD)
{
    let res = 1;
    while (y > 0) {
        if (y & 1)
            res = (res * x) % MOD;
        x = (x * x) % MOD;
        y = parseInt(y / 2);
    }
    return res;
}
 
// Function to return the count of distinct
// graphs possible with n vertices
function countGraphs(n)
{
 
    // Maximum number of edges for a
    // graph with n vertices
    let x = parseInt(n * (n - 1) / 2);
 
    // Function to calculate
    // (2^x) % mod
    return power(2, x, MOD);
}
 
// Driver code
    let n = 5;
 
    document.write(countGraphs(n));
 
</script>


Output: 

1024

 

Time Complexity: O(log(n2))

Auxiliary Space: O(1)



Last Updated : 28 Mar, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads