Question

我最近遇到了一个问题。我必须找到从多维数组整数的左上角到右下角的路径的开销。该路径的成本必须是不超过某个提供值的最大成本。

路径的成本定义为此路径经过的数组索引的值的总和。每条路径的起点始终是左上角，每条路径的末端始终是右下角。此外，您只能向右或向下行进。

假设这是我将用于此问题的多维数组，并且提供的值为12.

+---+---+---+
| 0 | 2 | 5 |
+---+---+---+
| 1 | 1 | 3 |
+---+---+---+
| 2 | 1 | 1 |
+---+---+---+

这是我应该找到的正确路径。此路径的成本为11，它是任何低于或等于给定值的路径的最高成本。

+---+---+---+
| X | X | X |
+---+---+---+
| 1 | 1 | X |
+---+---+---+
| 2 | 1 | X |
+---+---+---+

我试图在Python中解决这个问题，但我看不出我出错的地方。以下是我的代码的一部分。

def answer (food, grid):

    # Grid is N*N in size
    n = len(grid)

    # Memoize a given function
    def memoize (f):
        memo = {}
        def helper (r, c, k):
            i = c + (r * n)
            if i not in memo:
                memo[i] = f(r, c, k)
            return memo[i]
        return helper

    # Get cost function
    def get_cost (r, c, k):

        if r >= n or c >= n:
            return -1
        if k < grid[r][c]:
            return -1
        if r == n - 1 and c == n - 1:
            return grid[r][c]

        down = get_cost(r + 1, c, k - grid[r][c])
        right = get_cost(r, c + 1, k - grid[r][c])

        if down < 0 and right < 0:
            return -1

        return grid[r][c] + max(down, right)

    # Memoize the get cost function
    get_cost = memoize(get_cost)

    return get_cost(0, 0, food)

print answer (12, [[0, 2, 5], [1, 1, 3], [2, 1, 1]])

我总是得到16的答案，我应该得到11的答案。任何人都可以帮助我吗？

编辑：

我更改了memoize代码，以在索引中包含给定的食物值。我得到了正确的答案。但是，还有其他情况不起作用。（在这些情况下我没有提供输入，所以我看不出它出错了。）

这是我更新的代码。

# Memoize a given function
    def memoize (f):
        memo = {}
        def helper (r, c, k):
            i = (k * food) + (c + (r * n))
            if i not in memo:
                memo[i] = f(r, c, k)
            return memo[i]
        return helper

Answer 1

您可以将memoize功能更新为：

def memoize (f):
    memo = {}
    def helper(*args):
        if args not in memo:
            memo[args] = f(*args)
        return memo[args]
    return helper

grid = [[0,2,5],[1,1,3],[2,1,1]]
answer(12, grid)
# 11

只要您的参数是可清除的，您就可以使用*args作为函数的参数，并使用args作为memoization缓存的关键字。这与使用参数元组作为键相同。

def fn(*args):
    print(args)

fn(1,2,3)
(1, 2, 3)

由i = c + (r * n)组成的原始记忆缓存密钥排除在考虑k之外，并且还允许针对不同的c和r组合进行可能的冲突。

Answer 2

我想使用回溯分享不同的方法：

def find_path(food, grid):

    n = len(grid)

    def worker(cost, path):
        row, col = path[-1]
        if row == n - 1 and col == n - 1:
            # we reached the bottom right corner, exit now
            return cost, path

        possible_paths = []
        if row < n - 1:
            # we can go down
            cost_down = cost + grid[row+1][col]
            path_down = list(path)
            path_down.append((row+1, col))
            possible_paths.append(worker(cost_down, path_down))
        if col < n - 1:
            # we can go to the right
            cost_right = cost + grid[row][col+1]
            path_right = list(path)
            path_right.append((row, col+1))
            possible_paths.append(worker(cost_right, path_right))

        # a path is valid, if its cost is
        # less or equal to the food available
        valid_paths = [item for item in possible_paths
                       if item is not None
                       and item[0] <= food]

        if valid_paths:
            return max(valid_paths, key=lambda x: x[0])

        return None

    return worker(grid[0][0], [(0, 0)])

算法以递归方式遍历数组并继续查找所有可能的路径。如果路径成本高于限制（food），则将其丢弃;否则每一个可能的下一步都在尝试中。当到达右下角时，worker函数终止并且正在比较不同的路径。

这样也可以检测到没有任何可能路径的数组：

print(find_path(12, [[0, 2, 5],
                     [1, 1, 3],
                     [2, 1, 1]]))
# (11, [(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)])

print(find_path(12, [[0, 2, 5],
                     [1, 1, 3],
                     [2, 1, 10]]))
# None

print(find_path(42, [[3, 8, 6, 5],
                     [1, 5, 3, 9],
                     [1, 5, 8, 1],
                     [2, 1, 9, 4]]))
# (42, [(0, 0), (0, 1), (1, 1), (2, 1), (2, 2), (3, 2), (3, 3)])

查找最接近给定值的路径旅行成本

2 个答案: