# Find if possible to visit every nodes in given Graph exactly once based on given conditions

• Last Updated : 13 Sep, 2021

Given a Graph having N+1 nodes with 2*N-1 edges and a boolean array arr[ ], the task is to find if one can visit every nodes exactly once and print any one possible path. It’s also known that N-1 edges go i-th to (i+1)-th node and rest edges go i-th to (n+1)-th node if arr[i] is 0 otherwise (n+1)-th to i-th.

Examples:

Input: N = 3, arr = {0, 1, 0}
Output: [1, 2, 3, 4]
Explanation:
from the given data, the edges will:
1 -> 2
2 -> 3
1 -> 4
4 -> 2
3 -> 4

Therefore, one can follow the path: 1 -> 2 -> 3 -> 4

Input: N = 4, arr = {0, 1, 1, 1}
Output: [1, 4, 2, 3]

Approach: This problem can be solved using greedy approach with some observations. The observations are given below:

• If arr[1] is 1, then follow the path [N+1 -> 1 -> 2……..-> N].
• If arr[N] is 0, then follow the path [1 -> 2 ->……….-> N -> N+1].
• If arr[1] is 0 and arr[N] is 1, there must exists an integer i (1 â‰¤ i< N) where arr[i] =0 and arr[i+1] = 1, then the path [1 -> 2 -> â‹Ż -> i -> N+1 -> i+1 -> i+2 -> â‹ŻN] is valid.
• Previous step proves that there always exists an Hamiltonian path in this graph.

Below is the implementation for the above approach:

## C++

 `// C++ program for above approach.``#include ``using` `namespace` `std;` `// Function to find print path``void` `findpath(``int` `N, ``int` `a[])``{` `    ``// If a[0] is 1``    ``if` `(a[0]) {` `        ``// Printing path``        ``cout <<``" "``<< N + 1;``        ``for` `(``int` `i = 1; i <= N; i++)``            ``cout <<``" "` `<< i;``        ``return``;``    ``}` `    ``// Seeking for a[i] = 0 and a[i+1] = 1``    ``for` `(``int` `i = 0; i < N - 1; i++) {``        ``if` `(!a[i] && a[i + 1]) {` `            ``// Printing path``            ``for` `(``int` `j = 1; j <= i; j++)``                ``cout <<``" "``<< j;``            ``cout <<``" "``<< N + 1;``            ``for` `(``int` `j = i + 1; j <= N; j++)``                ``cout <<``" "``<< j;``            ``return``;``        ``}``    ``}` `    ``// If a[N-1] = 0``    ``for` `(``int` `i = 1; i <= N; i++)``        ``cout <<``" "``<< i;``    ``cout <<``" "``<< N + 1;``}` `// Driver Code``int` `main()``{` `    ``// Given Input``    ``int` `N = 3, arr[] = { 0, 1, 0 };` `    ``// Function Call``    ``findpath(N, arr);``}` `// This code is contributed by shivanisinghss2110`

## C

 `// C++ program for above approach.``#include ``using` `namespace` `std;` `// Function to find print path``void` `findpath(``int` `N, ``int` `a[])``{` `    ``// If a[0] is 1``    ``if` `(a[0]) {` `        ``// Printing path``        ``printf``(``"%d "``, N + 1);``        ``for` `(``int` `i = 1; i <= N; i++)``            ``printf``(``"%d "``, i);``        ``return``;``    ``}` `    ``// Seeking for a[i] = 0 and a[i+1] = 1``    ``for` `(``int` `i = 0; i < N - 1; i++) {``        ``if` `(!a[i] && a[i + 1]) {` `            ``// Printing path``            ``for` `(``int` `j = 1; j <= i; j++)``                ``printf``(``"%d "``, j);``            ``printf``(``"%d "``, N + 1);``            ``for` `(``int` `j = i + 1; j <= N; j++)``                ``printf``(``"%d "``, j);``            ``return``;``        ``}``    ``}` `    ``// If a[N-1] = 0``    ``for` `(``int` `i = 1; i <= N; i++)``        ``printf``(``"%d "``, i);``    ``printf``(``"%d "``, N + 1);``}` `// Driver Code``int` `main()``{` `    ``// Given Input``    ``int` `N = 3, arr[] = { 0, 1, 0 };` `    ``// Function Call``    ``findpath(N, arr);``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``class` `GFG {` `    ``// Function to find print path``    ``static` `void` `findpath(``int` `N, ``int` `a[])``    ``{` `        ``// If a[0] is 1``        ``if` `(a[``0``] == ``1``) {` `            ``// Printing path``            ``System.out.print((N + ``1``) + ``" "``);``            ``for` `(``int` `i = ``1``; i <= N; i++)``                ``System.out.print((i) + ``" "``);``            ``return``;``        ``}` `        ``// Seeking for a[i] = 0 and a[i+1] = 1``        ``for` `(``int` `i = ``0``; i < N - ``1``; i++) {``            ``if` `(a[i] == ``0` `&& a[i + ``1``] == ``1``) {` `                ``// Printing path``                ``for` `(``int` `j = ``1``; j <= i; j++)``                    ``System.out.print((j) + ``" "``);``                ``System.out.print((N + ``1``) + ``" "``);``                ``for` `(``int` `j = i + ``1``; j <= N; j++)``                    ``System.out.print((j) + ``" "``);``                ``return``;``            ``}``        ``}` `        ``// If a[N-1] = 0``        ``for` `(``int` `i = ``1``; i <= N; i++)``            ``System.out.print((i) + ``" "``);``        ``System.out.print((N + ``1``) + ``" "``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``3``, arr[] = { ``0``, ``1``, ``0` `};` `        ``// Function Call``        ``findpath(N, arr);``    ``}``}` `// This code is contributed by dwivediyash`

