// Original C++ solution (slower):
            #include <bits/stdc++.h>

            #include<iostream>

            #include<cstdio>

            #include<vector>

            #include<queue>

            #include<map>

            #include<cstring>

            #include<string>

            #include <math.h>

            #include<algorithm>

        //    #include <boost/multiprecision/cpp_int.hpp>

            #include<functional>

          #define int long long

            #define inf  1000000007

            #define pa pair<int,int>

    #define ll long long

            #define pal pair<ll,ll>

            #define ppa pair<int,pa>

            #define  mp make_pair

            #define  pb push_back

            #define EPS (1e-10)

            #define equals(a,b) (fabs((a)-(b))<EPS)

     

            using namespace std;

     

            class Point{

            	public:

            	double x,y;

            	Point(double x=0,double y=0):x(x),y(y) {}

            	Point operator + (Point p) {return Point(x+p.x,y+p.y);}

            	Point operator - (Point p) {return Point(x-p.x,y-p.y);}

            	Point operator * (double a) {return Point(x*a,y*a);}

            	Point operator / (double a) {return Point(x/a,y/a);}

            	double absv() {return sqrt(norm());}

            	double norm() {return x*x+y*y;}

            	bool operator < (const Point &p) const{

            		return x != p.x ? x<p.x: y<p.y;

            	}

            	bool operator == (const Point &p) const{

            		return fabs(x-p.x)<EPS && fabs(y-p.y)<EPS;

            	}

            };

            typedef Point Vector;

     

            struct Segment{

            Point p1,p2;

            };

     

        double hen(Vector a){

        if(fabs(a.x)<EPS && a.y>0) return acos(0);

        else if(fabs(a.x)<EPS && a.y<0) return 3*acos(0);

        else if(fabs(a.y)<EPS && a.x<0) return 2*acos(0);

        else if(fabs(a.y)<EPS && a.x>0) return 0.0;

        else if(a.y>0) return acos(a.x/a.absv());

        else return 2*acos(0)+acos(-a.x/a.absv());

     

        }

     

int gcd(int v,int b){

	if(v>b) return gcd(b,v);

	if(v==b) return b;

	if(b%v==0) return v;

	return gcd(v,b%v);

}

            double dot(Vector a,Vector b){

            	return a.x*b.x+a.y*b.y;

            }

            double cross(Vector a,Vector b){

            	return a.x*b.y-a.y*b.x;

            }

        

            //----------------kokomade tenpure------------





int n,a,l;





bool power(int s){

	int z=1;

	for(int i=0;i<l;i++){

		z *= s;

		if(z >= n) return true;

	}

	return false;

	

}



int power1(int s){

	int z=1;

	for(int i=0;i<l;i++){

		z *= s;

//		if(z >= n) return true;

	}

	return z;

	

}

    signed main(){





    

    	cin>>n>>a;

    	

    	int ans=n;

 

    	

    	for( l=2;l<=1000;l++){

    		int sita=1,ue=100000000ll,med;

    	//	med=(sita+ue)/2;

    		while(ue-sita>1){

    				med=(sita+ue)/2;

    	//		cout<<med<<endl;

    			if( power(med) ){

    				ue=med;

    			}	

    			else sita=med;	

    		}

    	//	cout<<l<<" "<<ue<<endl;

    		int s=ue;

    		int e=power1(s);

    		int t=l*s+a*(l-1);

    	//	cout<<t<<" "<<e<<" "<<n<<endl;

    		while(e>= n){

    			e /= s;

    			e *= (s-1);

    			t--;

    			

    		}

    		t++;

    		e /= s-1;

    			e *= (s);

    	//	cout<<t<<endl;

    		ans=min(ans,t);

    		

    	//	cout<<endl;

    	}

    	

    	cout<<ans<<endl;

    	

    //	printf("%.10f\n",ans);

    	return 0;

    }

// Optimized solution to the same problem (faster):
   #include <bits/stdc++.h>

 

