# 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 walk 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 which 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.

We apply breadth first search to visit each vertex of the graph.

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

**Output:**

016

This article is contributed by **Sunidhi Chaudhary**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

## Recommended Posts:

- Applications of Minimum Spanning Tree Problem
- Breadth First Search or BFS for a Graph
- Find if there is a path between two vertices in a directed graph
- Depth First Search or DFS for a Graph
- Detect Cycle in a Directed Graph
- m Coloring Problem | Backtracking-5
- Disjoint Set (Or Union-Find) | Set 1 (Detect Cycle in an Undirected Graph)
- Graph and its representations
- Transitive closure of a graph
- Check whether a given graph is Bipartite or not
- Shortest Path in Directed Acyclic Graph
- Bridges in a graph
- Articulation Points (or Cut Vertices) in a Graph
- Biconnected graph
- Check if a graph is strongly connected | Set 1 (Kosaraju using DFS)
- Eulerian path and circuit for undirected graph
- Ford-Fulkerson Algorithm for Maximum Flow Problem
- Stable Marriage Problem
- Longest Path in a Directed Acyclic Graph
- Detect cycle in an undirected graph