蓝桥杯2014年省赛Java A组

最新推荐文章于 2021-02-27 09:59:21 发布
最新推荐文章于 2021-02-27 09:59:21 发布
阅读量522 收藏 4
点赞数 3
分类专栏： 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24681499/article/details/88704542
版权

第一题：猜年龄

小明带两个妹妹参加元宵灯会。别人问她们多大了，她们调皮地说：“我们俩的年龄之积是年龄之和的6倍”。小明又补充说：“她们可不是双胞胎，年龄差肯定也不超过8岁啊。”

请你写出：小明的较小的妹妹的年龄。

注意： 只写一个人的年龄数字，请通过浏览器提交答案。不要书写任何多余的内容。

答案：10
Java 代码：

package 省赛JavaA_2014;
//answer:妹妹年龄：10   姐姐年龄：15
public class _01猜年龄 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(int i=1;i<100;i++) {
			for(int j=i+1;j<100;j++) {
				if(6*(i+j)==i*j && j<=(i+8)) {
					System.out.println("妹妹年龄："+i+"   姐姐年龄："+j);
				}
			}
		}
	}
}

第二题：李白打酒

话说大诗人李白，一生好饮。幸好他从不开车。

一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：

无事街上走，提壶去打酒。
逢店加一倍，遇花喝一斗。

这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。 

请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的次序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。

注意：通过浏览器提交答案。答案是个整数。不要书写任何多余的内容。

答案：14
Java 代码：

package 省赛JavaA_2014;
//answer:14
public class _02李白打酒 {
	static int ans;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		f(5,9,2);
		System.out.println(ans);
	}
	private static void f(int dian, int hua, int jiu) {
		// TODO Auto-generated method stub
		if(dian==0&&hua==0&&jiu==1) {
			ans++;
			return ;
		}
		if(dian>0) {
			f(dian-1,hua,jiu*2);
		}
		if(hua>0) {
			f(dian,hua-1,jiu-1);
		}
	}
}

第三题：神奇算式

由4个不同的数字，组成的一个乘法算式，它们的乘积仍然由这4个数字组成。

比如： 

210 x 6 = 1260 
8 x 473 = 3784
27 x 81 = 2187 

都符合要求。

如果满足乘法交换律的算式算作同一种情况，那么，包含上边已列出的3种情况，一共有多少种满足要求的算式。

请填写该数字，通过浏览器提交答案，不要填写多余内容（例如：列出所有算式）。

package 省赛JavaA_2014;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
/**
 * 倒数第一行输出最终结果（去除重复的数据）
 * 倒数第二行输出结果（满足交换律的数据被多次累加）
 * 其余输出为满足条件的 两个乘数
 * @author Genius
 */
//answer:12
public class _03神奇算式 {
	static boolean vis[];
	static int a[];
	static int ans=0;
	static Set<Node> set;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		a = new int[4];
		vis = new boolean[10];
		Arrays.fill(a, 0);
		Arrays.fill(vis,false);
		set = new HashSet<>();
		getFullP(0);//列举每一位的数字
		System.out.println(ans);
		System.out.println(set.size());
	}
	private static void getFullP(int step) {
		// TODO Auto-generated method stub
		if(step==4) {
			judge();
			return ;
		}
		for(int i=0;i<vis.length;i++) {
			if(!vis[i]) {
				a[step]=i;
				vis[i] = true;
				getFullP(step+1);
				vis[i]=false;
			}
		}
	}
	private static void judge() {
		if(a[0]==0) {
			return ;
		}
		//第1位为第一个乘数，第2,3,4为第二个乘数
		int t1 = 0;
		int t2 =0;
		t1 = a[0];
		if(a[1]!=0) {
			t2 = a[1]*100+a[2]*10+a[3];
			int tmp = t1*t2;
			String str = ""+a[0]+a[1]+a[2]+a[3];
			if(judgeIsEqual(str,String.valueOf(tmp))) {
				ans++;
				System.out.println(t1+" "+t2);
				set.add(new Node(t1,t2));
			}	
		}
		t1 = a[0]*10+a[1];
		if(a[2]!=0) {
			t2 =a[2]*10+a[3];
			int tmp = t1*t2;
			String str = ""+a[0]+a[1]+a[2]+a[3];
			if(judgeIsEqual(str,String.valueOf(tmp))) {
				ans++;
				System.out.println(t1+" "+t2);
				set.add(new Node(t1,t2));
			}
		}
		t1 = a[0]*100+a[1]*10+a[2];
		if(a[3]!=0) {
			t2 = a[3];
			int tmp = t1*t2;
			String str = ""+a[0]+a[1]+a[2]+a[3];
			if(judgeIsEqual(str,String.valueOf(tmp))) {
				ans++;
				System.out.println(t1+" "+t2);
				set.add(new Node(t1,t2));
			}
		}
	}
	private static boolean judgeIsEqual(String s1,String result) {
		if(s1.length()!=4||result.length()!=4) {
			return false;
		}
		char c1[] = s1.toCharArray();
		char c2[] = result.toCharArray();
		Arrays.sort(c1);
		Arrays.sort(c2);
		for(int i=0;i<c1.length;i++) {
			if(c1[i]!=c2[i]) {
				return false;
			}
		}
		
		return true;
	}
	static class Node{
		int t1;int t2;

		public Node(int t1, int t2) {
			super();
			this.t1 = t1;
			this.t2 = t2;
		}
		@Override
		public int hashCode() {
			// TODO Auto-generated method stub
			return t1+t2;
		}
		@Override
		public boolean equals(Object obj) {
			// TODO Auto-generated method stub
			Node node = (Node)obj;
			return (t1==node.t1&&t2==node.t2)||(t1==node.t2&&t2==node.t1);
		}
	}
}

