第七届蓝桥杯Java A组决赛试题

1.阶乘位数


9的阶乘等于：362880
它的二进制表示为：1011000100110000000
这个数字共有19位。


请你计算，9999 的阶乘的二进制表示一共有多少位？


注意：需要提交的是一个整数，不要填写任何无关内容（比如说明解释等）

答案：118445

思路：考查BigInteger

import java.util.*;
import java.math.*;
public class Main {

    public static void main(String[] args) {
        // write your code here
        BigInteger num;
        num=BigInteger.ONE;
        for(int i=1;i<=9999;i++)
        {
            BigInteger temp=BigInteger.valueOf(i);
            num=num.multiply(temp);
        }
        String str=num.toString(2);
        System.out.println(str.length());
    }

}

2.凑平方数


把0~9这10个数字，分成多个组，每个组恰好是一个平方数，这是能够办到的。
比如：0, 36, 5948721


再比如：
1098524736
1, 25, 6390784
0, 4, 289, 15376
等等...


注意，0可以作为独立的数字，但不能作为多位数字的开始。
分组时，必须用完所有的数字，不能重复，不能遗漏。


如果不计较小组内数据的先后顺序，请问有多少种不同的分组方案？


注意：需要提交的是一个整数，不要填写多余内容。

答案：300

思路：先枚举所有各位不相等平方数，再通过DFS查找符合条件的数组。

import java.util.*;
import java.math.*;
public class Main {

    static long map[]=new long[1000];
    static int count;
    static int res=0;
    static boolean vis[]=new boolean[10];

    public static boolean check(long num)//检查这个数字是否各位不相等
    {
        int vis[]=new int[10];
        while(num>0)
        {
            long temp = num % 10;
            vis[(int)temp]++;
            if(vis[(int)temp]>1)
            {
                return false;
            }
            num=num/10;
        }
        return true;

    }

    public static void visit(long num,boolean flag)//添加(删除)这个数字并标记数字是否访问
    {


        if(flag==true)
        {
            if(num==0)
            {
                vis[0]=true;
                return;
            }

            while (num>0)
            {
                vis[(int)(num%10)]=true;
                num=num/10;
            }
        }

        if(flag==false)
        {
            if(num==0)
            {
                vis[0]=false;
                return;
            }

            while (num>0)
            {
                vis[(int)(num%10)]=false;
                num=num/10;
            }
        }
    }

    public static boolean checkvis(long num)//检测是否能添加这个数字
    {
        while (num>0)
        {
            if(vis[(int)(num%10)])
            {
                return false;
            }
            num=num/10;
        }
        return true;
    }

    public  static boolean isFind()//检测是否用完了所有数字
    {
        for(int i=0;i<10;i++)
        {
            if(!vis[i])
            {
                return false;
            }
        }
        return true;
    }


    public static void dfs(int i)//i是指map[i]的索引，按照从小到大dfs
    {
        if(isFind())
        {
            res++;
            return;
        }

        for(int j=i;j<count;j++)
        {
            if(checkvis(map[j]))
            {
                visit(map[j],true);
                dfs(j+1);
                visit(map[j],false);//注意回溯
            }
        }

    }

    public static void main(String[] args) {
        // write your code here
        count=0;
        for(long i=0;i<100000;i++)
        {
            long num=i*i;
            if(check(num))
            {
                map[count]=num;//将所有结果保存到map中
                count++;
            }
        }
        dfs(0);
        System.out.println(res);
    }

}

3.棋子换位


有n个棋子A，n个棋子B，在棋盘上排成一行。
它们中间隔着一个空位，用“.”表示，比如：


AAA.BBB


现在需要所有的A棋子和B棋子交换位置。
移动棋子的规则是：
1. A棋子只能往右边移动，B棋子只能往左边移动。
2. 每个棋子可以移动到相邻的空位。
3. 每个棋子可以跳过相异的一个棋子落入空位（A跳过B或者B跳过A）。


AAA.BBB 可以走法：
移动A ==> AA.ABBB
移动B ==> AAAB.BB


跳走的例子：
AA.ABBB ==> AABA.BB


以下的程序完成了AB换位的功能，请仔细阅读分析源码，填写划线部分缺失的内容。



