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++ 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 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# 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 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 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..
?>

<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>

21

Complexity Analysis:

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