蓝桥冲刺31天，第五天java打卡

一、猴子分香蕉

题目:

精选项目课程_IT热门课程_蓝桥云课课程 - 蓝桥云课

解析:

常规思路:直接n循环，判断是否满足每一次的条件，全部满足则输出(如果数值过大，则会导致无效运算次数过多)

逆序思路:最后一次是均分，所以我们可以将n设置为最后一次均分后每一堆剩余个数

公式: (((n5/45+4)/45+3)/45+2)/4*5+1

文字表示：

第五只猴子醒来剩余总个数:n*5

第四只猴子醒来剩余总个数:n5/45+4---->满足条件n*5/4为整数

第三只猴子醒来剩余总个数:(n5/45+4)/45+3---->满足条件n5/4*5+4)/4为整数

第二只猴子醒来剩余总个数:((n5/45+4)/45+3)/45+2---->满足条件((n5/45+4)/4*5+3)/4为整数

第一只猴子醒来剩余总个数:

(((n5/45+4)/45+3)/45+2)/45+1---->满足条件(((n5/45+4)/45+3)/4*5+2)/4为整数

代码如下:

public class 猴子分香蕉 {
    public static void main(String[] args) {
        int k;
        for (int i=1;;i++){
            k=5*i;
            if (k%4==0){
                k=k/4*5+4;
                if (k%4==0){
                    k=k/4*5+3;
                    if (k%4==0){
                        k=k/4*5+2;
                        if (k%4==0){
                            k=k/4*5+1;
                            System.out.println(k);
                            return;
                        }
                    }
                }
            }
        }
    }
}

二、等差数列

题目：

精选项目课程_IT热门课程_蓝桥云课课程 - 蓝桥云课

解析：

它给定你一部分数列，需要的是最短数列的项数（也就是这个数列最短的情况下有多少个）

我们知道，等差数列中间的差值是一样的，所以我们只需要让这个差值尽可能大就可以

那么这个差值的最大值为多少？

我们先把给定的数列升序排序，然后计算每一个差值，每一个差值的最小值就是可以使用差值的最大值，比如 2 5 9 15 这四个数，差值分别为 3 4 6，那么所可以使用的最大差值为3；

我们只需要求出它们的最大公因子，然后在按照等差数列取个数就可以

代码如下:

Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();//个数
        long []arr=new long[n];
        for (int i=0;i<arr.length;i++)//输入
            arr[i]=sc.nextInt();
        Arrays.sort(arr);//升序排序
        long []srr=new long[n-1];
        for (int i=0;i<srr.length;i++)//从最小值开始运算，取每个值的差值
            srr[i]=arr[i+1]-arr[0];
        int max=1;
        for (int i=2;i<=srr[0];i++){//求所有差值的最大公因数
            for (int j=0;j<srr.length;j++){
                if (srr[j]%i!=0)
                    break;
                else if (j==srr.length-1)
                    max=i;
            }
        }
        System.out.println(max);//输出最大公因数
        System.out.println((arr[n-1]-arr[0])/max+1);//输出个数
        long t=arr[0];
        for (int i=0;i<=(arr[n-1]-arr[0])/max;i++) {//输出该数列
            System.out.println(t);
            t+=max;
        }

三、平方序列

题目：精选项目课程_IT热门课程_蓝桥云课课程 - 蓝桥云课

解析：直接开始x从2020开始循环，y从x+1开始，双重循环

但是要注意，当yy-xx>xx-20192019时，要结束y的循环，因为再往后，两边的差值只会更大

同时，满足两边相等的解不止1个，那么怎么判断哪个值最小？

因为y>x,所以当你前面运行出结果，你就保留已有结果的最小值

然后当x>最小值/2时，就可以输出该最小值

代码如下:

public class 平方序列 {
    public static void main(String[] args) {
        int a=2019;
        for (int i=2020;;i++){
            for (int j=i+1;;j++){
                if (j*j-i*i==i*i-2019*2019){
                    System.out.println(i+j);
                    return;
                }else if(j*j-i*i>i*i-2019*2019){
                    break;
                }
            }
        }
    }
}

四、倍数问题

题目：精选项目课程_IT热门课程_蓝桥云课课程 - 蓝桥云课

解析:

你输入的n个数，如果直接排序后循环，那么计算次数 1e15左右

而给定了一个k值，且每次计算只需要三个数，那么，我们先排序

排序后每个数模三，然后取每一个模三后最大的三个值

因为一个数模k，最多存在k种不同值，那么每一种值存放三个，最多3000个值，在三千个值中开循环是可行的

比如：k=3， 数列为：2 5 8 11 12

那么 我们只需要计算的数就是：5 8 11 12

而2就不在考虑范围内（因为有三个比2大的值模值和2相同）

而选出了需要比较的数以后，怎么让运算次数更少呢？

1.从大往小取值

2.满足条件后，最内层结束

3.当某一层值不可能出现比当前结果更大时，该层结束

代码如下：(拉胯的代码，看看就行）

import java.util.Arrays;
import java.util.Scanner;

public class 倍数问题 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int k=sc.nextInt();
        int []arr=new int[n];
        int []brr=new int[3*k];
        int []crr=new int[k];
        for (int i=0;i<n;i++){
            arr[i]=sc.nextInt();
        }
        Arrays.sort(arr);
        int s=0;
        for (int i=n-1;i>=0;i--){
            if (crr[arr[i]%k]<2){
                crr[arr[i]%k]++;
                brr[s]=arr[i];
                s++;
                if (s==3*k){
                    break;
                }
            }
        }
        int max=0,y;
        for (int i=0;i<s-2;i++){
            for (int j=i+1;j<s-1;j++){
                for (int m=j+1;m<s;m++){
                    y=brr[i]+brr[j]+brr[m];
                    if (y%k==0){
                        max=Math.max(max,y);
                    }
                    if(y<=max)
                        break;
                }
                if (brr[i]+2*brr[j]<=max)
                    break;
            }
            if (brr[i]*3<max){
                System.out.println(max);
                return;
            }
        }
    }
}

小怂会更加努力的！！！

如果可以的话，请哥哥姐姐们随手送个赞吧