可以由N个顶点形成的不同图形的计数

给定整数N ，它是顶点数。任务是找到可以形成的不同图形的数量。由于答案可能非常大，因此请打印答案％1000000007 。
例子：

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

方法：

• 具有N个顶点的图形可包含的最大边数为X = N *(N – 1)/ 2。
• 包含0个边和N个顶点的图形总数为^X C ₀
• 包含1个边和N个顶点的图形总数为^X C ₁
• 依此类推，从多个边1到具有N个顶点的X
• 因此，可以用n个顶点形成的图的总数将是：
  ^X C ₀ + ^X C ₁ + ^X C ₂ +…+ ^X C _X = 2 ^X。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
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

 
// 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));
 

输出：

1024