使用嵌套循环迭代 m^n 组合[关闭]

Question

我有一个维度为n 的数组y，每个维度都有m 条目。 如何使用嵌套的 for 循环遍历所有索引组合？

我想获得所有可能的总和组合，如以下代码所示：

for (int i = 0; i < m; ++i) {

    for (int j = 0; j < m; ++j) {
        ...
        for (int k = 0; k < m; ++k) {
            z = x[0] + y[i]*x[1] + y[j]*x[2] + ... + y[k]*x[n];
        }
    }
}

     

如果使用for 循环无法做到这一点，那还能如何实现？

Answer 1

这是问题的解决方案，可能不是最佳解决方案，但说明了这个想法。由于您需要一次使用与 y 一样多的索引来索引 y，因此您需要一个数组。数组的索引将在每次迭代中递增，从第 0 个索引开始。当第 0 个索引达到 m 时，我们继续一个 1，就像正常的加法一样。当下一个索引处的整数达到 m 时，我们将 1 结转到下一个索引。当所有索引从 0 变为 m - 1 时，我们就知道我们已经完成了。 Test it in the browser if you wish.

#include <iostream>
#include <string>
#include <vector>

int main()
{
    std::vector<int> y = { 1, 2, 3 };
    std::vector<int> x = { 0, 1, 2, 3 };
    std::vector<int> indices = { 0, 0, 0 };
    int m = y.size();
    int sum = 0;
    
    int index_to_increment_next = 0;
    
    while (index_to_increment_next < m)
    {
        // sum up at current indices
        sum += x[0];
        for (int i = 0; i < m; i++)
        {
            sum += x[i + 1] * y[indices[i]]; 
        }
        
        int j;
        for (j = 0; j < m; j++)
        {
            if (indices[j] < m - 1)
            {
                // increment indices
                indices[j]++;
                break;
            }
            // when the index reaches m, reset it to 0 
            // and try to increment the next one
            indices[j] = 0;
        }
        
        // on the last iteration, this will be equal to m
        // and all of the indices will be reset back to 0
        index_to_increment_next = j;
    }
    
    std::cout << sum;
}

更新

对于每个可能的组合，我需要一个单独的总和 z = x[0] + y[i]*x[1] + y[j]*x[2] + ... + y[k]*x[ n] 其中 i,j,...k 是 n 个计数器，取值从 0 到 m。

只需在每次迭代中保存单独的总和并将它们存储在例如一个向量。 See the code.

// declare above the while
std::vector<int> sums;

// ...

int sum = x[0];
for (int i = 0; i < m; i++)
{
    sum += x[i + 1] * y[indices[i]]; 
}
sums.push_back(sum);

Answer 2

如果我正确理解你的问题，那么Daniyal Shaikh said above in a comment

您可以改用递归。它可以证明是一个更好的选择

n 个 for 循环的简单实现是： （n_counter 和 z 是全局变量）

int n_counter = 0; // which is the 1,2,3 of your y[i]*x[**1**]
int z = x[0];      // all possible combinations of sums at every iteration

void recursion(int n, int m){
   n_counter++;
   for(int i=0 ; i<m ; i++){
      z += y[i]*x[n_counter];
   }

   if(n_counter<=n){ // go deeper n times, which is equal to n for-loops
      recursion(n, m);
   }

   return;
}

每次我们深入递归时，n_counter 都会增加，因为我们需要增加的数字。

例如数字 2：“.. + y[j]*x[2] + ..”。

最后，您所要做的就是打印 z。