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

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];
    }
}

 

你可能感兴趣的:(leetcode)