Related Articles
Construct a graph using N vertices whose shortest distance between K pair of vertices is 2
• Last Updated : 05 Feb, 2021

Given two positive integers N and K, the task is to construct a simple and connected graph consisting of N vertices with 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 ``#include ``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 > 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 ` `// 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 conthe 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 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 conthe 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 ans = ``new` `List();` `    ``// 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`
Output:
```1 2
1 3
1 4
1 5
2 3
2 4
2 5```

Time Complexity: O(N2)
Auxiliary Space: O(N2)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up