[Leetcode Weekly Contest]288
链接：LeetCode
[Leetcode]2231. 按奇偶性交换后的最大数字
给你一个正整数 num 。你可以交换 num 中 奇偶性 相同的任意两位数字（即，都是奇数或者偶数）。
返回交换 任意 次之后 num 的 最大 可能值。
遍历即可。
class Solution {
public int largestInteger(int num) {
List<Character> even = new ArrayList<>();
List<Character> odd = new ArrayList<>();
char[] numChars = String.valueOf(num).toCharArray();
for(var ch: numChars) {
if(((int)(ch-'0') & 1) != 0) odd.add(ch);
else even.add(ch);
}
even.sort((a,b) -> b-a);
odd.sort((a,b) -> b-a);
int res = 0;
int even_ind = 0, odd_ind = 0;
for(var ch: numChars) {
if(((int)(ch-'0') & 1) != 0) {
res = res * 10 + (int)(odd.get(odd_ind)-'0');
odd_ind ++;
}
else {
res = res * 10 + (int)(even.get(even_ind)-'0');
even_ind ++;
}
}
return res;
}
}
[Leetcode]2232. 向表达式添加括号后的最小结果
给你一个下标从 0 开始的字符串 expression ，格式为 \("<num1>+<num2>"\) ，其中 \(<num1>\) 和 \(<num2>\) 表示正整数。
请你向 expression 中添加一对括号，使得在添加之后， expression 仍然是一个有效的数学表达式，并且计算后可以得到 最小 可能值。左括号 必须 添加在 '+' 的左侧，而右括号必须添加在 '+' 的右侧。
返回添加一对括号后形成的表达式 expression ，且满足 expression 计算得到 最小 可能值。如果存在多个答案都能产生相同结果，返回任意一个答案。
生成的输入满足：expression 的原始值和添加满足要求的任一对括号之后 expression 的值，都符合 32-bit 带符号整数范围。
遍历左括号和右括号的位置即可。
class Solution {
public String minimizeResult(String expression) {
int add_idx = -1;
for(int i=0;i<expression.length();++i) {
if(expression.charAt(i) == '+') add_idx =i;
}
String res = expression;
int min_value = Integer.MAX_VALUE;
for(int left = 0;left<add_idx; ++left){
for(int right = add_idx+1; right<expression.length(); ++right) {
if(getResult(expression, add_idx, left, right) < min_value) {
min_value = getResult(expression, add_idx, left, right);
res = insertToString(expression, left, right);
}
}
}
return res;
}
public String insertToString(String expression, int left, int right) {
StringBuilder sb = new StringBuilder();
for(int i = 0;i<expression.length();++i) {
if(i==left) sb.append('(');
sb.append(expression.charAt(i));
if(i == right) sb.append(')');
}
return sb.toString();
}
public int getResult(String expression, int add_idx, int left, int right) {
int res = 0;
int left_value = 1, right_value = 1;
if(left!=0) left_value = getValue(expression, 0, left-1);
int mid_value = getValue(expression, left, add_idx-1) + getValue(expression, add_idx+1, right);
if(right!=expression.length()-1) right_value = getValue(expression, right+1, expression.length()-1);
return left_value * mid_value * right_value;
}
public int getValue(String expression, int start, int end) {
int res = 0;
for(int ind = start;ind <= end; ind++) {
res = res * 10 + (int)(expression.charAt(ind)-'0');
}
return res;
}
}
[Leetcode]2233. K 次增加后的最大乘积
给你一个非负整数数组 nums 和一个整数 k 。每次操作，你可以选择 nums 中 任一 元素并将它 增加 1 。
请你返回 至多 k 次操作后，能得到的 nums的 最大乘积 。由于答案可能很大，请你将答案对 109 + 7 取余后返回。
class Solution {
public int maximumProduct(int[] nums, int k) {
Queue<Integer> queue=new PriorityQueue<>((o1,o2)->o1-o2);
for(int num:nums){
queue.add(num);
}
while(k>0){
Integer peek = queue.poll();
queue.add(peek+1);
k --;
}
long ans=1;
while(!queue.isEmpty()){
Integer peek = queue.poll();
ans=(ans*peek)%1000000007L;
}
return (int)ans;
}
}
[Leetcode]2234. 花园的最大总美丽值
Alice 是 n 个花园的园丁，她想通过种花，最大化她所有花园的总美丽值。
给你一个下标从 0 开始大小为 n 的整数数组 flowers ，其中 flowers[i] 是第 i 个花园里已经种的花的数目。已经种了的花 不能 移走。同时给你 newFlowers ，表示 Alice 额外可以种花的 最大数目 。同时给你的还有整数 target ，full 和 partial 。
如果一个花园有 至少 target 朵花，那么这个花园称为 完善的 ，花园的 总美丽值 为以下分数之 和 ：
- 完善 花园数目乘以 full.
- 剩余 不完善 花园里，花的 最少数目 乘以 partial 。如果没有不完善花园，那么这一部分的值为 0 。
请你返回 Alice 种最多 newFlowers 朵花以后，能得到的 最大 总美丽值。
容易想到， 我们可以枚举完善花园数目，来求最大总美丽值。
首先明确 , newFlowers 是不需要用完的 , 所以如果我们要对 x 个花坛进行完善 , 我们选择最多花朵的花坛进行完善一定是最优的 (此时消耗的 newFlowers 最少)。那么在剩下的 n - x 个 不完善 的花坛我们二分最后的 最小值 使其最大 即可。
难点在于，我们在 二分中需要用 前缀和 + 二分 再一步优化。
class Solution {
public long maximumBeauty(int[] flowers, long newFlowers, int target, int full, int partial) {
long res = 0;
int n = flowers.length;
List<Integer> UpperBounderflowers = new ArrayList<>();
for(int flower: flowers) UpperBounderflowers.add(Math.min(flower, target));
UpperBounderflowers.sort((o1,o2)->o2-o1);
long[] perfixSum = new long[n];
long cur = 0;
int idx = 0;
for(int flower: UpperBounderflowers) {
cur += flower;
perfixSum[idx] = cur;
idx ++;
}
for(int perfect_count=0;perfect_count<=flowers.length;perfect_count++) {
long perfect_garden_flowers_need = 0;
if(perfect_count >0) perfect_garden_flowers_need = (long)target * perfect_count - perfixSum[perfect_count-1];
if(perfect_count < flowers.length && UpperBounderflowers.get(perfect_count) >= target) continue;
if(perfect_garden_flowers_need > newFlowers) break;
if(perfect_count == flowers.length) {
res = Math.max(res, (long)full * perfect_count);
break;
}
long rest_flowers = newFlowers - perfect_garden_flowers_need;
int min_partial_flowers = getPartialCount(UpperBounderflowers, perfect_count, rest_flowers, target, perfixSum);
res = Math.max(res, (long)perfect_count * full + (long)min_partial_flowers * partial);
}
return res;
}
public int getPartialCount(List<Integer> UpperBounderflowers, int perfect_count, long rest_flowers, int target, long[] perfixSum) {
int lo = 0, hi = target -1 ;
while(lo <= hi) {
int mid = lo + (hi-lo)/2;
if(isValid(UpperBounderflowers, perfect_count, rest_flowers, mid, perfixSum)) {
lo = mid + 1;
}
else hi = mid - 1;
}
return hi;
}
public boolean isValid(List<Integer> UpperBounderflowers, int perfect_count, long rest_flowers, int target, long[] perfixSum) {
int idx = Math.max(getFirstSmallerIdx(UpperBounderflowers, target), perfect_count);
long need = 0;
if(idx == UpperBounderflowers.size()) return true;
if(idx == 0) need = (long)target * UpperBounderflowers.size() - perfixSum[UpperBounderflowers.size()-1];
else need = (long)target * (UpperBounderflowers.size()-idx) - (perfixSum[UpperBounderflowers.size()-1] - perfixSum[idx-1]);
if(need > rest_flowers) return false;
return true;
}
public int getFirstSmallerIdx(List<Integer> nums, int target) {
int lo = 0, hi = nums.size()-1;
while(lo<=hi) {
int mid = lo+(hi-lo)/2;
if(nums.get(mid) < target) hi = mid-1;
else lo = mid+1;
}
return lo;
}
}
