# Minimum number of operation required to convert number x into y

Given a initial number x and two operations which are given below:

1. Multiply number by 2.
2. Subtract 1 from the number.

The task is to find out minimum number of operation required to convert number x into y using only above two operations. We can apply these operations any number of times.

Constraints:
1 <= x, y <= 10000

Example:

```Input : x = 4, y = 7
Output : 2
We can transform x into y using following
two operations.
1. 4*2  = 8
2. 8-1  = 7

Input  : x = 2, y = 5
Output : 4
We can transform x into y using following
four operations.
1. 2*2  = 4
2. 4-1   = 3
3. 3*2  = 6
4. 6-1   = 5
Note that other sequences of two operations
would take more operations.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea is to use BFS for this. We run a BFS and create nodes by multiplying with 2 and subtracting by 1, thus we can obtain all possible numbers reachable from starting number.
Important Points :
1) When we subtract 1 from a number and if it becomes < 0 i.e. Negative then there is no reason to create next node from it (As per input constraints, numbers x and y are positive).
2) Also, if we have already created a number then there is no reason to create it again. i.e. we maintain a visited array.

Below is C++ implementation of above idea.

```// C++ program to find minimum number of steps needed
// to covert a number x into y with two operations
// allowed : (1) multiplication with 2 (2) subtraction
// with 1.
#include<bits/stdc++.h>
using namespace std;

// A node of BFS traversal
struct node
{
int val;
int level;
};

// Returns minimum number of operations
// needed to covert x into y using BFS
int minOperations(int x, int y)
{
// To keep track of visited numbers
// in BFS.
set<int> visit;

// Create a queue and enqueue x into it.
queue<node> q;
node n = {x, 0};
q.push(n);

// Do BFS starting from x
while (!q.empty())
{
// Remove an item from queue
node t = q.front();
q.pop();

// If the removed item is target
// number y, return its level
if (t.val == y)
return t.level;

// Mark dequeued number as visited
visit.insert(t.val);

// If we can reach y in one more step
if (t.val*2 == y || t.val-1 == y)
return t.level+1;

// Insert children of t if not visited
if (visit.find(t.val*2) == visit.end())
{
n.val = t.val*2;
n.level = t.level+1;
q.push(n);
}
if (t.val-1>=0 && visit.find(t.val-1) == visit.end())
{
n.val = t.val-1;
n.level = t.level+1;
q.push(n);
}
}
}

// Driver code
int main()
{
int x = 4, y = 7;
cout << minOperations(x, y);
return 0;
}
```

Output :

`2`

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

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
2.8 Average Difficulty : 2.8/5.0
Based on 8 vote(s)