作者: CheungQ

LeetCode刷题【1760】袋子里最少数目的球

给你一个整数数组 nums ,其中 nums[i] 表示第 i 个袋子里球的数目。同时给你一个整数 maxOperations 。

你可以进行如下操作至多 maxOperations 次:

  • 选择任意一个袋子,并将袋子里的球分到 2 个新的袋子中,每个袋子里都有 正整数 个球。
    • 比方说,一个袋子里有 5 个球,你可以把它们分到两个新袋子里,分别有 1 个和 4 个球,或者分别有 2 个和 3 个球。

你的开销是单个袋子里球数目的 最大值 ,你想要 最小化 开销。

请你返回进行上述操作后的最小开销。

 

示例 1:

输入:nums = [9], maxOperations = 2
输出:3
解释:
- 将装有 9 个球的袋子分成装有 6 个和 3 个球的袋子。[9] -> [6,3] 。
- 将装有 6 个球的袋子分成装有 3 个和 3 个球的袋子。[6,3] -> [3,3,3] 。
装有最多球的袋子里装有 3 个球,所以开销为 3 并返回 3 。

示例 2:

输入:nums = [2,4,8,2], maxOperations = 4
输出:2
解释:
- 将装有 8 个球的袋子分成装有 4 个和 4 个球的袋子。[2,4,8,2] -> [2,4,4,4,2] 。
- 将装有 4 个球的袋子分成装有 2 个和 2 个球的袋子。[2,4,4,4,2] -> [2,2,2,4,4,2] 。
- 将装有 4 个球的袋子分成装有 2 个和 2 个球的袋子。[2,2,2,4,4,2] -> [2,2,2,2,2,4,2] 。
- 将装有 4 个球的袋子分成装有 2 个和 2 个球的袋子。[2,2,2,2,2,4,2] -> [2,2,2,2,2,2,2,2] 。
装有最多球的袋子里装有 2 个球,所以开销为 2 并返回 2 。

示例 3:

输入:nums = [7,17], maxOperations = 2
输出:7

 

提示:

  • 1 <= nums.length <= 105
  • 1 <= maxOperations, nums[i] <= 109
Related Topics
  • 数组
  • 二分查找
  • \n
  • 👍 47
  • 👎 0
  • 题解

    
    
    //leetcode submit region begin(Prohibit modification and deletion)
    class Solution {
    
        public int minimumSize(int[] nums, int maxOperations) {
            int l=1;
            int r = 1000000000;
            int lastAvailable = 0;
            while (l <= r){
                int mid = l + (r-l)/2;
                if (available(nums, mid, maxOperations)){
                    //当前mid值能满足在maxOperations次数内,分袋完成
                    //可以尝试继续缩小mid值
                    r = mid-1;
                    lastAvailable = mid;
                }else{
                    //当前mid值不能满足在maxOperations次数内,分袋完成
                    //需要加大mid值再次尝试
                    l = mid+1;
                }
            }
           return lastAvailable;
        }
    
        /**
         *
         * @param nums 给予的数组
         * @param minShap  期望值
         * @param maxOperations
         * @return
         */
        private boolean available(int[] nums, int minShap, int maxOperations){
            int operateTimes = 0;
            for (int num : nums) {
                //挨个加上需要分袋的次数
                operateTimes += num/minShap;
                if (num % minShap == 0){
                    //如果是能整除的。比如有6个,每次分两个,只需要分2次,最后余下的2个留在袋子里
                    //而不是6/2=3次
                    operateTimes--;
                }
                if (operateTimes > maxOperations){
                    return false;
                }
            }
    
            return true;
        }
    }
    //leetcode submit region end(Prohibit modification and deletion)
    

    LeetCode刷题 【剑指 Offer 59-II】队列的最大值

    请定义一个队列并实现函数 max_value 得到队列里的最大值,要求函数max_valuepush_backpop_front均摊时间复杂度都是O(1)。

    若队列为空,pop_frontmax_value 需要返回 -1

    示例 1:

    输入: 
    ["MaxQueue","push_back","push_back","max_value","pop_front","max_value"]
    [[],[1],[2],[],[],[]]
    输出: [null,null,null,2,1,2]
    

    示例 2:

    输入: 
    ["MaxQueue","pop_front","max_value"]
    [[],[],[]]
    输出: [null,-1,-1]
    

     

    限制:

    • 1 <= push_back,pop_front,max_value的总操作数 <= 10000
    • 1 <= value <= 10^5
    Related Topics
  • 设计
  • 队列
  • 单调队列
  • \n
  • 👍 254
  • 👎 0
  • 题解

    思路和上一题【239】滑动窗口最大值类似,单调队列

    根据题面,我们必然需要维护一个队列用来从尾部插入新值,从头部弹出旧的值。接下来的问题就是怎么维护这个最大值,且这个最大值在从头部弹出后需要自动维护到比他小的一个值。所以这边就想到了用一个有序集合来维护这个大小排序的关系。

    同样的因为题面中的单向性,只从尾部新增,只从头部弹出,且只需要维护一个最大值的情况。可以试想下这样的场景,我们在依次从集合头部弹出数值,而此时的的最大值关系我们可以知道从头部到最大值之间的关系是不需要维护的。

    而当最大值弹出的时候,我们只需要知道从最大值的位置到末尾的位置之间的最大值即可。那么思路就自然出来了。

    
    import java.util.LinkedList;
    
    //leetcode submit region begin(Prohibit modification and deletion)
    class MaxQueue {
    
        private LinkedList<Integer> maxValueList = new LinkedList<>();
    
        private LinkedList<Integer> queue = new LinkedList<>();
    
        public MaxQueue() {
    
        }
    
        //取最大值
        public int max_value() {
            if (!maxValueList.isEmpty()){
                return maxValueList.getFirst();
            }
            return -1;
        }
        //往尾添加一个
        public void push_back(int value) {
            queue.addLast(value);
            while (!maxValueList.isEmpty() && maxValueList.getLast() <= value){
                maxValueList.pollLast();
            }
            maxValueList.addLast(value);
        }
        //从头部弹出
        public int pop_front() {
            if (queue.isEmpty()){
                return -1;
            }
            if (queue.peekFirst().equals(maxValueList.getFirst())){
                maxValueList.pollFirst();
            }
            return queue.pollFirst();
        }
    }
    
    /**
     * Your MaxQueue object will be instantiated and called as such:
     * MaxQueue obj = new MaxQueue();
     * int param_1 = obj.max_value();
     * obj.push_back(value);
     * int param_3 = obj.pop_front();
     */
    //leetcode submit region end(Prohibit modification and deletion)
    

    LeetCode刷题【239】滑动窗口最大值

    给你一个整数数组 nums,有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

    返回滑动窗口中的最大值。

     

    示例 1:

    输入:nums = [1,3,-1,-3,5,3,6,7], k = 3
    输出:[3,3,5,5,6,7]
    解释:
    滑动窗口的位置                最大值
    ---------------               -----
    [1  3  -1] -3  5  3  6  7       3
     1 [3  -1  -3] 5  3  6  7       3
     1  3 [-1  -3  5] 3  6  7       5
     1  3  -1 [-3  5  3] 6  7       5
     1  3  -1  -3 [5  3  6] 7       6
     1  3  -1  -3  5 [3  6  7]      7
    

    示例 2:

    输入:nums = [1], k = 1
    输出:[1]
    

    示例 3:

    输入:nums = [1,-1], k = 1
    输出:[1,-1]
    

    示例 4:

    输入:nums = [9,11], k = 2
    输出:[11]
    

    示例 5:

    输入:nums = [4,-2], k = 2
    输出:[4]

     

    提示:

    • 1 <= nums.length <= 105
    • -104 <= nums[i] <= 104
    • 1 <= k <= nums.length
    Related Topics
  • 队列
  • 数组
  • 滑动窗口
  • 单调队列
  • 堆(优先队列)
  • \n
  • 👍 1058
  • 👎 0
  • 题解

    单调队列解法,从思路来说,最基础的

    1.长度为k的区间,每挪一次,算一下区间内的最大值,这是最基础的算法

    2.每挪一次,其实相比上次只有两个值有变化,挪动之后去除掉了当前区间的前一位,和新增的当前区间的最后一位

    3.基于2的结论,我们需要对当前区间内的K位数字进行排序。到这里,我们可以试着用堆来处理这个问题了

    4.基于前面的基础,因为这长度为k的窗口是一直单向的往后滑动的,所以,假如我们在长度为k的窗口内,下标位置为n的位置为当前窗口区间内的最大值,其实我们需要的值就剩下n位置,和n位置到窗口末尾的一个递减的有序集合。而每往后挪动一次,前面比当前位置的值小的就都可以去掉。于是,新的题解思路就出来了

    
    
    import java.util.LinkedList;
    
    //leetcode submit region begin(Prohibit modification and deletion)
    class Solution {
        private LinkedList<Integer> list = new LinkedList<Integer>();
    
    
        public int[] maxSlidingWindow(int[] nums, int k) {
            int[] res = new int[nums.length-k+1];
    
            for (int i = 0; i < nums.length; i++) {
                if (list.size()==0){
                    list.add(i);
                }else {
    
    //有个判空,不然会报空指针
                    while (list.size()>0 && nums[list.getLast()] <= nums[i]){
    
    //如果末尾的值比当前值小,那么删除
                        list.pollLast();
                    }
                    list.addLast(i);
                    if (list.getFirst() <= i-k){//判断头部最大的值有没有超出当前区间
                        list.pollFirst();
                    }
                }
                if (i+1>=k){//边界值比较容易绕,可以拿简单的i=0,k=1的情况来模拟下
                    res[i-k+1] = nums[list.peekFirst()];
                }
            }
    
            return res;
        }
    }
    //leetcode submit region end(Prohibit modification and deletion)

    LeetCode刷题【1423】可获得的最大点数

    几张卡牌 排成一行,每张卡牌都有一个对应的点数。点数由整数数组 cardPoints 给出。

    每次行动,你可以从行的开头或者末尾拿一张卡牌,最终你必须正好拿 k 张卡牌。

    你的点数就是你拿到手中的所有卡牌的点数之和。

    给你一个整数数组 cardPoints 和整数 k,请你返回可以获得的最大点数。

     

    示例 1:

    输入:cardPoints = [1,2,3,4,5,6,1], k = 3
    输出:12
    解释:第一次行动,不管拿哪张牌,你的点数总是 1 。但是,先拿最右边的卡牌将会最大化你的可获得点数。最优策略是拿右边的三张牌,最终点数为 1 + 6 + 5 = 12 。
    

    示例 2:

    输入:cardPoints = [2,2,2], k = 2
    输出:4
    解释:无论你拿起哪两张卡牌,可获得的点数总是 4 。
    

    示例 3:

    输入:cardPoints = [9,7,7,9,7,7,9], k = 7
    输出:55
    解释:你必须拿起所有卡牌,可以获得的点数为所有卡牌的点数之和。
    

    示例 4:

    输入:cardPoints = [1,1000,1], k = 1
    输出:1
    解释:你无法拿到中间那张卡牌,所以可以获得的最大点数为 1 。 
    

    示例 5:

    输入:cardPoints = [1,79,80,1,1,1,200,1], k = 3
    输出:202
    

     

    提示:

    • 1 <= cardPoints.length <= 10^5
    • 1 <= cardPoints[i] <= 10^4
    • 1 <= k <= cardPoints.length
    Related Topics
  • 数组
  • 前缀和
  • 滑动窗口
  • \n
  • 👍 173
  • 👎 0
  • 题解

    上手直接开始想象下,k次取牌,那么这k张牌可以分为两个部分,从左边取的left张,和从右边取的right张,且left+right = k

    那么接下来就是挨个情况求和,然后求出一个最大值了,假设求得的合为sum,左边求得的合为sum_left,右边求得的合为sum_right,就有sum = sum_left + sum_right。

    那么分别分情况来,假设left是每次减一个位置,right是每次加一个位置

    第一次,左边left_1个的时候,右边对应right_1个有sum_1 = sum_left_1 + sum_right_1

    第二次,左边left_2个的时候,右边对应right_2个有sum_2 = sum_left_2 + sum_right_2

    第三次,哦,不是,这时候我们可以看到sum_left_2 = sum_left_1 – 第left_1位的值,sum_right_2 = sum_right_1 + 第right_2位的值

    这样基本的模式就可以看出来了,就是窗口模式,如果还没明白的话,试想着将cardPoints 数组首位相连,连接成一个环状,这样是不是就显而易见了。

    直接上代码

    
    import java.util.Arrays;
    
    //leetcode submit region begin(Prohibit modification and deletion)
    class Solution {
        public int maxScore(int[] cardPoints, int k) {
            int maxSum = 0;
            //左边全选拉满来一次作为基本值
            for (int i = 0; i < cardPoints.length && i < k; i++) {
                maxSum += cardPoints[i];
            }
            if (k >= cardPoints.length){
                //如果k的值比cardPoints长度长,或者等于长度
                return maxSum;
            }
            //此时左边取了k个,右边取了0个
            //那么继续滑动窗口左边减一个,右边加一个
            int lastSum = maxSum;
            for (int right = 1; right <= k; right++) {
                lastSum = lastSum - cardPoints[k-right] + cardPoints[cardPoints.length-1-(right-1)];
                maxSum = Math.max(maxSum, lastSum);
            }
    
            return maxSum;
        }
    }

    既然我们已经用了滑动窗口,那么不妨可以再回来看下这个数组

    除去头和尾巴的两段连起来做滑动窗口,其实可以把中间没有选择的cardPoints.length-k张牌作为另一个滑动窗口来看待,那么相对的,就是要求这个滑动窗口取得最大值的时候,再拿所有合减去这个最大的值就是所求目标值

    逻辑基本相同的代码省略

    LeetCode刷题【35】搜索插入

    给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。如果目标值不存在于数组中,返回它将会被按顺序插入的位置。

    你可以假设数组中无重复元素。

    示例 1:

    输入: [1,3,5,6], 5
    输出: 2
    

    示例 2:

    输入: [1,3,5,6], 2
    输出: 1
    

    示例 3:

    输入: [1,3,5,6], 7
    输出: 4
    

    示例 4:

    输入: [1,3,5,6], 0
    输出: 0
    
    Related Topics
  • 数组
  • 二分查找
  • \n
  • 👍 948
  • 👎 0
  • 题解

    把头尾情况单独处理了去掉,剩下的用二分法无限逼近目标位置,得到left的值

    之后再再小区间内做个遍历循环,二分法本身应该是有办法可以取到准确的目标位置的,但是这个里面边界判断的情况实在是有点头疼,于是就取个巧,最终位置无限逼近之后,再前后扩展一位进行大小判断

    
    
    
    //leetcode submit region begin(Prohibit modification and deletion)
    class Solution {
        public static int searchInsert(int[] nums, int target) {
            //请在此作答
            if(null==nums || nums.length == 0 || target < nums[0] || nums[0] == target){
                return 0;
            }
            if (nums[nums.length-1] == target){
                return nums.length-1;
            }
            if (nums[nums.length-1] < target){
                return nums.length;
            }
            int left = 0;
            int right = nums.length-1;
    
            while (left < right){
                int mid = left + (right-left)/2;
                if (nums[mid] == target){
                    return mid;
                }
                if (nums[mid] > target){
                    right = mid-1;
                }else{
                    left = mid+1;
                }
    
            }
            for (int i = left-1; i <= left+1; i++) {
                if (i<0 || i>= nums.length){
                    continue;
                }
                if (nums[i] == target){
                    return i;
                }
                if (nums[i] < target && nums[i+1] > target){
                    return i+1;
                }
            }
    
            return left;
    
    
    
        }
    }
    //leetcode submit region end(Prohibit modification and deletion)

    LeetCode刷题【140】单词拆分

    给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict,在字符串中增加空格来构建一个句子,使得句子中所有的单词都在词典中。返回所有这些可能的句子。

    说明:

    • 分隔时可以重复使用字典中的单词。
    • 你可以假设字典中没有重复的单词。

    示例 1:

    输入:
    s = "catsanddog"
    wordDict = ["cat", "cats", "and", "sand", "dog"]
    输出:
    [
      "cats and dog",
      "cat sand dog"
    ]
    

    示例 2:

    输入:
    s = "pineapplepenapple"
    wordDict = ["apple", "pen", "applepen", "pine", "pineapple"]
    输出:
    [
      "pine apple pen apple",
      "pineapple pen apple",
      "pine applepen apple"
    ]
    解释: 注意你可以重复使用字典中的单词。
    

    示例 3:

    输入:
    s = "catsandog"
    wordDict = ["cats", "dog", "sand", "and", "cat"]
    输出:
    []
    
    Related Topics
  • 字典树
  • 记忆化搜索
  • 哈希表
  • 字符串
  • 动态规划
  • 回溯
  • \n
  • 👍 475
  • 👎 0
  • 题解

    
    import java.util.ArrayList;
    import java.util.HashSet;
    import java.util.List;
    
    //leetcode submit region begin(Prohibit modification and deletion)
    class Solution {
        private List<String> res = new ArrayList<>();
        private HashSet<String> hashSet;
        private String testString;
    
        public List<String> wordBreak(String s, List<String> wordDict) {
            char[] chars = s.toCharArray();
            hashSet = new HashSet<>(wordDict);
            testString = s;
            List<String> stringList = new ArrayList<>();
            traceback(0,stringList);
            return res;
        }
    
    
        /**
         * 回溯模板
         * 这里的边界需要仔细考虑下。不过可以套个简单的方法
         * 假如字符串长度为1,那么截取的话应该是从index=0,截取到index=1
         * 所以最终的终止位置应该是和字符串的长度一致的
         */
        private void traceback(int startPosition,List<String> stringList){
            if (startPosition == testString.length()){
                res.add(listToString(stringList));
            }
            for (int endPosition = startPosition+1;endPosition<= testString.length();endPosition++){
                String subString = testString.substring(startPosition,endPosition);
    //            System.out.println(subString);
                if (!hashSet.contains(subString)){
                    continue;
                }
                stringList.add(subString);
                //向下嵌套
                traceback(endPosition,stringList);
                //退一次操作
                stringList.remove(stringList.size()-1);
            }
        }
    
    
        /**
         * 数组转换字符串的方法
         * @param stringList
         * @return
         */
        private String listToString(List<String> stringList){
            StringBuilder sb = new StringBuilder();
            for (String str: stringList){
                if (sb.length()>0){
                    sb.append(" ");
                }
                sb.append(str);
            }
            return sb.toString();
        }
    
    }
    //leetcode submit region end(Prohibit modification and deletion)
    

    LeetCode刷题【17】电话号码的字母组合

    给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

    给出数字到字母的映射如下(与电话按键相同)。注意 1 不对应任何字母。

     

    示例 1:

    输入:digits = "23"
    输出:["ad","ae","af","bd","be","bf","cd","ce","cf"]
    

    示例 2:

    输入:digits = ""
    输出:[]
    

    示例 3:

    输入:digits = "2"
    输出:["a","b","c"]
    

     

    提示:

    • 0 <= digits.length <= 4
    • digits[i] 是范围 ['2', '9'] 的一个数字。
    Related Topics
  • 哈希表
  • 字符串
  • 回溯
  • \n
  • 👍 1372
  • 👎 0
  • 题解

    看到题目第一印象是遍历多重循环,然后想了下好像不对,给定的字符串长度不定,瞅了一眼评论区,基本都是回溯,emmmmmmm

    想玩点花的,突然想到之前有做过一个转盘锁的,于是计上心来,动手开始撸,

    直白点的说明的话,就是说,从[0,0,0,0.....,0]枚举到[3,3,4,3,....4]这样的组合

    class Solution {
        private char[][] map = new char[][]{
                {97,98,99,0},    {100,101,102,0},
                {103,104,105,0},  {106,107,108,0}, {109,110,111,0},
                {112,113,114,115},{116,117,118,0}, {119,120,121,122}
        };
    
        public List<String> letterCombinations(String digits) {
    //        String n = "0123456789";//48-57
            char[] nCharArr = digits.toCharArray();
            int charLength = nCharArr.length;
            if (charLength ==0){
                return new ArrayList<>();
            }
            int count = 1;
            for (char c : nCharArr) {
                if (map[c-50][3]==0){
                    count = count * 3;
                }else{
                    count = count * 4;
                }
            }
            char[][] res = new char[count][charLength];
            int[] stepCount = new int[charLength];
            Arrays.fill(stepCount,0);
            for (int i = 0; i < count; i++) {
                for (int j = 0; j < stepCount.length; j++) {
                    res[i][j] = map[nCharArr[j]-50][stepCount[j]];
                }
                stepInc( nCharArr, stepCount );
            }
            List<String> resList = new ArrayList<>();
            for (char[] re : res) {
                resList.add(new String(re));
            }
    //        System.out.println(res);
            return resList;
        }
    
        private void stepInc(char[] nCharArr, int[] stepCount){
            boolean willPlus = true;
            for (int i = 0; i < stepCount.length; i++) {
                int index = stepCount.length - i - 1;
                if (willPlus){
                    stepCount[index] = stepCount[index]+1;
                    if(map[nCharArr[index]-50][3]==0){
                        //满3进
                        if (stepCount[index]==3){
                            stepCount[index]=0;
                        }else{
                            willPlus = false;
                        }
                    }else{
                        //满4进
                        if (stepCount[index]==4){
                            stepCount[index]=0;
                        }else{
                            willPlus = false;
                        }
                    }
                }
            }
        }
    }
    

    写完跑了下,居然过了,差点被自己笑到。。。