2015第六届蓝桥杯省赛JAVA B组真题解析（带源码及解析）

太过爱你忘了你带给我的痛 2023-07-14 05:48 11阅读 0赞

# [蓝桥杯历年真题及解析][Link 1]. #

### 目录 ###

*  蓝桥杯历年真题及解析.
 *   *  A：三角形面积（难度：★）
     *   *   *   *  分析：
                 *  AC代码
     *  B：立方变自身（难度：★★）
     *   *   *   *  分析：
                 *  AC代码
     *  C：三羊献瑞（难度：★★★★）
     *   *   *   *  分析：
                 *  AC代码
     *  D：循环节长度（难度：★★★）
     *   *   *   *  分析：
                 *  AC代码
     *  E：九数组分数（难度：★★）
     *   *   *   *  分析：
                 *  AC代码
     *  F：加法变乘法（难度：★★★★）
     *   *   *   *  分析：
                 *  AC代码：
     *  G：牌型种数（难度：★★★）
     *   *   *   *  分析：
                 *  AC代码：
     *  H：饮料换购（难度：★★）
     *   *   *   *  分析：
                 *  AC代码：
     *  I ：垒骰子（难度：★★★★★）
     *  J：生命之树（难度：★★★★★）

## A：三角形面积（难度：★） ##

如图所示。图中的所有小方格面积都是1。  
那么，图中的三角形面积应该是多少呢？

请填写三角形的面积。不要填写任何多余内容或说明性文字。

##### 分析： #####

加一道中线，以中线为底，两高相加，7\*8/2  
或者直接查方块数量  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyMzI3_size_16_color_FFFFFF_t_70]

##### AC代码 #####

package JB2015;
    
    public class A三角形面积 { 
    	public static void main(String[] args) { 
    		//把中线看作底，整体高度作为高
    		System.out.println((7*8)/2);
    	}
    }

## B：立方变自身（难度：★★） ##

观察下面的现象,某个数字的立方，按位累加仍然等于自身。  
1^3 = 1  
8^3 = 512 5+1+2=8  
17^3 = 4913 4+9+1+3=17  
…

请你计算包括1,8,17在内，符合这个性质的正整数一共有多少个？

请填写该数字，不要填写任何多余的内容或说明性的文字。

##### 分析： #####

X立方按位累加和不会超过99，  
99的立方有6位，  
按位累加和<6\*9=54，  
暴力枚举所有情况，  
符合条件计数得解。

##### AC代码 #####

package JB2015;
    
    public class B立方变自身 { 
    	public static int toNum(int x){ 
    		int ans=0;
    		while(x>0){ 
    			ans+=(x%10);
    			x/=10;
    		}
    		return ans;
    	}
    	public static void main(String[] args) { 
    		int count=0;
    		for(int i=1;i<100;i++){ 
    			if(i==toNum(i*i*i)){ 
    				count++;
    			}
    		}
    		System.out.println(count);
    	}
    }

## C：三羊献瑞（难度：★★★★） ##

观察下面的加法算式：  
![在这里插入图片描述][20200313171042515.png]

其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。

请你填写“三羊献瑞”所代表的4位数字（答案唯一），不要填写任何多余内容。

##### 分析： #####

设：  
//三 羊 献 瑞 生 气 祥 辉  
//\[0\] \[1\] \[2\] \[3\] \[4\] \[5\] \[6\] \[7\]  
上下一一对应。  
暴力枚举每一个位置1~9（去重），  
符合条件即输出。

##### AC代码 #####

package JB2015;
    
    // 三 羊 献 瑞 生 气 祥 辉
    //[0][1][2][3][4][5][6][7]
    public class C三羊献瑞 { 
    	public static int arr[]=new int[8],count=0;
    	
    	public static void check(){ 
    		if(arr[0]!=0&&((arr[6]+arr[0])*1000+(arr[1]+arr[3])*100+(arr[4]+arr[2])*10+arr[7]+arr[3])==
    				(arr[0]*10000+arr[1]*1000+arr[4]*100+arr[3]*10+arr[5])){ 
    				System.out.println(arr[0]+" "+arr[1]+" "+arr[2]+" "+arr[3]);
    		}
    	}
    	
    	public static void dfs(int k){ 
    		if(k==8)check();
    		else{ 
    			for(int i=0;i<10;i++){ 
    				if(contin(i))continue;
    				else{ 
    					arr[k]=i;
    					dfs(k+1);
    					arr[k]=10;
    				}
    			}
    		}
    	}
    	public static boolean contin(int x){ 
    		for(int i=0;i<8;i++)
    			if(arr[i]==x)
    				return true;
    		return false;
    	}
    
    	public static void main(String[] args) { 
    		for(int i=0;i<8;i++)
    			arr[i]=10;
    		dfs(0);
    	}
    }

## D：循环节长度（难度：★★★） ##

两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。  
比如，11/13=6=>0.846153846153… 其循环节为\[846153\] 共有6位。  
下面的方法，可以求出循环节的长度。

请仔细阅读代码，并填写划线部分缺少的代码。

public static int f(int n, int m)
    {
    	n = n % m;	
    	Vector v = new Vector();
    	
    	for(;;)
    	{
    		v.add(n);
    		n *= 10;
    		n = n % m;
    		if(n==0) return 0;
    		if(v.indexOf(n)>=0)  _________________________________ ;  //填空
    	}
    }

注意，只能填写缺少的部分，不要重复抄写已有代码。不要填写任何多余的文字。

##### 分析： #####

V容器中一旦出现相同数字，即小数已经完成一次循环

（V容器中所有数字的数量-不循环数字的长度n）即为解

##### AC代码 #####

package JB2015;
    
    import java.util.Vector;
    //注意，需要把V中的不循环数去除掉
    //v.size()-v.indexOf(n);
    //难度两颗星
    public class D循环节长度 { 
    
    	public static int f(int n, int m) { 
    		n = n % m;
    		Vector v = new Vector();
    
    		for (;;) { 
    			v.add(n);
    			n *= 10;
    			n = n % m;
    			if (n == 0)
    				return 0;
    			if (v.indexOf(n) >= 0)
    				return v.size()-v.indexOf(n);// _________________________________ ; //填空
    		}
    	}
    
    	public static void main(String[] args) { 
    		System.out.println(f(1, 8));
    		System.out.println(f(8, 3));
    		System.out.println(f(11, 13));
    		System.out.println(f(39, 190));
    	}
    }

## E：九数组分数（难度：★★） ##

1,2,3…9 这九个数字组成一个分数，其值恰好为1/3，如何组法？

下面的程序实现了该功能，请填写划线部分缺失的代码。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyMzI3_size_16_color_FFFFFF_t_70 1]  
注意，只能填写缺少的部分，不要重复抄写已有代码。不要填写任何多余的文字。

##### 分析： #####

回溯问题  
递归完了，回溯一下就完事了

##### AC代码 #####

package JB2015;
    
    //递归与回溯问题，记得回溯就ok
    public class E九数组分数
    { 
    	public static void test(int[] x)
    	{ 
    		int a = x[0]*1000 + x[1]*100 + x[2]*10 + x[3];
    		int b = x[4]*10000 + x[5]*1000 + x[6]*100 + x[7]*10 + x[8];		
    		if(a*3==b) System.out.println(a + " " + b);
    	}
    	
    	public static void f(int[] x, int k)
    	{ 
    		if(k>=x.length){ 
    			test(x);
    			return;
    		}
    		
    		for(int i=k; i<x.length; i++){ 
    			{ int t=x[k]; x[k]=x[i]; x[i]=t;}
    			f(x,k+1);
    			{ int t=x[k]; x[k]=x[i]; x[i]=t;}
    			//_______________________________________ // 填空
    		}
    	}
    	
    	public static void main(String[] args)
    	{ 
    		int[] x = { 1,2,3,4,5,6,7,8,9};		
    		f(x,0);
    	}
    }

## F：加法变乘法（难度：★★★★） ##

我们都知道：1+2+3+ … + 49 = 1225  
现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015

比如：  
1+2+3+…+10*11+12+…+27*28+29+…+49 = 2015  
就是符合要求的答案。

请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。

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

##### 分析： #####

暴力枚举两个位置，时间复杂度50\*50

##### AC代码： #####

package JB2015;
    
    public class F加法变乘法 { 
    	public static int sum=1225;
    	public static void findNum1(){ 
    		for(int i=1;i<47;i++){ 
    			sum-=(i+i+1);
    			sum+=(i*(i+1));
    			findNum2(i);
    			sum-=(i*(i+1));
    			sum+=(i+i+1);
    		}
    	}
    	public static void findNum2(int k){ 
    		for(int i=k+2;i<49;i++){ 
    			sum-=(i+i+1);
    			if(sum+(i*(i+1))==2015){ 
    				System.out.println(k+" "+i);
    			}
    			sum+=(i+i+1);
    		}
    	}
    	public static void main(String[] args) { 
    		findNum1();
    	}
    }

## G：牌型种数（难度：★★★） ##

小明被劫持到X赌城，被迫与其他3人玩牌。  
一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。  
这时，小明脑子里突然冒出一个问题：  
如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？

请填写该整数，不要填写任何多余的内容或说明文字。

##### 分析： #####

从1开始递归到13结束，对应A，2，3，4…J，Q，K；  
每次调用枚举0~4五种情况，对应没有当前牌，一张牌，两张牌，三张牌，四张牌  
符合条件计数+1；  
递归结束得结果。

##### AC代码： #####

package JB2015;
    
    public class G牌型种数 { 
    	public static int count=0;
    	public static void dfs(int x,int cur){ 
    		if(cur==13)count++;
    		else if(cur>13||x>13)return;
    		else{ 
    			for(int i=0;i<5;i++){ 
    				dfs(x+1,cur+i);
    			}
    		}
    	}
    	public static void main(String[] args) { 
    		dfs(1,0);
    		System.out.println(count);
    	}
    }

## H：饮料换购（难度：★★） ##

乐羊羊饮料厂正在举办一次促销优惠活动。乐羊羊C型饮料，凭3个瓶盖可以再换一瓶C型饮料，并且可以一直循环下去，但不允许赊账。

请你计算一下，如果小明不浪费瓶盖，尽量地参加活动，那么，对于他初始买入的n瓶饮料，最后他一共能得到多少瓶饮料。

输入：一个整数n，表示开始购买的饮料数量（0<n<10000）  
输出：一个整数，表示实际得到的饮料数

例如：  
用户输入：  
100  
程序应该输出：  
149

用户输入：  
101  
程序应该输出：  
151

资源约定：  
峰值内存消耗（含虚拟机） < 256M；CPU消耗 < 1000ms

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

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

##### 分析： #####

很简单得递归调用问题，不明白为啥在这个位置

递归就完事

##### AC代码： #####

package JB2015;
    
    import java.util.Scanner;
    
    public class H饮料换购 { 
    	public static int f(int n,int cnt){ 
    		if(n<3)return cnt;
    		else return f(n-2,cnt+1);
    	}
    	public static void main(String[] args) { 
    		Scanner sc=new Scanner(System.in);
    		int n=sc.nextInt();
    		System.out.println(f(n,n));
    	}
    }

## I ：垒骰子（难度：★★★★★） ##

篇幅过长，请访问 [垒筛子两种解法 DP or 矩阵][DP or].

## J：生命之树（难度：★★★★★） ##

篇幅过长，请访问 [生命之树（DFS）][DFS].  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyMzI3_size_16_color_FFFFFF_t_70 2]

[Link 1]: https://blog.csdn.net/qq_43652327/article/details/104899994
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyMzI3_size_16_color_FFFFFF_t_70]: /images/20230529/f3cbd0d6a7624edebfb7565edcc3b60e.png
[20200313171042515.png]: /images/20230529/caea82cde31541ddb2531269ac5c96e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyMzI3_size_16_color_FFFFFF_t_70 1]: /images/20230529/eda6e15aabd047c1b7820b062740bba2.png
[DP or]: https://blog.csdn.net/qq_43652327/article/details/104827435
[DFS]: https://blog.csdn.net/qq_43652327/article/details/104827577
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjUyMzI3_size_16_color_FFFFFF_t_70 2]: /images/20230529/acfcab49dbd14bb4805ac5a355c5041c.png