# Min steps to convert N-digit prime number into another by replacing a digit in each step

Given two N-digit prime numbers A and B, the task is to find the minimum number of steps taken to convert A to B. Condition for the conversion is that only 1 digit of the current prime number can be modified such that the new number formed is also a prime number. If no such conversion is possible, print -1.

Note: The range of N is [1, 5].
Examples:

Input: N = 4, A = 1033, B = 8179
Output: 6
Explanation: The steps of conversion are 1033 -> 1733 -> 3733 -> 3739 -> 3779 -> 8779 -> 8179. While changing numbers from 1033->1733, they differ by only one digit and the same happens for subsequent steps.

Input: N = 4, A = 1373, B = 8179
Output: 7

Input: N = 2, A = 11, B = 37
Output: 2
Explanation: The steps of conversion are 11 -> 17 -> 37

Approach: Using Breadth First Search Algorithm

1. Find all N digit prime numbers and make a graph with these numbers.
2. Consider each prime number as a node of a graph and create an edge from one node to another if they differ by a single digit.
3. Apply BFS traversal and find out the number of edges between A and B.
4. If no path exists, print -1.
5. Else print the no. of edges, which is the required solution.

Below is the implementation of the above approach.

 `// C++ program for the above problem ` ` `  `#include ` `using` `namespace` `std; ` ` `  `#define ll long long ` `#define mod 1000000007 ` `#define pb push_back ` `#define mod 1000000007 ` `#define vi vector ` ` `  `// adjacency list for numbers ` `// till 100001 ` `vi lis; ` `vi primes; ` ` `  `// visited array ` `int` `vis; ` ` `  `// to store distance of every ` `// vertex from A ` `int` `dis; ` ` `  `// function to check if number ` `// is a prime ` `bool` `isPrime(``int` `n) ` `{ ` `    ``for` `(``int` `i = 2; ` `         ``i * i <= n; i++) { ` `        ``if` `(n % i == 0) ` `            ``return` `false``; ` `    ``} ` `    ``return` `true``; ` `} ` ` `  `// function to check if numbers ` `// differ by only a single-digit ` `bool` `valid(``int` `a, ``int` `b) ` `{ ` `    ``int` `c = 0; ` `    ``while` `(a) { ` ` `  `        ``// check the last digit of ` `        ``// both numbers and increase ` `        ``// count if different ` `        ``if` `((a % 10) != (b % 10)) { ` `            ``c++; ` `        ``} ` `        ``a = a / 10; ` `        ``b = b / 10; ` `    ``} ` `    ``if` `(c == 1) { ` `        ``return` `true``; ` `    ``} ` `    ``else` `{ ` `        ``return` `false``; ` `    ``} ` `} ` ` `  `void` `makePrimes(``int` `N) ` `{ ` `    ``int` `i, j; ` `    ``int` `L = ``pow``(10, N - 1); ` `    ``int` `R = ``pow``(10, N) - 1; ` `    ``// generate all N digit primes ` `    ``for` `(``int` `i = L; i <= R; i++) { ` `        ``if` `(isPrime(i)) { ` `            ``primes.pb(i); ` `        ``} ` `    ``} ` `    ``for` `(i = 0; ` `         ``i < primes.size(); i++) { ` ` `  `        ``// for every prime number i ` `        ``// check if an edge ` `        ``// can be made. ` `        ``for` `(j = i + 1; ` `             ``j < primes.size(); j++) { ` `            ``int` `a = primes[i]; ` `            ``int` `b = primes[j]; ` ` `  `            ``// for every prime number ` `            ``// i check if an edge can ` `            ``// be made from i to j. ` `            ``if` `(valid(a, b)) { ` ` `  `                ``// if edge is possible then ` `                ``// insert in the adjacency ` `                ``// list ` `                ``lis[a].pb(b); ` `                ``lis[b].pb(a); ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// function to count distance ` `void` `bfs(``int` `src) ` `{ ` `    ``queue<``int``> q; ` `    ``q.push(src); ` `    ``vis[src] = 1; ` `    ``dis[src] = 0; ` `    ``while` `(!q.empty()) { ` `        ``int` `curr = q.front(); ` `        ``q.pop(); ` `        ``for` `(``int` `x : lis[curr]) { ` ` `  `            ``// if unvisited push onto queue ` `            ``// and mark visited as 1 and ` `            ``// add the distance of curr+1. ` `            ``if` `(vis[x] == 0) { ` `                ``vis[x] = 1; ` `                ``q.push(x); ` `                ``dis[x] = dis[curr] + 1; ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `N = 4; ` `    ``makePrimes(N); ` `    ``int` `A = 1033, B = 8179; ` ` `  `    ``// Call bfs traversal ` `    ``// with root as node A ` `    ``bfs(A); ` ` `  `    ``if` `(dis[B] == -1) ` `        ``// incdicates not possible ` `        ``cout << ``"-1"` `<< endl; ` `    ``else` `        ``cout << dis[B] << endl; ` ` `  `    ``return` `0; ` `} `

Output:

```6
```

Time Complexity: O(102N)
Auxillary Space Complexity: O(105) My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.