用迭代方法计算最大相互独立的节点集

Question

我们从一棵 n 叉树开始。 每个分支代表“依赖”（即父母依赖于孩子）。 我需要找到相互独立节点的最大和。

递归解决方案相当简单：

int calc_max()
{
    int child_max = 0;
    foreach (var n in nodes)
    {
        child_max += n.calc_max();
    }

    return Math.Max(this.value, child_max);
}

现在我很难为此提供非递归解决方案。 这将需要后序遍历。 此处已经回答了二叉树的迭代后顺序。 但即使使用该解决方案，我也无法从该解决方案中删除递归。

Answer 1

我有一些 SO 答案展示了如何将算法的任何递归表达式转换为非递归表达式。

让我们再做一次。

我将使用 C 因为它更清楚地用于此目的：

int calc_max(NODE *node) {
  int child_sum = 0;
  for (int i = 0; i < node->n_children; ++i) 
    child_sum += calc_max(node->children[i]);
  return MAX(node->value, child_sum);
}

现在使用显式堆栈模拟递归调用，该堆栈是一个充当“返回寄存器”的变量，并goto以模拟call和return指令执行的跳转。 为了清楚起见，让一些东西在伪代码中。

int calc_max(NODE *node) {
  int rtn_val; // Simulated register for function return value.
 start:
  int child_sum = 0;
  for (int i = 0; i < node->n_children; ++i) {
    <<save params and locals on frame stack>>
    node = node->children[i];
    goto start;
   rtn:
    child_sum += rtn_val;
  }
  // Simulate using a register to return a result.
  int rtn_val = MAX(node->value, child_sum);
  if (<<frame stack isn't empty>>) {
    <<restore params and locals from frame stack>>
    goto rtn;
  }
  return rtn_val;
}

需要保存的参数和局部变量是node 、 i和child_sum 。 这样我们就可以填写伪代码了。

typedef struct node {
  struct node *children[8];
  int n_children, value;
} NODE;

#define MAX(A, B) ((A) > (B) ? A : B)

int calc_max(NODE *node) {
  int i, child_sum, rtn_val, sp = 0;
  struct stack_frame {
    NODE *node;
    int i, child_sum;
  } stk[1000];
 start:
  child_sum = 0;
  for (i = 0; i < node->n_children; ++i) {
    stk[sp++] = (struct stack_frame){.node = node, .i = i, .child_sum = child_sum};
    node = node->children[i];
    goto start;
   rtn:
    child_sum += rtn_val;
  }
  rtn_val = MAX(node->value, child_sum);
  if (sp > 0) {
    --sp;
    node = stk[sp].node;
    i = stk[sp].i;
    child_sum = stk[sp].child_sum;
    goto rtn;
  }
  return rtn_val;
}

这应该可以正常工作。 我还没有测试过。 goto不是很漂亮，但是如果你愿意，可以通过一些代数将它们变成while或for循环。 以下是步骤。

将for循环更改为while并将 rtn 之后的语句移动到goto rtn rtn执行。 然后rtn本身可以在while之前移动：

int calc_max(NODE *node) {
  int i, child_sum, rtn_val, sp = 0;
  struct stack_frame {
    NODE *node;
    int i, child_sum;
  } stk[1000];
 start:
  i = child_sum = 0;
 rtn:
  while (i < node->n_children) {
    stk[sp++] = (struct stack_frame){.node = node, .i = i, .child_sum = child_sum};
    node = node->children[i];
    goto start;
  }
  rtn_val = MAX(node->value, child_sum);
  if (sp > 0) {
    --sp;
    node = stk[sp].node;
    i = stk[sp].i;
    child_sum = stk[sp].child_sum;
    child_sum += rtn_val;
    ++i;
    goto rtn;
  }
  return rtn_val;
}

现在通过复制i = child_sum = 0 rtn可以将goto start的目标移动到 rtn 。

int calc_max(NODE *node) {
  int i, child_sum, rtn_val, sp = 0;
  struct stack_frame {
    NODE *node;
    int i, child_sum;
  } stk[1000];
  i = child_sum = 0;
 rtn:
  while (i < node->n_children) {
    stk[sp++] = (struct stack_frame){.node = node, .i = i, .child_sum = child_sum};
    node = node->children[i];
    i = child_sum = 0;
    goto rtn;
  }
  rtn_val = MAX(node->value, child_sum);
  if (sp > 0) {
    --sp;
    node = stk[sp].node;
    i = stk[sp].i;
    child_sum = stk[sp].child_sum;
    child_sum += rtn_val;
    ++i;
    goto rtn;
  }
  return rtn_val;
}

现在注意第一个goto rtn可以去掉。 没有它， while循环会做同样的事情：

int calc_max(NODE *node) {
  int i, child_sum, rtn_val, sp = 0;
  struct stack_frame {
    NODE *node;
    int i, child_sum;
  } stk[1000];
  i = child_sum = 0;
 rtn:
  while (i < node->n_children) {
    stk[sp++] = (struct stack_frame){.node = node, .i = i, .child_sum = child_sum};
    node = node->children[i];
    i = child_sum = 0;
  }
  rtn_val = MAX(node->value, child_sum);
  if (sp > 0) {
    --sp;
    node = stk[sp].node;
    i = stk[sp].i;
    child_sum = stk[sp].child_sum;
    child_sum += rtn_val;
    ++i;
    goto rtn;
  }
  return rtn_val;
}

最后我们可以用一个无限循环替换最后一个goto rtn rtn，我们从 function return （跳出循环），除非goto rtn会循环：

int calc_max(NODE *node) {
  int i, child_sum, rtn_val, sp;
  struct stack_frame {
    NODE *node;
    int i, child_sum;
  } stk[1000];

  sp = i = child_sum = 0;
  while (1) {
    while (i < node->n_children) {
      stk[sp++] = (struct stack_frame){.node = node, .i = i, .child_sum = child_sum};
      node = node->children[i];
      i = child_sum = 0;
    }
    rtn_val = MAX(node->value, child_sum);
    if (sp <= 0) return rtn_val;
    node = stk[--sp].node;
    i = stk[sp].i + 1;
    child_sum = stk[sp].child_sum + rtn_val;
  }
}

在此过程中，我可能很容易犯错。 我手头没有编译器来做任何测试。 但是基本的想法是合理的，结果应该是相当有效的。 它编译为 33 条 x86 指令。

在你完成了其中的一些之后，摆脱goto的代数技巧就会陷入模式。 但是有通用的自动算法可以做同样的事情。 构建一个可以自动执行此转换的工具将相当简单。

现在goto已经消失了，您可以翻译回您选择的语言。

这种方法的好处是你不需要弄明白特定算法的操作语义。 只需从递归表达式开始并模拟编译器所做的事情，然后用代数转换以获得看起来不错的形式。 除了愚蠢的错误，它必须工作。