Construct a graph using N vertices whose shortest distance between K pair of vertices is 2

0 0 6 minutes read

Given two positive integers N and K, the task is to construct a simple and connected graph consisting of N vertices with the length of each edge as 1 unit, such that the shortest distance between exactly K pairs of vertices is 2. If it is not possible to construct the graph, then print -1. Otherwise, print the edges of the graph.

Examples:

Input: N = 5, K = 3
Output: { { 1, 2 }, { 1, 3}, { 1, 4 }, { 1, 5 }, { 2, 3 }, { 2, 4 }, { 2, 5 } }
Explanation:
The distance between the pairs of vertices { (3, 4), (4, 5), (3, 5) } is 2.

Input: N = 5, K = 8
Output: -1

Approach: Follow the steps below to solve the problem:

Since the graph is simple and connected, Therefore, the maximum possible count of edges, say Max is ((N – 1) * (N – 2)) / 2.
If K is greater than Max, then print -1.
Initialize an array, say edges[], to store the edges of the graph.
Otherwise, first connect all the vertices with 1 and store it in edges[], then connect all the pairs of vertices (i, j) such that i >= 2 and j > i and store it in edges[].
Finally, print the first ((N – 1) + Max – K ) elements of edges[] array.

Below is the implementation of the above approach:

C++

// C++ program to implement
// the above approach
 
#include <iostream>
#include <vector>
using namespace std;
 
// Function to construct the simple and
// connected graph such that the distance
// between exactly K pairs of vertices is 2
void constGraphWithCon(int N, int K)
{
 
    // Stores maximum possible count
    // of edges in a graph
    int Max = ((N - 1) * (N - 2)) / 2;
 
    // Base Case
    if (K > Max) {
        cout << -1 << endl;
        return;
    }
 
    // Stores edges of a graph
    vector<pair<int, int> > ans;
 
    // Connect all vertices of pairs (i, j)
    for (int i = 1; i < N; i++) {
        for (int j = i + 1; j <= N; j++) {
            ans.emplace_back(make_pair(i, j));
        }
    }
 
    // Print first ((N - 1) + Max - K)  elements
    // of edges[]
    for (int i = 0; i < (N - 1) + Max - K; i++) {
        cout << ans[i].first << " "
             << ans[i].second << endl;
    }
}
 
// Driver Code
int main()
{
    int N = 5, K = 3;
    constGraphWithCon(N, K);
 
    return 0;
}

C

// C program to implement
// the above approach
 
#include <stdio.h>
 
// Function to construct the simple and
// connected graph such that the distance
// between exactly K pairs of vertices is 2
void constGraphWithCon(int N, int K)
{
 
    // Stores maximum possible count
    // of edges in a graph
    int Max = ((N - 1) * (N - 2)) / 2;
 
    // Base Case
    if (K > Max) {
        printf("-1");
        return;
    }
 
    // Stores count of edges in a graph
    int count = 0;
 
    // Connect all vertices of pairs (i, j)
    for (int i = 1; i < N; i++) {
 
        for (int j = i + 1; j <= N; j++) {
 
            printf("%d %d\n", i, j);
 
            // Update
            count++;
 
            if (count == N * (N - 1) / 2 - K)
                break;
        }
 
        if (count == N * (N - 1) / 2 - K)
            break;
    }
}
 
