Question

好的，所以这就是我要做的。用户输入一个数字。我正在尝试编写一个递归函数来计算总和到该数字的序列数（用户输入）。

例如：

然后总计6的序列数是11（包括6本身）。

6
5+1
4+1+1
3+1+1+1
2+1+1+1+1
1+1+1+1+1+1
2+2+1+1
3+2+1
4+2
2+2+2
3+3

我也试图不重复序列，例如2 + 2 + 1 + 1和1 + 1 + 2 + 2.

我没有包含代码的原因是我无法弄清楚这种工作的递归方式，所以我正在寻求一些指导。提前谢谢！

此外：

好的，这就是我的思考过程。 6可以拆分为......

6
5+1
4+2
3+3

但是仍然没有结束，如果你拿5 + 1并考虑+1部分完成;你使用相同的技巧继续。

4+1+1
3+2+1

然后他们开始重复.....我并没有比我的计划中的第二步更进一步。

好的代码明智这就是我自己想出来的。正在寻找解决此问题的建议。

int sum(int number, int min, int counter)
{
    int temp=0, n;
    n=number+temp;
    if (number>=(n/2)& number!=min)
    {
        while (number>=(n/2))
        {
            cout << number << "+"<< temp <<"\n";
            number --;
            temp ++;
            counter ++;
        }
    }
    sum(temp, 1,counter);
    return counter;
}

int main()
{
    int number;

    cout << "Please enter the number: ";
    cin >> number ;
    cout << "\n";

    sum(number, 1, 0);

    return 0;
}

我确实意识到这种情况已经搞砸了。

Answer 1

提示：尝试找到一个函数，该函数给出n 和不大于k 的项的序列数。

修改：
如果这听起来很刺耳，请原谅我，但是......你的更新代码都错了。很难看出你的意图。我猜，但这没有意义。

这就是我的想法：一个序列应该以非递增的顺序，如“2 2 1 1 1 1”。那么有多少这样的序列加起来有6个？好吧，找到以1开头的序列数，然后是以2开头的序列数，依此类推，最多为6，并将它们相加。有多少序列以2开头，最多加6？（这是递归的来源。）在每个这样的序列中，第一个术语是2，其余的加起来为4 ，没有术语超过2 ，所以我们必须找到的数量序列加起来4，没有大于2的项。所以首先写入签名，然后是迭代循环，然后是递归调用，你就完成了。

修改：
好吧，这是除了循环之外的一切：

int partition(int n, int max)
{
  if(n==0)
    return(0);
  int ret = 0;
  if(n<=max)
    ret=1;
  for(...)
  {
    ...
  }
  return(ret);
}

你能填空吗？

Answer 2

我认为它接近概率论集{1,2,3,4,5,6}的组合数量给出摘要6

Answer 3

这些被称为整数分区，并且有一种使用中间函数计算任何数字的分区数的简单方法。看看这里：Integer Partition。

Answer 4

设f（n）是我们想要的函数，它生成加到n的整数序列，没有排列

定义

f（n）= g（n，n）

g（n，p）= {i \ in in 1..min（n，p）：[i g（n-i，i）]}

Answer 5

将P（n）定义为分割n的方式的数量，将n限制为整数，n> = 1.

将p（n，k）定义为使用不大于k的数字来划分n的方式的数量，将k限制为整数，k> = 1，k <= n。

由此得出P（n）= sum（i：1..n）p（n，i）。

要找到p（n，k），首先请注意，我们通过简单地保持分区排序来巧妙地避免重复计算：首先获取最大的块。因此，第一个块可以具有从1到k的任何大小，然后其余的块必须考虑总n的其余部分，并且不大于第一个块。

因此p（n，k）= sum（i：1..k）p（n - i，i）。

作为基本情况，p（1,1）= 1。

示例实现，非常不保证完全有效，甚至编译（但它应该给你基本的想法） - 破坏者！

// A utility function to represent the result of appending to a vector,
// as a new vector (without affecting the previous one).
template <typename T>
vector<T> operator<<(vector<T> copy, T to_append) {
    // We passed by value to get a copy implicitly.
    copy.push_back(to_append);
    return copy;
}

// A utility function to append one vector to another.
template <typename T>
vector<T>& operator+=(vector<T>& original, const vector<T>& to_append) {
    // 'copy' is in namespace std:: and defined in <algorithm>.
    // 'back_inserter' is in namespace std:: and defined in <iterator>.
    copy(to_append.begin(), to_append.end(), back_inserter(original));
    return original;
}

vector<vector<int> > partitions(int remaining, int limit, vector<int> prefix) {
    // Finds the partitions of some larger number which start with the
    // numbers in 'prefix', such that the rest of the "chunks" sum to
    // 'remaining' and are all no larger than 'limit'.

    // 'max' is in namespace std:: and defined in <algorithm>. We restrict
    // the 'limit' to be no more than 'remaining'.
    limit = max(remaining, limit);

    vector<vector<int> > result;

    // Base case. 
    if (remaining == 1) {
        return result << (prefix << 1); // note the parentheses are required!
    }

    for (int i = limit; i > 0; --i) {
        result += partitions(remaining - i, i, prefix << i);
    }

    return result;
}

Answer 6

this question.

涵盖了该算法

试图写一个递归函数，计算总和到那个数字C ++的序列数

6 个答案: