【数据结构】【更新中】【python】leetcode刷题记录：热题100答案 + 每日一题（附文字说明）

题目为leetcode的热题100.仅作学习用，且题目为节选，不断更新。
如果点赞过100就会制作动画

一、Hash

(1)

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那 两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]

答案：最简单的方法就是双循环，时间复杂度为N²，空间复杂度为O(1)。但时间复杂度略高。也可以用查找target - nums[i]在不在nums中来进行检索，这样操作时间会缩短一些，但无法起到质变。对于一串数字寻找关系的情况，可以想到用hash进行时间换空间的优化：

class Solution(object):
    def twoSum(self, nums, target):
        hashtable = dict()
        for i,num in enumerate(nums):
            if target-num in hashtable:
                return hashtable[target - num] , i
            hashtable[nums[i]] = i
        return []

其中，enumerate的方法是返回索引序列，例如：

example = ['abcd','efgh']
for i,j in enumerate(example):
    print(i,j)
打印结果为：
0 abcd
1 efgh

或者不要enumerate的话，也可以这么写：

class Solution(object):
    def twoSum(self, nums, target):
        hashtable = dict()
        for i in range(len(nums)):
            if target - nums[i] in hashtable:
                return i, hashtable[target-nums[i]]
            hashtable[nums[i]] = i
        return []

注意，这里的重点一定是使用dict的结构和hash的思想相匹配。如果单纯使用list，除非提前申请（但就本题而言，需要申请相当大的list），否则会出现越界的情况。但如果使用dict结构，就可以使用键值和对应的数值来代表hash，非常方便。
双循环的方法问题在于循环导致的时间浪费，但用hash表，就可以只进行一次遍历，每次使用hash找到要遍历的元素。因此，只需要遍历一次hash即可。因此，在对一串数据进行操作时，不仅可以使用双指针，也可以使用hash表。

(2)

你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

示例 1:

输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]

因为需要根据各个字符串之间的联系进行分组，因此自然想到hash表，使用hash表来进行分组操作。对于原分组中的每个字符串进行讨论：原list中的字符串进行排序后赋值给t变量，若t未在hash表中，则将t作为key，将s放入key中；否则就将s添加在已经存在的key中。
因此，核心思路就是将每个字符串进行排序，并检查原字符串是否在hashtable中，并决定是将排序后的字符串作为key或是添加。

class Solution(object):
    def groupAnagrams(self, strs):
        hashtable = dict()
        for s in strs:
            t = "".join(sorted(s))
            if t not in hashtable:
                hashtable[t] = [s]
            else:
                hashtable[t].append(s)
        return list(hashtable.values()) 

第三题不需要hash更简单，不记录了。

二、双指针

（1）移动0

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:

输入: nums = [0]
输出: [0]

思路：其实不需要双指针，只要得知0的个数，再删除和增添0即可。

def moveZeroes(self, nums):
        n = nums.count(0)
        for i in range(n):# 删一个0再加一个0
            nums.remove(0)
            nums.append(0)
        return nums

双指针思路：设置指针a和b，指针a永远指向最前面的0，b则是不断移动的。移动规则如下：

若a内容为0，b为非0，则交换，且都向后移动；
若a为0，b为0，则b向后移动；
若a为非0，b为0，则b向后移动；
若a、b均非0，则均向后移动。

设置好初始条件后，代码如下：

class Solution(object):
    def moveZeroes(self, nums):
        a = b = 0
        for b in range(len(nums)):
            if nums[a] == 0 and nums[b] != 0:
                temp = nums[a]
                nums[a] = nums[b]
                nums[b] = temp
                a += 1 
            elif  nums[a] != 0 and nums[b] != 0:
                a += 1
        return nums

（2）盛水最多的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i])
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水，返回容器可以储存的最大水量。

题意是选择两条柱子，以这两条柱高度的最小值为容器高度，取容器装水的量，即：

V = height[i] * (j - i)

