蓝桥杯备赛第二弹

昨日第一题：

class Solution {
    public int maximumProduct(int[] nums) {
Arrays.sort(nums);
        int n = nums.length;
        return Math.max(nums[0] * nums[1] * nums[n - 1], nums[n - 3] * nums[n - 2] * nums[n - 1]);
    }
}

先排序，

我们只需要找到第一大，第二大，第三大的值，以及第一小，第二小的值即可。

第二题：

package Leecode2;
//约瑟夫环
import java.util.Scanner;
import java.util.ArrayList;
public class Main2 {
	public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n=scan.nextInt();
        int k=scan.nextInt();
        int m=scan.nextInt();
        ArrayList<Integer> arr = new ArrayList<>();
        
        int a=0;
        int delete_k=k;
        for(int i=0;i<n;i++){
            arr.add(i);
            
        }

    while(arr.size()>1){
    	a++;
    	if(delete_k>arr.size()-1){
           delete_k=0;
           
        }
         if(a==m){
        	
             arr.remove(arr.get(delete_k));
             delete_k-=1;
        a=0;
         }
         delete_k++;
        
    }
        System.out.println(arr.get(0));
    }
}

a用来记录是否读到第m个人，每次读到后清零。delete_k用来标记被删除元素的索引，每次删除后减一是为了抵消后面加的1，否则将无法指向被删元素后一个元素。当它索引越界，就置为零。用集合来存储每个编号，将不符合要求的元素一一删去，最后只剩下一个元素，就是大王的编号

第四题：

class Solution {
    public int minIncrementForUnique(int[] A) {
        // 先排序
        Arrays.sort(A);
        int move = 0;
        // 遍历数组，若当前元素小于等于它的前一个元素，则将其变为前一个数+1
        for (int i = 1; i < A.length; i++) {
            if (A[i] <= A[i - 1]) {
                int pre = A[i];
                A[i] = A[i - 1] + 1;
                move += A[i] - pre;
            }
        }
        return move;
    }
}

 

方法：先排序，再依次遍历数组元素，若当前元素小于等于它前一个元素，则将其变为前一个数 +1。

原因：因为想要让move的值最小，就是需要让相等的几个元素通过加若干个1变成大小连续的，排序主要是为了更方便的找到相等的元素，对其进行操作。

今日第一题：

class Solution {
    public int search(int[] nums, int target) {
        int first=0;
        int last=nums.length-1;
        int mid=(first+last)/2;
        int end=0;
        while(first<=last){
            if(nums[mid]<target){
                first=mid+1;
            }else if(nums[mid]==target){
                end=mid;
                break;
            }else{
                last=mid-1;
            }
        mid=(first+last)/2;
        }
        if(first>last){
            end=-1;
        }
        return end;
    }
}

 

第二题：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
class Solution {
    public List<Integer> targetIndices(int[] nums, int target) {
        List<Integer> list=new ArrayList<>();
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){
            if(nums[i]==target){
                list.add(i);
            }
        }

return list;
    }
}

 首先将nums[]数组递增排列，然后遍历nums，将符合要求的元素添加到列表中。

第三题：

class Solution {
    public int findDuplicate(int[] nums) {
        int chong=0;
        for(int i=0;i<nums.length;i++){
            for(int j=0;j<nums.length;j++){
                if(i!=j&&nums[i]==nums[j]){
                    chong=nums[i];
                }
            }
        }
        return chong;
    }
}

 暴力算法，遍历nums，找出其中重复的元素，然后赋值给chong，再返回