第四题：写日志

写日志是程序的常见任务。现在要求在 t1.log, t2.log, t3.log 三个文件间轮流写入日志。也就是说第一次写入t1.log，第二次写入t2.log，... 第四次仍然写入t1.log，如此反复。

下面的代码模拟了这种轮流写入不同日志文件的逻辑。

public class A
{
	private static int n = 1;
	
	public static void write(String msg)
	{
    	String filename = "t" + n + ".log";
    	n = ____________;
    	System.out.println("write to file: " + filename + " " + msg);
   }
}

请填写划线部分缺失的代码。通过浏览器提交答案。

注意：不要填写题面已有的内容，也不要填写任何说明、解释文字。

答案：n%3+1
Java 代码：

package 省赛JavaA_2014;
//answer:n==1?2:n==2?3:1
//answer:n%3+1
public class _04写日志 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(int i=0;i<15;i++) {
			A.write(""+i+i+i+i);
		}
	}
	static public class A
	{
		private static int n = 1;
		public static void write(String msg)
		{
			String filename = "t" + n + ".log";
			//第一种答案
			//n = n==1?2:n==2?3:1;//填空位置
			//第二种答案
			n=n%3+1;
			System.out.println("write to file: " + filename + " " + msg);
		}
	}
}

第五题：锦标赛

    如果要在n个数据中挑选出第一大和第二大的数据（要求输出数据所在位置和值），使用什么方法比较的次数最     少？我们可以从体育锦标赛中受到启发。

 如图【1.png】所示，8个选手的锦标赛，先两两捉对比拼，淘汰一半。优胜者再两两比拼...直到决出第一名。

 第一名输出后，只要对黄色标示的位置重新比赛即可。

下面的代码实现了这个算法(假设数据中没有相同值)。

代码中需要用一个数组来表示图中的树（注意，这是个满二叉树, 不足需要补齐）。它不是存储数据本身，而是存储了数据的下标。   

第一个数据输出后，它所在的位置被标识为-1

class A{
   	//a 表示待处理的数据，长度如果不是2的次幂，则不足位置补为-1
    static void pick(int[] a)
    {
    	int n = 1;
    	while(n<a.length) n *= 2;
	    
	
    	int[] b = new int[2*n-1];
	    for(int i=0; i<n; i++){ 
	    	if(i<a.length) 
	    		b[n-1+i] = i;
	    	else
    			b[n-1+i] = -1;
    	}
	
		//从最后一个向前处理
    	for(int i=b.length-1; i>0; i-=2){
	    	if(b[i]<0){
	    		if(b[i-1]>=0)
	    			b[(i-1)/2] = b[i-1]; 
	    		else
		    		b[(i-1)/2] = -1;
	    	}
	    	else{
		    	if(a[b[i]]>a[b[i-1]])
	    			b[(i-1)/2] = b[i];
	    		else
	    			b[(i-1)/2] = b[i-1];
	    	}
    	}

	//输出树根
	System.out.println(b[0] + ": " + a[b[0]]);
	
	//值等于根元素的位置需要重新pk
	pk(a,b,0,b[0]);
	
	//再次输出树根
	System.out.println(b[0] + ": " + a[b[0]]);
}

// a 表示待处理数据，b 二叉树，k 当前要重新比拼的位置，v 已经决胜出的值	
static void pk(int[] a, int[] b, int k, int v)
{
	
	int k1 = k*2+1;
	int k2 = k1 + 1;
	
	if(k1>=b.length || k2>=b.length){
		b[k] = -1;
		return;
	}
	
	if(b[k1]==v) 
		pk(a,b,k1,v);
	else
		pk(a,b,k2,v);
	
	
	//重新比较
	if(b[k1]<0){
		if(b[k2]>=0)
			b[k] = b[k2]; 
		else
			b[k] = -1;
		return;
	}
	
	if(b[k2]<0){
		if(b[k1]>=0)
			b[k] = b[k1]; 
		else
			b[k] = -1;
		return;
	}
	
	if(__________________________)  //填空
		b[k] = b[k1];
	else
		b[k] = b[k2];
	}
}


请仔细分析流程，填写缺失的代码。

通过浏览器提交答案，只填写缺失的代码，不要填写已有代码或其它说明语句等。

在这里插入图片描述
答案：a[b[k1]]>a[b[k2]]
Java 代码：

package 省赛JavaA_2014;
//answer:a[b[k1]]>a[b[k2]]
public class _05锦标赛 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	}
	static class A{
	   	//a 表示待处理的数据，长度如果不是2的次幂，则不足位置补为-1
		static void pick(int[] a)
		{
			int n = 1;
			while(n<a.length) n *= 2;
			int[] b = new int[2*n-1];
			for(int i=0; i<n; i++){ 
				if(i<a.length) 
					b[n-1+i] = i;
				else
					b[n-1+i] = -1;
			}
			//从最后一个向前处理
			for(int i=b.length-1; i>0; i-=2){
				if(b[i]<0){
					if(b[i-1]>=0)
						b[(i-1)/2] = b[i-1]; 
					else
						b[(i-1)/2] = -1;
				}
				else{
					if(a[b[i]]>a[b[i-1]])
						b[(i-1)/2] = b[i];
					else
						b[(i-1)/2] = b[i-1];
				}
			}
			//输出树根
			System.out.println(b[0] + ": " + a[b[0]]);
			//值等于根元素的位置需要重新pk
			pk(a,b,0,b[0]);
			//再次输出树根
			System.out.println(b[0] + ": " + a[b[0]]);
		}
		// a 表示待处理数据，b 二叉树，k 当前要重新比拼的位置，v 已经决胜出的值	
	   	static void pk(int[] a, int[] b, int k, int v)
		{
			int k1 = k*2+1;
			int k2 = k1 + 1;
			
			if(k1>=b.length || k2>=b.length){
				b[k] = -1;
				return;
			}
			if(b[k1]==v) 
				pk(a,b,k1,v);
			else
				pk(a,b,k2,v);
			//重新比较
			if(b[k1]<0){
				if(b[k2]>=0)
					b[k] = b[k2]; 
				else
					b[k] = -1;
				return;
			}
			if(b[k2]<0){
				if(b[k1]>=0)
					b[k] = b[k1]; 
				else
					b[k] = -1;
				return;
			}
			if(a[b[k1]]>a[b[k2]])  //填空
				b[k] = b[k1];
			else
				b[k] = b[k2];
		}
	}
}

第六题：六角填数

如图【1.png】所示六角形中，填入1~12的数字。

使得每条直线上的数字之和都相同。

图中，已经替你填好了3个数字，请你计算星号位置所代表的数字是多少？

请通过浏览器提交答案，不要填写多余的内容。

在这里插入图片描述
答案：10
Java 代码：

package 省赛JavaA_2014;
//answer:10
public class _06六角填数 {
	static int a[]= {2,4,5,6,7,9,10,11,12};
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		getFullP(0);
	}
	/*
	 * 求数组a的全排列
	 */
	private static void getFullP(int step) {
		if(step == a.length) {
			judge();
			return ;
		}
		// TODO Auto-generated method stub
		for(int i=step;i<a.length;i++) {
			int tmp = a[i];
			a[i] = a[step];
			a[step] = tmp;
			getFullP(step+1);
			tmp = a[i];
			a[i] = a[step];
			a[step] = tmp;
		}
	}
	private static void judge() {
		// TODO Auto-generated method stub
		int edge1 = 1+a[0]+a[8]+a[7];
		int edge2 = 1+a[1]+a[3]+a[4];
		int edge3 = 8+a[0]+a[1]+a[2];
		int edge4 = 8+a[8]+a[6]+3;
		int edge5 = a[2]+a[3]+a[5]+3;
		int edge6 = a[7]+a[6]+a[5]+a[4];
		if(edge1==edge2&&edge2==edge3&&edge3==edge4&&edge4==edge5&&edge5==edge6) {
			System.out.println(a[8]);
		}
	}
}

第七题：绳圈

今有 100 根绳子，当然会有 200 个绳头。

如果任意取绳头两两配对，把所有绳头都打结连接起来。最后会形成若干个绳圈（不考虑是否套在一起）。

我们的问题是：请计算最后将形成多少个绳圈的概率最大？

注意：结果是一个整数，请通过浏览器提交该数字。不要填写多余的内容。

答案：3
Java 代码：

package 省赛JavaA_2014;
import java.util.Scanner;
//answer:3
public class _07绳圈 {
	public static void main(String[] args) {
		//用i个绳围成 j 个圈的概率
		//用 i 个绳 所能围成的组合数  c[i] = c[i-1]*(i-1)*2+1;
		//f[i][j] =( f[i-1][j]*c[i-1]*(i-1)*2 + f[i-1][j-1]*c[i-1] ) / c[i]
		//化解得  f[i][j] = (f[i-1][j-1] + f[i-1][j]*[i-1])/(2*i-1)
		double f[][] = new double[101][101];
		f[1][1]=1;
		for (int i = 2; i < f.length; i++) {
			//f[i][1] = f[i - 1][1] * (i - 1) * 2 / (2 * i - 1);
			for (int j = 1; j <=i; j++) {
				f[i][j] = (f[i-1][j-1]+f[i-1][j]*(i-1)*2)/(2*i-1);
			}
		}
		double max = -1;
		int ans = -1;
		for (int i = 1; i < f[0].length; i++) {
			if(f[100][i]>max) {
				max = f[100][i];
				System.out.println(max);
				ans = i;
			}
		}
		System.out.println(ans);
	}
}

第八题：兰顿蚂蚁

兰顿蚂蚁，是于1986年，由克里斯·兰顿提出来的，属于细胞自动机的一种。

平面上的正方形格子被填上黑色或白色。在其中一格正方形内有一只“蚂蚁”。
蚂蚁的头部朝向为：上下左右其中一方。

蚂蚁的移动规则十分简单：
若蚂蚁在黑格，右转90度，将该格改为白格，并向前移一格；
若蚂蚁在白格，左转90度，将该格改为黑格，并向前移一格。

规则虽然简单，蚂蚁的行为却十分复杂。刚刚开始时留下的路线都会有接近对称，像是会重复，但不论起始状态如何，蚂蚁经过漫长的混乱活动后，会开辟出一条规则的“高速公路”。

蚂蚁的路线是很难事先预测的。

你的任务是根据初始状态，用计算机模拟兰顿蚂蚁在第n步行走后所处的位置。

【数据格式】

输入数据的第一行是 m n 两个整数（3 < m, n < 100），表示正方形格子的行数和列数。
接下来是 m 行数据。
每行数据为 n 个被空格分开的数字。0 表示白格，1 表示黑格。

接下来是一行数据：x y s k, 其中x y为整数，表示蚂蚁所在行号和列号（行号从上到下增长，列号从左到右增            长，都是从0开始编号）。s 是一个大写字母，表示蚂蚁头的朝向，我们约定：上下左右分别用：UDLR表示。k   表示蚂蚁走的步数。

输出数据为两个空格分开的整数 p q, 分别表示蚂蚁在k步后，所处格子的行号和列号。


例如, 输入：
5 6
0 0 0 0 0 0
0 0 0 0 0 0
0 0 1 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
2 3 L 5
程序应该输出：
1 3

再例如, 输入：
3 3
0 0 0
1 1 1
1 1 1
1 1 U 6
程序应该输出：
0 0


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


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

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

在这里插入图片描述
Java 代码：

package 省赛JavaA_2014;
import java.util.Scanner;
public class _08兰顿蚂蚁 {
static int dir[][]= {{-1,0},{0,1},{1,0},{0,-1}};//上右下左
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int m = sc.nextInt();
		int n = sc.nextInt();
		boolean isBlack[][] = new boolean[m][n];
		for (int i = 0; i < isBlack.length; i++) {
			for (int j = 0; j < n; j++) {
				isBlack[i][j] = sc.nextInt() == 0 ? false : true;
			}
		}
		int x = sc.nextInt();
		int y = sc.nextInt();
		String c = sc.next();
		int k = sc.nextInt();
		int current=0;//对应dir数组的第一维下标，如果为0，就是上，1为右，2为下，3为左
		if(c.equals("U")) {
			current = 0;
		}
		else if(c.equals("D")) {
			current = 2;
		}
		else if(c.equals("L")) {
			current = 3;
		}
		else {
			current = 1;
		}
		for(int i=0;i<k;i++) {
			if(isBlack[x][y]) {
				current+=1;//右转
				current=current%4;
				isBlack[x][y]=!isBlack[x][y];//黑格转白格
				x+=dir[current][0];
				y+=dir[current][1];
			}
			else {
				current-=1;//左转
				current = (current+4)%4;
				isBlack[x][y]=!isBlack[x][y];//白格转黑格
				x+=dir[current][0];
				y+=dir[current][1];
			}
		}
		System.out.println(x+" "+y);
	}
}

第九题：斐波那契

斐波那契数列大家都非常熟悉。它的定义是：

f(x) = 1                    .... (x=1,2)
f(x) = f(x-1) + f(x-2)      .... (x>2)

对于给定的整数 n 和 m，我们希望求出：
f(1) + f(2) + ... + f(n)  的值。但这个值可能非常大，所以我们把它对 f(m) 取模。
公式参见【图1.png】

但这个数字依然很大，所以需要再对 p 求模。

【数据格式】
输入为一行用空格分开的整数 n m p (0 < n, m, p < 10^18)
输出为1个整数

例如，如果输入：
2 3 5
程序应该输出：
0

再例如，输入：
15 11 29
程序应该输出：
25

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

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

在这里插入图片描述
Java 代码：

package 省赛JavaA_2014;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;
public class _09斐波那契 {
	private static long p;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		long n = sc.nextLong();
		long m = sc.nextLong();
		p = sc.nextLong();
		BigInteger fm = fib(m);
		BigInteger sum = fib(n+2).subtract(BigInteger.ONE).mod(fm).mod(BigInteger.valueOf(p));
		System.out.println(sum.toString());
	}
	private static  BigInteger fib(long n) {
		if(n<=2) {
			return BigInteger.ONE;
		}
		BigInteger a[][]= {{BigInteger.ONE,BigInteger.ONE},{BigInteger.ONE,BigInteger.ZERO}};
		BigInteger b[][]= {{BigInteger.ONE,BigInteger.ONE}};
		BigInteger ans =  matrixMultiply(b, matrixPower(a, n-2))[0][0];
		return ans;
	}
	/**
	 * 求矩阵快速幂
	 * @param a 第一个矩阵
	 * @param b 第二个矩阵
	 * @return 返回矩阵相乘结果
	 */
	private static BigInteger[][] matrixMultiply(BigInteger a[][],BigInteger b[][]) {
		BigInteger arr[][] = new BigInteger[a.length][b[0].length];
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[i].length; j++) {
				arr[i][j]=BigInteger.ZERO;
			}
		}
		for(int i =0;i<a.length;i++) {
			for(int j=0;j<b[0].length;j++) {
				for(int k=0;k<a[0].length;k++) {
					arr[i][j]=(arr[i][j].add(a[i][k].multiply(b[k][j])));
				}
			}
		}
		return arr;
	}
	/**
	 * 使用快速幂算法，求矩阵a的n次幂
	 * @param a
	 * @param n
	 * @return
	 */
	private static BigInteger[][] matrixPower(BigInteger a[][],long n){
		BigInteger ans[][] = new BigInteger[a.length][a[0].length];
		for(int i=0;i<ans.length;i++) {
			for(int j=0;j<ans[0].length;j++) {
				ans[i][j] = i==j?BigInteger.ONE:BigInteger.ZERO;
			}
		}
		while(n!=0) {
			if((n&1)==1) {
				ans = matrixMultiply(ans,a);
			}
			a = matrixMultiply(a, a);
			n=n>>1;
		}
		return ans;
	}
}

第十题：波动数列

观察这个数列：
1 3 0 2 -1 1 -2 ...

这个数列中后一项总是比前一项增加2或者减少3。

栋栋对这种数列很好奇，他想知道长度为 n 和为 s 而且后一项总是比前一项增加a或者减少b的整数数列可能有多少种呢？

【数据格式】
    输入的第一行包含四个整数 n s a b，含义如前面说述。
    输出一行，包含一个整数，表示满足条件的方案数。由于这个数很大，请输出方案数除以100000007的余数。

例如，输入：
4 10 2 3
程序应该输出：
2

【样例说明】
这两个数列分别是2 4 1 3和7 4 1 -2。

【数据规模与约定】
对于10%的数据，1<=n<=5，0<=s<=5，1<=a,b<=5；
对于30%的数据，1<=n<=30，0<=s<=30，1<=a,b<=30；
对于50%的数据，1<=n<=50，0<=s<=50，1<=a,b<=50；
对于70%的数据，1<=n<=100，0<=s<=500，1<=a, b<=50；
对于100%的数据，1<=n<=1000，-1,000,000,000<=s<=1,000,000,000，1<=a, b<=1,000,000。

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


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

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

Java 代码：

package 省赛JavaA_2014;
import java.util.Scanner;
public class _10波动数列 {
	  private static int n;
	  private static long s;
	  private static long a;
	  private static long b;
	  public static void main(String[] args) {
	    Scanner sc = new Scanner(System.in);
	    n = sc.nextInt();
	    s = sc.nextLong();
	    a = sc.nextLong();
	    b = sc.nextLong();
	    int t = n * (n - 1) / 2;
	    int[] dp = new int[t + 1];
	    dp[0] = 1;
	    for (int i = 1; i <= n - 1; i++) {
	      for (int j = i * (i + 1) / 2; j >= i; j--) {
	        // dp[j] += dp[j - i];
	        // if (dp[j] > 100000007) dp[j] %= 100000007;
	        dp[j] = (dp[j] + dp[j - i]) % 100000007;
	      }
	    }
	    long ans = 0;
	    for (int i = 0; i <= t; i++) {
	      if ((s - i * a + (t - i) * b) % n == 0)
	        ans = (ans + dp[i]) % 100000007;
	      // if (ans > 100000007) ans %= 100000007;
	    }
	    System.out.println(ans);
	  }
}

等以后有时间再慢慢写注释吧

Genius Soul
关注
专栏目录
2014年 第5届 蓝桥杯 Java B组 省赛解析及总结
upward
08-19 3075
01 武功秘籍 书的构造方式，思维题 02 切面条 发现规律，思维题 03 猜字母 数组中元素的挪动和挤压 04 大衍数列 考察奇偶数判断 05 圆周率 细心，极限思维 06 奇怪的分式 枚举abcd，分数运算，最大公约数 07 扑克排序 带重复元素的全排列 08 分糖果 模拟 **09 地宫取宝 搜索->记忆型递归，因为子问题重复求解 ****10 矩阵翻硬币 数学；字符，字符串，BigInteger的互相转化
2014年蓝桥杯省赛题目(大学B组)
qq_64030389的博客
02-14 261
武功秘籍 小明到X山洞探险，捡到一本有破损的武功秘籍（2000多页！当然是伪造的）。他注意到：书的第10页和第11页在同一张纸上，但第11页和第12页不在同一张纸上。 小明只想练习该书的第81页到第92页的武功，又不想带着整本书。请问他至少要撕下多少张纸带走？ 这是个整数，请通过浏览器提交该数字，不要填写任何多余的内容。 答案：7 要注意的是书本2000多页就是1000多张纸叠在一起中间用线缝合，依照题意符合条件的情况大致如图： 那么他想要学习第81页到第92页的武功，就需要[80/81
单位分数求解
程序设计与算法......
12-20 1360
形如：1/a 的分数称为单位分数。 可以把1分解为若干个互不相同的单位分数之和。 例如： 1 = 1/2 + 1/3 + 1/9 + 1/18 1 = 1/2 + 1/3 + 1/10 + 1/15 1 = 1/3 + 1/5 + 1/7 + 1/9 + 1/11 + 1/15 + 1/35 + 1/45 + 1/231 等等，类似这样的分解无穷无尽。 我们增加一
2014年第五届蓝桥杯省赛试题及详解（Java本科A组）
一叶之修的博客
02-28 2882
蓝桥杯历年真题题目及题解目录汇总 结果填空 (满分2分) 结果填空 (满分6分) 结果填空 (满分7分) 代码填空 (满分4分) 代码填空 (满分12分) 结果填空 (满分12分) 结果填空 (满分9分) 程序设计（满分8分） 程序设计（满分17分） 程序设计（满分23分） 1.标题：猜年龄 小明带两个妹妹参加元宵灯会。别人问她们多大了，她们调皮地...
蓝桥杯2014年JavaB组
My Blog
01-17 726
文章目录武功秘籍切面条猜字母大衍数列圆周率奇怪的分式 武功秘籍 将信息输出一下，手动判断就可以。答案为7 package Contest_2014; /** * 答案是7 * @author Admin * */ public class 武功秘籍 { public static void main(String[] args) { int num = 0; for (int ...
2014年 蓝桥杯决赛（Java）
piaocoder
05-24 1804
国王的遗产        X国是个小国。国王K有6个儿子。在临终前，K国王立下遗嘱：国王的一批牛作为遗产要分给他的6个儿子。     其中，大儿子分1/4，二儿子1/5，三儿子1/6，....     直到小儿子分1/9。     牛是活的，不能把一头牛切开分。     最后还剩下11头牛，分给管家。     请计算国王这批遗产中一共有多少头牛。     这是一个整数，请通过浏览器...
2014年第五届蓝桥杯大赛软件类JAVA-A组全国总决赛真题.doc
最新发布
05-09
在2014年第五届蓝桥杯大赛软件类JAVA-A组全国总决赛中，出现了一道名为“海盗分金币”的题目。题目背景设定为五位海盗在一次帆船比赛中遭遇天气突变，各自在途中的一座荒岛上发现了金币，并按照特定的方式分配。 ##...
蓝桥杯 2015省赛 Java语言 大学A组 真题
04-21
【蓝桥杯2015省赛Java语言大学A组真题解析】 1. 结果填空 (满分 3 分) 题目描述：熊怪吃核桃问题。熊怪将核桃分等份，吃掉一份，直至剩下一个核桃。问在吃1543个核桃过程中会丢掉多少个核桃。 解题思路：熊怪每次...
2014年蓝桥杯JAVA本科A组试题
03-22
《2014年蓝桥杯JAVA本科A组试题解析》 蓝桥杯是一项全国性的专业编程竞赛，自举办以来，每年都吸引着大量的JAVA专业学子参与。2014年的赛事，尤其对于本科A组的学生来说，是一次检验自身JAVA编程能力的重要机会。...
2014年第五届蓝桥杯大赛软件类JAVA A组全国总决赛真题
04-04
【标题】2014年第五届蓝桥杯大赛软件类JAVA A组全国总决赛真题，是针对Java编程语言的一次专业竞赛，旨在检验参赛者的Java技术能力，涵盖基础语法、数据结构、算法设计等多个方面。这是一场面向全国高校学生的比赛，...
2014蓝桥杯A组java第七题（有缺陷）
lzh578903779的博客
02-18 690
import java.util.HashMap; import java.util.Map; import java.util.Scanner; /**  * @author Administrator  * 给定平面内平行于坐标轴的一个矩形，从矩形内选择一些点，从这些点向右和向上各射出一条射线，请问：这些射线将矩形分成了多少份。 数据格式： 输入的第一行
蓝桥杯 java A组
Sylvia_Wu51的博客
12-04 659
标题：拉马车 小的时候，你玩过纸牌游戏吗？ 有一种叫做“拉马车”的游戏，规则很简单，却很吸引小朋友。 其规则简述如下： 假设参加游戏的小朋友是A和B，游戏开始的时候，他们得到的随机的纸牌序列如下： A方：[K, 8, X, K, A, 2, A, 9, 5, A] B方：[2, 7, K, 5, J, 5, Q, 6, K, 4] 其中的X表示“10”，我们忽略了纸牌的花色。 从A方开始，A、B双...
2014年第五届蓝桥杯国赛试题及部分题解（Java本科B组）
zmjのblog
05-22 414
1. 国王的遗产 标题：国王的遗产 X国是个小国。国王K有6个儿子。在临终前，K国王立下遗嘱：国王的一批牛作为遗产要分给他的6个儿子。 其中，大儿子分1/4，二儿子1/5，三儿子1/6，… 直到小儿子分1/9。 牛是活的，不能把一头牛切开分。 最后还剩下11头牛，分给管家。 请计算国王这批遗产中一共有多少头牛。 这是一个整数，请通过浏览器提交答案，不要填写任何多余的内容（比如说明性的文字） 解析：...
2014年第四届蓝桥杯国赛试题及详解（Java本科B组）
zmjのblog
05-18 488
1. 猜灯谜 标题：猜灯谜 A 村的元宵节灯会上有一迷题： 请猜谜 * 请猜谜 = 请边赏灯边猜 小明想，一定是每个汉字代表一个数字，不同的汉字代表不同的数字。 请你用计算机按小明的思路算一下，然后提交“请猜谜”三个字所代表的整数即可。 请严格按照格式，通过浏览器提交答案。 注意：只提交一个3位的整数，不要写其它附加内容，比如：说明性的文字。 解析：写几层循环暴力过就行 package A; ...
2014年蓝桥杯省赛试题(Java本科A组)第9题斐波那契
qq_43467330的博客
04-21 307
题干: 斐波那契数列大家都非常熟悉。它的定义是： f(x) = 1 .... (x=1,2) f(x) = f(x-1) + f(x-2) .... (x>2) 对于给定的整数 n 和 m，我们希望求出： f(1) + f(2) + ... + f(n) 的值。但这个值可能非常大，所以我们把它对 f(m) ...
蓝桥杯2014Java_A组题解
qq_42847094的博客
03-29 315
蓝桥杯2014Java_A组 文章目录蓝桥杯2014Java_A组1.猜年龄2.李白打酒3.神奇算式6.六角填数7.绳圈8.兰顿蚂蚁 1.猜年龄 标题：猜年龄 小明带两个妹妹参加元宵灯会。别人问她们多大了，她们调皮地说：“我们俩的年龄之积是年龄之和的6倍”。小明又补充说：“她们可不是双胞胎，年龄差肯定也不超过8岁啊。” 请你写出：小明的较小的妹妹的年龄。 注意： 只写一个人的年龄数字，请通过浏览器...
第五届蓝桥杯java试题答案_2014年第五届蓝桥杯省赛试题（JavaA组）
weixin_39715513的博客
02-27 639
1.结果填空 (满分2分)2.结果填空 (满分6分)3.结果填空 (满分7分)4.代码填空 (满分4分)5.代码填空 (满分12分)6.结果填空 (满分12分)7.结果填空 (满分9分)8.程序设计(满分8分)9.程序设计(满分17分)10.程序设计(满分23分) 1.标题:猜年龄 小明带两个妹妹参加元宵灯会.别人问她们多大了,她们调皮地说:“我们俩的年龄之积是年龄之和的6倍”.小明又补充说:“她...
2014 第五届蓝桥杯 Java B组真题整理（附答案）
mcp3128
03-27 3941
1.武功秘籍    小明到X山洞探险，捡到一本有破损的武功秘籍（2000多页！当然是伪造的）。他注意到：书的第10页和第11页在同一张纸上，但第11页和第12页不在同一张纸上。    小明只想练习该书的第81页到第92页的武功，又不想带着整本书。请问他至少要撕下多少张纸带走？这是个整数，请通过浏览器提交该数字，不要填写任何多余的内容。【解析】：带走的页数（80,81）（82,83）（84,85）（...
第五届蓝桥杯Java A组决赛试题
Slayer_Zhao的博客
05-02 511
1.标题：海盗分金币    有5个海盗，相约进行一次帆船比赛。    比赛中天气发生突变，他们被冲散了。    恰巧，他们都先后经过途中的一个无名的荒岛，并且每个人都信心满满，觉得自己是第一个经过该岛的人。    第一个人在沙滩上发现了一堆金币。他把金币分成5等份。发现刚好少一个金币。他就从自己口袋拿出一个金币补充进去，然后把属于自己的那份拿走。    第二个到达的人也看到了金币，他也和第一个人一...
2014蓝桥杯预赛JAVA本科A组考试指南
"2014年第五届蓝桥杯预赛是针对JAVA软件开发本科A组的一场比赛，考试时长4小时，考生需在规定时间内解答各类题目，包括结果填空、代码填空和程序设计三类。考试过程中，考生不能在代码中透露个人信息，需通过浏览器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值