Определить, за сколько дней все деревья в лесу будут вырублены

#include <iostream>
using namespace std;
 
int f(_int64 A, _int64 K, _int64 B, _int64 M, _int64 X);
bool validNumber(_int64 N, _int64 A, _int64 K, _int64 B, _int64 M, _int64 X);
int main()
{
    _int64 A, B;
    _int64 K, M, X;
    cin >> A >> K >> B >> M >> X;
    f(A, K, B, M, X);
}
int f(_int64 A, _int64 K, _int64 B, _int64 M, _int64 X)
{
    _int64 N = 1;
    while (validNumber(N, A, K, B, M, X) == 0)
    {
        N *= 2;
    }
    _int64 left, right, mid;
    right = N;
    left = N / 2;
    while (right - left > 1)
    {
        mid = left + (right - left) / 2;
        if (validNumber(mid, A, K, B, M, X) == 1)
            right = mid;
        else
            left = mid;
    }
    cout << mid << endl;
    return 0;
}
bool validNumber(_int64 N, _int64 A, _int64 K, _int64 B, _int64 M, _int64 X)
{
    return ((N*A) - ((N / K) *A)) + ((N*B) - ((N / B) *B)) >= X;
}

#include <iostream>
using namespace std;
 
typedef unsigned long long int ull;
 
typedef struct {ull a; ull k; ull b; ull m; ull x;} pars;
 
ull task(pars* p,ull l,ull r) {ull d = l+(r-l)/2;
    return l+1==r ? r : (p->a*(d-d/p->k) + p->b*(d-d/p->m) < p->x) ? task(p,d,r) : task(p,l,d);}
 
int main() {pars p; p.a=2; p.k=4; p.b=3; p.m=3; p.x=25; cout<<task(&p, 0, 2*p.x); return 0;}