因此暴力解法显而易见：从头开始遍历，经历两次循环得到最大值。
双指针解法如下：取指针在左右两端，假设a为左端且为短板，b为右端且为长板，那么b若向内移动，则容积一定减小，这是因为容器高取决于容器的最短边，因此b移动后，容器的高不会增大。而若向内移动a，则可能会导致体积增大，因此该算法时间复杂度为O(n):

    def maxArea(self, height):
        i,j,res = 0,len(height)-1,0
        while i < j:
            if height[i] < height[j]:
                res = max(res, height[i] * (j - i))
                i += 1
            else:
                res = max(res, height[j] * (j - i))
                j -= 1
        return res

(3)三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4] 输出：[[-1,-1,2],[-1,0,1]] 解释： nums[0] +
nums[1] + nums[2] = (-1) + 0 + 1 = 0 。 nums[1] + nums[2] + nums[4] = 0

• 1 + (-1) = 0 。 nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。 不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。 注意，输出的顺序和三元组的顺序并不重要。

思路：先进行排序，将i固定一个元素，并以此元素向两边辐射，寻找三个元素和为0的情况。

class Solution(object):
    def threeSum(self, nums):
        nums.sort()

        i, n = 1, len(nums)
        res = []
        if nums[0] > 0:
            return res
        while i < n-1:
            left, right = (i-1), (i+1)
            while left >= 0 and right <= (n-1):
                t = nums[i] + nums[left] + nums[right]
                if t == 0 and ([nums[left],nums[i],nums[right]] not in res):
                    res.append((nums[left],nums[i],nums[right]]))
                elif t < 0:
                    right += 1
                else:
                    left -= 1
            i += 1
        return res

五、数组

(1) 最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大为 6 。

思路：典型的动态规划，

def maxSubArray(self, nums):
        tail = len(nums) - 1
        for i in range(len(nums)-1):
            if nums[tail-1] + nums[tail] > nums[tail-1]:
                nums[tail-1] = nums[tail-1] + nums[tail] 
            tail -= 1
        return max(nums)

(2) 合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]] 输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6]. 示例 2：

输入：intervals = [[1,4],[4,5]] 输出：[[1,5]] 解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

思路：首先我们把intervals中的值全部按照区间左端点进行排序，这样可以方便我们后续的操作（对多个列表，应当有意识的把他们按某种顺序排列）。再建立一个res列表，用来存储最终结果。而算法思路也很简单，对每个元素进行扫描，如果res为空或者当前元素与res中的最后一个元素无法合并，那么就将其append进res；否则即可以合并，那就取res最后一个元素的区间右边界和当前元素的有边界的最大值作为res最后一个元素的区间右边界，即拓展区间。
有一点需要注意：为什么每次都是用res的最后一个元素比较？这是因为res是从空列表拓展出来的，且intervals数组按区间左边界排序，因此最后一个元素就是当前准备合并的元素。且不会出现漏合并的情况
例如，intervals为[[1,2],[2,2],[3,4],[2,3]]，如果按照这样来执行算法，则会漏掉最后的[2,3]，但由于已经排序过的原因，[2,3]的最小值2小于3，也会被排到前面，即让区间左边界越小的越往前。
代码：

class Solution(object):
    def merge(self, intervals):
        intervals.sort(key=lambda x: x[0])
        res = []

        for cur in intervals:
            if not res or res[-1][1] < cur[0]:
                res.append(cur)
            else: #存在重叠
                res[-1][1] = max(res[-1][1],cur[1])
                
        return res

写法上，是遍历intervals中的每个元素。如果用双指针的方式遍历会导致耗费时间较高，但也给出代码：

class Solution(object):
    def merge(self, intervals):
        i, n= 0, len(intervals)
        intervals.sort(key=lambda x: x[0])

        while i < n:
            cur = intervals[i]
            j = i+1
            while j < n:
                temp = intervals[j]
                if temp[0] <= cur[1] or temp[1] <= cur[1]:
                    cur[1] = max(cur[1],temp[1])
                    intervals.pop(j)
                    j -= 1
                    n -= 1
                j += 1
            i += 1
                
        return intervals

（3） 轮转数组

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

示例 1:

输入: nums = [1,2,3,4,5,6,7], k = 3 输出: [5,6,7,1,2,3,4] 解释: 向右轮转 1 步:
[7,1,2,3,4,5,6] 向右轮转 2 步: [6,7,1,2,3,4,5] 向右轮转 3 步: [5,6,7,1,2,3,4]

思路：最简单的就是进行python切片，先对k进行模除。然后将后k位和前面的数字交换：

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        k = k % len(nums)
        res = nums[-k:]+nums[0:-k]
        for i in range(len(nums)):
            nums[i] = res[i]

但这样需要新开一个数组，导致空间复杂度为O(n),下面是原地排序的方法：先将全部数逆转，再将前k位逆转，后面的（n-k）位逆转即可。

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        k, n= k % len(nums), len(nums)
        nums.reverse()
        nums[:k] = nums[(k-n)-1:-n-1:-1]
        nums[k:] = nums[:(k-n)-1:-1]

(4） 除自身以外数组的乘积

给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。

题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。
请 不要使用除法，且在 O(n) 时间复杂度内完成此题。

示例 1:

输入: nums = [1,2,3,4]
输出: [24,12,8,6]
示例 2:

输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]

思路：使用左右数组，最后左右数组对应项相乘即可得到答案。

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        n=  len(nums)
        L, R, res = [1]*n, [1]*n, [0]*n
        
        for i in range(1,n):
            L[i] = nums[i-1] * L[i-1]
            R[-i-1] = nums[-i] * R[-i]
            
        for i in range(n):
            res[i] = L[i] * R[i]

        return res

二叉树

二叉树的基本遍历方式可以看，本节的题有使用下文的算法：

【数据结构】【树的遍历算法】【python】树的各种遍历算法

（1）二叉树对称

给你一个二叉树的根节点 root ， 检查它是否轴对称。

思路：可以有多种做法。比如利用左右根和右左根的遍历来检查是否对称，不过那样的代码效率比较差。也可以用下面的方法，如果左子树的左节点和右子树的右节点存在，左子树的右节点和右子树的左节点存在，且值相同就可以判断为对称的。反之则是不对称的。具体代码细节在注释：

class Solution(object):
    def isSymmetric(self, root):
        
        def check(left,right):
            
            # 两方都不存在 true
            if not left and not right:
                return True
            # 如果有一方不存在则为flase
            elif not left or not right:
                return False
            #两方都存在
            if left.val != right.val:
                return False 
            return check(left.left,right.right) and check(left.right,right.left)
        return check(root,root)

（2）二叉树的直径

给你一棵二叉树的根节点，返回该树的直径 。
二叉树的直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。
两节点之间路径的 长度 由它们之间边数表示。

这题的思路即DFS.使用深度优先遍历的思想，记录每个节点的深度，进而与res比较，若遇到左子树深度加右子树深度大于当前记录的最大值时，就进行替换。最后返回的值就是res。代码：

class Solution(object):
    def diameterOfBinaryTree(self, root):
        self.res = 0
        def DFS(root):
            if not root:
                return 0
            left = DFS(root.left)
            right = DFS(root.right)
            if self.res < left + right:
                self.res = left + right
            
            return max(left,right)+1
        DFS(root)
        return self.res

实际上，本题只是DFS的一个变体，用res记录L+R的最大值。

(3) 将有序数组转换为二叉搜索树

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。
高度平衡二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

思路：当存储方式是数组的时候，解决这个问题就会比较简单。本题没有规定要构造成什么样的平衡二叉树，而只是一颗平衡二叉树，因此，选择好根节点，再将原数组一分为二即可，很有二分查找的感觉。但本题是构造一棵树，返回的结果是TreeNode类型，因此使用递归更加简单。代码如下：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def sortedArrayToBST(self, nums):
        def midorder(L,R):
            if L > R:# 边界条件
                return None
            
            mid = (L + R) // 2
            #思路类似于二分查找
            root = TreeNode(nums[mid])
            root.left = midorder(L,mid-1)
            root.right = midorder(mid+1,R)  
            return root      

        return midorder(0,len(nums)-1)

二分法

