Из заданного числа используя заданный набор операций получить единицу

if((x&(x-1))==0)

void __fastcall TForm1::Button1Click(TObject *Sender)
{
int n,mi,i;
String rezult;
n=StrToInt(Edit1->Text);
int *d = new int[n+1];
d[1]= 0;
for(i=2; i<n+1; i++)
  {
    mi=d[i-1]+1;
    if(i % 2==0) mi=min(mi,d[i/2]+1);
    if(i % 3==0) mi=min(mi,d[i/3]+1);
    d[i] = mi;
  }
i=n;
while(i>1)
 {
   if(d[i]==d[i-1]+1){ rezult=rezult+'1'; i--;}
     else if((i % 2==0) && (d[i]==d[i/2]+1)) { rezult=rezult+'2';  i/=2;}
       else {rezult=rezult+'3'; i/=3;}
 }
delete[]d;
}

#include "iostream"
 
int nmin = 10000000;
 
void recurs(int n, int nm)
{
 if (n == 1) {
  if (nm < nmin) nmin = nm;
  return;
 }
 nm++;
 recurs(n - 1, nm);
 if (n % 2 == 0) recurs(n / 2, nm);
 if (n % 3 == 0) recurs(n / 3, nm);
}
 
void main(int argc,char **argv)
{
 int n;
 cin >> n;
 recurs(n,0);
 cout << nmin << endl;
}

// prg_title 'dream in summer night'
#include<iostream>
#include<map>
#include<stack>
#include<vector>
#include <ctime>
#include <cstdlib>
 
using namespace std;
 
struct crasy_solver
{
crasy_solver(int N_=0)
:N(N_), countOp(0)
{
map<int,int>& mawpa = alreadyEvaluated();
mawpa[0]=0;
mawpa[1]=0;
mawpa[2]=1;
mawpa[3]=1;
}
 
crasy_solver(int N_, int countOp_)
:N(N_), countOp(countOp_)
{
}
    static map<int,int>& alreadyEvaluated();
    static stack<pair<int,int>>& toBeStored();
 
 
    void countOfOperations()
    {
        stack<pair<int,int>>&   stacka  =   toBeStored();
 
        map<int,int>&           mawpa   =   alreadyEvaluated();
 
 
      auto pairOfGnedih = mawpa.find(N);
      if(pairOfGnedih != mawpa.end())
        {
            N=1;
            countOp = pairOfGnedih->second;
            while(!stacka.empty())
                {
                    auto& toExtract = stacka.top();
                    toExtract.second = ++countOp;
                    mawpa.insert(toExtract);
                    stacka.pop();
                }
              //  cout<<countOp<<endl;
            return;
        }
 
        auto toStore = pair<int,int>(N, 0);
        stacka.push(toStore);
        ++countOp;
      if(N%3 == 0)
      {
            N/=3;
            return countOfOperations();
      }
 
      if(N%4 == 0 || (N%2==0 && (N/2-1)%3==0))
      {
            N/=2;
            return countOfOperations();
      }
            N-=1;
            return countOfOperations();
 
    }
 
  static
    void show_mawpa()
    {
        static map<int,int> AlreadyEvaluated=alreadyEvaluated();
        for(const auto & mawp : AlreadyEvaluated)
            cout<<mawp.first<<'\t'<<mawp.second<<endl;
 
    }
 
    int N;
    int countOp;
 
};
 
stack<pair<int,int>>&
crasy_solver::toBeStored()
{
    static stack<pair<int,int>> ToBeStored;
    return ToBeStored;
}
map<int,int>&
crasy_solver:: alreadyEvaluated()
{
    static map<int,int> AlreadyEvaluated;
    return AlreadyEvaluated;
}
 
int nA,x;
void action(int a,int n);
 
int main(int argv, char*argc[])
{
    srand((int)time(0));
  const int sz = 100000;
 int n[sz];
 for(int i=0; i<sz; ++i)
    {
n[i] = rand()%(sz+1);
//cout<<n[i]<<"\n";
    }
cout<<"\nmy_prg\n";
clock_t tBegFirst=clock();
for(int i=0; i<sz; ++i)
{
 crasy_solver cs(n[i]);
 cs.countOfOperations();
// cout<<cs.countOp<<endl;
}
clock_t  tEndFirst=clock ();
clock_t spanF= tEndFirst-tBegFirst;
cout<<"elapsed "<<spanF<<endl;
 
cout<<"\nbiger18_prg\n";
tBegFirst=clock();
for(int i=0; i<sizeof(n)/sizeof(int); i++)
    {
        nA=0;
        action(1,n[i]);
       // cout<<nA<<endl;
    }
tEndFirst=clock ();
spanF= tEndFirst-tBegFirst;
cout<<"\nelapsed "<<spanF<<endl;
 
 
 //cin.get();
    return 0;
}
 
void action(int a,int n)
{
    for(char i=0; i<3; i++)
    {
        x=0;
        if(!i   && n%3==0) x=n/3;
        if(i==1 && n%2==0) x=n/2;
        if(i==2 && n>1) x=n-1;
        if(x==1 && (a<nA || !nA)) nA=a;
        if(x>1  && (a<nA || !nA)) action(a+1,x);
    }
}

#include <iostream>
#include <vector>
#include <algorithm>
 
int main() {
    size_t n;
    std::cin >> n;
    std::vector<size_t> dp(n+1);
    for (size_t i = 2; i <= n; i++) {
        dp[i] = dp[i-1] + 1;
        if (i % 2 == 0)
            dp[i] = std::min(dp[i], dp[i / 2] + 1);
        if (i % 3 == 0)
            dp[i] = std::min(dp[i], dp[i / 3] + 1);
    }
    std::cout << dp[n];
}

map<int,int>&
crasy_solver:: alreadyEvaluated()
{
    static map<int,int> AlreadyEvaluated={{0,0},{1,0},{2,1},{3,1}};
    return AlreadyEvaluated;
}