Number of Simple Graph with N Vertices and M Edges

Given two integers N and M, the task is to count the number of simple undirected graphs that can be drawn with N vertices and M edges. A simple graph is a graph that does not contain multiple edges and self-loops.

Examples:

Input: N = 3, M = 1 
Output: 3 
The 3 graphs are {1-2, 3}, {2-3, 1}, {1-3, 2}.

Input: N = 5, M = 1 
Output: 10 

Approach: The N vertices are numbered from 1 to N. As there are no self-loops or multiple edges, the edge must be present between two different vertices. So the number of ways we can choose two different vertices is ^NC₂ which is equal to (N * (N – 1)) / 2. Assume it P. 

Now M edges must be used with these pairs of vertices, so the number of ways to choose M pairs of vertices between P pairs will be ^PC_M. 

If P < M then the answer will be 0 as the extra edges can not be left alone.

Below is the implementation of the above approach: 

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function to return the value of
// Binomial Coefficient C(n, k)
int binomialCoeff(int n, int k)
{

    if (k > n)
        return 0;

    int res = 1;

    // Since C(n, k) = C(n, n-k)
    if (k > n - k)
        k = n - k;

    // Calculate the value of
    // [n * (n - 1) *---* (n - k + 1)] / [k * (k - 1) * ... * 1]
    for (int i = 0; i < k; ++i) {
        res *= (n - i);
        res /= (i + 1);
    }

    return res;
}

// Driver Code
int main()
{
    int N = 5, M = 1;

    int P = (N * (N - 1)) / 2;

    cout << binomialCoeff(P, M);

    return 0;
}

Java

// Java implementation of the approach
class GFG
{

    // Function to return the value of
    // Binomial Coefficient C(n, k)
    static int binomialCoeff(int n, int k)
    {

        if (k > n)
            return 0;

        int res = 1;

        // Since C(n, k) = C(n, n-k)
        if (k > n - k)
            k = n - k;

        // Calculate the value of
        // [n * (n - 1) *---* (n - k + 1)] /
        // [k * (k - 1) * ... * 1]
        for (int i = 0; i < k; ++i)
        {
            res *= (n - i);
            res /= (i + 1);
        }
        return res;
    }

// Driver Code
public static void main(String[] args)
{
    int N = 5, M = 1;
    int P = (N * (N - 1)) / 2;

    System.out.println(binomialCoeff(P, M));
}
}

// This code is contributed by Shivi_Aggarwal

Python 3

# Python 3 implementation of the approach

# Function to return the value of
# Binomial Coefficient C(n, k)
def binomialCoeff(n, k):

    if (k > n):
        return 0

    res = 1

    # Since C(n, k) = C(n, n-k)
    if (k > n - k):
        k = n - k

    # Calculate the value of
    # [n * (n - 1) *---* (n - k + 1)] /
    # [k * (k - 1) * ... * 1]
    for i in range( k):
        res *= (n - i)
        res //= (i + 1)

    return res

# Driver Code
if __name__=="__main__":

    N = 5
    M = 1

    P = (N * (N - 1)) // 2

    print(binomialCoeff(P, M))

# This code is contributed by ita_c

C#

// C# implementation of the approach
using System;

class GFG
{
// Function to return the value of
// Binomial Coefficient C(n, k)
static int binomialCoeff(int n, int k)
{

    if (k > n)
        return 0;

    int res = 1;

    // Since C(n, k) = C(n, n-k)
    if (k > n - k)
        k = n - k;

    // Calculate the value of
    // [n * (n - 1) *---* (n - k + 1)] /
    // [k * (k - 1) * ... * 1]
    for (int i = 0; i < k; ++i)
    {
        res *= (n - i);
        res /= (i + 1);
    }

    return res;
}

// Driver Code
public static void Main()
{
    int N = 5, M = 1;

    int P = (N * (N - 1)) / 2;

    Console.Write(binomialCoeff(P, M));
}
}

// This code is contributed
// by Akanksha Rai

PHP

<?php
// PHP implementation of the approach

// Function to return the value of
// Binomial Coefficient C(n, k)
function binomialCoeff($n, $k)
{
    if ($k > $n)
        return 0;

    $res = 1;

    // Since C(n, k) = C(n, n-k)
    if ($k > $n - $k)
        $k = $n - $k;

    // Calculate the value of
    // [n * (n - 1) *---* (n - k + 1)] /
    // [k * (k - 1) * ... * 1]
    for ($i = 0; $i < $k; ++$i)
    {
        $res *= ($n - $i);
        $res /= ($i + 1);
    }

    return $res;
}

// Driver Code
$N = 5;
$M = 1;

$P = floor(($N * ($N - 1)) / 2);

echo binomialCoeff($P, $M);

// This code is contributed by Ryuga
?>

Javascript

<script>

// Javascript implementation of the approach

// Function to return the value of
// Binomial Coefficient C(n, k)
function binomialCoeff(n, k)
{

    if (k > n)
        return 0;

    var res = 1;

    // Since C(n, k) = C(n, n-k)
    if (k > n - k)
        k = n - k;

    // Calculate the value of
    // [n * (n - 1) *---* (n - k + 1)] / [k * (k - 1) * ... * 1]
    for (var i = 0; i < k; ++i) {
        res *= (n - i);
        res /= (i + 1);
    }

    return res;
}

// Driver Code
var N = 5, M = 1;
var P = (N * (N - 1)) / 2;
document.write( binomialCoeff(P, M));

</script>

Output

10

Complexity Analysis:

• Time Complexity: O(M), where M is the number of edges.
• Space Complexity: O(1), since no extra space has been taken.