注意：只提交划线部分缺少的代码，不要复制已有代码或填写任何多余内容。


答案：valid(data,i+dd+dd) && valid(data, i-dd) && data[i-dd] == data[i+dd+dd]

public class Main
{
	static void move(char[] data, int from, int to)
	{
		data[to] = data[from];
		data[from] = '.';
	}
	
	static boolean valid(char[] data, int k)
	{
		if(k<0 || k>=data.length) return false;
		return true;
	}
	
	static void f(char[] data)
	{
		while(true){
			boolean tag = false;
			for(int i=0; i<data.length; i++){
				int dd = 0; // 移动方向
				if(data[i]=='.') continue;
				if(data[i]=='A') dd = 1;
				if(data[i]=='B') dd = -1;
				
				if(valid(data, i+dd) && valid(data,i+dd+dd) 
				&& data[i+dd]!=data[i] && data[i+dd+dd]=='.'){ 
				// 如果能跳...
					move(data, i, i+dd+dd);
					System.out.println(new String(data));
					tag = true;
					break;
				}
			}
			
			if(tag) continue;
			
			for(int i=0; i<data.length; i++){
				int dd = 0; // `移动方向
				if(data[i]=='.') continue;
				if(data[i]=='A') dd = 1;
				if(data[i]=='B') dd = -1;			
					 
				if(valid(data, i+dd) && data[i+dd]=='.'){ 
				// 如果能移动...
					if( _____________________ ) continue;  //填空位置
					move(data, i, i+dd);
					System.out.println(new String(data));
					tag = true;
					break;
				}
			}
			
			if(tag==false) break;					
		}
	}
	
	public static void main(String[] args)
	{
		char[] data = "AAA.BBB".toCharArray();	
		f(data);
	}
}

4.机器人塔


X星球的机器人表演拉拉队有两种服装，A和B。
他们这次表演的是搭机器人塔。


类似：


     A
    B B
   A B A
  A A B B
 B B B A B
A B A B B A


队内的组塔规则是：
  
  A 只能站在 AA 或 BB 的肩上。
  B 只能站在 AB 或 BA 的肩上。


你的任务是帮助拉拉队计算一下，在给定A与B的人数时，可以组成多少种花样的塔。


输入一行两个整数 M 和 N，空格分开（0<M,N<500）,分别表示A、B的人数，保证人数合理性。


要求输出一个整数，表示可以产生的花样种数。


例如：
用户输入：
1 2


程序应该输出：
3




再例如：
用户输入：
3 3


程序应该输出：
4


资源约定：
峰值内存消耗 < 256M
CPU消耗  < 1000ms




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


所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。

注意：主类的名字必须是：Main，否则按无效代码处理。

思路：显然确定了最底下一行就能确定整个图，DFS枚举即可。

import java.util.*;
public class Main {

    static int m,n,r;
    static int a[];
    static int map[][];
    static int res=0;

    public static void check()//以a数组为最后一行补全整个图存入map,统计A,B个数判断是否符合条件
    {
        int numa=0;
        int numb=0;

        for(int i=0;i<r;i++)
        {
            map[r-1][i]=a[i];
        }

        for(int i=r-2;i>=0;i--)
        {
            for(int j=0;j<=i;j++)
            {
                if((map[i+1][j]==1 && map[i+1][j+1]==1)||(map[i+1][j]==0 && map[i+1][j+1]==0))
                {
                    map[i][j]=1;
                }
                else
                {
                    map[i][j]=0;
                }
            }
        }

        for(int i=0;i<r;i++)
        {
            for(int j=0;j<=i;j++)
            {
                if(map[i][j]==1)
                {
                    numa++;
                }
                if(map[i][j]==0)
                {
                    numb++;
                }
            }
        }

        if(numa==m && numb==n)
        {
            res++;
        }
    }

    public static void dfs(int na,int nb,int i)//枚举最后一行并把结果存入a数组
    {
        if(i==r)
        {
            check();
            return;
        }

        if(na>0)
        {
            a[i]=1;
            dfs(na-1,nb,i+1);
        }
        if(nb>0)
        {
            a[i]=0;
            dfs(na,nb-1,i+1);
        }
    }
    public static void main(String[] args) {
        // write your code here
        Scanner in=new Scanner(System.in);
        m=in.nextInt();
        n=in.nextInt();

        int row=0;
        for(int i=1;i<50;i++)
        {
            row+=i;
            if(row==(m+n))
            {
                r=i;
            }
        }

        a=new int[r];//A代表1，B代表2
        map=new int[r][r];

        dfs(m,n,0);
        System.out.print(res);

    }

}

5.广场舞


LQ市的市民广场是一个多边形，广场上铺满了大理石的地板砖。


地板砖铺得方方正正，就像坐标轴纸一样。
以某四块砖相接的点为原点，地板砖的两条边为两个正方向，一块砖的边长为横纵坐标的单位长度，则所有横纵坐标都为整数的点都是四块砖的交点（如果在广场内）。


广场的砖单调无趣，却给跳广场舞的市民们提供了绝佳的参照物。每天傍晚，都会有大批市民前来跳舞。
舞者每次都会选一块完整的砖来跳舞，两个人不会选择同一块砖，如果一块砖在广场边上导致缺角或者边不完整，则没人会选这块砖。
（广场形状的例子参考【图1.png】）


现在，告诉你广场的形状，请帮LQ市的市长计算一下，同一时刻最多有多少市民可以在广场跳舞。






【输入格式】
输入的第一行包含一个整数n，表示广场是n边形的（因此有n个顶点）。
接下来n行，每行两个整数，依次表示n边形每个顶点的坐标（也就是说广场边缘拐弯的地方都在砖的顶角上。数据保证广场是一个简单多边形。


【输出格式】
输出一个整数，表示最多有多少市民可以在广场跳舞。


【样例输入】
5
3 3
6 4
4 1
1 -1
0 4


【样例输出】
7


【样例说明】
广场如图1.png所示，一共有7块完整的地板砖，因此最多能有7位市民一起跳舞。


【数据规模与约定】
对于30%的数据，n不超过100，横纵坐标的绝对值均不超过100。
对于50%的数据，n不超过1000，横纵坐标的绝对值均不超过1000。
对于100%的数据，n不超过1000，横纵坐标的绝对值均不超过100000000（一亿）。




资源约定：
峰值内存消耗 < 256M
CPU消耗  < 1000ms


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


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

import java.util.*;
public class Main {

    public static int all_sum=0;

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);

        int n=scanner.nextInt();
        int [][]points=new int[n][2];

        int max_x=Integer.MIN_VALUE,max_y=Integer.MIN_VALUE;
        int min_x=Integer.MAX_VALUE,min_y=Integer.MAX_VALUE;

        for(int i=0;i<n;i++){
            points[i][0]=scanner.nextInt();
            points[i][1]=scanner.nextInt();
            if(points[i][0]>max_x)max_x=points[i][0];
            if(points[i][0]<min_x)min_x=points[i][0];
            if(points[i][1]>max_y)max_y=points[i][1];
            if(points[i][1]<min_y)min_y=points[i][1];
        }//获取上下左右边界

        for(int i=min_x;i<max_x;i++){
            for(int j=min_y;j<max_y;j++){
                if(judge_point_is_in(points, i, j)&&judge_point_is_in(points, i+1, j)&&judge_point_is_in(points, i, j+1)&&judge_point_is_in(points, i+1, j+1)){
                    all_sum++;
                }
            }
        }
        System.out.println(all_sum);

    }

    public static boolean judge_point_is_in(int [][]points,int x,int y){
        boolean result=false;
        int j=points.length-1;
        //n-1~0 0~1 1~2 .....计算斜率
        for(int i=0;i<points.length;i++){
            if(Math.min(points[i][1], points[j][1])<y&&Math.max(points[i][1], points[j][1])>=y){
                double temp=(double)points[i][0]+(double)(((double)(y-points[i][1])/(double)(points[i][1]-points[j][1]))*((double)(points[i][0]-points[j][0])));
                if(temp<x){
                    result=!result;//关键判断
                }
            }
            j=i;
        }
        return result;
    }


}

6.生成树计数


