寻找解决这个动态规划问题的提示

Question

我正在努力提高我在编程面试中解决问题的能力，并正在努力解决this problem。我感觉可以使用动态编程来解决，但递归关系对我来说并不明显。

要选择前三位合唱歌手，我只是使用蛮力。因为只有20 Choose 3 = 1140 可以选择它们。起初我以为dp[a][b][c]可以代表三个合唱团歌手剩余呼吸的最短歌曲a, b, c。如果我可以使用dp[a][b][c] = 1 + dp[a - 1][b - 1][c - 1] 计算这个值，但是当任何索引等于0 时应该做什么，应该替换哪个合唱团歌手。此外，我们不能重用dp 数组，因为在一个例子中我们从有呼吸的合唱团歌手开始a, b, c，然后是d, e, f。一旦计算了第一个实例并填充了 dp 数组；第二个实例可能需要使用第一个实例计算的dp[i][j][k]。由于此值取决于第一个实例中可用的合唱团歌手，并且两个实例中可用的歌手不一样，dp[i][j][k] 在第二个实例中可能是不可能的。这是因为最短的歌曲长度dp[i][j][k] 可能使用合唱团歌手，而合唱团歌手在第二种情况下已经被使用。

我没有解决这个问题的想法，也没有任何解决方案。有人可以给我一些提示来解决它吗？

问题陈述

我们有N歌手，每个人都有一定的时间可以唱歌，一旦气喘吁吁需要1秒恢复。他们能唱的最低限度的歌曲是多少，三位歌手一直在唱，三位歌手同时唱完的歌曲是多少？

输入：

输入 3

Answer 1

这就是想法。

在演唱的每一点，当前状态可以通过歌手是谁、他们演唱了多长时间以及哪些人目前已经气喘吁吁来代表。而从每一个状态我们都需要过渡到一个新的状态，也就是每一个上气不接下气的歌手都准备好再唱一次，每一个歌手唱的都好少转一圈，可能会选择新的歌手。

天真地完成了，最多有 20 个选择 3 个歌手，每个歌手可以处于 10 个当前状态，再加上最多 2 个气喘吁吁的人。这是您可以处于的 175560000 个组合状态。这太多了，我们需要更聪明才能完成这项工作。

更聪明的是，我们确实没有有 20 位可区分的歌手。根据歌手能唱多长时间，我们有 10 位歌手。如果一个歌手可以唱 7 圈，那么他们不可能处于 10 种状态，而现在只能唱 7 圈。我们确实不关心两个人能否唱 7 圈转在 4 和 3 左转或 3 和 4，它们是相同的。这引入了很多对称性。一旦我们处理好所有的对称性，就会将我们可能处于的可能状态的数量从数亿减少到（通常）数万。

现在我们的 DP 有一个状态转换，从 dp[state1] 到 dp[state2]。挑战在于生成利用这些对称性的状态表示，您可以将其用作数据结构的键。

更新：

代码的主循环看起来像这样 Python：

while not finished:
    song_length += 1
    next_states = set()
    for state in current_states:
        for next_state in transitions(state):
            if is_finished(next_state):
                finished = True # Could break out of loops here
            else:
                next_states.add(next_state)
    current_states = next_states

大部分挑战是很好地表示一个状态，以及你的transitions 函数。

Answer 2

在记忆方面的状态似乎与自开始以来经过的时间无关。采取任何起始位置，

a, b, c

其中a, b, c 是选定的幅度（每个歌手可以屏住呼吸的时间），a 是最小的幅度。我们有

a, b, c
t = 0

和它一样：

0, b - a, c - a
t = a

所以让我们定义具有最小幅度的初始状态a 为：

b, c, ba, ca
  where ba = b - a
        ca = c - a
t = a

从这里开始，状态的每一次转换都是相似的：

new_a <- x
  where x is a magnitude in
  the list that can be available
  together with b and c. (We only
  need to try each such unique
  magnitude once during this
  iteration. We must also prevent
  a singer from repeating.)

  let m = min(new_a, ba, ca)

  then the new state is:
    u, v, um, vm
    t = t + m
      where u and v are from the
      elements of [new_a, b, c] that
      aren't associated with m, and um
      and vm are their pairs from
      [new_a, ba, ca] that aren't m,
      subtracted by m.

已访问组合的记忆状态只能是：

[(b, ba), (c, ca)] sorted by
the tuples' first element

如果到达的关联t 等于或高于该状态下看到的最小值，我们可以使用它修剪搜索中的分支。

例子：

2 4 7 6 5

解决方案（自上而下阅读）：

4 5 6
7 4 5
  2

州：

u v um vm
5 6 1 2
t = 4

new_a = 7
m = min(7, 1, 2) = 1 (associated with 5)
7 6 6 1
t = 5

new_a = 4
m = min(4, 6, 1) = 1 (associated with 6)
4 7 3 5
t = 6

new_a = 5
m = min(5, 3, 5) = 3 (associated with 4)
5 7 2 2
t = 9

new_a = 2
m = min(2, 2, 2) = 2 (associated with 2)
5 7 0 0
t = 11

Python 代码：

import heapq
from itertools import combinations

def f(A):
  mag_counts = {}

  for x in A:
    if x in mag_counts:
      mag_counts[x] = mag_counts[x] + 1
    else:
      mag_counts[x] = 1

  q = []

  seen = set()

  # Initialise the queue with unique starting combinations
  for comb in combinations(A, 3):
    sorted_comb = tuple(sorted(comb))
    if not sorted_comb in seen:
      (a, b, c) = sorted_comb
      heapq.heappush(q, (a, (b-a, b), (c-a, c), a))
    seen.add(sorted_comb)

  while q:
    (t, (ba, b), (ca, c), prev) = heapq.heappop(q)

    if ba == 0 and ca == 0:
      return t

    for mag in mag_counts.keys():
      # Check that the magnitude is available
      # and the same singer is not repeating.
      [three, two] = [3, 2] if mag != prev else [4, 3]
      if mag == b == c and mag_counts[mag] < three:
        continue
      elif mag == b and mag_counts[mag] < two:
        continue
      elif mag == c and mag_counts[mag] < two:
        continue
      elif mag == prev and mag_counts[mag] < 2:
        continue

      m = min(mag, ba, ca)

      if m == mag:
        heapq.heappush(q, (t + m, (ba-m, b), (ca-m, c), m))
      elif m == ba:
        heapq.heappush(q, (t + m, (mag-m, mag), (ca-m, c), b))
      else:
        heapq.heappush(q, (t + m, (mag-m, mag), (ba-m, b), c))

  return float('inf')

As = [
  [3, 2, 3, 3], # 3
  [1, 2, 3, 2, 4], # 3
  [2, 4, 7, 6, 5] # 11
]

for A in As:
  print A, f(A)