leetcode第 24 場雙週賽

時間:2020/4/18 22:30-24:00

第一題、逐步求和得到正數的最小值

難度:easy,鏈接：https://leetcode-cn.com/problems/minimum-value-to-get-positive-step-by-step-sum/

給你一個整數數組 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 {
    public int minStartValue(int[] nums) {
        int res = 1;
        int sum = 0;
        for (int i = 0; i < nums.length; i++)
        {
            sum += nums[i];
            if (sum <= 0)
                res = Math.max(res,1 - sum);
        }
        return res;
    }
}

 

第二題、和爲 K 的最少斐波那契數字數目

難度:medium,鏈接:https://leetcode-cn.com/problems/find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/

給你數字 k ，請你返回和爲 k 的斐波那契數字的最少數目，其中，每個斐波那契數字都可以被使用多次。

斐波那契數字定義爲：

• F1 = 1
• F2 = 1
• Fn = Fn-1 + Fn-2 ， 其中 n > 2 。

數據保證對於給定的 k ，一定能找到可行解。

1 <= k <= 10^9

輸入：k = 7
輸出：2
解釋：斐波那契數字爲：1，1，2，3，5，8，13，……
對於 k = 7 ，我們可以得到 2 + 5 = 7 。

思路：因爲k <= 10^9,而斐波那契數列基本是以指數增長的，所以提前計算出前一百個斐波那契數（實際上一百個也多了，但沒有細算最少需要多少個了)，然後用貪心，找出小於k的最大斐波那契數，減去這個數，然後用差再進行一輪相同的運算，直到結束。

class Solution {
    public int findMinFibonacciNumbers(int k) {
        int[] fibo = new int[100];
        int fibolen = 0;
        fibo[0] = 1;
        fibo[1] = 1;
        for (int i = 2; i < 100; i++)
        {
            fibo[i] = fibo[i -  1] + fibo[i - 2];
            if (fibo[i] > Math.pow(10,9)) 
            {
                fibolen = i;
                break;
            }
        }
        int res = 0;
        while (k > 0)
        {
            if (fibo[fibolen] > k) fibolen--;
            else 
            {
                res++;
                k -= fibo[fibolen];
            }
        }
        return res;
    }
}

 

第三題、長度爲 n 的開心字符串中字典序第 k 小的字符串

難度：medium，鏈接：https://leetcode-cn.com/problems/the-k-th-lexicographical-string-of-all-happy-strings-of-length-n/

一個 「開心字符串」定義爲：

• 僅包含小寫字母 ['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 個，那麼請你返回 空字符串 。

輸入：n = 1, k = 3
輸出："c"
解釋：列表 ["a", "b", "c"] 包含了所有長度爲 1 的開心字符串。按照字典序排序後第三個字符串爲 "c" 。

思路：dfs深搜，暴力回溯即可。

class Solution {
    int num = 0;
    char[] character = {'a','b','c'};
    public String getHappyString(int n, int k) {
        if (n == 1)
        {
            return k <= 3 ? "" + character[k - 1] : ""; 
        }
        String res = dfs("a",n,k);
        if (res == "")
        {
            res = dfs("b",n,k);
        }
        if (res == "")
        {
            res = dfs("c",n,k);
        }
        return res;
    }
    
    String dfs(String s,int n,int k)
    {
        if (s.length() == n)
        {
            num++;
            if (num == k) return s;
            else return "";
        }
        else 
        {
            for (int i = 0; i < 3; i++)
            {
                if (s.charAt(s.length() - 1) != character[i])
                {
                    String temp = dfs(s + character[i] , n, k);
                    if ( temp == "") ;
                    else return temp;
                }
            }
            return "";
        }
    }
    
}

 

第四題、恢復數組

某個程序本來應該輸出一個整數數組。但是這個程序忘記輸出空格了以致輸出了一個數字字符串，我們所知道的信息只有：數組中所有整數都在 [1, k] 之間，且數組中的數字都沒有前導 0 。

給你字符串 s 和整數 k 。可能會有多種不同的數組恢復結果。

按照上述程序，請你返回所有可能輸出字符串 s 的數組方案數。

由於數組方案數可能會很大，請你返回它對 10^9 + 7 取餘 後的結果。

輸入：s = "1000", k = 10000
輸出：1
解釋：唯一一種可能的數組方案是 [1000]

輸入：s = "1000", k = 10
輸出：0
解釋：不存在任何數組方案滿足所有整數都 >= 1 且 <= 10 同時輸出結果爲 s 。

• 1 <= s.length <= 10^5.
• s 只包含數字且不包含前導 0 。
• 1 <= k <= 10^9.

思路：這種給一個整數數組的一般都可以往dp上去想，dp[i]代表s長度爲i的子串的數組恢復方案數，dp[i] = sum(dp[j),其中j<i且j+1到i的數小於k，且j+1到i的數不以0開頭)，注意點就是要注意越界，得用long存儲。

class Solution {
    public int numberOfArrays(String s, int k) {
        int mo = 1000000007;//題意中取模的要求
        int len = s.length();
        int[] dp = new int[len + 1];//dp[i]代表s長度爲i的子串的數組恢復方案數
        dp[0] = 1;
        for (int i = 1; i <= len; i++)
        {
            long base = 1;//代表進制
            long sum = 0;//求和
            for (int j = i - 1; j >= 0 && j >= i - 16; --j)//超過16就越界了
            {
                sum += base * (s.charAt(j)  - 48);//計算當前字串的數，超過k就退出循環
                base *= 10;
                if (sum > k) break;
                if (s.charAt(j) != '0')//等於0就不考慮
                {
                    
                    dp[i] = (dp[i] % mo + dp[j] % mo) % mo;//取模
                }
            }
        }
        return dp[len];
    }
}