[Li Kou] the second set of the 280 Li Kou weekly match

• Author's brief introduction ： Hello everyone , I'm Xiao Huang who likes to knock code , Unicorn enterprise Java Development Engineer ,Java New star creators in the field
• Official account number ： Xiao Huang who likes to knock code
• Series column ：Java Design patterns 、 Data structures and algorithms
• If there is something wrong with the knowledge of the article , Please correct me. ！ Learn with you , Progress together
• If you feel the blogger's article is good , Please support the blogger for the third company
• Bloggers are trying to complete 2022 Planned ： Take dreams as horses , Set sail ,2022 Dream catcher

One 、 introduction

Today's weekly match is hard to say , Because of a simple long Conversion negligence leads to oneself T3 no A

Two 、 6004. obtain 0 The number of operations

1、 Introduction to the topic

2、 title

• Simulation is enough
• Pay attention to the return condition ：while(num1 != 0 && num2 != 0)

3、 Title code

class Solution {
    
    public int countOperations(int num1, int num2) {
    
        int count = 0;
        while(num1 != 0 && num2 != 0){
    
            if(num1 >= num2){
    
                num1 = num1 - num2;
            }else{
    
                num2 = num2 - num1;
            }
            count++;
        }
        return count;
    }
}

3、 ... and 、6005. The minimum number of operands to make an array an alternating array

1、 Introduction to the topic

2、 title

• greedy
• We analyze the topic , In a nutshell , The final result ： Our odd digits are the same number , Even digits are the same number , And the numbers cannot be equal
• We use two priority queues to store its number , according to The most frequent occurrence Judge
• Let's consider the following situations ：
  • [0]： Queue 2 is empty
  • [1,2]： The size of queue one and queue two is 1
  • [1,2,3]： The size of queue one is 2, The size of queue 2 is 1
  • [1,2,3,4]： The size of queue one is 2, The size of queue 2 is 2
• We compare the priority queue int value = peek() , The number of times the number appears
  • If not equal , It means that you need to become value, Calculate the number of times
  • If it's equal , We need to compare value Size , Big ones stay the same , Small needs become The second largest

3、 Title code

class Solution {
    
    public static int minimumOperations(int[] nums) {
    
        if (nums.length == 1) {
    
            return 0;
        }
        HashMap<Integer, Integer> map1 = new HashMap<>();
        HashMap<Integer, Integer> map2 = new HashMap<>();
        int count1 = 0;
        int count2 = 0;
        for (int i = 0; i < nums.length; i++) {
    
            if (i % 2 != 0) {
    
                count1++;
                map1.put(nums[i], map1.getOrDefault(nums[i], 0) + 1);
            } else {
    
                count2++;
                map2.put(nums[i], map2.getOrDefault(nums[i], 0) + 1);
            }
        }
        //  Odd number 
        PriorityQueue<int[]> priorityQueue1 = new PriorityQueue<>(new Comparator<int[]>() {
    
            @Override
            public int compare(int[] o1, int[] o2) {
    
                return o2[1] - o1[1];
            }
        });
        for (Integer key : map1.keySet()) {
    
            priorityQueue1.add(new int[]{
    key, map1.get(key)});
        }
        //  even numbers 
        PriorityQueue<int[]> priorityQueue2 = new PriorityQueue<>(new Comparator<int[]>() {
    
            @Override
            public int compare(int[] o1, int[] o2) {
    
                return o2[1] - o1[1];
            }
        });
        for (Integer key : map2.keySet()) {
    
            priorityQueue2.add(new int[]{
    (int) key, (int) map2.get(key)});
        }
        if (priorityQueue1.size() == 1 && priorityQueue2.size() == 1) {
    
            if (priorityQueue1.peek()[0] != priorityQueue2.peek()[0]) {
    
                return 0;
            } else {
    
                return priorityQueue1.peek()[1] >= priorityQueue2.peek()[1] ? priorityQueue2.peek()[1] : priorityQueue1.peek()[1];
            }
        }else if (priorityQueue1.size() > 1 && priorityQueue2.size() == 1) {
    
            if (priorityQueue1.peek()[0] != priorityQueue2.peek()[0]) {
    
                return count1 - priorityQueue1.peek()[1];
            } else {
    
                if (priorityQueue1.peek()[1] >= priorityQueue2.peek()[1]) {
    
                    return count2 + count1 - priorityQueue1.peek()[1];
                } else {
    
                    priorityQueue1.poll();
                    return count1 - priorityQueue1.peek()[1];
                }
            }
        } else {
    
            if (priorityQueue1.peek()[0] != priorityQueue2.peek()[0]) {
    
                return count1 - priorityQueue1.peek()[1] + count2 - priorityQueue2.peek()[1];
            } else {
    
                if (priorityQueue1.peek()[1] >= priorityQueue2.peek()[1]) {
    
                    priorityQueue2.poll();
                    return count1 - priorityQueue1.peek()[1] + count2 - priorityQueue2.peek()[1];
                } else {
    
                    priorityQueue1.poll();
                    return count1 - priorityQueue1.peek()[1] + count2 - priorityQueue2.peek()[1];
                }
            }
        }
    }
}

Four 、6006. Take out the smallest number of magic beans

1、 Introduction to the topic

2、 title

• We found that , We want to make magic beans equal , Need to find one critical point , According to this critical point ： Less than his all become 0, More than his whole becomes it
• Sort first
• We use [1,4,5,6] As an example
  • Suppose the current critical point is 5, So our 1、4 Need to become 0,6 become 5, The final result is ：7
  • Because our magic beans can't be increased , Can only reduce
  • When we traverse its value , We will Overall sum - The number of subsequent data * The current value
    
  • Be careful , When we are evaluating , Don't forget to change the type to long
  • This topic can also be used The prefix and

3、 Title code

class Solution {
    
   public long minimumRemoval(int[] beans) {
    
        int len = beans.length;
        Arrays.sort(beans);
        long sum = 0;
        for(int i = 0; i < len; i++){
    
            sum = sum + beans[i];
        }
        long minSum = Long.MAX_VALUE;
        for(int i = 0; i < len; i++){
    
        	//  Attention turns to long
            minSum = Math.min(minSum, sum - (len - i) * (long)beans[i]);
        }
        return minSum;
    }
}

5、 ... and 、 summary

The result of this week's race is still not ideal , I hope the next week's race will be better ~
Next time, be sure to pay attention to the conversion of types
Come on ~~~