给你两个 非负 整数 num1 和 num2 。
每一步 操作 中,如果 num1 >= num2 ,你必须用 num1 减 num2 ;否则,你必须用 num2 减 num1 。
例如,num1 = 5 且 num2 = 4 ,应该用 num1 减 num2 ,因此,得到 num1 = 1 和 num2 = 4 。然而,如果 num1 = 4且 num2 = 5 ,一步操作后,得到 num1 = 4 和 num2 = 1 。
返回使 num1 = 0 或 num2 = 0 的 操作数 。
模拟即可
class Solution {
public int countOperations(int num1, int num2) {
if(num1==0||num2==0){
return 0;
}
int ans=1;
if(num1>=num2){
num1-=num2;
}else{
num2-=num1;
}
ans+=countOperations(num1,num2);
return ans;
}
}
给你一个下标从 0 开始的数组 nums ,该数组由 n 个正整数组成。
如果满足下述条件,则数组 nums 是一个 交替数组 :
nums[i - 2] == nums[i] ,其中 2 <= i <= n - 1 。
nums[i - 1] != nums[i] ,其中 1 <= i <= n - 1 。
在一步 操作 中,你可以选择下标 i 并将 nums[i] 更改 为 任一 正整数。
返回使数组变成交替数组的 最少操作数 。
统计奇数和偶数位置对应的出现次数最大、次大数字,如果最大数字不相同,采用这些数字,其他数字变换即可答案为len-max1-max2,如果相同,要采用另一个的次大出现次数数字
class Solution {
public int minimumOperations(int[] nums) {
int n=nums.length,ans=0;
if(n==1)return 0;
int even1=0,even2=0,odd1=0,odd2=0;
int max1=0,max2=0;
Map<Integer,Integer>map1=new HashMap<>();
Map<Integer,Integer>map2=new HashMap<>();
for(int i=0;i<n;i+=2){
map1.put(nums[i],map1.getOrDefault(nums[i],0)+1);
}
for(int num:map1.keySet()){
int cnt=map1.get(num);
if(cnt>even1){
max1=num;
even2=even1;
even1=cnt;
}else if(cnt>even2){
even2=cnt;
}
}
for(int i=1;i<n;i+=2){
map2.put(nums[i],map2.getOrDefault(nums[i],0)+1);
}
for(int num:map2.keySet()){
int cnt=map2.get(num);
if(cnt>odd1){
max2=num;
odd2=odd1;
odd1=cnt;
}else if(cnt>odd2){
odd2=cnt;
}
}
if(max1!=max2){
ans=n-even1-odd1;
}else{
if(odd1+even2>even1+odd2){
System.out.println("使用最大奇数"+odd1+"和次大偶数"+even2);
ans=n-odd1-even2;
}else{
System.out.println("使用最大偶数"+even1+"和次大奇数"+odd2);
ans=n-even1-odd2;
}
}
System.out.println(n);
return ans;
}
}
给你一个 正 整数数组 beans ,其中每个整数表示一个袋子里装的魔法豆的数目。
请你从每个袋子中 拿出 一些豆子(也可以 不拿出),使得剩下的 非空 袋子中(即 至少 还有 一颗 魔法豆的袋子)魔法豆的数目 相等 。一旦魔法豆从袋子中取出,你不能将它放到任何其他的袋子中。
请你返回你需要拿出魔法豆的 最少数目。
先排序,然后从前到后遍历,计算以当前袋子为基准(前面全部清空)所需要拿出的豆子数(注意不可能清空最后一个袋子,最后一个袋子做基准一定比清空消耗豆子少),返回拿出魔法豆的最少数目
class Solution {
public long minimumRemoval(int[] beans) {
Arrays.sort(beans);
int n=beans.length;
if(n==1)return 0;
long sum=beans[0];
long[]pre=new long[n];
pre[0]=(long)beans[0];
for(int i=1;i<n;i++){
sum+=(long)beans[i];
}
for(int i=0;i<n;i++){
pre[i]=sum-(long)(n-i)*beans[i];
}
Arrays.sort(pre);
return pre[0];
}
}
给你一个长度为 n 的整数数组 nums 和一个整数 numSlots ,满足2 * numSlots >= n 。总共有 numSlots 个篮子,编号为 1 到 numSlots 。
你需要把所有 n 个整数分到这些篮子中,且每个篮子 至多 有 2 个整数。一种分配方案的 与和 定义为每个数与它所在篮子编号的 按位与运算 结果之和。
比方说,将数字 [1, 3] 放入篮子 1 中,[4, 6] 放入篮子 2 中,这个方案的与和为 (1 AND 1) + (3 AND 1) + (4 AND 2) + (6 AND 2) = 1 + 1 + 0 + 2 = 4 。
请你返回将 nums 中所有数放入 numSlots 个篮子中的最大与和。
这题相当折磨人,我直接化身恶魔,CV了一份题解,学习了状态压缩算法,其实也不是没见过了,就是用二进制数对状态进行压缩即可
class Solution {
public int maximumANDSum(int[] nums, int numSlots) {
int ans = 0;
//需要开一个2^numSlots*2的数组,返回最大值
int f = new int[1 << (numSlots * 2)];
for (int i = 0; i < f.length; i++) {
//计算1的个数
int c = Integer.bitCount(i);
//如果越界不考虑
if (c >= nums.length) continue;
for (int j = 0; j < numSlots * 2; ++j) {
if ((i & (1 << j)) == 0) { // 枚举空篮子 j
int s = i | (1 << j);
f[s] = Math.max(f[s], f[i] + ((j / 2 + 1) & nums[c]));
ans = Math.max(ans, f[s]);
}
}
}
return ans;
}
}