Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Minimize steps required to convert number N to M using arithmetic operators

  • Difficulty Level : Expert
  • Last Updated : 19 Oct, 2021

Given two integers N and M, the task is to find the sequence of the minimum number of operations required to convert the number N into M such that in each operation N can be added (N = N + N), subtracted as (N = N – N), multiplied as (N = N*N), or divided as (N = N/N). If it is not possible to convert N into M then print “-1”.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

Input: N = 7, M = 392
Output:
+, *, +
Explanation:
Following are the operations performed:

  1. Performing addition modifies the value of N as 7 + 7 = 14.
  2. Performing multiplication modifies the value of N as 14*14 = 196.
  3. Performing addition modifies the value of N as 196 + 196 = 392.

After the above sequence of moves as “+*+”, the value of N can be modified to M.



Input: N = 7, M = 9
Output: -1
Explanation: There are no possible sequence of operations to convert N to M.

Approach: The given problem can be solved using the following observations:

  • Subtraction operation will always result in 0 as N = N – N = 0. Similarly, division operation will always result in 1 as N = N / N = 1. Therefore, these cases can be handled easily.
  • For addition and multiplication, the problem can be solved using a Breadth-First Search Traversal by creating a state for each of the sequences of operations in increasing order of operation count.

The steps to solve the given problem are as follows:

  • Maintain a queue to store the BFS states where each state contains the current reachable integer N’ and a string representing the sequence of operations to reach N’ from N.
  • Initially, add a state {N, “”} representing N and sequence of operations as empty into the queue.
  • Add a state {1, “/”} for the division operation into the queue as well.
  • During the Breadth-First traversal, for each state, add two states where the 1st state will represent addition (N’ + N’) and the 2nd state will represent multiplication (N’ * N’).
  • Maintain an unordered map to check whether the current state is already visited during the BFS Traversal.
  • If the value of the current state is equal to M, then the sequence of operations obtained till M is the result. Otherwise, print “-1”.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the sequence of
// minimum number of operations needed
// to convert N into M using +, -, *, /
string changeNtoM(int N, int M)
{
    // Case where N and M are same
    if (N == M) {
        return " ";
    }
 
    // Case where M = 0
    if (M == 0) {
        return "-";
    }
 
    // Stores the BFS states in a queue
    queue<pair<int, string> > q;
 
    // Stores if current state is visited
    unordered_map<int, bool> visited;
 
    // Initial State
    q.push({ N, "" }), visited[N] = 1;
 
    // State where the first operation is /
    q.push({ 1, "/" }), visited[1] = 1;
 
    // Loop for the BFS traversal
    while (!q.empty()) {
        // Stores the current BFS state
        pair<int, string> cur = q.front();
        q.pop();
 
        // If the value of current state is
        // equal to M return the stored
        // sequence of operations
        if (cur.first == M) {
            // Return answer
            return cur.second;
        }
 
        // Adding 1st state representing the
        // addition operation(N' + N')
        if (!visited[cur.first + cur.first]
            && cur.first + cur.first <= M) {
 
            // Add state into queue and
            // mark the state visited
            q.push({ cur.first + cur.first,
                     cur.second + "+" });
            visited[cur.first + cur.first] = 1;
        }
 
        // Adding 2nd state representing the
        // multiplication operation(N' * N')
        if (!visited[cur.first * cur.first]
            && cur.first * cur.first <= M) {
 
            // Add state into queue and
            // mark the state visited
            q.push({ cur.first * cur.first,
                     cur.second + "*" });
            visited[cur.first * cur.first] = 1;
        }
    }
 
    // No valid sequence of operations exist
    return "-1";
}
 
// Driver Code
int main()
{
    int N = 7, M = 392;
    string result = changeNtoM(N, M);
 
    if (result == "-1")
        cout << result << endl;
    else
        cout << result.length() << endl
             << result;
 
    return 0;
}
Output: 
3
+*+

 

Time Complexity: O(min(2log2(M – N), M – N))
Auxiliary Space: O((M-N)* log2(M – N))




My Personal Notes arrow_drop_up
Recommended Articles
Page :