Задача о рюкзаке

void perebor(int a[n], int b[n], int w)// массив из их массы, массив из стоимостей, вместимость рюкзака
{
    int max = b[1];
    int r = a[1];
    for (int i = 1; i <= n; i++)
    {
        for (int j = i; j <= n; j++)
        {
            if ((r<w) && (max>=max))
            {
                cout << "максимальная стоимость=" <<r<< endl;
                cout << "количество предметов" << j << endl;
            }
            else if ((max < max)&&()
            {
                max = max + b[j];
                r = r + a[j];
            }
        }
    }
    /*for (int i = 1; i <= n; i++)
    {
        for (int j = i; j <= n; j++)
        {
            if ((r+a[j+1]) < w)
            {
                if(max+)
            }
            else if ((r+a[j+1]>=w)
            {
                cout << "максимальная стоимость=" << max1 << endl;
                cout << "количество предметов:" << j + 1;
            }
        }
    }*/
}

///////////////////////////////////////////////////////////////////////////////
//4.
///////////////////////////////////////////////////////////////////////////////
//нужно реализовать задачу о рюкзаке (из заданного множества предметов
//со свойствами «стоимость» и «вес» требуется отобрать подмножество
//с максимальной полной стоимостью, соблюдая при этом ограничение
//на суммарный вес) методом полного перебора.
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <set>
#include <utility>
///////////////////////////////////////////////////////////////////////////////
struct  T_item
{
    //-------------------------------------------------------------------------
    int     weight_;
    int     cost_;
    //-------------------------------------------------------------------------
    T_item
        (
            int     weight,
            int     cost
        )
        :
        weight_ ( weight    ),
        cost_   ( cost      )
    {}
    //-------------------------------------------------------------------------
    bool    operator<   ( T_item    const   &   i )                         const
    {
        return      std::make_pair( weight_,    cost_   )
                <   std::make_pair( i.weight_,  i.cost_ );
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
typedef std::multiset   < T_item    >   T_items;
///////////////////////////////////////////////////////////////////////////////
template < typename TT_cont >
void    print_cont( TT_cont     const   &   cont )
{
    for( auto   const   &   elem    :   cont )
    {
        std::cout   <<  elem    <<  '\t';
    }
    std::cout   <<  std::endl;
}
///////////////////////////////////////////////////////////////////////////////
std::ostream    &   operator<<
    (
        std::ostream            &   ostr,
        T_item          const   &   i
    )
{
    ostr    <<  "(" <<  i.weight_   <<  ","     <<  i.cost_     <<  ")";
    return  ostr;
}
///////////////////////////////////////////////////////////////////////////////
class   T_rucksack
{
    //-------------------------------------------------------------------------
    int         weight_total_max_;
    int         weight_total_;
    int         cost_total_;
    T_items     items_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_rucksack( int     weight_total_max )
        :
        weight_total_max_   ( weight_total_max ),
        weight_total_       (),
        cost_total_         ()
    {}
    //-------------------------------------------------------------------------
    void    fill_with_max_cost( T_items     const   &   items )
    {
        T_rucksack  rucksack_cur( weight_total_max_ );
 
        while   (
                        rucksack_cur.successfully_add_item_from( items )
                    ||  rucksack_cur.successfully_inc_item_from( items )
                )
        {
            if  (
                        rucksack_cur.cost_total_
                    >   cost_total_
                )
            {
                *this   =   rucksack_cur;
            }
        }//while
    }
    //-------------------------------------------------------------------------
    void    print()                                                         const
    {
        std::cout   <<  std::endl
                    <<  "rucksack:"
                    <<  std::endl
                    <<  "weight_total_max = "
                    <<  weight_total_max_
                    <<  std::endl;
 
        print_cont( items_ );
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    bool    successfully_add_item_from( T_items     const   &   items )
    {
        bool    bool_res{};
 
        if  (
                items_.empty()
            )
        {
            bool_res    =   successfully_insert_item    (
                                                            *items.begin()
                                                        );
        }
        else
        {
            auto    it  =   std::find_if
                                (
                                    items.find  (
                                                    *items_.rbegin()
                                                ),
 
                                    items.end   (),
 
                                    [=]         ( auto  const   &   item )
                                    {
                                        return          items_  .count  ( item )
                                                    <   items   .count  ( item )
 
                                                &&      item.weight_
                                                    <=  this->weight_free();
                                    }
                                );
 
            bool_res    =   it  !=  items.end();
 
            if( bool_res )
            {
                insert_item( *it );
            }
        }//else
 
        return  bool_res;
    }
    //-------------------------------------------------------------------------
    bool    successfully_inc_item_from( T_items     const   &   items )
    {
        bool    bool_res{};
 
        for(;;)
        {
            bool_res    =   !items_.empty();
 
            if( !bool_res )
            {
                break;
            }
 
            auto    item_back   =   *items_.rbegin();
            remove_item( item_back );
            auto    begin_it    =   items.upper_bound( item_back );
 
            auto    it  =   std::find_if
                                (
                                    begin_it,
                                    items.end   (),
 
                                    [=]         ( auto  const   &   item )
                                    {
                                        return      item.weight_
                                                <=  this->weight_free();
                                    }
                                );
 
            bool_res    =   it  !=  items.end();
 
            if( bool_res )
            {
                insert_item( *it );
                break;
            }
        }//for
 
        return  bool_res;
    }
    //-------------------------------------------------------------------------
    void    remove_item( T_item     const   &   item )
    {
        items_.erase    (
                            items_.lower_bound( item )
                        );
 
        weight_total_   -=  item.weight_;
        cost_total_     -=  item.cost_;
    }
    //-------------------------------------------------------------------------
    void    insert_item( T_item     const   &   item )
    {
        items_.emplace( item );
        weight_total_   +=  item.weight_;
        cost_total_     +=  item.cost_;
    }
    //-------------------------------------------------------------------------
    bool    successfully_insert_item( T_item    const   &   item )
    {
        bool    bool_res    =   item.weight_    <=  weight_free();
 
        if( bool_res )
        {
            insert_item( item );
        }
 
        return  bool_res;
    }
    //-------------------------------------------------------------------------
    int     weight_free()                                                   const
    {
        return      weight_total_max_
                -   weight_total_;
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
int     get_rand_val_in_segm
    (
        int     min,
        int     max
    )
{
    return  rand() % ( max - min + 1 )  + min;
}
///////////////////////////////////////////////////////////////////////////////
T_items     get_rand_items( size_t  items_size )
{
    const   int     VAL_MIN     {1};
    const   int     VAL_MAX     {10};
 
    T_items     res;
 
    while   (
                res.size()  <   items_size
            )
    {
        res.emplace (
                        T_item  (
                                    get_rand_val_in_segm( VAL_MIN,  VAL_MAX ),
                                    get_rand_val_in_segm( VAL_MIN,  VAL_MAX )
                                )
                    );
    }//while
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    const   int     ITEMS_SIZE          { 50 };
    const   int     WEIGHT_TOTAL_MAX    { 10 };
 
    srand(unsigned(time(0)));
 
    auto    rand_items  =   get_rand_items  ( ITEMS_SIZE );
 
    std::cout   <<  "items:"
                <<  std::endl;
 
    print_cont( rand_items );
 
    T_rucksack  rucksack            ( WEIGHT_TOTAL_MAX  );
    rucksack.fill_with_max_cost     ( rand_items        );
    rucksack.print                  ();
}