动态编程 - 4 键键盘

Question

假设您有一个带有以下键的特殊键盘：

键 1：(A)：在屏幕上打印一个“A”。

键 2：（Ctrl-A）：选择整个屏幕。

键 3：（Ctrl-C）：将选择复制到缓冲区。

键 4：（Ctrl-V）：在屏幕上打印缓冲区，将其附加在已完成的内容之后 已经打印出来了。

现在，你只能按键盘N次（以上四次 键），找出您可以在屏幕上打印的“A”的最大数量。

示例 1：

输入：N = 3

输出：3

说明：我们最多可以通过按以下键序列在屏幕上获得3个A：A, A, A

示例 2：
输入：N = 7

输出：9

说明：我们最多可以通过按以下键序列在屏幕上获得 9 个 A：A, A, A, Ctrl A, Ctrl C, Ctrl V, Ctrl V

（免责声明：我不想听到不同的解决方案。我只想了解我缺少什么以及如何解决它。）

这是我当前的（不正确的）解决方案（解释如下）：

class Solution:
    def maxA(self, N):
        screen = [0] * N
        screen[0] = 1
        applied_clipboard = clipboard = select = 0        
        for i in range(1, N):
            if i < 3:
                screen[i] = screen[i-1] + 1
            else:
                screen[i] = max(screen[i-3] + clipboard, screen[i-1] + 1, screen[i-1] + applied_clipboard)

                if screen[i] == screen[i-3] + clipboard:
                    applied_clipboard = clipboard

            select, clipboard = max(select, screen[i-1]), max(clipboard, select)
        return screen[-1]

如您在上面的代码中所见，我正在跟踪一些状态。状态是：

1. 我选择了多少个字符？
2. 我在屏幕上打印了多少个字符？
3. 我的剪贴板中有多少个字符？
4. 我实际应用的最新剪贴板是什么？

有了这些状态，我相信我可以在每一步做出最佳决策。

但是，我的代码不正确。对于N = 11的输入，我的代码返回27，正确值为27。但是，对于N=9 和N=10，正确的值是16 和20（分别），但我得到15 和18（分别）。

有人看到我更新状态的方式中的错误吗？

编辑。回应现有答案： 我知道我的状态更新可能不完整，但问题是在哪里。我的想法是保持每个状态最大化，因为有一系列单独的决策来最大化每个状态。然后，使用所有这些信息来更新下一次迭代中的状态。

重写了我的代码以保留每个部分的状态。

class Solution:
    def maxA(self, N):
        screen = [0] * N
        screen[0] = 1
        applied_clipboard, clipboard, select = [[0] * N for _ in range(3)]

        for i in range(1, N):
            if i < 3:
                screen[i] = screen[i-1] + 1
            else:
                screen[i] = max(screen[i-3] + clipboard[i-1], screen[i-1] + 1, screen[i-1] + applied_clipboard[i-1])

                if screen[i] == screen[i-3] + clipboard[i-1]:
                    applied_clipboard[i] = clipboard[i-1]
                else:
                    applied_clipboard[i] = applied_clipboard[i-1]

            select[i] = max(select[i-1], screen[i-1])
            clipboard[i] = max(clipboard[i-1], select[i-1])

        print('screen', screen)
        print('clipboard', clipboard)
        print('applied', applied_clipboard)
        return screen[-1]

我认为我在这里感到困惑的是如何保留已应用的剪贴板值 (applied_clipboard) 与最大剪贴板状态。但我需要区分两者，因为它会影响递归关系。

感谢user3386109 引导我看到：

• N=9 的正确步骤是AAAASCVVV（总共 16 个 A）
• 我的代码，对于 N=9，输出 AAASCVVVV（总共 15 个 A）。

其中 s = 选择，c = 复制，v = 粘贴。

Answer 1

错误很简单，就是代码在每一步都在最大化屏幕上的“A”数量。如果 print screen 在函数末尾 N 为 9 时，你会看到：

[1, 2, 3, 4, 5, 6, 9, 12, 15]

请注意，当N 为 6 时，屏幕上的“A”的最大数量为 6。这可以通过三种不同的方式实现：

AAAAAA
AAscvv
AAAscv

其中 s = 选择，c = 复制，v = 粘贴。

但是，当N 是 9 时，正确答案是

AAAAscvvv

如您所见，按 6 次键后，屏幕上的“A”数量只有 4 个，而不是 6 个。因此，在每个步骤中最大化屏幕上的“A”数量并不能给出正确答案。

Answer 2

一种思考方式可能是我们的解决方案必须以paste 结尾，因为显然我们不希望以select 或copy 结尾来浪费印刷机。然后我们可以假设我们要选择粘贴的屏幕状态是最佳的（否则，我们为什么要从它粘贴？）。

让f(n) 表示可能输出的As 的最大数量。然后我们可以选择重复应用任何屏幕状态返回三个或更多按键。例如，在第 7 次按下时，我们可以回顾并说：要重复屏幕状态 4（只有 4 次），我们需要 3 次按下，因此从 4 开始重复将提供我们的记录 7, 4 + 4 = 8 As .如果我们尝试从 3 开始重复，我们需要按 3 次重复 1 次，使我们达到 6，我们仍然可以再多 1 次，所以 3 + 2*3 = 9。所以重复应用屏幕状态 3，提供记录对于 7 九 As，这是最好的。对于任何0 < j < i-3，我们可以得到1 + i - (j + 3) + 1 或i - j - 1 乘以jth 屏幕状态。

JavaScript 代码：

function f(n) {
  const m = [0,1,2,3,4,5,6].concat(
    new Array(Math.max(n-6,0)).fill(0));

  for (let i=7; i<=n; i++)
    for (let j=1; j<=i-3; j++)
      m[i] = Math.max(m[i], m[j]*(i-j-1));

  console.log(JSON.stringify(m));
  return m[n];
}

console.log(4, f(4));
console.log(7, f(7));
console.log(9, f(9));
console.log(10, f(10));
console.log(11, f(11));

检查数据，我发现要从中复制的最佳屏幕状态似乎始终非常接近n（在 6 个状态之内），并且在向后遍历时似乎始终是凸的，这意味着我们可以通过向后遍历和查看来优化向下变化。

如果这种行为是一致的，则意味着该算法具有O(n) 复杂度。

function f(n) {
  const m = [0,1,2,3,4,5,6].concat(
    new Array(Math.max(n-6,0)).fill(0));

  for (let i=7; i<=n; i++){
    let prev = 0;
    for (let j=i-3; j>0; j--){
      let curr = m[j]*(i-j-1);
      if (curr < prev){
        console.log(`Early exit. n: ${n}, i: ${i}, j: ${j}`);
        break;
      }
      prev = curr;
      m[i] = Math.max(m[i], curr);
    }
  }

  console.log(JSON.stringify(m));
  return m[n];
}

console.log(50, f(50));

Answer 3

据我所知（现在我已将代码更改为可运行），您可以正常更新内容。我怀疑问题出在不完整的状态更新上。不幸的是，我认为你的实现是正确的，但是你的算法是错误的。

我认为您的问题在于 screen 更新每次迭代都会使您的长期目标短路。在每次迭代中，您都会处理选择，就好像这次按键必须是您的最后一次一样。因此，您有时会放弃具有更大潜力的剪贴板，并仅使用在此步骤中最能获得As 的内容进行更新。

你需要为每一步保持多个有用的状态：不仅是最大的屏幕显示，还有一个丰富的剪贴板的潜力。

更新 我想我们现在的想法是一致的。您需要为每个击键数量存储多个状态 - 部分解决方案。这不是一个简单的递归关系：它更像是一种量子态。

例如，在 7 次击键时，您至少需要表示两种状态。

• 由于 AAAASCV，屏幕上有 8 个 As，剪贴板中有 4 个。 (8, 4)
• 由于 AAASCVV，屏幕上有 9 个As，剪贴板中有 3 个。 (9, 3)

您当前的算法对于每个击键次数只允许screen 和clipboard 各有一个值。它只保留具有最佳短期结果的解决方案。它错过了 (8,4) 将成为 9 和 10 击键更好的垫脚石。

你需要保留每一步没有被支配的所有对。当G(screen) >= H(screen) 和 G(clipboard) >= H(clipboard).

时，状态G“支配”状态H

---

另外请注意，您需要在您的状态中有一个较少使用的元素：当前选择的内容。例如，考虑上述两种状态的情况（用于说明），一笔（粘贴）更远，另一笔“提前计划”：

scr   clip   sel
12      4     0          Nothing selected
12      3     0          Nothing selected
 9      3     9          Stopped at 9 A's and did a select-copy

这第三个状态将立即超过前两个状态另外两个步骤。