Open In App
Related Articles

A Peterson Graph Problem

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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. 
 

Example of a Petersen Graph

Example of a Petersen Graph


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>

                    

Output
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.

 



Last Updated : 20 Feb, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads