LeetCode 47. 礼物的最大价值【Python】

文章发布且更新于个人博客：https://www.xerrors.fun/leetcode/li-wu-de-zui-da-jie-zhi-lcof/

1. 题目

在一个 m * n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

链接：https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof

输入: 
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 12
解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物

2. 解题步骤

动态规划

能采用动态规划求解的问题的一般要具有3个性质：

1. 最优化原理：如果问题的最优解所包含的子问题的解也是最优的，就称该问题具有最优子结构，即满足最优化原理。

2. 无后效性：即某阶段状态一旦确定，就不受这个状态以后决策的影响。也就是说，某状态以后的过程不会影响以前的状态，只与当前状态有关。

3. 有重叠子问题：即子问题之间是不独立的，一个子问题在下一阶段决策中可能被多次使用到。（该性质并不是动态规划适用的必要条件，但是如果没有这条性质，动态规划算法同其他算法相比就不具备优势）

同样根据第一个原理，本题也不适用。因为在有些时候并不是得到局部最优解

是我傻了，这明显是一个很基础的动态规划的问题，子问题的划分是从起始位置开始划分的，而不是把一个节点的选择当作子问题。所以下面使用动态规划来解决这个问题。

首先是需要知道动态规划的状态转移方程。

V[i][j] = max(V[i-1][j], V[i][j-1]) + grid[i][j]

然后几行代码解决问题

class Solution:
    def maxValue(self, grid: List[List[int]]) -> int:
        m,n = len(grid),len(grid[0])
        v = [ [0] * (n+1) for k in range(m+1)]
        for i in range(1, m+1):
            for j in range(1, n+1):
                v[i][j] += max(v[i][j-1], v[i-1][j]) + grid[i-1][j-1]
        return v[-1][-1]

参考：五大常用算法之二：动态规划算法

3. 走过的坑

下面是我的尝试的其他办法（现在看看，弱智一样）

贪心算法

PS：这么明显的动态规划问题，我也不晓得为啥最先想到的是贪心算法，而且在后面还顺便断了我的动态规划的念头。

判断当前情况的最优解

class Solution:
    def maxValue(self, grid: List[List[int]]) -> int:
        maxVal = grid[0][0]
        m = len(grid)
        n = len(grid[0])
        i, j = 0, 0
        while True:
            if i == m-1:
                while j < n-1:
                    maxVal += grid[i][j+1]
                    j += 1
                return maxVal
            elif j == n-1:
                while i < m-1:
                    maxVal += grid[i+1][j]
                    i += 1
                return maxVal
            elif grid[i+1][j] >= grid[i][j+1]:
                maxVal += grid[i+1][j]
                i += 1
            else:
                maxVal += grid[i][j+1]
                j += 1
        return maxVal

对于测试用例有效，但是对于 [ [1,2,5], [3,2,1] ] 无效，个人认为是因为贪心算法成立需要满足最优子结构，最优子结构的意思是局部最优解能决定全局最优解。简单地说，问题能够分解成子问题来解决，子问题的最优解能递推到最终问题的最优解。

但是对于这个题目而言，容易进入局部最优解的情况，所以最终结果并不是最优解。

A* 算法

这个题目让我想到了人工智能课上学习到的启发式搜索，但是这个搜索办法似乎并不能够总是得到最优解，先试一下再说。

方法虽然好用，可以快速找到可行的解，但是缺点也很明显，找不到最优解；尽管我在此基础上添加了一个缓冲队列，用来保存最先解出来的可行解，最后从缓冲中找到缓冲中的最优解。但是还是没办法找到最优解。毕竟这是硬伤。

import heapq

class Node:
    def __init__(self, grid, cur=None, right=True):
        if not cur:
            self.i = 0
            self.j = 0
            self.value = len(grid) + len(grid[0]) + grid[0][0] - 2
            return
        if right:
            self.i = cur.i
            self.j = cur.j+1
        else:
            self.i = cur.i+1
            self.j = cur.j
        self.value = cur.value + grid[self.i][self.j] - 1

    def __lt__(self, other):
        # 取最大的
        return self.value > other.value

class Solution:
    def maxValue(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])
        i, j = 0, 0
        q = [Node(grid)]
        buf = []
        heapq.heapify(q)
        while len(q) > 0:
            cur = heapq.heappop(q)
            if cur.j < n-1:
                heapq.heappush(q, Node(grid, cur, True))
            if cur.i < m-1:
                heapq.heappush(q, Node(grid, cur, False))
            if cur.i == m-1 and cur.j == n-1:
                buf.append(cur.value)
                if len(buf) > 10:
                    break
        return max(buf)