给定一个 n*m 的格点图，包含 n 行 m 列共 n*m 个顶点，相邻的顶点之间有一条边。
【图1.png】给出了一个3*4的格点图的例子。




如果在图中删除部分顶点和其相邻的边，如上图删除第2行第3列和第3行第1列的顶点后，如【图2.png】所示。


图的生成树指包含图中的所有顶点和其中的一部分边，使得任意两个顶点之间都有由边构成的唯一路径。如果两个生成树包含有不同的边即被认为不同，则上图中共有31种不同的生成树，其中a边不选有10种，a边选有21种。
给出格点图中保留的顶点的信息，请计算该图一共有多少种不同的生成树。


【输入格式】
输入的第一行包含两个整数n, m，用空格分隔，表示格点图的行数和列数。
接下来n行，每行m个字母（中间没有分隔字符），每个字母必然是大写E或大写N，E表示对应的顶点存在，N表示对应的顶点不存在。保证存在至少一个顶点。


【输出格式】
输出一行，包含一个整数，表示生成树的个数。答案可能很大，你只需要计算答案除以1000000007的余数即可。


【样例输入】
3 4
EEEE
EENE
NEEE


【样例输出】
31


【数据规模与约定】
对于10%的数据，1<=n<=2。
对于30%的数据，1<=n<=3。
对于40%的数据，1<=n<=4。
对于50%的数据，1<=n<=5。
另有20%的数据，1<=n*m<=12。
另有10%的数据，1<=m<=15。
对于100%的数据，1<=n<=6，1<=m<=100000。


资源约定：
峰值内存消耗 < 256M
CPU消耗  < 8000ms




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


所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。

注意：主类的名字必须是：Main，否则按无效代码处理。

import java.util.HashSet;  
import java.util.LinkedList;  
import java.util.Queue;  
import java.util.Scanner;  
import java.util.Set;  
  
public class Main {  
  
    public static int all_point_num=0;             ///点的个数  
    public static Set<String>set=new HashSet<>();  ///去除重复的元素          
      
      
    public static void main(String[] args) {  
        Scanner scanner=new Scanner(System.in);  
        int m=scanner.nextInt();  
        int n=scanner.nextInt();  
        char [][]matrix_point=new char[m][n];  
        boolean [][]matrix_edge=new boolean[m*2][n];  
        for(int i=0;i<m;i++){  
            String temp=scanner.next();  
            for(int j=0;j<n;j++){  
                matrix_point[i][j]=temp.charAt(j);  
                if(matrix_point[i][j]=='E')all_point_num++;  
            }  
        }  
        set_matrix_enge(matrix_point, matrix_edge);  
        can_build_tree(matrix_edge, matrix_point);  
        System.out.println(set.size()%1000000007);  
    }  
      
    public static void set_matrix_enge(char[][]matrix_point,boolean[][] matrix_edge){  
        ///我们只检查每个节点的右侧和下侧，如果右侧和下侧是'E'，为其填上边  
        for(int i=0;i<matrix_point.length;i++){  
            for(int j=0;j<matrix_point[i].length;j++){  
                if(matrix_point[i][j]=='E'){  
                    if(j+1<matrix_point[i].length&&matrix_point[i][j+1]=='E')matrix_edge[i*2][j]=true;  
                    if(i+1<matrix_point.length&&matrix_point[i+1][j]=='E')matrix_edge[i*2+1][j]=true;  
                }  
            }  
        }  
    }  
      
