蓝桥冲刺31天，第十四天java题解

一、带分数（全排列）

解析：

这是一个稍微难一点点的全排列问题，但是难度没有提升太多，和普通的全排列不同的是，普通的全排列一般是将9个数，分为左右两部分，而这个题分成了三个部分

那么，很容易可以得到以下条件：

第一部分的值不会到达第八位数，也就是最多是7位数；

第二部分的值位置在第一部分结束到第八位数，不可能到达最后一位

第三部分的值从第二部分结束到最后

因为这题要求n=a+b/c；

所以前置条件：b%c==0；b>c;

然后就用全排列的模板把内容套进去就可以了，网上挺多模板的，也可以用我代码的更改一下

代码：

import java.util.*;
public class 带分数 {
    static long max=0;
    static int arr[]= {1,2,3,4,5,6,7,8,9};
    static int []brr=new int[10];
    static Scanner sc=new Scanner(System.in);
    static int q=sc.nextInt();
    static int count=0;
    public static void main(String[] args) {
        dfs(0);
        System.out.print(count);
    }
    public static void dfs(int step) {//全排列
        if(step==9) {
            check();
            return;
        }
        for(int i=step;i<arr.length;i++)
        {
            swap(i,step);
            dfs(step+1);
            swap(i,step);
        }
    }
    public static void swap(int i,int j)
    {
        int t=arr[i];
        arr[i]=arr[j];
        arr[j]=t;
    }
    public static void check()
    {
        for(int i=0;i<7;i++){
            for (int j=i+1;j<8;j++){
                h(i,j);
            }
        }
    }
    public static void h(int step,int up) {
        int n1=1;
        int sum=0;
        int y=0;
        int n2=1;
        for (int i=0;i<=step;i++){
            y+=arr[i]*n2;
            n2*=10;
        }
        for(int i=step+1;i<=up;i++)
        {
            sum+=arr[i]*n1;
            n1=n1*10;
        }
        int n=1;
        int sums=0;
        for(int i=up+1;i<=8;i++)
        {
            sums+=arr[i]*n;
            n=n*10;
        }
        long ss= (long) sum %sums;
        if(ss==0&&sum>sums) {
            if(y+sum/sums==q) {
                count++;
            }
        }
    }
}

二、走迷宫（bfs）

 

解析：

这题能运用的是bfs的知识，小怂也是下午才学会的知识，就不在这里误人子弟了，上代码，等我再理解两天发详细讲解

代码：

import java.util.*;
public class 走迷宫 {
    static Scanner sc=new Scanner(System.in);
    static int n=sc.nextInt();
    static int m=sc.nextInt();
    static int [][]arr=new int[n][m];
    static int sx,sy,ex,ey,t;
    public static void main(String[] args) {
        for (int i=0;i<n;i++){
            for (int j=0;j<m;j++){
                if (sc.nextInt()==1){
                    arr[i][j]=-2;
                }else{
                    arr[i][j]=-1;
                }
            }
        }
        sx=sc.nextInt()-1;
        sy=sc.nextInt()-1;//设置起点
        ex=sc.nextInt()-1;
        ey=sc.nextInt()-1;//设置终点
        bfs();
    }
    static void bfs(){
        Queue<Integer>qx=new LinkedList<>();
        Queue<Integer>qy=new LinkedList<>();
        arr[sx][sy]=0;
        qx.add(sx);
        qy.add(sy);
        int xa,ya;
        while (!qx.isEmpty()){
            int x=qx.poll(),y=qy.poll();
            if (x==ex&&y==ey){
                System.out.println(arr[ex][ey]);
                return;
            }
            for (int i=-1;i<2;i+=2){
                xa=x+i;
                if (pd(xa,y)){
                    qx.add(xa);
                    qy.add(y);
                    arr[xa][y]=arr[x][y]+1;
                }
            }
            for (int i=-1;i<2;i+=2){
                ya=y+i;
                if (pd(x,ya)){
                    qx.add(x);
                    qy.add(ya);
                    arr[x][ya]=arr[x][y]+1;
                }
            }
        }
        System.out.println(-1);
    }
    static boolean pd(int x, int y) {
        return x < n && x >= 0 && y < m && y >= 0 && arr[x][y] == -2;
    }
}

三、蓝桥幼儿园（并查集）

 

解析：

并查集也是新学的，等我理解完了，和bfs一起发讲解

代码：

import java.util.Scanner;
public class 蓝桥幼儿园 {
    static Scanner sc=new Scanner(System.in);
    static int n=sc.nextInt();
    static int m=sc.nextInt();
    static  int []arr=new int[n+1];
    public static void main(String[] args) {
        for (int i=1;i<=n;i++){
            arr[i]=i;
        }
        int t;
        for (int i=0;i<m;i++){
            t=sc.nextInt();
            if (t==1){
                lj(sc.nextInt(),sc.nextInt());
            }else{
                System.out.println(pd(sc.nextInt())==pd(sc.nextInt())?"YES":"NO");
            }
        }
    }
    static void lj(int a,int b){
        int arr_a=pd(a),arr_b=pd(b);
        arr[arr_a]=arr_b;
    }
    static int pd(int a){
        if (arr[a]==a)
            return a;
        arr[a]=pd(arr[a]);
        return arr[a];
    }
}

四、跳石头（贪心+二分）

 

解析：

这题运用了贪心+二分的思想

先想一下，如果所有的石头被搬走了，那么最大值就是总长度

那么如果放了一块石头，最短跳跃距离的最大值是多少？

很明显，放在正中间的时候，会有最大值，最大值 L/2；

那么，现在放了很多石头，我们每一次，都用总长度/2，去判断这个长度是否能成为最大值就可以了；

用例子的：

25   5   2

2   11   14   17   21

总长度为25，那么一半就是12；我们判断拿掉有多少值可以满足，发现拿走所有值都无法满足；

那么这时候最大值就变成了11；再判断下一次：5；

发现要拿走 2   14   21三块石头才能满足，那就最大值变成4，判断2；

发现只要不拿走2，都可以满足，这时，最小值更改为,3；

然后(3+4)/2=3;下一步判断3；

发现只要拿走2,然后11/17/21中任取一块就可以满足；那么最小值变成4；

判断4，发现拿走.2和14可以满足条件；这时最小值变成5，最大值变成4；结束输出最大为4；

代码：

import java.util.Scanner;
public class 跳石子 {
    public static int [] arr = new int[50001];
    public static int l,n,m,ans = 0;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        l = scanner.nextInt();
        n= scanner.nextInt();
        m = scanner.nextInt();
        for(int i = 0; i < n; i++)//石头的位置
            arr[i] = scanner.nextInt();
        int min = 0, max = l, mid;//最小值和最大值
        //如果把所有的石头挪走，那么跳的最远就是总长度
        while(min <= max) {
            mid = (min + max) / 2;//取中间值
            if(check(mid)) {//判断当前值是否可以成为最短跳跃距离
                ans = mid;//当前值可以为最短跳跃距离，寻找更大值
                min = mid + 1;//最小值增加1，再重新判断中间值
            }else {
                max = mid - 1;//当前值不可以为最短跳跃距离，寻找小值
            }
        }
        System.out.println(ans);
    }
    public static boolean check(int d) {
        int num = 0, pos = 0;
        for(int i = 0; i < n; i++) {
            if(arr[i] - pos < d)
                num++;
            else
                pos = arr[i];
        }
        if(num <= m)
            return true;
        return false;
    }

}