## Python3

 `# Python 3 program for above approach.` `# Function to find print path``def` `findpath(N, a):``    ``# If a[0] is 1``    ``if` `(a[``0``]):``        ``# Printing path``        ``print``(N ``+` `1``)``        ``for` `i ``in` `range``(``1``,N``+``1``,``1``):``            ``print``(i,end ``=` `" "``)``        ``return` `    ``# Seeking for a[i] = 0 and a[i+1] = 1``    ``for` `i ``in` `range``(N ``-` `1``):``        ``if` `(a[i]``=``=``0` `and` `a[i ``+` `1``]):``          ` `            ``# Printing path``            ``for` `j ``in` `range``(``1``,i``+``1``,``1``):``                ``print``(j,end ``=` `" "``)``            ``print``(N ``+` `1``,end ``=` `" "``);``            ``for` `j ``in` `range``(i ``+` `1``,N``+``1``,``1``):``                ``print``(j,end ``=` `" "``)``            ``return` `    ``# If a[N-1] = 0``    ``for` `i ``in` `range``(``1``,N``+``1``,``1``):``        ``print``(i,end ``=` `" "``)``    ``print``(N ``+` `1``,end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``# Given Input``    ``N ``=` `3``    ``arr ``=` `[``0``, ``1``, ``0``]` `    ``# Function Call``    ``findpath(N, arr)``    ` `    ``# This code is contributed by ipg2016107.`

## C#

 `// C# program for above approach.``using` `System;` `class` `GFG{` `// Function to find print path``static` `void` `findpath(``int` `N, ``int` `[]a)``{` `    ``// If a[0] is 1``    ``if` `(a[0]!=0) {` `        ``// Printing path``        ``Console.Write(N + 1);``        ``for` `(``int` `i = 1; i <= N; i++)``            ``Console.Write(i+ ``" "``);``        ``return``;``    ``}` `    ``// Seeking for a[i] = 0 and a[i+1] = 1``    ``for` `(``int` `i = 0; i < N - 1; i++) {``        ``if` `(a[i]==0 && a[i + 1] !=0) {` `            ``// Printing path``            ``for` `(``int` `j = 1; j <= i; j++)``                ``Console.Write(j+``" "``);``            ``Console.Write(N + 1 + ``" "``);``            ``for` `(``int` `j = i + 1; j <= N; j++)``                ``Console.Write(j + ``" "``);``            ``return``;``        ``}``    ``}` `    ``// If a[N-1] = 0``    ``for` `(``int` `i = 1; i <= N; i++)``        ``Console.Write(i+``" "``);``    ``Console.Write(N + 1 + ``" "``);``}` `// Driver Code``public` `static` `void` `Main()``{` `    ``// Given Input``    ``int` `N = 3;``    ``int` `[]arr = { 0, 1, 0 };` `    ``// Function Call``    ``findpath(N, arr);``}``}` `// This code is contributed by SURENDRA_GANGWAR.`

## Javascript

 ``

Output:

`4 1 2 3`

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

My Personal Notes arrow_drop_up