    public static void can_build_tree(boolean[][]matrix_edge,char[][]matrix_point){  
        for(int i=0;i<matrix_edge.length;i++){  
            for(int j=0;j<matrix_edge[i].length;j++){  
                if(matrix_edge[i][j]){            ///找到一条边，将这条边删除，并检查是否是生成树  
                    boolean[][]current_matrix_edge=copy_matrix_edge(matrix_edge);  
                    current_matrix_edge[i][j]=false;  
                    if(is_a_tree_bfs(current_matrix_edge, matrix_point)){  
                        String temp_string=matrix_edge_to_string(current_matrix_edge);  
                        if(temp_string!="")  
                        set.add(temp_string);  
                        can_build_tree(current_matrix_edge, matrix_point);  
                    }  
                      
                }  
            }  
        }  
    }  
  
      
    public static String matrix_edge_to_string(boolean[][]matrix_edge){  
        String result="";  
        int temp_sum=0;  
        for(int i=0;i<matrix_edge.length;i++){  
            for(int j=0;j<matrix_edge[i].length;j++){  
                if(matrix_edge[i][j]==true){  
                    result+='1';  
                    temp_sum++;  
                }else{  
                    result+='0';  
                }  
            }  
        }  
        if(temp_sum!=all_point_num-1){  
            return "";  
        }  
        return result;  
    }  
      
  
    public static boolean is_a_tree_bfs(boolean[][]current_matrix_edge,char[][]matrix_point){  
        boolean result=false;  
        int current_point_num=0;  
        char[][]matrix_mark=new char[matrix_point.length][matrix_point[0].length];  
        Queue<Integer>queue=new LinkedList<Integer>();  
        for(int i=0;i<matrix_point.length;i++){  
            for(int j=0;j<matrix_mark[i].length;j++){  
                if(matrix_point[i][j]=='E'){              ///找到第一个节点，将其放入到  
                    queue.add(i);  
                    queue.add(j);  
                    current_point_num++;  
                    matrix_mark[i][j]='E';  
                    while(!queue.isEmpty()){  
                        int current_i=queue.remove();  
                        int current_j=queue.remove();  
                        if(current_j+1<matrix_point[current_i].length&¤t_matrix_edge[current_i*2][current_j]==true&&matrix_point[current_i][current_j+1]=='E'&&matrix_mark[current_i][current_j+1]!='E'){         ///右侧有节点  右侧的路是通的，并且右侧是节点  从未走过    
                            queue.add(current_i);  
                            queue.add(current_j+1);  
                            current_point_num++;  
                            matrix_mark[current_i][current_j+1]='E';  
                            //System.out.println("当前的坐标是："+current_i+","+current_j+"  他的右侧是可行的");  
                        }  
                        if(current_i+1<matrix_point.length&¤t_matrix_edge[current_i*2+1][current_j]==true&&matrix_point[current_i+1][current_j]=='E'&&matrix_mark[current_i+1][current_j]!='E'){          ///下侧有节点   下侧是通的  下侧是节点  从未走过       
                            queue.add(current_i+1);  
                            queue.add(current_j);  
                            current_point_num++;  
                            matrix_mark[current_i+1][current_j]='E';  
                            //System.out.println("当前的坐标是："+current_i+","+current_j+"  他的下侧是可行的 ");  
                        }  
                        if(current_j-1>=0&¤t_matrix_edge[current_i*2][current_j-1]==true&&matrix_point[current_i][current_j-1]=='E'&&matrix_mark[current_i][current_j-1]!='E'){         ///左    
                            queue.add(current_i);  
                            queue.add(current_j-1);  
                            current_point_num++;  
                            matrix_mark[current_i][current_j-1]='E';  
                            //System.out.println("当前的坐标是："+current_i+","+current_j+"  他的左侧是可行的");  
                        }  
                        if(current_i-1>=0&¤t_matrix_edge[current_i*2-1][current_j]==true&&matrix_point[current_i-1][current_j]=='E'&&matrix_mark[current_i-1][current_j]!='E'){          ///上       
                            queue.add(current_i-1);  
                            queue.add(current_j);  
                            current_point_num++;  
                            matrix_mark[current_i-1][current_j]='E';  
                            //System.out.println("当前的坐标是："+current_i+","+current_j+"  他的上侧是可行的 ");  
                        }  
                    }  
                    if(current_point_num==all_point_num)  
                        return true;  
                    else  
                        return false;  
                }  
            }  
        }  
        return result;  
    }  
      
    public static boolean[][]copy_matrix_edge(boolean[][]matrix_edge){  
        boolean [][]result=new boolean[matrix_edge.length][matrix_edge[0].length];  
        for(int i=0;i<matrix_edge.length;i++){  
            for(int j=0;j<matrix_edge[i].length;j++){  
                result[i][j]=matrix_edge[i][j];  
            }  
        }  
        return result;  
    }  
  
}