Question

我想写一个代码来显示有多少种方法可以总结5个不同的数字来得到100.例如，数字是2,5,10,20,50，它们可以重复任意次。这里50+50是单向和20+20+20+20+20。我不知道如何编程。

我认为它应该通过递归函数来完成，并且我试图在不知道如何编写的情况下编写一个函数，所以这是我提出的最佳函数：

#include<iostream>
#include<vector>

using namespace std;


int i,sum,n=5,counter=0;


int add(vector<int> &m){

    if(m.size()==0) return 0 ;

    for(i=0 ; i<m.size() ; i++ ){

          sum=m[i]+add(m);
          cout<< sum<<endl;
        if(n>0) n--;
        m.resize(n);
    }


}


int _tmain(int argc, _TCHAR* argv[])
{
    int i,sum,n=5;

vector<int> m;

m.resize(5);

m[0]=2;
m[1]=5;
m[2]=10;
m[3]=20;
m[4]=50;

add(m);


    return 0;
}

Answer 1

这个问题可以使用generating functions在理论上解决。生成函数不是一个函数，它不生成任何东西（好名字，嗯？），但它确实可以很好地跟踪信息。结果是你的问题的答案是方法的数量等于扩展中x^100的系数

1/(1-x^2) * 1/(1-x^5) * 1/(1-x^10) * 1/(1-x^20) * 1/(1-x^50)

以下是对原因的解释。回想一下1/(1-x) = 1 + x + x^2 + x^3 + ...。这是我们将用来解决问题的基本生成函数。

考虑您有数字A，B，...，N（在您的示例中，它们是2,5,10,20,50），您可以重复任意次数。然后考虑（生成）函数

f(x) = 1/(1-x^A) * 1/(1-x^B) * ... * 1/(1-x^N)

x^M中f(x)的系数是将M写为表格总和的方式的数量

M = a*A + b*B + ... + n*N

其中a,b,...,n是非负整数。

为什么这样做？因为展开f(x)中的任何单项术语来自1/(1-x^A)中的一个术语，对于某些非负义词来说，x^(a*A)看起来像a x^M，以及其他条款。自指数添加以来，系数M就是写出这样一笔总和来获得{{1}}的所有方法。

我知道这不是一个编程答案，但希望你能用这个想法编写一个程序。

Answer 2

这是一个递归解决方案：http://ideone.com/ip98M

#include <iostream>

template<size_t N>
void find_combinations_helper(int total, const int (&denoms)[N], int denoms_used, int remaining, int (&counts)[N])
{
    if (remaining == 0) {
        int partial_sum = 0;
        for( int i = 0; i < denoms_used; ++i ) {
           if (counts[i]) {
               std::cout << counts[i] << "*" << denoms[i];
               partial_sum += counts[i] * denoms[i];
               if (partial_sum < total) std::cout << " + ";
           }
        }
        std::cout << "\n";
        return;
    }

    if (denoms_used == N) return;

    for( counts[denoms_used] = 0; remaining >= 0; (remaining -= denoms[denoms_used]), ++counts[denoms_used] )
        find_combinations_helper(total, denoms, denoms_used + 1, remaining, counts);
}

template<size_t N>
void find_combinations( int total, const int (&denoms)[N] )
{
    int solutions[N];
    find_combinations_helper(total, denoms, 0, total, solutions);
}

int main(void) {
    const int bill_denoms[] = { 50, 20, 10, 5, 2 };
    find_combinations(100, bill_denoms);
}

Answer 3

只是为了好玩

#include <iostream>
#include <vector>
#include <iterator>
#include <numeric>
#include <algorithm>

static const int terms[] = { 2,5,10,20,50,   /*end marker*/0 };

using namespace std;
typedef vector  <int> Solution;
typedef vector  <Solution> Solutions;

inline int Sum(const Solution& s)
{
    return accumulate(s.begin(), s.end(), 0);
}

template <typename OutIt>
    OutIt generate(const int target, const int* term, Solution partial, OutIt out)
{
    const int cumulative = Sum(partial); // TODO optimize

    if (cumulative>target)
        return out;         // bail out, target exceeded

    if (cumulative == target)
    {
        (*out++) = partial; // report found solution
        return out;
    } else
    {
        // target not reached yet, try all terms in succession
        for (; *term && cumulative+*term<=target; term++)
        {
            partial.push_back(*term);
            out = generate(target, term, partial, out); // recursively generate till target reached
            partial.pop_back();
        }
        return out;
    }
}

Solutions generate(const int target)
{
    Solutions s;

    generate(target, terms, Solution(), back_inserter(s));

    return s;
}

void Dump(const Solution& solution)
{
    std::copy(solution.begin(), solution.end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;
}

#ifdef _TCHAR
int _tmain(int argc, _TCHAR* argv[])
#else
int main(int argc, char* argv[])
#endif
{
    Solutions all = generate(100);
    for_each(all.rbegin(), all.rend(), &Dump);
    return 0;
}

$ 0.02

为了真正回答这个问题，我删除了所有不需要的解决方案输出，大大优化了代码。它现在效率更高（我使用target=2000 以25倍的速度对其进行基准测试，但它仍然无法扩展为大型target ...

#include <iostream>
#include <vector>

using namespace std;

size_t generate(const int target, vector<int> terms)
{
    size_t count = 0;

    if (terms.back()<=target)
    {
        int largest = terms.back();
        terms.pop_back();
        int remain = target % largest;

        if (!remain)
            count += 1;

        if (!terms.empty())
            for (; remain<=target; remain+=largest)
                count += generate(remain, terms);
    }

    return count;
}

int main(int argc, char* argv[])
{
    static const int terms[] = {2,5,10,20,50};
    std::cout << "Found: " << generate(1000, vector<int>(terms, terms+5)) << std::endl;
    return 0;
}

希望更聪明的模运算开始反映PengOne关于解决这个问题的建议。

Answer 4

这看起来不对：

m[0]=2;
...
m[0]=50;

不应该是m [4] = 50;？

修改你永远不会宣布价值100，你怎么知道什么时候达到100？

Answer 5

目前您为函数add提供的代码将为您带来堆栈溢出:)因为您在修改向量add(m)之前对m进行了递归调用。因此，add始终使用未修改的向量进行调用，并且基本情况永远不会被命中。

我不知道我是否抓住了你想做的事情，但是：

#include <iostream>
#include <sstream>
#include <vector>

void add(int i, std::string s, int sum)
{
    if (sum == 100)
    {
      std::cout << s << "=100" << std::endl;
      return;
    }
    if (sum > 100)
    {
       return;
    }
    if (sum < 100)
    {
      std::ostringstream oss;
      oss << s << "+" << i;
      add(i, oss.str(), sum+i);
    }
}

int main()
{
  std::vector<int> m;

  m.resize(5);

  m[0]=2;
  m[1]=5;
  m[2]=10;
  m[3]=20;
  m[4]=50;

  // This loop will initiate m.size lines of recursive calls
  // one for each element of the array
  for (size_t i = 0; i < m.size(); i++)
  {
    add(m[i], "", 0);
  }

  return 0;
}

总结特定数字以获得100的不同方式

5 个答案: