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++ 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 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 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# 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 |
<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.