A Peterson Graph Problem
The following graph G is called a Petersen graph and its vertices have been numbered from 0 to 9. Some letters have also been assigned to vertices of G, as can be seen from the following picture:
Let’s consider a walk W in graph G, which consists of L vertices W1, W2, …, WL. A string S of L letters ‘A’ – ‘E’ is realized by walking W if the sequence of letters written along W is equal to S. Vertices can be visited multiple times while walking along W.
For example, S = ‘ABBECCD’ is realized by W = (0, 1, 6, 9, 7, 2, 3). Determine whether there is a walk W that realizes a given string S in graph G and if so then find the lexicographically least such walk. The only line of input contains one string S. If there is no walk W which realizes S, then output -1 otherwise, you should output the least lexicographical walk W which realizes S.
Examples:
Input : s = 'ABB' Output: 016 Explanation: As we can see in the graph the path from ABB is 016. Input : s = 'AABE' Output :-1 Explanation: As there is no path that exists, hence output is -1.
Algorithm for a Peterson Graph Problem:
petersonGraphWalk(S, v):
begin
res := starting vertex
for each character c in S except the first one, do
if there is an edge between v and c in outer graph, then
v := c
else if there is an edge between v and c+5 in inner graph, then
v := c + 5
else
return false
end if
put v into res
done
return true
end
Below is the implementation of the above algorithm:
C++
// C++ program to find the // path in Peterson graph #include <bits/stdc++.h> using namespace std; // path to be checked char S[100005]; // adjacency matrix. bool adj[10][10]; // resulted path - way char result[100005]; // we are applying breadth first search // here bool findthepath( char * S, int v) { result[0] = v + '0' ; for ( int i = 1; S[i]; i++) { // first traverse the outer graph if (adj[v][S[i] - 'A' ] || adj[S[i] - 'A' ][v]) { v = S[i] - 'A' ; } // then traverse the inner graph else if (adj[v][S[i] - 'A' + 5] || adj[S[i] - 'A' + 5][v]) { v = S[i] - 'A' + 5; } // if the condition failed to satisfy // return false else return false ; result[i] = v + '0' ; } return true ; } // driver code int main() { // here we have used adjacency matrix to make // connections between the connected nodes adj[0][1] = adj[1][2] = adj[2][3] = adj[3][4] = adj[4][0] = adj[0][5] = adj[1][6] = adj[2][7] = adj[3][8] = adj[4][9] = adj[5][7] = adj[7][9] = adj[9][6] = adj[6][8] = adj[8][5] = true ; // path to be checked char S[] = "ABB" ; if (findthepath(S, S[0] - 'A' ) || findthepath(S, S[0] - 'A' + 5)) { cout << result; } else { cout << "-1" ; } return 0; } |
Java
// Java program to find the // path in Peterson graph class GFG { // path to be checked static char []S = new char [ 100005 ]; // adjacency matrix. static boolean [][]adj = new boolean [ 10 ][ 10 ]; // resulted path - way static char [] result = new char [ 100005 ]; // we are applying breadth first search // here static boolean findthepath( char [] S, int v) { result[ 0 ] = ( char ) (v + '0' ); for ( int i = 1 ; i<( int )S.length; i++) { // first traverse the outer graph if (adj[v][S[i] - 'A' ] || adj[S[i] - 'A' ][v]) { v = S[i] - 'A' ; } // then traverse the inner graph else if (adj[v][S[i] - 'A' + 5 ] || adj[S[i] - 'A' + 5 ][v]) { v = S[i] - 'A' + 5 ; } // if the condition failed to satisfy // return false else return false ; result[i] = ( char ) (v + '0' ); } return true ; } // Driver code public static void main(String[] args) { // here we have used adjacency matrix to make // connections between the connected nodes adj[ 0 ][ 1 ] = adj[ 1 ][ 2 ] = adj[ 2 ][ 3 ] = adj[ 3 ][ 4 ] = adj[ 4 ][ 0 ] = adj[ 0 ][ 5 ] = adj[ 1 ][ 6 ] = adj[ 2 ][ 7 ] = adj[ 3 ][ 8 ] = adj[ 4 ][ 9 ] = adj[ 5 ][ 7 ] = adj[ 7 ][ 9 ] = adj[ 9 ][ 6 ] = adj[ 6 ][ 8 ] = adj[ 8 ][ 5 ] = true ; // path to be checked char S[] = "ABB" .toCharArray(); if (findthepath(S, S[ 0 ] - 'A' ) || findthepath(S, S[ 0 ] - 'A' + 5 )) { System.out.print(result); } else { System.out.print( "-1" ); } } } // This code is contributed by Rajput-Ji |
Python3
# Python3 program to find the # path in Peterson graph # path to be checked # adjacency matrix. adj = [[ False for i in range ( 10 )] for j in range ( 10 )] # resulted path - way result = [ 0 ] # we are applying breadth first search # here def findthepath(S, v): result[ 0 ] = v for i in range ( 1 , len (S)): # first traverse the outer graph if (adj[v][ ord (S[i]) - ord ( 'A' )] or adj[ ord (S[i]) - ord ( 'A' )][v]): v = ord (S[i]) - ord ( 'A' ) # then traverse the inner graph else if (adj[v][ ord (S[i]) - ord ( 'A' ) + 5 ] or adj[ ord (S[i]) - ord ( 'A' ) + 5 ][v]): v = ord (S[i]) - ord ( 'A' ) + 5 # if the condition failed to satisfy # return false else : return False result.append(v) return True # driver code # here we have used adjacency matrix to make # connections between the connected nodes adj[ 0 ][ 1 ] = adj[ 1 ][ 2 ] = adj[ 2 ][ 3 ] = \ adj[ 3 ][ 4 ] = adj[ 4 ][ 0 ] = adj[ 0 ][ 5 ] = \ adj[ 1 ][ 6 ] = adj[ 2 ][ 7 ] = adj[ 3 ][ 8 ] = \ adj[ 4 ][ 9 ] = adj[ 5 ][ 7 ] = adj[ 7 ][ 9 ] = \ adj[ 9 ][ 6 ] = adj[ 6 ][ 8 ] = adj[ 8 ][ 5 ] = True # path to be checked S = "ABB" S = list (S) if (findthepath(S, ord (S[ 0 ]) - ord ( 'A' )) or findthepath(S, ord (S[ 0 ]) - ord ( 'A' ) + 5 )): print ( * result, sep = "") else : print ( "-1" ) # This code is contributed by SHUBHAMSINGH10 |
C#
// C# program to find the // path in Peterson graph using System; public class GFG { // adjacency matrix. static bool [,]adj = new bool [10, 10]; // resulted path - way static char [] result = new char [100005]; // we are applying breadth first search // here static bool findthepath(String S, int v) { result[0] = ( char ) (v + '0' ); for ( int i = 1; i < S.Length; i++) { // first traverse the outer graph if (adj[v,S[i] - 'A' ] || adj[S[i] - 'A' ,v]) { v = S[i] - 'A' ; } // then traverse the inner graph else if (adj[v,S[i] - 'A' + 5] || adj[S[i] - 'A' + 5,v]) { v = S[i] - 'A' + 5; } // if the condition failed to satisfy // return false else return false ; result[i] = ( char ) (v + '0' ); } return true ; } // Driver code public static void Main(String[] args) { // here we have used adjacency matrix to make // connections between the connected nodes adj[0,1] = adj[1,2] = adj[2,3] = adj[3,4] = adj[4,0] = adj[0,5] = adj[1,6] = adj[2,7] = adj[3,8] = adj[4,9] = adj[5,7] = adj[7,9] = adj[9,6] = adj[6,8] = adj[8,5] = true ; // path to be checked String S = "ABB" ; if (findthepath(S, S[0] - 'A' ) || findthepath(S, S[0] - 'A' + 5)) { Console.WriteLine(result); } else { Console.Write( "-1" ); } } } // This code is contributed by aashish1995 |
Javascript
<script> // Javascript program to find the // path in Peterson graph // adjacency matrix. let adj = new Array(10).fill(0).map(() => new Array(10).fill( false )) // resulted path - way let result = new Array(100005) // we are applying breadth first search // here function findthepath(S, v) { result[0] = v for (let i = 1; i < S.length; i++) { // first traverse the outer graph if (adj[v][S[i].charCodeAt(0) - 'A' .charCodeAt(0)] || adj[S[i].charCodeAt(0) - 'A' .charCodeAt(0)][v]) { v = S[i].charCodeAt(0) - 'A' .charCodeAt(0); } // then traverse the inner graph else if (adj[v][S[i].charCodeAt(0) - 'A' .charCodeAt(0) + 5] || adj[S[i].charCodeAt(0) - 'A' .charCodeAt(0) + 5][v]) { v = S[i].charCodeAt(0) - 'A' .charCodeAt(0) + 5; } // if the condition failed to satisfy // return false else return false ; result[i] = String.fromCharCode(v + '0' .charCodeAt(0)); } return true ; } // Driver code // here we have used adjacency matrix to make // connections between the connected nodes adj[0][1] = adj[1][2] = adj[2][3] = adj[3][4] = adj[4][0] = adj[0][5] = adj[1][6] = adj[2][7] = adj[3][8] = adj[4][9] = adj[5][7] = adj[7][9] = adj[9][6] = adj[6][8] = adj[8][5] = true ; // path to be checked let S = "ABB" ; S = S.split( "" ) if (findthepath(S, S[0].charCodeAt(0) - 'A' .charCodeAt(0)) || findthepath(S, S[0].charCodeAt(0) - 'A' .charCodeAt(0) + 5)) { document.write(result.join( "" )); } else { document.write( "-1" ); } // This code is contributed by Saurabh Jaiswal </script> |
016
Time complexity: O(N)
The time complexity of the above program is O(N), where N is the length of the given string S. We are applying Breadth First Search here, which runs in linear time.
Space complexity: O(N)
The space complexity of the above program is O(N), where N is the length of the given string S. We are using two auxiliary arrays – result[] and S[] to store the path and the given string, respectively. Both of them require linear space.