// Driver Code
int main()
{
    int N = 5, K = 3;
    constGraphWithCon(N, K);
 
    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
     
static class pair
{ 
    int first, second; 
     
    public pair(int first, int second)  
    { 
        this.first = first; 
        this.second = second; 
    }    
} 
 
// Function to construct the simple and connected
// graph such that the distance between 
// exactly K pairs of vertices is 2
static void constGraphWithCon(int N, int K)
{
     
    // Stores maximum possible count
    // of edges in a graph
    int Max = ((N - 1) * (N - 2)) / 2;
 
    // Base Case
    if (K > Max)
    {
        System.out.print(-1 + "\n");
        return;
    }
 
    // Stores edges of a graph
    Vector<pair> ans = new Vector<>();
 
    // Connect all vertices of pairs (i, j)
    for(int i = 1; i < N; i++) 
    {
        for(int j = i + 1; j <= N; j++) 
        {
            ans.add(new pair(i, j));
        }
    }
 
    // Print first ((N - 1) + Max - K)  elements
    // of edges[]
    for(int i = 0; i < (N - 1) + Max - K; i++) 
    {
        System.out.print(ans.get(i).first + " " + 
                         ans.get(i).second +"\n");
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 5, K = 3;
     
    constGraphWithCon(N, K);
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program to implement
# the above approach
 
# Function to construct the simple and
# connected graph such that the distance
# between exactly K pairs of vertices is 2
def constGraphWithCon(N, K):
   
    # Stores maximum possible count
    # of edges in a graph
    Max = ((N - 1) * (N - 2)) // 2
     
    # Base case
    if (K > Max):
        print(-1)
        return
     
    # Stores edges of a graph
    ans = []
 
    # Connect all vertices of pairs (i, j)
    for i in range(1, N):
        for j in range(i + 1, N + 1):
            ans.append([i, j])
             
    # Print first ((N - 1) + Max - K)  elements
    # of edges[]
    for i in range(0, (N - 1) + Max - K):
        print(ans[i][0], ans[i][1], sep = " ")
 
# Driver code
if __name__ == '__main__':
     
    N = 5
    K = 3
     
    constGraphWithCon(N, K)
 
# This code is contributed by MuskanKalra1

C#

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
 
public class GFG{
     
class pair
{ 
    public int first, second; 
     
    public pair(int first, int second)  
    { 
        this.first = first; 
        this.second = second; 
    }    
} 
 
// Function to construct the simple and connected
// graph such that the distance between 
// exactly K pairs of vertices is 2
static void constGraphWithCon(int N, int K)
{
     
    // Stores maximum possible count
    // of edges in a graph
    int Max = ((N - 1) * (N - 2)) / 2;
 
    // Base Case
    if (K > Max)
    {
        Console.Write(-1 + "\n");
        return;
    }
 
    // Stores edges of a graph
    List<pair> ans = new List<pair>();
 
    // Connect all vertices of pairs (i, j)
    for(int i = 1; i < N; i++) 
    {
        for(int j = i + 1; j <= N; j++) 
        {
            ans.Add(new pair(i, j));
        }
    }
 
    // Print first ((N - 1) + Max - K)  elements
    // of edges[]
    for(int i = 0; i < (N - 1) + Max - K; i++) 
    {
        Console.Write(ans[i].first + " " + 
                         ans[i].second +"\n");
    }
}
 
// Driver Code
public static void Main(String[] args)
{
    int N = 5, K = 3;
    constGraphWithCon(N, K);
}
}
 
// This code is contributed by 29AjayKumar

Javascript

<script>
 
// Javascript program to implement
// the above approach
     
class pair
{ 
    constructor(first, second)
    {
        this[0] = first;
        this[1] = second;
    }
} 
 
// Function to construct the simple and connected
// graph such that the distance between 
// exactly K pairs of vertices is 2
function constGraphWithCon(N, K)
{
     
    // Stores maximum possible count
    // of edges in a graph
    var Max = ((N - 1) * (N - 2)) / 2;
 
    // Base Case
    if (K > Max)
    {
        document.write(-1 + "<br>");
        return;
    }
 
    // Stores edges of a graph
    var ans = [];
 
    // Connect all vertices of pairs (i, j)
    for(var i = 1; i < N; i++) 
    {
        for(var j = i + 1; j <= N; j++) 
        {
            ans.push([i, j]);
        }
    }
 
    // Print first ((N - 1) + Max - K)  elements
    // of edges[]
    for(var i = 0; i < (N - 1) + Max - K; i++) 
    {
        document.write(ans[i][0] + " " + 
                         ans[i][1] +"<br>");
    }
}
 
// Driver Code
var N = 5, K = 3;
constGraphWithCon(N, K);
 
</script>

Output:

Time Complexity: O(N²)
Auxiliary Space: O(N²)

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!