第九届蓝桥杯题解

第九届蓝桥杯题解

A，第几天

package train;

public class test_27 {
    public static void main(String[] args){
        System.out.println(31+29+31+30+4);
    }
}

B，方格计数

直接提交会超时，只需要积累每一个正方形就可以了，面积小于最大的正方形的面积（或者说是右上角的点到圆心的距离小于半径就可以）

package train;

public class test_28 {
    public static void main(String[] args) {
//        long count = 0;
//        for (long i = 1; i <= 50000; i++) {
//            for (long j = 1; j <= 50000; j++) {
//                if (i * i + j * j <= 50000 * 50000L) {
//                    count++;
//                }
//            }
//        }
//        System.out.println(count * 4);
        String ch="7853781044";
        System.out.println(ch);
    }//7853781044
}

C，复数幂

D，测试次数

起初以为要直接二分就可以了，在1000层先测试，在减半寻找，但是有一个最坏情况，和最佳策略的限制，就只能dp，而这题利用dp拆分的子决策就是1，在同一层楼上仍的时候手机没碎，2，在同一层楼上仍的时候碎了，那么设扔手机的这层楼为k，总层数为j，手机数为i

那么就可以得到两个情况的方程：1，dp(j-k)(i),因为没有碎所以用总层数减去当前测试层数

且手机数还是3个，2，dp(k-1)(i-1)因为手机碎了所以当前层数要下降一层，且手机数要去掉一个，且题目给的是最坏情况，所以要在这两种中取最大值，但是又有最优策略这个限制，那么我们就必然还要再取的一个最小值了，那么我们就应该在每一步都要选出可能完成测试的最少次数，就可以，总而言之，我们要在每一层进行测试的时候做出子决策，碎或者不碎，选取最大的可能值，在子问题就是在每一层上测试时要选取出在这个层数上所需要的最少测试次数，从而在1000层塔中找出最少的测试次数，每一个子问题中会有许多子决策，(在最坏情况下找出最佳策略)

package train;
//最坏的情况是指在最后一部手机的情况下，才测出指数
//最佳策略是指要找出最优解，所以利用动态规划是最好的
public class test_29 {
    public static void main(String [] args){
        int [][] dp=new int[1001][4];
        for(int i=1;i<=3;i++)
            for(int j=1;j<=1000;j++)
            {
                dp[j][i]=dp[j-1][i]+1;
                for(int k=1;k<j&&i>1;k++){
                    dp[j][i]=Math.min(dp[j][i],Math.max(dp[k-1][i-1],dp[j-k][i])+1);
                    //分为碎或者不碎两种情况，最坏情况取最大值，
                }//k为当前测试层数，i是总共的测试层数，
            }
        System.out.println(dp[1000][3]);
    }
}

E，快速排序

签到题

package train;
import java.util.Scanner;
import java.util.Random;
public class test_30 {
        public static int quickSelect(int a[], int l, int r, int k) {
            Random rand = new Random();
            int p = rand.nextInt(r - l + 1) + l;
            int x = a[p];
            int tmp = a[p]; a[p] = a[r]; a[r] = tmp;
            int i = l, j = r;
            while(i < j) {
                while(i < j && a[i] < x) i++;
                if(i < j) {
                    a[j] = a[i];
                    j--;
                }
                while(i < j && a[j] > x) j--;
                if(i < j) {
                    a[i] = a[j];
                    i++;
                }
            }
            a[i] = x;
            p = i;
            if(i - l + 1 == k) return a[i];
            if(i - l + 1 < k) return quickSelect(a, l, r, k); //填空
            else return quickSelect(a, l, i - 1, k);
        }
        public static void main(String args[]) {
            Scanner scan = new Scanner(System.in);
            int n = scan.nextInt();
            int a[]=new int[110];
            for(int i=0;i<n;i++)
            {
                a[i]=scan.nextInt();
            }
            System.out.println(quickSelect(a, 0, n-1, 5));
        }
    }

F，递增三元组

第一次只有62.5%的通过率，三个超时，

第一次(62.5%)：

package train;

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

public class test_31 {
    public static void main(String [] args){
        Scanner br=new Scanner(System.in);
        int n=br.nextInt();
        int []a=new int[n];
        int []b=new int[n];
        int []c=new int[n];
        for(int i=0;i<n;i++)
            a[i]=br.nextInt();
        for(int i=0;i<n;i++)
            b[i]=br.nextInt();
        for(int i=0;i<n;i++)
            c[i]=br.nextInt();
        Arrays.sort(a);
        Arrays.sort(b);
        Arrays.sort(c);
        long count=0;
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                for(int k=0;k<n;k++)
                {
                    if(a[i]<b[j]&&b[j]<c[k])
                        count++;
                }
        System.out.println(count);
    }
}

100%：

第二个while循环不可以写成c(k)>b[j],这样连循环都进不去，会在第一个小于b数组的数时卡住，

package train;

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

public class test_31 {
    public static void main(String [] args){
        Scanner br=new Scanner(System.in);
        int n=br.nextInt();
        int []a=new int[n];
        int []b=new int[n];
        int []c=new int[n];
        for(int i=0;i<n;i++)
            a[i]=br.nextInt();
        for(int i=0;i<n;i++)
            b[i]=br.nextInt();
        for(int i=0;i<n;i++)
            c[i]=br.nextInt();
        Arrays.sort(a);
        Arrays.sort(b);
        Arrays.sort(c);
        long count=0L;
        for(int i=0;i<n;i++) {
            int j=0,k=0;
            while (j < n && b[i] > a[j])
                j++;
            while(k<n&&c[k]<=b[i])
                k++;
            count+=1L*j*(n-k);
        }
        System.out.println(count);
    }
}

G，螺旋折线

package train;

import java.util.Scanner;

public class test_32 {
    public static void main(String[] args){
        Scanner br=new Scanner(System.in);
       long a=br.nextLong();
        long b=br.nextLong();
        long max=Math.max(Math.abs(a),Math.abs(b));
        long ans=0;
        if(a==max){
            ans=a*(4*a+1)-b;
        }else if(a==-max){
              ans=max*(max*4-3)+b;
        }else if(b==max){
            ans=b*(4*b-1)+a;
        }else if(b==-max){
            ans=max*(4*max+3)-a;
        }
        System.out.println(ans);
    }
}

I，全球变暖

直接利用bfs解题就可以

import java.util.*;//使用BFS的解法
class node{
    int x,y;
    public point(int x,int y) {
        this.x =x;
        this.y=y;
    }
}
public class test_33 {
    static int N =1000;
    static char[][] map=new char[N][N];
    static int[][] vis=new int[N][N];
    static int flag;
    static int[][] dis= {{0,1},{0,-1},{1,0},{-1,0}};
    static void bfs(node p0) {
        vis[p0.x][p0.y]=1;
        LinkedList<node> qu=new LinkedList<node>();
        qu.addLast(p0);
        while(!qu.isEmpty()) {
            p0=qu.removeFirst();
            if(map[p0.x+1][p0.y]=='#'&&map[p0.x-1][p0.y]=='#'&&map[p0.x][p0.y+1]=='#'&&map[p0.x][p0.y-1]=='#') {
                flag++;
            }
            for(int i=0;i<4;i++) {
                node p1=new node(p0.x+dis[i][0],p0.y+dis[i][1]);
                if(map[p1.x][p1.y]=='#'&&vis[p1.x][p1.y]==0) {
                    vis[p1.x][p1.y]=1;
                    qu.addLast(p1);
                }
            }
        }
    }
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        int n=sc.nextInt();sc.nextLine();

        for(int i=0;i<n;i++) {
            map[i]=sc.nextLine().toCharArray();
        }
        int land=0;
        for(int x=0;x<n;x++) {
            for(int y=0;y<n;y++) {
                if(map[x][y]=='#'&&vis[x][y]==0) {
                    node p=new node(x,y);
                    flag=0;
                    bfs(p);
                    if(flag==0) {
                        land++;
                    }
                }
            }
        }
        System.out.println(land);
    }
}