本章的内容都基于二分查找的思想。
给你一个满足下述两条属性的 m x n 整数矩阵：每行中的整数从左到右按非严格递增顺序排列。每行的第一个整数大于前一行的最后一个整数。
给你一个整数 target ，如果 target 在矩阵中，返回 true ；否则，返回 false 。

思路一：因为是有序的排列，因此如果想做出本题非常容易：对矩阵的每一行进行遍历，如果遇到元素值大于target时，则直接返回false，因为整体有序，不可能再出现相等的值。时间复杂度则是O(n)

class Solution(object):
    def searchMatrix(self, matrix, target):
        for i in range(len(matrix)):
            for j in range(len(matrix[i])):
                t = matrix[i][j]
                if t == target:
                    return True
                elif t > target:
                    return False
                    
        # 最后的false是满足查找不到的情况，即target大于矩阵中最大值的情况。
        return False

思路二：二分查找：
和普通的二分查找不同的是，这是一个矩阵，因此二分查找的方式不能直接进行查找，需要进行一定的转换。
思想还是二分查找的思想，将整个矩阵看成一个数组，left = 0，right为最后一个元素。mid仍取中间值。重点是x，y如何确定，确定x，y后就可以与target进行比较并确定mid的位置。x是用mid // col，即除一行的元素个数，例如mid = 5，col = 4，则x = 1，确定为第一行。列元素则是取模运算，例如mid = 7，col = 4，则y = 3。在涉及行列转换的时候，可以多考虑取模或整除运算。

class Solution(object):
    def searchMatrix(self, matrix, target):
        row,col = len(matrix),len(matrix[0])
        left, right = 0, row*col -1  

        while left <= right:
            mid = (left + right) // 2
            x, y = mid // col , mid % col
            if matrix[x][y] == target:
                return True
            elif matrix[x][y] > target:
                right = mid - 1
            else:
                left =  mid + 1

        return False

（2）在排序数组中查找元素的第一个和最后一个位置

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。
你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8 输出：[3,4] 示例 2：

输入：nums = [5,7,7,8,8,10], target = 6 输出：[-1,-1] 示例 3：

输入：nums = [], target = 0 输出：[-1,-1]

思路：如果仅以通过来说，先找到第一个target的下标，再依次向后找依然可以通过本题，但不满足时间复杂度为O(logn)。实际上，本题的logn和非递减序列也说明了需要使用二分查找。对于本题，进行两次二分查找即可，第一次找到第一个，第二次找到最后一个。与普通二分查找不同的是，找第一个或者第二个的二分查找需要在当前值等于target时仍要改变指针的方向，因为我们要找的是target序列的第一个或者最后一个。具体细节见代码：

class Solution(object):
    def searchRange(self, nums, target):
    	#这样赋初值可以解决空列表的情况
        res = [-1,-1]
        left, right= 0,len(nums)-1
        # 找第一个      
        while left <= right:
            mid = (left + right) // 2
            if nums[mid] == target:
                res[0] = mid
                #因为是找第一个，即要找当前指向元素或其左边的元素
                right = mid - 1
            elif nums[mid] > target:
                right = mid - 1
            elif nums[mid] < target:
                left = mid + 1
        left,right= 0,len(nums)-1
		# 找最后一个
        while left <= right:
            mid = (left + right) // 2
            if nums[mid] == target:
                res[1] = mid
                #因为是找最后一个，即要找当前指向元素或其右边的元素
                left = mid + 1
            elif nums[mid] > target:
                right = mid - 1
            elif nums[mid] < target:
                left = mid + 1
        
        return res

栈

（1）有效括号

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：
1.左括号必须用相同类型的右括号闭合。
2.左括号必须以正确的顺序闭合。
3.每个右括号都有一个对应的相同类型的左括号。

思路：本题只是利用栈的特性，较为简单，可以使用字典进行匹配的判断。
将左括号入栈，当遇到右括号时，将栈顶元素pop出来，并和当前的右括号尝试配对，如果无法配对则返回fasle。若可以配对则继续遍历。若出现了栈为空但此时遍历到右括号，则一定无法配对，也是false。
最后返回时判断栈是否为空，若为空则完成配对，否则是左括号多于右括号，返回False。

lass Solution(object):
    def isValid(self, s):
        stack = []
        dic = {'{': '}',  '[': ']', '(': ')'}

        for string in s:
            if string in dic:
                stack.append(string)
            elif len(stack) == 0:# 提前栈空 无法配对
                return False
            elif dic[stack.pop()] != string:
                return False
            
        return len(stack) == 0

（2）最小栈

思路：如果仅仅是做出本题，那会非常简单。仅仅是多封装了一个函数而已：

class MinStack(object):
    def __init__(self):
        self.stack = []

    def push(self, val):
        self.stack.append(val)

    def pop(self):
        self.stack.pop()

    def top(self):
        return self.stack[-1]
        
    def getMin(self):
        return min(self.stack)

但如果在常数时间内返回，那显然就不能使用min函数，也就需要在push、pop中进行额外操作。我们设计一个最小栈的结构，来记录每次push操作之后stack中的最小值，因此getMin的操作就可以在O(1)中返回最小值。

class MinStack(object):

    def __init__(self):
        self.stack = []
        # 最小栈存储每次push后的最小值，栈顶的当前栈的最小栈
        self.min_stack = [float('inf')]

    def push(self, val):
        self.stack.append(val)
        # 如果当前值val没有最小栈的栈顶值s小，则再记录一次最小值s
        # 这样在pop的时候，stack中的val被pop出去，不影响最小栈的最小值仍为s
        self.min_stack.append(min(val,self.min_stack[-1]))                       


    def pop(self):
        self.stack.pop()
        self.min_stack.pop()

    def top(self):
        return self.stack[-1]


    def getMin(self):
        return self.min_stack[-1]

每日一题：

（1）

给你一个下标从 0 开始的数组 nums ，数组长度为 n 。

nums 的 不同元素数目差 数组可以用一个长度为 n 的数组 diff 表示，其中 diff[i] 等于前缀 nums[0, …, i] 中不同元素的数目 减去 后缀 nums[i + 1, …, n - 1] 中不同元素的数目。

返回 nums 的 不同元素数目差 数组。

注意 nums[i, …, j] 表示 nums 的一个从下标 i 开始到下标 j 结束的子数组（包含下标 i 和 j 对应元素）。特别需要说明的是，如果 i > j ，则 nums[i, …, j] 表示一个空子数组。

思路：看起来还怪麻烦的，实际写起来也不是很容易…
前文说过，当遇到一串数字找其中规律，或者根据数字之间的关系来解决问题，可以考虑hash的想法，因此可以使用hash的思想来解决问题。同时，本题的关键是前后部分中不同的字符数，因此需要想到集合这个数据元素，因为其天然具有划分重复数据元素的特性。如果没想到集合将会浪费额外精力去处理重复数据的个数。本题的核心思想也就是两个集合的长度做差
首先先用cnt这个列表来记录后缀中重复的个数，为什么是后缀呢？第二个for循环是从0到n的遍历，即获得前缀的集合长度，因此先获取后缀重复的个数，对之后的操作更简单。记录得到后缀的重复个数后，通过第二个for循环得到diff的值。

class Solution(object):
    def distinctDifferenceArray(self, nums):
        st, n = set(), len(nums)
        diff, cnt = [], [0]*(n+1)

        for i in range(n - 1,0,-1):
            st.add(nums[i])
            cnt[i] = len(st)
        st.clear()

        for i in range(n):
            st.add(nums[i])
            diff.append(len(st) - cnt[i + 1])

        return diff

class Solution {
public:
    vector<int> distinctDifferenceArray(vector<int>& nums) {
        int n = nums.size();
        unordered_set<int> st;
        vector<int> sufCnt(n + 1, 0);
        for (int i = n - 1; i > 0; i--) {
            st.insert(nums[i]);
            sufCnt[i] = st.size();
        }
        vector<int> res;
        st.clear();
        for (int i = 0; i < n; i++) {
            st.insert(nums[i]);
            res.push_back(int(st.size()) - sufCnt[i + 1]);
        }
        return res;
    }
};

