• 第九届蓝桥杯JavaB组省赛真题


    解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论

    题目1、第几天

    题目描述
    2000年的1月1日,是那一年的第1天。
    那么,2000年的5月4日,是那一年的第几天?

    注意:需要提交的是一个整数,不要填写任何多余内容。

    import java.util.Calendar;
    import java.util.GregorianCalendar;
    import JavaB.s9.Reader;
    /**
     * 125
     * @description TODO
     * @author frontier
     * @time 2019年3月8日 上午9:34:38
     *月份从0开始
     */
    public class 结果填空1第几天 {
    	static long n1,n2;
    
    	public static void main(String[] args) {
    		Reader.init(System.in); // connect Reader to an input stream
    		Calendar c1=new GregorianCalendar();
    		c1.set(2000, 0, 1);
    		Calendar c2=new GregorianCalendar();
    		c2.set(2000, 4, 4);
    		n1=c1.getTimeInMillis();
    		n2=c2.getTimeInMillis();
    		long day=(n2-n1)/(1000*3600*24);
    		System.out.println(day+1);
    
    	}
    }
    
    
    
    题目2、方格计数

    题目描述
    如图p1.png所示,在二维平面上有无数个1x1的小方格。

    我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
    你能计算出这个圆里有多少个完整的小方格吗?

    注意:需要提交的是一个整数,不要填写任何多余内容。

    在这里插入图片描述

    PS:
    以圆的圆心为坐标原点,半径所在直线为横轴和纵轴,将圆划分为四个象限。计算出一个象限内的方块个数再*4即可。

    设a,b为最远的方块的长度,r为圆的半径长。最远的方块的的顶点一定不会超过圆的半径因此aa+bb<=r*r。

    public class Main {
    	public static void main(String args[]) {
    		int a, b;
    		int r = 1000;// 半径长度
    		int sum = 0;// 总个数
    		for (int i = 0; i < 1000; i++) {
    			for (int j = 0; j < 1000; j++) {
    				a = i + 1;
    				b = j + 1;
    				if (a * a + b * b <= r * r)
    					sum++;
    			}
    		}
    		System.out.println(sum * 4);
    	}
    }
    
    题目3、复数幂

    题目描述
    设i为虚数单位。对于任意正整数n,(2+3i)^n 的实部和虚部都是整数。
    求 (2+3i)^123456 等于多少? 即(2+3i)的123456次幂,这个数字很大,要求精确表示。

    答案写成 “实部±虚部i” 的形式,实部和虚部都是整数(不能用科学计数法表示),中间任何地方都不加空格,实部为正时前面不加正号。(2+3i)^2 写成: -5+12i,
    (2+3i)^5 的写成: 122-597i

    注意:需要提交的是一个很庞大的复数,不要填写任何多余内容。

    import java.math.BigInteger;
    
    /**
     * https://blog.csdn.net/xy88115211/article/details/80401199
     * @param args
     * 13483137
    1100011648
    
     */
    public class 结果填空3复数幂 {
    	static BigInteger A=new BigInteger("2");
    	static BigInteger B=new BigInteger("3");
    	static BigInteger a=new BigInteger("2");
    	static BigInteger b=new BigInteger("3");
    	static BigInteger ta,tb;
    	public static void main(String[] args) {
    		//System.out.println(Math.pow(2, 123456));
    		for(int i=1;i<=123455;++i) {
    			ta=a.multiply(A).subtract(b.multiply(B));
    			tb=a.multiply(B).add(b.multiply(A));
    			A=ta;
    			B=tb;
    		}
    		System.out.print(A);
    		if(B.compareTo(BigInteger.ZERO)>0)
    			System.out.print("+");
    		System.out.print(B);
    		System.out.println("i");
    	}
    }
    
    
    题目4、测试次数

    题目描述
    x星球的居民脾气不太好,但好在他们生气的时候唯一的异常举动是:摔手机。
    各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试,并且评定出一个耐摔指数来,之后才允许上市流通。

    x星球有很多高耸入云的高塔,刚好可以用来做耐摔测试。塔的每一层高度都是一样的,与地球上稍有不同的是,他们的第一层不是地面,而是相当于我们的2楼。

    如果手机从第7层扔下去没摔坏,但第8层摔坏了,则手机耐摔指数=7。
    特别地,如果手机从第1层扔下去就坏了,则耐摔指数=0。
    如果到了塔的最高层第n层扔没摔坏,则耐摔指数=n

    为了减少测试次数,从每个厂家抽样3部手机参加测试。

    某次测试的塔高为1000层,如果我们总是采用最佳策略,在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢?

    请填写这个最多测试次数。

    注意:需要填写的是一个整数,不要填写任何多余内容。

    PS:
    小伙伴们注意一下,这道题其实是谷歌面试题,高楼扔鸡蛋

    import java.util.Scanner;
     
    public class Main {
     
    	private static int maxn = 1005;
    	private static int[][] dp = new int[maxn][10];
    	private static int inf = 0x3f3f3f3f;
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Scanner cin = new Scanner(System.in);
    		int n = cin.nextInt();
    		int m = cin.nextInt();
    		for(int i = 0; i <= n; ++i) {
    			for(int j = 0; j <= m; ++j) {
    				dp[i][j] = inf;
    			}
    		}
    		System.out.println(work(n, m));
    	}
    	private static int work(int n, int m) {
    		if(dp[n][m] != inf) {
    			return dp[n][m];
    		}
    		if(n == 0) {
    			return dp[n][m] = 0;
    		}
    		if(m == 1) {
    			return dp[n][m] = n;
    		}
    		for(int i = 1; i <= n; ++i) {
    			dp[n][m] = Math.min(dp[n][m], 1 + Math.max(work(i-1, m-1), work(n-i, m)));
    		}
    		return dp[n][m];
    	}
     
    }
    
    题目5、快速排序

    以下代码可以从数组a[]中找出第k小的元素。

    它使用了类似快速排序中的分治算法,期望时间复杂度是O(N)的。

    请仔细阅读分析源码,填写划线部分缺失的内容。

    package bb;
    import java.util.Random;
    public class JB18_5快速排序 {
        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)// (1)说明到底了
                return a[i];
            if (i - l + 1 < k)
                return quickSelect(a, i + 1, r, k - i + l - 1); // 填空
            // qsort(a, i + 1, right);
            // (3)先试试k,
            // (4)再考虑:k要移动到等于(i - l + 1),试试k-(i - l + 1)
            else
                // i - l + 1 > k
                return quickSelect(a, l, i - 1, k);// (2)qsort(a, left, i -
                                                    // 1);对上了,k不变
        }
        public static void main(String args[]) {
            int[] a = { 1, 4, 2, 8, 5, 7 };
            System.out.println(quickSelect(a, 0, 5, 4));
            // int [] a = {1, 4, 2, 8, 5, 7, 23, 58, 16, 27, 55, 13, 26, 24, 12, 2};
            // System.out.println(quickSelect(a, 0, a.length-1, 6));
        }
    }
    
    题目6、递增三元组

    题目描述
    给定三个整数数组
    A = [A1, A2, … AN],
    B = [B1, B2, … BN],
    C = [C1, C2, … CN],
    请你统计有多少个三元组(i, j, k) 满足:

    1. 1 <= i, j, k <= N
    2. Ai < Bj < Ck

    【输入格式】
    第一行包含一个整数N。
    第二行包含N个整数A1, A2, … AN。
    第三行包含N个整数B1, B2, … BN。
    第四行包含N个整数C1, C2, … CN。

    对于30%的数据,1 <= N <= 100
    对于60%的数据,1 <= N <= 1000
    对于100%的数据,1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000

    【输出格式】
    一个整数表示答案

    【输入样例】
    3
    1 1 1
    2 2 2
    3 3 3

    【输出样例】
    27

    资源约定:
    峰值内存消耗(含虚拟机) < 256M
    CPU消耗 < 1000ms

    请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
    所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
    不要使用package语句。不要使用jdk1.7及以上版本的特性。
    主类的名字必须是:Main,否则按无效代码处理。

    import java.util.Arrays;
    import java.util.Scanner;
     
    public class t6 {
    	
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		int n = sc.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] = sc.nextInt();
    		for (int i = 0; i < n; i++) 
    			B[i] = sc.nextInt();
    		for (int i = 0; i < n; i++) 
    			C[i] = sc.nextInt();
    		Arrays.sort(A);
    		Arrays.sort(B);
    		Arrays.sort(C);
    		int[] l = new int[n];
    		int[] r = new int[n];
    		long sum = 0;
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				if (B[j] > A[i]) {
    					l[i] = n - j;
    					break;
    				}
    			}
    			if (l[i] != 0)
    				for (int j = 0; j < n; j++) {
    					if (C[j] > B[i]) {
    						r[i] = n - j;
    						sum += l[i] * r[i];
    						break;
    					}
    				}
    		}
    		System.out.println(sum);
     		
    	}
    }
    
    题目7、螺旋折线

    题目描述
    如图p1.pgn所示的螺旋折线经过平面上所有整点恰好一次。
    对于整点(X, Y),我们定义它到原点的距离dis(X, Y)是从原点到(X, Y)的螺旋折线段的长度。

    例如dis(0, 1)=3, dis(-2, -1)=9

    给出整点坐标(X, Y),你能计算出dis(X, Y)吗?

    【输入格式】
    X和Y

    对于40%的数据,-1000 <= X, Y <= 1000
    对于70%的数据,-100000 <= X, Y <= 100000
    对于100%的数据, -1000000000 <= X, Y <= 1000000000

    【输出格式】
    输出dis(X, Y)

    【输入样例】
    0 1

    【输出样例】
    3

    资源约定:
    峰值内存消耗(含虚拟机) < 256M
    CPU消耗 < 1000ms

    请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。

    所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
    不要使用package语句。不要使用jdk1.7及以上版本的特性。
    主类的名字必须是:Main,否则按无效代码处理。
    在这里插入图片描述

    import java.util.Scanner;
    
    public class Main {
        static int x, y;
        static int df = 0;
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            x = in.nextInt();
            y = in.nextInt();
    
            if (x > 0 && y >= 0) {
                int dx = Math.max(x, y);
                int dy = dx;
                df = (dx + dy) * (dx + dy);
                if (x < dx) {
                    df -= (dx - x);
                }
                if (y < dy) {
                    df += (dy - y);
                }
            } else if (x >= 0 && y < 0) {
                int dx = Math.max(Math.abs(x), Math.abs(y));
                int dy = -dx;
                df = (dx + Math.abs(dy)) * (dx + Math.abs(dy) + 1);
                if (x < dx) {
                    df += (dx - x);
                }
                if (y > dy) {
                    df -= (y - dy);
                }
            } else if (x < 0 && y <= 0) {
                int dx = -Math.max(Math.abs(x), Math.abs(y));
                int dy = dx + 1;
                df = (Math.abs(dx) + Math.abs(dy)) * (Math.abs(dx) + Math.abs(dy));
                if (x > dx) {
                    df -= (x - dx);
                }
                if (y > dy) {
                    df += (y - dy);
                }
            } else  if (x <= 0 && y > 0) {
                int dx = -Math.max(Math.abs(x), Math.abs(y));
                int dy = -dx;
                df = (Math.abs(dx) + Math.abs(dy)) * (Math.abs(dx) + Math.abs(dy) - 1);
                if (x > dx) {
                    df += (x - dx);
                }
                if (y < dy) {
                    df -= (y - dy);
                }
            }
            System.out.println(df);
        }
    }
    
    题目8、阶乘位数

    题目描述
    小明维护着一个程序员论坛。现在他收集了一份"点赞"日志,日志共有N行。其中每一行的格式是:

    ts id

    表示在ts时刻编号id的帖子收到一个"赞"。

    现在小明想统计有哪些帖子曾经是"热帖"。如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞,小明就认为这个帖子曾是"热帖"。

    具体来说,如果存在某个时刻T满足该帖在[T, T+D)这段时间内(注意是左闭右开区间)收到不少于K个赞,该帖就曾是"热帖"。

    给定日志,请你帮助小明统计出所有曾是"热帖"的帖子编号。

    【输入格式】
    第一行包含三个整数N、D和K。
    以下N行每行一条日志,包含两个整数ts和id。

    对于50%的数据,1 <= K <= N <= 1000
    对于100%的数据,1 <= K <= N <= 100000 0 <= ts <= 100000 0 <= id <= 100000

    【输出格式】
    按从小到大的顺序输出热帖id。每个id一行。

    【输入样例】
    7 10 2
    0 1
    0 10
    10 10
    10 1
    9 1
    100 3
    100 3

    【输出样例】
    1
    3

    资源约定:
    峰值内存消耗(含虚拟机) < 256M
    CPU消耗 < 1000ms

    请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。

    所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
    不要使用package语句。不要使用jdk1.7及以上版本的特性。
    主类的名字必须是:Main,否则按无效代码处理。

    import java.util.Arrays;
    import java.util.Scanner;
    class Main
    {
        public static void main(String args[])
        {
            int n,d,k;  //输入的N行每行一条日志,包含两个整数ts 和id。   
            Scanner sc=new Scanner(System.in);
            n=sc.nextInt();
            d=sc.nextInt();
            k=sc.nextInt();
            ClickHot arr[]=new ClickHot[n];
            for(int i=0;i<n;i++)
                arr[i]=new ClickHot(sc.nextInt(),sc.nextInt()); //存放每组数字
            Arrays.sort(arr); //对其进行排序
            int parentId=arr[0].id; //先拿到第一个id
            int flag=0; //设置一个标志
            for(int i=0;i<n;i++)
            {
                if(i+k-1<n&&arr[i+k-1].id==parentId&&arr[i+k-1].ts-arr[i].ts<d&&flag==0) 
                    // 后一个的id与(前一个id值相比较):(这里需要说明一下,这个id就是我所得到的变量parentId的值)
                {
                    System.out.println(parentId); //输出这个id 因为题目中只要求输出在同一个时间段有两个赞即可
                    flag=1;//这步设置变量,当后面来相同的,但是我不需要输出了,因为两个已经够了
                }
                else if(arr[i].id!=parentId) //这步是如果我不相同id值,那么我就把这个当前的id用我现在i数组中对应的id取代
                {
                    parentId=arr[i].id; //把先前的id替换
                    flag=0; //重新设置标志
                    i=i-1; //因为我把上面一个设置了,此时我需要向上减一,然后再做比较,这样相当于我开始时候i不做变换没我把该取代的值取代掉
                }
            }
        }
    }
    class ClickHot implements Comparable<ClickHot>  //创建一个ClickHot类留存放两个每次的两个数字  一个是 ts 是td
    {
        int ts,id;
        ClickHot(int a,int b)  //两个变量
        {
            this.ts=a;
            this.id=b;
        }
     
        @Override
        public int compareTo(ClickHot o) {
            if(id==o.id)  //先对id做比较其次id相同对ts做比较
                return ts-o.ts;
            else
                return id-o.id;
        }
     
    }
    
    题目9、全球变暖
    题目描述
    你有一张某海域NxN像素的照片,"."表示海洋、"#"表示陆地,如下所示:
    
    .......
    .##....
    .##....
    ....##.
    ..####.
    ...###.
    .......
    
    其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。  
    
    由于全球变暖导致了海面上升,科学家预测未来几十年,岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋),它就会被淹没。  
    
    例如上图中的海域未来会变成如下样子:
    
    .......
    .......
    .......
    .......
    ....#..
    .......
    .......
    
    请你计算:依照科学家的预测,照片中有多少岛屿会被完全淹没。  
    
    【输入格式】
    第一行包含一个整数N。  (1 <= N <= 1000)  
    以下N行N列代表一张海域照片。  
    
    照片保证第1行、第1列、第N行、第N列的像素都是海洋。  
    
    【输出格式】
    一个整数表示答案。
    
    【输入样例】
    7 
    .......
    .##....
    .##....
    ....##.
    ..####.
    ...###.
    .......  
    
    【输出样例】
    1  
    
    资源约定:
    峰值内存消耗(含虚拟机) < 256M
    CPU消耗  < 1000ms
    
    
    请严格按要求输出,不要画蛇添足地打印类似:“请您输入...” 的多余内容。
    
    所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
    不要使用package语句。不要使用jdk1.7及以上版本的特性。
    主类的名字必须是:Main,否则按无效代码处理。
    
    
    import java.util.Scanner;
    /**
     * 2018蓝桥杯Java B组 全球变暖问题:
     * 条件:
     .代表海洋像素,#代表像素,相连的一块#代表岛屿,如果陆地像素左右上下某个方向有海洋便会被淹没成海洋
    
     输入:
     7
     .......
     .##.....
     .##.....
     ...##..
     ..###...
     ...##..
     .......
    
    输出:
     .......
     .......
     .......
     .......
     ...#...
     .......
     .......
     * Created by XQM on 2018/4/2.
     */
    public class Main{
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();//输入n构成n*n二维数组
            String[] s = new String[n];
            char[] c;
            char[][] a = new char[n][n];//存储输入的字符
            char[][] b = new char[n][n];//存储输出的字符
    
            //输入
            for (int i = 0;i < n;i++){
                s[i] = sc.next();
                c = s[i].toCharArray();
                for (int j = 0; j < n;j++){
                    a[i][j] = c[j];
                    b[i][j] = c[j];
                }
            }
    
            char temp;
            //题目的要求是第一行、第一列、最后一行、最后一列都是.
            for (int i = 0;i < n;i++){
                for (int j = 0; j < n;j++){
                    if (i != 0 && i != 6 && j != 0 && j != 6){
                        temp = a[i][j];
                        if (temp == '#'){
                            if ((temp != a[i][j-1]) || (temp != a[i-1][j]) || (temp != a[i][j+1]) || (temp != a[i+1][j])){
                                b[i][j] = '.';
                            }
                        }
                    }else {
                        b[i][j] = '.';
                    }
                }
    
            }
    
            //输出
            for (int i = 0;i < n;i++){
                for (int j = 0; j < n;j++){
                    System.out.print(b[i][j]);
                }
                System.out.println();
            }
        }
    }
    
    
    题目10、堆的计数
    题目描述
    我们知道包含N个元素的堆可以看成是一棵包含N个节点的完全二叉树。  
    每个节点有一个权值。对于小根堆来说,父节点的权值一定小于其子节点的权值。  
    
    假设N个节点的权值分别是1~N,你能求出一共有多少种不同的小根堆吗?  
    
    例如对于N=4有如下3种:
    
        1
       / 
      2   3
     /
    4
    
        1
       / 
      3   2
     /
    4
    
        1
       / 
      2   4
     /
    3
    
    由于数量可能超过整型范围,你只需要输出结果除以1000000009的余数。  
    
    
    【输入格式】
    一个整数N。  
    对于40%的数据,1 <= N <= 1000  
    对于70%的数据,1 <= N <= 10000  
    对于100%的数据,1 <= N <= 100000
    
    【输出格式】
    一个整数表示答案。  
    
    【输入样例】
    4  
    
    【输出样例】
    3
    
    
    资源约定:
    峰值内存消耗(含虚拟机) < 256M
    CPU消耗  < 1000ms
    
    
    请严格按要求输出,不要画蛇添足地打印类似:“请您输入...” 的多余内容。
    
    所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
    不要使用package语句。不要使用jdk1.7及以上版本的特性。
    主类的名字必须是:Main,否则按无效代码处理。
    
    

    PS:
    这里附上C++代码,还望Java大佬指点
    假设d[i]是以完全二叉树i号位置为根结点的二叉子堆个数,则考虑我们现在需要把n个点放入这个完全二叉树里,显然根节点已经被确定,只能放最小的,然后假设左子树的节点个数为lsize,则我们需要从n-1个节点中选出lsize个节点放入左子树,选法一共组合数C(n-1,lsize)种,剩余的放在右子树中,所以d[i]=C(n-1,lsize)*d[i的左儿子]*d[i的右儿子];

    注意:求组合数需要用快速幂,乘法逆元的知识。以i为根节点个数可以先用动态规划算出来,s[i]=s[i的左儿子]+s[i的右儿子];

    求阶乘逆元O(nlongn),动态规划O(n);

    所以此算法的时间复杂度O(nlongn),在本题最大数据10^5下,具有时间可行性;

    #include <iostream>
    #include <cstdio>
    #define _for(i,a,b) for(int i=a;i<b;i++)
    #define _unfor(i,a,b) for(int i=a;i>=b;i--)
    #define mset(a,val,n) for(int i=0;i<n;i++)a[i]=val;
     
    using namespace std;
    typedef long long LL;
    LL d[100005],s[100005],mod=1000000009;
    LL f[100005],inv[100005],n;
    LL C(LL n,LL m){
        return f[n]*inv[m]%mod*inv[n-m]%mod;
    }
    LL qpow(LL a,LL n){
        if(!n||a==1)return 1;
        LL x=qpow(a,n/2);
        return n%2?(x*x%mod*a%mod):(x*x%mod);
    }
    int main(){
        cin>>n;
        f[0]=1;
        _for(i,1,100005){
            f[i]=f[i-1]*i%mod;
            inv[i]=qpow(f[i],mod-2);
        }
        _unfor(i,n,1)
            s[i]=(i*2<=n?s[i*2]:0)+((i*2+1)<=n?s[i*2+1]:0)+1; //c[i]<=n所以不用取余
        //初始化子树节点个数
        mset(d,1,n+5);
        _unfor(i,n,1)if(i*2+1<=n)
            d[i]= ((C(s[i]-1,s[i*2+1])*d[i*2])%mod*d[i*2+1])%mod;
        cout<< d[1]<<endl;
    }
    
  • 相关阅读:
    asp.net编程基础
    http://blog.csdn.net/pjw100/article/details/5261582
    英雄无敌3版的仙剑奇侠传
    另类DATAGRID数据编辑修改
    使用INDY组件发送邮件,DEMO程序没有讲到的一些内容.如邮件格式定议
    .net 简单实现MD5
    VB.NET 对于类型的传递按值或者按引用
    Start with Database Connection Pool 连接管理
    ASP页面之间传值
    正则表达式
  • 原文地址:https://www.cnblogs.com/a1439775520/p/13078577.html
Copyright © 2020-2023  润新知