/*
 Фермер Николай нанял двух лесорубов: Дмитрия и Федора, чтобы вырубить лес, на месте 
 которого должно быть кукурузное поле. В лесу растут X деревьев.
Дмитрий срубает по A деревьев в день, но каждый K-й день он отдыхает и не срубает 
ни одного дерева. Таким образом, Дмитрий отдыхает в K-й, 2K-й, 3K-й день, и т.д.
Федор срубает по B деревьев в день, но каждый M-й день он отдыхает и не срубает 
ни одного дерева. Таким образом, Федор отдыхает в M-й, 2M-й, 3M-й день, и т.д.
Лесорубы работают параллельно и, таким образом, в дни, когда никто из них не отдыхает, 
они срубают A + B деревьев, в дни, когда отдыхает только Федор – A деревьев, а в дни, 
когда отдыхает только Дмитрий – B деревьев. В дни, когда оба лесоруба отдыхают, 
ни одно дерево не срубается.
Фермер Николай хочет понять, за сколько дней лесорубы срубят все деревья, и он 
сможет засеять кукурузное поле.
Требуется написать программу, которая по заданным целым числам A, K, B, M и X определяет, 
за сколько дней все деревья в лесу будут вырублены.
 
ВХОДНЫЕ ДАННЫЕ
Входной файл INPUT.TXT содержит пять целых чисел, разделенных пробелами: 
A, K, B, M и X (1 ≤ A, B ≤ 10^9, 2 ≤ K, M ≤ 10^18, 1 ≤ X ≤ 10^18).
 
ВЫХОДНЫЕ ДАННЫЕ
В выходной файл OUTPUT.TXT выведите искомое количество дней.
 
ЕСТЬ ТОЛЬКО ОДИН ПРИМЕР:
2 4 3 3 25
Ответ: 7.
*/
/////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
/////////////////////////////////////////////////////////////////////////////////////////
typedef long long   T_int;
/////////////////////////////////////////////////////////////////////////////////////////
bool    days_count_is_valid
    (
        T_int   d,
        T_int   A,
        T_int   K,
        T_int   B,
        T_int   M,
        T_int   X
    )
{
    return  A * ( d - d / K ) + B * ( d - d / M )     >=  X;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_int   f
    (
        T_int   A,
        T_int   K,
        T_int   B,
        T_int   M,
        T_int   X
    )
{
    T_int   R   =   1;
 
    while   (
                !days_count_is_valid
                    (
                        R,
                        A,
                        K,
                        B,
                        M,
                        X
                    )
            )
    {
        R   *=  2;
    }
    
    T_int   L   =   R / 2;
 
    while( R - L > 1 )
    {
        T_int   middle   =   (L + R) / 2;
 
        if  (
                !days_count_is_valid
                    (
                        middle,
                        A,
                        K,
                        B,
                        M,
                        X
                    )
            )
        {
            L   =   middle;
        }
        else
        {
            R   =   middle;
        }
    }//while
 
    return  R;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_int   A   =   0;
    T_int   K   =   0;
    T_int   B   =   0;
    T_int   M   =   0;
    T_int   X   =   0;
 
    std::cin    >>  A//Дмитрий срубает
                >>  K//Дмитрий каждый K-й день отдыхает.
                >>  B
                >>  M
                >>  X;//Количество деревьев.
 
    std::cout   <<  f   (
                            A,
                            K,
                            B,
                            M,
                            X
                        )
 
                <<  std::endl;
 
    system("pause");
}

#include<iostream>
using namespace std;
 
const int A=2, K=4, B=3, M=3, X=25;
 
int real_chopping(int time)
{
    return A*(time-time/K)+B*(time-time/M);
}
 
int approximate_time(int X)
{
    //A*time*(1-1/K)+B*time*(1-1/M)=X;
    //time*(A*K-A)/K+time*(B*M-B)/M=X;
    //time*(A*K*M-A*M+B*M*K-B*K)/(K*M)=X;
    double div=double(A)*M*(K-1)+B*K*(M-1);
    double mul=double(K)*M;
    return X*mul/div;
}
 
int main()
{
    int low=approximate_time(X-A-B);
    int hight=approximate_time(X);
    for(int i=low;i<=hight+1;++i)
        if(real_chopping(i)>=X)
        {
            cout<<i<<endl;
            break;
        }
    return 0;
}

return ((N*A) - ((N / K) *A)) + ((N*B) - ((N / B) *B)) >= X;

return  A * ( d - d / K ) + B * ( d - d / M )     >=  X;

d['A'] * ( i - i / d['K'] ) + d['B'] * ( i - i / d['M'] )   >=  d['X'];

"AKBMX"

/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <map>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                         T_str;
typedef long long                           T_int;
typedef std::map    < char,     T_int   >   T_data;
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_val_ia_valid_for_data
{
    //-----------------------------------------------------------------------------------
    bool    operator()
        (
            T_int       i,
            T_data  &   d
        )                                                                           const
    {
        return  d['A'] * ( i - i / d['K'] ) + d['B'] * ( i - i / d['M'] )   >=  d['X'];
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
template< typename    TT_val_ia_valid_for_data >
class   T_binary_search
{
    //-----------------------------------------------------------------------------------
    T_str                       var_names_;
    T_int                       result_;
    T_data                      data_;
    TT_val_ia_valid_for_data    val_ia_valid_for_data_;
 
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_binary_search( T_str  const   &   var_names )
        :
        var_names_  ( var_names ),
        result_     ()
    {
        input_data_with_var_names   ();
        set_result                  ();
        print_result                ();
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void    input_data_with_var_names()
    {
        std::for_each
            (
                var_names_.begin     (),
                var_names_.end       (),
 
                [&]                 ( char  var_name )
                {
                    std::cin    >>  data_[ var_name ];
                }
            );
    }
    //-----------------------------------------------------------------------------------
    void    set_result()
    {
        T_int   R   =   1;
 
        while   (
                    !val_is_valid( R )
                )
        {
            R   *=  2;
        }
    
        T_int   L   =   R / 2;
 
        while( R - L > 1 )
        {
            T_int   middle   =   (L + R) / 2;
 
                (
                    val_is_valid( middle )
                        ?   R
                        :   L
                )
 
            =   middle;
        }//while
 
        result_     =   R;
    }
    //-----------------------------------------------------------------------------------
    bool    val_is_valid( T_int     i )
    {
        return  val_ia_valid_for_data_
                    (
                        i,
                        data_
                    );
    }
    //-----------------------------------------------------------------------------------
    void    print_result()
    {
        std::cout   <<  result_
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_binary_search< T_val_ia_valid_for_data >  binary_search( "AKBMX" );
    system("pause");
}