【力扣夜猫双周赛】第24场 | 5372,5373,5374,5374 | 动态规划 |回溯算法

5372 逐步求和得到正数的最小值

给你一个整数数组 nums 。你可以选定任意的 正数 startValue 作为初始值。

你需要从左到右遍历 nums 数组,并将 startValue 依次累加上 nums 数组中的值。

请你在确保累加和始终大于等于 1 的前提下,选出一个最小的 正数 作为 startValue 。

输入:nums = [-3,2,-3,4,2]
输出:5
解释:如果你选择 startValue = 4,在第三次累加时,和小于 1 。
                累加求和
                startValue = 4 | startValue = 5 | nums
                  (4 -3 ) = 1  | (5 -3 ) = 2    |  -3
                  (1 +2 ) = 3  | (2 +2 ) = 4    |   2
                  (3 -3 ) = 0  | (4 -3 ) = 1    |  -3
                  (0 +4 ) = 4  | (1 +4 ) = 5    |   4
                  (4 +2 ) = 6  | (5 +2 ) = 7    |   2

算法思路

class Solution:
    def minStartValue(self, nums) -> int:
        res=1
        k=res
        flag=True
        while flag:
            for i in nums:
                k+=i
                if k<1:break
            else:
                flag=False
            if flag:
                res+=1-k
                k=res
        return res

假定startValue以res代称=1,然后进行遍历,当累和小于1时,修改res加上差值,然后重新遍历。

现在复盘发现,其实不需要先行假定res,只要遍历一遍数组,其中的最小累加值(应该小于1,否则res最小等于1)与1的差值就是res:

class Solution:
    def minStartValue(self, nums) -> int:
        res,k=0,0
        for i in nums:
            k+=i
            res=min(res,k)
        return 1-res

5373 和为K的最小斐波那契数字数目

给你数字 k ,请你返回和为 k 的斐波那契数字的最少数目,其中,每个斐波那契数字都可以被使用多次。

斐波那契数字定义为:
F1 = 1
F2 = 1
Fn = Fn-1 + Fn-2 , 其中 n > 2 。

数据保证对于给定的 k ,一定能找到可行解。

算法思路

如果数字满足斐波那契数列,那么最少只需要一次,如果不满足,那么减去最接近的数列值得到新的数字K,所需数字数+1
重复上一步,直到K=0

class Solution:
    def findMinFibonacciNumbers(self, k: int) -> int:
        ls=self.fib(k)
        res=0
        while k:
            if k>=ls[-1]:
                k-=ls[-1]
                res+=1
            else:
                ls.pop()
        return res
            
    def fib(self, N) -> int:
        a, b = 0, 1
        res = []
        while b <= N:
            res.append(b)
            a, b = b, a + b
        return res

执行用时 :44 ms, 在所有 Python3 提交中击败了100.00%的用户
内存消耗 :13.6 MB, 在所有 Python3 提交中击败了100.00%的用户

5374. 长度为 n 的开心字符串中字典序第 k 小的字符串

一个 「开心字符串」定义为:
仅包含小写字母 [‘a’, ‘b’, ‘c’].
对所有在 1 到 s.length - 1 之间的 i ,满足 s[i] != s[i + 1] (字符串的下标从 1 开始)。

比方说,字符串 “abc”,“ac”,“b” 和 “abcbabcbcb” 都是开心字符串,但是 “aa”,“baa” 和 “ababbc” 都不是开心字符串。

给你两个整数 n 和 k ,你需要将长度为 n 的所有开心字符串按字典序排序。

请你返回排序后的第 k 个开心字符串,如果长度为 n 的开心字符串少于 k 个,那么请你返回 空字符串 。

算法思路

其实题目描述我看着是有点懵的,**对所有在 1 到 s.length - 1 之间的 i ,满足 s[i] != s[i + 1] (字符串的下标从 1 开始)。**难道对下标0的元素就不用满足吗?但是 "aa"不是开心字符串

我选择所有相邻元素都不能相同。

然后相对来说算法就简单了,开心字符串的列举就通过回溯算法即可。
最后一个问题就是k是从1开始数的第k个字符串,所以实际上数组按字典序排序后所求的字符串是第k-1个。

class Solution:
    def getHappyString(self, n: int, k: int) -> str:
        res=set()
        def helper(n,s=''):
            if len(s)==n:
                res.add(s)
                return
            for i in ['a','b','c']:
                if s and s[-1]==i:continue
                helper(n,s+i)
        helper(n)
        res=sorted(res)
        print(res)
        return res[k-1] if k-1 <len(res) else ''

执行用时 :196 ms, 在所有 Python3 提交中击败了100.00%的用户
内存消耗 :20.1 MB, 在所有 Python3 提交中击败了100.00%的用户

刚刚写题解的时候突然想到,第一遍写的回溯算法,所得到的满足条件的字符串本来就是满足字典序排序的,所以不需要排序,因为遍历的数组没有重复元素,所以字符串也不会重复,也就不需要哈希表来做去重。

class Solution:
    def getHappyString(self, n: int, k: int) -> str:
        res=[]
        def helper(n,s=''):
            if len(s)==n:
                res.append(s)
                return
            for i in ['a','b','c']:
                if s and s[-1]==i:continue
                helper(n,s+i)
        helper(n)
        # res=list(res)
        return res[k-1] if k-1 <len(res) else ''
        
执行用时 :136 ms, 在所有 Python3 提交中击败了100.00%的用户
内存消耗 :19.9 MB, 在所有 Python3 提交中击败了100.00%的用户

去掉了排序,用时显著减少了。

压轴:5375. 恢复数组

某个程序本来应该输出一个整数数组。但是这个程序忘记输出空格了以致输出了一个数字字符串,我们所知道的信息只有:数组中所有整数都在 [1, k] 之间,且数组中的数字都没有前导 0 。

给你字符串 s 和整数 k 。可能会有多种不同的数组恢复结果。

按照上述程序,请你返回所有可能输出字符串 s 的数组方案数。

由于数组方案数可能会很大,请你返回它对 10^9 + 7 取余 后的结果。

算法思路

昨晚比赛的时候,做到这,瞄了眼题目,选择了从心。
今早起来复盘,看到辛勤写题解的大佬们(超感谢)用的动态规划,果然,动规就是压轴大魔王啊!

——
采用动态规划,
先考虑不含0,且k足够大的情况
s = “1317”, k = 2000 为例
设定字符串从1开始下标。
i = 0 时,对应s = ”“,可以解析成空数组 所以dp[0] = 1
i = 1 时,对应s = ”1“,只能解析成 [1], 所以 dp[1] = 1
i = 2 时,对应s = ”13“。当“3”作为单独的数字时,所能解析出来的数量是i=1时的数量,因为“3”可以接在dp[1]表示的所有数组可能的后面;当“3”作为“13”的一部分的时候,参考前一句,所能解析出来的数量是i=0时的数量,dp[2]=dp[1]+dp[0]
i = 3 时,对应s = “131”。当“1”作为单独数字时,所能解析出来的数量是i=2时的,以此类推:转移方程dp[i]=dp[i-1]+dp[i-2]+dp[i-3]+…+dp[1]+dp[0]

伪代码:

dp[0] = 1
for i in range(1, n + 1):
    for j in range(i - 1, -1, -1):
        dp[i] += dp[j]

然后考虑不含0,但是k有限的情况
s = “1317”, k = 20 为例
设定字符串从1开始下标。
i = 0 时,对应s = ”“,可以解析成空数组 所以dp[0] = 1
i = 1 时,对应s = ”1“,只能解析成 [1], 所以 dp[1] = 1
i = 2 时,对应s = ”13“。当“3”作为单独的数字时,所能解析出来的数量是i=1时的数量,因为“3”可以接在dp[1]表示的所有数组可能的后面;当“3”作为“13”的一部分的时候,参考前一句,所能解析出来的数量是i=0时的数量,dp[2]=dp[1]+dp[0]
i = 3 时,对应s = “131”。当“1”作为单独数字时,所能解析出来的数量是i=2时的,当“1”作为“31”的一部分的时候,大于k,不符合条件,且从这里开始,往后的“131”等都不会符合条件。dp[3]=dp[2]
i = 4 时,对应s=“1317”.当“7”作为单独数字时,所能解析出来的数组数量是i=3时的数量,当“7”作为“17”时,数量等于i=2时,当“7”作为“317”的一部分时,就结束了。

所以伪代码:

dp[0] = 1
for i in range(1, n + 1):
    for j in range(i - 1, -1, -1):
        dp[i] += dp[j]
        if int(s[j:i]) <= k:
            dp[i] += dp[j]
        else:
            break

最后考虑含0,但是k有限的情况
s = “1310110”, k = 400 为例
i = 0 时,对应s = ”“,可以解析成空数组 所以dp[0] = 1
i = 1 时,对应s = ”1“,只能解析成 [1], 所以 dp[1] = 1
i = 2 时,对应s = ”13“,只能解析成 [1, 3] 和 [13], 所以 dp[2] = dp[1] + dp[0] = 2
i = 3 时,对应s = ”131“,dp[3] = dp[2]+dp[1]+dp[0] = 4
i = 4 时,对应s = ”1310“,"0"不能单独加入,所以dp[3]pass,”0“可以作为数字10加入,dp[2],也可以作为数字310加入dp[1],所以dp[4] = dp[2] + dp[1] = 3
i = 5 时,对应s = “13101”,1单独+dp[4],“01”pass,“101”+dp[2],"3101"pass, dp[5]=dp[4]+dp[2]
i = 6 时,对应s = “131010”, “0”pass,“10”+dp[4],"010"pass,"1010"pass, dp[6]=dp[4]

class Solution:
    def numberOfArrays(self, s: str, k: int) -> int:
        n = len(s)
        dp = [0] * (n + 1)
        dp[0] = 1
        mod = 10 ** 9 + 7
        
        for i in range(1, n + 1):
            for j in range(i - 1, -1, -1):
                if s[j] == "0": continue
                if int(s[j:i]) <= k:
                    dp[i] += dp[j]
                else:
                    if s[i - 1] == "0" and dp[i] == 0: return 0
                    break

            dp[i] %= mod
                
        #print(dp)
        return dp[-1] % mod

来源

作者:hhxxxx
链接:https://leetcode-cn.com/problems/restore-the-array/solution/dong-tai-gui-hua-zhu-zi-fu-jie-xi-pan-duan-you-duo/

悲惨世界

在这里插入图片描述

你可能感兴趣的:(力扣日记)