Minimum spanning tree cost of given Graphs

Given an undirected graph of V nodes (V > 2) named V₁, V₂, V₃, …, V_n. Two nodes V_i and V_j are connected to each other if and only if 0 < | i – j | ? 2. Each edge between any vertex pair (V_i, V_j) is assigned a weight i + j. The task is to find the cost of the minimum spanning tree of such graph with V nodes.

Examples:

Input: V = 4 

Output: 13

Input: V = 5 
Output: 21 

Approach:

Starting with a graph with minimum nodes (i.e. 3 nodes), the cost of the minimum spanning tree will be 7. Now for every node i starting from the fourth node which can be added to this graph, i^th node can only be connected to (i – 1)^th and (i – 2)^th node and the minimum spanning tree will only include the node with the minimum weight so the newly added edge will have the weight i + (i – 2). 

So addition of fourth node will increase the overall weight as 7 + (4 + 2) = 13 
Similarly adding fifth node, weight = 13 + (5 + 3) = 21 
… 
For n^th node, weight = weight + (n + (n – 2)). 

This can be generalized as weight = V² – V + 1 where V is the total nodes in the graph.

Below is the implementation of the above approach: 

C++

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

// Function that returns the minimum cost
// of the spanning tree for the required graph
int getMinCost(int Vertices)
{
    int cost = 0;

    // Calculating cost of MST
    cost = (Vertices * Vertices) - Vertices + 1;

    return cost;
}

// Driver code
int main()
{
    int V = 5;
    cout << getMinCost(V);

    return 0;
}

Java

// Java implementation of the approach
class GfG
{

// Function that returns the minimum cost
// of the spanning tree for the required graph
static int getMinCost(int Vertices)
{
    int cost = 0;

    // Calculating cost of MST
    cost = (Vertices * Vertices) - Vertices + 1;

    return cost;
}

// Driver code
public static void main(String[] args)
{
    int V = 5;
    System.out.println(getMinCost(V));
}
}

// This code is contributed by
// Prerna Saini.

C#

// C# implementation of the above approach
using System;

class GfG
{

    // Function that returns the minimum cost
    // of the spanning tree for the required graph
    static int getMinCost(int Vertices)
    {
        int cost = 0;

        // Calculating cost of MST
        cost = (Vertices * Vertices) - Vertices + 1;

        return cost;
    }

    // Driver code
    public static void Main()
    {
        int V = 5;
        Console.WriteLine(getMinCost(V));
    }
}

// This code is contributed by Ryuga

Python3

# python3 implementation of the approach

# Function that returns the minimum cost
# of the spanning tree for the required graph
def getMinCost( Vertices):
    cost = 0

    # Calculating cost of MST
    cost = (Vertices * Vertices) - Vertices + 1

    return cost

# Driver code
if __name__ == "__main__":

    V = 5
    print (getMinCost(V))

PHP

<?php
// PHP implementation of the approach
// Function that returns the minimum cost
// of the spanning tree for the required graph
function getMinCost($Vertices)
{
    $cost = 0;

    // Calculating cost of MST
    $cost = ($Vertices * $Vertices) - $Vertices + 1;

    return $cost;
}

// Driver code
$V = 5;
echo getMinCost($V);

#This Code is contributed by ajit..
?>

Javascript

<script>

// Javascript implementation of the approach

// Function that returns the minimum cost
// of the spanning tree for the required graph
function getMinCost(Vertices)
{
    var cost = 0;

    // Calculating cost of MST
    cost = (Vertices * Vertices) - Vertices + 1;

    return cost;
}

// Driver code
var V = 5;
document.write( getMinCost(V));

// This code is contributed by rrrtnx.
</script>

Output

21

Complexity Analysis:

• Time Complexity: O(1)
• Auxiliary Space: O(1)