【力扣夜貓雙週賽】第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/

悲慘世界