礼物的最大价值

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param grid int整型二维数组
# @return int整型
#
class Solution:
    def maxValue(self, grid: List[List[int]]) -> int:
        # write code here
        M = len(grid)
        N = len(grid[0])
        dp = [[0]*N for m in range(M)]

    # 记录当前位置的礼物的最大

        for i in range(0, len(grid)):
            for j in range(0, len(grid[0])):

            # 初始化第一行，第一列的元素，它不可能从上面，或者左边移动过来，所以说它的大小就是它最大的价值

                if i == 0 and j == 0:
                    print(grid[0][0])
                    dp[i][j] = grid[i][j]

            # 棋盘中非第一行，非第一列中的元素的最大的情况

                elif len(grid) > i > 0 and len(grid[0]) > j > 0:
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]

                # 棋盘的第一行只能从左移动过去，从上面移动下来不可能

                elif i-1 < 0:
                    print("行列", i, j)
                    dp[i][j] = dp[i][j-1]+grid[i][j]

                # 棋盘的第一列，不可能从左边移动过来，所以只能从上面移动过来
                elif j-1 < 0:
                    dp[i][j] = dp[i-1][j] + grid[i][j]

        return dp[M-1][N-1]

class Solution:
    # 动态规划
    def maxValue(self , grid: List[List[int]]) -> int:
        rows = len(grid)
        cols = len(grid[0])
        # 第一列只能来自上方
        for i in range(1, rows):
            grid[i][0] += grid[i- 1][0]
        # 第一行只能来自左边
        for i in range(1, cols):
            grid[0][i] += grid[0][i -1]
        # 遍历后续每一个位置
        for i in range(1, rows):
            for j in range(1, cols):
                # 增加来自左边与上边的较大值
                grid[i][j] += max(grid[i -1][j], grid[i][j -1])
        return grid[rows -1][cols -1]

class Solution:
    def maxValue(self , grid):
        m,n=len(grid),len(grid[0])
        dp=[[0]*n for _ in range(m)]
        dp[0][0]=grid[0][0]
        for i in range(m):
            for j in range(n):
                if m==0 and n==0:
                    continue
                x= dp[i-1][j] if 0<=i-1<m else 0 
                y= dp[i][j-1] if 0<=j-1<n else 0 
                dp[i][j]=max(x,y)+grid[i][j]
        return dp[-1][-1]

class Solution:
    def maxValue(self , grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])
        dp = [[0 for _ in range(n)] for _ in range(m)]
        dp[0][0] = grid[0][0]
        for i in range(1, m):
            dp[i][0] = dp[i - 1][0] + grid[i][0]
        for i in range(1, n):
            dp[0][i] = dp[0][i - 1] + grid[0][i]
        for i in range(1, m):
            for j in range(1, n):
                if i < m and j < n:
                    dp[i][j] = max(dp[i][j - 1] + grid[i][j], dp[i - 1][j] + grid[i][j])
        return dp[m - 1][n - 1]

class Solution:
    def maxValue(self , grid: List[List[int]]) -> int:
        # write code here
        m=len(grid)
        n=len(grid[0])
        for i in range(m):
            for j in range(n):
                if i==0 and j==0:
                    grid[i][j]=grid[i][j]
                elif i==0:
                    grid[i][j]=grid[i][j-1]+grid[i][j]
                elif j==0:
                    grid[i][j]=grid[i-1][j]+grid[i][j]
                else:
                    grid[i][j]=max(grid[i-1][j],grid[i][j-1])+grid[i][j]
        return grid[-1][-1]

class Solution:
    def maxValue(self, grid):
        if not grid:
            return 0
        dp = grid
        w, l = len(grid), len(grid[0])
        for i in range(w):
            for j in range(l):
                # 第一个元素的特殊情况
                if not (i&nbs***bsp;j):
                    dp[i][j] = grid[i][j]
                elif i == 0:
                    dp[i][j] = dp[i][j - 1] + grid[i][j]
                elif j == 0:
                    dp[i][j] = dp[i - 1][j] + grid[i][j]
                else:
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + grid[i][j]
        return dp[w-1][l-1]