//    #include <boost/multiprecision/cpp_int.hpp>

 #define int long long

 #define inf  1000000007

 #define pa pair<int,int>

 #define ll long long

 #define pal pair<double,double>

 #define ppap pair<pa,int>

  #define PI 3.14159265358979323846

  #define paa pair<int,char>

  #define  mp make_pair

  #define  pb push_back

  #define EPS (1e-8)

                                          

    int dx[8]={0,1,0,-1,1,1,-1,-1};

    int dy[8]={1,0,-1,0,-1,1,1,-1};

                                            using namespace std;

                                   			class pa3{

                                            	public:

                                            	int x;

                                   				int y,z;

                                            	pa3(int x=0,int y=0,int z=0):x(x),y(y),z(z) {}

                                            	bool operator < (const pa3 &p) const{

                                            		if(x!=p.x) return x<p.x;

                                            		if(y!=p.y) return y<p.y;

                                            		 return z<p.z;

                                            		//return x != p.x ? x<p.x: y<p.y;

                                            	}

                                   				bool operator > (const pa3 &p) const{

                                            		if(x!=p.x) return x>p.x;

                                            		if(y!=p.y) return y>p.y;

                                            		 return z>p.z;

                                            		//return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator == (const pa3 &p) const{

                                            		return x==p.x && y==p.y && z==p.z;

                                            	}

                                            		bool operator != (const pa3 &p) const{

                                            			return !( x==p.x && y==p.y && z==p.z);

                                            	}

                                            

                                            };

                                            

                                            class pa4{

                                            	public:

                                            	int x;

                                            	int y,z,w;

                                            	pa4(int x=0,int y=0,int z=0,int w=0):x(x),y(y),z(z),w(w) {}

                                            	bool operator < (const pa4 &p) const{

                                            		if(x!=p.x) return x<p.x;

                                            		if(y!=p.y) return y<p.y;

                                            		if(z!=p.z)return z<p.z;

                                            		return w<p.w;

                                            		//return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator > (const pa4 &p) const{

                                            		if(x!=p.x) return x>p.x;

                                            		if(y!=p.y) return y>p.y;

                                            		if(z!=p.z)return z>p.z;

                                            		return w>p.w;

                                            		//return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator == (const pa4 &p) const{

                                            		return x==p.x && y==p.y && z==p.z &&w==p.w;

                                            	}

                                            		

                                            

                                            };

                                            class pa2{

                                            	public:

                                            	int x,y;

                                            	pa2(int x=0,int y=0):x(x),y(y) {}

                                            	pa2 operator + (pa2 p) {return pa2(x+p.x,y+p.y);}

                                            	pa2 operator - (pa2 p) {return pa2(x-p.x,y-p.y);}

                                            	bool operator < (const pa2 &p) const{

                                            		return y != p.y ? y<p.y: x<p.x;

                                            	}

                                            	bool operator > (const pa2 &p) const{

                                            		return x != p.x ? x<p.x: y<p.y;

                                            	}

                                            	bool operator == (const pa2 &p) const{

                                            		return abs(x-p.x)==0 && abs(y-p.y)==0;

                                            	}

                                            	bool operator != (const pa2 &p) const{

                                            		return !(abs(x-p.x)==0 && abs(y-p.y)==0);

                                            	}

                                            		

                                            

                                            };

                                            

 

                      

                                string itos( int i ) {

                                ostringstream s ;

                                s << i ;

                                return s.str() ;

                                }

                                 

                                int gcd(int v,int b){

                                	if(v>b) return gcd(b,v);

                                	if(v==b) return b;

                                	if(b%v==0) return v;

                                	return gcd(v,b%v);

                                }

                 

                            

                                int mod;

int extgcd(int a, int b, int &x, int &y) {

    if (b == 0) {

        x = 1;

        y = 0;

        return a;

    }

    int d = extgcd(b, a%b, y, x);

    y -= a/b * x;

    return d;

}

pa operator+(const pa & l,const pa & r) {   

    return {l.first+r.first,l.second+r.second};                                    

}    

pa operator-(const pa & l,const pa & r) {   

    return {l.first-r.first,l.second-r.second};                                    

}  

                                

                int pr[1000010];

                int inv[1000010];

                

                int beki(int wa,int rr,int warukazu){

                	if(rr==0) return 1%warukazu;

                	if(rr==1) return wa%warukazu;

                	wa%=warukazu;

                	if(rr%2==1) return ((ll)beki(wa,rr-1,warukazu)*(ll)wa)%warukazu;

                	ll zx=beki(wa,rr/2,warukazu);

                	return (zx*zx)%warukazu;

                }

 

                

    			int comb(int nn,int rr){

    				if(rr<0 || rr>nn || nn<0) return 0;

    				int r=pr[nn]*inv[rr];

    				r%=mod;

    				r*=inv[nn-rr];

    				r%=mod;

    				return r;

    			}

               

                void gya(int ert){

                	pr[0]=1;

                	for(int i=1;i<=ert;i++){

                		pr[i]=(pr[i-1]*i)%mod;

                	}

                		inv[ert]=beki(pr[ert],mod-2,mod);

                	for(int i=ert-1;i>=0;i--){

                		inv[i]=inv[i+1]*(i+1)%mod;

                	}

                }

                

              //   cin.tie(0);

    		//	ios::sync_with_stdio(false);

    			//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;            

                 //sort(ve.begin(),ve.end(),greater<int>());

 //   mt19937(clock_per_sec);

  //  mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()) ;

      

       

       

                               //----------------kokomade tenpure------------

int jou=10000000000000000ll;



int ch(int e,int r){

	vector<int> ve(r,e/r);

	for(int i=0;i<e%r;i++)ve[i]++;

	

	int p=1;

	for(auto v:ve){

		if(v)if(jou/v<p) return jou;

		p*=v;

		

	}

	return p;

}





int solve(int r,int n){

	//cout<<r<<" "<<n<<endl;

	int si=0,ue=inf*100000ll;

	

	while(ue-si>1){

		int me=(ue+si)/2;

		if(ch(me,r)>=n)ue=me;

		else si=me;

		

	}

	//cout<<ue<<endl;

	return ue;

}





 signed main(){



   cin.tie(0);

	ios::sync_with_stdio(false);

	

 	

 	int n,a;

 	cin>>n>>a;

 	

 	int ans=n;

 	for(int i=2;i<=60;i++){

 		int p=(i-1)*a;

 		p+=solve(i,n);

 		ans=min(ans,p);

 	}

 	cout<<ans<<endl;

 	

return 0;

 

 }

 

// Fastest known solution for this problem: