Related Articles

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

• Last Updated : 18 Aug, 2021

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

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up