蓝桥杯历年真题JAVA版-2016年蓝桥杯省赛- Java组

我不是女神ヾ 2023-09-29 12:19 5阅读 0赞

## 第1题——生日蜡烛 ##

### （1）题目描述 ###

> 某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。  
> 现在算起来，他一共吹熄了236根蜡烛。  
> 请问，他从多少岁开始过生日party的？
> 
>   
> **输出格式：**请填写他开始过生日party的年龄数。

### （2）解题代码 ###

public static void func1() {
    		for (int i = 0; i < 100; i++) {
    			int sum = 0;// 一定要初始化 ，否则输出结果为0
    			for (int j = i;; j++) {
    				sum += j;// 从年龄i开始，往后累加一直加到要求的条件位置
    				if (sum > 236)// 若从年龄i累加，超过了236，终止循环
    				{
    					break;
    				}
    				if (sum == 236) {// 若从年龄i累加，刚好等于236，则开始吹蜡烛的年龄即为开始过生日的年龄。
    					System.out.println(i);
    				}
    			}
    		}
    	}

### （3）运行结果 ###

![d76eba71aea24bb9a6cbd2b88264b472.png][]

--------------------

## 第2题——方格填数 ##

### （1）题目描述 ###

> 如下的10个格子，填入0~9的数字。要求：连续的两个数字不能相邻。  
> （左右、上下、对角都算相邻）一共有多少种可能的填数方案？
> 
> ![6708530b461749fb974c4a3ea2f98466.png][]

### （2）解题代码 ###

public static int[][] m = new int[3][4];
    	public static int[] pack = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    	public static int[] visited = new int[10];
    	public static int sum = 0;
    
    	public static int solve() {
    		int ok = 1;
    		int index = 0;
    		for (int i = 0; i < 3; i++) {
    			for (int j = 0; j < 4; j++) {
    				if (m[i][j] == -2)
    					continue;
    				m[i][j] = pack[index];
    				index++;
    			}
    		}
    		for (int i = 0; i < 3; i++) {
    			for (int j = 0; j < 4; j++) {
    				if (m[i][j] == -2)
    					continue;
    				if (i - 1 >= 0 && (m[i][j] == m[i - 1][j] + 1 || m[i][j] == m[i - 1][j] - 1))
    					return 0;
    				if (i + 1 < 3 && (m[i][j] == m[i + 1][j] + 1 || m[i][j] == m[i + 1][j] - 1))
    					return 0;
    				if (j - 1 >= 0 && (m[i][j] == m[i][j - 1] + 1 || m[i][j] == m[i][j - 1] - 1))
    					return 0;
    				if (j + 1 < 4 && (m[i][j] == m[i][j + 1] + 1 || m[i][j] == m[i][j + 1] - 1))
    					return 0;
    
    				if (i - 1 >= 0 && j - 1 >= 0 && (m[i][j] == m[i - 1][j - 1] + 1 || m[i][j] == m[i - 1][j - 1] - 1))
    					return 0;
    				if (i - 1 >= 0 && j + 1 < 4 && (m[i][j] == m[i - 1][j + 1] + 1 || m[i][j] == m[i - 1][j + 1] - 1))
    					return 0;
    				if (i + 1 < 3 && j - 1 >= 0 && (m[i][j] == m[i + 1][j - 1] + 1 || m[i][j] == m[i + 1][j - 1] - 1))
    					return 0;
    				if (i + 1 < 3 && j + 1 < 4 && (m[i][j] == m[i + 1][j + 1] + 1 || m[i][j] == m[i + 1][j + 1] - 1))
    					return 0;
    			}
    		}
    		return ok;
    	}
    
    	public static void dfs(int index) {
    		if (index == 10) {
    			if (solve() != 0) {
    				sum++;
    			}
    		} else {
    			for (int i = 0; i < 10; i++) {
    				if (visited[i] == 0) {
    					visited[i] = 1;
    					pack[index] = i;
    					dfs(index + 1);
    					visited[i] = 0;
    				}
    			}
    		}
    	}
    
    	public static void func2() {
    		for (int i = 0; i < 3; i++)
    			for (int j = 0; j < 4; j++)
    				m[i][j] = -1;
    		m[0][0] = -2;
    		m[2][3] = -2;
    
    		dfs(0);
    		System.out.println(sum);
    	}

### （3）运行结果 ###

![12b45f186a3047c4a2e12ac349febb01.png][]

--------------------

## 第3题——寒假作业 ##

### （1）题目描述 ###

> 现在小学的数学题目也不是那么好玩的。  
> 看看这个寒假作业：
> 
> ![2eef4c567b9348679f7aa4d65e8c3c2b.png][]  
> 每个方块代表1~13中的某一个数字，但不能重复。  
> 比如：
> 
> > 6 + 7 = 13  
> > 9 - 8 = 1  
> > 3 \* 4 = 12  
> > 10 / 2 = 5
> 
> 以及：
> 
> > 7 + 6 = 13  
> > 9 - 8 = 1  
> > 3 \* 4 = 12  
> > 10 / 2 = 5
> 
> 就算两种解法。（加法，乘法交换律后算不同的方案）  
> 你一共找到了多少种方案？

### （2）解题代码 ###

public static int[] a = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };
    	public static int ans = 0;
    
    	public static void swap(int i, int j) {
    		int t = a[i];
    		a[i] = a[j];
    		a[j] = t;
    	}
    
    	public static void dfs(int m) {
    		if (m >= 13) {// + - * /
    			if (a[0] + a[1] == a[2] && a[3] - a[4] == a[5] && a[6] * a[7] == a[8] && a[9] / a[10] == a[11]
    					&& a[9] % a[10] == 0) {
    				if (ans < 10) {// 11/2==5
    					// System.out.println(a[0] + "+" + a[1] + "==" + a[2]);
    					// System.out.println(a[3] + "-" + a[4] + "==" + a[5]);
    					// System.out.println(a[6] + "*" + a[7] + "==" + a[8]);
    					// System.out.println(a[9] + "/" + a[10] + "==" + a[11]);
    					// System.out.println();
    				}
    				ans++;
    			}
    
    			return;
    		}
    		if (m >= 3 && a[0] + a[1] != a[2])// 剪枝,2^13跑不出来
    			return;
    		if (m >= 6 && a[3] - a[4] != a[5])// 这个剪不剪都行反正跑出来了
    			return;
    
    		for (int i = m; i < 13; i++) {
    			swap(m, i);
    			dfs(m + 1);
    			swap(m, i);
    		}
    	}
    
    	public static void func3() {
    		dfs(0);
    		System.out.println(ans);
    	}

### （3）运行结果 ###

![b4a8b566341d4e72ac60252fb29265ca.png][]

--------------------

## 第4题——剪邮票 ##

### （1）题目描述 ###

> 如下图, 有12张连在一起的12生肖的邮票。现在你要从中剪下5张来，要求必须是连着的。（仅仅连接一个角不算相连）
> 
> ![e6894c8279274d71b8461f026fa97c84.png][]
> 
> 比如，下面两张图中，粉红色所示部分就是合格的剪取。
> 
> ![4d4c5635e62445558a3a785a79a4fde0.png][]
> 
> 请你计算，一共有多少种不同的剪取方法。

### （2）解题代码 ###

public static boolean[] book = new boolean[12];
    	public static int[] path = new int[5];
    	public static int[][] map = new int[3][4];
    	public static Set<String> set = new HashSet<String>();
    	public static int ans;
    
    	public static void dfs(int index) {
    		if (index == 5) {
    			int[] tmp = Arrays.copyOf(path, 5);
    			Arrays.sort(tmp);
    			String str = tmp[0] + "" + tmp[1] + "" + tmp[2] + "" + tmp[3] + "" + tmp[4];
    			if (!set.contains(str) && check()) {
    				set.add(str);
    				ans++;
    			}
    		} else {
    			for (int i = 0; i < 12; i++) {
    				if (!book[i]) {
    					book[i] = true;
    					path[index] = i;
    					dfs(index + 1);
    					book[i] = false;
    				}
    			}
    		}
    	}
    
    	public static boolean check() {
    		map = new int[3][4];
    		for (int i = 0; i < 3; i++) {
    			for (int j = 0; j < 4; j++) {
    				for (int t = 0; t < 5; t++) {
    					if (i * 4 + j == path[t]) {
    						map[i][j] = 1;
    					}
    				}
    			}
    		}
    		int cnt = 0;
    		for (int i = 0; i < 3; i++) {
    			for (int j = 0; j < 4; j++) {
    				if (map[i][j] == 1) {
    					dfs_connect(i, j);
    					cnt++;
    				}
    			}
    		}
    		return cnt == 1;
    	}
    
    	public static void dfs_connect(int i, int j) {
    		map[i][j] = 0;
    		if (i + 1 < 3 && map[i + 1][j] == 1)
    			dfs_connect(i + 1, j);
    		if (j + 1 < 4 && map[i][j + 1] == 1)
    			dfs_connect(i, j + 1);
    		if (i - 1 >= 0 && map[i - 1][j] == 1)
    			dfs_connect(i - 1, j);
    		if (j - 1 >= 0 && map[i][j - 1] == 1)
    			dfs_connect(i, j - 1);
    	}
    
    	public static void func4() {
    		dfs(0);
    		System.out.println(ans);
    	}

### （3）运行结果 ###

![c7ac6900e9af4c8bbbdc563f6b8fc061.png][]

--------------------

## 第5题——四平方和 ##

### （1）题目描述 ###

> 四平方和定理，又称为拉格朗日定理：每个正整数都可以表示为至多4个正整数的平方和。  
> 如果把0包括进去，就正好可以表示为4个数的平方和。  
> 比如：  
> 5 = 0^2 + 0^2 + 1^2 + 2^2  
> 7 = 1^2 + 1^2 + 1^2 + 2^2（^符号表示乘方的意思）  
> 对于一个给定的正整数N，可能存在多种平方和的表示法。  
> 要求你对4个数排序：0 <= a <= b <= c <= d  
> 并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法
> 
> **输入格式：**  
> 输入存在多组测试数据，每组测试数据输入一行为一个正整数N (N<5000000)
> 
> **输出格式：**  
> 对于每组测试数据，要求输出4个非负整数，按从小到大排序，中间用空格分开
> 
> **输入样例：**  
> 5  
> 12  
> 773535
> 
>   
> **输出样例：**  
> 0 0 1 2  
> 0 2 2 2  
> 1 1 267 838

### （2）解题代码 ###

public static void func5(int n) {
    		HashMap<Integer, Integer> map = new HashMap<>();
    
    		for (int c = 0; c * c <= n / 2; c++) {
    			for (int d = c; d * d + c * c <= n; d++) {
    				// 用map保存值和对应的a
    				if (map.containsKey(c * c + d * d) == false) {
    					map.put(c * c + d * d, c);
    				}
    
    			}
    		}
    		for (int a = 0; a * a <= n / 4; a++) {
    			for (int b = a; b * b + a * a <= n / 2; b++) {
    				if (map.containsKey(n - (b * b + a * a))) {
    					int c = (int) map.get(n - (a * a + b * b));
    					int d = (int) Math.sqrt(n - (b * b + c * c) - a * a);
    					System.out.printf("%d %d %d %d\n", a, b, c, d);
    					return;
    				}
    
    			}
    		}
    
    	}

### （3）运行结果 ###

![782535413a534c46986ee3b8664bc0f8.png][]

--------------------

## 第6题——密码脱落 ##

### （1）题目描述 ###

> X星球的考古学家发现了一批古代留下来的密码。这些密码是由A、B、C、D 四种植物的种子串成的序列。  
> 仔细分析发现，这些密码串当初应该是前后对称的（也就是我们说的镜像串）。  
> 由于年代久远，其中许多种子脱落了，因而可能会失去镜像的特征。  
> 你的任务是：给定一个现在看到的密码串，计算一下从当初的状态，它要至少脱落多少个种子，才可能会变成现在的样子。
> 
> **输入格式：**  
> 输入存在多组测试数据，对于每组测试数据输入一行，表示现在看到的密码串（长度不大于1000）
> 
> **输出格式：**  
> 对于每组测试数据要求输出一个正整数，表示至少脱落了多少个种子。
> 
> **输入样例 ：**  
> ABCBA  
> ABDCDCBABC
> 
> **输出样例：**  
> 0  
> 3

### （2）解题代码 ###

public static int min = 0, num = 0;
    	public static String inputstr;
    
    	public static void fcode(int left, int right, int num) {
    		if (left >= right) {
    			min = min < num ? min : num; // 每次递归结束都会得到一个num，与全局变量min对比更新，最终得到最小值
    		} else {
    			if (inputstr.charAt(left) == inputstr.charAt(right)) // 左右对比是否一致
    				fcode(left + 1, right - 1, num);
    			else {
    				fcode(left + 1, right, num + 1); // 左边+1
    				fcode(left, right - 1, num + 1); // 右边-1
    			}
    		}
    		return;
    	}
    
    	public static void func8() {
    		// 层数
    		Scanner in = new Scanner(System.in);
    		inputstr = in.next();
    		min = inputstr.length();
    		fcode(0, min - 1, 0);
    		System.out.println(min);
    		in.close();
    	}

### （3）运行结果 ###

![f4e130fe7acd4c3786e25c9eb55db41d.png][]

![168f02d7ff0e4e50adb04efd9a7e54ce.png][]

--------------------

## 第7题——煤球数目 ##

### （1）题目描述 ###

> 有一堆煤球，堆成三角棱锥形。具体：  
> 第一层放1个，  
> 第二层3个（排列成三角形），  
> 第三层6个（排列成三角形），  
> 第四层10个（排列成三角形），  
> ....  
> 如果一共有100层，共有多少个煤球？
> 
> **输出格式：**
> 
> 请填表示煤球总数目的数字。

### （2）解题代码 ###

public static void func7() {
    		// 层数
    		int c = 0;
    		int sum = 0;
    		for (int i = 1; i <= 100; i++) {
    			// 统计每层的个数
    			c += i;
    			// 上层加上这层个数
    			sum += c;
    		}
    		System.out.println(sum);
    	}

### （3）运行结果![bf24a682ff1e4ef7a309b678071ade2c.png][] ###

--------------------

## 第8题——凑算式 ##

### （1）题目描述 ###

> ![6a6aecb78173477f995b727a09b448c1.png][]  
> 
> 
> 这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。  
> 比如：  
> 6+8/3+952/714 就是一种解法，5+3/1+972/486 是另一种解法。  
> 这个算式一共有多少种解法？
> 
> **输出格式：**
> 
> 输出一个整数表示答案

### （2）解题代码 ###

public static void func8() {
    		int x = 0;// 保存结果
    		int[] nums = new int[9];// 用于验证结果数据，
    		for (int i = 1; i < 10; i++) {// 第1个数A
    			for (int j = 1; j < 10; j++) {// 第2个数B
    				for (int k = 1; k < 10; k++) {// 第3个数C
    					for (int l = 123; l <= 987; l++) {// 被除数DEF
    						for (int m = 123; m <= 987; m++) {// 除数GHI
    							double z = i * 1.0 + j * 1.0 / k * 1.0 + l * 1.0 / m * 1.0;
    							// 验证结果是否等于10，等于10后将数据存入数组中验证是否为1-9.
    							if (z == 10.0) {
    								// 数据存入数组
    								nums[0] = i;
    								nums[1] = j;
    								nums[2] = k;
    								nums[3] = l % 10;
    								nums[4] = (l / 10) % 10;
    								nums[5] = (l / 100) % 10;
    								nums[6] = m % 10;
    								nums[7] = (m / 10) % 10;
    								nums[8] = (m / 100) % 10;
    								// 验证数组值是否为1-9
    								Arrays.sort(nums);
    								boolean flag = true;
    								for (int n = 0; n < 9; n++) {
    									if (n + 1 != nums[n]) {
    										flag = false;
    										break;
    									}
    								}
    								// 符合要求计数器+1
    								if (flag) {
    									x++;
    								}
    							}
    						}
    					}
    				}
    
    			}
    		}
    		// 输出结果
    		System.out.println(x);
    	}

### （3）运行结果 ###

![17119c2e76cd49edad8d9ea63413926f.png][]

--------------------

## 第9题——交换瓶子 ##

### （1）题目描述 ###

> 有N个瓶子，编号 1 ~ N，放在架子上。  
> 比如有5个瓶子：2 1 3 5 4，要求每次拿起2个瓶子，交换它们的位置。  
> 经过若干次后，使得瓶子的序号为：1 2 3 4 5  
> 对于这么简单的情况，显然，至少需要交换2次就可以复位。  
> 如果瓶子更多呢？你可以通过编程来解决。
> 
> **输入格式：**  
> 输入存在多组测试数据，对于每组测试数据：  
> 第一行: 一个正整数N（N<10000）, 表示瓶子的数目  
> 第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。
> 
> **输出格式：**  
> 对于每组测试数据输出一行，包含一个正整数表示答案
> 
> **输入样例：**  
> 5  
> 3 1 2 5 4  
> 5  
> 5 4 3 2 1
> 
> **输出样例：**  
> 3  
> 2

### （2）解题代码 ###

public static int[] bottle;
    	public static int count = 0;
    
    	public static void swap(int a, int b) {
    		int tmp = bottle[a];
    		bottle[a] = bottle[b];
    		bottle[b] = tmp;
    	}
    
    	public static void func9() {
    		Scanner in = new Scanner(System.in);
    		int n = in.nextInt();
    		bottle = new int[n + 1];
    		for (int i = 1; i <= n; i++)
    			bottle[i] = in.nextInt();
    
    		for (int i = 1; i <= n; i++) {
    			while (i != bottle[i]) {
    				swap(i, bottle[i]);
    				count++;
    			}
    		}
    		System.out.println(count);
    		in.close();
    	}

