Решить задачу методом рекурсивного перебора с возвратом

100 6
11 20 30 40 11 99

3
40 30 30

#include <iostream>
#include <vector>
#include <string>
#include<set>
#include<math.h>
#include <algorithm>
using namespace std;
int main()
{
 
    long long n, m, a, kirp = 0, razm = 0;
    long long min1 = 9999999999; string str, str1;
    int minit = -92187452;
    cin >> n >> m;
    vector<int>v; vector<int>c(m);
    long long ch;
    long long k = 0;
    while (k != m&&cin >> a)
    {
        k++;
        v.push_back(a);
    }
    sort(v.begin(), v.end());
    reverse(v.begin(),v.end());
    int tr = 0;
    for (int i = 0; i < m; i++)
    {
        c[i] = 0;
        if (v[i] == v[0])
        {
            tr++;
        }
    }
    if (tr == v.size() && v[0]>n)
    {
        cout << 0; return 0;
    }
    for (int d = 1; d <pow(3, m); d++)
    {
        int s;
        long long l = m - 1;
        while (c[l] == 2)
        {
            c[l] = 0;
            l--;
            if (l < 0)
            {
                break;
            }
        }
        if (l >= 0)
        {
            c[l]++;
        }
        long long ch = 0;
        int frf = 0;
        str.clear();
        for (int j = 0; j < m; j++)
        {
            ch += c[j] * v[j];
            if (ch > n)
            {
                razm = 1; s = n + 1; break;
            }
            s += ch;
            if (s > n)
            {
                break;
            }
            str += (c[j] + 48);
        }
        long long ch1 = 0;
        if (frf == 1)
        {
            continue;
        }
        if (ch == n)
        {
            ch1 = 0;
            for (int i = 0; i < str.size(); i++)
            {
                ch1 += str[i] - 48;
            }
            if (ch1 < min1)
            {
                min1 = ch1;
                minit = d;
                str1 = str;
            }
        }
 
    }
    if (minit == -92187452 && razm == 1)
    {
        cout << 0; system("pause"); return 0;
    }
    else
    {
        if (minit == -92187452 && razm == 0)
        {
            cout << -1; system("pause"); return 0;
        }
    }
    string otvet = str1;
    cout << min1 << endl;
    for (int i = 0; i < otvet.length(); i++)
    {
        long long t = otvet[i] - 48;
        while (t != 0)
        {
            cout << v[i] << " ";
            t--;
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
//Вариант 9.
///////////////////////////////////////////////////////////////////////////////
//http://informatics.mccme.ru/moodle/mod/statements/view3.php?chapterid=32&run_id=36r8533#1
//Задача №32. Монетки
 
//Данные вводятся с клавиатуры или из файла input.txt, выводятся на экран
//или в файл output.txt. Первые тесты не всегда совпадают с примерами из условия.
 
//Ограничение по времени, сек    2
//Ограничение по памяти, мегабайт    64
 
//В Волшебной стране используются монетки достоинством A1, A2,…, AM.
//Волшебный человечек пришел в магазин и обнаружил, что у него есть
//ровно по две монетки каждого достоинства. Ему нужно заплатить сумму N.
//Напишите программу, определяющую, сможет ли он расплатиться без сдачи.
 
//Входные данные
 
//Сначала вводится число N (1≤N≤10^9), затем — число M (1≤M≤15) и далее M
//попарно различных чисел A1, A2,…, AM (1≤Ai≤10^9).
//Выходные данные
 
//Выведите сначала K — количество монет, которое придется отдать
//Волшебному человечку, если он сможет заплатить указанную сумму без сдачи.
//Далее выведите K чисел, задающих достоинства монет. Если решений несколько,
//выведите вариант, в котором Волшебный человек отдаст наименьшее возможное
//количество монет. Если таких вариантов несколько, выведите любой из них.
 
//Если без сдачи не обойтись, то выведите одно число 0. Если же у Волшебного
//человечка не хватит денег, чтобы заплатить указанную сумму, выведите
//одно число –1 (минус один).
 
//Оценка задачи
 
//1 балл получат программы, правильно решающие задачу с дополнительными
//ограничениями Ai≤106, M≤10.
 
//Примеры
//Входные данные
 
//5 2
//1 2
 
//Выходные данные
 
//3
//2 2 1
 
//Входные данные
 
//7 2
//1 2
 
//Выходные данные
 
//-1
 
//Входные данные
 
//5 2
//3 4
 
//Выходные данные
 
//0
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::vector     < int   >   T_int_values;
///////////////////////////////////////////////////////////////////////////////
void    pay
    (
        int                         amount,
        int                         active_money,
        T_int_values    const   &   coins_values,
        int                         count_of_each_val,
 
        int                     &   res_total_counter,
        T_int_values            &   res_counters,
        bool                    &   bool_res,
 
        int                         total_counter   =   0,
        T_int_values                counters        =   {}
    )
{
    if  (
            !amount
        )
    {
 
        bool    total_counter_is_valid    =     !res_total_counter
 
                                            ||      total_counter
                                                <   res_total_counter;
 
        if  (
                    !bool_res
                ||  total_counter_is_valid
            )
        {
            res_total_counter   =   total_counter;
            res_counters        =   counters;
            bool_res            =   true;
        }//if
    }
    else if (
                    active_money
                >=  amount
            )
    {
        size_t  ind                 =       coins_values    .size()
                                        -   1
                                        -   counters        .size();
 
        auto    coin_val_cur        =   coins_values[ ind ];
 
        auto    active_money_new    =       active_money
 
                                        -       coin_val_cur
                                            *   count_of_each_val;
 
        int     counter_max         =   std::min
                                            (
                                                count_of_each_val,
                                                amount / coin_val_cur
                                            );
 
        for( int  counter{ counter_max }; counter >= 0; --counter )
        {
            auto    amount_new          =       amount
 
                                            -       coin_val_cur
                                                *   counter;
 
            auto    total_counter_new   =       total_counter
                                            +   counter;
 
            auto    counters_new        =   counters;
            counters_new.push_back( counter );
 
            pay (
                    amount_new,
                    active_money_new,
                    coins_values,
                    count_of_each_val,
 
                    res_total_counter,
                    res_counters,
                    bool_res,
 
                    total_counter_new,
                    counters_new
                );
        }//for
    }//else if
}
///////////////////////////////////////////////////////////////////////////////
void    try_to_pay_and_print_result
    (
        int             amount,
        T_int_values    coins_values,
        int             count_of_each_val
    )
{
    std::sort
        (
            coins_values.begin  (),
            coins_values.end    ()
        );
 
    int             res_total_counter{};
    T_int_values    res_counters;
 
    int             active_money   =        std::accumulate
                                                (
                                                     coins_values.begin      (),
                                                     coins_values.end        (),
                                                     0
                                                )
 
                                        *   count_of_each_val;
 
    if  (
                amount
            >   active_money
        )
    {
        std::cout   <<  -1;
    }
    else
    {
        bool    bool_res{};
 
        pay (
                amount,
                active_money,
                coins_values,
                count_of_each_val,
 
                res_total_counter,
                res_counters,
                bool_res
            );
 
        if( bool_res )
        {
            std::cout   <<  res_total_counter
                        <<  std::endl;
 
            for( size_t  i{}; i < res_counters.size(); ++i )
            {
                for( int  count{}; count < res_counters[i]; ++count )
                {
                    std::cout   <<  coins_values
                                        [
                                                coins_values.size()
                                            -   1
                                            -   i
                                        ]
 
                                <<  ' ';
                }//for
            }//for
        }
        else
        {
            std::cout   <<  0;
        }//else
    }//else
 
    std::cout   <<  std::endl;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    const   int     COUNT_OF_EACH_VAL   =   2;
    int             amount              {};
    int             coin_values_total   {};
 
    std::cin    >>  amount;
    std::cin    >>  coin_values_total;
 
    T_int_values  coins_values( coin_values_total );
 
    for (
            auto    &   coin_val    :
            coins_values
        )
    {
        std::cin    >>  coin_val;
    }
 
    try_to_pay_and_print_result
        (
            amount,
            coins_values,
            COUNT_OF_EACH_VAL
        );
}