（2）1690 石子游戏

石子游戏中，爱丽丝和鲍勃轮流进行自己的回合，爱丽丝先开始 。

有 n 块石子排成一排。每个玩家的回合中，可以从行中 移除 最左边的石头或最右边的石头，并获得与该行中剩余石头值之 和 相等的得分。当没有石头可移除时，得分较高者获胜。

鲍勃发现他总是输掉游戏（可怜的鲍勃，他总是输），所以他决定尽力 减小得分的差值 。爱丽丝的目标是最大限度地 扩大得分的差值 。

给你一个整数数组 stones ，其中 stones[i] 表示 从左边开始 的第 i 个石头的值，如果爱丽丝和鲍勃都 发挥出最佳水平 ，请返回他们 得分的差值 。

思路：对于这种逐渐更改数组，并且在更改过程中需要记录数据，设计策略，那么就很可能是动态规划/带备忘录搜索（记忆化搜索）。而动态规划的重点就是从小规模问题拓展到大规模，从小规模的问题入手解决大规模问题。因此首要问题就是找到核心的小规模问题。
Alice的目的是让她的分数（A）减去Bob的分数的值最大，A-B最大，而Bob则要尽力缩小这个差距，反过来说，也就是B-A最大。而所谓的Alice先手，实际上也会在Alice完成一次操作后，变成Bob先手，这点也满足动态规划的要求。
也就是说，对于上图的实例：

移除最左边的石子 stones[0]=5，剩余石子为 stones′=[3,1,4,2]
问题变成了鲍勃（他现在是先手）的得分减去爱丽丝（她现在是后手）的得分最大是多少。
移除最右边的石子 stones[4]=2，剩余石子为stones′=[5,3,1,4]
问题变成了鲍勃（他现在是先手）的得分减去爱丽丝（她现在是后手）的得分最大是多少。

因此，如果先拿走左边的石头，那么Alice的得分就是右边石头数值的和（S1），得分差就是S1-dfs(i+1，j);
如果先拿走右边的石头，那么那么Alice的得分就是左边石头数值的和（S2),得分差就是S2-dfs(i，j-1).
而S1或者S2的和的求法，可以使用前缀和的差值计算。如果每次都要求一次中间若干数值的和，那将会耗费额外的时间。因此现在代码的起始位置计算好stones数组的前缀和，而计算S1/S2时直接做差即可。

记忆化搜索代码如下。但似乎在leetcode无法通过，因为无法import第三方库，因此cache的装饰器无法使用。如果去掉装饰器的部分，会导致有用例超时。如果在本地运行可以正确执行。

from functools import cache

class Solution(object):
    def stoneGameVII(self, stones):
        pre, n = [0], len(stones)
        #pre 是前缀和
        for i in stones:
            pre.append(pre[-1] + i)

        @cache
        def dfs(i,j):
            #不存在
            if i > j:
                return 0
            return max(pre[j+1] - pre[i+1] - dfs(i+1,j), pre[j] - pre[i] - dfs(i,j-1)) 
        res = dfs(0,n-1)
        dfs.cache_clear()

        return res

思路二：动态规划
如果将思路一的过程改为动态规划，即自底向上的进行构造，就可以不使用递归的方式，因此也就不需要使用装饰器，因此时间复杂度也可以得到缓解。我们可以首先求出区间 [i,i] 的最大得分差值，然后不断向外扩展求出 [i−1,i]，[i,i+1] 区间的最优解，一直扩展到区间 [0,n−1],此时即可求出最优解返回即可。

class Solution(object):
    def stoneGameVII(self, stones):
        n = len(stones)
        sum_arr = [0] * (n + 1)
        dp = [[0] * n for _ in range(n)]
        for i in range(n):
            sum_arr[i + 1] = sum_arr[i] + stones[i]
        for i in range(n - 2, -1, -1):
            for j in range(i + 1, n):
                dp[i][j] = max(sum_arr[j + 1] - sum_arr[i + 1] - dp[i + 1][j], sum_arr[j] - sum_arr[i] - dp[i][j - 1])
        return dp[0][n - 1]