### （3）运行结果 ###

![5b081933e1af411a92f0033dc94a6da2.png][]

![f061924191984b8da114d3ce75dbe76c.png][]

--------------------

## 第10题——平方怪圈 ##

### （1）题目描述 ###

> 如果把一个正整数的每一位都平方后再求和，得到一个新的正整数。对新产生的正整数再做同样的处理。  
> 如此一来，你会发现，不管开始取的是什么数字，最终如果不是落入1，就是落入同一个循环圈。  
> 请写出这个循环圈中最大的那个数字。
> 
> **输出格式：**
> 
> 输出答案即可

### （2）解题代码 ###

/*
    	 * 定义一个方法输出循环圈中最大值
    	 */
    	public static int m(int num) {
    		int max = 0;// 记录最大值
    		while (true) {
    			int temp = 0;// 平方和
    			while (num != 0) {
    				temp += Math.pow((num % 10), 2);
    				num = num / 10;
    			}
    			if (max == temp) {
    				break;
    			} else {
    				// 最大值
    				max = (max > temp) ? max : temp;
    				num = temp;// 再循环
    			}
    		}
    		return max;
    	}
    
    	public static void func10() {
    		Random r = new Random();
    		int a = r.nextInt(100);// 产生一个100以内的随机数
    		System.out.println(m(a));// 输出最大值
    	}

### （3）运行结果 ###

![c157560e0c0a400284bf028a39d7d1bb.png][]

--------------------

## 第11题——冰雹数 ##

### （1）题目描述 ###

> 任意给定一个正整数N，如果是偶数，执行： N / 2；如果是奇数，执行： N \* 3 + 1  
> 生成的新的数字再执行同样的动作，循环往复。  
> 通过观察发现，这个数字会一会儿上升到很高，一会儿又降落下来。  
> 就这样起起落落的，但最终必会落到“1”  
> 这有点像小冰雹粒子在冰雹云中翻滚增长的样子。  
> 比如N=9：9,28,14,7,22,11,34,17,52,26,13,40,20,10,5,16,8,4,2,1  
> 可以看到，N=9的时候，这个“小冰雹”最高冲到了52这个高度。
> 
> **输入格式：**  
> 输入存在多组测试数据，对于每组测试数据输入一行包含一个正整数N(N<1000000)
> 
> **输出格式：**  
> 对于每组测试数据，输出一行包含一个正整数表示答案
> 
> **输入样例：**  
> 10  
> 100
> 
> **输出样例：**  
> 52  
> 9232

### （2）解题代码 ###

public static void func11(int n) {
    		int max = 0;
    		int b;
    		for (int i = 1; i <= n; i++) { // 一个正整数表示不大于N的数 //所有小于N的数都要循环
    			b = i;
    			while (b != 1) {
    				if (b % 2 == 0) {
    					b /= 2;
    				} else {
    					b = b * 3 + 1;
    				}
    				if (b >= max) {
    					max = b;
    				}
    			}
    		}
    		System.out.println(max);
    	}

### （3）运行结果 ###

![19b19c3ea7a94a87ae3584c0ee4bc823.png][]

--------------------

## 第12题——搭积木 ##

### （1）题目描述 ###

> 小明最近喜欢搭数字积木，一共有10块积木，每个积木上有一个数字，0~9。  
> 搭积木规则：每个积木放到其它两个积木的上面，并且一定比下面的两个积木数字小。  
> 最后搭成4层的金字塔形，必须用完所有的积木  
> 下面是两种合格的搭法：
> 
> > 0  
> > 1 2  
> > 3 4 5  
> > 6 7 8 9
> 
> > 0  
> > 3 1  
> > 7 5 2  
> > 9 8 6 4
> 
> 请你计算这样的搭法一共有多少种？
> 
> **输出格式：**
> 
> 一个整数表示答案

### （2）解题代码 ###

public static int count = 0;
    
    	public static void dfs(int[] arr, int num, int k) {
    		if (num == k) {
    			if (panDuan(arr)) {
    				count++;
    			}
    		}
    		for (int i = num; i < arr.length; i++) {
    			swap(arr, num, i);
    			dfs(arr, num + 1, k);
    			swap(arr, num, i);
    
    		}
    	}
    
    	public static void swap(int[] arr, int num, int i) {
    		int temp = arr[num];
    		arr[num] = arr[i];
    		arr[i] = temp;
    	}
    
    	public static boolean panDuan(int[] arr) {
    		if (arr[0] < arr[1] && arr[0] < arr[2]) {
    			if (arr[1] < arr[3] && arr[1] < arr[4]) {
    				if (arr[2] < arr[4] && arr[2] < arr[5]) {
    					if (arr[3] < arr[6] && arr[3] < arr[7]) {
    						if (arr[4] < arr[7] && arr[4] < arr[8]) {
    							if (arr[5] < arr[8] && arr[5] < arr[9]) {
    								return true;
    							}
    						}
    					}
    				}
    			}
    		}
    		return false;
    	}
    
    	public static void func12() {
    		int arr[] = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    		dfs(arr, 0, 10);
    		System.out.println(count);
    	}

### （3）运行结果 ###

![bdeebde8d0204a5b8891de2ae1de82c3.png][]

--------------------

## 第13题——取球博弈 ##

### （1）题目描述 ###

> 两个人玩取球的游戏。一共有N个球，每人轮流取球，每次可取集合\{n1,n2,n3\}中的任何一个数目。  
> 如果无法继续取球，则游戏结束。此时，持有奇数个球的一方获胜。如果两人都是奇数，则为平局。  
> 假设双方都采用最聪明的取法，第一个取球的人一定能赢吗？试编程解决这个问题。
> 
> **输入格式：**  
> 输入存在多组测试样例，对于每一组测试数据：  
> 第一行3个正整数n1 n2 n3，空格分开，表示每次可取的数目 (0<n1,n2,n3<100)  
> 第二行5个正整数x1 x2 ... x5，空格分开，表示5局的初始球数(0<xi<1000)
> 
> **输出格式：**  
> 一行5个字符，空格分开。分别表示每局先取球的人能否获胜。  
> 能获胜则输出+，次之，如有办法逼平对手，输出0，无论如何都会输，则输出-
> 
> **输入样例：**  
> 1 2 3  
> 1 2 3 4 5  
> 1 4 5  
> 10 11 12 13 15  
> 2 3 5  
> 7 8 9 10 11
> 
> **输出样例：**  
> \+ 0 + 0 -  
> 0 - 0 + +  
> \+ 0 0 0 0

### （2）解题代码 ###

public static int[] n;
    
    	public static char[][][] cache = new char[1000][2][2];
    
    	/**
    	 * 
    	 * @param num 球的总数
    	 * @param me  我方持有的数目-->我方数目的奇偶性
    	 * @param you 对手持有的数目-对方数目的奇偶性
    	 * @return
    	 */
    	public static char f(int num, int me, int you) {
    		if (num < n[0]) {
    			if ((me & 1) == 1 && (you & 1) == 0) {
    				return '+';
    			} else if ((me & 1) == 0 && (you & 1) == 1) {
    				return '-';
    			} else {
    				return '0';
    			}
    
    		}
    		if (cache[num][me][you] != '\0')
    			return cache[num][me][you];
    		boolean flag = false;
    		for (int i = 0; i < 3; i++) {
    			if (num >= n[i]) {
    				char res = f(num - n[i], you, (n[i] & 1) == 0 ? me : (1 - me));// 注意此处，传递me和you的奇偶性
    				if (res == '-') {
    					cache[num][me][you] = '+';
    					return '+';
    				}
    				if (res == '0') {
    					flag = true;
    				}
    
    			}
    		}
    		// 如果能走到第这行，说明不存在对手输的情况，那么是否存在平的情况
    		if (flag) {
    			cache[num][me][you] = '0';
    			return '0';
    		} else {
    			cache[num][me][you] = '-';
    			return '-';
    		}
    	}
    
    	public static void func13() {
    		Scanner in = new Scanner(System.in);
    		n = new int[3];
    		for (int i = 0; i < 3; i++) {
    			n[i] = in.nextInt();
    		}
    		Arrays.sort(n);// 排序
    		for (int i = 0; i < 5; i++) {
    			int num = in.nextInt();
    			char res = f(num, 0, 0);
    			System.out.print(res + " ");
    		}
    		System.out.println();
    		in.close();
    	}

### （3）运行结果 ###

![d6391973459e4ed7aad7ec20a05d7ca0.png][]

![a8bc33b4d47b4a7bad9cebfa767e0f3b.png][]

![080be3eaf928435092497b1eb6e6fe71.png][]

--------------------

## 第14题——压缩变换 ##

### （1）题目描述 ###

> 小明最近在研究压缩算法。他知道，压缩的时候如果能够使得数值很小，就能通过熵编码得到较高的压缩比。然而，要使数值很小是一个挑战。  
> 最近，小明需要压缩一些正整数的序列，这些序列的特点是，后面出现的数字很大可能是刚出现过不久的数字。对于这种特殊的序列，小明准备对序列做一个变换来减小数字的值。  
> 变换的过程如下：  
> 从左到右枚举序列，每枚举到一个数字，如果这个数字没有出现过，刚将数字变换成它的相反数，如果数字出现过，则看它在原序列中最后的一次出现后面（且在当前数前面）出现了几种数字，用这个种类数替换原来的数字。  
> 比如，序列(a1, a2, a3, a4, a5)=(1, 2, 2, 1, 2)在变换过程为：  
> a1: 1未出现过，所以a1变为-1；  
> a2: 2未出现过，所以a2变为-2；  
> a3: 2出现过，最后一次为原序列的a2，在a2后、a3前有0种数字，所以a3变为0；  
> a4: 1出现过，最后一次为原序列的a1，在a1后、a4前有1种数字，所以a4变为1；  
> a5: 2出现过，最后一次为原序列的a3，在a3后、a5前有1种数字，所以a5变为1。  
> 现在，给出原序列，请问，按这种变换规则变换后的序列是什么。
> 
>   
> **输入格式：**  
> 输入第一行包含一个整数n，表示序列的长度。第二行包含n个正整数，表示输入序列a。  
> 1 <=n<=100000，1<=ai<=10^9
> 
>   
> **输出格式：**  
> 对于每组测试数据，输出一行，包含n个数，表示变换后的序列。
> 
>   
> **输入样例：**  
> 5  
> 1 2 2 1 2
> 
>   
> **输出样例：**  
> \-1 -2 0 1 1

### （2）解题代码 ###

public static void func14() {
    		Scanner in = new Scanner(System.in);
    		int n;
    		n = in.nextInt();
    		int[] a = new int[n + 1];// 输入用的
    		int[] b = new int[1000 * 100 + 1];// 判断用的，不占多少内存，暴力杯嘛
    		int[] c = new int[n + 1];// 存结果用的
    		for (int i = 1; i < n + 1; i++) {
    			a[i] = in.nextInt();
    		}
    		for (int i = 1; i < n + 1; i++) {
    			if (b[a[i]] == 0) {// 如果没出现过，则变为负
    				c[i] = -a[i];// 存值
    			} else {
    				int k = i - b[a[i]] - 1;
    				if (k == 0) {
    					c[i] = 0;
    				} else if (k == 1)
    					c[i] = 1;
    				else {
    					int[] s = new int[k];// 创建数组s
    					for (int l = 0; l < k; l++) {
    						s[l] = a[b[a[i]] + 1 + l];// 抠出中间段
    					}
    					Arrays.sort(s);// sort一下啊
    					int counts = 1;// 计数君，因为循环从1开始，判断这个与前一个，所以起始为1
    					for (int l = 1; l < k; l++) {// 统计不同的个数
    						if (s[l] == s[l - 1]) {
    							continue;
    						} else
    							counts++;
    					}
    					c[i] = counts;
    				}
    			}
    			b[a[i]] = i;// 记录最后下标位置
    		}
    		System.out.print(c[1]);// 第一个不带空格
    		for (int i = 2; i < n + 1; i++) {// 后面的带空格
    			System.out.print(" " + c[i]);
    		}
    		in.close();
    	}

### （3）运行结果 ###

![d030935bffcd4ba4b30b0e05ff3e7d21.png][]

--------------------

## 第15题——有奖猜谜 ##

### （1）题目描述 ###

> 小明很喜欢猜谜语。最近，他被邀请参加了X星球的猜谜活动。  
> 每位选手开始的时候都被发给777个电子币。  
> 规则是：猜对了，手里的电子币数目翻倍，猜错了，扣除555个电子币, 扣完为止。  
> 小明一共猜了15条谜语。战果为：vxvxvxvxvxvxvvx  
> 其中v表示猜对了，x表示猜错了。请你计算一下，小明最后手里的电子币数目是多少。
> 
>   
> **输出格式：**
> 
> 请填写表示最后电子币数目的数字。

### （2）解题代码 ###

public static void func15() {
    		String s = "vxvxvxvxvxvxvvx";
    		char[] ch = s.toCharArray();
    		int a = 777;
    		for (int i = 0; i < ch.length; i++) {
    			if (ch[i] == 'v') {
    				a *= 2;
    			} else {
    				a -= 555;
    			}
    
    		}
    		System.out.println(a);
    	}

### （3）运行结果 ###

## ![70f49af7e00b451783e598406c45bf41.png][] ##

[d76eba71aea24bb9a6cbd2b88264b472.png]: https://img-blog.csdnimg.cn/d76eba71aea24bb9a6cbd2b88264b472.png
[6708530b461749fb974c4a3ea2f98466.png]: https://img-blog.csdnimg.cn/6708530b461749fb974c4a3ea2f98466.png
[12b45f186a3047c4a2e12ac349febb01.png]: https://img-blog.csdnimg.cn/12b45f186a3047c4a2e12ac349febb01.png
[2eef4c567b9348679f7aa4d65e8c3c2b.png]: https://img-blog.csdnimg.cn/2eef4c567b9348679f7aa4d65e8c3c2b.png
[b4a8b566341d4e72ac60252fb29265ca.png]: https://img-blog.csdnimg.cn/b4a8b566341d4e72ac60252fb29265ca.png
[e6894c8279274d71b8461f026fa97c84.png]: https://img-blog.csdnimg.cn/e6894c8279274d71b8461f026fa97c84.png
[4d4c5635e62445558a3a785a79a4fde0.png]: https://img-blog.csdnimg.cn/4d4c5635e62445558a3a785a79a4fde0.png
[c7ac6900e9af4c8bbbdc563f6b8fc061.png]: https://img-blog.csdnimg.cn/c7ac6900e9af4c8bbbdc563f6b8fc061.png
[782535413a534c46986ee3b8664bc0f8.png]: https://img-blog.csdnimg.cn/782535413a534c46986ee3b8664bc0f8.png
[f4e130fe7acd4c3786e25c9eb55db41d.png]: https://img-blog.csdnimg.cn/f4e130fe7acd4c3786e25c9eb55db41d.png
[168f02d7ff0e4e50adb04efd9a7e54ce.png]: https://img-blog.csdnimg.cn/168f02d7ff0e4e50adb04efd9a7e54ce.png
[bf24a682ff1e4ef7a309b678071ade2c.png]: https://img-blog.csdnimg.cn/bf24a682ff1e4ef7a309b678071ade2c.png
[6a6aecb78173477f995b727a09b448c1.png]: https://img-blog.csdnimg.cn/6a6aecb78173477f995b727a09b448c1.png
[17119c2e76cd49edad8d9ea63413926f.png]: https://img-blog.csdnimg.cn/17119c2e76cd49edad8d9ea63413926f.png
[5b081933e1af411a92f0033dc94a6da2.png]: https://img-blog.csdnimg.cn/5b081933e1af411a92f0033dc94a6da2.png
[f061924191984b8da114d3ce75dbe76c.png]: https://img-blog.csdnimg.cn/f061924191984b8da114d3ce75dbe76c.png
[c157560e0c0a400284bf028a39d7d1bb.png]: https://img-blog.csdnimg.cn/c157560e0c0a400284bf028a39d7d1bb.png
[19b19c3ea7a94a87ae3584c0ee4bc823.png]: https://img-blog.csdnimg.cn/19b19c3ea7a94a87ae3584c0ee4bc823.png
[bdeebde8d0204a5b8891de2ae1de82c3.png]: https://img-blog.csdnimg.cn/bdeebde8d0204a5b8891de2ae1de82c3.png
[d6391973459e4ed7aad7ec20a05d7ca0.png]: https://img-blog.csdnimg.cn/d6391973459e4ed7aad7ec20a05d7ca0.png
[a8bc33b4d47b4a7bad9cebfa767e0f3b.png]: https://img-blog.csdnimg.cn/a8bc33b4d47b4a7bad9cebfa767e0f3b.png
[080be3eaf928435092497b1eb6e6fe71.png]: https://img-blog.csdnimg.cn/080be3eaf928435092497b1eb6e6fe71.png
[d030935bffcd4ba4b30b0e05ff3e7d21.png]: https://img-blog.csdnimg.cn/d030935bffcd4ba4b30b0e05ff3e7d21.png
[70f49af7e00b451783e598406c45bf41.png]: https://img-blog.csdnimg.cn/70f49af7e00b451783e598406c45bf41.png