使嵌套 for 循环算法 - 动态

Question

我有一个类似这样的算法：

对于 m = 1 到 2 初始化（工作项（m）） 对于 l = 1 到 2 初始化（工作项（l）） 对于 k = 1 到 2 初始化（工作项（k）） 对于 j = 1 到 2 初始化（工作项（j）） 对于 i = 1 到 2 初始化(work_item(i)) doSomething(work_item(i)) 下一个 做某事（工作项目（j）） 下一个 做某事（工作项目（k）） 下一个 做某事（工作项目（l）） 下一个 doSomething(work_item(m)) 下一个

如何迭代地编写它，使其动态化，这样我就不会将自己限制在固定数量的 for 循环 (i, j, k, l, m) 中（即我可以执行 (i) 或 ( i, j) or (i, j, k) or (i, j, k, l) etc...)?

（我严格要求用动态的、迭代的解决方案来回答。如果你不明白这一点，请继续阅读，从上一句开始。）

Answer 1

完全按照使用递归的方式编写算法，但使用显式堆栈对象而不是递归。即：

var stack = new Stack();
stack.Push(InitialThingy);
while(stack.Count != 0)
{
    var currentItem = stack.Pop();
    //Do things to current item and add things to stack as we go.
}

Answer 2

private sub doStuff(depth as integer)
    for i as integer = 1 to 2
        initialize(work_item(i))
        if depth > 1 then doStuff(depth - 1)
        doSomething(work_item(i))
    next
end sub

比您想出的任何迭代解决方案都更优雅、更短、更简单。你想给我投反对票，但这并不会降低它的真实性。

Answer 3

你可能想要recursion。

Answer 4

我会赞成 deinst 的解决方案，但我是新手，没有 15 个代表......在跟踪每个算法之后，我相信 deinst 具有正确的动态迭代方法。然而，deinst 在开始时一次性初始化所有，而 roygbiv 在循环嵌套中重复初始化。 （我想我之前看过正确的 deinst 编辑。）

Answer 5

您需要跟踪depth 变量，其中depth 是嵌套的总深度。您可以为此使用数组或堆栈，也可以使用递归的强大功能，一次只分配一个局部变量

function doEverything(depth) {
  if (depth == 0) return;

  var i; // a new local variable on each call
  for i = 1 to 2 {
    initialize(work_item(i));
    doEverything(depth-1);
    doSomething(work_item(i));
  }
}

由于i,j,k,... 的范围从 1 到 2，因此也可以将它们解释为单个整数变量的位。

请注意，您的嵌套循环总共执行 2^depth 操作。

Answer 6

调用变量 i[0] ... i[n] 将它们全部初始化为 1。要在每一步递增

int j, k;
for(j = n - 1; j >= 0; j--){
  initialize(i[j]);
}

while (true) {
  j = 0;
  while (i[j] == 2) {
    doSomething(i[j]);
    j++;
  }
  if (j < n) {
    doSomething(i[j]);
  } else {
    break;
  }
  for (j = 0; j < n; j++) {
     if (i[j] == 1) {
       i[j] = 2;
       break;
     }
     else {
       i[j] = 1;
     }
  }
  if (j == n) break;
  for (k = j; k >= 0; k--) {
    initialize(i[k]);
  }
}

本质上，您正在实现一个二进制计数器，清除所有设置位小于第一个清除位，然后设置第一个清除位。这将以与给定循环相同的顺序运行执行操作。

你可以用不同的范围做类似的事情，每个 i[j] 的范围甚至不必相同。

编辑添加了初始化。

注意 递归在这里可能有点过头了，并且比平面实现的灵活性稍差（考虑从内部循环中止。）。这是一个在实践中经常出现的问题，并不是那么复杂。我们想要做的是让每个循环看起来像

for i = 1 to 2
   do beginning stuff with i
   do inner loop
   do ending stuff with i
next

如果我们只考虑索引变量，我们就会得到看起来像二进制计数器的东西。如果我们在执行最内层循环时查看索引变量的值。

 i j k l
 1 1 1 1
 1 1 1 2
 1 1 2 1

实现一个计数器很容易。如果我们只是标记我们的变量，首先是最里面的，这样i -> i[3]、j -> i[2]、k -> i[1] 和l -> [0] 那么单个递增步骤包括

j = 0
while i[j] == 2
  i[j] = 1
  j++
if j == maxindex
  break out, we're done with all the loops
else
  i[j] = 2

现在，让我们在循环结束时做一些事情。这很容易，循环结束发生在我们递增之前。所以我们的增量器看起来像

j = 0
while i[j] == 2
  do ending stuff with i[j]
  i[j] = 1
  j++
if j == maxindex
  break out, we're done with all the loops
else
  do ending stuff with i[j]
  i[j] = 2

现在，棘手的部分。乍一看，我们只是在递增之后才开始做一些事情，但这有两个问题。

1. 它错过了初始增量（当我们将初始变量设置为 1 时发生的增量
2. 它为最终增量中的所有内容调用初始增量例程。

（这些本质上是同一个问题）

第一个的解决方案很简单，我们只是在主循环之外调用开始的东西。

for j = maxindex - 1 downto 0
  do beginning stuff with i[j]
while true
  j = 0
  while i[j] == 2
    do ending stuff with i[j]
    i[j] = 1
    j++
  if j == maxindex
    break out, we're done with all the loops
  else
    do ending stuff with i[j]
    i[j] = 2

现在要在增加计数后获取其他初始化程序。

for j = maxindex - 1 downto 0
  do beginning stuff with i[j]
while true
  j = 0
  while i[j] == 2
    do ending stuff with i[j]
    i[j] = 1
    j++
  if j == maxindex
    break out, we're done with all the loops
  else
    do ending stuff with i[j]
    i[j] = 2
  for k = j downto 0
    do beginning stuff with i[k]

与嵌套循环版本相比，这不会产生任何开销（调用堆栈等）。它可以很容易地从巢穴深处中止。这有点棘手，但如果它比具有显式堆栈的递归版本更复杂，我会感到惊讶。 De gustibus non disputandum est.

Answer 7

void doStuff(int depth)
{
    int i[depth];
    int sp = depth - 1;
    i[sp] = 0;

    while (1)
    {
        if (++i[sp] <= 2)              // "next".  This is why we init to 0.
        {                              // At this point, i[sp] is 1 or 2.
            // init item i[sp];

            if (sp)                    // If there's space to nest another loop
            {
                i[--sp] = 0;           // Push a 0
                continue;              // Start iterating with the new 0 as TOS
            }
        } 
        else if (++sp >= depth)        // Here, i[sp] is 3.  Leave the inner loop
            break;                     // and exit if stack's now empty

        // use item i[sp];
    }
}

仍然比递归更棘手。除非万不得已，否则不要使用它。

Answer 8

您可以构造一个序列集合，其中每个序列都是循环变量 i、j、k、...的排列。

一旦你有了这个集合，你就可以迭代：

foreach (var seq in myCollection)
{
  initialize(seq[0]);
  initialize(seq[1]);
  initialize(seq[2]);
  ...
  doSomething(...);
}

一种通过 LINQ 生成序列集合的方法，由 Eric Lippert 提供：

static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences) 
{ 
  IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() }; 
  return sequences.Aggregate( 
    emptyProduct, 
    (accumulator, sequence) =>  
      from accseq in accumulator  
      from item in sequence  
      select accseq.Concat(new[] {item}));                
}

您传递任意长度的序列 {{1,2},{1,2},...{1,2}}，其中每个内部 {1,2} 序列替换您的循环变量之一，并且你会得到所有值排列的序列。

Answer 9

您的问题归结为变量n 集合数的排列问题的解决方案。这可以通过递归来解决（Python）：

a = ('ab', 'AB', '12')

def permutate(a, s='', nLevel=0):
    aResult = []
    if nLevel < len(a):
        for n in range(0, len(a[nLevel])):
            aResult += permutate(a, s + a[nLevel][n], nLevel + 1)
    else:
       aResult = [s]

    return aResult

print(permutate(a))

生产：

['aA1', 'aA2', 'aB1', 'aB2', 'bA1', 'bA2', 'bB1', 'bB2']