第170场周赛实录（动态规划——以空间换时间）

1310. 子数组异或查询

难度：中等

一元动态规划问题

有一个正整数数组 arr，现给你一个对应的查询数组 queries，其中 queries[i] = [Li, Ri]。

对于每个查询 i，请你计算从 Li 到 Ri 的 XOR 值（即 arr[Li] xor arr[Li+1] xor … xor arr[Ri]）作为本次查询的结果。

并返回一个包含给定查询 queries 所有结果的数组。

示例 1：

输入：arr = [1,3,4,8], queries = [[0,1],[1,2],[0,3],[3,3]]
输出：[2,7,14,8]
解释：
数组中元素的二进制表示形式是：
1 = 0001
3 = 0011
4 = 0100
8 = 1000
查询的 XOR 值为：
[0,1] = 1 xor 3 = 2
[1,2] = 3 xor 4 = 7
[0,3] = 1 xor 3 xor 4 xor 8 = 14
[3,3] = 8

示例 2：

输入：arr = [4,8,2,10], queries = [[2,3],[1,3],[0,0],[0,3]]
输出：[8,0,4,4]

提示：

• 1 <= arr.length <= 3 * 10^4
• 1 <= arr[i] <= 10^9
• 1 <= queries.length <= 3 * 10^4
• queries[i].length == 2
• 0 <= queries[i][0] <= queries[i][1] < arr.length

解决方案 ：

动态规划：动规问题，我看来，总结来说可以看做是“以空间换时间”，大意是：当所给的数量级太大，遍历会超时间，这时却发现其实可以把遍历的中间过程记录下来放在一个数组中，这个数组通常命名为dp，最后根据题目的要求在二次处理的数组dp中得到或根据关系进行简单运算得到，这也就是动态规划问题的精髓所在吧。下一个结果在上一个结果的基础上，动态规划，其实就是在前面结果的基础上，再进行预算，因此在前面专门的一篇博客引申到马尔科夫链的概念，因为动规也可以理解为状态的转移，且与马尔科夫链类似，下一个状态只与前一个状态相关。

本题关键：注意到异或的性质：b^c = a^a^b^c，以此来寻找上述的“最后根据题目的要求在二次处理的数组dp中得到或根据关系进行简单运算得到”。

class Solution:
    def xorQueries(self, arr: List[int], queries: List[List[int]]) -> List[int]:
        ans = []
        dp = [0 for _ in range(len(arr)+1)]
        for i in range(len(arr)):
            dp[i+1] = dp[i] ^ arr[i]
        for query in queries:
            ans.append(dp[query[0]] ^ dp[query[1] + 1])
        return ans

1312. 让字符串成为回文串的最少插入次数

难度：困难

二元动态规划问题

给你一个字符串 s ，每一次操作你都可以在字符串的任意位置插入任意字符。

请你返回让 s 成为回文串的 最少操作次数 。

「回文串」是正读和反读都相同的字符串。

示例 1：
输入：s = “zzazz”
输出：0
解释：字符串 “zzazz” 已经是回文串了，所以不需要做任何插入操作。

示例 2：
输入：s = “mbadm”
输出：2
解释：字符串可变为 “mbdadbm” 或者 “mdbabdm” 。

示例 3：
输入：s = “leetcode”
输出：5
解释：插入 5 个字符后字符串变为 “leetcodocteel” 。

示例 4：
输入：s = “g”
输出：0

示例 5：
输入：s = “no”
输出：1

提示：

• 1 <= s.length <= 500
• s 中所有字符都是小写字母。

解决方案：

所谓二元动态规划问题，也就是上个问题的dp变为二维的，来存储二维的中间结果，如这个问题就是存储不同长度跳跃的结果（最少插入次数），因为跨度较大的跳跃的结构在较小跳跃结果的基础上得到，如下图：“22a22”对应01234，0-2可能跟1相关也可能跟0-1和1-2相关，抽象出来：

$arr[x_1]=arr[x_2]时，f[x_1][x_2]=f[x_1+1][x_2-1]$
$arr[x_1]!=arr[x_2]时，f[x_1][x_2]=min(f[x_1][x_2-1],f[x_1+1][x_2])+1$

class Solution:
    def minInsertions(self, s: str) -> int:
        """
        区间dp
        f[i][j] 表示把 i~j 区间的字符串变成回文串所需要的最少操作步数
        初始: 长度为1的字符串操作次数是0

        状态转移方程:
        1. s[i]!=s[j]：f[i][j] = min(f[i + 1][j], f[i][j - 1]) + 1
        2. s[i]==s[j], 头和尾刚好抵消: f[i][j] = f[i + 1][j - 1]

        :param s:
        :return:
        """
        n = len(s)
        f = [[0] * n for _ in range(n)]
        # 从长度为2的字符串开始枚举
        for l in range(1, n):
            for i in range(n - l):
                j = i + l
                if s[i] != s[j]:
                    f[i][j] = min(f[i][j - 1], f[i + 1][j]) + 1
                else:
                    # 这里长度为2时 i + 1 > j - 1， f[i + 1][j - 1]=0，所以可以省略 if l!=1 else 0 的判断条件
                    f[i][j] = f[i + 1][j - 1]
        return f[0][n - 1]

（解法来源leetcode）