2022java蓝桥杯算法训练

1.印章：

 

代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int n=s.nextInt();
        int m=s.nextInt();
        double p=1.0/n;

        double[][] b=new double[m+1][n+1];
        if (n==1){  //当n=1时m>n几率为1
            b[m][n]=1;
            System.out.printf("%.4f",b[m][n]);
            return;
        }
        if (n>1&&m<n){ //当m<n时几率为0
            b[m][n]=0;
            System.out.printf("%.4f",b[m][n]);
            return;
        }
        for (int i = 1; i <=m; i++) {
            for (int j = 1; j <=n; j++) {
                if (i<j) b[i][j]=0;       //当m<n时几率为0
                if (j==1){
                    b[i][j]=Math.pow(p,i-1);        //当i张集齐1种的概率
                }else {
                    b[i][j]=b[i-1][j]*(j*1.0/n)+b[i-1][j-1]*((n-j+1)*1.0/n);        //当i张集齐j种的概率
                }

            }

        }

        System.out.printf("%.4f",b[m][n]);

    }
}

 

2.拿金币：

代码：

import java.util.Scanner;


public class Main {

    /*
    * 输入：第一行，整数n，表示N*N的一个矩阵。
    *       n行，初始化，每个矩阵的大小。每个数不能找过1000. short类型。
    * 格式要求：n小于1000 short类型
    * */

    /*
    * 输出：一行整数sum，表示的是矩阵从左上角到右下角的最大和。 int类型
    * w*/

    //程序思路：
        //1.接受n，创建一个数组
        //2.初始化数组。
        //3.求和。

    public static void main(String[] args){
        //1.接受n，创建一个数组
        Scanner input = new Scanner(System.in);
        short n = input.nextShort();

        //2.初始化数组。
        int[][] arrys = new int[n][n];
        for (int i = 0; i <n ; i++) {
            for (int j = 0; j <n ; j++) {
                arrys[i][j] = input.nextInt();

            }

        }








        //3.求和
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                //初始化固定部分，arrys[0][0]-a[0][n-1]。a[0][0]-a[n-1][0]。
                //因为从这一部分走，方向是唯一，也就是和是唯一的，没有别的路。
                if (i==0&&j==0)//初始化首位。
                    continue;


                if (i == 0) {//首行非首位。
                    arrys[i][j] =  (arrys[i][j-1]+arrys[i][j]);//运算+ - 至少要int类型，所以会被强制转换，而不是下标问题。
                    continue;

                }

                if (j == 0) {//首列，非首位。
                    arrys[i][j] = (arrys[i-1][j]+arrys[i][j]);
                    continue;
                }

                if (arrys[i - 1][j] > arrys[i][j - 1]) {//上比左大。
                    arrys[i][j] = (arrys[i][j]+arrys[i-1][j]);
                }else arrys[i][j] =(arrys[i][j]+arrys[i][j-1]);//左比上大。


            }
        }


                System.out.println(arrys[n-1][n-1]);

        }

    }

3.数字游戏：

代码：

import java.util.Scanner;
/*
 *
 * */
public class Main {

    static int n;//初始的n个数
    static int sum;//相加的结果
    static int arr1[];
    static boolean bool = true;//标记是否找到n个元素

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        sum = sc.nextInt();

        int array[] = new int[n];
        int visit[] = new int[n+1]; //访问标记

        dfs(0, array, visit);
    }

    //step:当前已经遍历的元素数；array：存放当前遍历的元素； visit：标记当前哪些元素已被访问；
    public static void dfs(int step,int arr[], int vis[]){
        if(step == n){//1.找到n个数字，检查这n个数相加是否等于sum
            int arr1[] = new int[n];
            for(int i=0;i<n;i++){//先将array数组中的元素 放到arr1
                arr1[i] = arr[i];
            }//for

            for(int i=1;i<n;i++){//累加到arr1[0]
                for(int j=0;j<n-i;j++){
                    arr1[j]=arr1[j]+arr1[j+1];
                }
            }//for

            if(arr1[0] == sum){//累加后与sum相等,则输出
                for(int i:arr){
                    System.out.print(i+" ");
                }
                bool = false;//已经找到符合要求的n个元素
                return;
            }else{//累加后与sum不相等，退出重新查找
                return;
            }

        }//if
        if(bool == true){//2.没有找到符合要求的n个元素
            for(int i=1;i<=n;i++){
                if(vis[i]==0){//i值没有使用过
                    arr[step]=i;//存储当前访问的元素
                    vis[i]=1;
                    dfs(step+1,arr,vis);//从当前这个元素起，重新进行遍历
                    vis[i]=0;
                }
            }
        }//if
        return;
    }
}

4.无聊的逗：

代码：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        int ans=Integer.MIN_VALUE;
        int n = cin.nextInt();
        int []array=new int[1<<n];
        int []nums=new int[n];
        for(int i=0;i<n;++i){
            nums[i]=cin.nextInt();
            array[1<<i]=nums[i];
        }
        for(int i=0;i<1<<n;++i){
            for(int j=0;j<n;++j){
                if((i&(1<<j))==0)continue;
                array[i]=array[i-(1<<j)]+nums[j];
                break;
            }
        }
        for(int i=1;i<(1<<n);++i){
            int j=(1<<n)-i-1;
            for(int k=j;k>0;k=(k-1)&j){
                if(array[k]==array[i])
                    ans=Math.max(array[k],ans);
            }
        }
        System.out.print(ans);
    }
}

5.礼物：

思路：

　　a.只能拿一次，2k，从开头拿起。所以分为前k0，后k1，并且两者要相等。k0 和k1 都要小于s。最后再输出.k的值。

　　b.在循环赋值当中，保存每一项累加的结果到数组当中

　　c.通过二分查找的方式找到前面的k0的大小，再匹配后面k1的总和是否也满足，满足就直接输出，不满足就降低k0的值来重新寻找。

 

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main{
    static int count =0;
    static long S;
    public static void main(String args[]) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s,s2;
        String[] b1 = null,b2 = null;
        try {
                s=br.readLine();
                b1=s.split(" ");
                s2=br.readLine();
                b2=s2.split(" ");
    
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        int N=Integer.parseInt(b1[0]);
        S=Long.parseLong(b1[1]);
        
        int[] a=new int[N+1];
        long[] sum=new long[N+1];
        for(int i=1;i<=b2.length;i++) {
            a[i]=Integer.parseInt(b2[i-1]);
            sum[i]=sum[i-1]+a[i];
        }
        int l=1,r=N;
        while(l<r) {
            int mid=(l+r+1)/2;
            if(fun(mid,N,sum)) {
                l=mid;
            }else {
                r=mid-1;
            }
        }
        System.out.print(2*l);
    }
    public static boolean fun(int mid,int n,long[] sum) {
        for(int i=mid;i<=n-mid;i++) {
            if(sum[i]-sum[i-mid]<=S&&sum[i+mid]-sum[i]<=S) {
                return true;
            }
        }
        return false;
    }
}

 

 总结：

　　a.Scanner 类不适合输入太多的值的情况，容易引起内存过大，这时可以考虑BufferedReader类来完成输入流的操作。归属java.io.BufferedReader.和java.io.InputStreamReader

用法是 BufferedReader br = new BufferedReader（new InputStreamReader（System.in）

String s =br.readLine()//读取一整行。

String[] ss = s.split(" ")//根据空格来分割字符串为数组。

　　b.考虑大小，数组可以是int 类型，但是求和的时候可能会超过，所以最好用long数组。

　　c.paresInt 和parselong 参数一样，都是用的是字符串，最后转换为整形类型，虽然输出的的时候还是字符串，所以可以根据是否要用于做运算来抉择，加减乘除的运算至少是int类型才能，所以byte ，short适合不做运算的情况来使用，避免频繁装箱。

 6.跳马：

　　代码如下：

　　

import java.util.*;

import static java.lang.System.in;
import static java.lang.System.out;

public class Main {
    static Deque<int[]> list = new LinkedList<int[]>(); // 这个集合记录每一次走的过程，因为只涉及插入和删除，我用Deque。
    static int[][] steps = new int[][]{{1, 2}, {1, -2}, {-1, 2}, {-1, -2}, {2, 1}, {2, -1,}, {-2, 1},
            {-2, -1}};  // 因为马只能走“日”，所以这个二维数组给出所有马能够走的方向，共八方。

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt(), b = sc.nextInt(), c = sc.nextInt(), d = sc.nextInt(), len = steps.length;
        out.println(getCount(a, b, c, d, len));
    }

    /**
     * @param a 对应题目中的a
     * @param b 对应题目中的b
     * @param c 对应题目中的c
     * @param d 对应题目中的d
     * @param len steps数组的长度
     * @return 返回最短的次数
     */
    public static int getCount(int a, int b, int c, int d, int len) {
        list.offer(new int[]{a, b}); // 先将起始位置加进来
        int count = 0, innerCount = 0; //count为最后的返回值，innerCount后面会讲
        if (list.getFirst()[0] == c && list.getFirst()[1] == d) { // 如果起始位置等于最终的位置，我们直接返回count。
            return count;
        }

        boolean flag = true;  // 死循环退出标识
        while (flag) {
            for (int i = 0; i < len; i++) {  // 最外层的for循环是控制马走的方向
                int[] at = new int[2]; // 临时的at数组装载每一次当前位置的下一个位置
                for (int j = 0; j < 2; j++) { // 该循环每次都更新马当前位置可走的方向，比方说马当前在(1,1)，完成一次该for循环，马就出现了下一个可以走的位置，存到list里面,
                                                // 如果两层for循环都完成马就会出现8个当前位置可以走的下一个位置，存入list中
                    at[j] = list.getFirst()[j] + steps[i][j];
                }
                list.offer(at); // 存入下一个位置到list
                innerCount++; // 每一个存入innerCount就会+1，当这里的加1并不能表示次数。因为如果马用的步数为1的时候，innerCount的会是8，而步数用的是2时，innerCount为64
                if (at[0] == c && at[1] == d) { // 符号条件，则把退出表示设置为false
                    flag = false;
                    break;
                }
            }
            if (Math.pow(8, count + 1) == innerCount) // 基于42行的说法，所以有了当前的判别式。
                count++;
            list.pollFirst(); // 当当前位置下一步可走的8个方向存入list中，我们删除当前方向，判别下一个方向
        }
        return count + 1;
    }

}

7.kAc给糖果你吃：

代码如下：

import java.util.Scanner;
public class Main {

/*
* 输入：两行，第一行n（表示有多少堆），m（表示拿的次数）
*           第二行：n个数字（初始化每堆糖果的个数）
* 格式要求:n在0--1000,其他的是10亿。（int类型）
* */

    /*
    * 输出：一行，整数，s，表示最多拿多少糖果。
    * */




//程序：




        public static void main(String[] args){

            //1.接收n，m，初始化数组。
            Scanner input = new Scanner(System.in);
            int n = input.nextInt(); //n
//            System.out.println("n:"+n);
            int m = input.nextInt(); //m
//            System.out.println("m:"+m);
            int[] array = new int[n];//A【i】
            long sum = 0;//sum
            for(int i =0 ; i<n ; i++){
                array[i] = input.nextInt();
//                System.out.println(array[i]);
            }//for

            //2.查找m次最大值，使用选择排序
            for(int i=0; i<m;i++){
                for(int j = i+1;j<n;j++){
                    if(array[i]<array[j]){
                        //交换
                        int temp = array[j];
                        array[j] = array[i];
                        array[i] = temp;
                    }//if

                    //把每次最大值相加；

                }//for
                sum = sum + array[i];
            }//for

            System.out.println(sum);
        }//main
    }//类

8.数的潜能：

代码如下：

import java.util.Scanner;
public class Main{
    public static void main(String args[]) {
        Scanner sc=new Scanner(System.in);
        long n=sc.nextLong();
        //a 3的数量，b 2的数量
        long a=0;
        int b=0;
        int[] x=new int[100];
        long[] z=new long[100];
        //a 3的数量，b 2的数量
        if(n%3==1) {
            a=(n/3)-1;
            b=2;        
        }else if(n%3==2) {
            a=n/3;
            b=1;
        }else {
            a=n/3;
        }
        //c a个3相乘取模的当前位置 x[]与z[]记录相应的取模值及取模位置，d 后一半剩余相乘数量。
        long c=1;
        int yu=3%5218;
        int k=0;
        x[0]=yu;
        z[0]=c;
        while(a>=2*c) {
            yu=(yu*yu)%5218;
            x[++k]=yu;
            c*=2;
            z[k]=c;
        }
        long d=a-c;
        for(int i=k-1;i>=0;i--) {
            if(d>z[i]) {
                yu=(yu*x[i])%5218;
                d=d-z[i];
            }
        }
        yu=(int) ((yu*Math.pow(3, d)*Math.pow(2, b))%5218);
        System.out.print(yu);
    }    
}

9.娜神平衡

代码如下：

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

public class Main {
    static int N;// 数据的总个数
    static int R;// 相差不能超过R
    static int[] A;// A存放元素的数组
    static int[] B;// B存放元素的数组
    static int[] vis;// 数据被使用的状态
    static int a = 0;// A的元素
    static int b = 0;// B的元素
    static int flag = 0;// 结束标志，题目告知答案唯一，所以找到答案后就结束。

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        N = n;
        vis = new int[n];
        int r = scanner.nextInt();
        R = r;
        A = new int[n];
        B = new int[n];
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        DFS(arr, 1);
    }

    // 求和
    public static int sum(int[] num) {
        int sum = 0;
        for (int x : num) {
            sum += x;
        }
        return sum;
    }

    // 深度搜索
    public static void DFS(int[] arr, int step) {
        if (Math.abs(sum(A) - sum(B)) > R) {//不符合题目条件的直接返回结束
            return;
        }
        if (step > N) {//找到答案
            //对A、B数组进行从小到大的排序
            Arrays.sort(A, 0, a - 1);
            Arrays.sort(B, 0, b - 1);
            //输出结果
            for (int i = 0; i < a; i++) {
                System.out.print(A[i] + " ");
            }
            System.out.println();
            for (int i = 0; i < b; i++) {
                System.out.print(B[i] + " ");
            }
            flag = 1;//修改结束标志
            return;
        }
        //先往A里面放元素，直到放进A不满足条件 A-B的绝对值<r
        for (int i = 0; i < N; i++) {
            if (flag == 1) {// 先判断结束标志
                return;
            }
            if (vis[i] == 0) {
                A[a++] = arr[i];
                vis[i] = 1;
                DFS(arr, step + 1);//放下一个
                A[--a] = 0;
                vis[i] = 0;
            }
        }

        //放完A后，往B放元素 
        for (int i = 0; i < N; i++) {
            if (flag == 1) {// 先判断结束标志
                return;
            }
            if (a == 0) {//题目中要求先往A放，所以放入B时先检测A里面有没有元素
                return;
            }
            if (vis[i] == 0) {
                B[b++] = arr[i];
                vis[i] = 1;
                DFS(arr, step + 1);//放下一个
                B[--b] = 0;
                vis[i] = 0;
            }
        }
    }

}

10.粘木棍

代码如下：

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

public class Main {

static int mm;
public static void main(String args[]) {
Scanner sc=new Scanner(System.in);
int N=sc.nextInt();
int M=sc.nextInt();
int[] a=new int[N];
for(int i=0;i<N;i++) {
a[i]=sc.nextInt();
//总长度
mm+=a[i];
}
int[] b=new int[M];
//b 记录每根木棍长度，c记录木棍是否使用
fun(a,b,0,N,M);
System.out.print(mm);
}
public static void fun(int[] a,int[] b,int k,int n,int m) {
//如果还有木棍
if(k<n) {
//遍历数组b
for(int i=0;i<m;i++) {
//暂时将这个木棒加到当前的木棒组上
b[i]+=a[k];
//继续往下调用函
fun(a,b,k+1,n,m);
//在这个木棒组上去下当前木棒，以便在下一木棒组上使用
b[i]-=a[k];
}
}else {//当木棒全部粘完时
//找出当前所有木棒组里最小值和最大值
int max=b[0],min=b[0];
for(int i=0;i<m;i++) {
if(b[i]>max) {
max=b[i];
}
if(b[i]<min) {
min=b[i];
}
}
if(max-min<mm) {
mm=max-min;
}
}
}
}

11.车的放置

代码如下：

import java.io.*;
 
public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        Temp996b temp = new Temp996b(n);
        temp.dfs(1);//从第一行开始摆放
        System.out.println(temp.ans);
    }
}
class Temp996b{
    int n;
    int ans = 1;
    boolean visited[] = new boolean[9];//表示第几列是否摆放
    
    public Temp996b(int n) {
        this.n = n;
    }
    
    public void dfs(int step) {//表示棋子应放到第temp行
        if(step > n) {//递归出口：当前摆放行数超出棋盘总行数
            return;
        }
        for(int i = 1; i <= n; i++) {
            if(!visited[i]) {//step行的第i列为空
                visited[i] = true;//已放置
                ans++;
                dfs(step + 1);//递归至下一行摆放
                visited[i] = false;//回溯：将step行重置
            }
        }
        dfs(step + 1);//有空行情况，将step行跳过（不摆放）
    }
}

12.24点：

代码如下：

无。。。

13.最大分解：

代码如下：

import java.util.Scanner;

public class Main {

    public static void main(String[] args){

        //a0的值
        Scanner input= new Scanner(System.in);
        int a0 = input.nextInt();
        int[] a = new int[a0];
        a[0] = a0;
        int sum = 0 ;
        int j = 0;

        //找值。
        for (int i = a0-1; i >=1 ; i--) {
            if(a[j]%i==0){
                //把数存起来，下标+1.
                sum += i;
                j++;
                a[j] = i;
            }
        }
        System.out.println(sum);

    }


}

14.RP大冒险

代码如下（没看懂，随便写的）

import java.util.Scanner;

public class Main {

    public static void main(String[] args){



            int[] a = {0,1,2,3,4,5,6,7,8,9
            };
            int b = new Scanner(System.in).nextInt();

    System.out.println(a[b]);


    }


}

 

待更新。。。