Question

我遇到了求和问题的递归求解问题。问题是：对于给定的m和n，创建一个程序，将n个数加到m，这样就可以使用最小数，它们就是。有多个解，右边是使用更大数的解。用户输入n，m和n数字。例如：m = 19 n = 4 8,5,4,1。解决方案是8 + 5 + 5 + 1。如果我用一个数组中的下一个数字调用该函数并将其添加到小于和的值时，只有当数组中的下一个数字总和为m时才能找到解。如果问题是这样的：m = 28 n = 3 8,7,5解决方案是8 + 8 + 7 + 5，但是我的程序会去8 + 8 + 8并尝试添加7或5并且会因为没有崩溃它们最多可以容纳28个。所以我的问题在于回到2个以上的步骤。我可以从8 + 8 + 8 + 7到8 + 8 + 8但是可以回到8 + 8.这类似于背包问题只是它更简单。很抱歉到目前为止我的代码不包括在内：

#include <iostream>
#include <vector>
using namespace std;

void outputt(vector<int>);

int x(int m,vector<int> s,int n,int u)
{
    static int sum=0;
    static int level=0;
    static vector<int> p;
    sum+=s[u];       
    p.push_back(s[u]);

    if(level==((n-u)+1))
    {
        p.pop_back();
        level=0;
        x(m,s,n,u-1);
    }

    if(sum>m)
    {
        level++;
        sum-=s[u];
        p.pop_back();
        x(m,s,n,u+1);
    }

    if(sum==m)
    {
        outputt(p);
        return sum;
    }
    else
        x(m,s,n,u);

    level++;
    if(level>n-1)
        outputt(p);

    if(sum==m)
        return sum;
    else
    {
        cout<<"....";
        x(m,s,n,level);
    }
}

void outputt(vector<int> x)
{
    for(vector<int>::iterator i=x.begin();i!=x.end();++i)
        cout<<*i<<" ";
}

int main()
{
    int m,n;
    cin>>m>>n;
    int z;
    vector<int> p;
    for(int i=0;i<n;++i)
    {
        cin>>z;
        p.push_back(z);
    }
    cout<<x(m,p,n,0);

    system("PAUSE");
}

输出存在问题，但现在并不重要。

Answer 1

距离您需要的地方不远，这将尽快找到解决方案（最少的迭代次数），而不是最浅的解决方案。

#include <deque>
#include <iostream>
#include <iterator>
#include <algorithm>

template <typename IT, typename IT2>
bool perm_find(int num, IT start, IT last, IT2 output)
{
    for(IT first=start; first!=last; ++first)
    {
        int t=num-*first;
        if(t==0
        ||(t>0 && perm_find(t, start, last, output)))
        {   
            *output++=*first;
            return true;
        }   
    }
    return false;
} 

int main()
{
    int num;
    std::deque<int> pallet, results;

    std::cout << "Enter M: "      << std::endl;
    std::cin  >> num;
    std::cout << "Enter N vals: " << std::endl;

    std::copy(std::istream_iterator<int>(std::cin),
              std::istream_iterator<int>(),
              std::back_inserter(pallet));

    std::sort(pallet.rbegin(), pallet.rend());

    perm_find(num, pallet.begin(), pallet.end(), 
              std::back_inserter(results));

    std::copy(results.begin(), results.end(),
              std::ostream_iterator<int>(std::cout, ", "));
    return 0;
}

要对其进行修改以使其尽可能短，您需要使用dijstras算法等方式完成所有有效组合。

EDTT：我现在修复了一个错误

Answer 2

一些建议：

避免递归代码中的静态（可以将其用于调试），让函数的每个实例尽可能独立。
遍历函数（x）中的所有数字，以回溯到最佳解决方案。
将数字作为const引用传递，因为它们无论如何都不会改变。
还传递（作为值）具有已选择的数字（尝试）的容器，因此在返回时继续前一次尝试（回溯）。这应该是你的实际状态。
总和是std :: accumulate（attempt.begin（），attempt.end（），0）;
级别为attempt.size（）;
首先将您的数字降序排序以获得最小数字。
如果您以后需要它，则返回尝试向量（现在您并不总是返回总和）。

递归最大数字求和

2 个答案: