冉宝的每日一题 -8月18日--动态规划困难题+回溯法复习

今天的每日一题有点难
话说我今天买的锅到了，但是太大了退了，买了一个可爱小锅，做人还是要开心才行

522.学生出勤记录||

https://leetcode-cn.com/problems/student-attendance-record-ii/

题目描述：

可以用字符串表示一个学生的出勤记录，其中的每个字符用来标记当天的出勤情况（缺勤、迟到、到场）。记录中只含下面三种字符：

• ‘A’：Absent，缺勤
• ‘L’：Late，迟到
• ‘P’：Present，到场

如果学生能够 同时 满足下面两个条件，则可以获得出勤奖励：

按 总出勤 计，学生缺勤（‘A’）严格 少于两天。
学生 不会 存在 连续 3 天或 连续 3 天以上的迟到（‘L’）记录。
给你一个整数 n ，表示出勤记录的长度（次数）。请你返回记录长度为 n 时，可能获得出勤奖励的记录情况 数量 。答案可能很大，所以返回对 109 + 7 取余 的结果。

示例 1：

输入：n = 2
输出：8
解释：
有 8 种长度为 2 的记录将被视为可奖励：
"PP" , "AP", "PA", "LP", "PL", "AL", "LA", "LL" 
只有"AA"不会被视为可奖励，因为缺勤次数为 2 次（需要少于 2 次）。

示例 2：

输入：n = 1
输出：3

示例 3：

输入：n = 10101
输出：183236316

思路

时间：20:01 -21:30
思路，这题应该用动态规划，但是因为加的字母不同，转移方程不同，所以我们这里维护一个二维dp

关键是拆分成不交叉的转移矩阵，最后的和上面对齐就行。

而且发现 dp-n 只和。dp[n-1] 有关，所以滚动数组， O(1) 常数大小。
时间复杂度 O(n).

class Solution:
    def checkRecord(self, n: int) -> int:
        dp_1 = [3,1,1,1,0,0,0]
        for i in range(1,n):
            dp = [None]*7
            dp[1] = dp_1[1] + dp_1[3]+dp_1[5]
            dp[2] = dp_1[1] + dp_1[3]+dp_1[5] +dp_1[2] + dp_1[4]+dp_1[6]
            dp[3] = dp_1[1]
            dp[4] = dp_1[2]
            dp[5] = dp_1[3]
            dp[6] = dp_1[4]
            dp[0] = sum(dp[1:7])  % (10**9+7)

            dp_1 = dp[:]
        return dp_1[0] % (10**9+7)

然后我发现我超时了，所以不能这么搞，得一步到位,但是都到99996了，也无所谓了。然后我突然就明白了，大数的加法时间复杂度也很高，加了两个除余就好了。

class Solution:
    def checkRecord(self, n: int) -> int:
        dp_1 = [3,1,1,1,0,0,0]
        for i in range(1,n):
            dp = [None]*7
            dp[1] = (dp_1[1] + dp_1[3]+dp_1[5] ) % (10**9+7)
            dp[2] = (dp_1[1] + dp_1[3]+dp_1[5] +dp_1[2] + dp_1[4]+dp_1[6]) % (10**9+7)
            dp[3] = dp_1[1]
            dp[4] = dp_1[2]
            dp[5] = dp_1[3]
            dp[6] = dp_1[4]
            dp_1 = dp[:]
        return sum(dp_1[1:7]) % (10**9+7)

然后我中间有一次的题解应该可以更快

class Solution:
    def checkRecord(self, n: int) -> int:
        dp = [1,1,1,0,0,0]
        for i in range(1,n):
            dp = [(dp[0]+dp[2]+dp[4]) % (10**9+7),(sum(dp))% (10**9+7),dp[0],dp[1],dp[2],dp[3]]
        return sum(dp) % (10**9+7)

不愧是我：

所以有的时候通过不了，就是细节的问题了

题解的矩阵快速幂也是个很好的思想，就是吧上面的转移，变成乘法。

借助矩阵的优化，可以达到 logn的时间复杂度，真不错。

好啦，开始复习之前的知识点啦
晚安

回溯法复习

131.分割回文串

https://leetcode-cn.com/problems/palindrome-partitioning

题目描述

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

示例 2：

输入：s = "a"
输出：[["a"]]

提示：

• 1 <= s.length <= 16
• s 仅由小写英文字母组成

思路：

根据题目就知道这个题目吧，不是个时间复杂度简单的题目
先来这个吧：这个题目首先要拆分成各个部分都是回文串的子串。
就相当于从底下往上合并，哪些可以组成回文串，然后拼接起来，

感觉和8月16日没有做出来的题目呼应上了

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        res = []
        n = len(s)
        tmp_ind = []  # 用来存字符串

        def backtrack(ind):
            if ind == n:
                res.append(tmp_ind[:])
                return
            for new_ind in range(ind, n):
                s1 = s[ind:new_ind + 1]
                s2 = s[new_ind:ind - 1:-1] if ind - 1 >= 0 else s[new_ind::-1]
                if s1 == s2:
                    tmp_ind.append(s1)
                    backtrack(new_ind + 1)
                    tmp_ind.pop()

                else:
                    continue

        backtrack(0)
        return res

代码写出来还挺简单的，就是这个s1选择，我这里弄错了好久，写完已经两个小时过去了，再做一个吧。

剑指 Offer II 020. 回文子字符串的个数

https://leetcode-cn.com/problems/a7VOhD/

给定一个字符串 s ，请计算这个字符串中有多少个回文子字符串。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

示例 1：

输入：s = "abc"
输出：3
解释：三个回文子串: "a", "b", "c"

示例 2：

输入：s = "aaa"
输出：6
解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"

提示：

• 1 <= s.length <= 1000
• s 由小写英文字母组成

感觉和回溯并无关系。

还有一题相关的下一个排列，好像也是字节的一个面试题，我太累了直接抄答案吧。
https://leetcode-cn.com/problems/next-permutation/solution/xia-yi-ge-pai-lie-by-leetcode-solution/
扫描两次序列，找到第一个逆序对，交换位置，然后反转序列就可以了。