Question

我正在尝试编写一个递归函数来实现n个嵌套的for循环，其中n在运行时决定，这给了我所有可能的数字1-x的组合。因此，对于x = 3，这将是

我希望每个单个排列都保存到向量中。我已经找到了许多关于如何将嵌套for循环实现为递归函数的答案，但是没有一个产生我想要的结果。然后一些答案只适用于硬编码量的for循环，我无法动态工作（数字在运行时决定）。然后是一些答案，其中一个排列只有每个数字中的一个，我不想要（我还需要像2-2-2或3-3-3这样的排列）。这似乎是一个简单的问题，但我无法弄清楚。任何帮助都会受到极大的赞赏

Answer 1

我认为这应该可以解决问题：

#include <iostream>
#include <vector>

void getPerm(int from, int to, std::vector<int>& curr, std::vector<std::vector<int>>& result) {
    bool alreadySetToOne  = false;
    int  nextFrom = 0;
    if (curr.size() == to) {
        result.push_back(curr);
        return;
    }

    if (from > 1 && !alreadySetToOne) {
        from = 1;
        alreadySetToOne = true;
    }

    for (int i=from; i <= to; ++i) {
        curr.push_back(i);
        getPerm(i, to, curr, result);
        curr.pop_back();
    }
}

int main() {
    auto n = 0;
    std::vector<std::vector<int>> results;
    std::vector<int> curr;
    std::cout << "Put number ...\n";
    std::cin >> n;
    getPerm(1, n, curr, results);


    //Check results
    for (int i=0; i < results.size(); ++i) {
        for (int j = 0; j < results[i].size(); ++j) {
            std::cout << results[i][j] << ", ";
        }
        std::cout << std::endl;
    }
}

只需使用第一个和最后一个数字来生成序列，并且在每次递归中只迭代第一个中的n个数字。

Answer 2

void Foo(vector<vector<int>>& list, const int& n)
{
    if(list.empty())
    {
        list.push_back(vector<int>(n,1));
        return Foo(list,n);
    }

    vector<int> entry(list.back());
    for(int i=n-1; i>=0; i--)
    {
        if(entry.at(i) < n)
        {
            entry[i]++;
            list.push_back(entry);

            return Foo(list,n);
        }

        entry[i] = 1;
    }
}

// test case
vector<vector<int>> list;
Foo(list,3);

如果为空，这将初始化一个大小为n的向量为1。然后每次迭代它将克隆最后一个条目并将索引从最小到最重要循环，如果小于n则递增，并递归或重置为1并继续下一个最重要的指数，直到它完成。

递归嵌套for循环以在运行时实现特定的Permutations

2 个答案: