LeetCode第288场周赛

📒博客首页：崇尚学技术的科班人
🍣今天给大家带来的文章是《LeetCode第288场周赛》🍣
🍣希望各位小伙伴们能够耐心的读完这篇文章🍣
🙏博主也在学习阶段，如若发现问题，请告知，非常感谢🙏
💗同时也非常感谢各位小伙伴们的支持💗

文章目录

• 🚀<1> 第一题🚀
• • ✨题目✨
  • ✨示例✨
  • ✨提示✨
  • ⭐思路⭐
  • ✨代码实现✨
  • ✨运行结果✨
• 🚀<2> 第二题🚀
• • ✨题目✨
  • ✨示例✨
  • ✨提示✨
  • ⭐思路⭐
  • ✨代码实现✨
  • ✨运行结果✨
• 🚀<3> 第三题🚀
• • ✨题目✨
  • ✨示例✨
  • ✨提示✨
  • ⭐思路⭐
  • ✨代码实现✨
  • ✨运行结果✨

前言：好久没有打周赛了，本来以为手会有点生，但是还是 a了3道，最后一题过了两个样例，本来以为要 AK 了，但还是 WA 了 。

有点遗憾 😫😫。

不过排名上升了不少，不知道能不能加大分。

废话不多说，直接上题目。

---

🚀<1> 第一题🚀 ✨题目✨

按奇偶性交换后的最大数字

给你一个正整数 num 。

你可以交换 num 中 奇偶性 相同的任意两位数字（即，都是奇数或者偶数）。

返回交换 任意 次之后 num 的 最大 可能值。

✨示例✨

• 示例1：

输入：num = 1234
输出：3412
解释：交换数字 3 和数字 1 ，结果得到 3214 。


交换数字 2 和数字 4 ，结果得到 3412 。


注意，可能存在其他交换序列，但是可以证明 3412 是最大可能值。


注意，不能交换数字 4 和数字 1 ，因为它们奇偶性不同。

• 示例2：

输入：num = 65875
输出：87655
解释：交换数字 8 和数字 6 ，结果得到 85675 。


交换数字 5 和数字 7 ，结果得到 87655 。


注意，可能存在其他交换序列，但是可以证明 87655 是最大可能值。

✨提示✨

• 1 <= num <= 109

⭐思路⭐

• 思路

其实周赛第一题的数据范围啥的都不会太大，所以说你暴力的话是基本上都能过的。

这道题是签到题，我的做法就是模拟这个过程，我们先将 奇数和偶数 进行分离，在分离的过程中我们需要记录下对应的原数中奇数偶数所在的位置，然后进行排序。

然后按照对应的原数中奇偶数位置进行放置，记得大的要放在前面，这样才能保证结果最大。

✨代码实现✨

class Solution {
    static int num2 = 0, num1 = 0;
    public int getLen(int num){
        int len = 0;
        while(num != 0){
            len ++;
            int r = num % 10;
            if(r % 2 == 0){
                num2 ++;
            }else{
                num1 ++;
            }
            num /= 10;
        }
        return len;
    }
    public void deal(int num,int[] j,int[] o,boolean[] vis){
        int index = 0;
        int o1 = 0, j1 = 0;
        while(num != 0){
            int r = num % 10;
            if(r % 2 == 0){
                o[o1 ++] = r;
                vis[index] = true;
            }else{
                j[j1 ++] = r;
            }
            num /= 10;
            index ++;
        }
    }
    public int largestInteger(int num) {
        int len = getLen(num);
        boolean[] vis = new boolean[len];
        int[] j = new int[num1];
        int[] o = new int[num2];
        deal(num,j,o,vis);
        Arrays.sort(j);
        Arrays.sort(o);
        int nums = 0;
        int j1 = num1 - 1;
        int o1 = num2 - 1;
       
        for(int i = len - 1; i >= 0; i --){
            nums *= 10;
            if(vis[i] == true){
                nums += o[o1 --];
            }else{
                nums += j[j1 --];
            }
        }
        return nums;
    }
}

✨运行结果✨

🚀<2> 第二题🚀 ✨题目✨

向表达式添加括号后的最小结果

给你一个下标从 0 开始的字符串 expression ，格式为 "+" ，其中 和 表示正整数。

请你向 expression 中添加一对括号，使得在添加之后， expression 仍然是一个有效的数学表达式，并且计算后可以得到 最小 可能值。

左括号 必须 添加在 '+' 的左侧，而右括号必须添加在 '+' 的右侧。

返回添加一对括号后形成的表达式 expression ，且满足 expression 计算得到 最小 可能值。

如果存在多个答案都能产生相同结果，返回任意一个答案。

生成的输入满足： expression 的原始值和添加满足要求的任一对括号之后 expression 的值，都符合 32-bit 带符号整数范围。

✨示例✨

• 示例1：

输入：expression = "247+38"
输出："2(47+38)"
解释：表达式计算得到 2 * (47 + 38) = 2 * 85 = 170 。


注意 "2(4)7+38" 不是有效的结果，因为右括号必须添加在 '+' 的右侧。


可以证明 170 是最小可能值。

• 示例2：

输入：expression = "12+34"
输出："1(2+3)4"
解释：表达式计算得到 1 * (2 + 3) * 4 = 1 * 5 * 4 = 20 。

• 示例3：

输入：expression = "999+999"
输出："(999+999)"
解释：表达式计算得到 999 + 999 = 1998 。

✨提示✨

• 3 <= expression.length <= 10
• expression 仅由数字 '1' 到 '9' 和 '+' 组成
• expression 由数字开始和结束
• expression 恰好仅含有一个 '+'.
• expression 的原始值和添加满足要求的任一对括号之后 expression 的值，都符合 32-bit 带符号整数范围

⭐思路⭐

• 思路

其实这道题只是一道暴力题，看数据范围就可以知道了，我们首先照着 + 进行分割开，然后枚举两边 **()**的放置位置，然后进行判断求最小值。

✨代码实现✨

class Solution {
    String ans = null;
    int min = Integer.MAX_VALUE;
    public String minimizeResult(String e) {
        String[] s = e.split("\+");
        int n = s[0].length();
        int m = s[1].length();
        for(int i = 1; i <= n;i ++){
            for(int j = 1; j <= m; j ++){
                String s1 = "";
                if(i != 1) s1 = s[0].substring(0,i - 1);
                String s2 = s[0].substring(i - 1,n);
                
                String s3 = s[1].substring(0,j);
                String s4 = "";
                if(j != m) s4 = s[1].substring(j,m);
                
                int nums = 0;
                nums = Integer.parseInt(s2) + Integer.parseInt(s3);
                if(!s1.equals("")) nums *= Integer.parseInt(s1);
                if(!s4.equals("")) nums *= Integer.parseInt(s4);
                if(nums < min){
                    ans = s1 + '(' + s2 + '+' + s3 + ')' + s4;
                    min = nums;
                    
                }
                //System.out.println(nums);
            }
        }
        //System.out.println(min);
        return ans;
    }
}

✨运行结果✨

🚀<3> 第三题🚀 ✨题目✨

K 次增加后的最大乘积

给你一个非负整数数组 nums 和一个整数 k 。

每次 *** 作，你可以选择 nums 中 任一 元素并将它 增加 1 。

请你返回 至多 k 次 *** 作后，能得到的 nums 的 最大乘积 。

由于答案可能很大，请你将答案对 109 + 7 取余后返回。

✨示例✨

• 示例1：

输入：nums = [0,4], k = 5
输出：20
解释：将第一个数增加 5 次。


得到 nums = [5, 4] ，乘积为 5 * 4 = 20 。


可以证明 20 是能得到的最大乘积，所以我们返回 20 。


存在其他增加 nums 的方法，也能得到最大乘积。

• 示例2：

输入：nums = [6,3,3,2], k = 2
输出：216
解释：将第二个数增加 1 次，将第四个数增加 1 次。


得到 nums = [6, 4, 3, 3] ，乘积为 6 * 4 * 3 * 3 = 216 。


可以证明 216 是能得到的最大乘积，所以我们返回 216 。


存在其他增加 nums 的方法，也能得到最大乘积。

✨提示✨

• 1 <= nums.length, k <= 10^5
• 0 <= nums[i] <= 10^6

⭐思路⭐

• 思路

这道题的思路就是我们增加的元素一定要是数组中最小的元素。

我们每一次增加 1， 需要将该元素重新放入优先级队列中。

然后直到 k减为0。

还有一个注意点就是我们这里求乘积的时候必须要使用 long，不然会导致爆 int。

那么为什么是最小的元素呢？

因为你想一想，如果增加的是最大的元素的话，那么你增加 1 产生的效果就是除了 这个最大的数的其它数的乘积，那么显然小于 增加的是最小的元素产生的效果。

所以每一次增加的是 最小的元素。

✨代码实现✨

class Solution {
    int mod = 1000000000 + 7;
    public int maximumProduct(int[] nums, int k) {
        PriorityQueue<Integer> q = new PriorityQueue<>();
        for(int num : nums){
            q.offer(num);
        }
        while(k -- > 0){
            int num = q.poll();
            q.offer(++ num);
        }
        long num = 1;
        while(!q.isEmpty()){
            int t = q.poll();
            //System.out.println(num * t);
            num = (num * t) % mod;
            //System.out.println(t + " " + num);
        }
        return (int)num;
    }
}

✨运行结果✨