Dividing an even number in the most efficient way - c++

Question

I need a program in c++ that gets a number:
LOOP:
If that number is even divide it by 2 (n=n/2)
If it's not even you can do one of this operations:
n+1
n-1
LOOP ENDS
The program should do this until n=1.
But it should do this in the most efficient and fastest way and the only hint I have is that I can use DP approach.
And the output should be numbers of operations used to calculate that number.
For example:
15->16->8->4->2->1 output:5
35->36->18->9->8->4->2->1 output:7
here's the code I wrote but it's not completed yet and it's wrong since I couldn't figure out how should I add or subtract in each step:
#include "stdafx.h"
#include <iostream>
using namespace std;
int main()
{
int n;
int h=0;
int i=0;
cout<<"Enter A Number:";
cin >> n;
int r=n;
int q=n;
cout<<r;
L1: while ( r % 2 == 0)
{
for(int m=0;r>1 && m==0 ;)
{ r=r / 2;h++;
m=r%2;
cout<<" => "<<r;
}}
while(r%2==1 && r>1)
{r=r-1;cout<<" => "<<r;h++;
goto L1;}
cout<<endl;
//**********************
cout<<q;
L2: while ( q % 2 == 0)
{
for(int m=0;q>1 && m==0 ;)
{ q=q / 2;i++;
m=q%2;
cout<<" => "<<q;
}}
while(q%2==1 && q>1)
{q=q+1;cout<<" => "<<q;i++;
goto L2;}
cout<<endl<<"First:"<<h<<endl<<"Second:"<<i<<endl;
system("pause");
}

Answer 1

If you want to solve it using DP:
I would state this: for each possible value 1 <=i < N find the optimal number of steps.
We use a priority queue to do this where we extract at each iteration the highest number. This is much more efficient than a vector of length N because a lot of states are unreachable (e.g. i=10 in the 15 example).
Consider that the starting state is (15,0): 15 with zero moves.
From this you create two new states (8,2) and (7,2) because for each you need two steps(add/subtract + division).
Extracting (8,2): (7,2)(4,3)
Extracting (7,2): (4,3)(3,4) Here comes DP! (7,2) would create the state (4,4) but you mantain in the queue only the minimum number of steps for the same state.
Extracting (4,3): (2,4)(3,4)
extracting(3,4): (2,4)(1,6)
Extracting (2,4): (1,5)
And that is it the solution is 5 steps.
Steps for 35:
(35,0) --- >(18,2) (17,2) -----> (17,2) (9,3) ----->
(9,3)(8,4) ----> (8,4)(5,5)(4,5) ----> (5,5)(4,5) ----->
(4,5)(3,7)(2,7)----> (3,7)(2,6) -----> (2,6)(1,9) ----> (1,7)
Solution: 7 steps.

Answer 2

Look if that helps you.
// Example program
#include <iostream>
#include <string>
int f (int n)
{
int iterations = 0;
while (n > 1)
{
if (n % 2 != 0)
{
std::cout << n << "->";
++n;
if (n & (n - 1))
n -= 2;
++iterations;
}
std::cout << n << "->";
n >>= 1;
++iterations;
}
std::cout << n << "->";
return iterations;
}
int main()
{
std::cout << f(15) << std::endl;
std::cout << f(41) << std::endl;
std::cout << f(43) << std::endl;
}

Answer 3

For use of dynamic programming, you should make recursion to get sub-solutions to the problem and then solve the problem itself. You also have to use a memory structure to hold the results of such sub-solutions.
#include <deque>
#include <iostream>
using namespace std;
int solve(deque<int>& solution, int number) {
if(number >= solution.size()) // resize to fit
solution.resize(number + 1, -1);
if(number == 1) // special case for number 1
return solution[number] = 0;
if(solution[number] != -1) // if already calculated
return solution[number];
if(number % 2 == 0) // n=n/2
return solution[number] = solve(solution, number/2) + 1;
int solutionA = solve(solution, number + 1); // n++
int solutionB = solve(solution, number - 1); // n--
return solution[number] = std::min(solutionA, solutionB) + 1; // best of n++,n--
}
int main() {
deque<int> solution;
cout << solve(solution, 35);
}
I'm not sure the code will work though.

Answer 4

Here's my recursive solution, verified up to 2097152 against the DP example.
The basis of it is using the value of the last two bits to determine the optimal operation. If the last bit is a 0, we always divide. If the last two bits are 11 we always increment as this transforms to 100 which enables two consecutive divide operations.
If the last two bits are 01 we decrement as this gives our next operation two consecutive divide operations vs incrementing which gives us 10.
The corner case is the number 3 where 3 -> 2 is desired over promotion to 4.
I suspect you can optimise this further by just scanning the bit pattern to determine the number of operations required. i.e. each zero requires a div op, and a set of ones can be changed into zeroes with a single addition.
#include <cstdint>
int solve_algorithmically(std::uint64_t number)
{
// If 1 there is nothing to do.
if (number <= 1)
return 0;
// Nasty hack to get around the case where number=3 & 3 == 3 will cause increment
if (number == 3)
return solve_algorithmically(number - 1) + 1;
// If we have an even number (0 in LSB)
if ((number & 1) == 0)
return solve_algorithmically(number / 2) + 1;
// If we have two consecutive 1's i.e. (...11) then increment as this wil give us two zeroes.
// The exception is the root case 3 where decrement wins.
if ((number & 3) == 3)
return solve_algorithmically(number + 1) + 1;
// The only other case ends last two bits = 01
return solve_algorithmically(number - 1) + 1;
}
int main() {
for (auto i = 1; i < 2097152; i++)
{
int alg = solve_algorithmically(i);
}
}