Skip to content
Related Articles
Construct a graph which does not contain any pair of adjacent nodes with same value
• Last Updated : 04 Nov, 2020

Given an array arr[] consisting of N characters, the task is to generate a graph of N nodes and (N – 1) Edges such that each node i is associated with character arr[i] and no two adjacent nodes have the same value. If it is possible to make such a graph, then print “Possible” with the pairs of edges. Otherwise, print “Not Possible”.

Examples:

Input: N = 5, arr[] = {‘a’, ‘b’, ‘a’, ‘b’, ‘c’}
Output: “Possible”
1 – 2
1 – 4
1 – 5
5 – 3
Explanation:
One possible graph that can be constructed to satisfy the given conditions is as follows: Input: N = 3, arr[] = {‘z’, ‘z’, ‘z’}
Output: “Not Possible”

Approach: To construct a graph such that no adjacent node has the same value, the idea is to check if at least two unique values exist or not. If found to be true, such a graph can be constructed. Follow the steps below:

• Check for all the values present at each node and if all the node values are the same, it’s not possible to construct the graph.
• If any two values are different, there will always be a way to construct such a graph.
• Now, select any two unique values, connect the occurrence of all the other values to 1st unique value except the value itself.
• Store indices of occurrence of 1st unique value except for its first occurrence and connect all those indices to the second unique value.
• This way there will always be a way to construct such a graph with (N – 1) edges.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function that prints the edges of``// the generated graph``void` `printConnections(``    ``vector > store,``    ``vector<``int``> ind, ``int` `ind1)``{``    ``// First print connections``    ``// stored in store[]``    ``for` `(``auto` `pr : store) {``        ``cout << pr.first << ``" "``             ``<< pr.second << ``"\n"``;``    ``}` `    ``// Check if there is more than one``    ``// occurrence of 1st unique element``    ``if` `(ind.size() != 0) {` `        ``// Print all other occurrence``        ``// of 1st unique element with``        ``// second unique element``        ``for` `(``auto` `x : ind) {``            ``cout << ind1 << ``" "``                 ``<< x + 1 << ``"\n"``;``        ``}``    ``}``}` `// Function to construct the graph such``// that the every adjacent nodes have``// different value``void` `constructGraph(``char` `arr[], ``int` `N)``{``    ``vector<``int``> ind;` `    ``// Stores pair of edges formed``    ``vector > store;` `    ``// Stores first unique occurrence``    ``char` `x = arr;` `    ``int` `count = 0, ind1;` `    ``for` `(``int` `i = 1; i <= N - 1; ++i) {` `        ``// Check for the second``        ``// unique occurrence``        ``if` `(arr[i] != x) {` `            ``// Store indices of 2nd``            ``// unique occurrence``            ``ind1 = i + 1;` `            ``// To check if arr has only``            ``// 1 unique element or not``            ``count++;` `            ``// Store the connections of all``            ``// unique elements with Node 1``            ``store.push_back({ 1, i + 1 });``        ``}` `        ``// If value at node (i + 1) is``        ``// same as value at Node 1 then``        ``// store its indices``        ``else` `{``            ``ind.push_back(i);``        ``}``    ``}` `    ``// If count is zero then it's not``    ``// possible to construct the graph``    ``if` `(count == 0) {``        ``cout << ``"Not Possible"``;``    ``}` `    ``// If more than 1 unique``    ``// element is present``    ``else` `{``        ``cout << ``"Possible"``             ``<< ``"\n"``;` `        ``// Print the edges``        ``printConnections(store, ind, ind1);``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 5;` `    ``// Given array having node values``    ``char` `arr[] = { ``'a'``, ``'b'``, ``'a'``, ``'b'``, ``'c'` `};` `    ``// Function Call``    ``constructGraph(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for 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 that prints the edges of``// the generated graph``static` `void` `printConnections(Vector store,``                             ``Vector ind,``                             ``int` `ind1)``{``  ``// First print connections``  ``// stored in store[]``  ``for` `(pair pr : store)``  ``{``    ``System.out.print(pr.first + ``" "` `+``                     ``pr.second + ``"\n"``);``  ``}` `  ``// Check if there is more than one``  ``// occurrence of 1st unique element``  ``if` `(ind.size() != ``0``)``  ``{``    ``// Print all other occurrence``    ``// of 1st unique element with``    ``// second unique element``    ``for` `(``int` `x : ind)``    ``{``      ``System.out.print(ind1 + ``" "` `+``                      ``(x + ``1``) + ``"\n"``);``    ``}``  ``}``}` `// Function to conthe graph such``// that the every adjacent nodes have``// different value``static` `void` `constructGraph(``char` `arr[],``                           ``int` `N)``{``  ``Vector ind = ``new` `Vector<>();` `  ``// Stores pair of edges formed``  ``Vector store = ``new` `Vector<>();` `  ``// Stores first unique occurrence``  ``char` `x = arr[``0``];` `  ``int` `count = ``0``;``  ``int` `ind1=-``1``;` `  ``for` `(``int` `i = ``1``; i <= N - ``1``; ++i)``  ``{``    ``// Check for the second``    ``// unique occurrence``    ``if` `(arr[i] != x)``    ``{``      ``// Store indices of 2nd``      ``// unique occurrence``      ``ind1 = i + ``1``;` `      ``// To check if arr has only``      ``// 1 unique element or not``      ``count++;` `      ``// Store the connections of all``      ``// unique elements with Node 1``      ``store.add(``new` `pair(``1``, i + ``1` `));``    ``}` `    ``// If value at node (i + 1) is``    ``// same as value at Node 1 then``    ``// store its indices``    ``else``    ``{``      ``ind.add(i);``    ``}``  ``}` `  ``// If count is zero then it's not``  ``// possible to conthe graph``  ``if` `(count == ``0``)``  ``{``    ``System.out.print(``"Not Possible"``);``  ``}` `  ``// If more than 1 unique``  ``// element is present``  ``else``  ``{``    ``System.out.print(``"Possible"` `+``                     ``"\n"``);` `    ``// Print the edges``    ``printConnections(store,``                     ``ind, ind1);``  ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``int` `N = ``5``;` `  ``// Given array having``  ``// node values``  ``char` `arr[] = {``'a'``, ``'b'``,``                ``'a'``, ``'b'``, ``'c'``};` `  ``// Function Call``  ``constructGraph(arr, N);``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program for the above approach` `# Function that prints the edges of``# the generated graph``def` `printConnections(store, ind, ind1):``    ` `    ``# First print connections``    ``# stored in store[]``    ``for` `pr ``in` `store:``        ``print``(pr[``0``], pr[``1``])` `    ``# Check if there is more than one``    ``# occurrence of 1st unique element``    ``if` `(``len``(ind) !``=` `0``):``        ` `        ``# Print all other occurrence``        ``# of 1st unique element with``        ``# second unique element``        ``for` `x ``in` `ind:``            ``print``(ind1, x ``+` `1``)``            ` `# Function to construct the graph such``# that the every adjacent nodes have``# different value``def` `constructGraph(arr, N):``    ` `    ``ind ``=` `[]` `    ``# Stores pair of edges formed``    ``store ``=` `[]` `    ``# Stores first unique occurrence``    ``x ``=` `arr[``0``]`` ` `    ``count, ind1 ``=` `0``, ``0` `    ``for` `i ``in` `range``(``1``, N):``        ` `        ``# Check for the second``        ``# unique occurrence``        ``if` `(arr[i] !``=` `x):``            ` `            ``# Store indices of 2nd``            ``# unique occurrence``            ``ind1 ``=` `i ``+` `1` `            ``# To check if arr has only``            ``# 1 unique element or not``            ``count ``+``=` `1` `            ``# Store the connections of all``            ``# unique elements with Node 1``            ``store.append([``1``, i ``+` `1``])` `            ``# If value at node (i + 1) is``            ``# same as value at Node 1 then``            ``# store its indices``        ``else``:``            ``ind.append(i)` `    ``# If count is zero then it's not``    ``# possible to construct the graph``    ``if` `count ``=``=` `0``:``        ``print``(``"Not Possible"``)``    ``else``:``        ` `        ``# If more than 1 unique``        ``# element is present``        ``print``(``"Possible"``)` `        ``# Print the edges``        ``printConnections(store, ind, ind1)``            ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``N ``=` `5` `    ``# Given array having node values``    ``arr ``=` `[ ``'a'``, ``'b'``, ``'a'``, ``'b'``, ``'c'` `]` `    ``# Function Call``    ``constructGraph(arr, N)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the``// above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG{``    ` `public` `class` `pair``{``  ``public` `int` `first,``  ``second;``  ``public` `pair(``int` `first,``              ``int` `second) ``  ``{``    ``this``.first = first;``    ``this``.second = second;``  ``}   ``}` `// Function that prints the edges of``// the generated graph``static` `void` `printConnections(List store,``                             ``List<``int``> ind,``                             ``int` `ind1)``{``  ``// First print connections``  ``// stored in store[]``  ``foreach` `(pair pr ``in` `store)``  ``{``    ``Console.Write(pr.first + ``" "` `+``                  ``pr.second + ``"\n"``);``  ``}` `  ``// Check if there is more than one``  ``// occurrence of 1st unique element``  ``if` `(ind.Count != 0)``  ``{``    ``// Print all other occurrence``    ``// of 1st unique element with``    ``// second unique element``    ``foreach` `(``int` `x ``in` `ind)``    ``{``      ``Console.Write(ind1 + ``" "` `+``                   ``(x + 1) + ``"\n"``);``    ``}``  ``}``}` `// Function to conthe graph such``// that the every adjacent nodes have``// different value``static` `void` `constructGraph(``char` `[]arr,``                           ``int` `N)``{``  ``List<``int``> ind = ``new` `List<``int``>();` `  ``// Stores pair of edges formed``  ``List store = ``new` `List();` `  ``// Stores first unique occurrence``  ``char` `x = arr;` `  ``int` `count = 0;``  ``int` `ind1=-1;` `  ``for` `(``int` `i = 1; i <= N - 1; ++i)``  ``{``    ``// Check for the second``    ``// unique occurrence``    ``if` `(arr[i] != x)``    ``{``      ``// Store indices of 2nd``      ``// unique occurrence``      ``ind1 = i + 1;` `      ``// To check if arr has only``      ``// 1 unique element or not``      ``count++;` `      ``// Store the connections of all``      ``// unique elements with Node 1``      ``store.Add(``new` `pair(1, i + 1 ));``    ``}` `    ``// If value at node (i + 1) is``    ``// same as value at Node 1 then``    ``// store its indices``    ``else``    ``{``      ``ind.Add(i);``    ``}``  ``}` `  ``// If count is zero then it's not``  ``// possible to conthe graph``  ``if` `(count == 0)``  ``{``    ``Console.Write(``"Not Possible"``);``  ``}` `  ``// If more than 1 unique``  ``// element is present``  ``else``  ``{``    ``Console.Write(``"Possible"` `+``                     ``"\n"``);` `    ``// Print the edges``    ``printConnections(store,``                     ``ind, ind1);``  ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ``int` `N = 5;` `  ``// Given array having``  ``// node values``  ``char` `[]arr = {``'a'``, ``'b'``,``                ``'a'``, ``'b'``, ``'c'``};` `  ``// Function Call``  ``constructGraph(arr, N);``}``}` `// This code is contributed by gauravrajput1`
Output:
```Possible
1 2
1 4
1 5
5 3

```

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

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 industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up